@saastemly/voidcommerce 0.3.0 → 0.4.0

package/dist/index-mpr7gm6k.js

@@ -0,0 +1,4597 @@
+import {
+  __commonJS,
+  __require
+} from "./index-0v6na3yp.js";
+
+// node_modules/@dotenvx/primitives/dist/index.cjs
+var require_dist = __commonJS((exports, module) => {
+  var D = (e, t) => () => {
+    try {
+      return t || e((t = { exports: {} }).exports, t), t.exports;
+    } catch (n) {
+      throw t = 0, n;
+    }
+  };
+  var $e = D((Q) => {
+    Object.defineProperty(Q, "__esModule", { value: true });
+    Q.wrapCipher = Q.Hash = Q.nextTick = Q.isLE = undefined;
+    Q.isBytes = er;
+    Q.abool = xs;
+    Q.anumber = zn;
+    Q.abytes = qe;
+    Q.ahash = Yc;
+    Q.aexists = Xc;
+    Q.aoutput = Fc;
+    Q.u8 = Wc;
+    Q.u32 = zc;
+    Q.clean = Qc;
+    Q.createView = Es;
+    Q.bytesToHex = Bs;
+    Q.hexToBytes = As;
+    Q.hexToNumber = Ss;
+    Q.bytesToNumberBE = ea;
+    Q.numberToBytesBE = ta;
+    Q.utf8ToBytes = vs;
+    Q.bytesToUtf8 = ra;
+    Q.toBytes = sa;
+    Q.overlapBytes = Rs;
+    Q.complexOverlapBytes = oa;
+    Q.concatBytes = ia;
+    Q.checkOpts = ca;
+    Q.equalBytes = aa;
+    Q.getOutput = fa;
+    Q.setBigUint64 = Jn;
+    Q.u64Lengths = la;
+    Q.isAligned32 = Hs;
+    Q.copyBytes = Is;
+    function er(e) {
+      return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+    }
+    function xs(e) {
+      if (typeof e != "boolean")
+        throw new Error(`boolean expected, not ${e}`);
+    }
+    function zn(e) {
+      if (!Number.isSafeInteger(e) || e < 0)
+        throw new Error("positive integer expected, got " + e);
+    }
+    function qe(e, ...t) {
+      if (!er(e))
+        throw new Error("Uint8Array expected");
+      if (t.length > 0 && !t.includes(e.length))
+        throw new Error("Uint8Array expected of length " + t + ", got length=" + e.length);
+    }
+    function Yc(e) {
+      if (typeof e != "function" || typeof e.create != "function")
+        throw new Error("Hash should be wrapped by utils.createHasher");
+      zn(e.outputLen), zn(e.blockLen);
+    }
+    function Xc(e, t = true) {
+      if (e.destroyed)
+        throw new Error("Hash instance has been destroyed");
+      if (t && e.finished)
+        throw new Error("Hash#digest() has already been called");
+    }
+    function Fc(e, t) {
+      qe(e);
+      let n = t.outputLen;
+      if (e.length < n)
+        throw new Error("digestInto() expects output buffer of length at least " + n);
+    }
+    function Wc(e) {
+      return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+    }
+    function zc(e) {
+      return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+    }
+    function Qc(...e) {
+      for (let t = 0;t < e.length; t++)
+        e[t].fill(0);
+    }
+    function Es(e) {
+      return new DataView(e.buffer, e.byteOffset, e.byteLength);
+    }
+    Q.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+    var ws = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Jc = Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+    function Bs(e) {
+      if (qe(e), ws)
+        return e.toHex();
+      let t = "";
+      for (let n = 0;n < e.length; n++)
+        t += Jc[e[n]];
+      return t;
+    }
+    var ze = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+    function _s(e) {
+      if (e >= ze._0 && e <= ze._9)
+        return e - ze._0;
+      if (e >= ze.A && e <= ze.F)
+        return e - (ze.A - 10);
+      if (e >= ze.a && e <= ze.f)
+        return e - (ze.a - 10);
+    }
+    function As(e) {
+      if (typeof e != "string")
+        throw new Error("hex string expected, got " + typeof e);
+      if (ws)
+        return Uint8Array.fromHex(e);
+      let t = e.length, n = t / 2;
+      if (t % 2)
+        throw new Error("hex string expected, got unpadded hex of length " + t);
+      let r = new Uint8Array(n);
+      for (let s = 0, o = 0;s < n; s++, o += 2) {
+        let i = _s(e.charCodeAt(o)), c = _s(e.charCodeAt(o + 1));
+        if (i === undefined || c === undefined) {
+          let a = e[o] + e[o + 1];
+          throw new Error('hex string expected, got non-hex character "' + a + '" at index ' + o);
+        }
+        r[s] = i * 16 + c;
+      }
+      return r;
+    }
+    function Ss(e) {
+      if (typeof e != "string")
+        throw new Error("hex string expected, got " + typeof e);
+      return BigInt(e === "" ? "0" : "0x" + e);
+    }
+    function ea(e) {
+      return Ss(Bs(e));
+    }
+    function ta(e, t) {
+      return As(e.toString(16).padStart(t * 2, "0"));
+    }
+    var na = async () => {};
+    Q.nextTick = na;
+    function vs(e) {
+      if (typeof e != "string")
+        throw new Error("string expected");
+      return new Uint8Array(new TextEncoder().encode(e));
+    }
+    function ra(e) {
+      return new TextDecoder().decode(e);
+    }
+    function sa(e) {
+      if (typeof e == "string")
+        e = vs(e);
+      else if (er(e))
+        e = Is(e);
+      else
+        throw new Error("Uint8Array expected, got " + typeof e);
+      return e;
+    }
+    function Rs(e, t) {
+      return e.buffer === t.buffer && e.byteOffset < t.byteOffset + t.byteLength && t.byteOffset < e.byteOffset + e.byteLength;
+    }
+    function oa(e, t) {
+      if (Rs(e, t) && e.byteOffset < t.byteOffset)
+        throw new Error("complex overlap of input and output is not supported");
+    }
+    function ia(...e) {
+      let t = 0;
+      for (let r = 0;r < e.length; r++) {
+        let s = e[r];
+        qe(s), t += s.length;
+      }
+      let n = new Uint8Array(t);
+      for (let r = 0, s = 0;r < e.length; r++) {
+        let o = e[r];
+        n.set(o, s), s += o.length;
+      }
+      return n;
+    }
+    function ca(e, t) {
+      if (t == null || typeof t != "object")
+        throw new Error("options must be defined");
+      return Object.assign(e, t);
+    }
+    function aa(e, t) {
+      if (e.length !== t.length)
+        return false;
+      let n = 0;
+      for (let r = 0;r < e.length; r++)
+        n |= e[r] ^ t[r];
+      return n === 0;
+    }
+    var Qn = class {
+    };
+    Q.Hash = Qn;
+    var ua = (e, t) => {
+      function n(r, ...s) {
+        if (qe(r), !Q.isLE)
+          throw new Error("Non little-endian hardware is not yet supported");
+        if (e.nonceLength !== undefined) {
+          let u = s[0];
+          if (!u)
+            throw new Error("nonce / iv required");
+          e.varSizeNonce ? qe(u) : qe(u, e.nonceLength);
+        }
+        let o = e.tagLength;
+        o && s[1] !== undefined && qe(s[1]);
+        let i = t(r, ...s), c = (u, y) => {
+          if (y !== undefined) {
+            if (u !== 2)
+              throw new Error("cipher output not supported");
+            qe(y);
+          }
+        }, a = false;
+        return { encrypt(u, y) {
+          if (a)
+            throw new Error("cannot encrypt() twice with same key + nonce");
+          return a = true, qe(u), c(i.encrypt.length, y), i.encrypt(u, y);
+        }, decrypt(u, y) {
+          if (qe(u), o && u.length < o)
+            throw new Error("invalid ciphertext length: smaller than tagLength=" + o);
+          return c(i.decrypt.length, y), i.decrypt(u, y);
+        } };
+      }
+      return Object.assign(n, e), n;
+    };
+    Q.wrapCipher = ua;
+    function fa(e, t, n = true) {
+      if (t === undefined)
+        return new Uint8Array(e);
+      if (t.length !== e)
+        throw new Error("invalid output length, expected " + e + ", got: " + t.length);
+      if (n && !Hs(t))
+        throw new Error("invalid output, must be aligned");
+      return t;
+    }
+    function Jn(e, t, n, r) {
+      if (typeof e.setBigUint64 == "function")
+        return e.setBigUint64(t, n, r);
+      let s = BigInt(32), o = BigInt(4294967295), i = Number(n >> s & o), c = Number(n & o), a = r ? 4 : 0, l = r ? 0 : 4;
+      e.setUint32(t + a, i, r), e.setUint32(t + l, c, r);
+    }
+    function la(e, t, n) {
+      xs(n);
+      let r = new Uint8Array(16), s = Es(r);
+      return Jn(s, 0, BigInt(t), n), Jn(s, 8, BigInt(e), n), r;
+    }
+    function Hs(e) {
+      return e.byteOffset % 4 === 0;
+    }
+    function Is(e) {
+      return Uint8Array.from(e);
+    }
+  });
+  var ln = D((xe) => {
+    Object.defineProperty(xe, "__esModule", { value: true });
+    xe.AEAD_TAG_LENGTH = xe.XCHACHA20_NONCE_LENGTH = xe.CURVE25519_PUBLIC_KEY_SIZE = xe.ETH_PUBLIC_KEY_SIZE = xe.UNCOMPRESSED_PUBLIC_KEY_SIZE = xe.COMPRESSED_PUBLIC_KEY_SIZE = xe.SECRET_KEY_LENGTH = undefined;
+    xe.SECRET_KEY_LENGTH = 32;
+    xe.COMPRESSED_PUBLIC_KEY_SIZE = 33;
+    xe.UNCOMPRESSED_PUBLIC_KEY_SIZE = 65;
+    xe.ETH_PUBLIC_KEY_SIZE = 64;
+    xe.CURVE25519_PUBLIC_KEY_SIZE = 32;
+    xe.XCHACHA20_NONCE_LENGTH = 24;
+    xe.AEAD_TAG_LENGTH = 16;
+  });
+  var Gt = D((St) => {
+    Object.defineProperty(St, "__esModule", { value: true });
+    St.ECIES_CONFIG = St.Config = undefined;
+    var dn = ln(), hn = class {
+      constructor() {
+        this.ellipticCurve = "secp256k1", this.isEphemeralKeyCompressed = false, this.isHkdfKeyCompressed = false, this.symmetricAlgorithm = "aes-256-gcm", this.symmetricNonceLength = 16;
+      }
+      get ephemeralKeySize() {
+        let t = { secp256k1: this.isEphemeralKeyCompressed ? dn.COMPRESSED_PUBLIC_KEY_SIZE : dn.UNCOMPRESSED_PUBLIC_KEY_SIZE, x25519: dn.CURVE25519_PUBLIC_KEY_SIZE, ed25519: dn.CURVE25519_PUBLIC_KEY_SIZE };
+        if (this.ellipticCurve in t)
+          return t[this.ellipticCurve];
+        throw new Error("Not implemented");
+      }
+    };
+    St.Config = hn;
+    St.ECIES_CONFIG = new hn;
+  });
+  var Ts = D((pn) => {
+    Object.defineProperty(pn, "__esModule", { value: true });
+    pn.crypto = undefined;
+    var st = __require("node:crypto");
+    pn.crypto = st && typeof st == "object" && "webcrypto" in st ? st.webcrypto : st && typeof st == "object" && ("randomBytes" in st) ? st : undefined;
+  });
+  var rr = D((Be) => {
+    Object.defineProperty(Be, "__esModule", { value: true });
+    Be.gcm = Be.ctr = Be.cbc = Be.utils = undefined;
+    Be.randomBytes = Os;
+    Be.getWebcryptoSubtle = tr;
+    Be.managedNonce = da;
+    var ke = Ts(), vt = $e();
+    function Os(e = 32) {
+      if (ke.crypto && typeof ke.crypto.getRandomValues == "function")
+        return ke.crypto.getRandomValues(new Uint8Array(e));
+      if (ke.crypto && typeof ke.crypto.randomBytes == "function")
+        return Uint8Array.from(ke.crypto.randomBytes(e));
+      throw new Error("crypto.getRandomValues must be defined");
+    }
+    function tr() {
+      if (ke.crypto && typeof ke.crypto.subtle == "object" && ke.crypto.subtle != null)
+        return ke.crypto.subtle;
+      throw new Error("crypto.subtle must be defined");
+    }
+    function da(e) {
+      let { nonceLength: t } = e;
+      return (0, vt.anumber)(t), (n, ...r) => ({ encrypt(s, ...o) {
+        let i = Os(t), c = e(n, i, ...r).encrypt(s, ...o), a = (0, vt.concatBytes)(i, c);
+        return c.fill(0), a;
+      }, decrypt(s, ...o) {
+        let i = s.subarray(0, t), c = s.subarray(t);
+        return e(n, i, ...r).decrypt(c, ...o);
+      } });
+    }
+    Be.utils = { async encrypt(e, t, n, r) {
+      let s = tr(), o = await s.importKey("raw", e, t, true, ["encrypt"]), i = await s.encrypt(n, o, r);
+      return new Uint8Array(i);
+    }, async decrypt(e, t, n, r) {
+      let s = tr(), o = await s.importKey("raw", e, t, true, ["decrypt"]), i = await s.decrypt(n, o, r);
+      return new Uint8Array(i);
+    } };
+    var Me = { CBC: "AES-CBC", CTR: "AES-CTR", GCM: "AES-GCM" };
+    function ha(e, t, n) {
+      if (e === Me.CBC)
+        return { name: Me.CBC, iv: t };
+      if (e === Me.CTR)
+        return { name: Me.CTR, counter: t, length: 64 };
+      if (e === Me.GCM)
+        return n ? { name: Me.GCM, iv: t, additionalData: n } : { name: Me.GCM, iv: t };
+      throw new Error("unknown aes block mode");
+    }
+    function nr(e) {
+      return (t, n, r) => {
+        (0, vt.abytes)(t), (0, vt.abytes)(n);
+        let s = { name: e, length: t.length * 8 }, o = ha(e, n, r), i = false;
+        return { encrypt(c) {
+          if ((0, vt.abytes)(c), i)
+            throw new Error("Cannot encrypt() twice with same key / nonce");
+          return i = true, Be.utils.encrypt(t, s, o, c);
+        }, decrypt(c) {
+          return (0, vt.abytes)(c), Be.utils.decrypt(t, s, o, c);
+        } };
+      };
+    }
+    Be.cbc = nr(Me.CBC);
+    Be.ctr = nr(Me.CTR);
+    Be.gcm = nr(Me.GCM);
+  });
+  var Cs = D((yn) => {
+    Object.defineProperty(yn, "__esModule", { value: true });
+    yn.crypto = undefined;
+    var ot = __require("node:crypto");
+    yn.crypto = ot && typeof ot == "object" && "webcrypto" in ot ? ot.webcrypto : ot && typeof ot == "object" && ("randomBytes" in ot) ? ot : undefined;
+  });
+  var De = D((G) => {
+    Object.defineProperty(G, "__esModule", { value: true });
+    G.wrapXOFConstructorWithOpts = G.wrapConstructorWithOpts = G.wrapConstructor = G.Hash = G.nextTick = G.swap32IfBE = G.byteSwapIfBE = G.swap8IfBE = G.isLE = undefined;
+    G.isBytes = qs;
+    G.anumber = sr;
+    G.abytes = Ht;
+    G.ahash = pa;
+    G.aexists = ya;
+    G.aoutput = ba;
+    G.u8 = ga;
+    G.u32 = ma;
+    G.clean = _a;
+    G.createView = xa;
+    G.rotr = Ea;
+    G.rotl = wa;
+    G.byteSwap = ir;
+    G.byteSwap32 = Ns;
+    G.bytesToHex = Aa;
+    G.hexToBytes = Sa;
+    G.asyncLoop = Ra;
+    G.utf8ToBytes = cr;
+    G.bytesToUtf8 = Ha;
+    G.toBytes = bn;
+    G.kdfInputToBytes = Ia;
+    G.concatBytes = Ta;
+    G.checkOpts = Oa;
+    G.createHasher = Us;
+    G.createOptHasher = Ks;
+    G.createXOFer = $s;
+    G.randomBytes = Ca;
+    var Rt = Cs();
+    function qs(e) {
+      return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+    }
+    function sr(e) {
+      if (!Number.isSafeInteger(e) || e < 0)
+        throw new Error("positive integer expected, got " + e);
+    }
+    function Ht(e, ...t) {
+      if (!qs(e))
+        throw new Error("Uint8Array expected");
+      if (t.length > 0 && !t.includes(e.length))
+        throw new Error("Uint8Array expected of length " + t + ", got length=" + e.length);
+    }
+    function pa(e) {
+      if (typeof e != "function" || typeof e.create != "function")
+        throw new Error("Hash should be wrapped by utils.createHasher");
+      sr(e.outputLen), sr(e.blockLen);
+    }
+    function ya(e, t = true) {
+      if (e.destroyed)
+        throw new Error("Hash instance has been destroyed");
+      if (t && e.finished)
+        throw new Error("Hash#digest() has already been called");
+    }
+    function ba(e, t) {
+      Ht(e);
+      let n = t.outputLen;
+      if (e.length < n)
+        throw new Error("digestInto() expects output buffer of length at least " + n);
+    }
+    function ga(e) {
+      return new Uint8Array(e.buffer, e.byteOffset, e.byteLength);
+    }
+    function ma(e) {
+      return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+    }
+    function _a(...e) {
+      for (let t = 0;t < e.length; t++)
+        e[t].fill(0);
+    }
+    function xa(e) {
+      return new DataView(e.buffer, e.byteOffset, e.byteLength);
+    }
+    function Ea(e, t) {
+      return e << 32 - t | e >>> t;
+    }
+    function wa(e, t) {
+      return e << t | e >>> 32 - t >>> 0;
+    }
+    G.isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+    function ir(e) {
+      return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
+    }
+    G.swap8IfBE = G.isLE ? (e) => e : (e) => ir(e);
+    G.byteSwapIfBE = G.swap8IfBE;
+    function Ns(e) {
+      for (let t = 0;t < e.length; t++)
+        e[t] = ir(e[t]);
+      return e;
+    }
+    G.swap32IfBE = G.isLE ? (e) => e : Ns;
+    var Ps = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", Ba = Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+    function Aa(e) {
+      if (Ht(e), Ps)
+        return e.toHex();
+      let t = "";
+      for (let n = 0;n < e.length; n++)
+        t += Ba[e[n]];
+      return t;
+    }
+    var Qe = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+    function Ls(e) {
+      if (e >= Qe._0 && e <= Qe._9)
+        return e - Qe._0;
+      if (e >= Qe.A && e <= Qe.F)
+        return e - (Qe.A - 10);
+      if (e >= Qe.a && e <= Qe.f)
+        return e - (Qe.a - 10);
+    }
+    function Sa(e) {
+      if (typeof e != "string")
+        throw new Error("hex string expected, got " + typeof e);
+      if (Ps)
+        return Uint8Array.fromHex(e);
+      let t = e.length, n = t / 2;
+      if (t % 2)
+        throw new Error("hex string expected, got unpadded hex of length " + t);
+      let r = new Uint8Array(n);
+      for (let s = 0, o = 0;s < n; s++, o += 2) {
+        let i = Ls(e.charCodeAt(o)), c = Ls(e.charCodeAt(o + 1));
+        if (i === undefined || c === undefined) {
+          let a = e[o] + e[o + 1];
+          throw new Error('hex string expected, got non-hex character "' + a + '" at index ' + o);
+        }
+        r[s] = i * 16 + c;
+      }
+      return r;
+    }
+    var va = async () => {};
+    G.nextTick = va;
+    async function Ra(e, t, n) {
+      let r = Date.now();
+      for (let s = 0;s < e; s++) {
+        n(s);
+        let o = Date.now() - r;
+        o >= 0 && o < t || (await (0, G.nextTick)(), r += o);
+      }
+    }
+    function cr(e) {
+      if (typeof e != "string")
+        throw new Error("string expected");
+      return new Uint8Array(new TextEncoder().encode(e));
+    }
+    function Ha(e) {
+      return new TextDecoder().decode(e);
+    }
+    function bn(e) {
+      return typeof e == "string" && (e = cr(e)), Ht(e), e;
+    }
+    function Ia(e) {
+      return typeof e == "string" && (e = cr(e)), Ht(e), e;
+    }
+    function Ta(...e) {
+      let t = 0;
+      for (let r = 0;r < e.length; r++) {
+        let s = e[r];
+        Ht(s), t += s.length;
+      }
+      let n = new Uint8Array(t);
+      for (let r = 0, s = 0;r < e.length; r++) {
+        let o = e[r];
+        n.set(o, s), s += o.length;
+      }
+      return n;
+    }
+    function Oa(e, t) {
+      if (t !== undefined && {}.toString.call(t) !== "[object Object]")
+        throw new Error("options should be object or undefined");
+      return Object.assign(e, t);
+    }
+    var or = class {
+    };
+    G.Hash = or;
+    function Us(e) {
+      let t = (r) => e().update(bn(r)).digest(), n = e();
+      return t.outputLen = n.outputLen, t.blockLen = n.blockLen, t.create = () => e(), t;
+    }
+    function Ks(e) {
+      let t = (r, s) => e(s).update(bn(r)).digest(), n = e({});
+      return t.outputLen = n.outputLen, t.blockLen = n.blockLen, t.create = (r) => e(r), t;
+    }
+    function $s(e) {
+      let t = (r, s) => e(s).update(bn(r)).digest(), n = e({});
+      return t.outputLen = n.outputLen, t.blockLen = n.blockLen, t.create = (r) => e(r), t;
+    }
+    G.wrapConstructor = Us;
+    G.wrapConstructorWithOpts = Ks;
+    G.wrapXOFConstructorWithOpts = $s;
+    function Ca(e = 32) {
+      if (Rt.crypto && typeof Rt.crypto.getRandomValues == "function")
+        return Rt.crypto.getRandomValues(new Uint8Array(e));
+      if (Rt.crypto && typeof Rt.crypto.randomBytes == "function")
+        return Uint8Array.from(Rt.crypto.randomBytes(e));
+      throw new Error("crypto.getRandomValues must be defined");
+    }
+  });
+  var ks = D((Ae) => {
+    Object.defineProperty(Ae, "__esModule", { value: true });
+    Ae.SHA512_IV = Ae.SHA384_IV = Ae.SHA224_IV = Ae.SHA256_IV = Ae.HashMD = undefined;
+    Ae.setBigUint64 = Ms;
+    Ae.Chi = La;
+    Ae.Maj = qa;
+    var Ve = De();
+    function Ms(e, t, n, r) {
+      if (typeof e.setBigUint64 == "function")
+        return e.setBigUint64(t, n, r);
+      let s = BigInt(32), o = BigInt(4294967295), i = Number(n >> s & o), c = Number(n & o), a = r ? 4 : 0, l = r ? 0 : 4;
+      e.setUint32(t + a, i, r), e.setUint32(t + l, c, r);
+    }
+    function La(e, t, n) {
+      return e & t ^ ~e & n;
+    }
+    function qa(e, t, n) {
+      return e & t ^ e & n ^ t & n;
+    }
+    var ar = class extends Ve.Hash {
+      constructor(t, n, r, s) {
+        super(), this.finished = false, this.length = 0, this.pos = 0, this.destroyed = false, this.blockLen = t, this.outputLen = n, this.padOffset = r, this.isLE = s, this.buffer = new Uint8Array(t), this.view = (0, Ve.createView)(this.buffer);
+      }
+      update(t) {
+        (0, Ve.aexists)(this), t = (0, Ve.toBytes)(t), (0, Ve.abytes)(t);
+        let { view: n, buffer: r, blockLen: s } = this, o = t.length;
+        for (let i = 0;i < o; ) {
+          let c = Math.min(s - this.pos, o - i);
+          if (c === s) {
+            let a = (0, Ve.createView)(t);
+            for (;s <= o - i; i += s)
+              this.process(a, i);
+            continue;
+          }
+          r.set(t.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === s && (this.process(n, 0), this.pos = 0);
+        }
+        return this.length += t.length, this.roundClean(), this;
+      }
+      digestInto(t) {
+        (0, Ve.aexists)(this), (0, Ve.aoutput)(t, this), this.finished = true;
+        let { buffer: n, view: r, blockLen: s, isLE: o } = this, { pos: i } = this;
+        n[i++] = 128, (0, Ve.clean)(this.buffer.subarray(i)), this.padOffset > s - i && (this.process(r, 0), i = 0);
+        for (let y = i;y < s; y++)
+          n[y] = 0;
+        Ms(r, s - 8, BigInt(this.length * 8), o), this.process(r, 0);
+        let c = (0, Ve.createView)(t), a = this.outputLen;
+        if (a % 4)
+          throw new Error("_sha2: outputLen should be aligned to 32bit");
+        let l = a / 4, u = this.get();
+        if (l > u.length)
+          throw new Error("_sha2: outputLen bigger than state");
+        for (let y = 0;y < l; y++)
+          c.setUint32(4 * y, u[y], o);
+      }
+      digest() {
+        let { buffer: t, outputLen: n } = this;
+        this.digestInto(t);
+        let r = t.slice(0, n);
+        return this.destroy(), r;
+      }
+      _cloneInto(t) {
+        t || (t = new this.constructor), t.set(...this.get());
+        let { blockLen: n, buffer: r, length: s, finished: o, destroyed: i, pos: c } = this;
+        return t.destroyed = i, t.finished = o, t.length = s, t.pos = c, s % n && t.buffer.set(r), t;
+      }
+      clone() {
+        return this._cloneInto();
+      }
+    };
+    Ae.HashMD = ar;
+    Ae.SHA256_IV = Uint32Array.from([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+    Ae.SHA224_IV = Uint32Array.from([3238371032, 914150663, 812702999, 4144912697, 4290775857, 1750603025, 1694076839, 3204075428]);
+    Ae.SHA384_IV = Uint32Array.from([3418070365, 3238371032, 1654270250, 914150663, 2438529370, 812702999, 355462360, 4144912697, 1731405415, 4290775857, 2394180231, 1750603025, 3675008525, 1694076839, 1203062813, 3204075428]);
+    Ae.SHA512_IV = Uint32Array.from([1779033703, 4089235720, 3144134277, 2227873595, 1013904242, 4271175723, 2773480762, 1595750129, 1359893119, 2917565137, 2600822924, 725511199, 528734635, 4215389547, 1541459225, 327033209]);
+  });
+  var uo = D((z) => {
+    Object.defineProperty(z, "__esModule", { value: true });
+    z.toBig = z.shrSL = z.shrSH = z.rotrSL = z.rotrSH = z.rotrBL = z.rotrBH = z.rotr32L = z.rotr32H = z.rotlSL = z.rotlSH = z.rotlBL = z.rotlBH = z.add5L = z.add5H = z.add4L = z.add4H = z.add3L = z.add3H = undefined;
+    z.add = no;
+    z.fromBig = fr;
+    z.split = Ds;
+    var gn = BigInt(2 ** 32 - 1), ur = BigInt(32);
+    function fr(e, t = false) {
+      return t ? { h: Number(e & gn), l: Number(e >> ur & gn) } : { h: Number(e >> ur & gn) | 0, l: Number(e & gn) | 0 };
+    }
+    function Ds(e, t = false) {
+      let n = e.length, r = new Uint32Array(n), s = new Uint32Array(n);
+      for (let o = 0;o < n; o++) {
+        let { h: i, l: c } = fr(e[o], t);
+        [r[o], s[o]] = [i, c];
+      }
+      return [r, s];
+    }
+    var Vs = (e, t) => BigInt(e >>> 0) << ur | BigInt(t >>> 0);
+    z.toBig = Vs;
+    var js = (e, t, n) => e >>> n;
+    z.shrSH = js;
+    var Gs = (e, t, n) => e << 32 - n | t >>> n;
+    z.shrSL = Gs;
+    var Zs = (e, t, n) => e >>> n | t << 32 - n;
+    z.rotrSH = Zs;
+    var Ys = (e, t, n) => e << 32 - n | t >>> n;
+    z.rotrSL = Ys;
+    var Xs = (e, t, n) => e << 64 - n | t >>> n - 32;
+    z.rotrBH = Xs;
+    var Fs = (e, t, n) => e >>> n - 32 | t << 64 - n;
+    z.rotrBL = Fs;
+    var Ws = (e, t) => t;
+    z.rotr32H = Ws;
+    var zs = (e, t) => e;
+    z.rotr32L = zs;
+    var Qs = (e, t, n) => e << n | t >>> 32 - n;
+    z.rotlSH = Qs;
+    var Js = (e, t, n) => t << n | e >>> 32 - n;
+    z.rotlSL = Js;
+    var eo = (e, t, n) => t << n - 32 | e >>> 64 - n;
+    z.rotlBH = eo;
+    var to = (e, t, n) => e << n - 32 | t >>> 64 - n;
+    z.rotlBL = to;
+    function no(e, t, n, r) {
+      let s = (t >>> 0) + (r >>> 0);
+      return { h: e + n + (s / 2 ** 32 | 0) | 0, l: s | 0 };
+    }
+    var ro = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0);
+    z.add3L = ro;
+    var so = (e, t, n, r) => t + n + r + (e / 2 ** 32 | 0) | 0;
+    z.add3H = so;
+    var oo = (e, t, n, r) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (r >>> 0);
+    z.add4L = oo;
+    var io = (e, t, n, r, s) => t + n + r + s + (e / 2 ** 32 | 0) | 0;
+    z.add4H = io;
+    var co = (e, t, n, r, s) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (r >>> 0) + (s >>> 0);
+    z.add5L = co;
+    var ao = (e, t, n, r, s, o) => t + n + r + s + o + (e / 2 ** 32 | 0) | 0;
+    z.add5H = ao;
+    var Na = { fromBig: fr, split: Ds, toBig: Vs, shrSH: js, shrSL: Gs, rotrSH: Zs, rotrSL: Ys, rotrBH: Xs, rotrBL: Fs, rotr32H: Ws, rotr32L: zs, rotlSH: Qs, rotlSL: Js, rotlBH: eo, rotlBL: to, add: no, add3L: ro, add3H: so, add4L: oo, add4H: io, add5H: ao, add5L: co };
+    z.default = Na;
+  });
+  var wn = D((ae) => {
+    Object.defineProperty(ae, "__esModule", { value: true });
+    ae.sha512_224 = ae.sha512_256 = ae.sha384 = ae.sha512 = ae.sha224 = ae.sha256 = ae.SHA512_256 = ae.SHA512_224 = ae.SHA384 = ae.SHA512 = ae.SHA224 = ae.SHA256 = undefined;
+    var j = ks(), J = uo(), pe = De(), Pa = 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]), it = new Uint32Array(64), Zt = class extends j.HashMD {
+      constructor(t = 32) {
+        super(64, t, 8, false), this.A = j.SHA256_IV[0] | 0, this.B = j.SHA256_IV[1] | 0, this.C = j.SHA256_IV[2] | 0, this.D = j.SHA256_IV[3] | 0, this.E = j.SHA256_IV[4] | 0, this.F = j.SHA256_IV[5] | 0, this.G = j.SHA256_IV[6] | 0, this.H = j.SHA256_IV[7] | 0;
+      }
+      get() {
+        let { A: t, B: n, C: r, D: s, E: o, F: i, G: c, H: a } = this;
+        return [t, n, r, s, o, i, c, a];
+      }
+      set(t, n, r, s, o, i, c, a) {
+        this.A = t | 0, this.B = n | 0, this.C = r | 0, this.D = s | 0, this.E = o | 0, this.F = i | 0, this.G = c | 0, this.H = a | 0;
+      }
+      process(t, n) {
+        for (let y = 0;y < 16; y++, n += 4)
+          it[y] = t.getUint32(n, false);
+        for (let y = 16;y < 64; y++) {
+          let h = it[y - 15], p = it[y - 2], b = (0, pe.rotr)(h, 7) ^ (0, pe.rotr)(h, 18) ^ h >>> 3, x = (0, pe.rotr)(p, 17) ^ (0, pe.rotr)(p, 19) ^ p >>> 10;
+          it[y] = x + it[y - 7] + b + it[y - 16] | 0;
+        }
+        let { A: r, B: s, C: o, D: i, E: c, F: a, G: l, H: u } = this;
+        for (let y = 0;y < 64; y++) {
+          let h = (0, pe.rotr)(c, 6) ^ (0, pe.rotr)(c, 11) ^ (0, pe.rotr)(c, 25), p = u + h + (0, j.Chi)(c, a, l) + Pa[y] + it[y] | 0, x = ((0, pe.rotr)(r, 2) ^ (0, pe.rotr)(r, 13) ^ (0, pe.rotr)(r, 22)) + (0, j.Maj)(r, s, o) | 0;
+          u = l, l = a, a = c, c = i + p | 0, i = o, o = s, s = r, r = p + x | 0;
+        }
+        r = r + this.A | 0, s = s + this.B | 0, o = o + this.C | 0, i = i + this.D | 0, c = c + this.E | 0, a = a + this.F | 0, l = l + this.G | 0, u = u + this.H | 0, this.set(r, s, o, i, c, a, l, u);
+      }
+      roundClean() {
+        (0, pe.clean)(it);
+      }
+      destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0), (0, pe.clean)(this.buffer);
+      }
+    };
+    ae.SHA256 = Zt;
+    var mn = class extends Zt {
+      constructor() {
+        super(28), this.A = j.SHA224_IV[0] | 0, this.B = j.SHA224_IV[1] | 0, this.C = j.SHA224_IV[2] | 0, this.D = j.SHA224_IV[3] | 0, this.E = j.SHA224_IV[4] | 0, this.F = j.SHA224_IV[5] | 0, this.G = j.SHA224_IV[6] | 0, this.H = j.SHA224_IV[7] | 0;
+      }
+    };
+    ae.SHA224 = mn;
+    var fo = J.split(["0x428a2f98d728ae22", "0x7137449123ef65cd", "0xb5c0fbcfec4d3b2f", "0xe9b5dba58189dbbc", "0x3956c25bf348b538", "0x59f111f1b605d019", "0x923f82a4af194f9b", "0xab1c5ed5da6d8118", "0xd807aa98a3030242", "0x12835b0145706fbe", "0x243185be4ee4b28c", "0x550c7dc3d5ffb4e2", "0x72be5d74f27b896f", "0x80deb1fe3b1696b1", "0x9bdc06a725c71235", "0xc19bf174cf692694", "0xe49b69c19ef14ad2", "0xefbe4786384f25e3", "0x0fc19dc68b8cd5b5", "0x240ca1cc77ac9c65", "0x2de92c6f592b0275", "0x4a7484aa6ea6e483", "0x5cb0a9dcbd41fbd4", "0x76f988da831153b5", "0x983e5152ee66dfab", "0xa831c66d2db43210", "0xb00327c898fb213f", "0xbf597fc7beef0ee4", "0xc6e00bf33da88fc2", "0xd5a79147930aa725", "0x06ca6351e003826f", "0x142929670a0e6e70", "0x27b70a8546d22ffc", "0x2e1b21385c26c926", "0x4d2c6dfc5ac42aed", "0x53380d139d95b3df", "0x650a73548baf63de", "0x766a0abb3c77b2a8", "0x81c2c92e47edaee6", "0x92722c851482353b", "0xa2bfe8a14cf10364", "0xa81a664bbc423001", "0xc24b8b70d0f89791", "0xc76c51a30654be30", "0xd192e819d6ef5218", "0xd69906245565a910", "0xf40e35855771202a", "0x106aa07032bbd1b8", "0x19a4c116b8d2d0c8", "0x1e376c085141ab53", "0x2748774cdf8eeb99", "0x34b0bcb5e19b48a8", "0x391c0cb3c5c95a63", "0x4ed8aa4ae3418acb", "0x5b9cca4f7763e373", "0x682e6ff3d6b2b8a3", "0x748f82ee5defb2fc", "0x78a5636f43172f60", "0x84c87814a1f0ab72", "0x8cc702081a6439ec", "0x90befffa23631e28", "0xa4506cebde82bde9", "0xbef9a3f7b2c67915", "0xc67178f2e372532b", "0xca273eceea26619c", "0xd186b8c721c0c207", "0xeada7dd6cde0eb1e", "0xf57d4f7fee6ed178", "0x06f067aa72176fba", "0x0a637dc5a2c898a6", "0x113f9804bef90dae", "0x1b710b35131c471b", "0x28db77f523047d84", "0x32caab7b40c72493", "0x3c9ebe0a15c9bebc", "0x431d67c49c100d4c", "0x4cc5d4becb3e42b6", "0x597f299cfc657e2a", "0x5fcb6fab3ad6faec", "0x6c44198c4a475817"].map((e) => BigInt(e))), Ua = fo[0], Ka = fo[1], ct = new Uint32Array(80), at = new Uint32Array(80), ht = class extends j.HashMD {
+      constructor(t = 64) {
+        super(128, t, 16, false), this.Ah = j.SHA512_IV[0] | 0, this.Al = j.SHA512_IV[1] | 0, this.Bh = j.SHA512_IV[2] | 0, this.Bl = j.SHA512_IV[3] | 0, this.Ch = j.SHA512_IV[4] | 0, this.Cl = j.SHA512_IV[5] | 0, this.Dh = j.SHA512_IV[6] | 0, this.Dl = j.SHA512_IV[7] | 0, this.Eh = j.SHA512_IV[8] | 0, this.El = j.SHA512_IV[9] | 0, this.Fh = j.SHA512_IV[10] | 0, this.Fl = j.SHA512_IV[11] | 0, this.Gh = j.SHA512_IV[12] | 0, this.Gl = j.SHA512_IV[13] | 0, this.Hh = j.SHA512_IV[14] | 0, this.Hl = j.SHA512_IV[15] | 0;
+      }
+      get() {
+        let { Ah: t, Al: n, Bh: r, Bl: s, Ch: o, Cl: i, Dh: c, Dl: a, Eh: l, El: u, Fh: y, Fl: h, Gh: p, Gl: b, Hh: x, Hl: B } = this;
+        return [t, n, r, s, o, i, c, a, l, u, y, h, p, b, x, B];
+      }
+      set(t, n, r, s, o, i, c, a, l, u, y, h, p, b, x, B) {
+        this.Ah = t | 0, this.Al = n | 0, this.Bh = r | 0, this.Bl = s | 0, this.Ch = o | 0, this.Cl = i | 0, this.Dh = c | 0, this.Dl = a | 0, this.Eh = l | 0, this.El = u | 0, this.Fh = y | 0, this.Fl = h | 0, this.Gh = p | 0, this.Gl = b | 0, this.Hh = x | 0, this.Hl = B | 0;
+      }
+      process(t, n) {
+        for (let w = 0;w < 16; w++, n += 4)
+          ct[w] = t.getUint32(n), at[w] = t.getUint32(n += 4);
+        for (let w = 16;w < 80; w++) {
+          let S = ct[w - 15] | 0, q = at[w - 15] | 0, k = J.rotrSH(S, q, 1) ^ J.rotrSH(S, q, 8) ^ J.shrSH(S, q, 7), K = J.rotrSL(S, q, 1) ^ J.rotrSL(S, q, 8) ^ J.shrSL(S, q, 7), T = ct[w - 2] | 0, E = at[w - 2] | 0, g = J.rotrSH(T, E, 19) ^ J.rotrBH(T, E, 61) ^ J.shrSH(T, E, 6), $ = J.rotrSL(T, E, 19) ^ J.rotrBL(T, E, 61) ^ J.shrSL(T, E, 6), C = J.add4L(K, $, at[w - 7], at[w - 16]), m = J.add4H(C, k, g, ct[w - 7], ct[w - 16]);
+          ct[w] = m | 0, at[w] = C | 0;
+        }
+        let { Ah: r, Al: s, Bh: o, Bl: i, Ch: c, Cl: a, Dh: l, Dl: u, Eh: y, El: h, Fh: p, Fl: b, Gh: x, Gl: B, Hh: _, Hl: A } = this;
+        for (let w = 0;w < 80; w++) {
+          let S = J.rotrSH(y, h, 14) ^ J.rotrSH(y, h, 18) ^ J.rotrBH(y, h, 41), q = J.rotrSL(y, h, 14) ^ J.rotrSL(y, h, 18) ^ J.rotrBL(y, h, 41), k = y & p ^ ~y & x, K = h & b ^ ~h & B, T = J.add5L(A, q, K, Ka[w], at[w]), E = J.add5H(T, _, S, k, Ua[w], ct[w]), g = T | 0, $ = J.rotrSH(r, s, 28) ^ J.rotrBH(r, s, 34) ^ J.rotrBH(r, s, 39), C = J.rotrSL(r, s, 28) ^ J.rotrBL(r, s, 34) ^ J.rotrBL(r, s, 39), m = r & o ^ r & c ^ o & c, f = s & i ^ s & a ^ i & a;
+          _ = x | 0, A = B | 0, x = p | 0, B = b | 0, p = y | 0, b = h | 0, { h: y, l: h } = J.add(l | 0, u | 0, E | 0, g | 0), l = c | 0, u = a | 0, c = o | 0, a = i | 0, o = r | 0, i = s | 0;
+          let d = J.add3L(g, C, f);
+          r = J.add3H(d, E, $, m), s = d | 0;
+        }
+        ({ h: r, l: s } = J.add(this.Ah | 0, this.Al | 0, r | 0, s | 0)), { h: o, l: i } = J.add(this.Bh | 0, this.Bl | 0, o | 0, i | 0), { h: c, l: a } = J.add(this.Ch | 0, this.Cl | 0, c | 0, a | 0), { h: l, l: u } = J.add(this.Dh | 0, this.Dl | 0, l | 0, u | 0), { h: y, l: h } = J.add(this.Eh | 0, this.El | 0, y | 0, h | 0), { h: p, l: b } = J.add(this.Fh | 0, this.Fl | 0, p | 0, b | 0), { h: x, l: B } = J.add(this.Gh | 0, this.Gl | 0, x | 0, B | 0), { h: _, l: A } = J.add(this.Hh | 0, this.Hl | 0, _ | 0, A | 0), this.set(r, s, o, i, c, a, l, u, y, h, p, b, x, B, _, A);
+      }
+      roundClean() {
+        (0, pe.clean)(ct, at);
+      }
+      destroy() {
+        (0, pe.clean)(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+      }
+    };
+    ae.SHA512 = ht;
+    var _n = class extends ht {
+      constructor() {
+        super(48), this.Ah = j.SHA384_IV[0] | 0, this.Al = j.SHA384_IV[1] | 0, this.Bh = j.SHA384_IV[2] | 0, this.Bl = j.SHA384_IV[3] | 0, this.Ch = j.SHA384_IV[4] | 0, this.Cl = j.SHA384_IV[5] | 0, this.Dh = j.SHA384_IV[6] | 0, this.Dl = j.SHA384_IV[7] | 0, this.Eh = j.SHA384_IV[8] | 0, this.El = j.SHA384_IV[9] | 0, this.Fh = j.SHA384_IV[10] | 0, this.Fl = j.SHA384_IV[11] | 0, this.Gh = j.SHA384_IV[12] | 0, this.Gl = j.SHA384_IV[13] | 0, this.Hh = j.SHA384_IV[14] | 0, this.Hl = j.SHA384_IV[15] | 0;
+      }
+    };
+    ae.SHA384 = _n;
+    var Ee = Uint32Array.from([2352822216, 424955298, 1944164710, 2312950998, 502970286, 855612546, 1738396948, 1479516111, 258812777, 2077511080, 2011393907, 79989058, 1067287976, 1780299464, 286451373, 2446758561]), we = Uint32Array.from([573645204, 4230739756, 2673172387, 3360449730, 596883563, 1867755857, 2520282905, 1497426621, 2519219938, 2827943907, 3193839141, 1401305490, 721525244, 746961066, 246885852, 2177182882]), xn = class extends ht {
+      constructor() {
+        super(28), this.Ah = Ee[0] | 0, this.Al = Ee[1] | 0, this.Bh = Ee[2] | 0, this.Bl = Ee[3] | 0, this.Ch = Ee[4] | 0, this.Cl = Ee[5] | 0, this.Dh = Ee[6] | 0, this.Dl = Ee[7] | 0, this.Eh = Ee[8] | 0, this.El = Ee[9] | 0, this.Fh = Ee[10] | 0, this.Fl = Ee[11] | 0, this.Gh = Ee[12] | 0, this.Gl = Ee[13] | 0, this.Hh = Ee[14] | 0, this.Hl = Ee[15] | 0;
+      }
+    };
+    ae.SHA512_224 = xn;
+    var En = class extends ht {
+      constructor() {
+        super(32), this.Ah = we[0] | 0, this.Al = we[1] | 0, this.Bh = we[2] | 0, this.Bl = we[3] | 0, this.Ch = we[4] | 0, this.Cl = we[5] | 0, this.Dh = we[6] | 0, this.Dl = we[7] | 0, this.Eh = we[8] | 0, this.El = we[9] | 0, this.Fh = we[10] | 0, this.Fl = we[11] | 0, this.Gh = we[12] | 0, this.Gl = we[13] | 0, this.Hh = we[14] | 0, this.Hl = we[15] | 0;
+      }
+    };
+    ae.SHA512_256 = En;
+    ae.sha256 = (0, pe.createHasher)(() => new Zt);
+    ae.sha224 = (0, pe.createHasher)(() => new mn);
+    ae.sha512 = (0, pe.createHasher)(() => new ht);
+    ae.sha384 = (0, pe.createHasher)(() => new _n);
+    ae.sha512_256 = (0, pe.createHasher)(() => new En);
+    ae.sha512_224 = (0, pe.createHasher)(() => new xn);
+  });
+  var et = D((Y) => {
+    Object.defineProperty(Y, "__esModule", { value: true });
+    Y.notImplemented = Y.bitMask = Y.utf8ToBytes = Y.randomBytes = Y.isBytes = Y.hexToBytes = Y.concatBytes = Y.bytesToUtf8 = Y.bytesToHex = Y.anumber = Y.abytes = undefined;
+    Y.abool = $a;
+    Y._abool2 = Ma;
+    Y._abytes2 = ka;
+    Y.numberToHexUnpadded = lo;
+    Y.hexToNumber = dr;
+    Y.bytesToNumberBE = Da;
+    Y.bytesToNumberLE = Va;
+    Y.numberToBytesBE = ho;
+    Y.numberToBytesLE = ja;
+    Y.numberToVarBytesBE = Ga;
+    Y.ensureBytes = Za;
+    Y.equalBytes = Ya;
+    Y.copyBytes = Xa;
+    Y.asciiToBytes = Fa;
+    Y.inRange = po;
+    Y.aInRange = Wa;
+    Y.bitLen = za;
+    Y.bitGet = Qa;
+    Y.bitSet = Ja;
+    Y.createHmacDrbg = tu;
+    Y.validateObject = ru;
+    Y.isHash = su;
+    Y._validateObject = ou;
+    Y.memoized = cu;
+    var je = De(), Je = De();
+    Object.defineProperty(Y, "abytes", { enumerable: true, get: function() {
+      return Je.abytes;
+    } });
+    Object.defineProperty(Y, "anumber", { enumerable: true, get: function() {
+      return Je.anumber;
+    } });
+    Object.defineProperty(Y, "bytesToHex", { enumerable: true, get: function() {
+      return Je.bytesToHex;
+    } });
+    Object.defineProperty(Y, "bytesToUtf8", { enumerable: true, get: function() {
+      return Je.bytesToUtf8;
+    } });
+    Object.defineProperty(Y, "concatBytes", { enumerable: true, get: function() {
+      return Je.concatBytes;
+    } });
+    Object.defineProperty(Y, "hexToBytes", { enumerable: true, get: function() {
+      return Je.hexToBytes;
+    } });
+    Object.defineProperty(Y, "isBytes", { enumerable: true, get: function() {
+      return Je.isBytes;
+    } });
+    Object.defineProperty(Y, "randomBytes", { enumerable: true, get: function() {
+      return Je.randomBytes;
+    } });
+    Object.defineProperty(Y, "utf8ToBytes", { enumerable: true, get: function() {
+      return Je.utf8ToBytes;
+    } });
+    var Bn = BigInt(0), Yt = BigInt(1);
+    function $a(e, t) {
+      if (typeof t != "boolean")
+        throw new Error(e + " boolean expected, got " + t);
+    }
+    function Ma(e, t = "") {
+      if (typeof e != "boolean") {
+        let n = t && `"${t}"`;
+        throw new Error(n + "expected boolean, got type=" + typeof e);
+      }
+      return e;
+    }
+    function ka(e, t, n = "") {
+      let r = (0, je.isBytes)(e), s = e == null ? undefined : e.length, o = t !== undefined;
+      if (!r || o && s !== t) {
+        let i = n && `"${n}" `, c = o ? ` of length ${t}` : "", a = r ? `length=${s}` : `type=${typeof e}`;
+        throw new Error(i + "expected Uint8Array" + c + ", got " + a);
+      }
+      return e;
+    }
+    function lo(e) {
+      let t = e.toString(16);
+      return t.length & 1 ? "0" + t : t;
+    }
+    function dr(e) {
+      if (typeof e != "string")
+        throw new Error("hex string expected, got " + typeof e);
+      return e === "" ? Bn : BigInt("0x" + e);
+    }
+    function Da(e) {
+      return dr((0, je.bytesToHex)(e));
+    }
+    function Va(e) {
+      return (0, je.abytes)(e), dr((0, je.bytesToHex)(Uint8Array.from(e).reverse()));
+    }
+    function ho(e, t) {
+      return (0, je.hexToBytes)(e.toString(16).padStart(t * 2, "0"));
+    }
+    function ja(e, t) {
+      return ho(e, t).reverse();
+    }
+    function Ga(e) {
+      return (0, je.hexToBytes)(lo(e));
+    }
+    function Za(e, t, n) {
+      let r;
+      if (typeof t == "string")
+        try {
+          r = (0, je.hexToBytes)(t);
+        } catch (o) {
+          throw new Error(e + " must be hex string or Uint8Array, cause: " + o);
+        }
+      else if ((0, je.isBytes)(t))
+        r = Uint8Array.from(t);
+      else
+        throw new Error(e + " must be hex string or Uint8Array");
+      let s = r.length;
+      if (typeof n == "number" && s !== n)
+        throw new Error(e + " of length " + n + " expected, got " + s);
+      return r;
+    }
+    function Ya(e, t) {
+      if (e.length !== t.length)
+        return false;
+      let n = 0;
+      for (let r = 0;r < e.length; r++)
+        n |= e[r] ^ t[r];
+      return n === 0;
+    }
+    function Xa(e) {
+      return Uint8Array.from(e);
+    }
+    function Fa(e) {
+      return Uint8Array.from(e, (t, n) => {
+        let r = t.charCodeAt(0);
+        if (t.length !== 1 || r > 127)
+          throw new Error(`string contains non-ASCII character "${e[n]}" with code ${r} at position ${n}`);
+        return r;
+      });
+    }
+    var lr = (e) => typeof e == "bigint" && Bn <= e;
+    function po(e, t, n) {
+      return lr(e) && lr(t) && lr(n) && t <= e && e < n;
+    }
+    function Wa(e, t, n, r) {
+      if (!po(t, n, r))
+        throw new Error("expected valid " + e + ": " + n + " <= n < " + r + ", got " + t);
+    }
+    function za(e) {
+      let t;
+      for (t = 0;e > Bn; e >>= Yt, t += 1)
+        ;
+      return t;
+    }
+    function Qa(e, t) {
+      return e >> BigInt(t) & Yt;
+    }
+    function Ja(e, t, n) {
+      return e | (n ? Yt : Bn) << BigInt(t);
+    }
+    var eu = (e) => (Yt << BigInt(e)) - Yt;
+    Y.bitMask = eu;
+    function tu(e, t, n) {
+      if (typeof e != "number" || e < 2)
+        throw new Error("hashLen must be a number");
+      if (typeof t != "number" || t < 2)
+        throw new Error("qByteLen must be a number");
+      if (typeof n != "function")
+        throw new Error("hmacFn must be a function");
+      let r = (p) => new Uint8Array(p), s = (p) => Uint8Array.of(p), o = r(e), i = r(e), c = 0, a = () => {
+        o.fill(1), i.fill(0), c = 0;
+      }, l = (...p) => n(i, o, ...p), u = (p = r(0)) => {
+        i = l(s(0), p), o = l(), p.length !== 0 && (i = l(s(1), p), o = l());
+      }, y = () => {
+        if (c++ >= 1000)
+          throw new Error("drbg: tried 1000 values");
+        let p = 0, b = [];
+        for (;p < t; ) {
+          o = l();
+          let x = o.slice();
+          b.push(x), p += o.length;
+        }
+        return (0, je.concatBytes)(...b);
+      };
+      return (p, b) => {
+        a(), u(p);
+        let x;
+        for (;!(x = b(y())); )
+          u();
+        return a(), x;
+      };
+    }
+    var nu = { bigint: (e) => typeof e == "bigint", function: (e) => typeof e == "function", boolean: (e) => typeof e == "boolean", string: (e) => typeof e == "string", stringOrUint8Array: (e) => typeof e == "string" || (0, je.isBytes)(e), isSafeInteger: (e) => Number.isSafeInteger(e), array: (e) => Array.isArray(e), field: (e, t) => t.Fp.isValid(e), hash: (e) => typeof e == "function" && Number.isSafeInteger(e.outputLen) };
+    function ru(e, t, n = {}) {
+      let r = (s, o, i) => {
+        let c = nu[o];
+        if (typeof c != "function")
+          throw new Error("invalid validator function");
+        let a = e[s];
+        if (!(i && a === undefined) && !c(a, e))
+          throw new Error("param " + String(s) + " is invalid. Expected " + o + ", got " + a);
+      };
+      for (let [s, o] of Object.entries(t))
+        r(s, o, false);
+      for (let [s, o] of Object.entries(n))
+        r(s, o, true);
+      return e;
+    }
+    function su(e) {
+      return typeof e == "function" && Number.isSafeInteger(e.outputLen);
+    }
+    function ou(e, t, n = {}) {
+      if (!e || typeof e != "object")
+        throw new Error("expected valid options object");
+      function r(s, o, i) {
+        let c = e[s];
+        if (i && c === undefined)
+          return;
+        let a = typeof c;
+        if (a !== o || c === null)
+          throw new Error(`param "${s}" is invalid: expected ${o}, got ${a}`);
+      }
+      Object.entries(t).forEach(([s, o]) => r(s, o, false)), Object.entries(n).forEach(([s, o]) => r(s, o, true));
+    }
+    var iu = () => {
+      throw new Error("not implemented");
+    };
+    Y.notImplemented = iu;
+    function cu(e) {
+      let t = new WeakMap;
+      return (n, ...r) => {
+        let s = t.get(n);
+        if (s !== undefined)
+          return s;
+        let o = e(n, ...r);
+        return t.set(n, o), o;
+      };
+    }
+  });
+  var ut = D((de) => {
+    Object.defineProperty(de, "__esModule", { value: true });
+    de.isNegativeLE = undefined;
+    de.mod = He;
+    de.pow = fu;
+    de.pow2 = lu;
+    de.invert = An;
+    de.tonelliShanks = pr;
+    de.FpSqrt = Eo;
+    de.validateField = bu;
+    de.FpPow = yr;
+    de.FpInvertBatch = wo;
+    de.FpDiv = gu;
+    de.FpLegendre = Sn;
+    de.FpIsSquare = mu;
+    de.nLength = br;
+    de.Field = vn;
+    de.FpSqrtOdd = _u;
+    de.FpSqrtEven = xu;
+    de.hashToPrivateScalar = Eu;
+    de.getFieldBytesLength = gr;
+    de.getMinHashLength = Bo;
+    de.mapHashToField = wu;
+    var Ie = et(), Se = BigInt(0), ye = BigInt(1), pt = BigInt(2), yo = BigInt(3), bo = BigInt(4), go = BigInt(5), au = BigInt(7), mo = BigInt(8), uu = BigInt(9), _o = BigInt(16);
+    function He(e, t) {
+      let n = e % t;
+      return n >= Se ? n : t + n;
+    }
+    function fu(e, t, n) {
+      return yr(vn(n), e, t);
+    }
+    function lu(e, t, n) {
+      let r = e;
+      for (;t-- > Se; )
+        r *= r, r %= n;
+      return r;
+    }
+    function An(e, t) {
+      if (e === Se)
+        throw new Error("invert: expected non-zero number");
+      if (t <= Se)
+        throw new Error("invert: expected positive modulus, got " + t);
+      let n = He(e, t), r = t, s = Se, o = ye, i = ye, c = Se;
+      for (;n !== Se; ) {
+        let l = r / n, u = r % n, y = s - i * l, h = o - c * l;
+        r = n, n = u, s = i, o = c, i = y, c = h;
+      }
+      if (r !== ye)
+        throw new Error("invert: does not exist");
+      return He(s, t);
+    }
+    function hr(e, t, n) {
+      if (!e.eql(e.sqr(t), n))
+        throw new Error("Cannot find square root");
+    }
+    function xo(e, t) {
+      let n = (e.ORDER + ye) / bo, r = e.pow(t, n);
+      return hr(e, r, t), r;
+    }
+    function du(e, t) {
+      let n = (e.ORDER - go) / mo, r = e.mul(t, pt), s = e.pow(r, n), o = e.mul(t, s), i = e.mul(e.mul(o, pt), s), c = e.mul(o, e.sub(i, e.ONE));
+      return hr(e, c, t), c;
+    }
+    function hu(e) {
+      let t = vn(e), n = pr(e), r = n(t, t.neg(t.ONE)), s = n(t, r), o = n(t, t.neg(r)), i = (e + au) / _o;
+      return (c, a) => {
+        let l = c.pow(a, i), u = c.mul(l, r), y = c.mul(l, s), h = c.mul(l, o), p = c.eql(c.sqr(u), a), b = c.eql(c.sqr(y), a);
+        l = c.cmov(l, u, p), u = c.cmov(h, y, b);
+        let x = c.eql(c.sqr(u), a), B = c.cmov(l, u, x);
+        return hr(c, B, a), B;
+      };
+    }
+    function pr(e) {
+      if (e < yo)
+        throw new Error("sqrt is not defined for small field");
+      let t = e - ye, n = 0;
+      for (;t % pt === Se; )
+        t /= pt, n++;
+      let r = pt, s = vn(e);
+      for (;Sn(s, r) === 1; )
+        if (r++ > 1000)
+          throw new Error("Cannot find square root: probably non-prime P");
+      if (n === 1)
+        return xo;
+      let o = s.pow(r, t), i = (t + ye) / pt;
+      return function(a, l) {
+        if (a.is0(l))
+          return l;
+        if (Sn(a, l) !== 1)
+          throw new Error("Cannot find square root");
+        let u = n, y = a.mul(a.ONE, o), h = a.pow(l, t), p = a.pow(l, i);
+        for (;!a.eql(h, a.ONE); ) {
+          if (a.is0(h))
+            return a.ZERO;
+          let b = 1, x = a.sqr(h);
+          for (;!a.eql(x, a.ONE); )
+            if (b++, x = a.sqr(x), b === u)
+              throw new Error("Cannot find square root");
+          let B = ye << BigInt(u - b - 1), _ = a.pow(y, B);
+          u = b, y = a.sqr(_), h = a.mul(h, y), p = a.mul(p, _);
+        }
+        return p;
+      };
+    }
+    function Eo(e) {
+      return e % bo === yo ? xo : e % mo === go ? du : e % _o === uu ? hu(e) : pr(e);
+    }
+    var pu = (e, t) => (He(e, t) & ye) === ye;
+    de.isNegativeLE = pu;
+    var yu = ["create", "isValid", "is0", "neg", "inv", "sqrt", "sqr", "eql", "add", "sub", "mul", "pow", "div", "addN", "subN", "mulN", "sqrN"];
+    function bu(e) {
+      let t = { ORDER: "bigint", MASK: "bigint", BYTES: "number", BITS: "number" }, n = yu.reduce((r, s) => (r[s] = "function", r), t);
+      return (0, Ie._validateObject)(e, n), e;
+    }
+    function yr(e, t, n) {
+      if (n < Se)
+        throw new Error("invalid exponent, negatives unsupported");
+      if (n === Se)
+        return e.ONE;
+      if (n === ye)
+        return t;
+      let r = e.ONE, s = t;
+      for (;n > Se; )
+        n & ye && (r = e.mul(r, s)), s = e.sqr(s), n >>= ye;
+      return r;
+    }
+    function wo(e, t, n = false) {
+      let r = new Array(t.length).fill(n ? e.ZERO : undefined), s = t.reduce((i, c, a) => e.is0(c) ? i : (r[a] = i, e.mul(i, c)), e.ONE), o = e.inv(s);
+      return t.reduceRight((i, c, a) => e.is0(c) ? i : (r[a] = e.mul(i, r[a]), e.mul(i, c)), o), r;
+    }
+    function gu(e, t, n) {
+      return e.mul(t, typeof n == "bigint" ? An(n, e.ORDER) : e.inv(n));
+    }
+    function Sn(e, t) {
+      let n = (e.ORDER - ye) / pt, r = e.pow(t, n), s = e.eql(r, e.ONE), o = e.eql(r, e.ZERO), i = e.eql(r, e.neg(e.ONE));
+      if (!s && !o && !i)
+        throw new Error("invalid Legendre symbol result");
+      return s ? 1 : o ? 0 : -1;
+    }
+    function mu(e, t) {
+      return Sn(e, t) === 1;
+    }
+    function br(e, t) {
+      t !== undefined && (0, Ie.anumber)(t);
+      let n = t !== undefined ? t : e.toString(2).length, r = Math.ceil(n / 8);
+      return { nBitLength: n, nByteLength: r };
+    }
+    function vn(e, t, n = false, r = {}) {
+      if (e <= Se)
+        throw new Error("invalid field: expected ORDER > 0, got " + e);
+      let s, o, i = false, c;
+      if (typeof t == "object" && t != null) {
+        if (r.sqrt || n)
+          throw new Error("cannot specify opts in two arguments");
+        let h = t;
+        h.BITS && (s = h.BITS), h.sqrt && (o = h.sqrt), typeof h.isLE == "boolean" && (n = h.isLE), typeof h.modFromBytes == "boolean" && (i = h.modFromBytes), c = h.allowedLengths;
+      } else
+        typeof t == "number" && (s = t), r.sqrt && (o = r.sqrt);
+      let { nBitLength: a, nByteLength: l } = br(e, s);
+      if (l > 2048)
+        throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+      let u, y = Object.freeze({ ORDER: e, isLE: n, BITS: a, BYTES: l, MASK: (0, Ie.bitMask)(a), ZERO: Se, ONE: ye, allowedLengths: c, create: (h) => He(h, e), isValid: (h) => {
+        if (typeof h != "bigint")
+          throw new Error("invalid field element: expected bigint, got " + typeof h);
+        return Se <= h && h < e;
+      }, is0: (h) => h === Se, isValidNot0: (h) => !y.is0(h) && y.isValid(h), isOdd: (h) => (h & ye) === ye, neg: (h) => He(-h, e), eql: (h, p) => h === p, sqr: (h) => He(h * h, e), add: (h, p) => He(h + p, e), sub: (h, p) => He(h - p, e), mul: (h, p) => He(h * p, e), pow: (h, p) => yr(y, h, p), div: (h, p) => He(h * An(p, e), e), sqrN: (h) => h * h, addN: (h, p) => h + p, subN: (h, p) => h - p, mulN: (h, p) => h * p, inv: (h) => An(h, e), sqrt: o || ((h) => (u || (u = Eo(e)), u(y, h))), toBytes: (h) => n ? (0, Ie.numberToBytesLE)(h, l) : (0, Ie.numberToBytesBE)(h, l), fromBytes: (h, p = true) => {
+        if (c) {
+          if (!c.includes(h.length) || h.length > l)
+            throw new Error("Field.fromBytes: expected " + c + " bytes, got " + h.length);
+          let x = new Uint8Array(l);
+          x.set(h, n ? 0 : x.length - h.length), h = x;
+        }
+        if (h.length !== l)
+          throw new Error("Field.fromBytes: expected " + l + " bytes, got " + h.length);
+        let b = n ? (0, Ie.bytesToNumberLE)(h) : (0, Ie.bytesToNumberBE)(h);
+        if (i && (b = He(b, e)), !p && !y.isValid(b))
+          throw new Error("invalid field element: outside of range 0..ORDER");
+        return b;
+      }, invertBatch: (h) => wo(y, h), cmov: (h, p, b) => b ? p : h });
+      return Object.freeze(y);
+    }
+    function _u(e, t) {
+      if (!e.isOdd)
+        throw new Error("Field doesn't have isOdd");
+      let n = e.sqrt(t);
+      return e.isOdd(n) ? n : e.neg(n);
+    }
+    function xu(e, t) {
+      if (!e.isOdd)
+        throw new Error("Field doesn't have isOdd");
+      let n = e.sqrt(t);
+      return e.isOdd(n) ? e.neg(n) : n;
+    }
+    function Eu(e, t, n = false) {
+      e = (0, Ie.ensureBytes)("privateHash", e);
+      let r = e.length, s = br(t).nByteLength + 8;
+      if (s < 24 || r < s || r > 1024)
+        throw new Error("hashToPrivateScalar: expected " + s + "-1024 bytes of input, got " + r);
+      let o = n ? (0, Ie.bytesToNumberLE)(e) : (0, Ie.bytesToNumberBE)(e);
+      return He(o, t - ye) + ye;
+    }
+    function gr(e) {
+      if (typeof e != "bigint")
+        throw new Error("field order must be bigint");
+      let t = e.toString(2).length;
+      return Math.ceil(t / 8);
+    }
+    function Bo(e) {
+      let t = gr(e);
+      return t + Math.ceil(t / 2);
+    }
+    function wu(e, t, n = false) {
+      let r = e.length, s = gr(t), o = Bo(t);
+      if (r < 16 || r < o || r > 1024)
+        throw new Error("expected " + o + "-1024 bytes of input, got " + r);
+      let i = n ? (0, Ie.bytesToNumberLE)(e) : (0, Ie.bytesToNumberBE)(e), c = He(i, t - ye) + ye;
+      return n ? (0, Ie.numberToBytesLE)(c, s) : (0, Ie.numberToBytesBE)(c, s);
+    }
+  });
+  var Rn = D((Ne) => {
+    Object.defineProperty(Ne, "__esModule", { value: true });
+    Ne.wNAF = undefined;
+    Ne.negateCt = Er;
+    Ne.normalizeZ = Bu;
+    Ne.mulEndoUnsafe = Au;
+    Ne.pippenger = Su;
+    Ne.precomputeMSMUnsafe = vu;
+    Ne.validateBasic = Ru;
+    Ne._createCurveFields = Hu;
+    var Xt = et(), Ft = ut(), It = BigInt(0), yt = BigInt(1);
+    function Er(e, t) {
+      let n = t.negate();
+      return e ? n : t;
+    }
+    function Bu(e, t) {
+      let n = (0, Ft.FpInvertBatch)(e.Fp, t.map((r) => r.Z));
+      return t.map((r, s) => e.fromAffine(r.toAffine(n[s])));
+    }
+    function Br(e, t) {
+      if (!Number.isSafeInteger(e) || e <= 0 || e > t)
+        throw new Error("invalid window size, expected [1.." + t + "], got W=" + e);
+    }
+    function mr(e, t) {
+      Br(e, t);
+      let n = Math.ceil(t / e) + 1, r = 2 ** (e - 1), s = 2 ** e, o = (0, Xt.bitMask)(e), i = BigInt(e);
+      return { windows: n, windowSize: r, mask: o, maxNumber: s, shiftBy: i };
+    }
+    function Ao(e, t, n) {
+      let { windowSize: r, mask: s, maxNumber: o, shiftBy: i } = n, c = Number(e & s), a = e >> i;
+      c > r && (c -= o, a += yt);
+      let l = t * r, u = l + Math.abs(c) - 1, y = c === 0, h = c < 0, p = t % 2 !== 0;
+      return { nextN: a, offset: u, isZero: y, isNeg: h, isNegF: p, offsetF: l };
+    }
+    function Ro(e, t) {
+      if (!Array.isArray(e))
+        throw new Error("array expected");
+      e.forEach((n, r) => {
+        if (!(n instanceof t))
+          throw new Error("invalid point at index " + r);
+      });
+    }
+    function Ho(e, t) {
+      if (!Array.isArray(e))
+        throw new Error("array of scalars expected");
+      e.forEach((n, r) => {
+        if (!t.isValid(n))
+          throw new Error("invalid scalar at index " + r);
+      });
+    }
+    var _r = new WeakMap, Io = new WeakMap;
+    function xr(e) {
+      return Io.get(e) || 1;
+    }
+    function So(e) {
+      if (e !== It)
+        throw new Error("invalid wNAF");
+    }
+    var wr = class {
+      constructor(t, n) {
+        this.BASE = t.BASE, this.ZERO = t.ZERO, this.Fn = t.Fn, this.bits = n;
+      }
+      _unsafeLadder(t, n, r = this.ZERO) {
+        let s = t;
+        for (;n > It; )
+          n & yt && (r = r.add(s)), s = s.double(), n >>= yt;
+        return r;
+      }
+      precomputeWindow(t, n) {
+        let { windows: r, windowSize: s } = mr(n, this.bits), o = [], i = t, c = i;
+        for (let a = 0;a < r; a++) {
+          c = i, o.push(c);
+          for (let l = 1;l < s; l++)
+            c = c.add(i), o.push(c);
+          i = c.double();
+        }
+        return o;
+      }
+      wNAF(t, n, r) {
+        if (!this.Fn.isValid(r))
+          throw new Error("invalid scalar");
+        let s = this.ZERO, o = this.BASE, i = mr(t, this.bits);
+        for (let c = 0;c < i.windows; c++) {
+          let { nextN: a, offset: l, isZero: u, isNeg: y, isNegF: h, offsetF: p } = Ao(r, c, i);
+          r = a, u ? o = o.add(Er(h, n[p])) : s = s.add(Er(y, n[l]));
+        }
+        return So(r), { p: s, f: o };
+      }
+      wNAFUnsafe(t, n, r, s = this.ZERO) {
+        let o = mr(t, this.bits);
+        for (let i = 0;i < o.windows && r !== It; i++) {
+          let { nextN: c, offset: a, isZero: l, isNeg: u } = Ao(r, i, o);
+          if (r = c, !l) {
+            let y = n[a];
+            s = s.add(u ? y.negate() : y);
+          }
+        }
+        return So(r), s;
+      }
+      getPrecomputes(t, n, r) {
+        let s = _r.get(n);
+        return s || (s = this.precomputeWindow(n, t), t !== 1 && (typeof r == "function" && (s = r(s)), _r.set(n, s))), s;
+      }
+      cached(t, n, r) {
+        let s = xr(t);
+        return this.wNAF(s, this.getPrecomputes(s, t, r), n);
+      }
+      unsafe(t, n, r, s) {
+        let o = xr(t);
+        return o === 1 ? this._unsafeLadder(t, n, s) : this.wNAFUnsafe(o, this.getPrecomputes(o, t, r), n, s);
+      }
+      createCache(t, n) {
+        Br(n, this.bits), Io.set(t, n), _r.delete(t);
+      }
+      hasCache(t) {
+        return xr(t) !== 1;
+      }
+    };
+    Ne.wNAF = wr;
+    function Au(e, t, n, r) {
+      let s = t, o = e.ZERO, i = e.ZERO;
+      for (;n > It || r > It; )
+        n & yt && (o = o.add(s)), r & yt && (i = i.add(s)), s = s.double(), n >>= yt, r >>= yt;
+      return { p1: o, p2: i };
+    }
+    function Su(e, t, n, r) {
+      Ro(n, e), Ho(r, t);
+      let s = n.length, o = r.length;
+      if (s !== o)
+        throw new Error("arrays of points and scalars must have equal length");
+      let i = e.ZERO, c = (0, Xt.bitLen)(BigInt(s)), a = 1;
+      c > 12 ? a = c - 3 : c > 4 ? a = c - 2 : c > 0 && (a = 2);
+      let l = (0, Xt.bitMask)(a), u = new Array(Number(l) + 1).fill(i), y = Math.floor((t.BITS - 1) / a) * a, h = i;
+      for (let p = y;p >= 0; p -= a) {
+        u.fill(i);
+        for (let x = 0;x < o; x++) {
+          let B = r[x], _ = Number(B >> BigInt(p) & l);
+          u[_] = u[_].add(n[x]);
+        }
+        let b = i;
+        for (let x = u.length - 1, B = i;x > 0; x--)
+          B = B.add(u[x]), b = b.add(B);
+        if (h = h.add(b), p !== 0)
+          for (let x = 0;x < a; x++)
+            h = h.double();
+      }
+      return h;
+    }
+    function vu(e, t, n, r) {
+      Br(r, t.BITS), Ro(n, e);
+      let s = e.ZERO, o = 2 ** r - 1, i = Math.ceil(t.BITS / r), c = (0, Xt.bitMask)(r), a = n.map((l) => {
+        let u = [];
+        for (let y = 0, h = l;y < o; y++)
+          u.push(h), h = h.add(l);
+        return u;
+      });
+      return (l) => {
+        if (Ho(l, t), l.length > n.length)
+          throw new Error("array of scalars must be smaller than array of points");
+        let u = s;
+        for (let y = 0;y < i; y++) {
+          if (u !== s)
+            for (let p = 0;p < r; p++)
+              u = u.double();
+          let h = BigInt(i * r - (y + 1) * r);
+          for (let p = 0;p < l.length; p++) {
+            let b = l[p], x = Number(b >> h & c);
+            x && (u = u.add(a[p][x - 1]));
+          }
+        }
+        return u;
+      };
+    }
+    function Ru(e) {
+      return (0, Ft.validateField)(e.Fp), (0, Xt.validateObject)(e, { n: "bigint", h: "bigint", Gx: "field", Gy: "field" }, { nBitLength: "isSafeInteger", nByteLength: "isSafeInteger" }), Object.freeze({ ...(0, Ft.nLength)(e.n, e.nBitLength), ...e, p: e.Fp.ORDER });
+    }
+    function vo(e, t, n) {
+      if (t) {
+        if (t.ORDER !== e)
+          throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+        return (0, Ft.validateField)(t), t;
+      } else
+        return (0, Ft.Field)(e, { isLE: n });
+    }
+    function Hu(e, t, n = {}, r) {
+      if (r === undefined && (r = e === "edwards"), !t || typeof t != "object")
+        throw new Error(`expected valid ${e} CURVE object`);
+      for (let a of ["p", "n", "h"]) {
+        let l = t[a];
+        if (!(typeof l == "bigint" && l > It))
+          throw new Error(`CURVE.${a} must be positive bigint`);
+      }
+      let s = vo(t.p, n.Fp, r), o = vo(t.n, n.Fn, r), c = ["Gx", "Gy", "a", e === "weierstrass" ? "b" : "d"];
+      for (let a of c)
+        if (!s.isValid(t[a]))
+          throw new Error(`CURVE.${a} must be valid field element of CURVE.Fp`);
+      return t = Object.freeze(Object.assign({}, t)), { CURVE: t, Fp: s, Fn: o };
+    }
+  });
+  var Co = D((gt) => {
+    Object.defineProperty(gt, "__esModule", { value: true });
+    gt.PrimeEdwardsPoint = undefined;
+    gt.edwards = To;
+    gt.eddsa = Oo;
+    gt.twistedEdwards = qu;
+    var te = et(), bt = Rn(), Iu = ut(), ft = BigInt(0), be = BigInt(1), Ar = BigInt(2), Tu = BigInt(8);
+    function Ou(e, t, n, r) {
+      let s = e.sqr(n), o = e.sqr(r), i = e.add(e.mul(t.a, s), o), c = e.add(e.ONE, e.mul(t.d, e.mul(s, o)));
+      return e.eql(i, c);
+    }
+    function To(e, t = {}) {
+      let n = (0, bt._createCurveFields)("edwards", e, t, t.FpFnLE), { Fp: r, Fn: s } = n, o = n.CURVE, { h: i } = o;
+      (0, te._validateObject)(t, {}, { uvRatio: "function" });
+      let c = Ar << BigInt(s.BYTES * 8) - be, a = (B) => r.create(B), l = t.uvRatio || ((B, _) => {
+        try {
+          return { isValid: true, value: r.sqrt(r.div(B, _)) };
+        } catch {
+          return { isValid: false, value: ft };
+        }
+      });
+      if (!Ou(r, o, o.Gx, o.Gy))
+        throw new Error("bad curve params: generator point");
+      function u(B, _, A = false) {
+        let w = A ? be : ft;
+        return (0, te.aInRange)("coordinate " + B, _, w, c), _;
+      }
+      function y(B) {
+        if (!(B instanceof b))
+          throw new Error("ExtendedPoint expected");
+      }
+      let h = (0, te.memoized)((B, _) => {
+        let { X: A, Y: w, Z: S } = B, q = B.is0();
+        _ == null && (_ = q ? Tu : r.inv(S));
+        let k = a(A * _), K = a(w * _), T = r.mul(S, _);
+        if (q)
+          return { x: ft, y: be };
+        if (T !== be)
+          throw new Error("invZ was invalid");
+        return { x: k, y: K };
+      }), p = (0, te.memoized)((B) => {
+        let { a: _, d: A } = o;
+        if (B.is0())
+          throw new Error("bad point: ZERO");
+        let { X: w, Y: S, Z: q, T: k } = B, K = a(w * w), T = a(S * S), E = a(q * q), g = a(E * E), $ = a(K * _), C = a(E * a($ + T)), m = a(g + a(A * a(K * T)));
+        if (C !== m)
+          throw new Error("bad point: equation left != right (1)");
+        let f = a(w * S), d = a(q * k);
+        if (f !== d)
+          throw new Error("bad point: equation left != right (2)");
+        return true;
+      });
+
+      class b {
+        constructor(_, A, w, S) {
+          this.X = u("x", _), this.Y = u("y", A), this.Z = u("z", w, true), this.T = u("t", S), Object.freeze(this);
+        }
+        static CURVE() {
+          return o;
+        }
+        static fromAffine(_) {
+          if (_ instanceof b)
+            throw new Error("extended point not allowed");
+          let { x: A, y: w } = _ || {};
+          return u("x", A), u("y", w), new b(A, w, be, a(A * w));
+        }
+        static fromBytes(_, A = false) {
+          let w = r.BYTES, { a: S, d: q } = o;
+          _ = (0, te.copyBytes)((0, te._abytes2)(_, w, "point")), (0, te._abool2)(A, "zip215");
+          let k = (0, te.copyBytes)(_), K = _[w - 1];
+          k[w - 1] = K & -129;
+          let T = (0, te.bytesToNumberLE)(k), E = A ? c : r.ORDER;
+          (0, te.aInRange)("point.y", T, ft, E);
+          let g = a(T * T), $ = a(g - be), C = a(q * g - S), { isValid: m, value: f } = l($, C);
+          if (!m)
+            throw new Error("bad point: invalid y coordinate");
+          let d = (f & be) === be, R = (K & 128) !== 0;
+          if (!A && f === ft && R)
+            throw new Error("bad point: x=0 and x_0=1");
+          return R !== d && (f = a(-f)), b.fromAffine({ x: f, y: T });
+        }
+        static fromHex(_, A = false) {
+          return b.fromBytes((0, te.ensureBytes)("point", _), A);
+        }
+        get x() {
+          return this.toAffine().x;
+        }
+        get y() {
+          return this.toAffine().y;
+        }
+        precompute(_ = 8, A = true) {
+          return x.createCache(this, _), A || this.multiply(Ar), this;
+        }
+        assertValidity() {
+          p(this);
+        }
+        equals(_) {
+          y(_);
+          let { X: A, Y: w, Z: S } = this, { X: q, Y: k, Z: K } = _, T = a(A * K), E = a(q * S), g = a(w * K), $ = a(k * S);
+          return T === E && g === $;
+        }
+        is0() {
+          return this.equals(b.ZERO);
+        }
+        negate() {
+          return new b(a(-this.X), this.Y, this.Z, a(-this.T));
+        }
+        double() {
+          let { a: _ } = o, { X: A, Y: w, Z: S } = this, q = a(A * A), k = a(w * w), K = a(Ar * a(S * S)), T = a(_ * q), E = A + w, g = a(a(E * E) - q - k), $ = T + k, C = $ - K, m = T - k, f = a(g * C), d = a($ * m), R = a(g * m), v = a(C * $);
+          return new b(f, d, v, R);
+        }
+        add(_) {
+          y(_);
+          let { a: A, d: w } = o, { X: S, Y: q, Z: k, T: K } = this, { X: T, Y: E, Z: g, T: $ } = _, C = a(S * T), m = a(q * E), f = a(K * w * $), d = a(k * g), R = a((S + q) * (T + E) - C - m), v = d - f, O = d + f, N = a(m - A * C), L = a(R * v), M = a(O * N), X = a(R * N), se = a(v * O);
+          return new b(L, M, se, X);
+        }
+        subtract(_) {
+          return this.add(_.negate());
+        }
+        multiply(_) {
+          if (!s.isValidNot0(_))
+            throw new Error("invalid scalar: expected 1 <= sc < curve.n");
+          let { p: A, f: w } = x.cached(this, _, (S) => (0, bt.normalizeZ)(b, S));
+          return (0, bt.normalizeZ)(b, [A, w])[0];
+        }
+        multiplyUnsafe(_, A = b.ZERO) {
+          if (!s.isValid(_))
+            throw new Error("invalid scalar: expected 0 <= sc < curve.n");
+          return _ === ft ? b.ZERO : this.is0() || _ === be ? this : x.unsafe(this, _, (w) => (0, bt.normalizeZ)(b, w), A);
+        }
+        isSmallOrder() {
+          return this.multiplyUnsafe(i).is0();
+        }
+        isTorsionFree() {
+          return x.unsafe(this, o.n).is0();
+        }
+        toAffine(_) {
+          return h(this, _);
+        }
+        clearCofactor() {
+          return i === be ? this : this.multiplyUnsafe(i);
+        }
+        toBytes() {
+          let { x: _, y: A } = this.toAffine(), w = r.toBytes(A);
+          return w[w.length - 1] |= _ & be ? 128 : 0, w;
+        }
+        toHex() {
+          return (0, te.bytesToHex)(this.toBytes());
+        }
+        toString() {
+          return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+        }
+        get ex() {
+          return this.X;
+        }
+        get ey() {
+          return this.Y;
+        }
+        get ez() {
+          return this.Z;
+        }
+        get et() {
+          return this.T;
+        }
+        static normalizeZ(_) {
+          return (0, bt.normalizeZ)(b, _);
+        }
+        static msm(_, A) {
+          return (0, bt.pippenger)(b, s, _, A);
+        }
+        _setWindowSize(_) {
+          this.precompute(_);
+        }
+        toRawBytes() {
+          return this.toBytes();
+        }
+      }
+      b.BASE = new b(o.Gx, o.Gy, be, a(o.Gx * o.Gy)), b.ZERO = new b(ft, be, be, ft), b.Fp = r, b.Fn = s;
+      let x = new bt.wNAF(b, s.BITS);
+      return b.BASE.precompute(8), b;
+    }
+    var Sr = class {
+      constructor(t) {
+        this.ep = t;
+      }
+      static fromBytes(t) {
+        (0, te.notImplemented)();
+      }
+      static fromHex(t) {
+        (0, te.notImplemented)();
+      }
+      get x() {
+        return this.toAffine().x;
+      }
+      get y() {
+        return this.toAffine().y;
+      }
+      clearCofactor() {
+        return this;
+      }
+      assertValidity() {
+        this.ep.assertValidity();
+      }
+      toAffine(t) {
+        return this.ep.toAffine(t);
+      }
+      toHex() {
+        return (0, te.bytesToHex)(this.toBytes());
+      }
+      toString() {
+        return this.toHex();
+      }
+      isTorsionFree() {
+        return true;
+      }
+      isSmallOrder() {
+        return false;
+      }
+      add(t) {
+        return this.assertSame(t), this.init(this.ep.add(t.ep));
+      }
+      subtract(t) {
+        return this.assertSame(t), this.init(this.ep.subtract(t.ep));
+      }
+      multiply(t) {
+        return this.init(this.ep.multiply(t));
+      }
+      multiplyUnsafe(t) {
+        return this.init(this.ep.multiplyUnsafe(t));
+      }
+      double() {
+        return this.init(this.ep.double());
+      }
+      negate() {
+        return this.init(this.ep.negate());
+      }
+      precompute(t, n) {
+        return this.init(this.ep.precompute(t, n));
+      }
+      toRawBytes() {
+        return this.toBytes();
+      }
+    };
+    gt.PrimeEdwardsPoint = Sr;
+    function Oo(e, t, n = {}) {
+      if (typeof t != "function")
+        throw new Error('"hash" function param is required');
+      (0, te._validateObject)(n, {}, { adjustScalarBytes: "function", randomBytes: "function", domain: "function", prehash: "function", mapToCurve: "function" });
+      let { prehash: r } = n, { BASE: s, Fp: o, Fn: i } = e, c = n.randomBytes || te.randomBytes, a = n.adjustScalarBytes || ((E) => E), l = n.domain || ((E, g, $) => {
+        if ((0, te._abool2)($, "phflag"), g.length || $)
+          throw new Error("Contexts/pre-hash are not supported");
+        return E;
+      });
+      function u(E) {
+        return i.create((0, te.bytesToNumberLE)(E));
+      }
+      function y(E) {
+        let g = w.secretKey;
+        E = (0, te.ensureBytes)("private key", E, g);
+        let $ = (0, te.ensureBytes)("hashed private key", t(E), 2 * g), C = a($.slice(0, g)), m = $.slice(g, 2 * g), f = u(C);
+        return { head: C, prefix: m, scalar: f };
+      }
+      function h(E) {
+        let { head: g, prefix: $, scalar: C } = y(E), m = s.multiply(C), f = m.toBytes();
+        return { head: g, prefix: $, scalar: C, point: m, pointBytes: f };
+      }
+      function p(E) {
+        return h(E).pointBytes;
+      }
+      function b(E = Uint8Array.of(), ...g) {
+        let $ = (0, te.concatBytes)(...g);
+        return u(t(l($, (0, te.ensureBytes)("context", E), !!r)));
+      }
+      function x(E, g, $ = {}) {
+        E = (0, te.ensureBytes)("message", E), r && (E = r(E));
+        let { prefix: C, scalar: m, pointBytes: f } = h(g), d = b($.context, C, E), R = s.multiply(d).toBytes(), v = b($.context, R, f, E), O = i.create(d + v * m);
+        if (!i.isValid(O))
+          throw new Error("sign failed: invalid s");
+        let N = (0, te.concatBytes)(R, i.toBytes(O));
+        return (0, te._abytes2)(N, w.signature, "result");
+      }
+      let B = { zip215: true };
+      function _(E, g, $, C = B) {
+        let { context: m, zip215: f } = C, d = w.signature;
+        E = (0, te.ensureBytes)("signature", E, d), g = (0, te.ensureBytes)("message", g), $ = (0, te.ensureBytes)("publicKey", $, w.publicKey), f !== undefined && (0, te._abool2)(f, "zip215"), r && (g = r(g));
+        let R = d / 2, v = E.subarray(0, R), O = (0, te.bytesToNumberLE)(E.subarray(R, d)), N, L, M;
+        try {
+          N = e.fromBytes($, f), L = e.fromBytes(v, f), M = s.multiplyUnsafe(O);
+        } catch {
+          return false;
+        }
+        if (!f && N.isSmallOrder())
+          return false;
+        let X = b(m, L.toBytes(), N.toBytes(), g);
+        return L.add(N.multiplyUnsafe(X)).subtract(M).clearCofactor().is0();
+      }
+      let A = o.BYTES, w = { secretKey: A, publicKey: A, signature: 2 * A, seed: A };
+      function S(E = c(w.seed)) {
+        return (0, te._abytes2)(E, w.seed, "seed");
+      }
+      function q(E) {
+        let g = T.randomSecretKey(E);
+        return { secretKey: g, publicKey: p(g) };
+      }
+      function k(E) {
+        return (0, te.isBytes)(E) && E.length === i.BYTES;
+      }
+      function K(E, g) {
+        try {
+          return !!e.fromBytes(E, g);
+        } catch {
+          return false;
+        }
+      }
+      let T = { getExtendedPublicKey: h, randomSecretKey: S, isValidSecretKey: k, isValidPublicKey: K, toMontgomery(E) {
+        let { y: g } = e.fromBytes(E), $ = w.publicKey, C = $ === 32;
+        if (!C && $ !== 57)
+          throw new Error("only defined for 25519 and 448");
+        let m = C ? o.div(be + g, be - g) : o.div(g - be, g + be);
+        return o.toBytes(m);
+      }, toMontgomerySecret(E) {
+        let g = w.secretKey;
+        (0, te._abytes2)(E, g);
+        let $ = t(E.subarray(0, g));
+        return a($).subarray(0, g);
+      }, randomPrivateKey: S, precompute(E = 8, g = e.BASE) {
+        return g.precompute(E, false);
+      } };
+      return Object.freeze({ keygen: q, getPublicKey: p, sign: x, verify: _, utils: T, Point: e, lengths: w });
+    }
+    function Cu(e) {
+      let t = { a: e.a, d: e.d, p: e.Fp.ORDER, n: e.n, h: e.h, Gx: e.Gx, Gy: e.Gy }, n = e.Fp, r = (0, Iu.Field)(t.n, e.nBitLength, true), s = { Fp: n, Fn: r, uvRatio: e.uvRatio }, o = { randomBytes: e.randomBytes, adjustScalarBytes: e.adjustScalarBytes, domain: e.domain, prehash: e.prehash, mapToCurve: e.mapToCurve };
+      return { CURVE: t, curveOpts: s, hash: e.hash, eddsaOpts: o };
+    }
+    function Lu(e, t) {
+      let n = t.Point;
+      return Object.assign({}, t, { ExtendedPoint: n, CURVE: e, nBitLength: n.Fn.BITS, nByteLength: n.Fn.BYTES });
+    }
+    function qu(e) {
+      let { CURVE: t, curveOpts: n, hash: r, eddsaOpts: s } = Cu(e), o = To(t, n), i = Oo(o, r, s);
+      return Lu(e, i);
+    }
+  });
+  var vr = D((Ge) => {
+    Object.defineProperty(Ge, "__esModule", { value: true });
+    Ge._DST_scalar = undefined;
+    Ge.expand_message_xmd = No;
+    Ge.expand_message_xof = Po;
+    Ge.hash_to_field = Hn;
+    Ge.isogenyMap = Uu;
+    Ge.createHasher = Ku;
+    var ge = et(), Lo = ut(), Nu = ge.bytesToNumberBE;
+    function lt(e, t) {
+      if (Wt(e), Wt(t), e < 0 || e >= 1 << 8 * t)
+        throw new Error("invalid I2OSP input: " + e);
+      let n = Array.from({ length: t }).fill(0);
+      for (let r = t - 1;r >= 0; r--)
+        n[r] = e & 255, e >>>= 8;
+      return new Uint8Array(n);
+    }
+    function Pu(e, t) {
+      let n = new Uint8Array(e.length);
+      for (let r = 0;r < e.length; r++)
+        n[r] = e[r] ^ t[r];
+      return n;
+    }
+    function Wt(e) {
+      if (!Number.isSafeInteger(e))
+        throw new Error("number expected");
+    }
+    function qo(e) {
+      if (!(0, ge.isBytes)(e) && typeof e != "string")
+        throw new Error("DST must be Uint8Array or string");
+      return typeof e == "string" ? (0, ge.utf8ToBytes)(e) : e;
+    }
+    function No(e, t, n, r) {
+      (0, ge.abytes)(e), Wt(n), t = qo(t), t.length > 255 && (t = r((0, ge.concatBytes)((0, ge.utf8ToBytes)("H2C-OVERSIZE-DST-"), t)));
+      let { outputLen: s, blockLen: o } = r, i = Math.ceil(n / s);
+      if (n > 65535 || i > 255)
+        throw new Error("expand_message_xmd: invalid lenInBytes");
+      let c = (0, ge.concatBytes)(t, lt(t.length, 1)), a = lt(0, o), l = lt(n, 2), u = new Array(i), y = r((0, ge.concatBytes)(a, e, l, lt(0, 1), c));
+      u[0] = r((0, ge.concatBytes)(y, lt(1, 1), c));
+      for (let p = 1;p <= i; p++) {
+        let b = [Pu(y, u[p - 1]), lt(p + 1, 1), c];
+        u[p] = r((0, ge.concatBytes)(...b));
+      }
+      return (0, ge.concatBytes)(...u).slice(0, n);
+    }
+    function Po(e, t, n, r, s) {
+      if ((0, ge.abytes)(e), Wt(n), t = qo(t), t.length > 255) {
+        let o = Math.ceil(2 * r / 8);
+        t = s.create({ dkLen: o }).update((0, ge.utf8ToBytes)("H2C-OVERSIZE-DST-")).update(t).digest();
+      }
+      if (n > 65535 || t.length > 255)
+        throw new Error("expand_message_xof: invalid lenInBytes");
+      return s.create({ dkLen: n }).update(e).update(lt(n, 2)).update(t).update(lt(t.length, 1)).digest();
+    }
+    function Hn(e, t, n) {
+      (0, ge._validateObject)(n, { p: "bigint", m: "number", k: "number", hash: "function" });
+      let { p: r, k: s, m: o, hash: i, expand: c, DST: a } = n;
+      if (!(0, ge.isHash)(n.hash))
+        throw new Error("expected valid hash");
+      (0, ge.abytes)(e), Wt(t);
+      let l = r.toString(2).length, u = Math.ceil((l + s) / 8), y = t * o * u, h;
+      if (c === "xmd")
+        h = No(e, a, y, i);
+      else if (c === "xof")
+        h = Po(e, a, y, s, i);
+      else if (c === "_internal_pass")
+        h = e;
+      else
+        throw new Error('expand must be "xmd" or "xof"');
+      let p = new Array(t);
+      for (let b = 0;b < t; b++) {
+        let x = new Array(o);
+        for (let B = 0;B < o; B++) {
+          let _ = u * (B + b * o), A = h.subarray(_, _ + u);
+          x[B] = (0, Lo.mod)(Nu(A), r);
+        }
+        p[b] = x;
+      }
+      return p;
+    }
+    function Uu(e, t) {
+      let n = t.map((r) => Array.from(r).reverse());
+      return (r, s) => {
+        let [o, i, c, a] = n.map((y) => y.reduce((h, p) => e.add(e.mul(h, r), p))), [l, u] = (0, Lo.FpInvertBatch)(e, [i, a], true);
+        return r = e.mul(o, l), s = e.mul(s, e.mul(c, u)), { x: r, y: s };
+      };
+    }
+    Ge._DST_scalar = (0, ge.utf8ToBytes)("HashToScalar-");
+    function Ku(e, t, n) {
+      if (typeof t != "function")
+        throw new Error("mapToCurve() must be defined");
+      function r(o) {
+        return e.fromAffine(t(o));
+      }
+      function s(o) {
+        let i = o.clearCofactor();
+        return i.equals(e.ZERO) ? e.ZERO : (i.assertValidity(), i);
+      }
+      return { defaults: n, hashToCurve(o, i) {
+        let c = Object.assign({}, n, i), a = Hn(o, 2, c), l = r(a[0]), u = r(a[1]);
+        return s(l.add(u));
+      }, encodeToCurve(o, i) {
+        let c = n.encodeDST ? { DST: n.encodeDST } : {}, a = Object.assign({}, n, c, i), l = Hn(o, 1, a), u = r(l[0]);
+        return s(u);
+      }, mapToCurve(o) {
+        if (!Array.isArray(o))
+          throw new Error("expected array of bigints");
+        for (let i of o)
+          if (typeof i != "bigint")
+            throw new Error("expected array of bigints");
+        return s(r(o));
+      }, hashToScalar(o, i) {
+        let c = e.Fn.ORDER, a = Object.assign({}, n, { p: c, m: 1, DST: Ge._DST_scalar }, i);
+        return Hn(o, 1, a)[0][0];
+      } };
+    }
+  });
+  var Uo = D((Rr) => {
+    Object.defineProperty(Rr, "__esModule", { value: true });
+    Rr.montgomery = ku;
+    var Ze = et(), $u = ut(), zt = BigInt(0), Tt = BigInt(1), In = BigInt(2);
+    function Mu(e) {
+      return (0, Ze._validateObject)(e, { adjustScalarBytes: "function", powPminus2: "function" }), Object.freeze({ ...e });
+    }
+    function ku(e) {
+      let t = Mu(e), { P: n, type: r, adjustScalarBytes: s, powPminus2: o, randomBytes: i } = t, c = r === "x25519";
+      if (!c && r !== "x448")
+        throw new Error("invalid type");
+      let a = i || Ze.randomBytes, l = c ? 255 : 448, u = c ? 32 : 56, y = BigInt(c ? 9 : 5), h = BigInt(c ? 121665 : 39081), p = c ? In ** BigInt(254) : In ** BigInt(447), b = c ? BigInt(8) * In ** BigInt(251) - Tt : BigInt(4) * In ** BigInt(445) - Tt, x = p + b + Tt, B = (m) => (0, $u.mod)(m, n), _ = A(y);
+      function A(m) {
+        return (0, Ze.numberToBytesLE)(B(m), u);
+      }
+      function w(m) {
+        let f = (0, Ze.ensureBytes)("u coordinate", m, u);
+        return c && (f[31] &= 127), B((0, Ze.bytesToNumberLE)(f));
+      }
+      function S(m) {
+        return (0, Ze.bytesToNumberLE)(s((0, Ze.ensureBytes)("scalar", m, u)));
+      }
+      function q(m, f) {
+        let d = T(w(f), S(m));
+        if (d === zt)
+          throw new Error("invalid private or public key received");
+        return A(d);
+      }
+      function k(m) {
+        return q(m, _);
+      }
+      function K(m, f, d) {
+        let R = B(m * (f - d));
+        return f = B(f - R), d = B(d + R), { x_2: f, x_3: d };
+      }
+      function T(m, f) {
+        (0, Ze.aInRange)("u", m, zt, n), (0, Ze.aInRange)("scalar", f, p, x);
+        let d = f, R = m, v = Tt, O = zt, N = m, L = Tt, M = zt;
+        for (let se = BigInt(l - 1);se >= zt; se--) {
+          let ee = d >> se & Tt;
+          M ^= ee, { x_2: v, x_3: N } = K(M, v, N), { x_2: O, x_3: L } = K(M, O, L), M = ee;
+          let P = v + O, oe = B(P * P), ue = v - O, I = B(ue * ue), Z = oe - I, H = N + L, W = N - L, ie = B(W * P), fe = B(H * ue), ce = ie + fe, Oe = ie - fe;
+          N = B(ce * ce), L = B(R * B(Oe * Oe)), v = B(oe * I), O = B(Z * (oe + B(h * Z)));
+        }
+        ({ x_2: v, x_3: N } = K(M, v, N)), { x_2: O, x_3: L } = K(M, O, L);
+        let X = o(O);
+        return B(v * X);
+      }
+      let E = { secretKey: u, publicKey: u, seed: u }, g = (m = a(u)) => ((0, Ze.abytes)(m, E.seed), m);
+      function $(m) {
+        let f = g(m);
+        return { secretKey: f, publicKey: k(f) };
+      }
+      return { keygen: $, getSharedSecret: (m, f) => q(m, f), getPublicKey: (m) => k(m), scalarMult: q, scalarMultBase: k, utils: { randomSecretKey: g, randomPrivateKey: g }, GuBytes: _.slice(), lengths: E };
+    }
+  });
+  var Fo = D((F) => {
+    Object.defineProperty(F, "__esModule", { value: true });
+    F.hash_to_ristretto255 = F.hashToRistretto255 = F.encodeToCurve = F.hashToCurve = F.RistrettoPoint = F.edwardsToMontgomery = F.ED25519_TORSION_SUBGROUP = F.ristretto255_hasher = F.ristretto255 = F.ed25519_hasher = F.x25519 = F.ed25519ph = F.ed25519ctx = F.ed25519 = undefined;
+    F.edwardsToMontgomeryPub = Xo;
+    F.edwardsToMontgomeryPriv = tf;
+    var Qt = wn(), On = De(), Du = Rn(), Ln = Co(), Tn = vr(), ne = ut(), Vu = Uo(), mt = et(), ju = BigInt(0), Ye = BigInt(1), Cn = BigInt(2), ko = BigInt(3), Do = BigInt(5), Or = BigInt(8), tt = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed"), Jt = { p: tt, n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"), h: Or, a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"), d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"), Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"), Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658") };
+    function Vo(e) {
+      let t = BigInt(10), n = BigInt(20), r = BigInt(40), s = BigInt(80), o = tt, c = e * e % o * e % o, a = (0, ne.pow2)(c, Cn, o) * c % o, l = (0, ne.pow2)(a, Ye, o) * e % o, u = (0, ne.pow2)(l, Do, o) * l % o, y = (0, ne.pow2)(u, t, o) * u % o, h = (0, ne.pow2)(y, n, o) * y % o, p = (0, ne.pow2)(h, r, o) * h % o, b = (0, ne.pow2)(p, s, o) * p % o, x = (0, ne.pow2)(b, s, o) * p % o, B = (0, ne.pow2)(x, t, o) * u % o;
+      return { pow_p_5_8: (0, ne.pow2)(B, Cn, o) * e % o, b2: c };
+    }
+    function jo(e) {
+      return e[0] &= 248, e[31] &= 127, e[31] |= 64, e;
+    }
+    var Hr = BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
+    function Cr(e, t) {
+      let n = tt, r = (0, ne.mod)(t * t * t, n), s = (0, ne.mod)(r * r * t, n), o = Vo(e * s).pow_p_5_8, i = (0, ne.mod)(e * r * o, n), c = (0, ne.mod)(t * i * i, n), a = i, l = (0, ne.mod)(i * Hr, n), u = c === e, y = c === (0, ne.mod)(-e, n), h = c === (0, ne.mod)(-e * Hr, n);
+      return u && (i = a), (y || h) && (i = l), (0, ne.isNegativeLE)(i, n) && (i = (0, ne.mod)(-i, n)), { isValid: u || y, value: i };
+    }
+    var U = (0, ne.Field)(Jt.p, { isLE: true }), Go = (0, ne.Field)(Jt.n, { isLE: true }), Lr = { ...Jt, Fp: U, hash: Qt.sha512, adjustScalarBytes: jo, uvRatio: Cr };
+    F.ed25519 = (0, Ln.twistedEdwards)(Lr);
+    function Zo(e, t, n) {
+      if (t.length > 255)
+        throw new Error("Context is too big");
+      return (0, On.concatBytes)((0, On.utf8ToBytes)("SigEd25519 no Ed25519 collisions"), new Uint8Array([n ? 1 : 0, t.length]), t, e);
+    }
+    F.ed25519ctx = (0, Ln.twistedEdwards)({ ...Lr, domain: Zo });
+    F.ed25519ph = (0, Ln.twistedEdwards)(Object.assign({}, Lr, { domain: Zo, prehash: Qt.sha512 }));
+    F.x25519 = (() => {
+      let e = U.ORDER;
+      return (0, Vu.montgomery)({ P: e, type: "x25519", powPminus2: (t) => {
+        let { pow_p_5_8: n, b2: r } = Vo(t);
+        return (0, ne.mod)((0, ne.pow2)(n, ko, e) * r, e);
+      }, adjustScalarBytes: jo });
+    })();
+    var Gu = (tt + ko) / Or, Zu = U.pow(Cn, Gu), Ko = U.sqrt(U.neg(U.ONE));
+    function Yu(e) {
+      let t = (tt - Do) / Or, n = BigInt(486662), r = U.sqr(e);
+      r = U.mul(r, Cn);
+      let s = U.add(r, U.ONE), o = U.neg(n), i = U.sqr(s), c = U.mul(i, s), a = U.mul(r, n);
+      a = U.mul(a, o), a = U.add(a, i), a = U.mul(a, o);
+      let l = U.sqr(c);
+      i = U.sqr(l), l = U.mul(l, c), l = U.mul(l, a), i = U.mul(i, l);
+      let u = U.pow(i, t);
+      u = U.mul(u, l);
+      let y = U.mul(u, Ko);
+      i = U.sqr(u), i = U.mul(i, c);
+      let h = U.eql(i, a), p = U.cmov(y, u, h), b = U.mul(o, r), x = U.mul(u, e);
+      x = U.mul(x, Zu);
+      let B = U.mul(x, Ko), _ = U.mul(a, r);
+      i = U.sqr(x), i = U.mul(i, c);
+      let A = U.eql(i, _), w = U.cmov(B, x, A);
+      i = U.sqr(p), i = U.mul(i, c);
+      let S = U.eql(i, a), q = U.cmov(b, o, S), k = U.cmov(w, p, S), K = U.isOdd(k);
+      return k = U.cmov(k, U.neg(k), S !== K), { xMn: q, xMd: s, yMn: k, yMd: Ye };
+    }
+    var Xu = (0, ne.FpSqrtEven)(U, U.neg(BigInt(486664)));
+    function Fu(e) {
+      let { xMn: t, xMd: n, yMn: r, yMd: s } = Yu(e), o = U.mul(t, s);
+      o = U.mul(o, Xu);
+      let i = U.mul(n, r), c = U.sub(t, n), a = U.add(t, n), l = U.mul(i, a), u = U.eql(l, U.ZERO);
+      o = U.cmov(o, U.ZERO, u), i = U.cmov(i, U.ONE, u), c = U.cmov(c, U.ONE, u), a = U.cmov(a, U.ONE, u);
+      let [y, h] = (0, ne.FpInvertBatch)(U, [i, a], true);
+      return { x: U.mul(o, y), y: U.mul(c, h) };
+    }
+    F.ed25519_hasher = (0, Tn.createHasher)(F.ed25519.Point, (e) => Fu(e[0]), { DST: "edwards25519_XMD:SHA-512_ELL2_RO_", encodeDST: "edwards25519_XMD:SHA-512_ELL2_NU_", p: tt, m: 1, k: 128, expand: "xmd", hash: Qt.sha512 });
+    var Ir = Hr, Wu = BigInt("25063068953384623474111414158702152701244531502492656460079210482610430750235"), zu = BigInt("54469307008909316920995813868745141605393597292927456921205312896311721017578"), Qu = BigInt("1159843021668779879193775521855586647937357759715417654439879720876111806838"), Ju = BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952"), $o = (e) => Cr(Ye, e), ef = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), Tr = (e) => F.ed25519.Point.Fp.create((0, mt.bytesToNumberLE)(e) & ef);
+    function Mo(e) {
+      let { d: t } = Jt, n = tt, r = (_) => U.create(_), s = r(Ir * e * e), o = r((s + Ye) * Qu), i = BigInt(-1), c = r((i - t * s) * r(s + t)), { isValid: a, value: l } = Cr(o, c), u = r(l * e);
+      (0, ne.isNegativeLE)(u, n) || (u = r(-u)), a || (l = u), a || (i = s);
+      let y = r(i * (s - Ye) * Ju - c), h = l * l, p = r((l + l) * c), b = r(y * Wu), x = r(Ye - h), B = r(Ye + h);
+      return new F.ed25519.Point(r(p * B), r(x * b), r(b * B), r(p * x));
+    }
+    function Yo(e) {
+      (0, On.abytes)(e, 64);
+      let t = Tr(e.subarray(0, 32)), n = Mo(t), r = Tr(e.subarray(32, 64)), s = Mo(r);
+      return new Pe(n.add(s));
+    }
+    var Pe = class e extends Ln.PrimeEdwardsPoint {
+      constructor(t) {
+        super(t);
+      }
+      static fromAffine(t) {
+        return new e(F.ed25519.Point.fromAffine(t));
+      }
+      assertSame(t) {
+        if (!(t instanceof e))
+          throw new Error("RistrettoPoint expected");
+      }
+      init(t) {
+        return new e(t);
+      }
+      static hashToCurve(t) {
+        return Yo((0, mt.ensureBytes)("ristrettoHash", t, 64));
+      }
+      static fromBytes(t) {
+        (0, On.abytes)(t, 32);
+        let { a: n, d: r } = Jt, s = tt, o = (S) => U.create(S), i = Tr(t);
+        if (!(0, mt.equalBytes)(U.toBytes(i), t) || (0, ne.isNegativeLE)(i, s))
+          throw new Error("invalid ristretto255 encoding 1");
+        let c = o(i * i), a = o(Ye + n * c), l = o(Ye - n * c), u = o(a * a), y = o(l * l), h = o(n * r * u - y), { isValid: p, value: b } = $o(o(h * y)), x = o(b * l), B = o(b * x * h), _ = o((i + i) * x);
+        (0, ne.isNegativeLE)(_, s) && (_ = o(-_));
+        let A = o(a * B), w = o(_ * A);
+        if (!p || (0, ne.isNegativeLE)(w, s) || A === ju)
+          throw new Error("invalid ristretto255 encoding 2");
+        return new e(new F.ed25519.Point(_, A, Ye, w));
+      }
+      static fromHex(t) {
+        return e.fromBytes((0, mt.ensureBytes)("ristrettoHex", t, 32));
+      }
+      static msm(t, n) {
+        return (0, Du.pippenger)(e, F.ed25519.Point.Fn, t, n);
+      }
+      toBytes() {
+        let { X: t, Y: n, Z: r, T: s } = this.ep, o = tt, i = (B) => U.create(B), c = i(i(r + n) * i(r - n)), a = i(t * n), l = i(a * a), { value: u } = $o(i(c * l)), y = i(u * c), h = i(u * a), p = i(y * h * s), b;
+        if ((0, ne.isNegativeLE)(s * p, o)) {
+          let B = i(n * Ir), _ = i(t * Ir);
+          t = B, n = _, b = i(y * zu);
+        } else
+          b = h;
+        (0, ne.isNegativeLE)(t * p, o) && (n = i(-n));
+        let x = i((r - n) * b);
+        return (0, ne.isNegativeLE)(x, o) && (x = i(-x)), U.toBytes(x);
+      }
+      equals(t) {
+        this.assertSame(t);
+        let { X: n, Y: r } = this.ep, { X: s, Y: o } = t.ep, i = (l) => U.create(l), c = i(n * o) === i(r * s), a = i(r * o) === i(n * s);
+        return c || a;
+      }
+      is0() {
+        return this.equals(e.ZERO);
+      }
+    };
+    Pe.BASE = new Pe(F.ed25519.Point.BASE);
+    Pe.ZERO = new Pe(F.ed25519.Point.ZERO);
+    Pe.Fp = U;
+    Pe.Fn = Go;
+    F.ristretto255 = { Point: Pe };
+    F.ristretto255_hasher = { hashToCurve(e, t) {
+      let n = (t == null ? undefined : t.DST) || "ristretto255_XMD:SHA-512_R255MAP_RO_", r = (0, Tn.expand_message_xmd)(e, n, 64, Qt.sha512);
+      return Yo(r);
+    }, hashToScalar(e, t = { DST: Tn._DST_scalar }) {
+      let n = (0, Tn.expand_message_xmd)(e, t.DST, 64, Qt.sha512);
+      return Go.create((0, mt.bytesToNumberLE)(n));
+    } };
+    F.ED25519_TORSION_SUBGROUP = ["0100000000000000000000000000000000000000000000000000000000000000", "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a", "0000000000000000000000000000000000000000000000000000000000000080", "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05", "ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f", "26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85", "0000000000000000000000000000000000000000000000000000000000000000", "c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa"];
+    function Xo(e) {
+      return F.ed25519.utils.toMontgomery((0, mt.ensureBytes)("pub", e));
+    }
+    F.edwardsToMontgomery = Xo;
+    function tf(e) {
+      return F.ed25519.utils.toMontgomerySecret((0, mt.ensureBytes)("pub", e));
+    }
+    F.RistrettoPoint = Pe;
+    F.hashToCurve = F.ed25519_hasher.hashToCurve;
+    F.encodeToCurve = F.ed25519_hasher.encodeToCurve;
+    F.hashToRistretto255 = F.ristretto255_hasher.hashToCurve;
+    F.hash_to_ristretto255 = F.ristretto255_hasher.hashToCurve;
+  });
+  var qr = D((xt) => {
+    Object.defineProperty(xt, "__esModule", { value: true });
+    xt.hmac = xt.HMAC = undefined;
+    var _t = De(), en = class extends _t.Hash {
+      constructor(t, n) {
+        super(), this.finished = false, this.destroyed = false, (0, _t.ahash)(t);
+        let r = (0, _t.toBytes)(n);
+        if (this.iHash = t.create(), typeof this.iHash.update != "function")
+          throw new Error("Expected instance of class which extends utils.Hash");
+        this.blockLen = this.iHash.blockLen, this.outputLen = this.iHash.outputLen;
+        let s = this.blockLen, o = new Uint8Array(s);
+        o.set(r.length > s ? t.create().update(r).digest() : r);
+        for (let i = 0;i < o.length; i++)
+          o[i] ^= 54;
+        this.iHash.update(o), this.oHash = t.create();
+        for (let i = 0;i < o.length; i++)
+          o[i] ^= 106;
+        this.oHash.update(o), (0, _t.clean)(o);
+      }
+      update(t) {
+        return (0, _t.aexists)(this), this.iHash.update(t), this;
+      }
+      digestInto(t) {
+        (0, _t.aexists)(this), (0, _t.abytes)(t, this.outputLen), this.finished = true, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
+      }
+      digest() {
+        let t = new Uint8Array(this.oHash.outputLen);
+        return this.digestInto(t), t;
+      }
+      _cloneInto(t) {
+        t || (t = Object.create(Object.getPrototypeOf(this), {}));
+        let { oHash: n, iHash: r, finished: s, destroyed: o, blockLen: i, outputLen: c } = this;
+        return t = t, t.finished = s, t.destroyed = o, t.blockLen = i, t.outputLen = c, t.oHash = n._cloneInto(t.oHash), t.iHash = r._cloneInto(t.iHash), t;
+      }
+      clone() {
+        return this._cloneInto();
+      }
+      destroy() {
+        this.destroyed = true, this.oHash.destroy(), this.iHash.destroy();
+      }
+    };
+    xt.HMAC = en;
+    var nf = (e, t, n) => new en(e, t).update(n).digest();
+    xt.hmac = nf;
+    xt.hmac.create = (e, t) => new en(e, t);
+  });
+  var $r = D((le) => {
+    Object.defineProperty(le, "__esModule", { value: true });
+    le.DER = le.DERErr = undefined;
+    le._splitEndoScalar = zo;
+    le._normFnElement = dt;
+    le.weierstrassN = Kr;
+    le.SWUFpSqrtRatio = Jo;
+    le.mapToCurveSimpleSWU = of;
+    le.ecdh = ti;
+    le.ecdsa = ni;
+    le.weierstrassPoints = cf;
+    le._legacyHelperEquat = si;
+    le.weierstrass = lf;
+    var rf = qr(), sf = De(), V = et(), nt = Rn(), Ct = ut(), Wo = (e, t) => (e + (e >= 0 ? t : -t) / Xe) / t;
+    function zo(e, t, n) {
+      let [[r, s], [o, i]] = t, c = Wo(i * e, n), a = Wo(-s * e, n), l = e - c * r - a * o, u = -c * s - a * i, y = l < Ue, h = u < Ue;
+      y && (l = -l), h && (u = -u);
+      let p = (0, V.bitMask)(Math.ceil((0, V.bitLen)(n) / 2)) + me;
+      if (l < Ue || l >= p || u < Ue || u >= p)
+        throw new Error("splitScalar (endomorphism): failed, k=" + e);
+      return { k1neg: y, k1: l, k2neg: h, k2: u };
+    }
+    function Pr(e) {
+      if (!["compact", "recovered", "der"].includes(e))
+        throw new Error('Signature format must be "compact", "recovered", or "der"');
+      return e;
+    }
+    function Nr(e, t) {
+      let n = {};
+      for (let r of Object.keys(t))
+        n[r] = e[r] === undefined ? t[r] : e[r];
+      return (0, V._abool2)(n.lowS, "lowS"), (0, V._abool2)(n.prehash, "prehash"), n.format !== undefined && Pr(n.format), n;
+    }
+    var qn = class extends Error {
+      constructor(t = "") {
+        super(t);
+      }
+    };
+    le.DERErr = qn;
+    le.DER = { Err: qn, _tlv: { encode: (e, t) => {
+      let { Err: n } = le.DER;
+      if (e < 0 || e > 256)
+        throw new n("tlv.encode: wrong tag");
+      if (t.length & 1)
+        throw new n("tlv.encode: unpadded data");
+      let r = t.length / 2, s = (0, V.numberToHexUnpadded)(r);
+      if (s.length / 2 & 128)
+        throw new n("tlv.encode: long form length too big");
+      let o = r > 127 ? (0, V.numberToHexUnpadded)(s.length / 2 | 128) : "";
+      return (0, V.numberToHexUnpadded)(e) + o + s + t;
+    }, decode(e, t) {
+      let { Err: n } = le.DER, r = 0;
+      if (e < 0 || e > 256)
+        throw new n("tlv.encode: wrong tag");
+      if (t.length < 2 || t[r++] !== e)
+        throw new n("tlv.decode: wrong tlv");
+      let s = t[r++], o = !!(s & 128), i = 0;
+      if (!o)
+        i = s;
+      else {
+        let a = s & 127;
+        if (!a)
+          throw new n("tlv.decode(long): indefinite length not supported");
+        if (a > 4)
+          throw new n("tlv.decode(long): byte length is too big");
+        let l = t.subarray(r, r + a);
+        if (l.length !== a)
+          throw new n("tlv.decode: length bytes not complete");
+        if (l[0] === 0)
+          throw new n("tlv.decode(long): zero leftmost byte");
+        for (let u of l)
+          i = i << 8 | u;
+        if (r += a, i < 128)
+          throw new n("tlv.decode(long): not minimal encoding");
+      }
+      let c = t.subarray(r, r + i);
+      if (c.length !== i)
+        throw new n("tlv.decode: wrong value length");
+      return { v: c, l: t.subarray(r + i) };
+    } }, _int: { encode(e) {
+      let { Err: t } = le.DER;
+      if (e < Ue)
+        throw new t("integer: negative integers are not allowed");
+      let n = (0, V.numberToHexUnpadded)(e);
+      if (Number.parseInt(n[0], 16) & 8 && (n = "00" + n), n.length & 1)
+        throw new t("unexpected DER parsing assertion: unpadded hex");
+      return n;
+    }, decode(e) {
+      let { Err: t } = le.DER;
+      if (e[0] & 128)
+        throw new t("invalid signature integer: negative");
+      if (e[0] === 0 && !(e[1] & 128))
+        throw new t("invalid signature integer: unnecessary leading zero");
+      return (0, V.bytesToNumberBE)(e);
+    } }, toSig(e) {
+      let { Err: t, _int: n, _tlv: r } = le.DER, s = (0, V.ensureBytes)("signature", e), { v: o, l: i } = r.decode(48, s);
+      if (i.length)
+        throw new t("invalid signature: left bytes after parsing");
+      let { v: c, l: a } = r.decode(2, o), { v: l, l: u } = r.decode(2, a);
+      if (u.length)
+        throw new t("invalid signature: left bytes after parsing");
+      return { r: n.decode(c), s: n.decode(l) };
+    }, hexFromSig(e) {
+      let { _tlv: t, _int: n } = le.DER, r = t.encode(2, n.encode(e.r)), s = t.encode(2, n.encode(e.s)), o = r + s;
+      return t.encode(48, o);
+    } };
+    var Ue = BigInt(0), me = BigInt(1), Xe = BigInt(2), Ot = BigInt(3), Ur = BigInt(4);
+    function dt(e, t) {
+      let { BYTES: n } = e, r;
+      if (typeof t == "bigint")
+        r = t;
+      else {
+        let s = (0, V.ensureBytes)("private key", t);
+        try {
+          r = e.fromBytes(s);
+        } catch {
+          throw new Error(`invalid private key: expected ui8a of size ${n}, got ${typeof t}`);
+        }
+      }
+      if (!e.isValidNot0(r))
+        throw new Error("invalid private key: out of range [1..N-1]");
+      return r;
+    }
+    function Kr(e, t = {}) {
+      let n = (0, nt._createCurveFields)("weierstrass", e, t), { Fp: r, Fn: s } = n, o = n.CURVE, { h: i, n: c } = o;
+      (0, V._validateObject)(t, {}, { allowInfinityPoint: "boolean", clearCofactor: "function", isTorsionFree: "function", fromBytes: "function", toBytes: "function", endo: "object", wrapPrivateKey: "boolean" });
+      let { endo: a } = t;
+      if (a && (!r.is0(o.a) || typeof a.beta != "bigint" || !Array.isArray(a.basises)))
+        throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+      let l = ei(r, s);
+      function u() {
+        if (!r.isOdd)
+          throw new Error("compression is not supported: Field does not have .isOdd()");
+      }
+      function y(C, m, f) {
+        let { x: d, y: R } = m.toAffine(), v = r.toBytes(d);
+        if ((0, V._abool2)(f, "isCompressed"), f) {
+          u();
+          let O = !r.isOdd(R);
+          return (0, V.concatBytes)(Qo(O), v);
+        } else
+          return (0, V.concatBytes)(Uint8Array.of(4), v, r.toBytes(R));
+      }
+      function h(C) {
+        (0, V._abytes2)(C, undefined, "Point");
+        let { publicKey: m, publicKeyUncompressed: f } = l, d = C.length, R = C[0], v = C.subarray(1);
+        if (d === m && (R === 2 || R === 3)) {
+          let O = r.fromBytes(v);
+          if (!r.isValid(O))
+            throw new Error("bad point: is not on curve, wrong x");
+          let N = x(O), L;
+          try {
+            L = r.sqrt(N);
+          } catch (se) {
+            let ee = se instanceof Error ? ": " + se.message : "";
+            throw new Error("bad point: is not on curve, sqrt error" + ee);
+          }
+          u();
+          let M = r.isOdd(L);
+          return (R & 1) === 1 !== M && (L = r.neg(L)), { x: O, y: L };
+        } else if (d === f && R === 4) {
+          let O = r.BYTES, N = r.fromBytes(v.subarray(0, O)), L = r.fromBytes(v.subarray(O, O * 2));
+          if (!B(N, L))
+            throw new Error("bad point: is not on curve");
+          return { x: N, y: L };
+        } else
+          throw new Error(`bad point: got length ${d}, expected compressed=${m} or uncompressed=${f}`);
+      }
+      let p = t.toBytes || y, b = t.fromBytes || h;
+      function x(C) {
+        let m = r.sqr(C), f = r.mul(m, C);
+        return r.add(r.add(f, r.mul(C, o.a)), o.b);
+      }
+      function B(C, m) {
+        let f = r.sqr(m), d = x(C);
+        return r.eql(f, d);
+      }
+      if (!B(o.Gx, o.Gy))
+        throw new Error("bad curve params: generator point");
+      let _ = r.mul(r.pow(o.a, Ot), Ur), A = r.mul(r.sqr(o.b), BigInt(27));
+      if (r.is0(r.add(_, A)))
+        throw new Error("bad curve params: a or b");
+      function w(C, m, f = false) {
+        if (!r.isValid(m) || f && r.is0(m))
+          throw new Error(`bad point coordinate ${C}`);
+        return m;
+      }
+      function S(C) {
+        if (!(C instanceof E))
+          throw new Error("ProjectivePoint expected");
+      }
+      function q(C) {
+        if (!a || !a.basises)
+          throw new Error("no endo");
+        return zo(C, a.basises, s.ORDER);
+      }
+      let k = (0, V.memoized)((C, m) => {
+        let { X: f, Y: d, Z: R } = C;
+        if (r.eql(R, r.ONE))
+          return { x: f, y: d };
+        let v = C.is0();
+        m == null && (m = v ? r.ONE : r.inv(R));
+        let O = r.mul(f, m), N = r.mul(d, m), L = r.mul(R, m);
+        if (v)
+          return { x: r.ZERO, y: r.ZERO };
+        if (!r.eql(L, r.ONE))
+          throw new Error("invZ was invalid");
+        return { x: O, y: N };
+      }), K = (0, V.memoized)((C) => {
+        if (C.is0()) {
+          if (t.allowInfinityPoint && !r.is0(C.Y))
+            return;
+          throw new Error("bad point: ZERO");
+        }
+        let { x: m, y: f } = C.toAffine();
+        if (!r.isValid(m) || !r.isValid(f))
+          throw new Error("bad point: x or y not field elements");
+        if (!B(m, f))
+          throw new Error("bad point: equation left != right");
+        if (!C.isTorsionFree())
+          throw new Error("bad point: not in prime-order subgroup");
+        return true;
+      });
+      function T(C, m, f, d, R) {
+        return f = new E(r.mul(f.X, C), f.Y, f.Z), m = (0, nt.negateCt)(d, m), f = (0, nt.negateCt)(R, f), m.add(f);
+      }
+
+      class E {
+        constructor(m, f, d) {
+          this.X = w("x", m), this.Y = w("y", f, true), this.Z = w("z", d), Object.freeze(this);
+        }
+        static CURVE() {
+          return o;
+        }
+        static fromAffine(m) {
+          let { x: f, y: d } = m || {};
+          if (!m || !r.isValid(f) || !r.isValid(d))
+            throw new Error("invalid affine point");
+          if (m instanceof E)
+            throw new Error("projective point not allowed");
+          return r.is0(f) && r.is0(d) ? E.ZERO : new E(f, d, r.ONE);
+        }
+        static fromBytes(m) {
+          let f = E.fromAffine(b((0, V._abytes2)(m, undefined, "point")));
+          return f.assertValidity(), f;
+        }
+        static fromHex(m) {
+          return E.fromBytes((0, V.ensureBytes)("pointHex", m));
+        }
+        get x() {
+          return this.toAffine().x;
+        }
+        get y() {
+          return this.toAffine().y;
+        }
+        precompute(m = 8, f = true) {
+          return $.createCache(this, m), f || this.multiply(Ot), this;
+        }
+        assertValidity() {
+          K(this);
+        }
+        hasEvenY() {
+          let { y: m } = this.toAffine();
+          if (!r.isOdd)
+            throw new Error("Field doesn't support isOdd");
+          return !r.isOdd(m);
+        }
+        equals(m) {
+          S(m);
+          let { X: f, Y: d, Z: R } = this, { X: v, Y: O, Z: N } = m, L = r.eql(r.mul(f, N), r.mul(v, R)), M = r.eql(r.mul(d, N), r.mul(O, R));
+          return L && M;
+        }
+        negate() {
+          return new E(this.X, r.neg(this.Y), this.Z);
+        }
+        double() {
+          let { a: m, b: f } = o, d = r.mul(f, Ot), { X: R, Y: v, Z: O } = this, N = r.ZERO, L = r.ZERO, M = r.ZERO, X = r.mul(R, R), se = r.mul(v, v), ee = r.mul(O, O), P = r.mul(R, v);
+          return P = r.add(P, P), M = r.mul(R, O), M = r.add(M, M), N = r.mul(m, M), L = r.mul(d, ee), L = r.add(N, L), N = r.sub(se, L), L = r.add(se, L), L = r.mul(N, L), N = r.mul(P, N), M = r.mul(d, M), ee = r.mul(m, ee), P = r.sub(X, ee), P = r.mul(m, P), P = r.add(P, M), M = r.add(X, X), X = r.add(M, X), X = r.add(X, ee), X = r.mul(X, P), L = r.add(L, X), ee = r.mul(v, O), ee = r.add(ee, ee), X = r.mul(ee, P), N = r.sub(N, X), M = r.mul(ee, se), M = r.add(M, M), M = r.add(M, M), new E(N, L, M);
+        }
+        add(m) {
+          S(m);
+          let { X: f, Y: d, Z: R } = this, { X: v, Y: O, Z: N } = m, L = r.ZERO, M = r.ZERO, X = r.ZERO, se = o.a, ee = r.mul(o.b, Ot), P = r.mul(f, v), oe = r.mul(d, O), ue = r.mul(R, N), I = r.add(f, d), Z = r.add(v, O);
+          I = r.mul(I, Z), Z = r.add(P, oe), I = r.sub(I, Z), Z = r.add(f, R);
+          let H = r.add(v, N);
+          return Z = r.mul(Z, H), H = r.add(P, ue), Z = r.sub(Z, H), H = r.add(d, R), L = r.add(O, N), H = r.mul(H, L), L = r.add(oe, ue), H = r.sub(H, L), X = r.mul(se, Z), L = r.mul(ee, ue), X = r.add(L, X), L = r.sub(oe, X), X = r.add(oe, X), M = r.mul(L, X), oe = r.add(P, P), oe = r.add(oe, P), ue = r.mul(se, ue), Z = r.mul(ee, Z), oe = r.add(oe, ue), ue = r.sub(P, ue), ue = r.mul(se, ue), Z = r.add(Z, ue), P = r.mul(oe, Z), M = r.add(M, P), P = r.mul(H, Z), L = r.mul(I, L), L = r.sub(L, P), P = r.mul(I, oe), X = r.mul(H, X), X = r.add(X, P), new E(L, M, X);
+        }
+        subtract(m) {
+          return this.add(m.negate());
+        }
+        is0() {
+          return this.equals(E.ZERO);
+        }
+        multiply(m) {
+          let { endo: f } = t;
+          if (!s.isValidNot0(m))
+            throw new Error("invalid scalar: out of range");
+          let d, R, v = (O) => $.cached(this, O, (N) => (0, nt.normalizeZ)(E, N));
+          if (f) {
+            let { k1neg: O, k1: N, k2neg: L, k2: M } = q(m), { p: X, f: se } = v(N), { p: ee, f: P } = v(M);
+            R = se.add(P), d = T(f.beta, X, ee, O, L);
+          } else {
+            let { p: O, f: N } = v(m);
+            d = O, R = N;
+          }
+          return (0, nt.normalizeZ)(E, [d, R])[0];
+        }
+        multiplyUnsafe(m) {
+          let { endo: f } = t, d = this;
+          if (!s.isValid(m))
+            throw new Error("invalid scalar: out of range");
+          if (m === Ue || d.is0())
+            return E.ZERO;
+          if (m === me)
+            return d;
+          if ($.hasCache(this))
+            return this.multiply(m);
+          if (f) {
+            let { k1neg: R, k1: v, k2neg: O, k2: N } = q(m), { p1: L, p2: M } = (0, nt.mulEndoUnsafe)(E, d, v, N);
+            return T(f.beta, L, M, R, O);
+          } else
+            return $.unsafe(d, m);
+        }
+        multiplyAndAddUnsafe(m, f, d) {
+          let R = this.multiplyUnsafe(f).add(m.multiplyUnsafe(d));
+          return R.is0() ? undefined : R;
+        }
+        toAffine(m) {
+          return k(this, m);
+        }
+        isTorsionFree() {
+          let { isTorsionFree: m } = t;
+          return i === me ? true : m ? m(E, this) : $.unsafe(this, c).is0();
+        }
+        clearCofactor() {
+          let { clearCofactor: m } = t;
+          return i === me ? this : m ? m(E, this) : this.multiplyUnsafe(i);
+        }
+        isSmallOrder() {
+          return this.multiplyUnsafe(i).is0();
+        }
+        toBytes(m = true) {
+          return (0, V._abool2)(m, "isCompressed"), this.assertValidity(), p(E, this, m);
+        }
+        toHex(m = true) {
+          return (0, V.bytesToHex)(this.toBytes(m));
+        }
+        toString() {
+          return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+        }
+        get px() {
+          return this.X;
+        }
+        get py() {
+          return this.X;
+        }
+        get pz() {
+          return this.Z;
+        }
+        toRawBytes(m = true) {
+          return this.toBytes(m);
+        }
+        _setWindowSize(m) {
+          this.precompute(m);
+        }
+        static normalizeZ(m) {
+          return (0, nt.normalizeZ)(E, m);
+        }
+        static msm(m, f) {
+          return (0, nt.pippenger)(E, s, m, f);
+        }
+        static fromPrivateKey(m) {
+          return E.BASE.multiply(dt(s, m));
+        }
+      }
+      E.BASE = new E(o.Gx, o.Gy, r.ONE), E.ZERO = new E(r.ZERO, r.ONE, r.ZERO), E.Fp = r, E.Fn = s;
+      let g = s.BITS, $ = new nt.wNAF(E, t.endo ? Math.ceil(g / 2) : g);
+      return E.BASE.precompute(8), E;
+    }
+    function Qo(e) {
+      return Uint8Array.of(e ? 2 : 3);
+    }
+    function Jo(e, t) {
+      let n = e.ORDER, r = Ue;
+      for (let b = n - me;b % Xe === Ue; b /= Xe)
+        r += me;
+      let s = r, o = Xe << s - me - me, i = o * Xe, c = (n - me) / i, a = (c - me) / Xe, l = i - me, u = o, y = e.pow(t, c), h = e.pow(t, (c + me) / Xe), p = (b, x) => {
+        let B = y, _ = e.pow(x, l), A = e.sqr(_);
+        A = e.mul(A, x);
+        let w = e.mul(b, A);
+        w = e.pow(w, a), w = e.mul(w, _), _ = e.mul(w, x), A = e.mul(w, b);
+        let S = e.mul(A, _);
+        w = e.pow(S, u);
+        let q = e.eql(w, e.ONE);
+        _ = e.mul(A, h), w = e.mul(S, B), A = e.cmov(_, A, q), S = e.cmov(w, S, q);
+        for (let k = s;k > me; k--) {
+          let K = k - Xe;
+          K = Xe << K - me;
+          let T = e.pow(S, K), E = e.eql(T, e.ONE);
+          _ = e.mul(A, B), B = e.mul(B, B), T = e.mul(S, B), A = e.cmov(_, A, E), S = e.cmov(T, S, E);
+        }
+        return { isValid: q, value: A };
+      };
+      if (e.ORDER % Ur === Ot) {
+        let b = (e.ORDER - Ot) / Ur, x = e.sqrt(e.neg(t));
+        p = (B, _) => {
+          let A = e.sqr(_), w = e.mul(B, _);
+          A = e.mul(A, w);
+          let S = e.pow(A, b);
+          S = e.mul(S, w);
+          let q = e.mul(S, x), k = e.mul(e.sqr(S), _), K = e.eql(k, B), T = e.cmov(q, S, K);
+          return { isValid: K, value: T };
+        };
+      }
+      return p;
+    }
+    function of(e, t) {
+      (0, Ct.validateField)(e);
+      let { A: n, B: r, Z: s } = t;
+      if (!e.isValid(n) || !e.isValid(r) || !e.isValid(s))
+        throw new Error("mapToCurveSimpleSWU: invalid opts");
+      let o = Jo(e, s);
+      if (!e.isOdd)
+        throw new Error("Field does not have .isOdd()");
+      return (i) => {
+        let c, a, l, u, y, h, p, b;
+        c = e.sqr(i), c = e.mul(c, s), a = e.sqr(c), a = e.add(a, c), l = e.add(a, e.ONE), l = e.mul(l, r), u = e.cmov(s, e.neg(a), !e.eql(a, e.ZERO)), u = e.mul(u, n), a = e.sqr(l), h = e.sqr(u), y = e.mul(h, n), a = e.add(a, y), a = e.mul(a, l), h = e.mul(h, u), y = e.mul(h, r), a = e.add(a, y), p = e.mul(c, l);
+        let { isValid: x, value: B } = o(a, h);
+        b = e.mul(c, i), b = e.mul(b, B), p = e.cmov(p, l, x), b = e.cmov(b, B, x);
+        let _ = e.isOdd(i) === e.isOdd(b);
+        b = e.cmov(e.neg(b), b, _);
+        let A = (0, Ct.FpInvertBatch)(e, [u], true)[0];
+        return p = e.mul(p, A), { x: p, y: b };
+      };
+    }
+    function ei(e, t) {
+      return { secretKey: t.BYTES, publicKey: 1 + e.BYTES, publicKeyUncompressed: 1 + 2 * e.BYTES, publicKeyHasPrefix: true, signature: 2 * t.BYTES };
+    }
+    function ti(e, t = {}) {
+      let { Fn: n } = e, r = t.randomBytes || V.randomBytes, s = Object.assign(ei(e.Fp, n), { seed: (0, Ct.getMinHashLength)(n.ORDER) });
+      function o(p) {
+        try {
+          return !!dt(n, p);
+        } catch {
+          return false;
+        }
+      }
+      function i(p, b) {
+        let { publicKey: x, publicKeyUncompressed: B } = s;
+        try {
+          let _ = p.length;
+          return b === true && _ !== x || b === false && _ !== B ? false : !!e.fromBytes(p);
+        } catch {
+          return false;
+        }
+      }
+      function c(p = r(s.seed)) {
+        return (0, Ct.mapHashToField)((0, V._abytes2)(p, s.seed, "seed"), n.ORDER);
+      }
+      function a(p, b = true) {
+        return e.BASE.multiply(dt(n, p)).toBytes(b);
+      }
+      function l(p) {
+        let b = c(p);
+        return { secretKey: b, publicKey: a(b) };
+      }
+      function u(p) {
+        if (typeof p == "bigint")
+          return false;
+        if (p instanceof e)
+          return true;
+        let { secretKey: b, publicKey: x, publicKeyUncompressed: B } = s;
+        if (n.allowedLengths || b === x)
+          return;
+        let _ = (0, V.ensureBytes)("key", p).length;
+        return _ === x || _ === B;
+      }
+      function y(p, b, x = true) {
+        if (u(p) === true)
+          throw new Error("first arg must be private key");
+        if (u(b) === false)
+          throw new Error("second arg must be public key");
+        let B = dt(n, p);
+        return e.fromHex(b).multiply(B).toBytes(x);
+      }
+      return Object.freeze({ getPublicKey: a, getSharedSecret: y, keygen: l, Point: e, utils: { isValidSecretKey: o, isValidPublicKey: i, randomSecretKey: c, isValidPrivateKey: o, randomPrivateKey: c, normPrivateKeyToScalar: (p) => dt(n, p), precompute(p = 8, b = e.BASE) {
+        return b.precompute(p, false);
+      } }, lengths: s });
+    }
+    function ni(e, t, n = {}) {
+      (0, sf.ahash)(t), (0, V._validateObject)(n, {}, { hmac: "function", lowS: "boolean", randomBytes: "function", bits2int: "function", bits2int_modN: "function" });
+      let r = n.randomBytes || V.randomBytes, s = n.hmac || ((f, ...d) => (0, rf.hmac)(t, f, (0, V.concatBytes)(...d))), { Fp: o, Fn: i } = e, { ORDER: c, BITS: a } = i, { keygen: l, getPublicKey: u, getSharedSecret: y, utils: h, lengths: p } = ti(e, n), b = { prehash: false, lowS: typeof n.lowS == "boolean" ? n.lowS : false, format: undefined, extraEntropy: false }, x = "compact";
+      function B(f) {
+        let d = c >> me;
+        return f > d;
+      }
+      function _(f, d) {
+        if (!i.isValidNot0(d))
+          throw new Error(`invalid signature ${f}: out of range 1..Point.Fn.ORDER`);
+        return d;
+      }
+      function A(f, d) {
+        Pr(d);
+        let R = p.signature, v = d === "compact" ? R : d === "recovered" ? R + 1 : undefined;
+        return (0, V._abytes2)(f, v, `${d} signature`);
+      }
+
+      class w {
+        constructor(d, R, v) {
+          this.r = _("r", d), this.s = _("s", R), v != null && (this.recovery = v), Object.freeze(this);
+        }
+        static fromBytes(d, R = x) {
+          A(d, R);
+          let v;
+          if (R === "der") {
+            let { r: M, s: X } = le.DER.toSig((0, V._abytes2)(d));
+            return new w(M, X);
+          }
+          R === "recovered" && (v = d[0], R = "compact", d = d.subarray(1));
+          let O = i.BYTES, N = d.subarray(0, O), L = d.subarray(O, O * 2);
+          return new w(i.fromBytes(N), i.fromBytes(L), v);
+        }
+        static fromHex(d, R) {
+          return this.fromBytes((0, V.hexToBytes)(d), R);
+        }
+        addRecoveryBit(d) {
+          return new w(this.r, this.s, d);
+        }
+        recoverPublicKey(d) {
+          let R = o.ORDER, { r: v, s: O, recovery: N } = this;
+          if (N == null || ![0, 1, 2, 3].includes(N))
+            throw new Error("recovery id invalid");
+          if (c * Xe < R && N > 1)
+            throw new Error("recovery id is ambiguous for h>1 curve");
+          let M = N === 2 || N === 3 ? v + c : v;
+          if (!o.isValid(M))
+            throw new Error("recovery id 2 or 3 invalid");
+          let X = o.toBytes(M), se = e.fromBytes((0, V.concatBytes)(Qo((N & 1) === 0), X)), ee = i.inv(M), P = q((0, V.ensureBytes)("msgHash", d)), oe = i.create(-P * ee), ue = i.create(O * ee), I = e.BASE.multiplyUnsafe(oe).add(se.multiplyUnsafe(ue));
+          if (I.is0())
+            throw new Error("point at infinify");
+          return I.assertValidity(), I;
+        }
+        hasHighS() {
+          return B(this.s);
+        }
+        toBytes(d = x) {
+          if (Pr(d), d === "der")
+            return (0, V.hexToBytes)(le.DER.hexFromSig(this));
+          let R = i.toBytes(this.r), v = i.toBytes(this.s);
+          if (d === "recovered") {
+            if (this.recovery == null)
+              throw new Error("recovery bit must be present");
+            return (0, V.concatBytes)(Uint8Array.of(this.recovery), R, v);
+          }
+          return (0, V.concatBytes)(R, v);
+        }
+        toHex(d) {
+          return (0, V.bytesToHex)(this.toBytes(d));
+        }
+        assertValidity() {}
+        static fromCompact(d) {
+          return w.fromBytes((0, V.ensureBytes)("sig", d), "compact");
+        }
+        static fromDER(d) {
+          return w.fromBytes((0, V.ensureBytes)("sig", d), "der");
+        }
+        normalizeS() {
+          return this.hasHighS() ? new w(this.r, i.neg(this.s), this.recovery) : this;
+        }
+        toDERRawBytes() {
+          return this.toBytes("der");
+        }
+        toDERHex() {
+          return (0, V.bytesToHex)(this.toBytes("der"));
+        }
+        toCompactRawBytes() {
+          return this.toBytes("compact");
+        }
+        toCompactHex() {
+          return (0, V.bytesToHex)(this.toBytes("compact"));
+        }
+      }
+      let S = n.bits2int || function(d) {
+        if (d.length > 8192)
+          throw new Error("input is too large");
+        let R = (0, V.bytesToNumberBE)(d), v = d.length * 8 - a;
+        return v > 0 ? R >> BigInt(v) : R;
+      }, q = n.bits2int_modN || function(d) {
+        return i.create(S(d));
+      }, k = (0, V.bitMask)(a);
+      function K(f) {
+        return (0, V.aInRange)("num < 2^" + a, f, Ue, k), i.toBytes(f);
+      }
+      function T(f, d) {
+        return (0, V._abytes2)(f, undefined, "message"), d ? (0, V._abytes2)(t(f), undefined, "prehashed message") : f;
+      }
+      function E(f, d, R) {
+        if (["recovered", "canonical"].some((oe) => (oe in R)))
+          throw new Error("sign() legacy options not supported");
+        let { lowS: v, prehash: O, extraEntropy: N } = Nr(R, b);
+        f = T(f, O);
+        let L = q(f), M = dt(i, d), X = [K(M), K(L)];
+        if (N != null && N !== false) {
+          let oe = N === true ? r(p.secretKey) : N;
+          X.push((0, V.ensureBytes)("extraEntropy", oe));
+        }
+        let se = (0, V.concatBytes)(...X), ee = L;
+        function P(oe) {
+          let ue = S(oe);
+          if (!i.isValidNot0(ue))
+            return;
+          let I = i.inv(ue), Z = e.BASE.multiply(ue).toAffine(), H = i.create(Z.x);
+          if (H === Ue)
+            return;
+          let W = i.create(I * i.create(ee + H * M));
+          if (W === Ue)
+            return;
+          let ie = (Z.x === H ? 0 : 2) | Number(Z.y & me), fe = W;
+          return v && B(W) && (fe = i.neg(W), ie ^= 1), new w(H, fe, ie);
+        }
+        return { seed: se, k2sig: P };
+      }
+      function g(f, d, R = {}) {
+        f = (0, V.ensureBytes)("message", f);
+        let { seed: v, k2sig: O } = E(f, d, R);
+        return (0, V.createHmacDrbg)(t.outputLen, i.BYTES, s)(v, O);
+      }
+      function $(f) {
+        let d, R = typeof f == "string" || (0, V.isBytes)(f), v = !R && f !== null && typeof f == "object" && typeof f.r == "bigint" && typeof f.s == "bigint";
+        if (!R && !v)
+          throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
+        if (v)
+          d = new w(f.r, f.s);
+        else if (R) {
+          try {
+            d = w.fromBytes((0, V.ensureBytes)("sig", f), "der");
+          } catch (O) {
+            if (!(O instanceof le.DER.Err))
+              throw O;
+          }
+          if (!d)
+            try {
+              d = w.fromBytes((0, V.ensureBytes)("sig", f), "compact");
+            } catch {
+              return false;
+            }
+        }
+        return d || false;
+      }
+      function C(f, d, R, v = {}) {
+        let { lowS: O, prehash: N, format: L } = Nr(v, b);
+        if (R = (0, V.ensureBytes)("publicKey", R), d = T((0, V.ensureBytes)("message", d), N), "strict" in v)
+          throw new Error("options.strict was renamed to lowS");
+        let M = L === undefined ? $(f) : w.fromBytes((0, V.ensureBytes)("sig", f), L);
+        if (M === false)
+          return false;
+        try {
+          let X = e.fromBytes(R);
+          if (O && M.hasHighS())
+            return false;
+          let { r: se, s: ee } = M, P = q(d), oe = i.inv(ee), ue = i.create(P * oe), I = i.create(se * oe), Z = e.BASE.multiplyUnsafe(ue).add(X.multiplyUnsafe(I));
+          return Z.is0() ? false : i.create(Z.x) === se;
+        } catch {
+          return false;
+        }
+      }
+      function m(f, d, R = {}) {
+        let { prehash: v } = Nr(R, b);
+        return d = T(d, v), w.fromBytes(f, "recovered").recoverPublicKey(d).toBytes();
+      }
+      return Object.freeze({ keygen: l, getPublicKey: u, getSharedSecret: y, utils: h, lengths: p, Point: e, sign: g, verify: C, recoverPublicKey: m, Signature: w, hash: t });
+    }
+    function cf(e) {
+      let { CURVE: t, curveOpts: n } = ri(e), r = Kr(t, n);
+      return uf(e, r);
+    }
+    function ri(e) {
+      let t = { a: e.a, b: e.b, p: e.Fp.ORDER, n: e.n, h: e.h, Gx: e.Gx, Gy: e.Gy }, n = e.Fp, r = e.allowedPrivateKeyLengths ? Array.from(new Set(e.allowedPrivateKeyLengths.map((i) => Math.ceil(i / 2)))) : undefined, s = (0, Ct.Field)(t.n, { BITS: e.nBitLength, allowedLengths: r, modFromBytes: e.wrapPrivateKey }), o = { Fp: n, Fn: s, allowInfinityPoint: e.allowInfinityPoint, endo: e.endo, isTorsionFree: e.isTorsionFree, clearCofactor: e.clearCofactor, fromBytes: e.fromBytes, toBytes: e.toBytes };
+      return { CURVE: t, curveOpts: o };
+    }
+    function af(e) {
+      let { CURVE: t, curveOpts: n } = ri(e), r = { hmac: e.hmac, randomBytes: e.randomBytes, lowS: e.lowS, bits2int: e.bits2int, bits2int_modN: e.bits2int_modN };
+      return { CURVE: t, curveOpts: n, hash: e.hash, ecdsaOpts: r };
+    }
+    function si(e, t, n) {
+      function r(s) {
+        let o = e.sqr(s), i = e.mul(o, s);
+        return e.add(e.add(i, e.mul(s, t)), n);
+      }
+      return r;
+    }
+    function uf(e, t) {
+      let { Fp: n, Fn: r } = t;
+      function s(i) {
+        return (0, V.inRange)(i, me, r.ORDER);
+      }
+      let o = si(n, e.a, e.b);
+      return Object.assign({}, { CURVE: e, Point: t, ProjectivePoint: t, normPrivateKeyToScalar: (i) => dt(r, i), weierstrassEquation: o, isWithinCurveOrder: s });
+    }
+    function ff(e, t) {
+      let n = t.Point;
+      return Object.assign({}, t, { ProjectivePoint: n, CURVE: Object.assign({}, e, (0, Ct.nLength)(n.Fn.ORDER, n.Fn.BITS)) });
+    }
+    function lf(e) {
+      let { CURVE: t, curveOpts: n, hash: r, ecdsaOpts: s } = af(e), o = Kr(t, n), i = ni(o, r, s);
+      return ff(e, i);
+    }
+  });
+  var oi = D((Nn) => {
+    Object.defineProperty(Nn, "__esModule", { value: true });
+    Nn.getHash = hf;
+    Nn.createCurve = pf;
+    var df = $r();
+    function hf(e) {
+      return { hash: e };
+    }
+    function pf(e, t) {
+      let n = (r) => (0, df.weierstrass)({ ...e, hash: r });
+      return { ...n(t), create: n };
+    }
+  });
+  var yi = D((_e) => {
+    Object.defineProperty(_e, "__esModule", { value: true });
+    _e.encodeToCurve = _e.hashToCurve = _e.secp256k1_hasher = _e.schnorr = _e.secp256k1 = undefined;
+    var Pn = wn(), ui = De(), yf = oi(), fi = vr(), ve = ut(), li = $r(), Ce = et(), Lt = { p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"), n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"), h: BigInt(1), a: BigInt(0), b: BigInt(7), Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"), Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8") }, bf = { beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"), basises: [[BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")], [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]] }, gf = BigInt(0), ii = BigInt(1), Mr = BigInt(2);
+    function mf(e) {
+      let t = Lt.p, n = BigInt(3), r = BigInt(6), s = BigInt(11), o = BigInt(22), i = BigInt(23), c = BigInt(44), a = BigInt(88), l = e * e * e % t, u = l * l * e % t, y = (0, ve.pow2)(u, n, t) * u % t, h = (0, ve.pow2)(y, n, t) * u % t, p = (0, ve.pow2)(h, Mr, t) * l % t, b = (0, ve.pow2)(p, s, t) * p % t, x = (0, ve.pow2)(b, o, t) * b % t, B = (0, ve.pow2)(x, c, t) * x % t, _ = (0, ve.pow2)(B, a, t) * B % t, A = (0, ve.pow2)(_, c, t) * x % t, w = (0, ve.pow2)(A, n, t) * u % t, S = (0, ve.pow2)(w, i, t) * b % t, q = (0, ve.pow2)(S, r, t) * l % t, k = (0, ve.pow2)(q, Mr, t);
+      if (!rt.eql(rt.sqr(k), e))
+        throw new Error("Cannot find square root");
+      return k;
+    }
+    var rt = (0, ve.Field)(Lt.p, { sqrt: mf });
+    _e.secp256k1 = (0, yf.createCurve)({ ...Lt, Fp: rt, lowS: true, endo: bf }, Pn.sha256);
+    var ci = {};
+    function Un(e, ...t) {
+      let n = ci[e];
+      if (n === undefined) {
+        let r = (0, Pn.sha256)((0, Ce.utf8ToBytes)(e));
+        n = (0, Ce.concatBytes)(r, r), ci[e] = n;
+      }
+      return (0, Pn.sha256)((0, Ce.concatBytes)(n, ...t));
+    }
+    var Dr = (e) => e.toBytes(true).slice(1), qt = _e.secp256k1.Point, Vr = (e) => e % Mr === gf;
+    function kr(e) {
+      let { Fn: t, BASE: n } = qt, r = (0, li._normFnElement)(t, e), s = n.multiply(r);
+      return { scalar: Vr(s.y) ? r : t.neg(r), bytes: Dr(s) };
+    }
+    function di(e) {
+      let t = rt;
+      if (!t.isValidNot0(e))
+        throw new Error("invalid x: Fail if x ≥ p");
+      let n = t.create(e * e), r = t.create(n * e + BigInt(7)), s = t.sqrt(r);
+      Vr(s) || (s = t.neg(s));
+      let o = qt.fromAffine({ x: e, y: s });
+      return o.assertValidity(), o;
+    }
+    var tn = Ce.bytesToNumberBE;
+    function hi(...e) {
+      return qt.Fn.create(tn(Un("BIP0340/challenge", ...e)));
+    }
+    function ai(e) {
+      return kr(e).bytes;
+    }
+    function _f(e, t, n = (0, ui.randomBytes)(32)) {
+      let { Fn: r } = qt, s = (0, Ce.ensureBytes)("message", e), { bytes: o, scalar: i } = kr(t), c = (0, Ce.ensureBytes)("auxRand", n, 32), a = r.toBytes(i ^ tn(Un("BIP0340/aux", c))), l = Un("BIP0340/nonce", a, o, s), { bytes: u, scalar: y } = kr(l), h = hi(u, o, s), p = new Uint8Array(64);
+      if (p.set(u, 0), p.set(r.toBytes(r.create(y + h * i)), 32), !pi(p, s, o))
+        throw new Error("sign: Invalid signature produced");
+      return p;
+    }
+    function pi(e, t, n) {
+      let { Fn: r, BASE: s } = qt, o = (0, Ce.ensureBytes)("signature", e, 64), i = (0, Ce.ensureBytes)("message", t), c = (0, Ce.ensureBytes)("publicKey", n, 32);
+      try {
+        let a = di(tn(c)), l = tn(o.subarray(0, 32));
+        if (!(0, Ce.inRange)(l, ii, Lt.p))
+          return false;
+        let u = tn(o.subarray(32, 64));
+        if (!(0, Ce.inRange)(u, ii, Lt.n))
+          return false;
+        let y = hi(r.toBytes(l), Dr(a), i), h = s.multiplyUnsafe(u).add(a.multiplyUnsafe(r.neg(y))), { x: p, y: b } = h.toAffine();
+        return !(h.is0() || !Vr(b) || p !== l);
+      } catch {
+        return false;
+      }
+    }
+    _e.schnorr = (() => {
+      let n = (s = (0, ui.randomBytes)(48)) => (0, ve.mapHashToField)(s, Lt.n);
+      _e.secp256k1.utils.randomSecretKey;
+      function r(s) {
+        let o = n(s);
+        return { secretKey: o, publicKey: ai(o) };
+      }
+      return { keygen: r, getPublicKey: ai, sign: _f, verify: pi, Point: qt, utils: { randomSecretKey: n, randomPrivateKey: n, taggedHash: Un, lift_x: di, pointToBytes: Dr, numberToBytesBE: Ce.numberToBytesBE, bytesToNumberBE: Ce.bytesToNumberBE, mod: ve.mod }, lengths: { secretKey: 32, publicKey: 32, publicKeyHasPrefix: false, signature: 64, seed: 48 } };
+    })();
+    var xf = (0, fi.isogenyMap)(rt, [["0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa8c7", "0x7d3d4c80bc321d5b9f315cea7fd44c5d595d2fc0bf63b92dfff1044f17c6581", "0x534c328d23f234e6e2a413deca25caece4506144037c40314ecbd0b53d9dd262", "0x8e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38e38daaaaa88c"], ["0xd35771193d94918a9ca34ccbb7b640dd86cd409542f8487d9fe6b745781eb49b", "0xedadc6f64383dc1df7c4b2d51b54225406d36b641f5e41bbc52a56612a8c6d14", "0x0000000000000000000000000000000000000000000000000000000000000001"], ["0x4bda12f684bda12f684bda12f684bda12f684bda12f684bda12f684b8e38e23c", "0xc75e0c32d5cb7c0fa9d0a54b12a0a6d5647ab046d686da6fdffc90fc201d71a3", "0x29a6194691f91a73715209ef6512e576722830a201be2018a765e85a9ecee931", "0x2f684bda12f684bda12f684bda12f684bda12f684bda12f684bda12f38e38d84"], ["0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffff93b", "0x7a06534bb8bdb49fd5e9e6632722c2989467c1bfc8e8d978dfb425d2685c2573", "0x6484aa716545ca2cf3a70c3fa8fe337e0a3d21162f0d6299a7bf8192bfd2a76f", "0x0000000000000000000000000000000000000000000000000000000000000001"]].map((e) => e.map((t) => BigInt(t)))), Ef = (0, li.mapToCurveSimpleSWU)(rt, { A: BigInt("0x3f8731abdd661adca08a5558f0f5d272e953d363cb6f0e5d405447c01a444533"), B: BigInt("1771"), Z: rt.create(BigInt("-11")) });
+    _e.secp256k1_hasher = (0, fi.createHasher)(_e.secp256k1.Point, (e) => {
+      let { x: t, y: n } = Ef(rt.create(e[0]));
+      return xf(t, n);
+    }, { DST: "secp256k1_XMD:SHA-256_SSWU_RO_", encodeDST: "secp256k1_XMD:SHA-256_SSWU_NU_", p: rt.ORDER, m: 1, k: 128, expand: "xmd", hash: Pn.sha256 });
+    _e.hashToCurve = _e.secp256k1_hasher.hashToCurve;
+    _e.encodeToCurve = _e.secp256k1_hasher.encodeToCurve;
+  });
+  var jr = D((Et) => {
+    Object.defineProperty(Et, "__esModule", { value: true });
+    Et.decodeHex = Et.remove0x = undefined;
+    var wf = $e(), Bf = (e) => e.startsWith("0x") || e.startsWith("0X") ? e.slice(2) : e;
+    Et.remove0x = Bf;
+    var Af = (e) => (0, wf.hexToBytes)((0, Et.remove0x)(e));
+    Et.decodeHex = Af;
+  });
+  var mi = D((Re) => {
+    Object.defineProperty(Re, "__esModule", { value: true });
+    Re.hexToPublicKey = Re.convertPublicKeyFormat = Re.getSharedPoint = Re.getPublicKey = Re.isValidPrivateKey = Re.getValidSecret = undefined;
+    var Sf = rr(), bi = Fo(), vf = yi(), gi = ln(), Rf = jr(), Hf = (e) => {
+      let t;
+      do
+        t = (0, Sf.randomBytes)(gi.SECRET_KEY_LENGTH);
+      while (!(0, Re.isValidPrivateKey)(e, t));
+      return t;
+    };
+    Re.getValidSecret = Hf;
+    var If = (e, t) => nn(e, (n) => n.utils.isValidSecretKey(t), () => true, () => true);
+    Re.isValidPrivateKey = If;
+    var Tf = (e, t) => nn(e, (n) => n.getPublicKey(t), (n) => n.getPublicKey(t), (n) => n.getPublicKey(t));
+    Re.getPublicKey = Tf;
+    var Of = (e, t, n, r) => nn(e, (s) => s.getSharedSecret(t, n, r), (s) => s.getSharedSecret(t, n), (s) => Nf(s, t, n));
+    Re.getSharedPoint = Of;
+    var Cf = (e, t, n) => nn(e, (r) => r.getSharedSecret(Uint8Array.from(Array(31).fill(0).concat([1])), t, n), () => t, () => t);
+    Re.convertPublicKeyFormat = Cf;
+    var Lf = (e, t) => {
+      let n = (0, Rf.decodeHex)(t);
+      return nn(e, () => qf(n), () => n, () => n);
+    };
+    Re.hexToPublicKey = Lf;
+    function nn(e, t, n, r) {
+      let s = e;
+      if (s === "secp256k1")
+        return t(vf.secp256k1);
+      if (s === "x25519")
+        return n(bi.x25519);
+      if (s === "ed25519")
+        return r(bi.ed25519);
+      throw new Error("Not implemented");
+    }
+    var qf = (e) => {
+      if (e.length === gi.ETH_PUBLIC_KEY_SIZE) {
+        let t = new Uint8Array(1 + e.length);
+        return t.set([4]), t.set(e, 1), t;
+      }
+      return e;
+    }, Nf = (e, t, n) => {
+      let { scalar: r } = e.utils.getExtendedPublicKey(t);
+      return e.Point.fromBytes(n).multiply(r).toBytes();
+    };
+  });
+  var Bi = D((Pt) => {
+    Object.defineProperty(Pt, "__esModule", { value: true });
+    Pt.hkdf = undefined;
+    Pt.extract = Ei;
+    Pt.expand = wi;
+    var xi = qr(), Nt = De();
+    function Ei(e, t, n) {
+      return (0, Nt.ahash)(e), n === undefined && (n = new Uint8Array(e.outputLen)), (0, xi.hmac)(e, (0, Nt.toBytes)(n), (0, Nt.toBytes)(t));
+    }
+    var Gr = Uint8Array.from([0]), _i = Uint8Array.of();
+    function wi(e, t, n, r = 32) {
+      (0, Nt.ahash)(e), (0, Nt.anumber)(r);
+      let s = e.outputLen;
+      if (r > 255 * s)
+        throw new Error("Length should be <= 255*HashLen");
+      let o = Math.ceil(r / s);
+      n === undefined && (n = _i);
+      let i = new Uint8Array(o * s), c = xi.hmac.create(e, t), a = c._cloneInto(), l = new Uint8Array(c.outputLen);
+      for (let u = 0;u < o; u++)
+        Gr[0] = u + 1, a.update(u === 0 ? _i : l).update(n).update(Gr).digestInto(l), i.set(l, s * u), c._cloneInto(a);
+      return c.destroy(), a.destroy(), (0, Nt.clean)(l, Gr), i.slice(0, r);
+    }
+    var Pf = (e, t, n, r, s) => wi(e, Ei(e, t, n), r, s);
+    Pt.hkdf = Pf;
+  });
+  var Ai = D((wt) => {
+    Object.defineProperty(wt, "__esModule", { value: true });
+    wt.getSharedKey = wt.deriveKey = undefined;
+    var Uf = $e(), Kf = Bi(), $f = wn(), Mf = (e, t, n) => (0, Kf.hkdf)($f.sha256, e, t, n, 32);
+    wt.deriveKey = Mf;
+    var kf = (...e) => (0, wt.deriveKey)((0, Uf.concatBytes)(...e));
+    wt.getSharedKey = kf;
+  });
+  var Zr = D((Kn) => {
+    Object.defineProperty(Kn, "__esModule", { value: true });
+    Kn._compat = undefined;
+    var Si = __require("node:crypto"), vi = $e(), Df = 16, Vf = (e, t, n, r) => {
+      let s = e === "aes-256-gcm" || e === "chacha20-poly1305", o = s ? Df : 0, i = s ? { authTagLength: o } : undefined;
+      return { encrypt: (l) => {
+        let u = (0, Si.createCipheriv)(e, t, n, i);
+        s && r !== undefined && u.setAAD(r);
+        let y = u.update(l), h = u.final(), p = s ? u.getAuthTag() : new Uint8Array(0);
+        return (0, vi.concatBytes)(y, h, p);
+      }, decrypt: (l) => {
+        let u = l.subarray(0, l.length - o), y = l.subarray(l.length - o), h = (0, Si.createDecipheriv)(e, t, n, i);
+        s && (r !== undefined && h.setAAD(r), h.setAuthTag(y));
+        let p = h.update(u), b = h.final();
+        return (0, vi.concatBytes)(p, b);
+      } };
+    };
+    Kn._compat = Vf;
+  });
+  var Hi = D((Ut) => {
+    Object.defineProperty(Ut, "__esModule", { value: true });
+    Ut.aes256cbc = Ut.aes256gcm = undefined;
+    var Ri = Zr(), jf = (e, t, n) => (0, Ri._compat)("aes-256-gcm", e, t, n);
+    Ut.aes256gcm = jf;
+    var Gf = (e, t, n) => (0, Ri._compat)("aes-256-cbc", e, t);
+    Ut.aes256cbc = Gf;
+  });
+  var Ii = D(($n) => {
+    Object.defineProperty($n, "__esModule", { value: true });
+    $n._hchacha20 = undefined;
+    var Zf = (e, t, n, r) => {
+      let s = e[0], o = e[1], i = e[2], c = e[3], a = t[0], l = t[1], u = t[2], y = t[3], h = t[4], p = t[5], b = t[6], x = t[7], B = n[0], _ = n[1], A = n[2], w = n[3];
+      for (let q = 0;q < 20; q += 2)
+        s = s + a | 0, B = re(B ^ s, 16), h = h + B | 0, a = re(a ^ h, 12), s = s + a | 0, B = re(B ^ s, 8), h = h + B | 0, a = re(a ^ h, 7), o = o + l | 0, _ = re(_ ^ o, 16), p = p + _ | 0, l = re(l ^ p, 12), o = o + l | 0, _ = re(_ ^ o, 8), p = p + _ | 0, l = re(l ^ p, 7), i = i + u | 0, A = re(A ^ i, 16), b = b + A | 0, u = re(u ^ b, 12), i = i + u | 0, A = re(A ^ i, 8), b = b + A | 0, u = re(u ^ b, 7), c = c + y | 0, w = re(w ^ c, 16), x = x + w | 0, y = re(y ^ x, 12), c = c + y | 0, w = re(w ^ c, 8), x = x + w | 0, y = re(y ^ x, 7), s = s + l | 0, w = re(w ^ s, 16), b = b + w | 0, l = re(l ^ b, 12), s = s + l | 0, w = re(w ^ s, 8), b = b + w | 0, l = re(l ^ b, 7), o = o + u | 0, B = re(B ^ o, 16), x = x + B | 0, u = re(u ^ x, 12), o = o + u | 0, B = re(B ^ o, 8), x = x + B | 0, u = re(u ^ x, 7), i = i + y | 0, _ = re(_ ^ i, 16), h = h + _ | 0, y = re(y ^ h, 12), i = i + y | 0, _ = re(_ ^ i, 8), h = h + _ | 0, y = re(y ^ h, 7), c = c + a | 0, A = re(A ^ c, 16), p = p + A | 0, a = re(a ^ p, 12), c = c + a | 0, A = re(A ^ c, 8), p = p + A | 0, a = re(a ^ p, 7);
+      let S = 0;
+      r[S++] = s, r[S++] = o, r[S++] = i, r[S++] = c, r[S++] = B, r[S++] = _, r[S++] = A, r[S++] = w;
+    };
+    $n._hchacha20 = Zf;
+    var re = (e, t) => e << t | e >>> 32 - t;
+  });
+  var Oi = D((Kt) => {
+    Object.defineProperty(Kt, "__esModule", { value: true });
+    Kt.chacha20 = Kt.xchacha20 = undefined;
+    var Yr = $e(), Ti = Zr(), Yf = Ii(), Xf = (e, t, n) => {
+      if (t.length !== 24)
+        throw new Error("xchacha20's nonce must be 24 bytes");
+      let r = new Uint32Array([1634760805, 857760878, 2036477234, 1797285236]), s = new Uint32Array(8);
+      (0, Yf._hchacha20)(r, (0, Yr.u32)(e), (0, Yr.u32)(t.subarray(0, 16)), s);
+      let o = new Uint8Array(12);
+      return o.set([0, 0, 0, 0]), o.set(t.subarray(16), 4), (0, Ti._compat)("chacha20-poly1305", (0, Yr.u8)(s), o, n);
+    };
+    Kt.xchacha20 = Xf;
+    var Ff = (e, t, n) => {
+      if (t.length !== 12)
+        throw new Error("chacha20's nonce must be 12 bytes");
+      return (0, Ti._compat)("chacha20-poly1305", e, t, n);
+    };
+    Kt.chacha20 = Ff;
+  });
+  var qi = D(($t) => {
+    Object.defineProperty($t, "__esModule", { value: true });
+    $t.symDecrypt = $t.symEncrypt = undefined;
+    var Wf = Hi(), zf = Oi(), Ci = $e(), Qf = rr(), Xr = ln(), Jf = (e, t, n, r) => Li(tl, e, t, n, r);
+    $t.symEncrypt = Jf;
+    var el = (e, t, n, r) => Li(nl, e, t, n, r);
+    $t.symDecrypt = el;
+    function Li(e, t, n, r, s) {
+      let o = t.symmetricAlgorithm;
+      if (o === "aes-256-gcm")
+        return e(Wf.aes256gcm, n, r, t.symmetricNonceLength, Xr.AEAD_TAG_LENGTH, s);
+      if (o === "xchacha20")
+        return e(zf.xchacha20, n, r, Xr.XCHACHA20_NONCE_LENGTH, Xr.AEAD_TAG_LENGTH, s);
+      throw new Error("Not implemented");
+    }
+    function tl(e, t, n, r, s, o) {
+      let i = (0, Qf.randomBytes)(r), a = e(t, i, o).encrypt(n), l = a.length - s, u = a.subarray(0, l), y = a.subarray(l);
+      return (0, Ci.concatBytes)(i, y, u);
+    }
+    function nl(e, t, n, r, s, o) {
+      let i = n.subarray(0, r), c = e(t, Uint8Array.from(i), o), a = n.subarray(r), l = a.subarray(0, s), u = a.subarray(s);
+      return c.decrypt((0, Ci.concatBytes)(u, l));
+    }
+  });
+  var kn = D((Fe) => {
+    var rl = Fe && Fe.__createBinding || (Object.create ? function(e, t, n, r) {
+      r === undefined && (r = n);
+      var s = Object.getOwnPropertyDescriptor(t, n);
+      (!s || ("get" in s ? !t.__esModule : s.writable || s.configurable)) && (s = { enumerable: true, get: function() {
+        return t[n];
+      } }), Object.defineProperty(e, r, s);
+    } : function(e, t, n, r) {
+      r === undefined && (r = n), e[r] = t[n];
+    }), Mn = Fe && Fe.__exportStar || function(e, t) {
+      for (var n in e)
+        n !== "default" && !Object.prototype.hasOwnProperty.call(t, n) && rl(t, e, n);
+    };
+    Object.defineProperty(Fe, "__esModule", { value: true });
+    Mn(mi(), Fe);
+    Mn(Ai(), Fe);
+    Mn(jr(), Fe);
+    Mn(qi(), Fe);
+  });
+  var Wr = D((Vn) => {
+    Object.defineProperty(Vn, "__esModule", { value: true });
+    Vn.PublicKey = undefined;
+    var Ni = $e(), Pi = Gt(), Dn = kn(), Fr = class e {
+      static fromHex(t, n = Pi.ECIES_CONFIG.ellipticCurve) {
+        return new e((0, Dn.hexToPublicKey)(n, t), n);
+      }
+      get _uncompressed() {
+        return this.dataUncompressed !== null ? this.dataUncompressed : this.data;
+      }
+      constructor(t, n = Pi.ECIES_CONFIG.ellipticCurve) {
+        let r = (0, Dn.convertPublicKeyFormat)(n, t, true), s = (0, Dn.convertPublicKeyFormat)(n, t, false);
+        this.data = r, this.dataUncompressed = r.length !== s.length ? s : null;
+      }
+      toBytes(t = true) {
+        return t ? this.data : this._uncompressed;
+      }
+      toHex(t = true) {
+        return (0, Ni.bytesToHex)(this.toBytes(t));
+      }
+      decapsulate(t, n = false) {
+        let r = this.toBytes(n), s = t.multiply(this, n);
+        return (0, Dn.getSharedKey)(r, s);
+      }
+      equals(t) {
+        return (0, Ni.equalBytes)(this.data, t.data);
+      }
+    };
+    Vn.PublicKey = Fr;
+  });
+  var $i = D((jn) => {
+    Object.defineProperty(jn, "__esModule", { value: true });
+    jn.PrivateKey = undefined;
+    var Ui = $e(), Ki = Gt(), Mt = kn(), sl = Wr(), zr = class e {
+      static fromHex(t, n = Ki.ECIES_CONFIG.ellipticCurve) {
+        return new e((0, Mt.decodeHex)(t), n);
+      }
+      get secret() {
+        return this.data;
+      }
+      constructor(t, n = Ki.ECIES_CONFIG.ellipticCurve) {
+        if (this.curve = n, t === undefined)
+          this.data = (0, Mt.getValidSecret)(n);
+        else if ((0, Mt.isValidPrivateKey)(n, t))
+          this.data = t;
+        else
+          throw new Error("Invalid private key");
+        this.publicKey = new sl.PublicKey((0, Mt.getPublicKey)(n, this.data), n);
+      }
+      toHex() {
+        return (0, Ui.bytesToHex)(this.data);
+      }
+      encapsulate(t, n = false) {
+        let r = this.publicKey.toBytes(n), s = this.multiply(t, n);
+        return (0, Mt.getSharedKey)(r, s);
+      }
+      multiply(t, n = false) {
+        return (0, Mt.getSharedPoint)(this.curve, this.data, t.toBytes(true), n);
+      }
+      equals(t) {
+        return (0, Ui.equalBytes)(this.data, t.data);
+      }
+    };
+    jn.PrivateKey = zr;
+  });
+  var Qr = D((kt) => {
+    Object.defineProperty(kt, "__esModule", { value: true });
+    kt.PublicKey = kt.PrivateKey = undefined;
+    var ol = $i();
+    Object.defineProperty(kt, "PrivateKey", { enumerable: true, get: function() {
+      return ol.PrivateKey;
+    } });
+    var il = Wr();
+    Object.defineProperty(kt, "PublicKey", { enumerable: true, get: function() {
+      return il.PublicKey;
+    } });
+  });
+  var rn = D((We) => {
+    Object.defineProperty(We, "__esModule", { value: true });
+    We.PublicKey = We.PrivateKey = We.ECIES_CONFIG = undefined;
+    We.encrypt = al;
+    We.decrypt = ul;
+    var cl = $e(), Mi = Gt(), Dt = Qr(), ki = kn();
+    function al(e, t, n = Mi.ECIES_CONFIG) {
+      let r = n.ellipticCurve, s = new Dt.PrivateKey(undefined, r), o = e instanceof Uint8Array ? new Dt.PublicKey(e, r) : Dt.PublicKey.fromHex(e, r), i = s.encapsulate(o, n.isHkdfKeyCompressed), c = s.publicKey.toBytes(n.isEphemeralKeyCompressed), a = (0, ki.symEncrypt)(n, i, t);
+      return (0, cl.concatBytes)(c, a);
+    }
+    function ul(e, t, n = Mi.ECIES_CONFIG) {
+      let r = n.ellipticCurve, s = e instanceof Uint8Array ? new Dt.PrivateKey(e, r) : Dt.PrivateKey.fromHex(e, r), o = n.ephemeralKeySize, i = new Dt.PublicKey(t.subarray(0, o), r), c = t.subarray(o), a = i.decapsulate(s, n.isHkdfKeyCompressed);
+      return (0, ki.symDecrypt)(n, a, c);
+    }
+    var fl = Gt();
+    Object.defineProperty(We, "ECIES_CONFIG", { enumerable: true, get: function() {
+      return fl.ECIES_CONFIG;
+    } });
+    var Di = Qr();
+    Object.defineProperty(We, "PrivateKey", { enumerable: true, get: function() {
+      return Di.PrivateKey;
+    } });
+    Object.defineProperty(We, "PublicKey", { enumerable: true, get: function() {
+      return Di.PublicKey;
+    } });
+  });
+  var Zn = D((V0, Vi) => {
+    var Bt = { MISSING_PRIVATE_KEY: "https://github.com/dotenvx/dotenvx/issues/464", INVALID_PRIVATE_KEY: "https://github.com/dotenvx/dotenvx/issues/465", WRONG_PRIVATE_KEY: "https://github.com/dotenvx/dotenvx/issues/466", MALFORMED_ENCRYPTED_DATA: "https://github.com/dotenvx/dotenvx/issues/467", DECRYPTION_FAILED: "https://github.com/dotenvx/dotenvx/issues/757", COMMAND_SUBSTITUTION_FAILED: "https://github.com/dotenvx/dotenvx/issues/532" }, Gn = class {
+      constructor(t = {}) {
+        this.message = t.message, this.command = t.command;
+      }
+      missingPrivateKey() {
+        let t = "MISSING_PRIVATE_KEY", n = `[${t}] could not decrypt because private key is missing`, r = `fix: [${Bt[t]}]`, s = new Error(n);
+        return s.code = t, s.help = r, s.messageWithHelp = `${n}. ${r}`, s;
+      }
+      invalidPrivateKey() {
+        let t = "INVALID_PRIVATE_KEY", n = `[${t}] could not decrypt using private key`, r = `fix: [${Bt[t]}]`, s = new Error(n);
+        return s.code = t, s.help = r, s.messageWithHelp = `${n}. ${r}`, s;
+      }
+      wrongPrivateKey() {
+        let t = "WRONG_PRIVATE_KEY", n = `[${t}] could not decrypt using private key`, r = `fix: [${Bt[t]}]`, s = new Error(n);
+        return s.code = t, s.help = r, s.messageWithHelp = `${n}. ${r}`, s;
+      }
+      malformedEncryptedData() {
+        let t = "MALFORMED_ENCRYPTED_DATA", n = `[${t}] could not decrypt because encrypted data appears malformed`, r = `fix: [${Bt[t]}]`, s = new Error(n);
+        return s.code = t, s.help = r, s.messageWithHelp = `${n}. ${r}`, s;
+      }
+      decryptionFailed() {
+        let t = "DECRYPTION_FAILED", n = `[${t}] ${this.message}`, r = `fix: [${Bt[t]}]`, s = new Error(n);
+        return s.code = t, s.help = r, s.messageWithHelp = `${n}. ${r}`, s;
+      }
+      commandSubstitutionFailed() {
+        let t = "COMMAND_SUBSTITUTION_FAILED", n = `[${t}] could not evaluate command '${this.command}': ${this.message}`, r = `fix: [${Bt[t]}]`, s = new Error(n);
+        return s.code = t, s.help = r, s.messageWithHelp = `${n}. ${r}`, s;
+      }
+    };
+    Gn.ISSUE_BY_CODE = Bt;
+    Vi.exports = Gn;
+  });
+  var Vt = D((j0, Jr) => {
+    var ji = "encrypted:";
+    function ll(e) {
+      return e ? e.startsWith(ji) : false;
+    }
+    Jr.exports = ll;
+    Jr.exports.PREFIX = ji;
+  });
+  var ts = D((G0, Gi) => {
+    var { decrypt: dl } = rn(), sn = Zn(), es = Vt();
+    function hl(e, t, n = {}) {
+      let r = n.prefix === false ? `${es.PREFIX}${t}` : t;
+      if (!es(r))
+        return t;
+      if (!e || e.length < 1)
+        throw new sn().missingPrivateKey();
+      try {
+        let s = Buffer.from(e, "hex"), o = Buffer.from(r.substring(es.PREFIX.length), "base64");
+        return Buffer.from(dl(s, o)).toString("utf8");
+      } catch (s) {
+        throw s.message === "Invalid private key" ? new sn().invalidPrivateKey() : s.message === "Unsupported state or unable to authenticate data" ? new sn().wrongPrivateKey() : s.message === "Point of length 65 was invalid. Expected 33 compressed bytes or 65 uncompressed bytes" ? new sn().malformedEncryptedData() : new sn({ message: s.message }).decryptionFailed();
+      }
+    }
+    Gi.exports = hl;
+  });
+  var Yn = D((Z0, Zi) => {
+    var { PrivateKey: pl } = rn();
+    function yl(e) {
+      return new pl(Buffer.from(e, "hex")).publicKey.toHex();
+    }
+    Zi.exports = yl;
+  });
+  var Xi = D((Y0, Yi) => {
+    var { encrypt: bl } = rn(), { PREFIX: gl } = Vt();
+    function ml(e, t, n = {}) {
+      let r = bl(e, Buffer.from(t)), s = Buffer.from(r, "hex").toString("base64");
+      return n.prefix === false ? s : `${gl}${s}`;
+    }
+    Yi.exports = ml;
+  });
+  var ns = D((X0, zi) => {
+    var { execSync: _l } = __require("child_process"), Fi = __require("fs"), Wi = __require("path"), xl = Zn();
+    function El(e) {
+      return e.replace(/[\r\n]+$/, "");
+    }
+    function wl(e) {
+      let t = [], n = e.indexOf("$(");
+      for (;n !== -1; ) {
+        let r = [{ quote: null }], s = n + 2, o = -1;
+        for (;s < e.length; ) {
+          let i = r[r.length - 1], c = e[s];
+          if (i.quote === "'") {
+            c === "'" && (i.quote = null), s += 1;
+            continue;
+          }
+          if (i.quote) {
+            c === "\\" ? s += 2 : c === i.quote ? (i.quote = null, s += 1) : c === "$" && e[s + 1] === "(" ? (r.push({ quote: null }), s += 2) : s += 1;
+            continue;
+          }
+          if (c === "\\")
+            s += 2;
+          else if (c === "'" || c === '"' || c === "`")
+            i.quote = c, s += 1;
+          else if (c === "(")
+            r.push({ quote: null }), s += 1;
+          else if (c === ")") {
+            if (r.pop(), s += 1, r.length === 0) {
+              o = s;
+              break;
+            }
+          } else
+            s += 1;
+        }
+        o !== -1 ? (t.push(e.slice(n, o)), n = e.indexOf("$(", o)) : n = e.indexOf("$(", n + 2);
+      }
+      return t;
+    }
+    function Bl(e, t) {
+      var s, o;
+      let n = (s = Object.entries(t).find(([i]) => i.toUpperCase() === "PATH")) == null ? undefined : s[1];
+      if (!n)
+        return null;
+      let r = process.platform === "win32" ? (((o = Object.entries(t).find(([i]) => i.toUpperCase() === "PATHEXT")) == null ? undefined : o[1]) || ".COM;.EXE;.BAT;.CMD").split(";") : [""];
+      for (let i of n.split(Wi.delimiter))
+        for (let c of r) {
+          let a = Wi.join(i.replace(/^"|"$/g, ""), `${e}${c}`);
+          try {
+            return Fi.accessSync(a, Fi.constants.X_OK), a;
+          } catch {}
+        }
+      return null;
+    }
+    function Al(e) {
+      if (process.platform === "win32")
+        return '"' + e.replace(/"/g, "\\\"") + '"';
+      let t = "'";
+      return t + e.replaceAll(t, t + "\\" + t + t) + t;
+    }
+    function Sl(e, t) {
+      if (!process.pkg)
+        return e;
+      let n = /^(\s*)(?:node|"node"|'node')(?=\s|$)/;
+      if (!n.test(e))
+        return e;
+      let r = Bl("node", t);
+      return r ? e.replace(n, `$1${Al(r)}`) : e;
+    }
+    function vl(e, t) {
+      let n = t.processEnv || process.env, r = t.runningParsed || {};
+      return wl(e).reduce((o, i) => {
+        let c = i.slice(2, -1), a;
+        try {
+          let l = { ...n, ...r };
+          a = _l(Sl(c, l), { env: l }).toString();
+        } catch (l) {
+          throw new xl({ command: c, message: l.message.trim() }).commandSubstitutionFailed();
+        }
+        return a = El(a), o.replace(i, a);
+      }, e);
+    }
+    zi.exports = vl;
+  });
+  var rs = D((F0, Qi) => {
+    function Rl(e, t) {
+      let n = t.overload, r = t.processEnv || process.env, s = t.runningParsed || {}, o = t.literals || {}, i = { ...s, ...r };
+      n && (i = { ...r, ...s });
+      let c = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g, a = e, l;
+      for (;(l = c.exec(a)) !== null; ) {
+        let [u, y, h] = l, p = y || h, b = /(:\+|\+|:-|-)/, x = p.match(b), B = x ? x[0] : null, _ = p.split(B), A = _.shift(), w = _.join(B), S = Object.prototype.hasOwnProperty.call(i, A), q;
+        if (B === ":-" ? q = i[A] || w : B === "-" ? q = S ? i[A] : w : B === ":+" ? q = i[A] ? w : "" : B === "+" ? q = S ? w : "" : q = i[A] || "", a = a.replace(u, q), a === i[A] || o[A] && /\$\{[^}]+\}|\$[A-Za-z_][A-Za-z0-9_]*/.test(o[A]))
+          break;
+        c.lastIndex = 0;
+      }
+      return a;
+    }
+    Qi.exports = Rl;
+  });
+  var ec = D((W0, Ji) => {
+    var { PrivateKey: Hl } = rn(), Il = Yn();
+    function Tl(e) {
+      if (e)
+        return { publicKey: Il(e), privateKey: e };
+      let t = new Hl;
+      return { publicKey: t.publicKey.toHex(), privateKey: Buffer.from(t.secret).toString("hex") };
+    }
+    Ji.exports = Tl;
+  });
+  var on = D((z0, oc) => {
+    var tc = "[^\\\\/]", Ol = "(?=.)", nc = "[^/]", ss = "(?:\\/|$)", rc = "(?:^|\\/)", os = `\\.{1,2}${ss}`, Cl = "(?!\\.)", Ll = `(?!${rc}${os})`, ql = `(?!\\.{0,1}${ss})`, Nl = `(?!${os})`, Pl = "[^.\\/]", Ul = `${nc}*?`, Kl = "/", sc = { DOT_LITERAL: "\\.", PLUS_LITERAL: "\\+", QMARK_LITERAL: "\\?", SLASH_LITERAL: "\\/", ONE_CHAR: Ol, QMARK: nc, END_ANCHOR: ss, DOTS_SLASH: os, NO_DOT: Cl, NO_DOTS: Ll, NO_DOT_SLASH: ql, NO_DOTS_SLASH: Nl, QMARK_NO_DOT: Pl, STAR: Ul, START_ANCHOR: rc, SEP: Kl }, $l = { ...sc, SLASH_LITERAL: "[\\\\/]", QMARK: tc, STAR: `${tc}*?`, DOTS_SLASH: "\\.{1,2}(?:[\\\\/]|$)", NO_DOT: "(?!\\.)", NO_DOTS: "(?!(?:^|[\\\\/])\\.{1,2}(?:[\\\\/]|$))", NO_DOT_SLASH: "(?!\\.{0,1}(?:[\\\\/]|$))", NO_DOTS_SLASH: "(?!\\.{1,2}(?:[\\\\/]|$))", QMARK_NO_DOT: "[^.\\\\/]", START_ANCHOR: "(?:^|[\\\\/])", END_ANCHOR: "(?:[\\\\/]|$)", SEP: "\\" }, Ml = { __proto__: null, alnum: "a-zA-Z0-9", alpha: "a-zA-Z", ascii: "\\x00-\\x7F", blank: " \\t", cntrl: "\\x00-\\x1F\\x7F", digit: "0-9", graph: "\\x21-\\x7E", lower: "a-z", print: "\\x20-\\x7E ", punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~", space: " \\t\\r\\n\\v\\f", upper: "A-Z", word: "A-Za-z0-9_", xdigit: "A-Fa-f0-9" };
+    oc.exports = { DEFAULT_MAX_EXTGLOB_RECURSION: 0, MAX_LENGTH: 1024 * 64, POSIX_REGEX_SOURCE: Ml, REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g, REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/, REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/, REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g, REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g, REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g, REPLACEMENTS: { __proto__: null, "***": "*", "**/**": "**", "**/**/**": "**" }, CHAR_0: 48, CHAR_9: 57, CHAR_UPPERCASE_A: 65, CHAR_LOWERCASE_A: 97, CHAR_UPPERCASE_Z: 90, CHAR_LOWERCASE_Z: 122, CHAR_LEFT_PARENTHESES: 40, CHAR_RIGHT_PARENTHESES: 41, CHAR_ASTERISK: 42, CHAR_AMPERSAND: 38, CHAR_AT: 64, CHAR_BACKWARD_SLASH: 92, CHAR_CARRIAGE_RETURN: 13, CHAR_CIRCUMFLEX_ACCENT: 94, CHAR_COLON: 58, CHAR_COMMA: 44, CHAR_DOT: 46, CHAR_DOUBLE_QUOTE: 34, CHAR_EQUAL: 61, CHAR_EXCLAMATION_MARK: 33, CHAR_FORM_FEED: 12, CHAR_FORWARD_SLASH: 47, CHAR_GRAVE_ACCENT: 96, CHAR_HASH: 35, CHAR_HYPHEN_MINUS: 45, CHAR_LEFT_ANGLE_BRACKET: 60, CHAR_LEFT_CURLY_BRACE: 123, CHAR_LEFT_SQUARE_BRACKET: 91, CHAR_LINE_FEED: 10, CHAR_NO_BREAK_SPACE: 160, CHAR_PERCENT: 37, CHAR_PLUS: 43, CHAR_QUESTION_MARK: 63, CHAR_RIGHT_ANGLE_BRACKET: 62, CHAR_RIGHT_CURLY_BRACE: 125, CHAR_RIGHT_SQUARE_BRACKET: 93, CHAR_SEMICOLON: 59, CHAR_SINGLE_QUOTE: 39, CHAR_SPACE: 32, CHAR_TAB: 9, CHAR_UNDERSCORE: 95, CHAR_VERTICAL_LINE: 124, CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, extglobChars(e) {
+      return { "!": { type: "negate", open: "(?:(?!(?:", close: `))${e.STAR})` }, "?": { type: "qmark", open: "(?:", close: ")?" }, "+": { type: "plus", open: "(?:", close: ")+" }, "*": { type: "star", open: "(?:", close: ")*" }, "@": { type: "at", open: "(?:", close: ")" } };
+    }, globChars(e) {
+      return e === true ? $l : sc;
+    } };
+  });
+  var cn = D((Te) => {
+    var { REGEX_BACKSLASH: kl, REGEX_REMOVE_BACKSLASH: Dl, REGEX_SPECIAL_CHARS: Vl, REGEX_SPECIAL_CHARS_GLOBAL: jl } = on();
+    Te.isObject = (e) => e !== null && typeof e == "object" && !Array.isArray(e);
+    Te.hasRegexChars = (e) => Vl.test(e);
+    Te.isRegexChar = (e) => e.length === 1 && Te.hasRegexChars(e);
+    Te.escapeRegex = (e) => e.replace(jl, "\\$1");
+    Te.toPosixSlashes = (e) => e.replace(kl, "/");
+    Te.isWindows = () => {
+      if (typeof navigator < "u" && navigator.platform) {
+        let e = navigator.platform.toLowerCase();
+        return e === "win32" || e === "windows";
+      }
+      return typeof process < "u" && process.platform ? process.platform === "win32" : false;
+    };
+    Te.removeBackslashes = (e) => e.replace(Dl, (t) => t === "\\" ? "" : t);
+    Te.escapeLast = (e, t, n) => {
+      let r = e.lastIndexOf(t, n);
+      return r === -1 ? e : e[r - 1] === "\\" ? Te.escapeLast(e, t, r - 1) : `${e.slice(0, r)}\\${e.slice(r)}`;
+    };
+    Te.removePrefix = (e, t = {}) => {
+      let n = e;
+      return n.startsWith("./") && (n = n.slice(2), t.prefix = "./"), n;
+    };
+    Te.wrapOutput = (e, t = {}, n = {}) => {
+      let r = n.contains ? "" : "^", s = n.contains ? "" : "$", o = `${r}(?:${e})${s}`;
+      return t.negated === true && (o = `(?:^(?!${o}).*$)`), o;
+    };
+    Te.basename = (e, { windows: t } = {}) => {
+      let n = e.split(t ? /[\\/]/ : "/"), r = n[n.length - 1];
+      return r === "" ? n[n.length - 2] : r;
+    };
+  });
+  var hc = D((J0, dc) => {
+    var ic = cn(), { CHAR_ASTERISK: is, CHAR_AT: Gl, CHAR_BACKWARD_SLASH: an, CHAR_COMMA: Zl, CHAR_DOT: cs, CHAR_EXCLAMATION_MARK: as, CHAR_FORWARD_SLASH: lc, CHAR_LEFT_CURLY_BRACE: us, CHAR_LEFT_PARENTHESES: fs, CHAR_LEFT_SQUARE_BRACKET: Yl, CHAR_PLUS: Xl, CHAR_QUESTION_MARK: cc, CHAR_RIGHT_CURLY_BRACE: Fl, CHAR_RIGHT_PARENTHESES: ac, CHAR_RIGHT_SQUARE_BRACKET: Wl } = on(), uc = (e) => e === lc || e === an, fc = (e) => {
+      e.isPrefix !== true && (e.depth = e.isGlobstar ? 1 / 0 : 1);
+    }, zl = (e, t) => {
+      let n = t || {}, r = e.length - 1, s = n.parts === true || n.scanToEnd === true, o = [], i = [], c = [], a = e, l = -1, u = 0, y = 0, h = false, p = false, b = false, x = false, B = false, _ = false, A = false, w = false, S = false, q = false, k = 0, K, T, E = { value: "", depth: 0, isGlob: false }, g = () => l >= r, $ = () => a.charCodeAt(l + 1), C = () => (K = T, a.charCodeAt(++l));
+      for (;l < r; ) {
+        T = C();
+        let v;
+        if (T === an) {
+          A = E.backslashes = true, T = C(), T === us && (_ = true);
+          continue;
+        }
+        if (_ === true || T === us) {
+          for (k++;g() !== true && (T = C()); ) {
+            if (T === an) {
+              A = E.backslashes = true, C();
+              continue;
+            }
+            if (T === us) {
+              k++;
+              continue;
+            }
+            if (_ !== true && T === cs && (T = C()) === cs) {
+              if (h = E.isBrace = true, b = E.isGlob = true, q = true, s === true)
+                continue;
+              break;
+            }
+            if (_ !== true && T === Zl) {
+              if (h = E.isBrace = true, b = E.isGlob = true, q = true, s === true)
+                continue;
+              break;
+            }
+            if (T === Fl && (k--, k === 0)) {
+              _ = false, h = E.isBrace = true, q = true;
+              break;
+            }
+          }
+          if (s === true)
+            continue;
+          break;
+        }
+        if (T === lc) {
+          if (o.push(l), i.push(E), E = { value: "", depth: 0, isGlob: false }, q === true)
+            continue;
+          if (K === cs && l === u + 1) {
+            u += 2;
+            continue;
+          }
+          y = l + 1;
+          continue;
+        }
+        if (n.noext !== true && (T === Xl || T === Gl || T === is || T === cc || T === as) === true && $() === fs) {
+          if (b = E.isGlob = true, x = E.isExtglob = true, q = true, T === as && l === u && (S = true), s === true) {
+            for (;g() !== true && (T = C()); ) {
+              if (T === an) {
+                A = E.backslashes = true, T = C();
+                continue;
+              }
+              if (T === ac) {
+                b = E.isGlob = true, q = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+        if (T === is) {
+          if (K === is && (B = E.isGlobstar = true), b = E.isGlob = true, q = true, s === true)
+            continue;
+          break;
+        }
+        if (T === cc) {
+          if (b = E.isGlob = true, q = true, s === true)
+            continue;
+          break;
+        }
+        if (T === Yl) {
+          for (;g() !== true && (v = C()); ) {
+            if (v === an) {
+              A = E.backslashes = true, C();
+              continue;
+            }
+            if (v === Wl) {
+              p = E.isBracket = true, b = E.isGlob = true, q = true;
+              break;
+            }
+          }
+          if (s === true)
+            continue;
+          break;
+        }
+        if (n.nonegate !== true && T === as && l === u) {
+          w = E.negated = true, u++;
+          continue;
+        }
+        if (n.noparen !== true && T === fs) {
+          if (b = E.isGlob = true, s === true) {
+            for (;g() !== true && (T = C()); ) {
+              if (T === fs) {
+                A = E.backslashes = true, T = C();
+                continue;
+              }
+              if (T === ac) {
+                q = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+        if (b === true) {
+          if (q = true, s === true)
+            continue;
+          break;
+        }
+      }
+      n.noext === true && (x = false, b = false);
+      let m = a, f = "", d = "";
+      u > 0 && (f = a.slice(0, u), a = a.slice(u), y -= u), m && b === true && y > 0 ? (m = a.slice(0, y), d = a.slice(y)) : b === true ? (m = "", d = a) : m = a, m && m !== "" && m !== "/" && m !== a && uc(m.charCodeAt(m.length - 1)) && (m = m.slice(0, -1)), n.unescape === true && (d && (d = ic.removeBackslashes(d)), m && A === true && (m = ic.removeBackslashes(m)));
+      let R = { prefix: f, input: e, start: u, base: m, glob: d, isBrace: h, isBracket: p, isGlob: b, isExtglob: x, isGlobstar: B, negated: w, negatedExtglob: S };
+      if (n.tokens === true && (R.maxDepth = 0, uc(T) || i.push(E), R.tokens = i), n.parts === true || n.tokens === true) {
+        let v;
+        for (let O = 0;O < o.length; O++) {
+          let N = v ? v + 1 : u, L = o[O], M = e.slice(N, L);
+          n.tokens && (O === 0 && u !== 0 ? (i[O].isPrefix = true, i[O].value = f) : i[O].value = M, fc(i[O]), R.maxDepth += i[O].depth), (O !== 0 || M !== "") && c.push(M), v = L;
+        }
+        if (v && v + 1 < e.length) {
+          let O = e.slice(v + 1);
+          c.push(O), n.tokens && (i[i.length - 1].value = O, fc(i[i.length - 1]), R.maxDepth += i[i.length - 1].depth);
+        }
+        R.slashes = o, R.parts = c;
+      }
+      return R;
+    };
+    dc.exports = zl;
+  });
+  var mc = D((eh, gc) => {
+    var un = on(), Le = cn(), { MAX_LENGTH: Xn, POSIX_REGEX_SOURCE: Ql, REGEX_NON_SPECIAL_CHARS: Jl, REGEX_SPECIAL_CHARS_BACKREF: ed, REPLACEMENTS: pc } = un, td = (e, t) => {
+      if (typeof t.expandRange == "function")
+        return t.expandRange(...e, t);
+      e.sort();
+      let n = `[${e.join("-")}]`;
+      try {
+        new RegExp(n);
+      } catch {
+        return e.map((s) => Le.escapeRegex(s)).join("..");
+      }
+      return n;
+    }, jt = (e, t) => `Missing ${e}: "${t}" - use "\\\\${t}" to match literal characters`, yc = (e) => {
+      let t = [], n = 0, r = 0, s = 0, o = "", i = false;
+      for (let c of e) {
+        if (i === true) {
+          o += c, i = false;
+          continue;
+        }
+        if (c === "\\") {
+          o += c, i = true;
+          continue;
+        }
+        if (c === '"') {
+          s = s === 1 ? 0 : 1, o += c;
+          continue;
+        }
+        if (s === 0) {
+          if (c === "[")
+            n++;
+          else if (c === "]" && n > 0)
+            n--;
+          else if (n === 0) {
+            if (c === "(")
+              r++;
+            else if (c === ")" && r > 0)
+              r--;
+            else if (c === "|" && r === 0) {
+              t.push(o), o = "";
+              continue;
+            }
+          }
+        }
+        o += c;
+      }
+      return t.push(o), t;
+    }, nd = (e) => {
+      let t = false;
+      for (let n of e) {
+        if (t === true) {
+          t = false;
+          continue;
+        }
+        if (n === "\\") {
+          t = true;
+          continue;
+        }
+        if (/[?*+@!()[\]{}]/.test(n))
+          return false;
+      }
+      return true;
+    }, bc = (e) => {
+      let t = e.trim(), n = true;
+      for (;n === true; )
+        n = false, /^@\([^\\()[\]{}|]+\)$/.test(t) && (t = t.slice(2, -1), n = true);
+      if (nd(t))
+        return t.replace(/\\(.)/g, "$1");
+    }, rd = (e) => {
+      let t = e.map(bc).filter(Boolean);
+      for (let n = 0;n < t.length; n++)
+        for (let r = n + 1;r < t.length; r++) {
+          let s = t[n], o = t[r], i = s[0];
+          if (!(!i || s !== i.repeat(s.length) || o !== i.repeat(o.length)) && (s === o || s.startsWith(o) || o.startsWith(s)))
+            return true;
+        }
+      return false;
+    }, ls = (e, t = true) => {
+      if (e[0] !== "+" && e[0] !== "*" || e[1] !== "(")
+        return;
+      let n = 0, r = 0, s = 0, o = false;
+      for (let i = 1;i < e.length; i++) {
+        let c = e[i];
+        if (o === true) {
+          o = false;
+          continue;
+        }
+        if (c === "\\") {
+          o = true;
+          continue;
+        }
+        if (c === '"') {
+          s = s === 1 ? 0 : 1;
+          continue;
+        }
+        if (s !== 1) {
+          if (c === "[") {
+            n++;
+            continue;
+          }
+          if (c === "]" && n > 0) {
+            n--;
+            continue;
+          }
+          if (!(n > 0)) {
+            if (c === "(") {
+              r++;
+              continue;
+            }
+            if (c === ")" && (r--, r === 0))
+              return t === true && i !== e.length - 1 ? undefined : { type: e[0], body: e.slice(2, i), end: i };
+          }
+        }
+      }
+    }, sd = (e) => {
+      let t = 0, n = [];
+      for (;t < e.length; ) {
+        let s = ls(e.slice(t), false);
+        if (!s || s.type !== "*")
+          return;
+        let o = yc(s.body).map((c) => c.trim());
+        if (o.length !== 1)
+          return;
+        let i = bc(o[0]);
+        if (!i || i.length !== 1)
+          return;
+        n.push(i), t += s.end + 1;
+      }
+      return n.length < 1 ? undefined : `${n.length === 1 ? Le.escapeRegex(n[0]) : `[${n.map((s) => Le.escapeRegex(s)).join("")}]`}*`;
+    }, od = (e) => {
+      let t = 0, n = e.trim(), r = ls(n);
+      for (;r; )
+        t++, n = r.body.trim(), r = ls(n);
+      return t;
+    }, id = (e, t) => {
+      if (t.maxExtglobRecursion === false)
+        return { risky: false };
+      let n = typeof t.maxExtglobRecursion == "number" ? t.maxExtglobRecursion : un.DEFAULT_MAX_EXTGLOB_RECURSION, r = yc(e).map((s) => s.trim());
+      if (r.length > 1 && (r.some((s) => s === "") || r.some((s) => /^[*?]+$/.test(s)) || rd(r)))
+        return { risky: true };
+      for (let s of r) {
+        let o = sd(s);
+        if (o)
+          return { risky: true, safeOutput: o };
+        if (od(s) > n)
+          return { risky: true };
+      }
+      return { risky: false };
+    }, ds = (e, t) => {
+      if (typeof e != "string")
+        throw new TypeError("Expected a string");
+      e = pc[e] || e;
+      let n = { ...t }, r = typeof n.maxLength == "number" ? Math.min(Xn, n.maxLength) : Xn, s = e.length;
+      if (s > r)
+        throw new SyntaxError(`Input length: ${s}, exceeds maximum allowed length: ${r}`);
+      let o = { type: "bos", value: "", output: n.prepend || "" }, i = [o], c = n.capture ? "" : "?:", a = un.globChars(n.windows), l = un.extglobChars(a), { DOT_LITERAL: u, PLUS_LITERAL: y, SLASH_LITERAL: h, ONE_CHAR: p, DOTS_SLASH: b, NO_DOT: x, NO_DOT_SLASH: B, NO_DOTS_SLASH: _, QMARK: A, QMARK_NO_DOT: w, STAR: S, START_ANCHOR: q } = a, k = (I) => `(${c}(?:(?!${q}${I.dot ? b : u}).)*?)`, K = n.dot ? "" : x, T = n.dot ? A : w, E = n.bash === true ? k(n) : S;
+      n.capture && (E = `(${E})`), typeof n.noext == "boolean" && (n.noextglob = n.noext);
+      let g = { input: e, index: -1, start: 0, dot: n.dot === true, consumed: "", output: "", prefix: "", backtrack: false, negated: false, brackets: 0, braces: 0, parens: 0, quotes: 0, globstar: false, tokens: i };
+      e = Le.removePrefix(e, g), s = e.length;
+      let $ = [], C = [], m = [], f = o, d, R = () => g.index === s - 1, v = g.peek = (I = 1) => e[g.index + I], O = g.advance = () => e[++g.index] || "", N = () => e.slice(g.index + 1), L = (I = "", Z = 0) => {
+        g.consumed += I, g.index += Z;
+      }, M = (I) => {
+        g.output += I.output != null ? I.output : I.value, L(I.value);
+      }, X = () => {
+        let I = 1;
+        for (;v() === "!" && (v(2) !== "(" || v(3) === "?"); )
+          O(), g.start++, I++;
+        return I % 2 === 0 ? false : (g.negated = true, g.start++, true);
+      }, se = (I) => {
+        g[I]++, m.push(I);
+      }, ee = (I) => {
+        g[I]--, m.pop();
+      }, P = (I) => {
+        if (f.type === "globstar") {
+          let Z = g.braces > 0 && (I.type === "comma" || I.type === "brace"), H = I.extglob === true || $.length && (I.type === "pipe" || I.type === "paren");
+          I.type !== "slash" && I.type !== "paren" && !Z && !H && (g.output = g.output.slice(0, -f.output.length), f.type = "star", f.value = "*", f.output = E, g.output += f.output);
+        }
+        if ($.length && I.type !== "paren" && ($[$.length - 1].inner += I.value), (I.value || I.output) && M(I), f && f.type === "text" && I.type === "text") {
+          f.output = (f.output || f.value) + I.value, f.value += I.value;
+          return;
+        }
+        I.prev = f, i.push(I), f = I;
+      }, oe = (I, Z) => {
+        let H = { ...l[Z], conditions: 1, inner: "" };
+        H.prev = f, H.parens = g.parens, H.output = g.output, H.startIndex = g.index, H.tokensIndex = i.length;
+        let W = (n.capture ? "(" : "") + H.open;
+        se("parens"), P({ type: I, value: Z, output: g.output ? "" : p }), P({ type: "paren", extglob: true, value: O(), output: W }), $.push(H);
+      }, ue = (I) => {
+        let Z = e.slice(I.startIndex, g.index + 1), H = e.slice(I.startIndex + 2, g.index), W = id(H, n);
+        if ((I.type === "plus" || I.type === "star") && W.risky) {
+          let ce = W.safeOutput ? (I.output ? "" : p) + (n.capture ? `(${W.safeOutput})` : W.safeOutput) : undefined, Oe = i[I.tokensIndex];
+          Oe.type = "text", Oe.value = Z, Oe.output = ce || Le.escapeRegex(Z);
+          for (let Ke = I.tokensIndex + 1;Ke < i.length; Ke++)
+            i[Ke].value = "", i[Ke].output = "", delete i[Ke].suffix;
+          g.output = I.output + Oe.output, g.backtrack = true, P({ type: "paren", extglob: true, value: d, output: "" }), ee("parens");
+          return;
+        }
+        let ie = I.close + (n.capture ? ")" : ""), fe;
+        if (I.type === "negate") {
+          let ce = E;
+          if (I.inner && I.inner.length > 1 && I.inner.includes("/") && (ce = k(n)), (ce !== E || R() || /^\)+$/.test(N())) && (ie = I.close = `)$))${ce}`), I.inner.includes("*") && (fe = N()) && /^\.[^\\/.]+$/.test(fe)) {
+            let Oe = ds(fe, { ...t, fastpaths: false }).output;
+            ie = I.close = `)${Oe})${ce})`;
+          }
+          I.prev.type === "bos" && (g.negatedExtglob = true);
+        }
+        P({ type: "paren", extglob: true, value: d, output: ie }), ee("parens");
+      };
+      if (n.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(e)) {
+        let I = false, Z = e.replace(ed, (H, W, ie, fe, ce, Oe) => fe === "\\" ? (I = true, H) : fe === "?" ? W ? W + fe + (ce ? A.repeat(ce.length) : "") : Oe === 0 ? T + (ce ? A.repeat(ce.length) : "") : A.repeat(ie.length) : fe === "." ? u.repeat(ie.length) : fe === "*" ? W ? W + fe + (ce ? E : "") : E : W ? H : `\\${H}`);
+        return I === true && (n.unescape === true ? Z = Z.replace(/\\/g, "") : Z = Z.replace(/\\+/g, (H) => H.length % 2 === 0 ? "\\\\" : H ? "\\" : "")), Z === e && n.contains === true ? (g.output = e, g) : (g.output = Le.wrapOutput(Z, g, t), g);
+      }
+      for (;!R(); ) {
+        if (d = O(), d === "\x00")
+          continue;
+        if (d === "\\") {
+          let H = v();
+          if (H === "/" && n.bash !== true || H === "." || H === ";")
+            continue;
+          if (!H) {
+            d += "\\", P({ type: "text", value: d });
+            continue;
+          }
+          let W = /^\\+/.exec(N()), ie = 0;
+          if (W && W[0].length > 2 && (ie = W[0].length, g.index += ie, ie % 2 !== 0 && (d += "\\")), n.unescape === true ? d = O() : d += O(), g.brackets === 0) {
+            P({ type: "text", value: d });
+            continue;
+          }
+        }
+        if (g.brackets > 0 && (d !== "]" || f.value === "[" || f.value === "[^")) {
+          if (n.posix !== false && d === ":") {
+            let H = f.value.slice(1);
+            if (H.includes("[") && (f.posix = true, H.includes(":"))) {
+              let W = f.value.lastIndexOf("["), ie = f.value.slice(0, W), fe = f.value.slice(W + 2), ce = Ql[fe];
+              if (ce) {
+                f.value = ie + ce, g.backtrack = true, O(), !o.output && i.indexOf(f) === 1 && (o.output = p);
+                continue;
+              }
+            }
+          }
+          (d === "[" && v() !== ":" || d === "-" && v() === "]") && (d = `\\${d}`), d === "]" && (f.value === "[" || f.value === "[^") && (d = `\\${d}`), n.posix === true && d === "!" && f.value === "[" && (d = "^"), f.value += d, M({ value: d });
+          continue;
+        }
+        if (g.quotes === 1 && d !== '"') {
+          d = Le.escapeRegex(d), f.value += d, M({ value: d });
+          continue;
+        }
+        if (d === '"') {
+          g.quotes = g.quotes === 1 ? 0 : 1, n.keepQuotes === true && P({ type: "text", value: d });
+          continue;
+        }
+        if (d === "(") {
+          se("parens"), P({ type: "paren", value: d });
+          continue;
+        }
+        if (d === ")") {
+          if (g.parens === 0 && n.strictBrackets === true)
+            throw new SyntaxError(jt("opening", "("));
+          let H = $[$.length - 1];
+          if (H && g.parens === H.parens + 1) {
+            ue($.pop());
+            continue;
+          }
+          P({ type: "paren", value: d, output: g.parens ? ")" : "\\)" }), ee("parens");
+          continue;
+        }
+        if (d === "[") {
+          if (n.nobracket === true || !N().includes("]")) {
+            if (n.nobracket !== true && n.strictBrackets === true)
+              throw new SyntaxError(jt("closing", "]"));
+            d = `\\${d}`;
+          } else
+            se("brackets");
+          P({ type: "bracket", value: d });
+          continue;
+        }
+        if (d === "]") {
+          if (n.nobracket === true || f && f.type === "bracket" && f.value.length === 1) {
+            P({ type: "text", value: d, output: `\\${d}` });
+            continue;
+          }
+          if (g.brackets === 0) {
+            if (n.strictBrackets === true)
+              throw new SyntaxError(jt("opening", "["));
+            P({ type: "text", value: d, output: `\\${d}` });
+            continue;
+          }
+          ee("brackets");
+          let H = f.value.slice(1);
+          if (f.posix !== true && H[0] === "^" && !H.includes("/") && (d = `/${d}`), f.value += d, M({ value: d }), n.literalBrackets === false || Le.hasRegexChars(H))
+            continue;
+          let W = Le.escapeRegex(f.value);
+          if (g.output = g.output.slice(0, -f.value.length), n.literalBrackets === true) {
+            g.output += W, f.value = W;
+            continue;
+          }
+          f.value = `(${c}${W}|${f.value})`, g.output += f.value;
+          continue;
+        }
+        if (d === "{" && n.nobrace !== true) {
+          se("braces");
+          let H = { type: "brace", value: d, output: "(", outputIndex: g.output.length, tokensIndex: g.tokens.length };
+          C.push(H), P(H);
+          continue;
+        }
+        if (d === "}") {
+          let H = C[C.length - 1];
+          if (n.nobrace === true || !H) {
+            P({ type: "text", value: d, output: d });
+            continue;
+          }
+          let W = ")";
+          if (H.dots === true) {
+            let ie = i.slice(), fe = [];
+            for (let ce = ie.length - 1;ce >= 0 && (i.pop(), ie[ce].type !== "brace"); ce--)
+              ie[ce].type !== "dots" && fe.unshift(ie[ce].value);
+            W = td(fe, n), g.backtrack = true;
+          }
+          if (H.comma !== true && H.dots !== true) {
+            let ie = g.output.slice(0, H.outputIndex), fe = g.tokens.slice(H.tokensIndex);
+            H.value = H.output = "\\{", d = W = "\\}", g.output = ie;
+            for (let ce of fe)
+              g.output += ce.output || ce.value;
+          }
+          P({ type: "brace", value: d, output: W }), ee("braces"), C.pop();
+          continue;
+        }
+        if (d === "|") {
+          $.length > 0 && $[$.length - 1].conditions++, P({ type: "text", value: d });
+          continue;
+        }
+        if (d === ",") {
+          let H = d, W = C[C.length - 1];
+          W && m[m.length - 1] === "braces" && (W.comma = true, H = "|"), P({ type: "comma", value: d, output: H });
+          continue;
+        }
+        if (d === "/") {
+          if (f.type === "dot" && g.index === g.start + 1) {
+            g.start = g.index + 1, g.consumed = "", g.output = "", i.pop(), f = o;
+            continue;
+          }
+          P({ type: "slash", value: d, output: h });
+          continue;
+        }
+        if (d === ".") {
+          if (g.braces > 0 && f.type === "dot") {
+            f.value === "." && (f.output = u);
+            let H = C[C.length - 1];
+            f.type = "dots", f.output += d, f.value += d, H.dots = true;
+            continue;
+          }
+          if (g.braces + g.parens === 0 && f.type !== "bos" && f.type !== "slash") {
+            P({ type: "text", value: d, output: u });
+            continue;
+          }
+          P({ type: "dot", value: d, output: u });
+          continue;
+        }
+        if (d === "?") {
+          if (!(f && f.value === "(") && n.noextglob !== true && v() === "(" && v(2) !== "?") {
+            oe("qmark", d);
+            continue;
+          }
+          if (f && f.type === "paren") {
+            let W = v(), ie = d;
+            (f.value === "(" && !/[!=<:]/.test(W) || W === "<" && !/<([!=]|\w+>)/.test(N())) && (ie = `\\${d}`), P({ type: "text", value: d, output: ie });
+            continue;
+          }
+          if (n.dot !== true && (f.type === "slash" || f.type === "bos")) {
+            P({ type: "qmark", value: d, output: w });
+            continue;
+          }
+          P({ type: "qmark", value: d, output: A });
+          continue;
+        }
+        if (d === "!") {
+          if (n.noextglob !== true && v() === "(" && (v(2) !== "?" || !/[!=<:]/.test(v(3)))) {
+            oe("negate", d);
+            continue;
+          }
+          if (n.nonegate !== true && g.index === 0) {
+            X();
+            continue;
+          }
+        }
+        if (d === "+") {
+          if (n.noextglob !== true && v() === "(" && v(2) !== "?") {
+            oe("plus", d);
+            continue;
+          }
+          if (f && f.value === "(" || n.regex === false) {
+            P({ type: "plus", value: d, output: y });
+            continue;
+          }
+          if (f && (f.type === "bracket" || f.type === "paren" || f.type === "brace") || g.parens > 0) {
+            P({ type: "plus", value: d });
+            continue;
+          }
+          P({ type: "plus", value: y });
+          continue;
+        }
+        if (d === "@") {
+          if (n.noextglob !== true && v() === "(" && v(2) !== "?") {
+            P({ type: "at", extglob: true, value: d, output: "" });
+            continue;
+          }
+          P({ type: "text", value: d });
+          continue;
+        }
+        if (d !== "*") {
+          (d === "$" || d === "^") && (d = `\\${d}`);
+          let H = Jl.exec(N());
+          H && (d += H[0], g.index += H[0].length), P({ type: "text", value: d });
+          continue;
+        }
+        if (f && (f.type === "globstar" || f.star === true)) {
+          f.type = "star", f.star = true, f.value += d, f.output = E, g.backtrack = true, g.globstar = true, L(d);
+          continue;
+        }
+        let I = N();
+        if (n.noextglob !== true && /^\([^?]/.test(I)) {
+          oe("star", d);
+          continue;
+        }
+        if (f.type === "star") {
+          if (n.noglobstar === true) {
+            L(d);
+            continue;
+          }
+          let H = f.prev, W = H.prev, ie = H.type === "slash" || H.type === "bos", fe = W && (W.type === "star" || W.type === "globstar");
+          if (n.bash === true && (!ie || I[0] && I[0] !== "/")) {
+            P({ type: "star", value: d, output: "" });
+            continue;
+          }
+          let ce = g.braces > 0 && (H.type === "comma" || H.type === "brace"), Oe = $.length && (H.type === "pipe" || H.type === "paren");
+          if (!ie && H.type !== "paren" && !ce && !Oe) {
+            P({ type: "star", value: d, output: "" });
+            continue;
+          }
+          for (;I.slice(0, 3) === "/**"; ) {
+            let Ke = e[g.index + 4];
+            if (Ke && Ke !== "/")
+              break;
+            I = I.slice(3), L("/**", 3);
+          }
+          if (H.type === "bos" && R()) {
+            f.type = "globstar", f.value += d, f.output = k(n), g.output = f.output, g.globstar = true, L(d);
+            continue;
+          }
+          if (H.type === "slash" && H.prev.type !== "bos" && !fe && R()) {
+            g.output = g.output.slice(0, -(H.output + f.output).length), H.output = `(?:${H.output}`, f.type = "globstar", f.output = k(n) + (n.strictSlashes ? ")" : "|$)"), f.value += d, g.globstar = true, g.output += H.output + f.output, L(d);
+            continue;
+          }
+          if (H.type === "slash" && H.prev.type !== "bos" && I[0] === "/") {
+            let Ke = I[1] !== undefined ? "|$" : "";
+            g.output = g.output.slice(0, -(H.output + f.output).length), H.output = `(?:${H.output}`, f.type = "globstar", f.output = `${k(n)}${h}|${h}${Ke})`, f.value += d, g.output += H.output + f.output, g.globstar = true, L(d + O()), P({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          if (H.type === "bos" && I[0] === "/") {
+            f.type = "globstar", f.value += d, f.output = `(?:^|${h}|${k(n)}${h})`, g.output = f.output, g.globstar = true, L(d + O()), P({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          g.output = g.output.slice(0, -f.output.length), f.type = "globstar", f.output = k(n), f.value += d, g.output += f.output, g.globstar = true, L(d);
+          continue;
+        }
+        let Z = { type: "star", value: d, output: E };
+        if (n.bash === true) {
+          Z.output = ".*?", (f.type === "bos" || f.type === "slash") && (Z.output = K + Z.output), P(Z);
+          continue;
+        }
+        if (f && (f.type === "bracket" || f.type === "paren") && n.regex === true) {
+          Z.output = d, P(Z);
+          continue;
+        }
+        (g.index === g.start || f.type === "slash" || f.type === "dot") && (f.type === "dot" ? (g.output += B, f.output += B) : n.dot === true ? (g.output += _, f.output += _) : (g.output += K, f.output += K), v() !== "*" && (g.output += p, f.output += p)), P(Z);
+      }
+      for (;g.brackets > 0; ) {
+        if (n.strictBrackets === true)
+          throw new SyntaxError(jt("closing", "]"));
+        g.output = Le.escapeLast(g.output, "["), ee("brackets");
+      }
+      for (;g.parens > 0; ) {
+        if (n.strictBrackets === true)
+          throw new SyntaxError(jt("closing", ")"));
+        g.output = Le.escapeLast(g.output, "("), ee("parens");
+      }
+      for (;g.braces > 0; ) {
+        if (n.strictBrackets === true)
+          throw new SyntaxError(jt("closing", "}"));
+        g.output = Le.escapeLast(g.output, "{"), ee("braces");
+      }
+      if (n.strictSlashes !== true && (f.type === "star" || f.type === "bracket") && P({ type: "maybe_slash", value: "", output: `${h}?` }), g.backtrack === true) {
+        g.output = "";
+        for (let I of g.tokens)
+          g.output += I.output != null ? I.output : I.value, I.suffix && (g.output += I.suffix);
+      }
+      return g;
+    };
+    ds.fastpaths = (e, t) => {
+      let n = { ...t }, r = typeof n.maxLength == "number" ? Math.min(Xn, n.maxLength) : Xn, s = e.length;
+      if (s > r)
+        throw new SyntaxError(`Input length: ${s}, exceeds maximum allowed length: ${r}`);
+      e = pc[e] || e;
+      let { DOT_LITERAL: o, SLASH_LITERAL: i, ONE_CHAR: c, DOTS_SLASH: a, NO_DOT: l, NO_DOTS: u, NO_DOTS_SLASH: y, STAR: h, START_ANCHOR: p } = un.globChars(n.windows), b = n.dot ? u : l, x = n.dot ? y : l, B = n.capture ? "" : "?:", _ = { negated: false, prefix: "" }, A = n.bash === true ? ".*?" : h;
+      n.capture && (A = `(${A})`);
+      let w = (K) => K.noglobstar === true ? A : `(${B}(?:(?!${p}${K.dot ? a : o}).)*?)`, S = (K) => {
+        switch (K) {
+          case "*":
+            return `${b}${c}${A}`;
+          case ".*":
+            return `${o}${c}${A}`;
+          case "*.*":
+            return `${b}${A}${o}${c}${A}`;
+          case "*/*":
+            return `${b}${A}${i}${c}${x}${A}`;
+          case "**":
+            return b + w(n);
+          case "**/*":
+            return `(?:${b}${w(n)}${i})?${x}${c}${A}`;
+          case "**/*.*":
+            return `(?:${b}${w(n)}${i})?${x}${A}${o}${c}${A}`;
+          case "**/.*":
+            return `(?:${b}${w(n)}${i})?${o}${c}${A}`;
+          default: {
+            let T = /^(.*?)\.(\w+)$/.exec(K);
+            if (!T)
+              return;
+            let E = S(T[1]);
+            return E ? E + o + T[2] : undefined;
+          }
+        }
+      }, q = Le.removePrefix(e, _), k = S(q);
+      return k && n.strictSlashes !== true && (k += `${i}?`), k;
+    };
+    gc.exports = ds;
+  });
+  var Ec = D((th, xc) => {
+    var cd = hc(), hs = mc(), _c = cn(), ad = on(), ud = (e) => e && typeof e == "object" && !Array.isArray(e), he = (e, t, n = false) => {
+      if (Array.isArray(e)) {
+        let u = e.map((h) => he(h, t, n));
+        return (h) => {
+          for (let p of u) {
+            let b = p(h);
+            if (b)
+              return b;
+          }
+          return false;
+        };
+      }
+      let r = ud(e) && e.tokens && e.input;
+      if (e === "" || typeof e != "string" && !r)
+        throw new TypeError("Expected pattern to be a non-empty string");
+      let s = t || {}, o = s.windows, i = r ? he.compileRe(e, t) : he.makeRe(e, t, false, true), c = i.state;
+      delete i.state;
+      let a = () => false;
+      if (s.ignore) {
+        let u = { ...t, ignore: null, onMatch: null, onResult: null };
+        a = he(s.ignore, u, n);
+      }
+      let l = (u, y = false) => {
+        let { isMatch: h, match: p, output: b } = he.test(u, i, t, { glob: e, posix: o }), x = { glob: e, state: c, regex: i, posix: o, input: u, output: b, match: p, isMatch: h };
+        return typeof s.onResult == "function" && s.onResult(x), h === false ? (x.isMatch = false, y ? x : false) : a(u) ? (typeof s.onIgnore == "function" && s.onIgnore(x), x.isMatch = false, y ? x : false) : (typeof s.onMatch == "function" && s.onMatch(x), y ? x : true);
+      };
+      return n && (l.state = c), l;
+    };
+    he.test = (e, t, n, { glob: r, posix: s } = {}) => {
+      if (typeof e != "string")
+        throw new TypeError("Expected input to be a string");
+      if (e === "")
+        return { isMatch: false, output: "" };
+      let o = n || {}, i = o.format || (s ? _c.toPosixSlashes : null), c = e === r, a = c && i ? i(e) : e;
+      return c === false && (a = i ? i(e) : e, c = a === r), (c === false || o.capture === true) && (o.matchBase === true || o.basename === true ? c = he.matchBase(e, t, n, s) : c = t.exec(a)), { isMatch: !!c, match: c, output: a };
+    };
+    he.matchBase = (e, t, n) => (t instanceof RegExp ? t : he.makeRe(t, n)).test(_c.basename(e));
+    he.isMatch = (e, t, n) => he(t, n)(e);
+    he.parse = (e, t) => Array.isArray(e) ? e.map((n) => he.parse(n, t)) : hs(e, { ...t, fastpaths: false });
+    he.scan = (e, t) => cd(e, t);
+    he.compileRe = (e, t, n = false, r = false) => {
+      if (n === true)
+        return e.output;
+      let s = t || {}, o = s.contains ? "" : "^", i = s.contains ? "" : "$", c = `${o}(?:${e.output})${i}`;
+      e && e.negated === true && (c = `^(?!${c}).*$`);
+      let a = he.toRegex(c, t);
+      return r === true && (a.state = e), a;
+    };
+    he.makeRe = (e, t = {}, n = false, r = false) => {
+      if (!e || typeof e != "string")
+        throw new TypeError("Expected a non-empty string");
+      let s = { negated: false, fastpaths: true };
+      return t.fastpaths !== false && (e[0] === "." || e[0] === "*") && (s.output = hs.fastpaths(e, t)), s.output || (s = hs(e, t)), he.compileRe(s, t, n, r);
+    };
+    he.toRegex = (e, t) => {
+      try {
+        let n = t || {};
+        return new RegExp(e, n.flags || (n.nocase ? "i" : ""));
+      } catch (n) {
+        if (t && t.debug === true)
+          throw n;
+        return /$^/;
+      }
+    };
+    he.constants = ad;
+    xc.exports = he;
+  });
+  var Sc = D((nh, Ac) => {
+    var wc = Ec(), fd = cn();
+    function Bc(e, t, n = false) {
+      return t && (t.windows === null || t.windows === undefined) && (t = { ...t, windows: fd.isWindows() }), wc(e, t, n);
+    }
+    Object.assign(Bc, wc);
+    Ac.exports = Bc;
+  });
+  var Fn = D((rh, vc) => {
+    var ld = Sc();
+    function dd(e, t) {
+      return ld(e, t);
+    }
+    vc.exports = dd;
+  });
+  var At = D((sh, Ic) => {
+    var Rc = Fn();
+    function Hc(e) {
+      return e == null ? [] : Array.isArray(e) ? e : [e];
+    }
+    function ps(e) {
+      return (e || "").trim();
+    }
+    function hd(e) {
+      let n = ps(e)[0], r = "";
+      switch (n) {
+        case "'":
+          r = "'";
+          break;
+        case '"':
+          r = '"';
+          break;
+        case "`":
+          r = "`";
+          break;
+        default:
+          r = "";
+      }
+      return r;
+    }
+    function pd(e, t, n) {
+      let r = ps(e);
+      return r = r.replace(/^(['"`])([\s\S]*)\1$/mg, "$2"), t === "'" && (r = r.replace(/\\'/g, "'")), t === '"' && n.expandDoubleQuotedNewlines !== false && (r = r.replace(/\\n/g, `
+`), r = r.replace(/\\r/g, "\r"), r = r.replace(/\\t/g, "\t")), r;
+    }
+    function yd(e, t = {}, n) {
+      typeof t == "function" && (n = t, t = {});
+      let r = Hc(t.ik), s = Hc(t.ek), o = Rc(r, { ignore: s }), i = Rc(s), c = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#(.*))?(?:$|$)/mg, a = {}, l = {}, u = (e || "").toString();
+      t.convertWindowsNewlines !== false && (u = u.replace(/\r\n?/mg, `
+`));
+      let y;
+      for (;(y = c.exec(u)) !== null; ) {
+        let h = y[1];
+        if (i(h) || r.length > 0 && !o(h))
+          continue;
+        let p = y[2], b = hd(p), x = pd(p, b, t), B = y[3] === undefined ? undefined : ps(y[3]), _ = x;
+        typeof n == "function" && (_ = n({ name: h, value: x, quote: b, comment: B })), a[h] = a[h] || [], a[h].push(_), l[h] = l[h] || [], l[h].push(B);
+      }
+      return { parsed: a, comments: l };
+    }
+    Ic.exports = yd;
+  });
+  var fn = D((oh, ys) => {
+    var Tc = __require("fs"), Oc = Yn(), Cc = At();
+    async function bd(e = ".env.keys") {
+      try {
+        let t = await Tc.promises.readFile(e, "utf8"), { parsed: n } = Cc(t), r = [];
+        for (let s in n)
+          if (s.startsWith("DOTENV_PRIVATE_KEY")) {
+            let o = n[s];
+            for (let i of o) {
+              let c = i.split(",");
+              for (let a of c)
+                r.push(a);
+            }
+          }
+        return r;
+      } catch {
+        return [];
+      }
+    }
+    function gd(e = ".env.keys") {
+      try {
+        let t = Tc.readFileSync(e, "utf8"), { parsed: n } = Cc(t), r = [];
+        for (let s in n)
+          if (s.startsWith("DOTENV_PRIVATE_KEY")) {
+            let o = n[s];
+            for (let i of o) {
+              let c = i.split(",");
+              for (let a of c)
+                r.push(a);
+            }
+          }
+        return r;
+      } catch {
+        return [];
+      }
+    }
+    async function md(e = {}) {
+      let t = e.ring || {}, n = e.provider, r = e.processEnv || process.env, s = Array.isArray(e.fk) ? e.fk : [e.fk || ".env.keys"], o = [];
+      for (let i of s)
+        o.push(...await bd(i));
+      for (let i in r) {
+        if (i.startsWith("DOTENV_PUBLIC_KEY")) {
+          let c = r[i];
+          t[c] ||= "";
+        }
+        i.startsWith("DOTENV_PRIVATE_KEY") && o.push(r[i]);
+      }
+      for (let i of o)
+        try {
+          let c = Oc(i);
+          t[c] = i;
+        } catch {}
+      if (typeof n == "function")
+        for (let i in t) {
+          if (t[i])
+            continue;
+          let c = await n(i);
+          for (let a in c || {}) {
+            let l = c[a];
+            l && (t[a] = l);
+          }
+        }
+      return t;
+    }
+    function _d(e = {}) {
+      let t = e.ring || {}, n = e.provider, r = e.processEnv || process.env, o = (Array.isArray(e.fk) ? e.fk : [e.fk || ".env.keys"]).reduce((i, c) => i.concat(gd(c)), []);
+      for (let i in r) {
+        if (i.startsWith("DOTENV_PUBLIC_KEY")) {
+          let c = r[i];
+          t[c] ||= "";
+        }
+        i.startsWith("DOTENV_PRIVATE_KEY") && o.push(r[i]);
+      }
+      for (let i of o)
+        try {
+          let c = Oc(i);
+          t[c] = i;
+        } catch {}
+      if (typeof n == "function")
+        for (let i in t) {
+          if (t[i])
+            continue;
+          let c = n(i);
+          for (let a in c || {}) {
+            let l = c[a];
+            l && (t[a] = l);
+          }
+        }
+      return t;
+    }
+    ys.exports = md;
+    ys.exports.sync = _d;
+  });
+  var bs = D((ih, Lc) => {
+    var xd = At();
+    function Ed(e) {
+      let { parsed: t } = xd(e), n = [];
+      for (let r in t)
+        r.startsWith("DOTENV_PUBLIC_KEY") && n.push(t[r][t[r].length - 1]);
+      return n;
+    }
+    Lc.exports = Ed;
+  });
+  var ms = D((ch, gs) => {
+    var qc = ts(), wd = Zn(), Bd = fn(), Ad = fn().sync, Wn = Vt(), Sd = ns(), vd = rs(), Nc = Fn(), Rd = bs(), Hd = At();
+    function Pc(e) {
+      return e == null ? [] : Array.isArray(e) ? e : [e];
+    }
+    function Id(e) {
+      return e.replace(/\\\$/g, "$");
+    }
+    function Td(e, t, n) {
+      let r = {};
+      for (let s of n) {
+        let o = e[s];
+        if (o) {
+          r[o] = true;
+          try {
+            return qc(o, t);
+          } catch {}
+        }
+      }
+      for (let s of Object.values(e))
+        if (!(!s || r[s]))
+          try {
+            return qc(s, t);
+          } catch {}
+      return t;
+    }
+    function Od(e) {
+      let t = Object.keys(e);
+      if (t.length === 0)
+        return null;
+      let n = new wd({ message: `could not decrypt ${t.join(", ")}` }).decryptionFailed();
+      return { code: n.code, message: n.message };
+    }
+    async function Cd(e, t = {}) {
+      let { overload: n, array: r, ik: s, ek: o, processEnv: i, fk: c, provider: a, publicKeyHexes: l, ring: u } = Uc(e, t), y = await Bd({ processEnv: i, ring: u, fk: c, provider: a });
+      return Kc(e, { overload: n, array: r, ik: s, ek: o, processEnv: i, ring: y, publicKeyHexes: l });
+    }
+    function Ld(e, t = {}) {
+      let { overload: n, array: r, ik: s, ek: o, processEnv: i, fk: c, provider: a, publicKeyHexes: l, ring: u } = Uc(e, t), y = Ad({ processEnv: i, ring: u, fk: c, provider: a });
+      return Kc(e, { overload: n, array: r, ik: s, ek: o, processEnv: i, ring: y, publicKeyHexes: l });
+    }
+    function Uc(e, t = {}) {
+      let { overload: n, array: r } = t, s = Pc(t.ik), o = Pc(t.ek), i = t.processEnv || process.env, c = t.fk, a = t.provider, l = Rd(e), u = {};
+      for (let y of l)
+        u[y] = "";
+      return { overload: n, array: r, ik: s, ek: o, processEnv: i, fk: c, provider: a, publicKeyHexes: l, ring: u };
+    }
+    function Kc(e, t = {}) {
+      let { overload: n, array: r } = t, s = t.ik || [], o = t.ek || [], i = t.processEnv || process.env, c = t.ring || {}, a = t.publicKeyHexes || [], l = Nc(s, { ignore: o }), u = Nc(o);
+      function y(S) {
+        return Object.prototype.hasOwnProperty.call(i, S);
+      }
+      let h = {}, p = {}, b = {}, x = {}, B = {}, _ = {};
+      Hd(e, ({ name: S, value: q, quote: k }) => {
+        let K = q;
+        !n && y(S) && (K = i[S]);
+        let T = Wn(K);
+        !u(S) && (s.length === 0 || l(S)) && (K = Td(c, K, a), T && Wn(K) && (_[S] = true));
+        let E = Wn(K), g = false;
+        if (!E && k !== "'" && (!y(S) || i[S] === K)) {
+          let m = K;
+          try {
+            K = Sd(m, { processEnv: i, runningParsed: h });
+          } catch {}
+          m !== K && (g = true);
+        }
+        !E && !g && k !== "'" && (!i[S] || n) && (K = Id(vd(K, { overload: n, processEnv: i, runningParsed: h, literals: p }))), k === "'" && (p[S] = K), h[S] = K, r ? (b[S] = b[S] || [], b[S].push(K)) : b[S] = K;
+        let $ = Object.prototype.hasOwnProperty.call(i, S) && !n, C = $ && T && !Wn(K);
+        return $ && !C ? r ? (B[S] = B[S] || [], B[S].push(i[S])) : B[S] = i[S] : r ? (x[S] = x[S] || [], x[S].push(K)) : x[S] = b[S], K;
+      });
+      let A = [], w = Od(_);
+      return w && A.push(w), { parsed: b, injected: x, existed: B, errors: A };
+    }
+    gs.exports = Cd;
+    gs.exports.sync = Ld;
+  });
+  var kc = D((ah, Mc) => {
+    function qd(e) {
+      let t = e.trimStart();
+      t.startsWith("export ") && (t = t.slice(7).trimStart());
+      let n = t.indexOf("="), r = t.indexOf(": ");
+      if ((n === -1 || r !== -1 && r < n) && (n = r), n === -1)
+        return null;
+      let s = t.slice(0, n).trim();
+      if (!s || !/^[\w.-]+$/.test(s))
+        return null;
+      let o = t.slice(n).startsWith(": ") ? 2 : 1;
+      return { name: s, raw: t.slice(n + o) };
+    }
+    function $c(e, t) {
+      let n = false, r = 0;
+      for (let s of e)
+        s === t && !n && (r += 1), n = s === "\\" && !n, s !== "\\" && (n = false);
+      return r >= 2;
+    }
+    function Nd(e, t) {
+      e == null && (e = ""), e = e.toString();
+      let n = e.includes(`\r
+`) ? `\r
+` : `
+`, r = e.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`), s = r.endsWith(`
+`), o = r.split(`
+`);
+      s && o.pop();
+      let i = [], c = 0, a = false;
+      for (;c < o.length; ) {
+        let u = o[c], y = qd(u);
+        if (!y || y.name !== t) {
+          i.push(u), c += 1;
+          continue;
+        }
+        a = true;
+        let h = y.raw, p = h.trimStart(), b = p[0] && "'\"`".includes(p[0]) ? p[0] : "";
+        if (b && !$c(p, b))
+          for (c += 1;c < o.length && (h += `
+` + o[c], !$c(h.trimStart(), b)); )
+            c += 1;
+        c += 1;
+      }
+      if (!a)
+        return e;
+      let l = i.join(`
+`);
+      return s && l.length > 0 && (l += `
+`), n === `\r
+` && (l = l.replace(/\n/g, `\r
+`)), l;
+    }
+    Mc.exports = Nd;
+  });
+  var Vc = D((uh, Dc) => {
+    var Pd = Vt(), Ud = At();
+    function Kd(e) {
+      return e.startsWith("DOTENV_PUBLIC_KEY");
+    }
+    function $d(e) {
+      return e.endsWith("_PLAIN");
+    }
+    function Md(e) {
+      let { parsed: t } = Ud(e);
+      for (let [n, r] of Object.entries(t))
+        if (!(Kd(n) || $d(n))) {
+          for (let s of r)
+            if (!Pd(s))
+              return false;
+        }
+      return true;
+    }
+    Dc.exports = Md;
+  });
+  var Zc = D((fh, Gc) => {
+    var kd = At();
+    function jc(e) {
+      return e.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+    }
+    function Dd(e, t, n, r) {
+      let s = jc(t), o = jc(n), i = "";
+      o === "" && (i = "$");
+      let c = new RegExp("^(\\s*)?(export\\s+)?" + s + "\\s*=\\s*([\"'`]?)" + o + "\\3" + i, "m");
+      return e.replace(c, function(a, l = "", u = "", y = "") {
+        let h = `${t}=${y}${r}${y}`, p = e.match(new RegExp(`${s}\\s*=\\s*
+
+`, "m"));
+        if (o === "" && y === "" && p) {
+          let b = p[0].match(/\n/g).length - 1;
+          for (let x = 0;x < b; x++)
+            h += `
+`;
+        }
+        return `${l}${u}${h}`;
+      });
+    }
+    function Vd(e, t, n) {
+      let r, s = "", { parsed: o } = kd(e, { expandDoubleQuotedNewlines: false, convertWindowsNewlines: false });
+      if (Object.prototype.hasOwnProperty.call(o, t)) {
+        let i = o[t], c = e, a = Array.isArray(n) ? n : i.map(() => n);
+        return i.forEach((l, u) => {
+          c = Dd(c, t, l, `\x00DOTENVX_UPSERT_${u}\x00`);
+        }), a.forEach((l, u) => {
+          c = c.split(`\x00DOTENVX_UPSERT_${u}\x00`).join(l);
+        }), c;
+      } else
+        s += `${t}="${n}"`, e === "" || e.endsWith(`
+`) ? s = s + `
+` : s = `
+` + s, r = e + s;
+      return r;
+    }
+    Gc.exports = Vd;
+  });
+  var jd = ts();
+  var Gd = Yn();
+  var Zd = Xi();
+  var Yd = Vt();
+  var Xd = ns();
+  var Fd = rs();
+  var Wd = ec();
+  var zd = fn();
+  var Qd = fn().sync;
+  var Jd = Fn();
+  var e0 = ms();
+  var t0 = ms().sync;
+  var n0 = bs();
+  var r0 = kc();
+  var s0 = At();
+  var o0 = Vc();
+  var i0 = Zc();
+  module.exports = { decrypt: jd, derive: Gd, encrypt: Zd, encrypted: Yd, evaluate: Xd, expand: Fd, keypair: Wd, keyring: zd, keyringSync: Qd, match: Jd, parse: e0, parseSync: t0, publickeys: n0, remove: r0, scan: s0, sealed: o0, upsert: i0 };
+});
+export default require_dist();