@btc-vision/bitcoin 6.4.11 → 6.5.1

package/browser/chunks/crypto-C6FlKKmp.js

@@ -0,0 +1,2006 @@
+var ut = {}, rt = {};
+rt.byteLength = hr;
+rt.toByteArray = ur;
+rt.fromByteArray = ar;
+var N = [], S = [], or = typeof Uint8Array < "u" ? Uint8Array : Array, ht = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var Y = 0, sr = ht.length; Y < sr; ++Y)
+  N[Y] = ht[Y], S[ht.charCodeAt(Y)] = Y;
+S[45] = 62;
+S[95] = 63;
+function _t(c) {
+  var s = c.length;
+  if (s % 4 > 0)
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  var p = c.indexOf("=");
+  p === -1 && (p = s);
+  var a = p === s ? 0 : 4 - p % 4;
+  return [p, a];
+}
+function hr(c) {
+  var s = _t(c), p = s[0], a = s[1];
+  return (p + a) * 3 / 4 - a;
+}
+function cr(c, s, p) {
+  return (s + p) * 3 / 4 - p;
+}
+function ur(c) {
+  var s, p = _t(c), a = p[0], y = p[1], f = new or(cr(c, a, y)), l = 0, B = y > 0 ? a - 4 : a, w;
+  for (w = 0; w < B; w += 4)
+    s = S[c.charCodeAt(w)] << 18 | S[c.charCodeAt(w + 1)] << 12 | S[c.charCodeAt(w + 2)] << 6 | S[c.charCodeAt(w + 3)], f[l++] = s >> 16 & 255, f[l++] = s >> 8 & 255, f[l++] = s & 255;
+  return y === 2 && (s = S[c.charCodeAt(w)] << 2 | S[c.charCodeAt(w + 1)] >> 4, f[l++] = s & 255), y === 1 && (s = S[c.charCodeAt(w)] << 10 | S[c.charCodeAt(w + 1)] << 4 | S[c.charCodeAt(w + 2)] >> 2, f[l++] = s >> 8 & 255, f[l++] = s & 255), f;
+}
+function fr(c) {
+  return N[c >> 18 & 63] + N[c >> 12 & 63] + N[c >> 6 & 63] + N[c & 63];
+}
+function pr(c, s, p) {
+  for (var a, y = [], f = s; f < p; f += 3)
+    a = (c[f] << 16 & 16711680) + (c[f + 1] << 8 & 65280) + (c[f + 2] & 255), y.push(fr(a));
+  return y.join("");
+}
+function ar(c) {
+  for (var s, p = c.length, a = p % 3, y = [], f = 16383, l = 0, B = p - a; l < B; l += f)
+    y.push(pr(c, l, l + f > B ? B : l + f));
+  return a === 1 ? (s = c[p - 1], y.push(
+    N[s >> 2] + N[s << 4 & 63] + "=="
+  )) : a === 2 && (s = (c[p - 2] << 8) + c[p - 1], y.push(
+    N[s >> 10] + N[s >> 4 & 63] + N[s << 2 & 63] + "="
+  )), y.join("");
+}
+var ft = {};
+ft.read = function(c, s, p, a, y) {
+  var f, l, B = y * 8 - a - 1, w = (1 << B) - 1, d = w >> 1, o = -7, g = p ? y - 1 : 0, U = p ? -1 : 1, E = c[s + g];
+  for (g += U, f = E & (1 << -o) - 1, E >>= -o, o += B; o > 0; f = f * 256 + c[s + g], g += U, o -= 8)
+    ;
+  for (l = f & (1 << -o) - 1, f >>= -o, o += a; o > 0; l = l * 256 + c[s + g], g += U, o -= 8)
+    ;
+  if (f === 0)
+    f = 1 - d;
+  else {
+    if (f === w)
+      return l ? NaN : (E ? -1 : 1) * (1 / 0);
+    l = l + Math.pow(2, a), f = f - d;
+  }
+  return (E ? -1 : 1) * l * Math.pow(2, f - a);
+};
+ft.write = function(c, s, p, a, y, f) {
+  var l, B, w, d = f * 8 - y - 1, o = (1 << d) - 1, g = o >> 1, U = y === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, E = a ? 0 : f - 1, L = a ? 1 : -1, P = s < 0 || s === 0 && 1 / s < 0 ? 1 : 0;
+  for (s = Math.abs(s), isNaN(s) || s === 1 / 0 ? (B = isNaN(s) ? 1 : 0, l = o) : (l = Math.floor(Math.log(s) / Math.LN2), s * (w = Math.pow(2, -l)) < 1 && (l--, w *= 2), l + g >= 1 ? s += U / w : s += U * Math.pow(2, 1 - g), s * w >= 2 && (l++, w /= 2), l + g >= o ? (B = 0, l = o) : l + g >= 1 ? (B = (s * w - 1) * Math.pow(2, y), l = l + g) : (B = s * Math.pow(2, g - 1) * Math.pow(2, y), l = 0)); y >= 8; c[p + E] = B & 255, E += L, B /= 256, y -= 8)
+    ;
+  for (l = l << y | B, d += y; d > 0; c[p + E] = l & 255, E += L, l /= 256, d -= 8)
+    ;
+  c[p + E - L] |= P * 128;
+};
+(function(c) {
+  const s = rt, p = ft, a = typeof Symbol == "function" && typeof Symbol.for == "function" ? /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom") : null;
+  c.Buffer = o, c.SlowBuffer = C, c.INSPECT_MAX_BYTES = 50;
+  const y = 2147483647;
+  c.kMaxLength = y;
+  const { Uint8Array: f, ArrayBuffer: l, SharedArrayBuffer: B } = globalThis;
+  o.TYPED_ARRAY_SUPPORT = w(), !o.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error(
+    "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+  );
+  function w() {
+    try {
+      const i = new f(1), t = { foo: function() {
+        return 42;
+      } };
+      return Object.setPrototypeOf(t, f.prototype), Object.setPrototypeOf(i, t), i.foo() === 42;
+    } catch {
+      return !1;
+    }
+  }
+  Object.defineProperty(o.prototype, "parent", {
+    enumerable: !0,
+    get: function() {
+      if (o.isBuffer(this))
+        return this.buffer;
+    }
+  }), Object.defineProperty(o.prototype, "offset", {
+    enumerable: !0,
+    get: function() {
+      if (o.isBuffer(this))
+        return this.byteOffset;
+    }
+  });
+  function d(i) {
+    if (i > y)
+      throw new RangeError('The value "' + i + '" is invalid for option "size"');
+    const t = new f(i);
+    return Object.setPrototypeOf(t, o.prototype), t;
+  }
+  function o(i, t, r) {
+    if (typeof i == "number") {
+      if (typeof t == "string")
+        throw new TypeError(
+          'The "string" argument must be of type string. Received type number'
+        );
+      return L(i);
+    }
+    return g(i, t, r);
+  }
+  o.poolSize = 8192;
+  function g(i, t, r) {
+    if (typeof i == "string")
+      return P(i, t);
+    if (l.isView(i))
+      return it(i);
+    if (i == null)
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i
+      );
+    if (M(i, l) || i && M(i.buffer, l) || typeof B < "u" && (M(i, B) || i && M(i.buffer, B)))
+      return X(i, t, r);
+    if (typeof i == "number")
+      throw new TypeError(
+        'The "value" argument must not be of type number. Received type number'
+      );
+    const e = i.valueOf && i.valueOf();
+    if (e != null && e !== i)
+      return o.from(e, t, r);
+    const n = et(i);
+    if (n) return n;
+    if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof i[Symbol.toPrimitive] == "function")
+      return o.from(i[Symbol.toPrimitive]("string"), t, r);
+    throw new TypeError(
+      "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i
+    );
+  }
+  o.from = function(i, t, r) {
+    return g(i, t, r);
+  }, Object.setPrototypeOf(o.prototype, f.prototype), Object.setPrototypeOf(o, f);
+  function U(i) {
+    if (typeof i != "number")
+      throw new TypeError('"size" argument must be of type number');
+    if (i < 0)
+      throw new RangeError('The value "' + i + '" is invalid for option "size"');
+  }
+  function E(i, t, r) {
+    return U(i), i <= 0 ? d(i) : t !== void 0 ? typeof r == "string" ? d(i).fill(t, r) : d(i).fill(t) : d(i);
+  }
+  o.alloc = function(i, t, r) {
+    return E(i, t, r);
+  };
+  function L(i) {
+    return U(i), d(i < 0 ? 0 : J(i) | 0);
+  }
+  o.allocUnsafe = function(i) {
+    return L(i);
+  }, o.allocUnsafeSlow = function(i) {
+    return L(i);
+  };
+  function P(i, t) {
+    if ((typeof t != "string" || t === "") && (t = "utf8"), !o.isEncoding(t))
+      throw new TypeError("Unknown encoding: " + t);
+    const r = W(i, t) | 0;
+    let e = d(r);
+    const n = e.write(i, t);
+    return n !== r && (e = e.slice(0, n)), e;
+  }
+  function q(i) {
+    const t = i.length < 0 ? 0 : J(i.length) | 0, r = d(t);
+    for (let e = 0; e < t; e += 1)
+      r[e] = i[e] & 255;
+    return r;
+  }
+  function it(i) {
+    if (M(i, f)) {
+      const t = new f(i);
+      return X(t.buffer, t.byteOffset, t.byteLength);
+    }
+    return q(i);
+  }
+  function X(i, t, r) {
+    if (t < 0 || i.byteLength < t)
+      throw new RangeError('"offset" is outside of buffer bounds');
+    if (i.byteLength < t + (r || 0))
+      throw new RangeError('"length" is outside of buffer bounds');
+    let e;
+    return t === void 0 && r === void 0 ? e = new f(i) : r === void 0 ? e = new f(i, t) : e = new f(i, t, r), Object.setPrototypeOf(e, o.prototype), e;
+  }
+  function et(i) {
+    if (o.isBuffer(i)) {
+      const t = J(i.length) | 0, r = d(t);
+      return r.length === 0 || i.copy(r, 0, 0, t), r;
+    }
+    if (i.length !== void 0)
+      return typeof i.length != "number" || st(i.length) ? d(0) : q(i);
+    if (i.type === "Buffer" && Array.isArray(i.data))
+      return q(i.data);
+  }
+  function J(i) {
+    if (i >= y)
+      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + y.toString(16) + " bytes");
+    return i | 0;
+  }
+  function C(i) {
+    return +i != i && (i = 0), o.alloc(+i);
+  }
+  o.isBuffer = function(t) {
+    return t != null && t._isBuffer === !0 && t !== o.prototype;
+  }, o.compare = function(t, r) {
+    if (M(t, f) && (t = o.from(t, t.offset, t.byteLength)), M(r, f) && (r = o.from(r, r.offset, r.byteLength)), !o.isBuffer(t) || !o.isBuffer(r))
+      throw new TypeError(
+        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+      );
+    if (t === r) return 0;
+    let e = t.length, n = r.length;
+    for (let h = 0, u = Math.min(e, n); h < u; ++h)
+      if (t[h] !== r[h]) {
+        e = t[h], n = r[h];
+        break;
+      }
+    return e < n ? -1 : n < e ? 1 : 0;
+  }, o.isEncoding = function(t) {
+    switch (String(t).toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "utf-8":
+      case "ascii":
+      case "latin1":
+      case "binary":
+      case "base64":
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return !0;
+      default:
+        return !1;
+    }
+  }, o.concat = function(t, r) {
+    if (!Array.isArray(t))
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    if (t.length === 0)
+      return o.alloc(0);
+    let e;
+    if (r === void 0)
+      for (r = 0, e = 0; e < t.length; ++e)
+        r += t[e].length;
+    const n = o.allocUnsafe(r);
+    let h = 0;
+    for (e = 0; e < t.length; ++e) {
+      let u = t[e];
+      if (M(u, f))
+        h + u.length > n.length ? (o.isBuffer(u) || (u = o.from(u)), u.copy(n, h)) : f.prototype.set.call(
+          n,
+          u,
+          h
+        );
+      else if (o.isBuffer(u))
+        u.copy(n, h);
+      else
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      h += u.length;
+    }
+    return n;
+  };
+  function W(i, t) {
+    if (o.isBuffer(i))
+      return i.length;
+    if (l.isView(i) || M(i, l))
+      return i.byteLength;
+    if (typeof i != "string")
+      throw new TypeError(
+        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof i
+      );
+    const r = i.length, e = arguments.length > 2 && arguments[2] === !0;
+    if (!e && r === 0) return 0;
+    let n = !1;
+    for (; ; )
+      switch (t) {
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return r;
+        case "utf8":
+        case "utf-8":
+          return ot(i).length;
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return r * 2;
+        case "hex":
+          return r >>> 1;
+        case "base64":
+          return Ut(i).length;
+        default:
+          if (n)
+            return e ? -1 : ot(i).length;
+          t = ("" + t).toLowerCase(), n = !0;
+      }
+  }
+  o.byteLength = W;
+  function Ot(i, t, r) {
+    let e = !1;
+    if ((t === void 0 || t < 0) && (t = 0), t > this.length || ((r === void 0 || r > this.length) && (r = this.length), r <= 0) || (r >>>= 0, t >>>= 0, r <= t))
+      return "";
+    for (i || (i = "utf8"); ; )
+      switch (i) {
+        case "hex":
+          return Zt(this, t, r);
+        case "utf8":
+        case "utf-8":
+          return Bt(this, t, r);
+        case "ascii":
+          return Xt(this, t, r);
+        case "latin1":
+        case "binary":
+          return Jt(this, t, r);
+        case "base64":
+          return Yt(this, t, r);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return Qt(this, t, r);
+        default:
+          if (e) throw new TypeError("Unknown encoding: " + i);
+          i = (i + "").toLowerCase(), e = !0;
+      }
+  }
+  o.prototype._isBuffer = !0;
+  function O(i, t, r) {
+    const e = i[t];
+    i[t] = i[r], i[r] = e;
+  }
+  o.prototype.swap16 = function() {
+    const t = this.length;
+    if (t % 2 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 16-bits");
+    for (let r = 0; r < t; r += 2)
+      O(this, r, r + 1);
+    return this;
+  }, o.prototype.swap32 = function() {
+    const t = this.length;
+    if (t % 4 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 32-bits");
+    for (let r = 0; r < t; r += 4)
+      O(this, r, r + 3), O(this, r + 1, r + 2);
+    return this;
+  }, o.prototype.swap64 = function() {
+    const t = this.length;
+    if (t % 8 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 64-bits");
+    for (let r = 0; r < t; r += 8)
+      O(this, r, r + 7), O(this, r + 1, r + 6), O(this, r + 2, r + 5), O(this, r + 3, r + 4);
+    return this;
+  }, o.prototype.toString = function() {
+    const t = this.length;
+    return t === 0 ? "" : arguments.length === 0 ? Bt(this, 0, t) : Ot.apply(this, arguments);
+  }, o.prototype.toLocaleString = o.prototype.toString, o.prototype.equals = function(t) {
+    if (!o.isBuffer(t)) throw new TypeError("Argument must be a Buffer");
+    return this === t ? !0 : o.compare(this, t) === 0;
+  }, o.prototype.inspect = function() {
+    let t = "";
+    const r = c.INSPECT_MAX_BYTES;
+    return t = this.toString("hex", 0, r).replace(/(.{2})/g, "$1 ").trim(), this.length > r && (t += " ... "), "<Buffer " + t + ">";
+  }, a && (o.prototype[a] = o.prototype.inspect), o.prototype.compare = function(t, r, e, n, h) {
+    if (M(t, f) && (t = o.from(t, t.offset, t.byteLength)), !o.isBuffer(t))
+      throw new TypeError(
+        'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof t
+      );
+    if (r === void 0 && (r = 0), e === void 0 && (e = t ? t.length : 0), n === void 0 && (n = 0), h === void 0 && (h = this.length), r < 0 || e > t.length || n < 0 || h > this.length)
+      throw new RangeError("out of range index");
+    if (n >= h && r >= e)
+      return 0;
+    if (n >= h)
+      return -1;
+    if (r >= e)
+      return 1;
+    if (r >>>= 0, e >>>= 0, n >>>= 0, h >>>= 0, this === t) return 0;
+    let u = h - n, m = e - r;
+    const A = Math.min(u, m), x = this.slice(n, h), b = t.slice(r, e);
+    for (let I = 0; I < A; ++I)
+      if (x[I] !== b[I]) {
+        u = x[I], m = b[I];
+        break;
+      }
+    return u < m ? -1 : m < u ? 1 : 0;
+  };
+  function yt(i, t, r, e, n) {
+    if (i.length === 0) return -1;
+    if (typeof r == "string" ? (e = r, r = 0) : r > 2147483647 ? r = 2147483647 : r < -2147483648 && (r = -2147483648), r = +r, st(r) && (r = n ? 0 : i.length - 1), r < 0 && (r = i.length + r), r >= i.length) {
+      if (n) return -1;
+      r = i.length - 1;
+    } else if (r < 0)
+      if (n) r = 0;
+      else return -1;
+    if (typeof t == "string" && (t = o.from(t, e)), o.isBuffer(t))
+      return t.length === 0 ? -1 : wt(i, t, r, e, n);
+    if (typeof t == "number")
+      return t = t & 255, typeof f.prototype.indexOf == "function" ? n ? f.prototype.indexOf.call(i, t, r) : f.prototype.lastIndexOf.call(i, t, r) : wt(i, [t], r, e, n);
+    throw new TypeError("val must be string, number or Buffer");
+  }
+  function wt(i, t, r, e, n) {
+    let h = 1, u = i.length, m = t.length;
+    if (e !== void 0 && (e = String(e).toLowerCase(), e === "ucs2" || e === "ucs-2" || e === "utf16le" || e === "utf-16le")) {
+      if (i.length < 2 || t.length < 2)
+        return -1;
+      h = 2, u /= 2, m /= 2, r /= 2;
+    }
+    function A(b, I) {
+      return h === 1 ? b[I] : b.readUInt16BE(I * h);
+    }
+    let x;
+    if (n) {
+      let b = -1;
+      for (x = r; x < u; x++)
+        if (A(i, x) === A(t, b === -1 ? 0 : x - b)) {
+          if (b === -1 && (b = x), x - b + 1 === m) return b * h;
+        } else
+          b !== -1 && (x -= x - b), b = -1;
+    } else
+      for (r + m > u && (r = u - m), x = r; x >= 0; x--) {
+        let b = !0;
+        for (let I = 0; I < m; I++)
+          if (A(i, x + I) !== A(t, I)) {
+            b = !1;
+            break;
+          }
+        if (b) return x;
+      }
+    return -1;
+  }
+  o.prototype.includes = function(t, r, e) {
+    return this.indexOf(t, r, e) !== -1;
+  }, o.prototype.indexOf = function(t, r, e) {
+    return yt(this, t, r, e, !0);
+  }, o.prototype.lastIndexOf = function(t, r, e) {
+    return yt(this, t, r, e, !1);
+  };
+  function Gt(i, t, r, e) {
+    r = Number(r) || 0;
+    const n = i.length - r;
+    e ? (e = Number(e), e > n && (e = n)) : e = n;
+    const h = t.length;
+    e > h / 2 && (e = h / 2);
+    let u;
+    for (u = 0; u < e; ++u) {
+      const m = parseInt(t.substr(u * 2, 2), 16);
+      if (st(m)) return u;
+      i[r + u] = m;
+    }
+    return u;
+  }
+  function jt(i, t, r, e) {
+    return z(ot(t, i.length - r), i, r, e);
+  }
+  function Wt(i, t, r, e) {
+    return z(rr(t), i, r, e);
+  }
+  function Vt(i, t, r, e) {
+    return z(Ut(t), i, r, e);
+  }
+  function Kt(i, t, r, e) {
+    return z(ir(t, i.length - r), i, r, e);
+  }
+  o.prototype.write = function(t, r, e, n) {
+    if (r === void 0)
+      n = "utf8", e = this.length, r = 0;
+    else if (e === void 0 && typeof r == "string")
+      n = r, e = this.length, r = 0;
+    else if (isFinite(r))
+      r = r >>> 0, isFinite(e) ? (e = e >>> 0, n === void 0 && (n = "utf8")) : (n = e, e = void 0);
+    else
+      throw new Error(
+        "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+      );
+    const h = this.length - r;
+    if ((e === void 0 || e > h) && (e = h), t.length > 0 && (e < 0 || r < 0) || r > this.length)
+      throw new RangeError("Attempt to write outside buffer bounds");
+    n || (n = "utf8");
+    let u = !1;
+    for (; ; )
+      switch (n) {
+        case "hex":
+          return Gt(this, t, r, e);
+        case "utf8":
+        case "utf-8":
+          return jt(this, t, r, e);
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return Wt(this, t, r, e);
+        case "base64":
+          return Vt(this, t, r, e);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return Kt(this, t, r, e);
+        default:
+          if (u) throw new TypeError("Unknown encoding: " + n);
+          n = ("" + n).toLowerCase(), u = !0;
+      }
+  }, o.prototype.toJSON = function() {
+    return {
+      type: "Buffer",
+      data: Array.prototype.slice.call(this._arr || this, 0)
+    };
+  };
+  function Yt(i, t, r) {
+    return t === 0 && r === i.length ? s.fromByteArray(i) : s.fromByteArray(i.slice(t, r));
+  }
+  function Bt(i, t, r) {
+    r = Math.min(i.length, r);
+    const e = [];
+    let n = t;
+    for (; n < r; ) {
+      const h = i[n];
+      let u = null, m = h > 239 ? 4 : h > 223 ? 3 : h > 191 ? 2 : 1;
+      if (n + m <= r) {
+        let A, x, b, I;
+        switch (m) {
+          case 1:
+            h < 128 && (u = h);
+            break;
+          case 2:
+            A = i[n + 1], (A & 192) === 128 && (I = (h & 31) << 6 | A & 63, I > 127 && (u = I));
+            break;
+          case 3:
+            A = i[n + 1], x = i[n + 2], (A & 192) === 128 && (x & 192) === 128 && (I = (h & 15) << 12 | (A & 63) << 6 | x & 63, I > 2047 && (I < 55296 || I > 57343) && (u = I));
+            break;
+          case 4:
+            A = i[n + 1], x = i[n + 2], b = i[n + 3], (A & 192) === 128 && (x & 192) === 128 && (b & 192) === 128 && (I = (h & 15) << 18 | (A & 63) << 12 | (x & 63) << 6 | b & 63, I > 65535 && I < 1114112 && (u = I));
+        }
+      }
+      u === null ? (u = 65533, m = 1) : u > 65535 && (u -= 65536, e.push(u >>> 10 & 1023 | 55296), u = 56320 | u & 1023), e.push(u), n += m;
+    }
+    return qt(e);
+  }
+  const gt = 4096;
+  function qt(i) {
+    const t = i.length;
+    if (t <= gt)
+      return String.fromCharCode.apply(String, i);
+    let r = "", e = 0;
+    for (; e < t; )
+      r += String.fromCharCode.apply(
+        String,
+        i.slice(e, e += gt)
+      );
+    return r;
+  }
+  function Xt(i, t, r) {
+    let e = "";
+    r = Math.min(i.length, r);
+    for (let n = t; n < r; ++n)
+      e += String.fromCharCode(i[n] & 127);
+    return e;
+  }
+  function Jt(i, t, r) {
+    let e = "";
+    r = Math.min(i.length, r);
+    for (let n = t; n < r; ++n)
+      e += String.fromCharCode(i[n]);
+    return e;
+  }
+  function Zt(i, t, r) {
+    const e = i.length;
+    (!t || t < 0) && (t = 0), (!r || r < 0 || r > e) && (r = e);
+    let n = "";
+    for (let h = t; h < r; ++h)
+      n += er[i[h]];
+    return n;
+  }
+  function Qt(i, t, r) {
+    const e = i.slice(t, r);
+    let n = "";
+    for (let h = 0; h < e.length - 1; h += 2)
+      n += String.fromCharCode(e[h] + e[h + 1] * 256);
+    return n;
+  }
+  o.prototype.slice = function(t, r) {
+    const e = this.length;
+    t = ~~t, r = r === void 0 ? e : ~~r, t < 0 ? (t += e, t < 0 && (t = 0)) : t > e && (t = e), r < 0 ? (r += e, r < 0 && (r = 0)) : r > e && (r = e), r < t && (r = t);
+    const n = this.subarray(t, r);
+    return Object.setPrototypeOf(n, o.prototype), n;
+  };
+  function T(i, t, r) {
+    if (i % 1 !== 0 || i < 0) throw new RangeError("offset is not uint");
+    if (i + t > r) throw new RangeError("Trying to access beyond buffer length");
+  }
+  o.prototype.readUintLE = o.prototype.readUIntLE = function(t, r, e) {
+    t = t >>> 0, r = r >>> 0, e || T(t, r, this.length);
+    let n = this[t], h = 1, u = 0;
+    for (; ++u < r && (h *= 256); )
+      n += this[t + u] * h;
+    return n;
+  }, o.prototype.readUintBE = o.prototype.readUIntBE = function(t, r, e) {
+    t = t >>> 0, r = r >>> 0, e || T(t, r, this.length);
+    let n = this[t + --r], h = 1;
+    for (; r > 0 && (h *= 256); )
+      n += this[t + --r] * h;
+    return n;
+  }, o.prototype.readUint8 = o.prototype.readUInt8 = function(t, r) {
+    return t = t >>> 0, r || T(t, 1, this.length), this[t];
+  }, o.prototype.readUint16LE = o.prototype.readUInt16LE = function(t, r) {
+    return t = t >>> 0, r || T(t, 2, this.length), this[t] | this[t + 1] << 8;
+  }, o.prototype.readUint16BE = o.prototype.readUInt16BE = function(t, r) {
+    return t = t >>> 0, r || T(t, 2, this.length), this[t] << 8 | this[t + 1];
+  }, o.prototype.readUint32LE = o.prototype.readUInt32LE = function(t, r) {
+    return t = t >>> 0, r || T(t, 4, this.length), (this[t] | this[t + 1] << 8 | this[t + 2] << 16) + this[t + 3] * 16777216;
+  }, o.prototype.readUint32BE = o.prototype.readUInt32BE = function(t, r) {
+    return t = t >>> 0, r || T(t, 4, this.length), this[t] * 16777216 + (this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3]);
+  }, o.prototype.readBigUInt64LE = D(function(t) {
+    t = t >>> 0, K(t, "offset");
+    const r = this[t], e = this[t + 7];
+    (r === void 0 || e === void 0) && Z(t, this.length - 8);
+    const n = r + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + this[++t] * 2 ** 24, h = this[++t] + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + e * 2 ** 24;
+    return BigInt(n) + (BigInt(h) << BigInt(32));
+  }), o.prototype.readBigUInt64BE = D(function(t) {
+    t = t >>> 0, K(t, "offset");
+    const r = this[t], e = this[t + 7];
+    (r === void 0 || e === void 0) && Z(t, this.length - 8);
+    const n = r * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + this[++t], h = this[++t] * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + e;
+    return (BigInt(n) << BigInt(32)) + BigInt(h);
+  }), o.prototype.readIntLE = function(t, r, e) {
+    t = t >>> 0, r = r >>> 0, e || T(t, r, this.length);
+    let n = this[t], h = 1, u = 0;
+    for (; ++u < r && (h *= 256); )
+      n += this[t + u] * h;
+    return h *= 128, n >= h && (n -= Math.pow(2, 8 * r)), n;
+  }, o.prototype.readIntBE = function(t, r, e) {
+    t = t >>> 0, r = r >>> 0, e || T(t, r, this.length);
+    let n = r, h = 1, u = this[t + --n];
+    for (; n > 0 && (h *= 256); )
+      u += this[t + --n] * h;
+    return h *= 128, u >= h && (u -= Math.pow(2, 8 * r)), u;
+  }, o.prototype.readInt8 = function(t, r) {
+    return t = t >>> 0, r || T(t, 1, this.length), this[t] & 128 ? (255 - this[t] + 1) * -1 : this[t];
+  }, o.prototype.readInt16LE = function(t, r) {
+    t = t >>> 0, r || T(t, 2, this.length);
+    const e = this[t] | this[t + 1] << 8;
+    return e & 32768 ? e | 4294901760 : e;
+  }, o.prototype.readInt16BE = function(t, r) {
+    t = t >>> 0, r || T(t, 2, this.length);
+    const e = this[t + 1] | this[t] << 8;
+    return e & 32768 ? e | 4294901760 : e;
+  }, o.prototype.readInt32LE = function(t, r) {
+    return t = t >>> 0, r || T(t, 4, this.length), this[t] | this[t + 1] << 8 | this[t + 2] << 16 | this[t + 3] << 24;
+  }, o.prototype.readInt32BE = function(t, r) {
+    return t = t >>> 0, r || T(t, 4, this.length), this[t] << 24 | this[t + 1] << 16 | this[t + 2] << 8 | this[t + 3];
+  }, o.prototype.readBigInt64LE = D(function(t) {
+    t = t >>> 0, K(t, "offset");
+    const r = this[t], e = this[t + 7];
+    (r === void 0 || e === void 0) && Z(t, this.length - 8);
+    const n = this[t + 4] + this[t + 5] * 2 ** 8 + this[t + 6] * 2 ** 16 + (e << 24);
+    return (BigInt(n) << BigInt(32)) + BigInt(r + this[++t] * 2 ** 8 + this[++t] * 2 ** 16 + this[++t] * 2 ** 24);
+  }), o.prototype.readBigInt64BE = D(function(t) {
+    t = t >>> 0, K(t, "offset");
+    const r = this[t], e = this[t + 7];
+    (r === void 0 || e === void 0) && Z(t, this.length - 8);
+    const n = (r << 24) + // Overflow
+    this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + this[++t];
+    return (BigInt(n) << BigInt(32)) + BigInt(this[++t] * 2 ** 24 + this[++t] * 2 ** 16 + this[++t] * 2 ** 8 + e);
+  }), o.prototype.readFloatLE = function(t, r) {
+    return t = t >>> 0, r || T(t, 4, this.length), p.read(this, t, !0, 23, 4);
+  }, o.prototype.readFloatBE = function(t, r) {
+    return t = t >>> 0, r || T(t, 4, this.length), p.read(this, t, !1, 23, 4);
+  }, o.prototype.readDoubleLE = function(t, r) {
+    return t = t >>> 0, r || T(t, 8, this.length), p.read(this, t, !0, 52, 8);
+  }, o.prototype.readDoubleBE = function(t, r) {
+    return t = t >>> 0, r || T(t, 8, this.length), p.read(this, t, !1, 52, 8);
+  };
+  function _(i, t, r, e, n, h) {
+    if (!o.isBuffer(i)) throw new TypeError('"buffer" argument must be a Buffer instance');
+    if (t > n || t < h) throw new RangeError('"value" argument is out of bounds');
+    if (r + e > i.length) throw new RangeError("Index out of range");
+  }
+  o.prototype.writeUintLE = o.prototype.writeUIntLE = function(t, r, e, n) {
+    if (t = +t, r = r >>> 0, e = e >>> 0, !n) {
+      const m = Math.pow(2, 8 * e) - 1;
+      _(this, t, r, e, m, 0);
+    }
+    let h = 1, u = 0;
+    for (this[r] = t & 255; ++u < e && (h *= 256); )
+      this[r + u] = t / h & 255;
+    return r + e;
+  }, o.prototype.writeUintBE = o.prototype.writeUIntBE = function(t, r, e, n) {
+    if (t = +t, r = r >>> 0, e = e >>> 0, !n) {
+      const m = Math.pow(2, 8 * e) - 1;
+      _(this, t, r, e, m, 0);
+    }
+    let h = e - 1, u = 1;
+    for (this[r + h] = t & 255; --h >= 0 && (u *= 256); )
+      this[r + h] = t / u & 255;
+    return r + e;
+  }, o.prototype.writeUint8 = o.prototype.writeUInt8 = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 1, 255, 0), this[r] = t & 255, r + 1;
+  }, o.prototype.writeUint16LE = o.prototype.writeUInt16LE = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 2, 65535, 0), this[r] = t & 255, this[r + 1] = t >>> 8, r + 2;
+  }, o.prototype.writeUint16BE = o.prototype.writeUInt16BE = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 2, 65535, 0), this[r] = t >>> 8, this[r + 1] = t & 255, r + 2;
+  }, o.prototype.writeUint32LE = o.prototype.writeUInt32LE = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 4, 4294967295, 0), this[r + 3] = t >>> 24, this[r + 2] = t >>> 16, this[r + 1] = t >>> 8, this[r] = t & 255, r + 4;
+  }, o.prototype.writeUint32BE = o.prototype.writeUInt32BE = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 4, 4294967295, 0), this[r] = t >>> 24, this[r + 1] = t >>> 16, this[r + 2] = t >>> 8, this[r + 3] = t & 255, r + 4;
+  };
+  function dt(i, t, r, e, n) {
+    bt(t, e, n, i, r, 7);
+    let h = Number(t & BigInt(4294967295));
+    i[r++] = h, h = h >> 8, i[r++] = h, h = h >> 8, i[r++] = h, h = h >> 8, i[r++] = h;
+    let u = Number(t >> BigInt(32) & BigInt(4294967295));
+    return i[r++] = u, u = u >> 8, i[r++] = u, u = u >> 8, i[r++] = u, u = u >> 8, i[r++] = u, r;
+  }
+  function mt(i, t, r, e, n) {
+    bt(t, e, n, i, r, 7);
+    let h = Number(t & BigInt(4294967295));
+    i[r + 7] = h, h = h >> 8, i[r + 6] = h, h = h >> 8, i[r + 5] = h, h = h >> 8, i[r + 4] = h;
+    let u = Number(t >> BigInt(32) & BigInt(4294967295));
+    return i[r + 3] = u, u = u >> 8, i[r + 2] = u, u = u >> 8, i[r + 1] = u, u = u >> 8, i[r] = u, r + 8;
+  }
+  o.prototype.writeBigUInt64LE = D(function(t, r = 0) {
+    return dt(this, t, r, BigInt(0), BigInt("0xffffffffffffffff"));
+  }), o.prototype.writeBigUInt64BE = D(function(t, r = 0) {
+    return mt(this, t, r, BigInt(0), BigInt("0xffffffffffffffff"));
+  }), o.prototype.writeIntLE = function(t, r, e, n) {
+    if (t = +t, r = r >>> 0, !n) {
+      const A = Math.pow(2, 8 * e - 1);
+      _(this, t, r, e, A - 1, -A);
+    }
+    let h = 0, u = 1, m = 0;
+    for (this[r] = t & 255; ++h < e && (u *= 256); )
+      t < 0 && m === 0 && this[r + h - 1] !== 0 && (m = 1), this[r + h] = (t / u >> 0) - m & 255;
+    return r + e;
+  }, o.prototype.writeIntBE = function(t, r, e, n) {
+    if (t = +t, r = r >>> 0, !n) {
+      const A = Math.pow(2, 8 * e - 1);
+      _(this, t, r, e, A - 1, -A);
+    }
+    let h = e - 1, u = 1, m = 0;
+    for (this[r + h] = t & 255; --h >= 0 && (u *= 256); )
+      t < 0 && m === 0 && this[r + h + 1] !== 0 && (m = 1), this[r + h] = (t / u >> 0) - m & 255;
+    return r + e;
+  }, o.prototype.writeInt8 = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 1, 127, -128), t < 0 && (t = 255 + t + 1), this[r] = t & 255, r + 1;
+  }, o.prototype.writeInt16LE = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 2, 32767, -32768), this[r] = t & 255, this[r + 1] = t >>> 8, r + 2;
+  }, o.prototype.writeInt16BE = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 2, 32767, -32768), this[r] = t >>> 8, this[r + 1] = t & 255, r + 2;
+  }, o.prototype.writeInt32LE = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 4, 2147483647, -2147483648), this[r] = t & 255, this[r + 1] = t >>> 8, this[r + 2] = t >>> 16, this[r + 3] = t >>> 24, r + 4;
+  }, o.prototype.writeInt32BE = function(t, r, e) {
+    return t = +t, r = r >>> 0, e || _(this, t, r, 4, 2147483647, -2147483648), t < 0 && (t = 4294967295 + t + 1), this[r] = t >>> 24, this[r + 1] = t >>> 16, this[r + 2] = t >>> 8, this[r + 3] = t & 255, r + 4;
+  }, o.prototype.writeBigInt64LE = D(function(t, r = 0) {
+    return dt(this, t, r, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  }), o.prototype.writeBigInt64BE = D(function(t, r = 0) {
+    return mt(this, t, r, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  });
+  function Et(i, t, r, e, n, h) {
+    if (r + e > i.length) throw new RangeError("Index out of range");
+    if (r < 0) throw new RangeError("Index out of range");
+  }
+  function It(i, t, r, e, n) {
+    return t = +t, r = r >>> 0, n || Et(i, t, r, 4), p.write(i, t, r, e, 23, 4), r + 4;
+  }
+  o.prototype.writeFloatLE = function(t, r, e) {
+    return It(this, t, r, !0, e);
+  }, o.prototype.writeFloatBE = function(t, r, e) {
+    return It(this, t, r, !1, e);
+  };
+  function xt(i, t, r, e, n) {
+    return t = +t, r = r >>> 0, n || Et(i, t, r, 8), p.write(i, t, r, e, 52, 8), r + 8;
+  }
+  o.prototype.writeDoubleLE = function(t, r, e) {
+    return xt(this, t, r, !0, e);
+  }, o.prototype.writeDoubleBE = function(t, r, e) {
+    return xt(this, t, r, !1, e);
+  }, o.prototype.copy = function(t, r, e, n) {
+    if (!o.isBuffer(t)) throw new TypeError("argument should be a Buffer");
+    if (e || (e = 0), !n && n !== 0 && (n = this.length), r >= t.length && (r = t.length), r || (r = 0), n > 0 && n < e && (n = e), n === e || t.length === 0 || this.length === 0) return 0;
+    if (r < 0)
+      throw new RangeError("targetStart out of bounds");
+    if (e < 0 || e >= this.length) throw new RangeError("Index out of range");
+    if (n < 0) throw new RangeError("sourceEnd out of bounds");
+    n > this.length && (n = this.length), t.length - r < n - e && (n = t.length - r + e);
+    const h = n - e;
+    return this === t && typeof f.prototype.copyWithin == "function" ? this.copyWithin(r, e, n) : f.prototype.set.call(
+      t,
+      this.subarray(e, n),
+      r
+    ), h;
+  }, o.prototype.fill = function(t, r, e, n) {
+    if (typeof t == "string") {
+      if (typeof r == "string" ? (n = r, r = 0, e = this.length) : typeof e == "string" && (n = e, e = this.length), n !== void 0 && typeof n != "string")
+        throw new TypeError("encoding must be a string");
+      if (typeof n == "string" && !o.isEncoding(n))
+        throw new TypeError("Unknown encoding: " + n);
+      if (t.length === 1) {
+        const u = t.charCodeAt(0);
+        (n === "utf8" && u < 128 || n === "latin1") && (t = u);
+      }
+    } else typeof t == "number" ? t = t & 255 : typeof t == "boolean" && (t = Number(t));
+    if (r < 0 || this.length < r || this.length < e)
+      throw new RangeError("Out of range index");
+    if (e <= r)
+      return this;
+    r = r >>> 0, e = e === void 0 ? this.length : e >>> 0, t || (t = 0);
+    let h;
+    if (typeof t == "number")
+      for (h = r; h < e; ++h)
+        this[h] = t;
+    else {
+      const u = o.isBuffer(t) ? t : o.from(t, n), m = u.length;
+      if (m === 0)
+        throw new TypeError('The value "' + t + '" is invalid for argument "value"');
+      for (h = 0; h < e - r; ++h)
+        this[h + r] = u[h % m];
+    }
+    return this;
+  };
+  const V = {};
+  function nt(i, t, r) {
+    V[i] = class extends r {
+      constructor() {
+        super(), Object.defineProperty(this, "message", {
+          value: t.apply(this, arguments),
+          writable: !0,
+          configurable: !0
+        }), this.name = `${this.name} [${i}]`, this.stack, delete this.name;
+      }
+      get code() {
+        return i;
+      }
+      set code(n) {
+        Object.defineProperty(this, "code", {
+          configurable: !0,
+          enumerable: !0,
+          value: n,
+          writable: !0
+        });
+      }
+      toString() {
+        return `${this.name} [${i}]: ${this.message}`;
+      }
+    };
+  }
+  nt(
+    "ERR_BUFFER_OUT_OF_BOUNDS",
+    function(i) {
+      return i ? `${i} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
+    },
+    RangeError
+  ), nt(
+    "ERR_INVALID_ARG_TYPE",
+    function(i, t) {
+      return `The "${i}" argument must be of type number. Received type ${typeof t}`;
+    },
+    TypeError
+  ), nt(
+    "ERR_OUT_OF_RANGE",
+    function(i, t, r) {
+      let e = `The value of "${i}" is out of range.`, n = r;
+      return Number.isInteger(r) && Math.abs(r) > 2 ** 32 ? n = At(String(r)) : typeof r == "bigint" && (n = String(r), (r > BigInt(2) ** BigInt(32) || r < -(BigInt(2) ** BigInt(32))) && (n = At(n)), n += "n"), e += ` It must be ${t}. Received ${n}`, e;
+    },
+    RangeError
+  );
+  function At(i) {
+    let t = "", r = i.length;
+    const e = i[0] === "-" ? 1 : 0;
+    for (; r >= e + 4; r -= 3)
+      t = `_${i.slice(r - 3, r)}${t}`;
+    return `${i.slice(0, r)}${t}`;
+  }
+  function zt(i, t, r) {
+    K(t, "offset"), (i[t] === void 0 || i[t + r] === void 0) && Z(t, i.length - (r + 1));
+  }
+  function bt(i, t, r, e, n, h) {
+    if (i > r || i < t) {
+      const u = typeof t == "bigint" ? "n" : "";
+      let m;
+      throw t === 0 || t === BigInt(0) ? m = `>= 0${u} and < 2${u} ** ${(h + 1) * 8}${u}` : m = `>= -(2${u} ** ${(h + 1) * 8 - 1}${u}) and < 2 ** ${(h + 1) * 8 - 1}${u}`, new V.ERR_OUT_OF_RANGE("value", m, i);
+    }
+    zt(e, n, h);
+  }
+  function K(i, t) {
+    if (typeof i != "number")
+      throw new V.ERR_INVALID_ARG_TYPE(t, "number", i);
+  }
+  function Z(i, t, r) {
+    throw Math.floor(i) !== i ? (K(i, r), new V.ERR_OUT_OF_RANGE("offset", "an integer", i)) : t < 0 ? new V.ERR_BUFFER_OUT_OF_BOUNDS() : new V.ERR_OUT_OF_RANGE(
+      "offset",
+      `>= 0 and <= ${t}`,
+      i
+    );
+  }
+  const vt = /[^+/0-9A-Za-z-_]/g;
+  function tr(i) {
+    if (i = i.split("=")[0], i = i.trim().replace(vt, ""), i.length < 2) return "";
+    for (; i.length % 4 !== 0; )
+      i = i + "=";
+    return i;
+  }
+  function ot(i, t) {
+    t = t || 1 / 0;
+    let r;
+    const e = i.length;
+    let n = null;
+    const h = [];
+    for (let u = 0; u < e; ++u) {
+      if (r = i.charCodeAt(u), r > 55295 && r < 57344) {
+        if (!n) {
+          if (r > 56319) {
+            (t -= 3) > -1 && h.push(239, 191, 189);
+            continue;
+          } else if (u + 1 === e) {
+            (t -= 3) > -1 && h.push(239, 191, 189);
+            continue;
+          }
+          n = r;
+          continue;
+        }
+        if (r < 56320) {
+          (t -= 3) > -1 && h.push(239, 191, 189), n = r;
+          continue;
+        }
+        r = (n - 55296 << 10 | r - 56320) + 65536;
+      } else n && (t -= 3) > -1 && h.push(239, 191, 189);
+      if (n = null, r < 128) {
+        if ((t -= 1) < 0) break;
+        h.push(r);
+      } else if (r < 2048) {
+        if ((t -= 2) < 0) break;
+        h.push(
+          r >> 6 | 192,
+          r & 63 | 128
+        );
+      } else if (r < 65536) {
+        if ((t -= 3) < 0) break;
+        h.push(
+          r >> 12 | 224,
+          r >> 6 & 63 | 128,
+          r & 63 | 128
+        );
+      } else if (r < 1114112) {
+        if ((t -= 4) < 0) break;
+        h.push(
+          r >> 18 | 240,
+          r >> 12 & 63 | 128,
+          r >> 6 & 63 | 128,
+          r & 63 | 128
+        );
+      } else
+        throw new Error("Invalid code point");
+    }
+    return h;
+  }
+  function rr(i) {
+    const t = [];
+    for (let r = 0; r < i.length; ++r)
+      t.push(i.charCodeAt(r) & 255);
+    return t;
+  }
+  function ir(i, t) {
+    let r, e, n;
+    const h = [];
+    for (let u = 0; u < i.length && !((t -= 2) < 0); ++u)
+      r = i.charCodeAt(u), e = r >> 8, n = r % 256, h.push(n), h.push(e);
+    return h;
+  }
+  function Ut(i) {
+    return s.toByteArray(tr(i));
+  }
+  function z(i, t, r, e) {
+    let n;
+    for (n = 0; n < e && !(n + r >= t.length || n >= i.length); ++n)
+      t[n + r] = i[n];
+    return n;
+  }
+  function M(i, t) {
+    return i instanceof t || i != null && i.constructor != null && i.constructor.name != null && i.constructor.name === t.name;
+  }
+  function st(i) {
+    return i !== i;
+  }
+  const er = (function() {
+    const i = "0123456789abcdef", t = new Array(256);
+    for (let r = 0; r < 16; ++r) {
+      const e = r * 16;
+      for (let n = 0; n < 16; ++n)
+        t[e + n] = i[r] + i[n];
+    }
+    return t;
+  })();
+  function D(i) {
+    return typeof BigInt > "u" ? nr : i;
+  }
+  function nr() {
+    throw new Error("BigInt not supported");
+  }
+})(ut);
+const R = ut.Buffer, Hr = ut.Buffer;
+function Or(c) {
+  return c && c.__esModule && Object.prototype.hasOwnProperty.call(c, "default") ? c.default : c;
+}
+function lr(c) {
+  return c instanceof Uint8Array || ArrayBuffer.isView(c) && c.constructor.name === "Uint8Array";
+}
+function pt(c, ...s) {
+  if (!lr(c))
+    throw new Error("Uint8Array expected");
+  if (s.length > 0 && !s.includes(c.length))
+    throw new Error("Uint8Array expected of length " + s + ", got length=" + c.length);
+}
+function Tt(c, s = !0) {
+  if (c.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (s && c.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function yr(c, s) {
+  pt(c);
+  const p = s.outputLen;
+  if (c.length < p)
+    throw new Error("digestInto() expects output buffer of length at least " + p);
+}
+function j(...c) {
+  for (let s = 0; s < c.length; s++)
+    c[s].fill(0);
+}
+function ct(c) {
+  return new DataView(c.buffer, c.byteOffset, c.byteLength);
+}
+function k(c, s) {
+  return c << 32 - s | c >>> s;
+}
+function G(c, s) {
+  return c << s | c >>> 32 - s >>> 0;
+}
+function wr(c) {
+  if (typeof c != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(c));
+}
+function Lt(c) {
+  return typeof c == "string" && (c = wr(c)), pt(c), c;
+}
+class Br {
+}
+function at(c) {
+  const s = (a) => c().update(Lt(a)).digest(), p = c();
+  return s.outputLen = p.outputLen, s.blockLen = p.blockLen, s.create = () => c(), s;
+}
+function gr(c, s, p, a) {
+  if (typeof c.setBigUint64 == "function")
+    return c.setBigUint64(s, p, a);
+  const y = BigInt(32), f = BigInt(4294967295), l = Number(p >> y & f), B = Number(p & f), w = a ? 4 : 0, d = a ? 0 : 4;
+  c.setUint32(s + w, l, a), c.setUint32(s + d, B, a);
+}
+function St(c, s, p) {
+  return c & s ^ ~c & p;
+}
+function Ct(c, s, p) {
+  return c & s ^ c & p ^ s & p;
+}
+class lt extends Br {
+  constructor(s, p, a, y) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = s, this.outputLen = p, this.padOffset = a, this.isLE = y, this.buffer = new Uint8Array(s), this.view = ct(this.buffer);
+  }
+  update(s) {
+    Tt(this), s = Lt(s), pt(s);
+    const { view: p, buffer: a, blockLen: y } = this, f = s.length;
+    for (let l = 0; l < f; ) {
+      const B = Math.min(y - this.pos, f - l);
+      if (B === y) {
+        const w = ct(s);
+        for (; y <= f - l; l += y)
+          this.process(w, l);
+        continue;
+      }
+      a.set(s.subarray(l, l + B), this.pos), this.pos += B, l += B, this.pos === y && (this.process(p, 0), this.pos = 0);
+    }
+    return this.length += s.length, this.roundClean(), this;
+  }
+  digestInto(s) {
+    Tt(this), yr(s, this), this.finished = !0;
+    const { buffer: p, view: a, blockLen: y, isLE: f } = this;
+    let { pos: l } = this;
+    p[l++] = 128, j(this.buffer.subarray(l)), this.padOffset > y - l && (this.process(a, 0), l = 0);
+    for (let g = l; g < y; g++)
+      p[g] = 0;
+    gr(a, y - 8, BigInt(this.length * 8), f), this.process(a, 0);
+    const B = ct(s), w = this.outputLen;
+    if (w % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const d = w / 4, o = this.get();
+    if (d > o.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let g = 0; g < d; g++)
+      B.setUint32(4 * g, o[g], f);
+  }
+  digest() {
+    const { buffer: s, outputLen: p } = this;
+    this.digestInto(s);
+    const a = s.slice(0, p);
+    return this.destroy(), a;
+  }
+  _cloneInto(s) {
+    s || (s = new this.constructor()), s.set(...this.get());
+    const { blockLen: p, buffer: a, length: y, finished: f, destroyed: l, pos: B } = this;
+    return s.destroyed = l, s.finished = f, s.length = y, s.pos = B, y % p && s.buffer.set(a), s;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const F = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), dr = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), $ = /* @__PURE__ */ new Uint32Array(64);
+class mr extends lt {
+  constructor(s = 32) {
+    super(64, s, 8, !1), this.A = F[0] | 0, this.B = F[1] | 0, this.C = F[2] | 0, this.D = F[3] | 0, this.E = F[4] | 0, this.F = F[5] | 0, this.G = F[6] | 0, this.H = F[7] | 0;
+  }
+  get() {
+    const { A: s, B: p, C: a, D: y, E: f, F: l, G: B, H: w } = this;
+    return [s, p, a, y, f, l, B, w];
+  }
+  // prettier-ignore
+  set(s, p, a, y, f, l, B, w) {
+    this.A = s | 0, this.B = p | 0, this.C = a | 0, this.D = y | 0, this.E = f | 0, this.F = l | 0, this.G = B | 0, this.H = w | 0;
+  }
+  process(s, p) {
+    for (let g = 0; g < 16; g++, p += 4)
+      $[g] = s.getUint32(p, !1);
+    for (let g = 16; g < 64; g++) {
+      const U = $[g - 15], E = $[g - 2], L = k(U, 7) ^ k(U, 18) ^ U >>> 3, P = k(E, 17) ^ k(E, 19) ^ E >>> 10;
+      $[g] = P + $[g - 7] + L + $[g - 16] | 0;
+    }
+    let { A: a, B: y, C: f, D: l, E: B, F: w, G: d, H: o } = this;
+    for (let g = 0; g < 64; g++) {
+      const U = k(B, 6) ^ k(B, 11) ^ k(B, 25), E = o + U + St(B, w, d) + dr[g] + $[g] | 0, P = (k(a, 2) ^ k(a, 13) ^ k(a, 22)) + Ct(a, y, f) | 0;
+      o = d, d = w, w = B, B = l + E | 0, l = f, f = y, y = a, a = E + P | 0;
+    }
+    a = a + this.A | 0, y = y + this.B | 0, f = f + this.C | 0, l = l + this.D | 0, B = B + this.E | 0, w = w + this.F | 0, d = d + this.G | 0, o = o + this.H | 0, this.set(a, y, f, l, B, w, d, o);
+  }
+  roundClean() {
+    j($);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), j(this.buffer);
+  }
+}
+const Er = /* @__PURE__ */ at(() => new mr()), tt = Er, Q = /* @__PURE__ */ Uint32Array.from([
+  1732584193,
+  4023233417,
+  2562383102,
+  271733878,
+  3285377520
+]), H = /* @__PURE__ */ new Uint32Array(80);
+class Ir extends lt {
+  constructor() {
+    super(64, 20, 8, !1), this.A = Q[0] | 0, this.B = Q[1] | 0, this.C = Q[2] | 0, this.D = Q[3] | 0, this.E = Q[4] | 0;
+  }
+  get() {
+    const { A: s, B: p, C: a, D: y, E: f } = this;
+    return [s, p, a, y, f];
+  }
+  set(s, p, a, y, f) {
+    this.A = s | 0, this.B = p | 0, this.C = a | 0, this.D = y | 0, this.E = f | 0;
+  }
+  process(s, p) {
+    for (let w = 0; w < 16; w++, p += 4)
+      H[w] = s.getUint32(p, !1);
+    for (let w = 16; w < 80; w++)
+      H[w] = G(H[w - 3] ^ H[w - 8] ^ H[w - 14] ^ H[w - 16], 1);
+    let { A: a, B: y, C: f, D: l, E: B } = this;
+    for (let w = 0; w < 80; w++) {
+      let d, o;
+      w < 20 ? (d = St(y, f, l), o = 1518500249) : w < 40 ? (d = y ^ f ^ l, o = 1859775393) : w < 60 ? (d = Ct(y, f, l), o = 2400959708) : (d = y ^ f ^ l, o = 3395469782);
+      const g = G(a, 5) + d + B + o + H[w] | 0;
+      B = l, l = f, f = G(y, 30), y = a, a = g;
+    }
+    a = a + this.A | 0, y = y + this.B | 0, f = f + this.C | 0, l = l + this.D | 0, B = B + this.E | 0, this.set(a, y, f, l, B);
+  }
+  roundClean() {
+    j(H);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0), j(this.buffer);
+  }
+}
+const xr = /* @__PURE__ */ at(() => new Ir()), Ar = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), Mt = Uint8Array.from(new Array(16).fill(0).map((c, s) => s)), br = Mt.map((c) => (9 * c + 5) % 16), kt = /* @__PURE__ */ (() => {
+  const p = [[Mt], [br]];
+  for (let a = 0; a < 4; a++)
+    for (let y of p)
+      y.push(y[a].map((f) => Ar[f]));
+  return p;
+})(), Nt = kt[0], Pt = kt[1], Dt = /* @__PURE__ */ [
+  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
+  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
+  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
+  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
+  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
+].map((c) => Uint8Array.from(c)), Ur = /* @__PURE__ */ Nt.map((c, s) => c.map((p) => Dt[s][p])), Tr = /* @__PURE__ */ Pt.map((c, s) => c.map((p) => Dt[s][p])), Rr = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), _r = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function Rt(c, s, p, a) {
+  return c === 0 ? s ^ p ^ a : c === 1 ? s & p | ~s & a : c === 2 ? (s | ~p) ^ a : c === 3 ? s & a | p & ~a : s ^ (p | ~a);
+}
+const v = /* @__PURE__ */ new Uint32Array(16);
+class Lr extends lt {
+  constructor() {
+    super(64, 20, 8, !0), this.h0 = 1732584193, this.h1 = -271733879, this.h2 = -1732584194, this.h3 = 271733878, this.h4 = -1009589776;
+  }
+  get() {
+    const { h0: s, h1: p, h2: a, h3: y, h4: f } = this;
+    return [s, p, a, y, f];
+  }
+  set(s, p, a, y, f) {
+    this.h0 = s | 0, this.h1 = p | 0, this.h2 = a | 0, this.h3 = y | 0, this.h4 = f | 0;
+  }
+  process(s, p) {
+    for (let E = 0; E < 16; E++, p += 4)
+      v[E] = s.getUint32(p, !0);
+    let a = this.h0 | 0, y = a, f = this.h1 | 0, l = f, B = this.h2 | 0, w = B, d = this.h3 | 0, o = d, g = this.h4 | 0, U = g;
+    for (let E = 0; E < 5; E++) {
+      const L = 4 - E, P = Rr[E], q = _r[E], it = Nt[E], X = Pt[E], et = Ur[E], J = Tr[E];
+      for (let C = 0; C < 16; C++) {
+        const W = G(a + Rt(E, f, B, d) + v[it[C]] + P, et[C]) + g | 0;
+        a = g, g = d, d = G(B, 10) | 0, B = f, f = W;
+      }
+      for (let C = 0; C < 16; C++) {
+        const W = G(y + Rt(L, l, w, o) + v[X[C]] + q, J[C]) + U | 0;
+        y = U, U = o, o = G(w, 10) | 0, w = l, l = W;
+      }
+    }
+    this.set(this.h1 + B + o | 0, this.h2 + d + U | 0, this.h3 + g + y | 0, this.h4 + a + l | 0, this.h0 + f + w | 0);
+  }
+  roundClean() {
+    j(v);
+  }
+  destroy() {
+    this.destroyed = !0, j(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const Sr = /* @__PURE__ */ at(() => new Lr()), Ft = Sr, Cr = xr;
+function Mr(c) {
+  return R.from(Ft(Uint8Array.from(c)));
+}
+function kr(c) {
+  return R.from(Cr(Uint8Array.from(c)));
+}
+function $t(c) {
+  return R.from(tt(Uint8Array.from(c)));
+}
+function Nr(c) {
+  return R.from(Ft(tt(Uint8Array.from(c))));
+}
+function Pr(c) {
+  return R.from(tt(tt(Uint8Array.from(c))));
+}
+const Dr = [
+  "BIP0340/challenge",
+  "BIP0340/aux",
+  "BIP0340/nonce",
+  "TapLeaf",
+  "TapBranch",
+  "TapSighash",
+  "TapTweak",
+  "KeyAgg list",
+  "KeyAgg coefficient"
+], Ht = {
+  "BIP0340/challenge": R.from([
+    123,
+    181,
+    45,
+    122,
+    159,
+    239,
+    88,
+    50,
+    62,
+    177,
+    191,
+    122,
+    64,
+    125,
+    179,
+    130,
+    210,
+    243,
+    242,
+    216,
+    27,
+    177,
+    34,
+    79,
+    73,
+    254,
+    81,
+    143,
+    109,
+    72,
+    211,
+    124,
+    123,
+    181,
+    45,
+    122,
+    159,
+    239,
+    88,
+    50,
+    62,
+    177,
+    191,
+    122,
+    64,
+    125,
+    179,
+    130,
+    210,
+    243,
+    242,
+    216,
+    27,
+    177,
+    34,
+    79,
+    73,
+    254,
+    81,
+    143,
+    109,
+    72,
+    211,
+    124
+  ]),
+  "BIP0340/aux": R.from([
+    241,
+    239,
+    78,
+    94,
+    192,
+    99,
+    202,
+    218,
+    109,
+    148,
+    202,
+    250,
+    157,
+    152,
+    126,
+    160,
+    105,
+    38,
+    88,
+    57,
+    236,
+    193,
+    31,
+    151,
+    45,
+    119,
+    165,
+    46,
+    216,
+    193,
+    204,
+    144,
+    241,
+    239,
+    78,
+    94,
+    192,
+    99,
+    202,
+    218,
+    109,
+    148,
+    202,
+    250,
+    157,
+    152,
+    126,
+    160,
+    105,
+    38,
+    88,
+    57,
+    236,
+    193,
+    31,
+    151,
+    45,
+    119,
+    165,
+    46,
+    216,
+    193,
+    204,
+    144
+  ]),
+  "BIP0340/nonce": R.from([
+    7,
+    73,
+    119,
+    52,
+    167,
+    155,
+    203,
+    53,
+    91,
+    155,
+    140,
+    125,
+    3,
+    79,
+    18,
+    28,
+    244,
+    52,
+    215,
+    62,
+    247,
+    45,
+    218,
+    25,
+    135,
+    0,
+    97,
+    251,
+    82,
+    191,
+    235,
+    47,
+    7,
+    73,
+    119,
+    52,
+    167,
+    155,
+    203,
+    53,
+    91,
+    155,
+    140,
+    125,
+    3,
+    79,
+    18,
+    28,
+    244,
+    52,
+    215,
+    62,
+    247,
+    45,
+    218,
+    25,
+    135,
+    0,
+    97,
+    251,
+    82,
+    191,
+    235,
+    47
+  ]),
+  TapLeaf: R.from([
+    174,
+    234,
+    143,
+    220,
+    66,
+    8,
+    152,
+    49,
+    5,
+    115,
+    75,
+    88,
+    8,
+    29,
+    30,
+    38,
+    56,
+    211,
+    95,
+    28,
+    181,
+    64,
+    8,
+    212,
+    211,
+    87,
+    202,
+    3,
+    190,
+    120,
+    233,
+    238,
+    174,
+    234,
+    143,
+    220,
+    66,
+    8,
+    152,
+    49,
+    5,
+    115,
+    75,
+    88,
+    8,
+    29,
+    30,
+    38,
+    56,
+    211,
+    95,
+    28,
+    181,
+    64,
+    8,
+    212,
+    211,
+    87,
+    202,
+    3,
+    190,
+    120,
+    233,
+    238
+  ]),
+  TapBranch: R.from([
+    25,
+    65,
+    161,
+    242,
+    229,
+    110,
+    185,
+    95,
+    162,
+    169,
+    241,
+    148,
+    190,
+    92,
+    1,
+    247,
+    33,
+    111,
+    51,
+    237,
+    130,
+    176,
+    145,
+    70,
+    52,
+    144,
+    208,
+    91,
+    245,
+    22,
+    160,
+    21,
+    25,
+    65,
+    161,
+    242,
+    229,
+    110,
+    185,
+    95,
+    162,
+    169,
+    241,
+    148,
+    190,
+    92,
+    1,
+    247,
+    33,
+    111,
+    51,
+    237,
+    130,
+    176,
+    145,
+    70,
+    52,
+    144,
+    208,
+    91,
+    245,
+    22,
+    160,
+    21
+  ]),
+  TapSighash: R.from([
+    244,
+    10,
+    72,
+    223,
+    75,
+    42,
+    112,
+    200,
+    180,
+    146,
+    75,
+    242,
+    101,
+    70,
+    97,
+    237,
+    61,
+    149,
+    253,
+    102,
+    163,
+    19,
+    235,
+    135,
+    35,
+    117,
+    151,
+    198,
+    40,
+    228,
+    160,
+    49,
+    244,
+    10,
+    72,
+    223,
+    75,
+    42,
+    112,
+    200,
+    180,
+    146,
+    75,
+    242,
+    101,
+    70,
+    97,
+    237,
+    61,
+    149,
+    253,
+    102,
+    163,
+    19,
+    235,
+    135,
+    35,
+    117,
+    151,
+    198,
+    40,
+    228,
+    160,
+    49
+  ]),
+  TapTweak: R.from([
+    232,
+    15,
+    225,
+    99,
+    156,
+    156,
+    160,
+    80,
+    227,
+    175,
+    27,
+    57,
+    193,
+    67,
+    198,
+    62,
+    66,
+    156,
+    188,
+    235,
+    21,
+    217,
+    64,
+    251,
+    181,
+    197,
+    161,
+    244,
+    175,
+    87,
+    197,
+    233,
+    232,
+    15,
+    225,
+    99,
+    156,
+    156,
+    160,
+    80,
+    227,
+    175,
+    27,
+    57,
+    193,
+    67,
+    198,
+    62,
+    66,
+    156,
+    188,
+    235,
+    21,
+    217,
+    64,
+    251,
+    181,
+    197,
+    161,
+    244,
+    175,
+    87,
+    197,
+    233
+  ]),
+  "KeyAgg list": R.from([
+    72,
+    28,
+    151,
+    28,
+    60,
+    11,
+    70,
+    215,
+    240,
+    178,
+    117,
+    174,
+    89,
+    141,
+    78,
+    44,
+    126,
+    215,
+    49,
+    156,
+    89,
+    74,
+    92,
+    110,
+    199,
+    158,
+    160,
+    212,
+    153,
+    2,
+    148,
+    240,
+    72,
+    28,
+    151,
+    28,
+    60,
+    11,
+    70,
+    215,
+    240,
+    178,
+    117,
+    174,
+    89,
+    141,
+    78,
+    44,
+    126,
+    215,
+    49,
+    156,
+    89,
+    74,
+    92,
+    110,
+    199,
+    158,
+    160,
+    212,
+    153,
+    2,
+    148,
+    240
+  ]),
+  "KeyAgg coefficient": R.from([
+    191,
+    201,
+    4,
+    3,
+    77,
+    28,
+    136,
+    232,
+    200,
+    14,
+    34,
+    229,
+    61,
+    36,
+    86,
+    109,
+    100,
+    130,
+    78,
+    214,
+    66,
+    114,
+    129,
+    192,
+    145,
+    0,
+    249,
+    77,
+    205,
+    82,
+    201,
+    129,
+    191,
+    201,
+    4,
+    3,
+    77,
+    28,
+    136,
+    232,
+    200,
+    14,
+    34,
+    229,
+    61,
+    36,
+    86,
+    109,
+    100,
+    130,
+    78,
+    214,
+    66,
+    114,
+    129,
+    192,
+    145,
+    0,
+    249,
+    77,
+    205,
+    82,
+    201,
+    129
+  ])
+};
+function Fr(c, s) {
+  return $t(R.concat([Ht[c], s]));
+}
+const Gr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  TAGGED_HASH_PREFIXES: Ht,
+  TAGS: Dr,
+  hash160: Nr,
+  hash256: Pr,
+  ripemd160: Mr,
+  sha1: kr,
+  sha256: $t,
+  taggedHash: Fr
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  R as B,
+  Dr as T,
+  kr as a,
+  $t as b,
+  Gr as c,
+  Pr as d,
+  Ht as e,
+  Hr as f,
+  Or as g,
+  Nr as h,
+  Mr as r,
+  tt as s,
+  Fr as t
+};