@btc-vision/transaction 1.7.19 → 1.7.23

package/browser/polyfills.js

@@ -0,0 +1,4590 @@
+import { f as It, g as ct, h as Tt, i as Ot, j as Lt, k as Mt, l as Ut } from "./vendors.js";
+var Nr = {}, ir = {};
+ir.byteLength = Ct;
+ir.toByteArray = Dt;
+ir.fromByteArray = xt;
+var xe = [], Ne = [], Nt = typeof Uint8Array < "u" ? Uint8Array : Array, ar = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var Je = 0, Pt = ar.length; Je < Pt; ++Je)
+  xe[Je] = ar[Je], Ne[ar.charCodeAt(Je)] = Je;
+Ne[45] = 62;
+Ne[95] = 63;
+function ht(c) {
+  var v = c.length;
+  if (v % 4 > 0)
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  var P = c.indexOf("=");
+  P === -1 && (P = v);
+  var D = P === v ? 0 : 4 - P % 4;
+  return [P, D];
+}
+function Ct(c) {
+  var v = ht(c), P = v[0], D = v[1];
+  return (P + D) * 3 / 4 - D;
+}
+function jt(c, v, P) {
+  return (v + P) * 3 / 4 - P;
+}
+function Dt(c) {
+  var v, P = ht(c), D = P[0], Y = P[1], h = new Nt(jt(c, D, Y)), y = 0, O = Y > 0 ? D - 4 : D, p;
+  for (p = 0; p < O; p += 4)
+    v = Ne[c.charCodeAt(p)] << 18 | Ne[c.charCodeAt(p + 1)] << 12 | Ne[c.charCodeAt(p + 2)] << 6 | Ne[c.charCodeAt(p + 3)], h[y++] = v >> 16 & 255, h[y++] = v >> 8 & 255, h[y++] = v & 255;
+  return Y === 2 && (v = Ne[c.charCodeAt(p)] << 2 | Ne[c.charCodeAt(p + 1)] >> 4, h[y++] = v & 255), Y === 1 && (v = Ne[c.charCodeAt(p)] << 10 | Ne[c.charCodeAt(p + 1)] << 4 | Ne[c.charCodeAt(p + 2)] >> 2, h[y++] = v >> 8 & 255, h[y++] = v & 255), h;
+}
+function kt(c) {
+  return xe[c >> 18 & 63] + xe[c >> 12 & 63] + xe[c >> 6 & 63] + xe[c & 63];
+}
+function Ft(c, v, P) {
+  for (var D, Y = [], h = v; h < P; h += 3)
+    D = (c[h] << 16 & 16711680) + (c[h + 1] << 8 & 65280) + (c[h + 2] & 255), Y.push(kt(D));
+  return Y.join("");
+}
+function xt(c) {
+  for (var v, P = c.length, D = P % 3, Y = [], h = 16383, y = 0, O = P - D; y < O; y += h)
+    Y.push(Ft(c, y, y + h > O ? O : y + h));
+  return D === 1 ? (v = c[P - 1], Y.push(
+    xe[v >> 2] + xe[v << 4 & 63] + "=="
+  )) : D === 2 && (v = (c[P - 2] << 8) + c[P - 1], Y.push(
+    xe[v >> 10] + xe[v >> 4 & 63] + xe[v << 2 & 63] + "="
+  )), Y.join("");
+}
+var Pr = {};
+Pr.read = function(c, v, P, D, Y) {
+  var h, y, O = Y * 8 - D - 1, p = (1 << O) - 1, N = p >> 1, l = -7, k = P ? Y - 1 : 0, j = P ? -1 : 1, J = c[v + k];
+  for (k += j, h = J & (1 << -l) - 1, J >>= -l, l += O; l > 0; h = h * 256 + c[v + k], k += j, l -= 8)
+    ;
+  for (y = h & (1 << -l) - 1, h >>= -l, l += D; l > 0; y = y * 256 + c[v + k], k += j, l -= 8)
+    ;
+  if (h === 0)
+    h = 1 - N;
+  else {
+    if (h === p)
+      return y ? NaN : (J ? -1 : 1) * (1 / 0);
+    y = y + Math.pow(2, D), h = h - N;
+  }
+  return (J ? -1 : 1) * y * Math.pow(2, h - D);
+};
+Pr.write = function(c, v, P, D, Y, h) {
+  var y, O, p, N = h * 8 - Y - 1, l = (1 << N) - 1, k = l >> 1, j = Y === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, J = D ? 0 : h - 1, V = D ? 1 : -1, X = v < 0 || v === 0 && 1 / v < 0 ? 1 : 0;
+  for (v = Math.abs(v), isNaN(v) || v === 1 / 0 ? (O = isNaN(v) ? 1 : 0, y = l) : (y = Math.floor(Math.log(v) / Math.LN2), v * (p = Math.pow(2, -y)) < 1 && (y--, p *= 2), y + k >= 1 ? v += j / p : v += j * Math.pow(2, 1 - k), v * p >= 2 && (y++, p /= 2), y + k >= l ? (O = 0, y = l) : y + k >= 1 ? (O = (v * p - 1) * Math.pow(2, Y), y = y + k) : (O = v * Math.pow(2, k - 1) * Math.pow(2, Y), y = 0)); Y >= 8; c[P + J] = O & 255, J += V, O /= 256, Y -= 8)
+    ;
+  for (y = y << Y | O, N += Y; N > 0; c[P + J] = y & 255, J += V, y /= 256, N -= 8)
+    ;
+  c[P + J - V] |= X * 128;
+};
+(function(c) {
+  const v = ir, P = Pr, D = typeof Symbol == "function" && typeof Symbol.for == "function" ? /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom") : null;
+  c.Buffer = l, c.SlowBuffer = m, c.INSPECT_MAX_BYTES = 50;
+  const Y = 2147483647;
+  c.kMaxLength = Y;
+  const { Uint8Array: h, ArrayBuffer: y, SharedArrayBuffer: O } = globalThis;
+  l.TYPED_ARRAY_SUPPORT = p(), !l.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 p() {
+    try {
+      const i = new h(1), e = { foo: function() {
+        return 42;
+      } };
+      return Object.setPrototypeOf(e, h.prototype), Object.setPrototypeOf(i, e), i.foo() === 42;
+    } catch {
+      return !1;
+    }
+  }
+  Object.defineProperty(l.prototype, "parent", {
+    enumerable: !0,
+    get: function() {
+      if (l.isBuffer(this))
+        return this.buffer;
+    }
+  }), Object.defineProperty(l.prototype, "offset", {
+    enumerable: !0,
+    get: function() {
+      if (l.isBuffer(this))
+        return this.byteOffset;
+    }
+  });
+  function N(i) {
+    if (i > Y)
+      throw new RangeError('The value "' + i + '" is invalid for option "size"');
+    const e = new h(i);
+    return Object.setPrototypeOf(e, l.prototype), e;
+  }
+  function l(i, e, t) {
+    if (typeof i == "number") {
+      if (typeof e == "string")
+        throw new TypeError(
+          'The "string" argument must be of type string. Received type number'
+        );
+      return V(i);
+    }
+    return k(i, e, t);
+  }
+  l.poolSize = 8192;
+  function k(i, e, t) {
+    if (typeof i == "string")
+      return X(i, e);
+    if (y.isView(i))
+      return w(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 (Oe(i, y) || i && Oe(i.buffer, y) || typeof O < "u" && (Oe(i, O) || i && Oe(i.buffer, O)))
+      return B(i, e, t);
+    if (typeof i == "number")
+      throw new TypeError(
+        'The "value" argument must not be of type number. Received type number'
+      );
+    const a = i.valueOf && i.valueOf();
+    if (a != null && a !== i)
+      return l.from(a, e, t);
+    const g = R(i);
+    if (g) return g;
+    if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof i[Symbol.toPrimitive] == "function")
+      return l.from(i[Symbol.toPrimitive]("string"), e, t);
+    throw new TypeError(
+      "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof i
+    );
+  }
+  l.from = function(i, e, t) {
+    return k(i, e, t);
+  }, Object.setPrototypeOf(l.prototype, h.prototype), Object.setPrototypeOf(l, h);
+  function j(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 J(i, e, t) {
+    return j(i), i <= 0 ? N(i) : e !== void 0 ? typeof t == "string" ? N(i).fill(e, t) : N(i).fill(e) : N(i);
+  }
+  l.alloc = function(i, e, t) {
+    return J(i, e, t);
+  };
+  function V(i) {
+    return j(i), N(i < 0 ? 0 : d(i) | 0);
+  }
+  l.allocUnsafe = function(i) {
+    return V(i);
+  }, l.allocUnsafeSlow = function(i) {
+    return V(i);
+  };
+  function X(i, e) {
+    if ((typeof e != "string" || e === "") && (e = "utf8"), !l.isEncoding(e))
+      throw new TypeError("Unknown encoding: " + e);
+    const t = A(i, e) | 0;
+    let a = N(t);
+    const g = a.write(i, e);
+    return g !== t && (a = a.slice(0, g)), a;
+  }
+  function K(i) {
+    const e = i.length < 0 ? 0 : d(i.length) | 0, t = N(e);
+    for (let a = 0; a < e; a += 1)
+      t[a] = i[a] & 255;
+    return t;
+  }
+  function w(i) {
+    if (Oe(i, h)) {
+      const e = new h(i);
+      return B(e.buffer, e.byteOffset, e.byteLength);
+    }
+    return K(i);
+  }
+  function B(i, e, t) {
+    if (e < 0 || i.byteLength < e)
+      throw new RangeError('"offset" is outside of buffer bounds');
+    if (i.byteLength < e + (t || 0))
+      throw new RangeError('"length" is outside of buffer bounds');
+    let a;
+    return e === void 0 && t === void 0 ? a = new h(i) : t === void 0 ? a = new h(i, e) : a = new h(i, e, t), Object.setPrototypeOf(a, l.prototype), a;
+  }
+  function R(i) {
+    if (l.isBuffer(i)) {
+      const e = d(i.length) | 0, t = N(e);
+      return t.length === 0 || i.copy(t, 0, 0, e), t;
+    }
+    if (i.length !== void 0)
+      return typeof i.length != "number" || Ue(i.length) ? N(0) : K(i);
+    if (i.type === "Buffer" && Array.isArray(i.data))
+      return K(i.data);
+  }
+  function d(i) {
+    if (i >= Y)
+      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + Y.toString(16) + " bytes");
+    return i | 0;
+  }
+  function m(i) {
+    return +i != i && (i = 0), l.alloc(+i);
+  }
+  l.isBuffer = function(e) {
+    return e != null && e._isBuffer === !0 && e !== l.prototype;
+  }, l.compare = function(e, t) {
+    if (Oe(e, h) && (e = l.from(e, e.offset, e.byteLength)), Oe(t, h) && (t = l.from(t, t.offset, t.byteLength)), !l.isBuffer(e) || !l.isBuffer(t))
+      throw new TypeError(
+        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+      );
+    if (e === t) return 0;
+    let a = e.length, g = t.length;
+    for (let T = 0, x = Math.min(a, g); T < x; ++T)
+      if (e[T] !== t[T]) {
+        a = e[T], g = t[T];
+        break;
+      }
+    return a < g ? -1 : g < a ? 1 : 0;
+  }, l.isEncoding = function(e) {
+    switch (String(e).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;
+    }
+  }, l.concat = function(e, t) {
+    if (!Array.isArray(e))
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    if (e.length === 0)
+      return l.alloc(0);
+    let a;
+    if (t === void 0)
+      for (t = 0, a = 0; a < e.length; ++a)
+        t += e[a].length;
+    const g = l.allocUnsafe(t);
+    let T = 0;
+    for (a = 0; a < e.length; ++a) {
+      let x = e[a];
+      if (Oe(x, h))
+        T + x.length > g.length ? (l.isBuffer(x) || (x = l.from(x)), x.copy(g, T)) : h.prototype.set.call(
+          g,
+          x,
+          T
+        );
+      else if (l.isBuffer(x))
+        x.copy(g, T);
+      else
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      T += x.length;
+    }
+    return g;
+  };
+  function A(i, e) {
+    if (l.isBuffer(i))
+      return i.length;
+    if (y.isView(i) || Oe(i, y))
+      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 t = i.length, a = arguments.length > 2 && arguments[2] === !0;
+    if (!a && t === 0) return 0;
+    let g = !1;
+    for (; ; )
+      switch (e) {
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return t;
+        case "utf8":
+        case "utf-8":
+          return je(i).length;
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return t * 2;
+        case "hex":
+          return t >>> 1;
+        case "base64":
+          return _e(i).length;
+        default:
+          if (g)
+            return a ? -1 : je(i).length;
+          e = ("" + e).toLowerCase(), g = !0;
+      }
+  }
+  l.byteLength = A;
+  function M(i, e, t) {
+    let a = !1;
+    if ((e === void 0 || e < 0) && (e = 0), e > this.length || ((t === void 0 || t > this.length) && (t = this.length), t <= 0) || (t >>>= 0, e >>>= 0, t <= e))
+      return "";
+    for (i || (i = "utf8"); ; )
+      switch (i) {
+        case "hex":
+          return I(this, e, t);
+        case "utf8":
+        case "utf-8":
+          return Re(this, e, t);
+        case "ascii":
+          return Te(this, e, t);
+        case "latin1":
+        case "binary":
+          return Le(this, e, t);
+        case "base64":
+          return Be(this, e, t);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return F(this, e, t);
+        default:
+          if (a) throw new TypeError("Unknown encoding: " + i);
+          i = (i + "").toLowerCase(), a = !0;
+      }
+  }
+  l.prototype._isBuffer = !0;
+  function U(i, e, t) {
+    const a = i[e];
+    i[e] = i[t], i[t] = a;
+  }
+  l.prototype.swap16 = function() {
+    const e = this.length;
+    if (e % 2 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 16-bits");
+    for (let t = 0; t < e; t += 2)
+      U(this, t, t + 1);
+    return this;
+  }, l.prototype.swap32 = function() {
+    const e = this.length;
+    if (e % 4 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 32-bits");
+    for (let t = 0; t < e; t += 4)
+      U(this, t, t + 3), U(this, t + 1, t + 2);
+    return this;
+  }, l.prototype.swap64 = function() {
+    const e = this.length;
+    if (e % 8 !== 0)
+      throw new RangeError("Buffer size must be a multiple of 64-bits");
+    for (let t = 0; t < e; t += 8)
+      U(this, t, t + 7), U(this, t + 1, t + 6), U(this, t + 2, t + 5), U(this, t + 3, t + 4);
+    return this;
+  }, l.prototype.toString = function() {
+    const e = this.length;
+    return e === 0 ? "" : arguments.length === 0 ? Re(this, 0, e) : M.apply(this, arguments);
+  }, l.prototype.toLocaleString = l.prototype.toString, l.prototype.equals = function(e) {
+    if (!l.isBuffer(e)) throw new TypeError("Argument must be a Buffer");
+    return this === e ? !0 : l.compare(this, e) === 0;
+  }, l.prototype.inspect = function() {
+    let e = "";
+    const t = c.INSPECT_MAX_BYTES;
+    return e = this.toString("hex", 0, t).replace(/(.{2})/g, "$1 ").trim(), this.length > t && (e += " ... "), "<Buffer " + e + ">";
+  }, D && (l.prototype[D] = l.prototype.inspect), l.prototype.compare = function(e, t, a, g, T) {
+    if (Oe(e, h) && (e = l.from(e, e.offset, e.byteLength)), !l.isBuffer(e))
+      throw new TypeError(
+        'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof e
+      );
+    if (t === void 0 && (t = 0), a === void 0 && (a = e ? e.length : 0), g === void 0 && (g = 0), T === void 0 && (T = this.length), t < 0 || a > e.length || g < 0 || T > this.length)
+      throw new RangeError("out of range index");
+    if (g >= T && t >= a)
+      return 0;
+    if (g >= T)
+      return -1;
+    if (t >= a)
+      return 1;
+    if (t >>>= 0, a >>>= 0, g >>>= 0, T >>>= 0, this === e) return 0;
+    let x = T - g, ie = a - t;
+    const pe = Math.min(x, ie), de = this.slice(g, T), ge = e.slice(t, a);
+    for (let le = 0; le < pe; ++le)
+      if (de[le] !== ge[le]) {
+        x = de[le], ie = ge[le];
+        break;
+      }
+    return x < ie ? -1 : ie < x ? 1 : 0;
+  };
+  function z(i, e, t, a, g) {
+    if (i.length === 0) return -1;
+    if (typeof t == "string" ? (a = t, t = 0) : t > 2147483647 ? t = 2147483647 : t < -2147483648 && (t = -2147483648), t = +t, Ue(t) && (t = g ? 0 : i.length - 1), t < 0 && (t = i.length + t), t >= i.length) {
+      if (g) return -1;
+      t = i.length - 1;
+    } else if (t < 0)
+      if (g) t = 0;
+      else return -1;
+    if (typeof e == "string" && (e = l.from(e, a)), l.isBuffer(e))
+      return e.length === 0 ? -1 : Q(i, e, t, a, g);
+    if (typeof e == "number")
+      return e = e & 255, typeof h.prototype.indexOf == "function" ? g ? h.prototype.indexOf.call(i, e, t) : h.prototype.lastIndexOf.call(i, e, t) : Q(i, [e], t, a, g);
+    throw new TypeError("val must be string, number or Buffer");
+  }
+  function Q(i, e, t, a, g) {
+    let T = 1, x = i.length, ie = e.length;
+    if (a !== void 0 && (a = String(a).toLowerCase(), a === "ucs2" || a === "ucs-2" || a === "utf16le" || a === "utf-16le")) {
+      if (i.length < 2 || e.length < 2)
+        return -1;
+      T = 2, x /= 2, ie /= 2, t /= 2;
+    }
+    function pe(ge, le) {
+      return T === 1 ? ge[le] : ge.readUInt16BE(le * T);
+    }
+    let de;
+    if (g) {
+      let ge = -1;
+      for (de = t; de < x; de++)
+        if (pe(i, de) === pe(e, ge === -1 ? 0 : de - ge)) {
+          if (ge === -1 && (ge = de), de - ge + 1 === ie) return ge * T;
+        } else
+          ge !== -1 && (de -= de - ge), ge = -1;
+    } else
+      for (t + ie > x && (t = x - ie), de = t; de >= 0; de--) {
+        let ge = !0;
+        for (let le = 0; le < ie; le++)
+          if (pe(i, de + le) !== pe(e, le)) {
+            ge = !1;
+            break;
+          }
+        if (ge) return de;
+      }
+    return -1;
+  }
+  l.prototype.includes = function(e, t, a) {
+    return this.indexOf(e, t, a) !== -1;
+  }, l.prototype.indexOf = function(e, t, a) {
+    return z(this, e, t, a, !0);
+  }, l.prototype.lastIndexOf = function(e, t, a) {
+    return z(this, e, t, a, !1);
+  };
+  function ne(i, e, t, a) {
+    t = Number(t) || 0;
+    const g = i.length - t;
+    a ? (a = Number(a), a > g && (a = g)) : a = g;
+    const T = e.length;
+    a > T / 2 && (a = T / 2);
+    let x;
+    for (x = 0; x < a; ++x) {
+      const ie = parseInt(e.substr(x * 2, 2), 16);
+      if (Ue(ie)) return x;
+      i[t + x] = ie;
+    }
+    return x;
+  }
+  function S(i, e, t, a) {
+    return Pe(je(e, i.length - t), i, t, a);
+  }
+  function se(i, e, t, a) {
+    return Pe(Ke(e), i, t, a);
+  }
+  function he(i, e, t, a) {
+    return Pe(_e(e), i, t, a);
+  }
+  function ye(i, e, t, a) {
+    return Pe(me(e, i.length - t), i, t, a);
+  }
+  l.prototype.write = function(e, t, a, g) {
+    if (t === void 0)
+      g = "utf8", a = this.length, t = 0;
+    else if (a === void 0 && typeof t == "string")
+      g = t, a = this.length, t = 0;
+    else if (isFinite(t))
+      t = t >>> 0, isFinite(a) ? (a = a >>> 0, g === void 0 && (g = "utf8")) : (g = a, a = void 0);
+    else
+      throw new Error(
+        "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+      );
+    const T = this.length - t;
+    if ((a === void 0 || a > T) && (a = T), e.length > 0 && (a < 0 || t < 0) || t > this.length)
+      throw new RangeError("Attempt to write outside buffer bounds");
+    g || (g = "utf8");
+    let x = !1;
+    for (; ; )
+      switch (g) {
+        case "hex":
+          return ne(this, e, t, a);
+        case "utf8":
+        case "utf-8":
+          return S(this, e, t, a);
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return se(this, e, t, a);
+        case "base64":
+          return he(this, e, t, a);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return ye(this, e, t, a);
+        default:
+          if (x) throw new TypeError("Unknown encoding: " + g);
+          g = ("" + g).toLowerCase(), x = !0;
+      }
+  }, l.prototype.toJSON = function() {
+    return {
+      type: "Buffer",
+      data: Array.prototype.slice.call(this._arr || this, 0)
+    };
+  };
+  function Be(i, e, t) {
+    return e === 0 && t === i.length ? v.fromByteArray(i) : v.fromByteArray(i.slice(e, t));
+  }
+  function Re(i, e, t) {
+    t = Math.min(i.length, t);
+    const a = [];
+    let g = e;
+    for (; g < t; ) {
+      const T = i[g];
+      let x = null, ie = T > 239 ? 4 : T > 223 ? 3 : T > 191 ? 2 : 1;
+      if (g + ie <= t) {
+        let pe, de, ge, le;
+        switch (ie) {
+          case 1:
+            T < 128 && (x = T);
+            break;
+          case 2:
+            pe = i[g + 1], (pe & 192) === 128 && (le = (T & 31) << 6 | pe & 63, le > 127 && (x = le));
+            break;
+          case 3:
+            pe = i[g + 1], de = i[g + 2], (pe & 192) === 128 && (de & 192) === 128 && (le = (T & 15) << 12 | (pe & 63) << 6 | de & 63, le > 2047 && (le < 55296 || le > 57343) && (x = le));
+            break;
+          case 4:
+            pe = i[g + 1], de = i[g + 2], ge = i[g + 3], (pe & 192) === 128 && (de & 192) === 128 && (ge & 192) === 128 && (le = (T & 15) << 18 | (pe & 63) << 12 | (de & 63) << 6 | ge & 63, le > 65535 && le < 1114112 && (x = le));
+        }
+      }
+      x === null ? (x = 65533, ie = 1) : x > 65535 && (x -= 65536, a.push(x >>> 10 & 1023 | 55296), x = 56320 | x & 1023), a.push(x), g += ie;
+    }
+    return Se(a);
+  }
+  const Ae = 4096;
+  function Se(i) {
+    const e = i.length;
+    if (e <= Ae)
+      return String.fromCharCode.apply(String, i);
+    let t = "", a = 0;
+    for (; a < e; )
+      t += String.fromCharCode.apply(
+        String,
+        i.slice(a, a += Ae)
+      );
+    return t;
+  }
+  function Te(i, e, t) {
+    let a = "";
+    t = Math.min(i.length, t);
+    for (let g = e; g < t; ++g)
+      a += String.fromCharCode(i[g] & 127);
+    return a;
+  }
+  function Le(i, e, t) {
+    let a = "";
+    t = Math.min(i.length, t);
+    for (let g = e; g < t; ++g)
+      a += String.fromCharCode(i[g]);
+    return a;
+  }
+  function I(i, e, t) {
+    const a = i.length;
+    (!e || e < 0) && (e = 0), (!t || t < 0 || t > a) && (t = a);
+    let g = "";
+    for (let T = e; T < t; ++T)
+      g += Ce[i[T]];
+    return g;
+  }
+  function F(i, e, t) {
+    const a = i.slice(e, t);
+    let g = "";
+    for (let T = 0; T < a.length - 1; T += 2)
+      g += String.fromCharCode(a[T] + a[T + 1] * 256);
+    return g;
+  }
+  l.prototype.slice = function(e, t) {
+    const a = this.length;
+    e = ~~e, t = t === void 0 ? a : ~~t, e < 0 ? (e += a, e < 0 && (e = 0)) : e > a && (e = a), t < 0 ? (t += a, t < 0 && (t = 0)) : t > a && (t = a), t < e && (t = e);
+    const g = this.subarray(e, t);
+    return Object.setPrototypeOf(g, l.prototype), g;
+  };
+  function q(i, e, t) {
+    if (i % 1 !== 0 || i < 0) throw new RangeError("offset is not uint");
+    if (i + e > t) throw new RangeError("Trying to access beyond buffer length");
+  }
+  l.prototype.readUintLE = l.prototype.readUIntLE = function(e, t, a) {
+    e = e >>> 0, t = t >>> 0, a || q(e, t, this.length);
+    let g = this[e], T = 1, x = 0;
+    for (; ++x < t && (T *= 256); )
+      g += this[e + x] * T;
+    return g;
+  }, l.prototype.readUintBE = l.prototype.readUIntBE = function(e, t, a) {
+    e = e >>> 0, t = t >>> 0, a || q(e, t, this.length);
+    let g = this[e + --t], T = 1;
+    for (; t > 0 && (T *= 256); )
+      g += this[e + --t] * T;
+    return g;
+  }, l.prototype.readUint8 = l.prototype.readUInt8 = function(e, t) {
+    return e = e >>> 0, t || q(e, 1, this.length), this[e];
+  }, l.prototype.readUint16LE = l.prototype.readUInt16LE = function(e, t) {
+    return e = e >>> 0, t || q(e, 2, this.length), this[e] | this[e + 1] << 8;
+  }, l.prototype.readUint16BE = l.prototype.readUInt16BE = function(e, t) {
+    return e = e >>> 0, t || q(e, 2, this.length), this[e] << 8 | this[e + 1];
+  }, l.prototype.readUint32LE = l.prototype.readUInt32LE = function(e, t) {
+    return e = e >>> 0, t || q(e, 4, this.length), (this[e] | this[e + 1] << 8 | this[e + 2] << 16) + this[e + 3] * 16777216;
+  }, l.prototype.readUint32BE = l.prototype.readUInt32BE = function(e, t) {
+    return e = e >>> 0, t || q(e, 4, this.length), this[e] * 16777216 + (this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3]);
+  }, l.prototype.readBigUInt64LE = Ie(function(e) {
+    e = e >>> 0, te(e, "offset");
+    const t = this[e], a = this[e + 7];
+    (t === void 0 || a === void 0) && ae(e, this.length - 8);
+    const g = t + this[++e] * 2 ** 8 + this[++e] * 2 ** 16 + this[++e] * 2 ** 24, T = this[++e] + this[++e] * 2 ** 8 + this[++e] * 2 ** 16 + a * 2 ** 24;
+    return BigInt(g) + (BigInt(T) << BigInt(32));
+  }), l.prototype.readBigUInt64BE = Ie(function(e) {
+    e = e >>> 0, te(e, "offset");
+    const t = this[e], a = this[e + 7];
+    (t === void 0 || a === void 0) && ae(e, this.length - 8);
+    const g = t * 2 ** 24 + this[++e] * 2 ** 16 + this[++e] * 2 ** 8 + this[++e], T = this[++e] * 2 ** 24 + this[++e] * 2 ** 16 + this[++e] * 2 ** 8 + a;
+    return (BigInt(g) << BigInt(32)) + BigInt(T);
+  }), l.prototype.readIntLE = function(e, t, a) {
+    e = e >>> 0, t = t >>> 0, a || q(e, t, this.length);
+    let g = this[e], T = 1, x = 0;
+    for (; ++x < t && (T *= 256); )
+      g += this[e + x] * T;
+    return T *= 128, g >= T && (g -= Math.pow(2, 8 * t)), g;
+  }, l.prototype.readIntBE = function(e, t, a) {
+    e = e >>> 0, t = t >>> 0, a || q(e, t, this.length);
+    let g = t, T = 1, x = this[e + --g];
+    for (; g > 0 && (T *= 256); )
+      x += this[e + --g] * T;
+    return T *= 128, x >= T && (x -= Math.pow(2, 8 * t)), x;
+  }, l.prototype.readInt8 = function(e, t) {
+    return e = e >>> 0, t || q(e, 1, this.length), this[e] & 128 ? (255 - this[e] + 1) * -1 : this[e];
+  }, l.prototype.readInt16LE = function(e, t) {
+    e = e >>> 0, t || q(e, 2, this.length);
+    const a = this[e] | this[e + 1] << 8;
+    return a & 32768 ? a | 4294901760 : a;
+  }, l.prototype.readInt16BE = function(e, t) {
+    e = e >>> 0, t || q(e, 2, this.length);
+    const a = this[e + 1] | this[e] << 8;
+    return a & 32768 ? a | 4294901760 : a;
+  }, l.prototype.readInt32LE = function(e, t) {
+    return e = e >>> 0, t || q(e, 4, this.length), this[e] | this[e + 1] << 8 | this[e + 2] << 16 | this[e + 3] << 24;
+  }, l.prototype.readInt32BE = function(e, t) {
+    return e = e >>> 0, t || q(e, 4, this.length), this[e] << 24 | this[e + 1] << 16 | this[e + 2] << 8 | this[e + 3];
+  }, l.prototype.readBigInt64LE = Ie(function(e) {
+    e = e >>> 0, te(e, "offset");
+    const t = this[e], a = this[e + 7];
+    (t === void 0 || a === void 0) && ae(e, this.length - 8);
+    const g = this[e + 4] + this[e + 5] * 2 ** 8 + this[e + 6] * 2 ** 16 + (a << 24);
+    return (BigInt(g) << BigInt(32)) + BigInt(t + this[++e] * 2 ** 8 + this[++e] * 2 ** 16 + this[++e] * 2 ** 24);
+  }), l.prototype.readBigInt64BE = Ie(function(e) {
+    e = e >>> 0, te(e, "offset");
+    const t = this[e], a = this[e + 7];
+    (t === void 0 || a === void 0) && ae(e, this.length - 8);
+    const g = (t << 24) + // Overflow
+    this[++e] * 2 ** 16 + this[++e] * 2 ** 8 + this[++e];
+    return (BigInt(g) << BigInt(32)) + BigInt(this[++e] * 2 ** 24 + this[++e] * 2 ** 16 + this[++e] * 2 ** 8 + a);
+  }), l.prototype.readFloatLE = function(e, t) {
+    return e = e >>> 0, t || q(e, 4, this.length), P.read(this, e, !0, 23, 4);
+  }, l.prototype.readFloatBE = function(e, t) {
+    return e = e >>> 0, t || q(e, 4, this.length), P.read(this, e, !1, 23, 4);
+  }, l.prototype.readDoubleLE = function(e, t) {
+    return e = e >>> 0, t || q(e, 8, this.length), P.read(this, e, !0, 52, 8);
+  }, l.prototype.readDoubleBE = function(e, t) {
+    return e = e >>> 0, t || q(e, 8, this.length), P.read(this, e, !1, 52, 8);
+  };
+  function re(i, e, t, a, g, T) {
+    if (!l.isBuffer(i)) throw new TypeError('"buffer" argument must be a Buffer instance');
+    if (e > g || e < T) throw new RangeError('"value" argument is out of bounds');
+    if (t + a > i.length) throw new RangeError("Index out of range");
+  }
+  l.prototype.writeUintLE = l.prototype.writeUIntLE = function(e, t, a, g) {
+    if (e = +e, t = t >>> 0, a = a >>> 0, !g) {
+      const ie = Math.pow(2, 8 * a) - 1;
+      re(this, e, t, a, ie, 0);
+    }
+    let T = 1, x = 0;
+    for (this[t] = e & 255; ++x < a && (T *= 256); )
+      this[t + x] = e / T & 255;
+    return t + a;
+  }, l.prototype.writeUintBE = l.prototype.writeUIntBE = function(e, t, a, g) {
+    if (e = +e, t = t >>> 0, a = a >>> 0, !g) {
+      const ie = Math.pow(2, 8 * a) - 1;
+      re(this, e, t, a, ie, 0);
+    }
+    let T = a - 1, x = 1;
+    for (this[t + T] = e & 255; --T >= 0 && (x *= 256); )
+      this[t + T] = e / x & 255;
+    return t + a;
+  }, l.prototype.writeUint8 = l.prototype.writeUInt8 = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 1, 255, 0), this[t] = e & 255, t + 1;
+  }, l.prototype.writeUint16LE = l.prototype.writeUInt16LE = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 2, 65535, 0), this[t] = e & 255, this[t + 1] = e >>> 8, t + 2;
+  }, l.prototype.writeUint16BE = l.prototype.writeUInt16BE = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 2, 65535, 0), this[t] = e >>> 8, this[t + 1] = e & 255, t + 2;
+  }, l.prototype.writeUint32LE = l.prototype.writeUInt32LE = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 4, 4294967295, 0), this[t + 3] = e >>> 24, this[t + 2] = e >>> 16, this[t + 1] = e >>> 8, this[t] = e & 255, t + 4;
+  }, l.prototype.writeUint32BE = l.prototype.writeUInt32BE = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 4, 4294967295, 0), this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = e & 255, t + 4;
+  };
+  function b(i, e, t, a, g) {
+    fe(e, a, g, i, t, 7);
+    let T = Number(e & BigInt(4294967295));
+    i[t++] = T, T = T >> 8, i[t++] = T, T = T >> 8, i[t++] = T, T = T >> 8, i[t++] = T;
+    let x = Number(e >> BigInt(32) & BigInt(4294967295));
+    return i[t++] = x, x = x >> 8, i[t++] = x, x = x >> 8, i[t++] = x, x = x >> 8, i[t++] = x, t;
+  }
+  function _(i, e, t, a, g) {
+    fe(e, a, g, i, t, 7);
+    let T = Number(e & BigInt(4294967295));
+    i[t + 7] = T, T = T >> 8, i[t + 6] = T, T = T >> 8, i[t + 5] = T, T = T >> 8, i[t + 4] = T;
+    let x = Number(e >> BigInt(32) & BigInt(4294967295));
+    return i[t + 3] = x, x = x >> 8, i[t + 2] = x, x = x >> 8, i[t + 1] = x, x = x >> 8, i[t] = x, t + 8;
+  }
+  l.prototype.writeBigUInt64LE = Ie(function(e, t = 0) {
+    return b(this, e, t, BigInt(0), BigInt("0xffffffffffffffff"));
+  }), l.prototype.writeBigUInt64BE = Ie(function(e, t = 0) {
+    return _(this, e, t, BigInt(0), BigInt("0xffffffffffffffff"));
+  }), l.prototype.writeIntLE = function(e, t, a, g) {
+    if (e = +e, t = t >>> 0, !g) {
+      const pe = Math.pow(2, 8 * a - 1);
+      re(this, e, t, a, pe - 1, -pe);
+    }
+    let T = 0, x = 1, ie = 0;
+    for (this[t] = e & 255; ++T < a && (x *= 256); )
+      e < 0 && ie === 0 && this[t + T - 1] !== 0 && (ie = 1), this[t + T] = (e / x >> 0) - ie & 255;
+    return t + a;
+  }, l.prototype.writeIntBE = function(e, t, a, g) {
+    if (e = +e, t = t >>> 0, !g) {
+      const pe = Math.pow(2, 8 * a - 1);
+      re(this, e, t, a, pe - 1, -pe);
+    }
+    let T = a - 1, x = 1, ie = 0;
+    for (this[t + T] = e & 255; --T >= 0 && (x *= 256); )
+      e < 0 && ie === 0 && this[t + T + 1] !== 0 && (ie = 1), this[t + T] = (e / x >> 0) - ie & 255;
+    return t + a;
+  }, l.prototype.writeInt8 = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 1, 127, -128), e < 0 && (e = 255 + e + 1), this[t] = e & 255, t + 1;
+  }, l.prototype.writeInt16LE = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 2, 32767, -32768), this[t] = e & 255, this[t + 1] = e >>> 8, t + 2;
+  }, l.prototype.writeInt16BE = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 2, 32767, -32768), this[t] = e >>> 8, this[t + 1] = e & 255, t + 2;
+  }, l.prototype.writeInt32LE = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 4, 2147483647, -2147483648), this[t] = e & 255, this[t + 1] = e >>> 8, this[t + 2] = e >>> 16, this[t + 3] = e >>> 24, t + 4;
+  }, l.prototype.writeInt32BE = function(e, t, a) {
+    return e = +e, t = t >>> 0, a || re(this, e, t, 4, 2147483647, -2147483648), e < 0 && (e = 4294967295 + e + 1), this[t] = e >>> 24, this[t + 1] = e >>> 16, this[t + 2] = e >>> 8, this[t + 3] = e & 255, t + 4;
+  }, l.prototype.writeBigInt64LE = Ie(function(e, t = 0) {
+    return b(this, e, t, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  }), l.prototype.writeBigInt64BE = Ie(function(e, t = 0) {
+    return _(this, e, t, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  });
+  function C(i, e, t, a, g, T) {
+    if (t + a > i.length) throw new RangeError("Index out of range");
+    if (t < 0) throw new RangeError("Index out of range");
+  }
+  function Z(i, e, t, a, g) {
+    return e = +e, t = t >>> 0, g || C(i, e, t, 4), P.write(i, e, t, a, 23, 4), t + 4;
+  }
+  l.prototype.writeFloatLE = function(e, t, a) {
+    return Z(this, e, t, !0, a);
+  }, l.prototype.writeFloatBE = function(e, t, a) {
+    return Z(this, e, t, !1, a);
+  };
+  function ee(i, e, t, a, g) {
+    return e = +e, t = t >>> 0, g || C(i, e, t, 8), P.write(i, e, t, a, 52, 8), t + 8;
+  }
+  l.prototype.writeDoubleLE = function(e, t, a) {
+    return ee(this, e, t, !0, a);
+  }, l.prototype.writeDoubleBE = function(e, t, a) {
+    return ee(this, e, t, !1, a);
+  }, l.prototype.copy = function(e, t, a, g) {
+    if (!l.isBuffer(e)) throw new TypeError("argument should be a Buffer");
+    if (a || (a = 0), !g && g !== 0 && (g = this.length), t >= e.length && (t = e.length), t || (t = 0), g > 0 && g < a && (g = a), g === a || e.length === 0 || this.length === 0) return 0;
+    if (t < 0)
+      throw new RangeError("targetStart out of bounds");
+    if (a < 0 || a >= this.length) throw new RangeError("Index out of range");
+    if (g < 0) throw new RangeError("sourceEnd out of bounds");
+    g > this.length && (g = this.length), e.length - t < g - a && (g = e.length - t + a);
+    const T = g - a;
+    return this === e && typeof h.prototype.copyWithin == "function" ? this.copyWithin(t, a, g) : h.prototype.set.call(
+      e,
+      this.subarray(a, g),
+      t
+    ), T;
+  }, l.prototype.fill = function(e, t, a, g) {
+    if (typeof e == "string") {
+      if (typeof t == "string" ? (g = t, t = 0, a = this.length) : typeof a == "string" && (g = a, a = this.length), g !== void 0 && typeof g != "string")
+        throw new TypeError("encoding must be a string");
+      if (typeof g == "string" && !l.isEncoding(g))
+        throw new TypeError("Unknown encoding: " + g);
+      if (e.length === 1) {
+        const x = e.charCodeAt(0);
+        (g === "utf8" && x < 128 || g === "latin1") && (e = x);
+      }
+    } else typeof e == "number" ? e = e & 255 : typeof e == "boolean" && (e = Number(e));
+    if (t < 0 || this.length < t || this.length < a)
+      throw new RangeError("Out of range index");
+    if (a <= t)
+      return this;
+    t = t >>> 0, a = a === void 0 ? this.length : a >>> 0, e || (e = 0);
+    let T;
+    if (typeof e == "number")
+      for (T = t; T < a; ++T)
+        this[T] = e;
+    else {
+      const x = l.isBuffer(e) ? e : l.from(e, g), ie = x.length;
+      if (ie === 0)
+        throw new TypeError('The value "' + e + '" is invalid for argument "value"');
+      for (T = 0; T < a - t; ++T)
+        this[T + t] = x[T % ie];
+    }
+    return this;
+  };
+  const u = {};
+  function s(i, e, t) {
+    u[i] = class extends t {
+      constructor() {
+        super(), Object.defineProperty(this, "message", {
+          value: e.apply(this, arguments),
+          writable: !0,
+          configurable: !0
+        }), this.name = `${this.name} [${i}]`, this.stack, delete this.name;
+      }
+      get code() {
+        return i;
+      }
+      set code(g) {
+        Object.defineProperty(this, "code", {
+          configurable: !0,
+          enumerable: !0,
+          value: g,
+          writable: !0
+        });
+      }
+      toString() {
+        return `${this.name} [${i}]: ${this.message}`;
+      }
+    };
+  }
+  s(
+    "ERR_BUFFER_OUT_OF_BOUNDS",
+    function(i) {
+      return i ? `${i} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
+    },
+    RangeError
+  ), s(
+    "ERR_INVALID_ARG_TYPE",
+    function(i, e) {
+      return `The "${i}" argument must be of type number. Received type ${typeof e}`;
+    },
+    TypeError
+  ), s(
+    "ERR_OUT_OF_RANGE",
+    function(i, e, t) {
+      let a = `The value of "${i}" is out of range.`, g = t;
+      return Number.isInteger(t) && Math.abs(t) > 2 ** 32 ? g = H(String(t)) : typeof t == "bigint" && (g = String(t), (t > BigInt(2) ** BigInt(32) || t < -(BigInt(2) ** BigInt(32))) && (g = H(g)), g += "n"), a += ` It must be ${e}. Received ${g}`, a;
+    },
+    RangeError
+  );
+  function H(i) {
+    let e = "", t = i.length;
+    const a = i[0] === "-" ? 1 : 0;
+    for (; t >= a + 4; t -= 3)
+      e = `_${i.slice(t - 3, t)}${e}`;
+    return `${i.slice(0, t)}${e}`;
+  }
+  function $(i, e, t) {
+    te(e, "offset"), (i[e] === void 0 || i[e + t] === void 0) && ae(e, i.length - (t + 1));
+  }
+  function fe(i, e, t, a, g, T) {
+    if (i > t || i < e) {
+      const x = typeof e == "bigint" ? "n" : "";
+      let ie;
+      throw e === 0 || e === BigInt(0) ? ie = `>= 0${x} and < 2${x} ** ${(T + 1) * 8}${x}` : ie = `>= -(2${x} ** ${(T + 1) * 8 - 1}${x}) and < 2 ** ${(T + 1) * 8 - 1}${x}`, new u.ERR_OUT_OF_RANGE("value", ie, i);
+    }
+    $(a, g, T);
+  }
+  function te(i, e) {
+    if (typeof i != "number")
+      throw new u.ERR_INVALID_ARG_TYPE(e, "number", i);
+  }
+  function ae(i, e, t) {
+    throw Math.floor(i) !== i ? (te(i, t), new u.ERR_OUT_OF_RANGE("offset", "an integer", i)) : e < 0 ? new u.ERR_BUFFER_OUT_OF_BOUNDS() : new u.ERR_OUT_OF_RANGE(
+      "offset",
+      `>= 0 and <= ${e}`,
+      i
+    );
+  }
+  const Me = /[^+/0-9A-Za-z-_]/g;
+  function G(i) {
+    if (i = i.split("=")[0], i = i.trim().replace(Me, ""), i.length < 2) return "";
+    for (; i.length % 4 !== 0; )
+      i = i + "=";
+    return i;
+  }
+  function je(i, e) {
+    e = e || 1 / 0;
+    let t;
+    const a = i.length;
+    let g = null;
+    const T = [];
+    for (let x = 0; x < a; ++x) {
+      if (t = i.charCodeAt(x), t > 55295 && t < 57344) {
+        if (!g) {
+          if (t > 56319) {
+            (e -= 3) > -1 && T.push(239, 191, 189);
+            continue;
+          } else if (x + 1 === a) {
+            (e -= 3) > -1 && T.push(239, 191, 189);
+            continue;
+          }
+          g = t;
+          continue;
+        }
+        if (t < 56320) {
+          (e -= 3) > -1 && T.push(239, 191, 189), g = t;
+          continue;
+        }
+        t = (g - 55296 << 10 | t - 56320) + 65536;
+      } else g && (e -= 3) > -1 && T.push(239, 191, 189);
+      if (g = null, t < 128) {
+        if ((e -= 1) < 0) break;
+        T.push(t);
+      } else if (t < 2048) {
+        if ((e -= 2) < 0) break;
+        T.push(
+          t >> 6 | 192,
+          t & 63 | 128
+        );
+      } else if (t < 65536) {
+        if ((e -= 3) < 0) break;
+        T.push(
+          t >> 12 | 224,
+          t >> 6 & 63 | 128,
+          t & 63 | 128
+        );
+      } else if (t < 1114112) {
+        if ((e -= 4) < 0) break;
+        T.push(
+          t >> 18 | 240,
+          t >> 12 & 63 | 128,
+          t >> 6 & 63 | 128,
+          t & 63 | 128
+        );
+      } else
+        throw new Error("Invalid code point");
+    }
+    return T;
+  }
+  function Ke(i) {
+    const e = [];
+    for (let t = 0; t < i.length; ++t)
+      e.push(i.charCodeAt(t) & 255);
+    return e;
+  }
+  function me(i, e) {
+    let t, a, g;
+    const T = [];
+    for (let x = 0; x < i.length && !((e -= 2) < 0); ++x)
+      t = i.charCodeAt(x), a = t >> 8, g = t % 256, T.push(g), T.push(a);
+    return T;
+  }
+  function _e(i) {
+    return v.toByteArray(G(i));
+  }
+  function Pe(i, e, t, a) {
+    let g;
+    for (g = 0; g < a && !(g + t >= e.length || g >= i.length); ++g)
+      e[g + t] = i[g];
+    return g;
+  }
+  function Oe(i, e) {
+    return i instanceof e || i != null && i.constructor != null && i.constructor.name != null && i.constructor.name === e.name;
+  }
+  function Ue(i) {
+    return i !== i;
+  }
+  const Ce = (function() {
+    const i = "0123456789abcdef", e = new Array(256);
+    for (let t = 0; t < 16; ++t) {
+      const a = t * 16;
+      for (let g = 0; g < 16; ++g)
+        e[a + g] = i[t] + i[g];
+    }
+    return e;
+  })();
+  function Ie(i) {
+    return typeof BigInt > "u" ? Ge : i;
+  }
+  function Ge() {
+    throw new Error("BigInt not supported");
+  }
+})(Nr);
+const qt = Nr.Buffer, un = Nr.Buffer;
+function Wt(c) {
+  return c && c.__esModule && Object.prototype.hasOwnProperty.call(c, "default") ? c.default : c;
+}
+var pt = { exports: {} }, ve = pt.exports = {}, ke, Fe;
+function Mr() {
+  throw new Error("setTimeout has not been defined");
+}
+function Ur() {
+  throw new Error("clearTimeout has not been defined");
+}
+(function() {
+  try {
+    typeof setTimeout == "function" ? ke = setTimeout : ke = Mr;
+  } catch {
+    ke = Mr;
+  }
+  try {
+    typeof clearTimeout == "function" ? Fe = clearTimeout : Fe = Ur;
+  } catch {
+    Fe = Ur;
+  }
+})();
+function dt(c) {
+  if (ke === setTimeout)
+    return setTimeout(c, 0);
+  if ((ke === Mr || !ke) && setTimeout)
+    return ke = setTimeout, setTimeout(c, 0);
+  try {
+    return ke(c, 0);
+  } catch {
+    try {
+      return ke.call(null, c, 0);
+    } catch {
+      return ke.call(this, c, 0);
+    }
+  }
+}
+function Gt(c) {
+  if (Fe === clearTimeout)
+    return clearTimeout(c);
+  if ((Fe === Ur || !Fe) && clearTimeout)
+    return Fe = clearTimeout, clearTimeout(c);
+  try {
+    return Fe(c);
+  } catch {
+    try {
+      return Fe.call(null, c);
+    } catch {
+      return Fe.call(this, c);
+    }
+  }
+}
+var qe = [], Xe = !1, Ve, nr = -1;
+function Ht() {
+  !Xe || !Ve || (Xe = !1, Ve.length ? qe = Ve.concat(qe) : nr = -1, qe.length && yt());
+}
+function yt() {
+  if (!Xe) {
+    var c = dt(Ht);
+    Xe = !0;
+    for (var v = qe.length; v; ) {
+      for (Ve = qe, qe = []; ++nr < v; )
+        Ve && Ve[nr].run();
+      nr = -1, v = qe.length;
+    }
+    Ve = null, Xe = !1, Gt(c);
+  }
+}
+ve.nextTick = function(c) {
+  var v = new Array(arguments.length - 1);
+  if (arguments.length > 1)
+    for (var P = 1; P < arguments.length; P++)
+      v[P - 1] = arguments[P];
+  qe.push(new gt(c, v)), qe.length === 1 && !Xe && dt(yt);
+};
+function gt(c, v) {
+  this.fun = c, this.array = v;
+}
+gt.prototype.run = function() {
+  this.fun.apply(null, this.array);
+};
+ve.title = "browser";
+ve.browser = !0;
+ve.env = {};
+ve.argv = [];
+ve.version = "";
+ve.versions = {};
+function We() {
+}
+ve.on = We;
+ve.addListener = We;
+ve.once = We;
+ve.off = We;
+ve.removeListener = We;
+ve.removeAllListeners = We;
+ve.emit = We;
+ve.prependListener = We;
+ve.prependOnceListener = We;
+ve.listeners = function(c) {
+  return [];
+};
+ve.binding = function(c) {
+  throw new Error("process.binding is not supported");
+};
+ve.cwd = function() {
+  return "/";
+};
+ve.chdir = function(c) {
+  throw new Error("process.chdir is not supported");
+};
+ve.umask = function() {
+  return 0;
+};
+var Vt = pt.exports;
+const ue = /* @__PURE__ */ Wt(Vt);
+var $e = { exports: {} }, fr = {}, Dr;
+function or() {
+  return Dr || (Dr = 1, (function(c) {
+    Object.defineProperties(c, { __esModule: { value: !0 }, [Symbol.toStringTag]: { value: "Module" } });
+    var v = {}, P = {};
+    P.byteLength = l, P.toByteArray = j, P.fromByteArray = X;
+    for (var D = [], Y = [], h = typeof Uint8Array < "u" ? Uint8Array : Array, y = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", O = 0, p = y.length; O < p; ++O)
+      D[O] = y[O], Y[y.charCodeAt(O)] = O;
+    Y[45] = 62, Y[95] = 63;
+    function N(B) {
+      var R = B.length;
+      if (R % 4 > 0)
+        throw new Error("Invalid string. Length must be a multiple of 4");
+      var d = B.indexOf("=");
+      d === -1 && (d = R);
+      var m = d === R ? 0 : 4 - d % 4;
+      return [d, m];
+    }
+    function l(B) {
+      var R = N(B), d = R[0], m = R[1];
+      return (d + m) * 3 / 4 - m;
+    }
+    function k(B, R, d) {
+      return (R + d) * 3 / 4 - d;
+    }
+    function j(B) {
+      var R, d = N(B), m = d[0], A = d[1], M = new h(k(B, m, A)), U = 0, z = A > 0 ? m - 4 : m, Q;
+      for (Q = 0; Q < z; Q += 4)
+        R = Y[B.charCodeAt(Q)] << 18 | Y[B.charCodeAt(Q + 1)] << 12 | Y[B.charCodeAt(Q + 2)] << 6 | Y[B.charCodeAt(Q + 3)], M[U++] = R >> 16 & 255, M[U++] = R >> 8 & 255, M[U++] = R & 255;
+      return A === 2 && (R = Y[B.charCodeAt(Q)] << 2 | Y[B.charCodeAt(Q + 1)] >> 4, M[U++] = R & 255), A === 1 && (R = Y[B.charCodeAt(Q)] << 10 | Y[B.charCodeAt(Q + 1)] << 4 | Y[B.charCodeAt(Q + 2)] >> 2, M[U++] = R >> 8 & 255, M[U++] = R & 255), M;
+    }
+    function J(B) {
+      return D[B >> 18 & 63] + D[B >> 12 & 63] + D[B >> 6 & 63] + D[B & 63];
+    }
+    function V(B, R, d) {
+      for (var m, A = [], M = R; M < d; M += 3)
+        m = (B[M] << 16 & 16711680) + (B[M + 1] << 8 & 65280) + (B[M + 2] & 255), A.push(J(m));
+      return A.join("");
+    }
+    function X(B) {
+      for (var R, d = B.length, m = d % 3, A = [], M = 16383, U = 0, z = d - m; U < z; U += M)
+        A.push(V(B, U, U + M > z ? z : U + M));
+      return m === 1 ? (R = B[d - 1], A.push(
+        D[R >> 2] + D[R << 4 & 63] + "=="
+      )) : m === 2 && (R = (B[d - 2] << 8) + B[d - 1], A.push(
+        D[R >> 10] + D[R >> 4 & 63] + D[R << 2 & 63] + "="
+      )), A.join("");
+    }
+    var K = {};
+    K.read = function(B, R, d, m, A) {
+      var M, U, z = A * 8 - m - 1, Q = (1 << z) - 1, ne = Q >> 1, S = -7, se = d ? A - 1 : 0, he = d ? -1 : 1, ye = B[R + se];
+      for (se += he, M = ye & (1 << -S) - 1, ye >>= -S, S += z; S > 0; M = M * 256 + B[R + se], se += he, S -= 8)
+        ;
+      for (U = M & (1 << -S) - 1, M >>= -S, S += m; S > 0; U = U * 256 + B[R + se], se += he, S -= 8)
+        ;
+      if (M === 0)
+        M = 1 - ne;
+      else {
+        if (M === Q)
+          return U ? NaN : (ye ? -1 : 1) * (1 / 0);
+        U = U + Math.pow(2, m), M = M - ne;
+      }
+      return (ye ? -1 : 1) * U * Math.pow(2, M - m);
+    }, K.write = function(B, R, d, m, A, M) {
+      var U, z, Q, ne = M * 8 - A - 1, S = (1 << ne) - 1, se = S >> 1, he = A === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, ye = m ? 0 : M - 1, Be = m ? 1 : -1, Re = R < 0 || R === 0 && 1 / R < 0 ? 1 : 0;
+      for (R = Math.abs(R), isNaN(R) || R === 1 / 0 ? (z = isNaN(R) ? 1 : 0, U = S) : (U = Math.floor(Math.log(R) / Math.LN2), R * (Q = Math.pow(2, -U)) < 1 && (U--, Q *= 2), U + se >= 1 ? R += he / Q : R += he * Math.pow(2, 1 - se), R * Q >= 2 && (U++, Q /= 2), U + se >= S ? (z = 0, U = S) : U + se >= 1 ? (z = (R * Q - 1) * Math.pow(2, A), U = U + se) : (z = R * Math.pow(2, se - 1) * Math.pow(2, A), U = 0)); A >= 8; B[d + ye] = z & 255, ye += Be, z /= 256, A -= 8)
+        ;
+      for (U = U << A | z, ne += A; ne > 0; B[d + ye] = U & 255, ye += Be, U /= 256, ne -= 8)
+        ;
+      B[d + ye - Be] |= Re * 128;
+    };
+    (function(B) {
+      const R = P, d = K, m = typeof Symbol == "function" && typeof Symbol.for == "function" ? /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom") : null;
+      B.Buffer = S, B.SlowBuffer = F, B.INSPECT_MAX_BYTES = 50;
+      const A = 2147483647;
+      B.kMaxLength = A;
+      const { Uint8Array: M, ArrayBuffer: U, SharedArrayBuffer: z } = globalThis;
+      S.TYPED_ARRAY_SUPPORT = Q(), !S.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 Q() {
+        try {
+          const o = new M(1), r = { foo: function() {
+            return 42;
+          } };
+          return Object.setPrototypeOf(r, M.prototype), Object.setPrototypeOf(o, r), o.foo() === 42;
+        } catch {
+          return !1;
+        }
+      }
+      Object.defineProperty(S.prototype, "parent", {
+        enumerable: !0,
+        get: function() {
+          if (S.isBuffer(this))
+            return this.buffer;
+        }
+      }), Object.defineProperty(S.prototype, "offset", {
+        enumerable: !0,
+        get: function() {
+          if (S.isBuffer(this))
+            return this.byteOffset;
+        }
+      });
+      function ne(o) {
+        if (o > A)
+          throw new RangeError('The value "' + o + '" is invalid for option "size"');
+        const r = new M(o);
+        return Object.setPrototypeOf(r, S.prototype), r;
+      }
+      function S(o, r, n) {
+        if (typeof o == "number") {
+          if (typeof r == "string")
+            throw new TypeError(
+              'The "string" argument must be of type string. Received type number'
+            );
+          return Be(o);
+        }
+        return se(o, r, n);
+      }
+      S.poolSize = 8192;
+      function se(o, r, n) {
+        if (typeof o == "string")
+          return Re(o, r);
+        if (U.isView(o))
+          return Se(o);
+        if (o == null)
+          throw new TypeError(
+            "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof o
+          );
+        if (De(o, U) || o && De(o.buffer, U) || typeof z < "u" && (De(o, z) || o && De(o.buffer, z)))
+          return Te(o, r, n);
+        if (typeof o == "number")
+          throw new TypeError(
+            'The "value" argument must not be of type number. Received type number'
+          );
+        const f = o.valueOf && o.valueOf();
+        if (f != null && f !== o)
+          return S.from(f, r, n);
+        const E = Le(o);
+        if (E) return E;
+        if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof o[Symbol.toPrimitive] == "function")
+          return S.from(o[Symbol.toPrimitive]("string"), r, n);
+        throw new TypeError(
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof o
+        );
+      }
+      S.from = function(o, r, n) {
+        return se(o, r, n);
+      }, Object.setPrototypeOf(S.prototype, M.prototype), Object.setPrototypeOf(S, M);
+      function he(o) {
+        if (typeof o != "number")
+          throw new TypeError('"size" argument must be of type number');
+        if (o < 0)
+          throw new RangeError('The value "' + o + '" is invalid for option "size"');
+      }
+      function ye(o, r, n) {
+        return he(o), o <= 0 ? ne(o) : r !== void 0 ? typeof n == "string" ? ne(o).fill(r, n) : ne(o).fill(r) : ne(o);
+      }
+      S.alloc = function(o, r, n) {
+        return ye(o, r, n);
+      };
+      function Be(o) {
+        return he(o), ne(o < 0 ? 0 : I(o) | 0);
+      }
+      S.allocUnsafe = function(o) {
+        return Be(o);
+      }, S.allocUnsafeSlow = function(o) {
+        return Be(o);
+      };
+      function Re(o, r) {
+        if ((typeof r != "string" || r === "") && (r = "utf8"), !S.isEncoding(r))
+          throw new TypeError("Unknown encoding: " + r);
+        const n = q(o, r) | 0;
+        let f = ne(n);
+        const E = f.write(o, r);
+        return E !== n && (f = f.slice(0, E)), f;
+      }
+      function Ae(o) {
+        const r = o.length < 0 ? 0 : I(o.length) | 0, n = ne(r);
+        for (let f = 0; f < r; f += 1)
+          n[f] = o[f] & 255;
+        return n;
+      }
+      function Se(o) {
+        if (De(o, M)) {
+          const r = new M(o);
+          return Te(r.buffer, r.byteOffset, r.byteLength);
+        }
+        return Ae(o);
+      }
+      function Te(o, r, n) {
+        if (r < 0 || o.byteLength < r)
+          throw new RangeError('"offset" is outside of buffer bounds');
+        if (o.byteLength < r + (n || 0))
+          throw new RangeError('"length" is outside of buffer bounds');
+        let f;
+        return r === void 0 && n === void 0 ? f = new M(o) : n === void 0 ? f = new M(o, r) : f = new M(o, r, n), Object.setPrototypeOf(f, S.prototype), f;
+      }
+      function Le(o) {
+        if (S.isBuffer(o)) {
+          const r = I(o.length) | 0, n = ne(r);
+          return n.length === 0 || o.copy(n, 0, 0, r), n;
+        }
+        if (o.length !== void 0)
+          return typeof o.length != "number" || ur(o.length) ? ne(0) : Ae(o);
+        if (o.type === "Buffer" && Array.isArray(o.data))
+          return Ae(o.data);
+      }
+      function I(o) {
+        if (o >= A)
+          throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + A.toString(16) + " bytes");
+        return o | 0;
+      }
+      function F(o) {
+        return +o != o && (o = 0), S.alloc(+o);
+      }
+      S.isBuffer = function(r) {
+        return r != null && r._isBuffer === !0 && r !== S.prototype;
+      }, S.compare = function(r, n) {
+        if (De(r, M) && (r = S.from(r, r.offset, r.byteLength)), De(n, M) && (n = S.from(n, n.offset, n.byteLength)), !S.isBuffer(r) || !S.isBuffer(n))
+          throw new TypeError(
+            'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+          );
+        if (r === n) return 0;
+        let f = r.length, E = n.length;
+        for (let L = 0, W = Math.min(f, E); L < W; ++L)
+          if (r[L] !== n[L]) {
+            f = r[L], E = n[L];
+            break;
+          }
+        return f < E ? -1 : E < f ? 1 : 0;
+      }, S.isEncoding = function(r) {
+        switch (String(r).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;
+        }
+      }, S.concat = function(r, n) {
+        if (!Array.isArray(r))
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        if (r.length === 0)
+          return S.alloc(0);
+        let f;
+        if (n === void 0)
+          for (n = 0, f = 0; f < r.length; ++f)
+            n += r[f].length;
+        const E = S.allocUnsafe(n);
+        let L = 0;
+        for (f = 0; f < r.length; ++f) {
+          let W = r[f];
+          if (De(W, M))
+            L + W.length > E.length ? (S.isBuffer(W) || (W = S.from(W)), W.copy(E, L)) : M.prototype.set.call(
+              E,
+              W,
+              L
+            );
+          else if (S.isBuffer(W))
+            W.copy(E, L);
+          else
+            throw new TypeError('"list" argument must be an Array of Buffers');
+          L += W.length;
+        }
+        return E;
+      };
+      function q(o, r) {
+        if (S.isBuffer(o))
+          return o.length;
+        if (U.isView(o) || De(o, U))
+          return o.byteLength;
+        if (typeof o != "string")
+          throw new TypeError(
+            'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof o
+          );
+        const n = o.length, f = arguments.length > 2 && arguments[2] === !0;
+        if (!f && n === 0) return 0;
+        let E = !1;
+        for (; ; )
+          switch (r) {
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return n;
+            case "utf8":
+            case "utf-8":
+              return pe(o).length;
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return n * 2;
+            case "hex":
+              return n >>> 1;
+            case "base64":
+              return le(o).length;
+            default:
+              if (E)
+                return f ? -1 : pe(o).length;
+              r = ("" + r).toLowerCase(), E = !0;
+          }
+      }
+      S.byteLength = q;
+      function re(o, r, n) {
+        let f = !1;
+        if ((r === void 0 || r < 0) && (r = 0), r > this.length || ((n === void 0 || n > this.length) && (n = this.length), n <= 0) || (n >>>= 0, r >>>= 0, n <= r))
+          return "";
+        for (o || (o = "utf8"); ; )
+          switch (o) {
+            case "hex":
+              return je(this, r, n);
+            case "utf8":
+            case "utf-8":
+              return fe(this, r, n);
+            case "ascii":
+              return Me(this, r, n);
+            case "latin1":
+            case "binary":
+              return G(this, r, n);
+            case "base64":
+              return $(this, r, n);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return Ke(this, r, n);
+            default:
+              if (f) throw new TypeError("Unknown encoding: " + o);
+              o = (o + "").toLowerCase(), f = !0;
+          }
+      }
+      S.prototype._isBuffer = !0;
+      function b(o, r, n) {
+        const f = o[r];
+        o[r] = o[n], o[n] = f;
+      }
+      S.prototype.swap16 = function() {
+        const r = this.length;
+        if (r % 2 !== 0)
+          throw new RangeError("Buffer size must be a multiple of 16-bits");
+        for (let n = 0; n < r; n += 2)
+          b(this, n, n + 1);
+        return this;
+      }, S.prototype.swap32 = function() {
+        const r = this.length;
+        if (r % 4 !== 0)
+          throw new RangeError("Buffer size must be a multiple of 32-bits");
+        for (let n = 0; n < r; n += 4)
+          b(this, n, n + 3), b(this, n + 1, n + 2);
+        return this;
+      }, S.prototype.swap64 = function() {
+        const r = this.length;
+        if (r % 8 !== 0)
+          throw new RangeError("Buffer size must be a multiple of 64-bits");
+        for (let n = 0; n < r; n += 8)
+          b(this, n, n + 7), b(this, n + 1, n + 6), b(this, n + 2, n + 5), b(this, n + 3, n + 4);
+        return this;
+      }, S.prototype.toString = function() {
+        const r = this.length;
+        return r === 0 ? "" : arguments.length === 0 ? fe(this, 0, r) : re.apply(this, arguments);
+      }, S.prototype.toLocaleString = S.prototype.toString, S.prototype.equals = function(r) {
+        if (!S.isBuffer(r)) throw new TypeError("Argument must be a Buffer");
+        return this === r ? !0 : S.compare(this, r) === 0;
+      }, S.prototype.inspect = function() {
+        let r = "";
+        const n = B.INSPECT_MAX_BYTES;
+        return r = this.toString("hex", 0, n).replace(/(.{2})/g, "$1 ").trim(), this.length > n && (r += " ... "), "<Buffer " + r + ">";
+      }, m && (S.prototype[m] = S.prototype.inspect), S.prototype.compare = function(r, n, f, E, L) {
+        if (De(r, M) && (r = S.from(r, r.offset, r.byteLength)), !S.isBuffer(r))
+          throw new TypeError(
+            'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof r
+          );
+        if (n === void 0 && (n = 0), f === void 0 && (f = r ? r.length : 0), E === void 0 && (E = 0), L === void 0 && (L = this.length), n < 0 || f > r.length || E < 0 || L > this.length)
+          throw new RangeError("out of range index");
+        if (E >= L && n >= f)
+          return 0;
+        if (E >= L)
+          return -1;
+        if (n >= f)
+          return 1;
+        if (n >>>= 0, f >>>= 0, E >>>= 0, L >>>= 0, this === r) return 0;
+        let W = L - E, oe = f - n;
+        const Ee = Math.min(W, oe), we = this.slice(E, L), be = r.slice(n, f);
+        for (let ce = 0; ce < Ee; ++ce)
+          if (we[ce] !== be[ce]) {
+            W = we[ce], oe = be[ce];
+            break;
+          }
+        return W < oe ? -1 : oe < W ? 1 : 0;
+      };
+      function _(o, r, n, f, E) {
+        if (o.length === 0) return -1;
+        if (typeof n == "string" ? (f = n, n = 0) : n > 2147483647 ? n = 2147483647 : n < -2147483648 && (n = -2147483648), n = +n, ur(n) && (n = E ? 0 : o.length - 1), n < 0 && (n = o.length + n), n >= o.length) {
+          if (E) return -1;
+          n = o.length - 1;
+        } else if (n < 0)
+          if (E) n = 0;
+          else return -1;
+        if (typeof r == "string" && (r = S.from(r, f)), S.isBuffer(r))
+          return r.length === 0 ? -1 : C(o, r, n, f, E);
+        if (typeof r == "number")
+          return r = r & 255, typeof M.prototype.indexOf == "function" ? E ? M.prototype.indexOf.call(o, r, n) : M.prototype.lastIndexOf.call(o, r, n) : C(o, [r], n, f, E);
+        throw new TypeError("val must be string, number or Buffer");
+      }
+      function C(o, r, n, f, E) {
+        let L = 1, W = o.length, oe = r.length;
+        if (f !== void 0 && (f = String(f).toLowerCase(), f === "ucs2" || f === "ucs-2" || f === "utf16le" || f === "utf-16le")) {
+          if (o.length < 2 || r.length < 2)
+            return -1;
+          L = 2, W /= 2, oe /= 2, n /= 2;
+        }
+        function Ee(be, ce) {
+          return L === 1 ? be[ce] : be.readUInt16BE(ce * L);
+        }
+        let we;
+        if (E) {
+          let be = -1;
+          for (we = n; we < W; we++)
+            if (Ee(o, we) === Ee(r, be === -1 ? 0 : we - be)) {
+              if (be === -1 && (be = we), we - be + 1 === oe) return be * L;
+            } else
+              be !== -1 && (we -= we - be), be = -1;
+        } else
+          for (n + oe > W && (n = W - oe), we = n; we >= 0; we--) {
+            let be = !0;
+            for (let ce = 0; ce < oe; ce++)
+              if (Ee(o, we + ce) !== Ee(r, ce)) {
+                be = !1;
+                break;
+              }
+            if (be) return we;
+          }
+        return -1;
+      }
+      S.prototype.includes = function(r, n, f) {
+        return this.indexOf(r, n, f) !== -1;
+      }, S.prototype.indexOf = function(r, n, f) {
+        return _(this, r, n, f, !0);
+      }, S.prototype.lastIndexOf = function(r, n, f) {
+        return _(this, r, n, f, !1);
+      };
+      function Z(o, r, n, f) {
+        n = Number(n) || 0;
+        const E = o.length - n;
+        f ? (f = Number(f), f > E && (f = E)) : f = E;
+        const L = r.length;
+        f > L / 2 && (f = L / 2);
+        let W;
+        for (W = 0; W < f; ++W) {
+          const oe = parseInt(r.substr(W * 2, 2), 16);
+          if (ur(oe)) return W;
+          o[n + W] = oe;
+        }
+        return W;
+      }
+      function ee(o, r, n, f) {
+        return Qe(pe(r, o.length - n), o, n, f);
+      }
+      function u(o, r, n, f) {
+        return Qe(de(r), o, n, f);
+      }
+      function s(o, r, n, f) {
+        return Qe(le(r), o, n, f);
+      }
+      function H(o, r, n, f) {
+        return Qe(ge(r, o.length - n), o, n, f);
+      }
+      S.prototype.write = function(r, n, f, E) {
+        if (n === void 0)
+          E = "utf8", f = this.length, n = 0;
+        else if (f === void 0 && typeof n == "string")
+          E = n, f = this.length, n = 0;
+        else if (isFinite(n))
+          n = n >>> 0, isFinite(f) ? (f = f >>> 0, E === void 0 && (E = "utf8")) : (E = f, f = void 0);
+        else
+          throw new Error(
+            "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+          );
+        const L = this.length - n;
+        if ((f === void 0 || f > L) && (f = L), r.length > 0 && (f < 0 || n < 0) || n > this.length)
+          throw new RangeError("Attempt to write outside buffer bounds");
+        E || (E = "utf8");
+        let W = !1;
+        for (; ; )
+          switch (E) {
+            case "hex":
+              return Z(this, r, n, f);
+            case "utf8":
+            case "utf-8":
+              return ee(this, r, n, f);
+            case "ascii":
+            case "latin1":
+            case "binary":
+              return u(this, r, n, f);
+            case "base64":
+              return s(this, r, n, f);
+            case "ucs2":
+            case "ucs-2":
+            case "utf16le":
+            case "utf-16le":
+              return H(this, r, n, f);
+            default:
+              if (W) throw new TypeError("Unknown encoding: " + E);
+              E = ("" + E).toLowerCase(), W = !0;
+          }
+      }, S.prototype.toJSON = function() {
+        return {
+          type: "Buffer",
+          data: Array.prototype.slice.call(this._arr || this, 0)
+        };
+      };
+      function $(o, r, n) {
+        return r === 0 && n === o.length ? R.fromByteArray(o) : R.fromByteArray(o.slice(r, n));
+      }
+      function fe(o, r, n) {
+        n = Math.min(o.length, n);
+        const f = [];
+        let E = r;
+        for (; E < n; ) {
+          const L = o[E];
+          let W = null, oe = L > 239 ? 4 : L > 223 ? 3 : L > 191 ? 2 : 1;
+          if (E + oe <= n) {
+            let Ee, we, be, ce;
+            switch (oe) {
+              case 1:
+                L < 128 && (W = L);
+                break;
+              case 2:
+                Ee = o[E + 1], (Ee & 192) === 128 && (ce = (L & 31) << 6 | Ee & 63, ce > 127 && (W = ce));
+                break;
+              case 3:
+                Ee = o[E + 1], we = o[E + 2], (Ee & 192) === 128 && (we & 192) === 128 && (ce = (L & 15) << 12 | (Ee & 63) << 6 | we & 63, ce > 2047 && (ce < 55296 || ce > 57343) && (W = ce));
+                break;
+              case 4:
+                Ee = o[E + 1], we = o[E + 2], be = o[E + 3], (Ee & 192) === 128 && (we & 192) === 128 && (be & 192) === 128 && (ce = (L & 15) << 18 | (Ee & 63) << 12 | (we & 63) << 6 | be & 63, ce > 65535 && ce < 1114112 && (W = ce));
+            }
+          }
+          W === null ? (W = 65533, oe = 1) : W > 65535 && (W -= 65536, f.push(W >>> 10 & 1023 | 55296), W = 56320 | W & 1023), f.push(W), E += oe;
+        }
+        return ae(f);
+      }
+      const te = 4096;
+      function ae(o) {
+        const r = o.length;
+        if (r <= te)
+          return String.fromCharCode.apply(String, o);
+        let n = "", f = 0;
+        for (; f < r; )
+          n += String.fromCharCode.apply(
+            String,
+            o.slice(f, f += te)
+          );
+        return n;
+      }
+      function Me(o, r, n) {
+        let f = "";
+        n = Math.min(o.length, n);
+        for (let E = r; E < n; ++E)
+          f += String.fromCharCode(o[E] & 127);
+        return f;
+      }
+      function G(o, r, n) {
+        let f = "";
+        n = Math.min(o.length, n);
+        for (let E = r; E < n; ++E)
+          f += String.fromCharCode(o[E]);
+        return f;
+      }
+      function je(o, r, n) {
+        const f = o.length;
+        (!r || r < 0) && (r = 0), (!n || n < 0 || n > f) && (n = f);
+        let E = "";
+        for (let L = r; L < n; ++L)
+          E += Rt[o[L]];
+        return E;
+      }
+      function Ke(o, r, n) {
+        const f = o.slice(r, n);
+        let E = "";
+        for (let L = 0; L < f.length - 1; L += 2)
+          E += String.fromCharCode(f[L] + f[L + 1] * 256);
+        return E;
+      }
+      S.prototype.slice = function(r, n) {
+        const f = this.length;
+        r = ~~r, n = n === void 0 ? f : ~~n, r < 0 ? (r += f, r < 0 && (r = 0)) : r > f && (r = f), n < 0 ? (n += f, n < 0 && (n = 0)) : n > f && (n = f), n < r && (n = r);
+        const E = this.subarray(r, n);
+        return Object.setPrototypeOf(E, S.prototype), E;
+      };
+      function me(o, r, n) {
+        if (o % 1 !== 0 || o < 0) throw new RangeError("offset is not uint");
+        if (o + r > n) throw new RangeError("Trying to access beyond buffer length");
+      }
+      S.prototype.readUintLE = S.prototype.readUIntLE = function(r, n, f) {
+        r = r >>> 0, n = n >>> 0, f || me(r, n, this.length);
+        let E = this[r], L = 1, W = 0;
+        for (; ++W < n && (L *= 256); )
+          E += this[r + W] * L;
+        return E;
+      }, S.prototype.readUintBE = S.prototype.readUIntBE = function(r, n, f) {
+        r = r >>> 0, n = n >>> 0, f || me(r, n, this.length);
+        let E = this[r + --n], L = 1;
+        for (; n > 0 && (L *= 256); )
+          E += this[r + --n] * L;
+        return E;
+      }, S.prototype.readUint8 = S.prototype.readUInt8 = function(r, n) {
+        return r = r >>> 0, n || me(r, 1, this.length), this[r];
+      }, S.prototype.readUint16LE = S.prototype.readUInt16LE = function(r, n) {
+        return r = r >>> 0, n || me(r, 2, this.length), this[r] | this[r + 1] << 8;
+      }, S.prototype.readUint16BE = S.prototype.readUInt16BE = function(r, n) {
+        return r = r >>> 0, n || me(r, 2, this.length), this[r] << 8 | this[r + 1];
+      }, S.prototype.readUint32LE = S.prototype.readUInt32LE = function(r, n) {
+        return r = r >>> 0, n || me(r, 4, this.length), (this[r] | this[r + 1] << 8 | this[r + 2] << 16) + this[r + 3] * 16777216;
+      }, S.prototype.readUint32BE = S.prototype.readUInt32BE = function(r, n) {
+        return r = r >>> 0, n || me(r, 4, this.length), this[r] * 16777216 + (this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3]);
+      }, S.prototype.readBigUInt64LE = He(function(r) {
+        r = r >>> 0, g(r, "offset");
+        const n = this[r], f = this[r + 7];
+        (n === void 0 || f === void 0) && T(r, this.length - 8);
+        const E = n + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + this[++r] * 2 ** 24, L = this[++r] + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + f * 2 ** 24;
+        return BigInt(E) + (BigInt(L) << BigInt(32));
+      }), S.prototype.readBigUInt64BE = He(function(r) {
+        r = r >>> 0, g(r, "offset");
+        const n = this[r], f = this[r + 7];
+        (n === void 0 || f === void 0) && T(r, this.length - 8);
+        const E = n * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + this[++r], L = this[++r] * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + f;
+        return (BigInt(E) << BigInt(32)) + BigInt(L);
+      }), S.prototype.readIntLE = function(r, n, f) {
+        r = r >>> 0, n = n >>> 0, f || me(r, n, this.length);
+        let E = this[r], L = 1, W = 0;
+        for (; ++W < n && (L *= 256); )
+          E += this[r + W] * L;
+        return L *= 128, E >= L && (E -= Math.pow(2, 8 * n)), E;
+      }, S.prototype.readIntBE = function(r, n, f) {
+        r = r >>> 0, n = n >>> 0, f || me(r, n, this.length);
+        let E = n, L = 1, W = this[r + --E];
+        for (; E > 0 && (L *= 256); )
+          W += this[r + --E] * L;
+        return L *= 128, W >= L && (W -= Math.pow(2, 8 * n)), W;
+      }, S.prototype.readInt8 = function(r, n) {
+        return r = r >>> 0, n || me(r, 1, this.length), this[r] & 128 ? (255 - this[r] + 1) * -1 : this[r];
+      }, S.prototype.readInt16LE = function(r, n) {
+        r = r >>> 0, n || me(r, 2, this.length);
+        const f = this[r] | this[r + 1] << 8;
+        return f & 32768 ? f | 4294901760 : f;
+      }, S.prototype.readInt16BE = function(r, n) {
+        r = r >>> 0, n || me(r, 2, this.length);
+        const f = this[r + 1] | this[r] << 8;
+        return f & 32768 ? f | 4294901760 : f;
+      }, S.prototype.readInt32LE = function(r, n) {
+        return r = r >>> 0, n || me(r, 4, this.length), this[r] | this[r + 1] << 8 | this[r + 2] << 16 | this[r + 3] << 24;
+      }, S.prototype.readInt32BE = function(r, n) {
+        return r = r >>> 0, n || me(r, 4, this.length), this[r] << 24 | this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3];
+      }, S.prototype.readBigInt64LE = He(function(r) {
+        r = r >>> 0, g(r, "offset");
+        const n = this[r], f = this[r + 7];
+        (n === void 0 || f === void 0) && T(r, this.length - 8);
+        const E = this[r + 4] + this[r + 5] * 2 ** 8 + this[r + 6] * 2 ** 16 + (f << 24);
+        return (BigInt(E) << BigInt(32)) + BigInt(n + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + this[++r] * 2 ** 24);
+      }), S.prototype.readBigInt64BE = He(function(r) {
+        r = r >>> 0, g(r, "offset");
+        const n = this[r], f = this[r + 7];
+        (n === void 0 || f === void 0) && T(r, this.length - 8);
+        const E = (n << 24) + // Overflow
+        this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + this[++r];
+        return (BigInt(E) << BigInt(32)) + BigInt(this[++r] * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + f);
+      }), S.prototype.readFloatLE = function(r, n) {
+        return r = r >>> 0, n || me(r, 4, this.length), d.read(this, r, !0, 23, 4);
+      }, S.prototype.readFloatBE = function(r, n) {
+        return r = r >>> 0, n || me(r, 4, this.length), d.read(this, r, !1, 23, 4);
+      }, S.prototype.readDoubleLE = function(r, n) {
+        return r = r >>> 0, n || me(r, 8, this.length), d.read(this, r, !0, 52, 8);
+      }, S.prototype.readDoubleBE = function(r, n) {
+        return r = r >>> 0, n || me(r, 8, this.length), d.read(this, r, !1, 52, 8);
+      };
+      function _e(o, r, n, f, E, L) {
+        if (!S.isBuffer(o)) throw new TypeError('"buffer" argument must be a Buffer instance');
+        if (r > E || r < L) throw new RangeError('"value" argument is out of bounds');
+        if (n + f > o.length) throw new RangeError("Index out of range");
+      }
+      S.prototype.writeUintLE = S.prototype.writeUIntLE = function(r, n, f, E) {
+        if (r = +r, n = n >>> 0, f = f >>> 0, !E) {
+          const oe = Math.pow(2, 8 * f) - 1;
+          _e(this, r, n, f, oe, 0);
+        }
+        let L = 1, W = 0;
+        for (this[n] = r & 255; ++W < f && (L *= 256); )
+          this[n + W] = r / L & 255;
+        return n + f;
+      }, S.prototype.writeUintBE = S.prototype.writeUIntBE = function(r, n, f, E) {
+        if (r = +r, n = n >>> 0, f = f >>> 0, !E) {
+          const oe = Math.pow(2, 8 * f) - 1;
+          _e(this, r, n, f, oe, 0);
+        }
+        let L = f - 1, W = 1;
+        for (this[n + L] = r & 255; --L >= 0 && (W *= 256); )
+          this[n + L] = r / W & 255;
+        return n + f;
+      }, S.prototype.writeUint8 = S.prototype.writeUInt8 = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 1, 255, 0), this[n] = r & 255, n + 1;
+      }, S.prototype.writeUint16LE = S.prototype.writeUInt16LE = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 2, 65535, 0), this[n] = r & 255, this[n + 1] = r >>> 8, n + 2;
+      }, S.prototype.writeUint16BE = S.prototype.writeUInt16BE = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 2, 65535, 0), this[n] = r >>> 8, this[n + 1] = r & 255, n + 2;
+      }, S.prototype.writeUint32LE = S.prototype.writeUInt32LE = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 4, 4294967295, 0), this[n + 3] = r >>> 24, this[n + 2] = r >>> 16, this[n + 1] = r >>> 8, this[n] = r & 255, n + 4;
+      }, S.prototype.writeUint32BE = S.prototype.writeUInt32BE = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 4, 4294967295, 0), this[n] = r >>> 24, this[n + 1] = r >>> 16, this[n + 2] = r >>> 8, this[n + 3] = r & 255, n + 4;
+      };
+      function Pe(o, r, n, f, E) {
+        a(r, f, E, o, n, 7);
+        let L = Number(r & BigInt(4294967295));
+        o[n++] = L, L = L >> 8, o[n++] = L, L = L >> 8, o[n++] = L, L = L >> 8, o[n++] = L;
+        let W = Number(r >> BigInt(32) & BigInt(4294967295));
+        return o[n++] = W, W = W >> 8, o[n++] = W, W = W >> 8, o[n++] = W, W = W >> 8, o[n++] = W, n;
+      }
+      function Oe(o, r, n, f, E) {
+        a(r, f, E, o, n, 7);
+        let L = Number(r & BigInt(4294967295));
+        o[n + 7] = L, L = L >> 8, o[n + 6] = L, L = L >> 8, o[n + 5] = L, L = L >> 8, o[n + 4] = L;
+        let W = Number(r >> BigInt(32) & BigInt(4294967295));
+        return o[n + 3] = W, W = W >> 8, o[n + 2] = W, W = W >> 8, o[n + 1] = W, W = W >> 8, o[n] = W, n + 8;
+      }
+      S.prototype.writeBigUInt64LE = He(function(r, n = 0) {
+        return Pe(this, r, n, BigInt(0), BigInt("0xffffffffffffffff"));
+      }), S.prototype.writeBigUInt64BE = He(function(r, n = 0) {
+        return Oe(this, r, n, BigInt(0), BigInt("0xffffffffffffffff"));
+      }), S.prototype.writeIntLE = function(r, n, f, E) {
+        if (r = +r, n = n >>> 0, !E) {
+          const Ee = Math.pow(2, 8 * f - 1);
+          _e(this, r, n, f, Ee - 1, -Ee);
+        }
+        let L = 0, W = 1, oe = 0;
+        for (this[n] = r & 255; ++L < f && (W *= 256); )
+          r < 0 && oe === 0 && this[n + L - 1] !== 0 && (oe = 1), this[n + L] = (r / W >> 0) - oe & 255;
+        return n + f;
+      }, S.prototype.writeIntBE = function(r, n, f, E) {
+        if (r = +r, n = n >>> 0, !E) {
+          const Ee = Math.pow(2, 8 * f - 1);
+          _e(this, r, n, f, Ee - 1, -Ee);
+        }
+        let L = f - 1, W = 1, oe = 0;
+        for (this[n + L] = r & 255; --L >= 0 && (W *= 256); )
+          r < 0 && oe === 0 && this[n + L + 1] !== 0 && (oe = 1), this[n + L] = (r / W >> 0) - oe & 255;
+        return n + f;
+      }, S.prototype.writeInt8 = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 1, 127, -128), r < 0 && (r = 255 + r + 1), this[n] = r & 255, n + 1;
+      }, S.prototype.writeInt16LE = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 2, 32767, -32768), this[n] = r & 255, this[n + 1] = r >>> 8, n + 2;
+      }, S.prototype.writeInt16BE = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 2, 32767, -32768), this[n] = r >>> 8, this[n + 1] = r & 255, n + 2;
+      }, S.prototype.writeInt32LE = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 4, 2147483647, -2147483648), this[n] = r & 255, this[n + 1] = r >>> 8, this[n + 2] = r >>> 16, this[n + 3] = r >>> 24, n + 4;
+      }, S.prototype.writeInt32BE = function(r, n, f) {
+        return r = +r, n = n >>> 0, f || _e(this, r, n, 4, 2147483647, -2147483648), r < 0 && (r = 4294967295 + r + 1), this[n] = r >>> 24, this[n + 1] = r >>> 16, this[n + 2] = r >>> 8, this[n + 3] = r & 255, n + 4;
+      }, S.prototype.writeBigInt64LE = He(function(r, n = 0) {
+        return Pe(this, r, n, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+      }), S.prototype.writeBigInt64BE = He(function(r, n = 0) {
+        return Oe(this, r, n, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+      });
+      function Ue(o, r, n, f, E, L) {
+        if (n + f > o.length) throw new RangeError("Index out of range");
+        if (n < 0) throw new RangeError("Index out of range");
+      }
+      function Ce(o, r, n, f, E) {
+        return r = +r, n = n >>> 0, E || Ue(o, r, n, 4), d.write(o, r, n, f, 23, 4), n + 4;
+      }
+      S.prototype.writeFloatLE = function(r, n, f) {
+        return Ce(this, r, n, !0, f);
+      }, S.prototype.writeFloatBE = function(r, n, f) {
+        return Ce(this, r, n, !1, f);
+      };
+      function Ie(o, r, n, f, E) {
+        return r = +r, n = n >>> 0, E || Ue(o, r, n, 8), d.write(o, r, n, f, 52, 8), n + 8;
+      }
+      S.prototype.writeDoubleLE = function(r, n, f) {
+        return Ie(this, r, n, !0, f);
+      }, S.prototype.writeDoubleBE = function(r, n, f) {
+        return Ie(this, r, n, !1, f);
+      }, S.prototype.copy = function(r, n, f, E) {
+        if (!S.isBuffer(r)) throw new TypeError("argument should be a Buffer");
+        if (f || (f = 0), !E && E !== 0 && (E = this.length), n >= r.length && (n = r.length), n || (n = 0), E > 0 && E < f && (E = f), E === f || r.length === 0 || this.length === 0) return 0;
+        if (n < 0)
+          throw new RangeError("targetStart out of bounds");
+        if (f < 0 || f >= this.length) throw new RangeError("Index out of range");
+        if (E < 0) throw new RangeError("sourceEnd out of bounds");
+        E > this.length && (E = this.length), r.length - n < E - f && (E = r.length - n + f);
+        const L = E - f;
+        return this === r && typeof M.prototype.copyWithin == "function" ? this.copyWithin(n, f, E) : M.prototype.set.call(
+          r,
+          this.subarray(f, E),
+          n
+        ), L;
+      }, S.prototype.fill = function(r, n, f, E) {
+        if (typeof r == "string") {
+          if (typeof n == "string" ? (E = n, n = 0, f = this.length) : typeof f == "string" && (E = f, f = this.length), E !== void 0 && typeof E != "string")
+            throw new TypeError("encoding must be a string");
+          if (typeof E == "string" && !S.isEncoding(E))
+            throw new TypeError("Unknown encoding: " + E);
+          if (r.length === 1) {
+            const W = r.charCodeAt(0);
+            (E === "utf8" && W < 128 || E === "latin1") && (r = W);
+          }
+        } else typeof r == "number" ? r = r & 255 : typeof r == "boolean" && (r = Number(r));
+        if (n < 0 || this.length < n || this.length < f)
+          throw new RangeError("Out of range index");
+        if (f <= n)
+          return this;
+        n = n >>> 0, f = f === void 0 ? this.length : f >>> 0, r || (r = 0);
+        let L;
+        if (typeof r == "number")
+          for (L = n; L < f; ++L)
+            this[L] = r;
+        else {
+          const W = S.isBuffer(r) ? r : S.from(r, E), oe = W.length;
+          if (oe === 0)
+            throw new TypeError('The value "' + r + '" is invalid for argument "value"');
+          for (L = 0; L < f - n; ++L)
+            this[L + n] = W[L % oe];
+        }
+        return this;
+      };
+      const Ge = {};
+      function i(o, r, n) {
+        Ge[o] = class extends n {
+          constructor() {
+            super(), Object.defineProperty(this, "message", {
+              value: r.apply(this, arguments),
+              writable: !0,
+              configurable: !0
+            }), this.name = `${this.name} [${o}]`, this.stack, delete this.name;
+          }
+          get code() {
+            return o;
+          }
+          set code(E) {
+            Object.defineProperty(this, "code", {
+              configurable: !0,
+              enumerable: !0,
+              value: E,
+              writable: !0
+            });
+          }
+          toString() {
+            return `${this.name} [${o}]: ${this.message}`;
+          }
+        };
+      }
+      i(
+        "ERR_BUFFER_OUT_OF_BOUNDS",
+        function(o) {
+          return o ? `${o} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
+        },
+        RangeError
+      ), i(
+        "ERR_INVALID_ARG_TYPE",
+        function(o, r) {
+          return `The "${o}" argument must be of type number. Received type ${typeof r}`;
+        },
+        TypeError
+      ), i(
+        "ERR_OUT_OF_RANGE",
+        function(o, r, n) {
+          let f = `The value of "${o}" is out of range.`, E = n;
+          return Number.isInteger(n) && Math.abs(n) > 2 ** 32 ? E = e(String(n)) : typeof n == "bigint" && (E = String(n), (n > BigInt(2) ** BigInt(32) || n < -(BigInt(2) ** BigInt(32))) && (E = e(E)), E += "n"), f += ` It must be ${r}. Received ${E}`, f;
+        },
+        RangeError
+      );
+      function e(o) {
+        let r = "", n = o.length;
+        const f = o[0] === "-" ? 1 : 0;
+        for (; n >= f + 4; n -= 3)
+          r = `_${o.slice(n - 3, n)}${r}`;
+        return `${o.slice(0, n)}${r}`;
+      }
+      function t(o, r, n) {
+        g(r, "offset"), (o[r] === void 0 || o[r + n] === void 0) && T(r, o.length - (n + 1));
+      }
+      function a(o, r, n, f, E, L) {
+        if (o > n || o < r) {
+          const W = typeof r == "bigint" ? "n" : "";
+          let oe;
+          throw r === 0 || r === BigInt(0) ? oe = `>= 0${W} and < 2${W} ** ${(L + 1) * 8}${W}` : oe = `>= -(2${W} ** ${(L + 1) * 8 - 1}${W}) and < 2 ** ${(L + 1) * 8 - 1}${W}`, new Ge.ERR_OUT_OF_RANGE("value", oe, o);
+        }
+        t(f, E, L);
+      }
+      function g(o, r) {
+        if (typeof o != "number")
+          throw new Ge.ERR_INVALID_ARG_TYPE(r, "number", o);
+      }
+      function T(o, r, n) {
+        throw Math.floor(o) !== o ? (g(o, n), new Ge.ERR_OUT_OF_RANGE("offset", "an integer", o)) : r < 0 ? new Ge.ERR_BUFFER_OUT_OF_BOUNDS() : new Ge.ERR_OUT_OF_RANGE(
+          "offset",
+          `>= 0 and <= ${r}`,
+          o
+        );
+      }
+      const x = /[^+/0-9A-Za-z-_]/g;
+      function ie(o) {
+        if (o = o.split("=")[0], o = o.trim().replace(x, ""), o.length < 2) return "";
+        for (; o.length % 4 !== 0; )
+          o = o + "=";
+        return o;
+      }
+      function pe(o, r) {
+        r = r || 1 / 0;
+        let n;
+        const f = o.length;
+        let E = null;
+        const L = [];
+        for (let W = 0; W < f; ++W) {
+          if (n = o.charCodeAt(W), n > 55295 && n < 57344) {
+            if (!E) {
+              if (n > 56319) {
+                (r -= 3) > -1 && L.push(239, 191, 189);
+                continue;
+              } else if (W + 1 === f) {
+                (r -= 3) > -1 && L.push(239, 191, 189);
+                continue;
+              }
+              E = n;
+              continue;
+            }
+            if (n < 56320) {
+              (r -= 3) > -1 && L.push(239, 191, 189), E = n;
+              continue;
+            }
+            n = (E - 55296 << 10 | n - 56320) + 65536;
+          } else E && (r -= 3) > -1 && L.push(239, 191, 189);
+          if (E = null, n < 128) {
+            if ((r -= 1) < 0) break;
+            L.push(n);
+          } else if (n < 2048) {
+            if ((r -= 2) < 0) break;
+            L.push(
+              n >> 6 | 192,
+              n & 63 | 128
+            );
+          } else if (n < 65536) {
+            if ((r -= 3) < 0) break;
+            L.push(
+              n >> 12 | 224,
+              n >> 6 & 63 | 128,
+              n & 63 | 128
+            );
+          } else if (n < 1114112) {
+            if ((r -= 4) < 0) break;
+            L.push(
+              n >> 18 | 240,
+              n >> 12 & 63 | 128,
+              n >> 6 & 63 | 128,
+              n & 63 | 128
+            );
+          } else
+            throw new Error("Invalid code point");
+        }
+        return L;
+      }
+      function de(o) {
+        const r = [];
+        for (let n = 0; n < o.length; ++n)
+          r.push(o.charCodeAt(n) & 255);
+        return r;
+      }
+      function ge(o, r) {
+        let n, f, E;
+        const L = [];
+        for (let W = 0; W < o.length && !((r -= 2) < 0); ++W)
+          n = o.charCodeAt(W), f = n >> 8, E = n % 256, L.push(E), L.push(f);
+        return L;
+      }
+      function le(o) {
+        return R.toByteArray(ie(o));
+      }
+      function Qe(o, r, n, f) {
+        let E;
+        for (E = 0; E < f && !(E + n >= r.length || E >= o.length); ++E)
+          r[E + n] = o[E];
+        return E;
+      }
+      function De(o, r) {
+        return o instanceof r || o != null && o.constructor != null && o.constructor.name != null && o.constructor.name === r.name;
+      }
+      function ur(o) {
+        return o !== o;
+      }
+      const Rt = (function() {
+        const o = "0123456789abcdef", r = new Array(256);
+        for (let n = 0; n < 16; ++n) {
+          const f = n * 16;
+          for (let E = 0; E < 16; ++E)
+            r[f + E] = o[n] + o[E];
+        }
+        return r;
+      })();
+      function He(o) {
+        return typeof BigInt > "u" ? At : o;
+      }
+      function At() {
+        throw new Error("BigInt not supported");
+      }
+    })(v);
+    const w = v.Buffer;
+    c.Blob = v.Blob, c.BlobOptions = v.BlobOptions, c.Buffer = v.Buffer, c.File = v.File, c.FileOptions = v.FileOptions, c.INSPECT_MAX_BYTES = v.INSPECT_MAX_BYTES, c.SlowBuffer = v.SlowBuffer, c.TranscodeEncoding = v.TranscodeEncoding, c.atob = v.atob, c.btoa = v.btoa, c.constants = v.constants, c.default = w, c.isAscii = v.isAscii, c.isUtf8 = v.isUtf8, c.kMaxLength = v.kMaxLength, c.kStringMaxLength = v.kStringMaxLength, c.resolveObjectURL = v.resolveObjectURL, c.transcode = v.transcode;
+  })(fr)), fr;
+}
+var kr;
+function wt() {
+  return kr || (kr = 1, (function(c, v) {
+    var P = or(), D = P.Buffer;
+    function Y(y, O) {
+      for (var p in y)
+        O[p] = y[p];
+    }
+    D.from && D.alloc && D.allocUnsafe && D.allocUnsafeSlow ? c.exports = P : (Y(P, v), v.Buffer = h);
+    function h(y, O, p) {
+      return D(y, O, p);
+    }
+    h.prototype = Object.create(D.prototype), Y(D, h), h.from = function(y, O, p) {
+      if (typeof y == "number")
+        throw new TypeError("Argument must not be a number");
+      return D(y, O, p);
+    }, h.alloc = function(y, O, p) {
+      if (typeof y != "number")
+        throw new TypeError("Argument must be a number");
+      var N = D(y);
+      return O !== void 0 ? typeof p == "string" ? N.fill(O, p) : N.fill(O) : N.fill(0), N;
+    }, h.allocUnsafe = function(y) {
+      if (typeof y != "number")
+        throw new TypeError("Argument must be a number");
+      return D(y);
+    }, h.allocUnsafeSlow = function(y) {
+      if (typeof y != "number")
+        throw new TypeError("Argument must be a number");
+      return P.SlowBuffer(y);
+    };
+  })($e, $e.exports)), $e.exports;
+}
+var sr, Fr;
+function Yt() {
+  if (Fr) return sr;
+  Fr = 1;
+  var c = {}.toString;
+  return sr = Array.isArray || function(v) {
+    return c.call(v) == "[object Array]";
+  }, sr;
+}
+var lr, xr;
+function zt() {
+  if (xr) return lr;
+  xr = 1;
+  var c = /* @__PURE__ */ Tt(), v = /* @__PURE__ */ It(), P = v("TypedArray.prototype.buffer", !0), D = /* @__PURE__ */ ct();
+  return lr = P || function(h) {
+    if (!D(h))
+      throw new c("Not a Typed Array");
+    return h.buffer;
+  }, lr;
+}
+var cr, qr;
+function fn() {
+  if (qr) return cr;
+  qr = 1;
+  var c = wt().Buffer, v = Yt(), P = /* @__PURE__ */ zt(), D = ArrayBuffer.isView || function(p) {
+    try {
+      return P(p), !0;
+    } catch {
+      return !1;
+    }
+  }, Y = typeof Uint8Array < "u", h = typeof ArrayBuffer < "u" && typeof Uint8Array < "u", y = h && (c.prototype instanceof Uint8Array || c.TYPED_ARRAY_SUPPORT);
+  return cr = function(p, N) {
+    if (c.isBuffer(p))
+      return p.constructor && !("isBuffer" in p) ? c.from(p) : p;
+    if (typeof p == "string")
+      return c.from(p, N);
+    if (h && D(p)) {
+      if (p.byteLength === 0)
+        return c.alloc(0);
+      if (y) {
+        var l = c.from(p.buffer, p.byteOffset, p.byteLength);
+        if (l.byteLength === p.byteLength)
+          return l;
+      }
+      var k = p instanceof Uint8Array ? p : new Uint8Array(p.buffer, p.byteOffset, p.byteLength), j = c.from(k);
+      if (j.length === p.byteLength)
+        return j;
+    }
+    if (Y && p instanceof Uint8Array)
+      return c.from(p);
+    var J = v(p);
+    if (J)
+      for (var V = 0; V < p.length; V += 1) {
+        var X = p[V];
+        if (typeof X != "number" || X < 0 || X > 255 || ~~X !== X)
+          throw new RangeError("Array items must be numbers in the range 0-255.");
+      }
+    if (J || c.isBuffer(p) && p.constructor && typeof p.constructor.isBuffer == "function" && p.constructor.isBuffer(p))
+      return c.from(p);
+    throw new TypeError('The "data" argument must be a string, an Array, a Buffer, a Uint8Array, or a DataView.');
+  }, cr;
+}
+var er = { exports: {} }, hr = {}, pr = {}, Wr;
+function Kt() {
+  return Wr || (Wr = 1, (function(c) {
+    var v = /* @__PURE__ */ Lt(), P = Ot(), D = /* @__PURE__ */ Mt(), Y = /* @__PURE__ */ ct();
+    function h(G) {
+      return G.call.bind(G);
+    }
+    var y = typeof BigInt < "u", O = typeof Symbol < "u", p = h(Object.prototype.toString), N = h(Number.prototype.valueOf), l = h(String.prototype.valueOf), k = h(Boolean.prototype.valueOf);
+    if (y)
+      var j = h(BigInt.prototype.valueOf);
+    if (O)
+      var J = h(Symbol.prototype.valueOf);
+    function V(G, je) {
+      if (typeof G != "object")
+        return !1;
+      try {
+        return je(G), !0;
+      } catch {
+        return !1;
+      }
+    }
+    c.isArgumentsObject = v, c.isGeneratorFunction = P, c.isTypedArray = Y;
+    function X(G) {
+      return typeof Promise < "u" && G instanceof Promise || G !== null && typeof G == "object" && typeof G.then == "function" && typeof G.catch == "function";
+    }
+    c.isPromise = X;
+    function K(G) {
+      return typeof ArrayBuffer < "u" && ArrayBuffer.isView ? ArrayBuffer.isView(G) : Y(G) || F(G);
+    }
+    c.isArrayBufferView = K;
+    function w(G) {
+      return D(G) === "Uint8Array";
+    }
+    c.isUint8Array = w;
+    function B(G) {
+      return D(G) === "Uint8ClampedArray";
+    }
+    c.isUint8ClampedArray = B;
+    function R(G) {
+      return D(G) === "Uint16Array";
+    }
+    c.isUint16Array = R;
+    function d(G) {
+      return D(G) === "Uint32Array";
+    }
+    c.isUint32Array = d;
+    function m(G) {
+      return D(G) === "Int8Array";
+    }
+    c.isInt8Array = m;
+    function A(G) {
+      return D(G) === "Int16Array";
+    }
+    c.isInt16Array = A;
+    function M(G) {
+      return D(G) === "Int32Array";
+    }
+    c.isInt32Array = M;
+    function U(G) {
+      return D(G) === "Float32Array";
+    }
+    c.isFloat32Array = U;
+    function z(G) {
+      return D(G) === "Float64Array";
+    }
+    c.isFloat64Array = z;
+    function Q(G) {
+      return D(G) === "BigInt64Array";
+    }
+    c.isBigInt64Array = Q;
+    function ne(G) {
+      return D(G) === "BigUint64Array";
+    }
+    c.isBigUint64Array = ne;
+    function S(G) {
+      return p(G) === "[object Map]";
+    }
+    S.working = typeof Map < "u" && S(/* @__PURE__ */ new Map());
+    function se(G) {
+      return typeof Map > "u" ? !1 : S.working ? S(G) : G instanceof Map;
+    }
+    c.isMap = se;
+    function he(G) {
+      return p(G) === "[object Set]";
+    }
+    he.working = typeof Set < "u" && he(/* @__PURE__ */ new Set());
+    function ye(G) {
+      return typeof Set > "u" ? !1 : he.working ? he(G) : G instanceof Set;
+    }
+    c.isSet = ye;
+    function Be(G) {
+      return p(G) === "[object WeakMap]";
+    }
+    Be.working = typeof WeakMap < "u" && Be(/* @__PURE__ */ new WeakMap());
+    function Re(G) {
+      return typeof WeakMap > "u" ? !1 : Be.working ? Be(G) : G instanceof WeakMap;
+    }
+    c.isWeakMap = Re;
+    function Ae(G) {
+      return p(G) === "[object WeakSet]";
+    }
+    Ae.working = typeof WeakSet < "u" && Ae(/* @__PURE__ */ new WeakSet());
+    function Se(G) {
+      return Ae(G);
+    }
+    c.isWeakSet = Se;
+    function Te(G) {
+      return p(G) === "[object ArrayBuffer]";
+    }
+    Te.working = typeof ArrayBuffer < "u" && Te(new ArrayBuffer());
+    function Le(G) {
+      return typeof ArrayBuffer > "u" ? !1 : Te.working ? Te(G) : G instanceof ArrayBuffer;
+    }
+    c.isArrayBuffer = Le;
+    function I(G) {
+      return p(G) === "[object DataView]";
+    }
+    I.working = typeof ArrayBuffer < "u" && typeof DataView < "u" && I(new DataView(new ArrayBuffer(1), 0, 1));
+    function F(G) {
+      return typeof DataView > "u" ? !1 : I.working ? I(G) : G instanceof DataView;
+    }
+    c.isDataView = F;
+    var q = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : void 0;
+    function re(G) {
+      return p(G) === "[object SharedArrayBuffer]";
+    }
+    function b(G) {
+      return typeof q > "u" ? !1 : (typeof re.working > "u" && (re.working = re(new q())), re.working ? re(G) : G instanceof q);
+    }
+    c.isSharedArrayBuffer = b;
+    function _(G) {
+      return p(G) === "[object AsyncFunction]";
+    }
+    c.isAsyncFunction = _;
+    function C(G) {
+      return p(G) === "[object Map Iterator]";
+    }
+    c.isMapIterator = C;
+    function Z(G) {
+      return p(G) === "[object Set Iterator]";
+    }
+    c.isSetIterator = Z;
+    function ee(G) {
+      return p(G) === "[object Generator]";
+    }
+    c.isGeneratorObject = ee;
+    function u(G) {
+      return p(G) === "[object WebAssembly.Module]";
+    }
+    c.isWebAssemblyCompiledModule = u;
+    function s(G) {
+      return V(G, N);
+    }
+    c.isNumberObject = s;
+    function H(G) {
+      return V(G, l);
+    }
+    c.isStringObject = H;
+    function $(G) {
+      return V(G, k);
+    }
+    c.isBooleanObject = $;
+    function fe(G) {
+      return y && V(G, j);
+    }
+    c.isBigIntObject = fe;
+    function te(G) {
+      return O && V(G, J);
+    }
+    c.isSymbolObject = te;
+    function ae(G) {
+      return s(G) || H(G) || $(G) || fe(G) || te(G);
+    }
+    c.isBoxedPrimitive = ae;
+    function Me(G) {
+      return typeof Uint8Array < "u" && (Le(G) || b(G));
+    }
+    c.isAnyArrayBuffer = Me, ["isProxy", "isExternal", "isModuleNamespaceObject"].forEach(function(G) {
+      Object.defineProperty(c, G, {
+        enumerable: !1,
+        value: function() {
+          throw new Error(G + " is not supported in userland");
+        }
+      });
+    });
+  })(pr)), pr;
+}
+var dr, Gr;
+function Jt() {
+  return Gr || (Gr = 1, dr = function(v) {
+    return v instanceof qt;
+  }), dr;
+}
+var Hr;
+function Cr() {
+  return Hr || (Hr = 1, (function(c) {
+    var v = Object.getOwnPropertyDescriptors || function(F) {
+      for (var q = Object.keys(F), re = {}, b = 0; b < q.length; b++)
+        re[q[b]] = Object.getOwnPropertyDescriptor(F, q[b]);
+      return re;
+    }, P = /%[sdj%]/g;
+    c.format = function(I) {
+      if (!m(I)) {
+        for (var F = [], q = 0; q < arguments.length; q++)
+          F.push(y(arguments[q]));
+        return F.join(" ");
+      }
+      for (var q = 1, re = arguments, b = re.length, _ = String(I).replace(P, function(Z) {
+        if (Z === "%%") return "%";
+        if (q >= b) return Z;
+        switch (Z) {
+          case "%s":
+            return String(re[q++]);
+          case "%d":
+            return Number(re[q++]);
+          case "%j":
+            try {
+              return JSON.stringify(re[q++]);
+            } catch {
+              return "[Circular]";
+            }
+          default:
+            return Z;
+        }
+      }), C = re[q]; q < b; C = re[++q])
+        B(C) || !z(C) ? _ += " " + C : _ += " " + y(C);
+      return _;
+    }, c.deprecate = function(I, F) {
+      if (typeof ue < "u" && ue.noDeprecation === !0)
+        return I;
+      if (typeof ue > "u")
+        return function() {
+          return c.deprecate(I, F).apply(this, arguments);
+        };
+      var q = !1;
+      function re() {
+        if (!q) {
+          if (ue.throwDeprecation)
+            throw new Error(F);
+          ue.traceDeprecation ? console.trace(F) : console.error(F), q = !0;
+        }
+        return I.apply(this, arguments);
+      }
+      return re;
+    };
+    var D = {}, Y = /^$/;
+    if (ue.env.NODE_DEBUG) {
+      var h = ue.env.NODE_DEBUG;
+      h = h.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase(), Y = new RegExp("^" + h + "$", "i");
+    }
+    c.debuglog = function(I) {
+      if (I = I.toUpperCase(), !D[I])
+        if (Y.test(I)) {
+          var F = ue.pid;
+          D[I] = function() {
+            var q = c.format.apply(c, arguments);
+            console.error("%s %d: %s", I, F, q);
+          };
+        } else
+          D[I] = function() {
+          };
+      return D[I];
+    };
+    function y(I, F) {
+      var q = {
+        seen: [],
+        stylize: p
+      };
+      return arguments.length >= 3 && (q.depth = arguments[2]), arguments.length >= 4 && (q.colors = arguments[3]), w(F) ? q.showHidden = F : F && c._extend(q, F), M(q.showHidden) && (q.showHidden = !1), M(q.depth) && (q.depth = 2), M(q.colors) && (q.colors = !1), M(q.customInspect) && (q.customInspect = !0), q.colors && (q.stylize = O), l(q, I, q.depth);
+    }
+    c.inspect = y, y.colors = {
+      bold: [1, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      inverse: [7, 27],
+      white: [37, 39],
+      grey: [90, 39],
+      black: [30, 39],
+      blue: [34, 39],
+      cyan: [36, 39],
+      green: [32, 39],
+      magenta: [35, 39],
+      red: [31, 39],
+      yellow: [33, 39]
+    }, y.styles = {
+      special: "cyan",
+      number: "yellow",
+      boolean: "yellow",
+      undefined: "grey",
+      null: "bold",
+      string: "green",
+      date: "magenta",
+      // "name": intentionally not styling
+      regexp: "red"
+    };
+    function O(I, F) {
+      var q = y.styles[F];
+      return q ? "\x1B[" + y.colors[q][0] + "m" + I + "\x1B[" + y.colors[q][1] + "m" : I;
+    }
+    function p(I, F) {
+      return I;
+    }
+    function N(I) {
+      var F = {};
+      return I.forEach(function(q, re) {
+        F[q] = !0;
+      }), F;
+    }
+    function l(I, F, q) {
+      if (I.customInspect && F && S(F.inspect) && // Filter out the util module, it's inspect function is special
+      F.inspect !== c.inspect && // Also filter out any prototype objects using the circular check.
+      !(F.constructor && F.constructor.prototype === F)) {
+        var re = F.inspect(q, I);
+        return m(re) || (re = l(I, re, q)), re;
+      }
+      var b = k(I, F);
+      if (b)
+        return b;
+      var _ = Object.keys(F), C = N(_);
+      if (I.showHidden && (_ = Object.getOwnPropertyNames(F)), ne(F) && (_.indexOf("message") >= 0 || _.indexOf("description") >= 0))
+        return j(F);
+      if (_.length === 0) {
+        if (S(F)) {
+          var Z = F.name ? ": " + F.name : "";
+          return I.stylize("[Function" + Z + "]", "special");
+        }
+        if (U(F))
+          return I.stylize(RegExp.prototype.toString.call(F), "regexp");
+        if (Q(F))
+          return I.stylize(Date.prototype.toString.call(F), "date");
+        if (ne(F))
+          return j(F);
+      }
+      var ee = "", u = !1, s = ["{", "}"];
+      if (K(F) && (u = !0, s = ["[", "]"]), S(F)) {
+        var H = F.name ? ": " + F.name : "";
+        ee = " [Function" + H + "]";
+      }
+      if (U(F) && (ee = " " + RegExp.prototype.toString.call(F)), Q(F) && (ee = " " + Date.prototype.toUTCString.call(F)), ne(F) && (ee = " " + j(F)), _.length === 0 && (!u || F.length == 0))
+        return s[0] + ee + s[1];
+      if (q < 0)
+        return U(F) ? I.stylize(RegExp.prototype.toString.call(F), "regexp") : I.stylize("[Object]", "special");
+      I.seen.push(F);
+      var $;
+      return u ? $ = J(I, F, q, C, _) : $ = _.map(function(fe) {
+        return V(I, F, q, C, fe, u);
+      }), I.seen.pop(), X($, ee, s);
+    }
+    function k(I, F) {
+      if (M(F))
+        return I.stylize("undefined", "undefined");
+      if (m(F)) {
+        var q = "'" + JSON.stringify(F).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+        return I.stylize(q, "string");
+      }
+      if (d(F))
+        return I.stylize("" + F, "number");
+      if (w(F))
+        return I.stylize("" + F, "boolean");
+      if (B(F))
+        return I.stylize("null", "null");
+    }
+    function j(I) {
+      return "[" + Error.prototype.toString.call(I) + "]";
+    }
+    function J(I, F, q, re, b) {
+      for (var _ = [], C = 0, Z = F.length; C < Z; ++C)
+        Ae(F, String(C)) ? _.push(V(
+          I,
+          F,
+          q,
+          re,
+          String(C),
+          !0
+        )) : _.push("");
+      return b.forEach(function(ee) {
+        ee.match(/^\d+$/) || _.push(V(
+          I,
+          F,
+          q,
+          re,
+          ee,
+          !0
+        ));
+      }), _;
+    }
+    function V(I, F, q, re, b, _) {
+      var C, Z, ee;
+      if (ee = Object.getOwnPropertyDescriptor(F, b) || { value: F[b] }, ee.get ? ee.set ? Z = I.stylize("[Getter/Setter]", "special") : Z = I.stylize("[Getter]", "special") : ee.set && (Z = I.stylize("[Setter]", "special")), Ae(re, b) || (C = "[" + b + "]"), Z || (I.seen.indexOf(ee.value) < 0 ? (B(q) ? Z = l(I, ee.value, null) : Z = l(I, ee.value, q - 1), Z.indexOf(`
+`) > -1 && (_ ? Z = Z.split(`
+`).map(function(u) {
+        return "  " + u;
+      }).join(`
+`).slice(2) : Z = `
+` + Z.split(`
+`).map(function(u) {
+        return "   " + u;
+      }).join(`
+`))) : Z = I.stylize("[Circular]", "special")), M(C)) {
+        if (_ && b.match(/^\d+$/))
+          return Z;
+        C = JSON.stringify("" + b), C.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (C = C.slice(1, -1), C = I.stylize(C, "name")) : (C = C.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), C = I.stylize(C, "string"));
+      }
+      return C + ": " + Z;
+    }
+    function X(I, F, q) {
+      var re = I.reduce(function(b, _) {
+        return _.indexOf(`
+`) >= 0, b + _.replace(/\u001b\[\d\d?m/g, "").length + 1;
+      }, 0);
+      return re > 60 ? q[0] + (F === "" ? "" : F + `
+ `) + " " + I.join(`,
+  `) + " " + q[1] : q[0] + F + " " + I.join(", ") + " " + q[1];
+    }
+    c.types = Kt();
+    function K(I) {
+      return Array.isArray(I);
+    }
+    c.isArray = K;
+    function w(I) {
+      return typeof I == "boolean";
+    }
+    c.isBoolean = w;
+    function B(I) {
+      return I === null;
+    }
+    c.isNull = B;
+    function R(I) {
+      return I == null;
+    }
+    c.isNullOrUndefined = R;
+    function d(I) {
+      return typeof I == "number";
+    }
+    c.isNumber = d;
+    function m(I) {
+      return typeof I == "string";
+    }
+    c.isString = m;
+    function A(I) {
+      return typeof I == "symbol";
+    }
+    c.isSymbol = A;
+    function M(I) {
+      return I === void 0;
+    }
+    c.isUndefined = M;
+    function U(I) {
+      return z(I) && he(I) === "[object RegExp]";
+    }
+    c.isRegExp = U, c.types.isRegExp = U;
+    function z(I) {
+      return typeof I == "object" && I !== null;
+    }
+    c.isObject = z;
+    function Q(I) {
+      return z(I) && he(I) === "[object Date]";
+    }
+    c.isDate = Q, c.types.isDate = Q;
+    function ne(I) {
+      return z(I) && (he(I) === "[object Error]" || I instanceof Error);
+    }
+    c.isError = ne, c.types.isNativeError = ne;
+    function S(I) {
+      return typeof I == "function";
+    }
+    c.isFunction = S;
+    function se(I) {
+      return I === null || typeof I == "boolean" || typeof I == "number" || typeof I == "string" || typeof I == "symbol" || // ES6 symbol
+      typeof I > "u";
+    }
+    c.isPrimitive = se, c.isBuffer = Jt();
+    function he(I) {
+      return Object.prototype.toString.call(I);
+    }
+    function ye(I) {
+      return I < 10 ? "0" + I.toString(10) : I.toString(10);
+    }
+    var Be = [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec"
+    ];
+    function Re() {
+      var I = /* @__PURE__ */ new Date(), F = [
+        ye(I.getHours()),
+        ye(I.getMinutes()),
+        ye(I.getSeconds())
+      ].join(":");
+      return [I.getDate(), Be[I.getMonth()], F].join(" ");
+    }
+    c.log = function() {
+      console.log("%s - %s", Re(), c.format.apply(c, arguments));
+    }, c.inherits = Ye(), c._extend = function(I, F) {
+      if (!F || !z(F)) return I;
+      for (var q = Object.keys(F), re = q.length; re--; )
+        I[q[re]] = F[q[re]];
+      return I;
+    };
+    function Ae(I, F) {
+      return Object.prototype.hasOwnProperty.call(I, F);
+    }
+    var Se = typeof Symbol < "u" ? /* @__PURE__ */ Symbol("util.promisify.custom") : void 0;
+    c.promisify = function(F) {
+      if (typeof F != "function")
+        throw new TypeError('The "original" argument must be of type Function');
+      if (Se && F[Se]) {
+        var q = F[Se];
+        if (typeof q != "function")
+          throw new TypeError('The "util.promisify.custom" argument must be of type Function');
+        return Object.defineProperty(q, Se, {
+          value: q,
+          enumerable: !1,
+          writable: !1,
+          configurable: !0
+        }), q;
+      }
+      function q() {
+        for (var re, b, _ = new Promise(function(ee, u) {
+          re = ee, b = u;
+        }), C = [], Z = 0; Z < arguments.length; Z++)
+          C.push(arguments[Z]);
+        C.push(function(ee, u) {
+          ee ? b(ee) : re(u);
+        });
+        try {
+          F.apply(this, C);
+        } catch (ee) {
+          b(ee);
+        }
+        return _;
+      }
+      return Object.setPrototypeOf(q, Object.getPrototypeOf(F)), Se && Object.defineProperty(q, Se, {
+        value: q,
+        enumerable: !1,
+        writable: !1,
+        configurable: !0
+      }), Object.defineProperties(
+        q,
+        v(F)
+      );
+    }, c.promisify.custom = Se;
+    function Te(I, F) {
+      if (!I) {
+        var q = new Error("Promise was rejected with a falsy value");
+        q.reason = I, I = q;
+      }
+      return F(I);
+    }
+    function Le(I) {
+      if (typeof I != "function")
+        throw new TypeError('The "original" argument must be of type Function');
+      function F() {
+        for (var q = [], re = 0; re < arguments.length; re++)
+          q.push(arguments[re]);
+        var b = q.pop();
+        if (typeof b != "function")
+          throw new TypeError("The last argument must be of type Function");
+        var _ = this, C = function() {
+          return b.apply(_, arguments);
+        };
+        I.apply(this, q).then(
+          function(Z) {
+            ue.nextTick(C.bind(null, null, Z));
+          },
+          function(Z) {
+            ue.nextTick(Te.bind(null, Z, C));
+          }
+        );
+      }
+      return Object.setPrototypeOf(F, Object.getPrototypeOf(I)), Object.defineProperties(
+        F,
+        v(I)
+      ), F;
+    }
+    c.callbackify = Le;
+  })(hr)), hr;
+}
+var rr = { exports: {} }, Vr;
+function Xt() {
+  return Vr || (Vr = 1, typeof Object.create == "function" ? rr.exports = function(v, P) {
+    P && (v.super_ = P, v.prototype = Object.create(P.prototype, {
+      constructor: {
+        value: v,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }));
+  } : rr.exports = function(v, P) {
+    if (P) {
+      v.super_ = P;
+      var D = function() {
+      };
+      D.prototype = P.prototype, v.prototype = new D(), v.prototype.constructor = v;
+    }
+  }), rr.exports;
+}
+var Yr;
+function Ye() {
+  if (Yr) return er.exports;
+  Yr = 1;
+  try {
+    var c = Cr();
+    if (typeof c.inherits != "function") throw "";
+    er.exports = c.inherits;
+  } catch {
+    er.exports = Xt();
+  }
+  return er.exports;
+}
+var tr = { exports: {} }, zr;
+function mt() {
+  if (zr) return tr.exports;
+  zr = 1;
+  var c = typeof Reflect == "object" ? Reflect : null, v = c && typeof c.apply == "function" ? c.apply : function(m, A, M) {
+    return Function.prototype.apply.call(m, A, M);
+  }, P;
+  c && typeof c.ownKeys == "function" ? P = c.ownKeys : Object.getOwnPropertySymbols ? P = function(m) {
+    return Object.getOwnPropertyNames(m).concat(Object.getOwnPropertySymbols(m));
+  } : P = function(m) {
+    return Object.getOwnPropertyNames(m);
+  };
+  function D(d) {
+    console && console.warn && console.warn(d);
+  }
+  var Y = Number.isNaN || function(m) {
+    return m !== m;
+  };
+  function h() {
+    h.init.call(this);
+  }
+  tr.exports = h, tr.exports.once = w, h.EventEmitter = h, h.prototype._events = void 0, h.prototype._eventsCount = 0, h.prototype._maxListeners = void 0;
+  var y = 10;
+  function O(d) {
+    if (typeof d != "function")
+      throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof d);
+  }
+  Object.defineProperty(h, "defaultMaxListeners", {
+    enumerable: !0,
+    get: function() {
+      return y;
+    },
+    set: function(d) {
+      if (typeof d != "number" || d < 0 || Y(d))
+        throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + d + ".");
+      y = d;
+    }
+  }), h.init = function() {
+    (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+  }, h.prototype.setMaxListeners = function(m) {
+    if (typeof m != "number" || m < 0 || Y(m))
+      throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + m + ".");
+    return this._maxListeners = m, this;
+  };
+  function p(d) {
+    return d._maxListeners === void 0 ? h.defaultMaxListeners : d._maxListeners;
+  }
+  h.prototype.getMaxListeners = function() {
+    return p(this);
+  }, h.prototype.emit = function(m) {
+    for (var A = [], M = 1; M < arguments.length; M++) A.push(arguments[M]);
+    var U = m === "error", z = this._events;
+    if (z !== void 0)
+      U = U && z.error === void 0;
+    else if (!U)
+      return !1;
+    if (U) {
+      var Q;
+      if (A.length > 0 && (Q = A[0]), Q instanceof Error)
+        throw Q;
+      var ne = new Error("Unhandled error." + (Q ? " (" + Q.message + ")" : ""));
+      throw ne.context = Q, ne;
+    }
+    var S = z[m];
+    if (S === void 0)
+      return !1;
+    if (typeof S == "function")
+      v(S, this, A);
+    else
+      for (var se = S.length, he = V(S, se), M = 0; M < se; ++M)
+        v(he[M], this, A);
+    return !0;
+  };
+  function N(d, m, A, M) {
+    var U, z, Q;
+    if (O(A), z = d._events, z === void 0 ? (z = d._events = /* @__PURE__ */ Object.create(null), d._eventsCount = 0) : (z.newListener !== void 0 && (d.emit(
+      "newListener",
+      m,
+      A.listener ? A.listener : A
+    ), z = d._events), Q = z[m]), Q === void 0)
+      Q = z[m] = A, ++d._eventsCount;
+    else if (typeof Q == "function" ? Q = z[m] = M ? [A, Q] : [Q, A] : M ? Q.unshift(A) : Q.push(A), U = p(d), U > 0 && Q.length > U && !Q.warned) {
+      Q.warned = !0;
+      var ne = new Error("Possible EventEmitter memory leak detected. " + Q.length + " " + String(m) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+      ne.name = "MaxListenersExceededWarning", ne.emitter = d, ne.type = m, ne.count = Q.length, D(ne);
+    }
+    return d;
+  }
+  h.prototype.addListener = function(m, A) {
+    return N(this, m, A, !1);
+  }, h.prototype.on = h.prototype.addListener, h.prototype.prependListener = function(m, A) {
+    return N(this, m, A, !0);
+  };
+  function l() {
+    if (!this.fired)
+      return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+  }
+  function k(d, m, A) {
+    var M = { fired: !1, wrapFn: void 0, target: d, type: m, listener: A }, U = l.bind(M);
+    return U.listener = A, M.wrapFn = U, U;
+  }
+  h.prototype.once = function(m, A) {
+    return O(A), this.on(m, k(this, m, A)), this;
+  }, h.prototype.prependOnceListener = function(m, A) {
+    return O(A), this.prependListener(m, k(this, m, A)), this;
+  }, h.prototype.removeListener = function(m, A) {
+    var M, U, z, Q, ne;
+    if (O(A), U = this._events, U === void 0)
+      return this;
+    if (M = U[m], M === void 0)
+      return this;
+    if (M === A || M.listener === A)
+      --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete U[m], U.removeListener && this.emit("removeListener", m, M.listener || A));
+    else if (typeof M != "function") {
+      for (z = -1, Q = M.length - 1; Q >= 0; Q--)
+        if (M[Q] === A || M[Q].listener === A) {
+          ne = M[Q].listener, z = Q;
+          break;
+        }
+      if (z < 0)
+        return this;
+      z === 0 ? M.shift() : X(M, z), M.length === 1 && (U[m] = M[0]), U.removeListener !== void 0 && this.emit("removeListener", m, ne || A);
+    }
+    return this;
+  }, h.prototype.off = h.prototype.removeListener, h.prototype.removeAllListeners = function(m) {
+    var A, M, U;
+    if (M = this._events, M === void 0)
+      return this;
+    if (M.removeListener === void 0)
+      return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : M[m] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete M[m]), this;
+    if (arguments.length === 0) {
+      var z = Object.keys(M), Q;
+      for (U = 0; U < z.length; ++U)
+        Q = z[U], Q !== "removeListener" && this.removeAllListeners(Q);
+      return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
+    }
+    if (A = M[m], typeof A == "function")
+      this.removeListener(m, A);
+    else if (A !== void 0)
+      for (U = A.length - 1; U >= 0; U--)
+        this.removeListener(m, A[U]);
+    return this;
+  };
+  function j(d, m, A) {
+    var M = d._events;
+    if (M === void 0)
+      return [];
+    var U = M[m];
+    return U === void 0 ? [] : typeof U == "function" ? A ? [U.listener || U] : [U] : A ? K(U) : V(U, U.length);
+  }
+  h.prototype.listeners = function(m) {
+    return j(this, m, !0);
+  }, h.prototype.rawListeners = function(m) {
+    return j(this, m, !1);
+  }, h.listenerCount = function(d, m) {
+    return typeof d.listenerCount == "function" ? d.listenerCount(m) : J.call(d, m);
+  }, h.prototype.listenerCount = J;
+  function J(d) {
+    var m = this._events;
+    if (m !== void 0) {
+      var A = m[d];
+      if (typeof A == "function")
+        return 1;
+      if (A !== void 0)
+        return A.length;
+    }
+    return 0;
+  }
+  h.prototype.eventNames = function() {
+    return this._eventsCount > 0 ? P(this._events) : [];
+  };
+  function V(d, m) {
+    for (var A = new Array(m), M = 0; M < m; ++M)
+      A[M] = d[M];
+    return A;
+  }
+  function X(d, m) {
+    for (; m + 1 < d.length; m++)
+      d[m] = d[m + 1];
+    d.pop();
+  }
+  function K(d) {
+    for (var m = new Array(d.length), A = 0; A < m.length; ++A)
+      m[A] = d[A].listener || d[A];
+    return m;
+  }
+  function w(d, m) {
+    return new Promise(function(A, M) {
+      function U(Q) {
+        d.removeListener(m, z), M(Q);
+      }
+      function z() {
+        typeof d.removeListener == "function" && d.removeListener("error", U), A([].slice.call(arguments));
+      }
+      R(d, m, z, { once: !0 }), m !== "error" && B(d, U, { once: !0 });
+    });
+  }
+  function B(d, m, A) {
+    typeof d.on == "function" && R(d, "error", m, A);
+  }
+  function R(d, m, A, M) {
+    if (typeof d.on == "function")
+      M.once ? d.once(m, A) : d.on(m, A);
+    else if (typeof d.addEventListener == "function")
+      d.addEventListener(m, function U(z) {
+        M.once && d.removeEventListener(m, U), A(z);
+      });
+    else
+      throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof d);
+  }
+  return tr.exports;
+}
+var yr, Kr;
+function Et() {
+  return Kr || (Kr = 1, yr = tn()), yr;
+}
+var gr, Jr;
+function Zt() {
+  if (Jr) return gr;
+  Jr = 1;
+  function c(V, X) {
+    var K = Object.keys(V);
+    if (Object.getOwnPropertySymbols) {
+      var w = Object.getOwnPropertySymbols(V);
+      X && (w = w.filter(function(B) {
+        return Object.getOwnPropertyDescriptor(V, B).enumerable;
+      })), K.push.apply(K, w);
+    }
+    return K;
+  }
+  function v(V) {
+    for (var X = 1; X < arguments.length; X++) {
+      var K = arguments[X] != null ? arguments[X] : {};
+      X % 2 ? c(Object(K), !0).forEach(function(w) {
+        P(V, w, K[w]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(V, Object.getOwnPropertyDescriptors(K)) : c(Object(K)).forEach(function(w) {
+        Object.defineProperty(V, w, Object.getOwnPropertyDescriptor(K, w));
+      });
+    }
+    return V;
+  }
+  function P(V, X, K) {
+    return X = y(X), X in V ? Object.defineProperty(V, X, { value: K, enumerable: !0, configurable: !0, writable: !0 }) : V[X] = K, V;
+  }
+  function D(V, X) {
+    if (!(V instanceof X))
+      throw new TypeError("Cannot call a class as a function");
+  }
+  function Y(V, X) {
+    for (var K = 0; K < X.length; K++) {
+      var w = X[K];
+      w.enumerable = w.enumerable || !1, w.configurable = !0, "value" in w && (w.writable = !0), Object.defineProperty(V, y(w.key), w);
+    }
+  }
+  function h(V, X, K) {
+    return X && Y(V.prototype, X), Object.defineProperty(V, "prototype", { writable: !1 }), V;
+  }
+  function y(V) {
+    var X = O(V, "string");
+    return typeof X == "symbol" ? X : String(X);
+  }
+  function O(V, X) {
+    if (typeof V != "object" || V === null) return V;
+    var K = V[Symbol.toPrimitive];
+    if (K !== void 0) {
+      var w = K.call(V, X);
+      if (typeof w != "object") return w;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return String(V);
+  }
+  var p = or(), N = p.Buffer, l = Cr(), k = l.inspect, j = k && k.custom || "inspect";
+  function J(V, X, K) {
+    N.prototype.copy.call(V, X, K);
+  }
+  return gr = /* @__PURE__ */ (function() {
+    function V() {
+      D(this, V), this.head = null, this.tail = null, this.length = 0;
+    }
+    return h(V, [{
+      key: "push",
+      value: function(K) {
+        var w = {
+          data: K,
+          next: null
+        };
+        this.length > 0 ? this.tail.next = w : this.head = w, this.tail = w, ++this.length;
+      }
+    }, {
+      key: "unshift",
+      value: function(K) {
+        var w = {
+          data: K,
+          next: this.head
+        };
+        this.length === 0 && (this.tail = w), this.head = w, ++this.length;
+      }
+    }, {
+      key: "shift",
+      value: function() {
+        if (this.length !== 0) {
+          var K = this.head.data;
+          return this.length === 1 ? this.head = this.tail = null : this.head = this.head.next, --this.length, K;
+        }
+      }
+    }, {
+      key: "clear",
+      value: function() {
+        this.head = this.tail = null, this.length = 0;
+      }
+    }, {
+      key: "join",
+      value: function(K) {
+        if (this.length === 0) return "";
+        for (var w = this.head, B = "" + w.data; w = w.next; ) B += K + w.data;
+        return B;
+      }
+    }, {
+      key: "concat",
+      value: function(K) {
+        if (this.length === 0) return N.alloc(0);
+        for (var w = N.allocUnsafe(K >>> 0), B = this.head, R = 0; B; )
+          J(B.data, w, R), R += B.data.length, B = B.next;
+        return w;
+      }
+      // Consumes a specified amount of bytes or characters from the buffered data.
+    }, {
+      key: "consume",
+      value: function(K, w) {
+        var B;
+        return K < this.head.data.length ? (B = this.head.data.slice(0, K), this.head.data = this.head.data.slice(K)) : K === this.head.data.length ? B = this.shift() : B = w ? this._getString(K) : this._getBuffer(K), B;
+      }
+    }, {
+      key: "first",
+      value: function() {
+        return this.head.data;
+      }
+      // Consumes a specified amount of characters from the buffered data.
+    }, {
+      key: "_getString",
+      value: function(K) {
+        var w = this.head, B = 1, R = w.data;
+        for (K -= R.length; w = w.next; ) {
+          var d = w.data, m = K > d.length ? d.length : K;
+          if (m === d.length ? R += d : R += d.slice(0, K), K -= m, K === 0) {
+            m === d.length ? (++B, w.next ? this.head = w.next : this.head = this.tail = null) : (this.head = w, w.data = d.slice(m));
+            break;
+          }
+          ++B;
+        }
+        return this.length -= B, R;
+      }
+      // Consumes a specified amount of bytes from the buffered data.
+    }, {
+      key: "_getBuffer",
+      value: function(K) {
+        var w = N.allocUnsafe(K), B = this.head, R = 1;
+        for (B.data.copy(w), K -= B.data.length; B = B.next; ) {
+          var d = B.data, m = K > d.length ? d.length : K;
+          if (d.copy(w, w.length - K, 0, m), K -= m, K === 0) {
+            m === d.length ? (++R, B.next ? this.head = B.next : this.head = this.tail = null) : (this.head = B, B.data = d.slice(m));
+            break;
+          }
+          ++R;
+        }
+        return this.length -= R, w;
+      }
+      // Make sure the linked list only shows the minimal necessary information.
+    }, {
+      key: j,
+      value: function(K, w) {
+        return k(this, v(v({}, w), {}, {
+          // Only inspect one level.
+          depth: 0,
+          // It should not recurse.
+          customInspect: !1
+        }));
+      }
+    }]), V;
+  })(), gr;
+}
+var wr, Xr;
+function bt() {
+  if (Xr) return wr;
+  Xr = 1;
+  function c(y, O) {
+    var p = this, N = this._readableState && this._readableState.destroyed, l = this._writableState && this._writableState.destroyed;
+    return N || l ? (O ? O(y) : y && (this._writableState ? this._writableState.errorEmitted || (this._writableState.errorEmitted = !0, ue.nextTick(Y, this, y)) : ue.nextTick(Y, this, y)), this) : (this._readableState && (this._readableState.destroyed = !0), this._writableState && (this._writableState.destroyed = !0), this._destroy(y || null, function(k) {
+      !O && k ? p._writableState ? p._writableState.errorEmitted ? ue.nextTick(P, p) : (p._writableState.errorEmitted = !0, ue.nextTick(v, p, k)) : ue.nextTick(v, p, k) : O ? (ue.nextTick(P, p), O(k)) : ue.nextTick(P, p);
+    }), this);
+  }
+  function v(y, O) {
+    Y(y, O), P(y);
+  }
+  function P(y) {
+    y._writableState && !y._writableState.emitClose || y._readableState && !y._readableState.emitClose || y.emit("close");
+  }
+  function D() {
+    this._readableState && (this._readableState.destroyed = !1, this._readableState.reading = !1, this._readableState.ended = !1, this._readableState.endEmitted = !1), this._writableState && (this._writableState.destroyed = !1, this._writableState.ended = !1, this._writableState.ending = !1, this._writableState.finalCalled = !1, this._writableState.prefinished = !1, this._writableState.finished = !1, this._writableState.errorEmitted = !1);
+  }
+  function Y(y, O) {
+    y.emit("error", O);
+  }
+  function h(y, O) {
+    var p = y._readableState, N = y._writableState;
+    p && p.autoDestroy || N && N.autoDestroy ? y.destroy(O) : y.emit("error", O);
+  }
+  return wr = {
+    destroy: c,
+    undestroy: D,
+    errorOrDestroy: h
+  }, wr;
+}
+var mr = {}, Zr;
+function ze() {
+  if (Zr) return mr;
+  Zr = 1;
+  const c = {};
+  function v(y, O, p) {
+    p || (p = Error);
+    function N(k, j, J) {
+      return typeof O == "string" ? O : O(k, j, J);
+    }
+    class l extends p {
+      constructor(j, J, V) {
+        super(N(j, J, V));
+      }
+    }
+    l.prototype.name = p.name, l.prototype.code = y, c[y] = l;
+  }
+  function P(y, O) {
+    if (Array.isArray(y)) {
+      const p = y.length;
+      return y = y.map((N) => String(N)), p > 2 ? `one of ${O} ${y.slice(0, p - 1).join(", ")}, or ` + y[p - 1] : p === 2 ? `one of ${O} ${y[0]} or ${y[1]}` : `of ${O} ${y[0]}`;
+    } else
+      return `of ${O} ${String(y)}`;
+  }
+  function D(y, O, p) {
+    return y.substr(0, O.length) === O;
+  }
+  function Y(y, O, p) {
+    return (p === void 0 || p > y.length) && (p = y.length), y.substring(p - O.length, p) === O;
+  }
+  function h(y, O, p) {
+    return typeof p != "number" && (p = 0), p + O.length > y.length ? !1 : y.indexOf(O, p) !== -1;
+  }
+  return v("ERR_INVALID_OPT_VALUE", function(y, O) {
+    return 'The value "' + O + '" is invalid for option "' + y + '"';
+  }, TypeError), v("ERR_INVALID_ARG_TYPE", function(y, O, p) {
+    let N;
+    typeof O == "string" && D(O, "not ") ? (N = "must not be", O = O.replace(/^not /, "")) : N = "must be";
+    let l;
+    if (Y(y, " argument"))
+      l = `The ${y} ${N} ${P(O, "type")}`;
+    else {
+      const k = h(y, ".") ? "property" : "argument";
+      l = `The "${y}" ${k} ${N} ${P(O, "type")}`;
+    }
+    return l += `. Received type ${typeof p}`, l;
+  }, TypeError), v("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF"), v("ERR_METHOD_NOT_IMPLEMENTED", function(y) {
+    return "The " + y + " method is not implemented";
+  }), v("ERR_STREAM_PREMATURE_CLOSE", "Premature close"), v("ERR_STREAM_DESTROYED", function(y) {
+    return "Cannot call " + y + " after a stream was destroyed";
+  }), v("ERR_MULTIPLE_CALLBACK", "Callback called multiple times"), v("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable"), v("ERR_STREAM_WRITE_AFTER_END", "write after end"), v("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError), v("ERR_UNKNOWN_ENCODING", function(y) {
+    return "Unknown encoding: " + y;
+  }, TypeError), v("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event"), mr.codes = c, mr;
+}
+var Er, Qr;
+function _t() {
+  if (Qr) return Er;
+  Qr = 1;
+  var c = ze().codes.ERR_INVALID_OPT_VALUE;
+  function v(D, Y, h) {
+    return D.highWaterMark != null ? D.highWaterMark : Y ? D[h] : null;
+  }
+  function P(D, Y, h, y) {
+    var O = v(Y, y, h);
+    if (O != null) {
+      if (!(isFinite(O) && Math.floor(O) === O) || O < 0) {
+        var p = y ? h : "highWaterMark";
+        throw new c(p, O);
+      }
+      return Math.floor(O);
+    }
+    return D.objectMode ? 16 : 16 * 1024;
+  }
+  return Er = {
+    getHighWaterMark: P
+  }, Er;
+}
+var br, $r;
+function vt() {
+  if ($r) return br;
+  $r = 1, br = U;
+  function c(b) {
+    var _ = this;
+    this.next = null, this.entry = null, this.finish = function() {
+      re(_, b);
+    };
+  }
+  var v;
+  U.WritableState = A;
+  var P = {
+    deprecate: Ut()
+  }, D = Et(), Y = or().Buffer, h = (typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function y(b) {
+    return Y.from(b);
+  }
+  function O(b) {
+    return Y.isBuffer(b) || b instanceof h;
+  }
+  var p = bt(), N = _t(), l = N.getHighWaterMark, k = ze().codes, j = k.ERR_INVALID_ARG_TYPE, J = k.ERR_METHOD_NOT_IMPLEMENTED, V = k.ERR_MULTIPLE_CALLBACK, X = k.ERR_STREAM_CANNOT_PIPE, K = k.ERR_STREAM_DESTROYED, w = k.ERR_STREAM_NULL_VALUES, B = k.ERR_STREAM_WRITE_AFTER_END, R = k.ERR_UNKNOWN_ENCODING, d = p.errorOrDestroy;
+  Ye()(U, D);
+  function m() {
+  }
+  function A(b, _, C) {
+    v = v || Ze(), b = b || {}, typeof C != "boolean" && (C = _ instanceof v), this.objectMode = !!b.objectMode, C && (this.objectMode = this.objectMode || !!b.writableObjectMode), this.highWaterMark = l(this, b, "writableHighWaterMark", C), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1;
+    var Z = b.decodeStrings === !1;
+    this.decodeStrings = !Z, this.defaultEncoding = b.defaultEncoding || "utf8", this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function(ee) {
+      Be(_, ee);
+    }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.emitClose = b.emitClose !== !1, this.autoDestroy = !!b.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new c(this);
+  }
+  A.prototype.getBuffer = function() {
+    for (var _ = this.bufferedRequest, C = []; _; )
+      C.push(_), _ = _.next;
+    return C;
+  }, (function() {
+    try {
+      Object.defineProperty(A.prototype, "buffer", {
+        get: P.deprecate(function() {
+          return this.getBuffer();
+        }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+      });
+    } catch {
+    }
+  })();
+  var M;
+  typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (M = Function.prototype[Symbol.hasInstance], Object.defineProperty(U, Symbol.hasInstance, {
+    value: function(_) {
+      return M.call(this, _) ? !0 : this !== U ? !1 : _ && _._writableState instanceof A;
+    }
+  })) : M = function(_) {
+    return _ instanceof this;
+  };
+  function U(b) {
+    v = v || Ze();
+    var _ = this instanceof v;
+    if (!_ && !M.call(U, this)) return new U(b);
+    this._writableState = new A(b, this, _), this.writable = !0, b && (typeof b.write == "function" && (this._write = b.write), typeof b.writev == "function" && (this._writev = b.writev), typeof b.destroy == "function" && (this._destroy = b.destroy), typeof b.final == "function" && (this._final = b.final)), D.call(this);
+  }
+  U.prototype.pipe = function() {
+    d(this, new X());
+  };
+  function z(b, _) {
+    var C = new B();
+    d(b, C), ue.nextTick(_, C);
+  }
+  function Q(b, _, C, Z) {
+    var ee;
+    return C === null ? ee = new w() : typeof C != "string" && !_.objectMode && (ee = new j("chunk", ["string", "Buffer"], C)), ee ? (d(b, ee), ue.nextTick(Z, ee), !1) : !0;
+  }
+  U.prototype.write = function(b, _, C) {
+    var Z = this._writableState, ee = !1, u = !Z.objectMode && O(b);
+    return u && !Y.isBuffer(b) && (b = y(b)), typeof _ == "function" && (C = _, _ = null), u ? _ = "buffer" : _ || (_ = Z.defaultEncoding), typeof C != "function" && (C = m), Z.ending ? z(this, C) : (u || Q(this, Z, b, C)) && (Z.pendingcb++, ee = S(this, Z, u, b, _, C)), ee;
+  }, U.prototype.cork = function() {
+    this._writableState.corked++;
+  }, U.prototype.uncork = function() {
+    var b = this._writableState;
+    b.corked && (b.corked--, !b.writing && !b.corked && !b.bufferProcessing && b.bufferedRequest && Se(this, b));
+  }, U.prototype.setDefaultEncoding = function(_) {
+    if (typeof _ == "string" && (_ = _.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((_ + "").toLowerCase()) > -1)) throw new R(_);
+    return this._writableState.defaultEncoding = _, this;
+  }, Object.defineProperty(U.prototype, "writableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState && this._writableState.getBuffer();
+    }
+  });
+  function ne(b, _, C) {
+    return !b.objectMode && b.decodeStrings !== !1 && typeof _ == "string" && (_ = Y.from(_, C)), _;
+  }
+  Object.defineProperty(U.prototype, "writableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState.highWaterMark;
+    }
+  });
+  function S(b, _, C, Z, ee, u) {
+    if (!C) {
+      var s = ne(_, Z, ee);
+      Z !== s && (C = !0, ee = "buffer", Z = s);
+    }
+    var H = _.objectMode ? 1 : Z.length;
+    _.length += H;
+    var $ = _.length < _.highWaterMark;
+    if ($ || (_.needDrain = !0), _.writing || _.corked) {
+      var fe = _.lastBufferedRequest;
+      _.lastBufferedRequest = {
+        chunk: Z,
+        encoding: ee,
+        isBuf: C,
+        callback: u,
+        next: null
+      }, fe ? fe.next = _.lastBufferedRequest : _.bufferedRequest = _.lastBufferedRequest, _.bufferedRequestCount += 1;
+    } else
+      se(b, _, !1, H, Z, ee, u);
+    return $;
+  }
+  function se(b, _, C, Z, ee, u, s) {
+    _.writelen = Z, _.writecb = s, _.writing = !0, _.sync = !0, _.destroyed ? _.onwrite(new K("write")) : C ? b._writev(ee, _.onwrite) : b._write(ee, u, _.onwrite), _.sync = !1;
+  }
+  function he(b, _, C, Z, ee) {
+    --_.pendingcb, C ? (ue.nextTick(ee, Z), ue.nextTick(F, b, _), b._writableState.errorEmitted = !0, d(b, Z)) : (ee(Z), b._writableState.errorEmitted = !0, d(b, Z), F(b, _));
+  }
+  function ye(b) {
+    b.writing = !1, b.writecb = null, b.length -= b.writelen, b.writelen = 0;
+  }
+  function Be(b, _) {
+    var C = b._writableState, Z = C.sync, ee = C.writecb;
+    if (typeof ee != "function") throw new V();
+    if (ye(C), _) he(b, C, Z, _, ee);
+    else {
+      var u = Te(C) || b.destroyed;
+      !u && !C.corked && !C.bufferProcessing && C.bufferedRequest && Se(b, C), Z ? ue.nextTick(Re, b, C, u, ee) : Re(b, C, u, ee);
+    }
+  }
+  function Re(b, _, C, Z) {
+    C || Ae(b, _), _.pendingcb--, Z(), F(b, _);
+  }
+  function Ae(b, _) {
+    _.length === 0 && _.needDrain && (_.needDrain = !1, b.emit("drain"));
+  }
+  function Se(b, _) {
+    _.bufferProcessing = !0;
+    var C = _.bufferedRequest;
+    if (b._writev && C && C.next) {
+      var Z = _.bufferedRequestCount, ee = new Array(Z), u = _.corkedRequestsFree;
+      u.entry = C;
+      for (var s = 0, H = !0; C; )
+        ee[s] = C, C.isBuf || (H = !1), C = C.next, s += 1;
+      ee.allBuffers = H, se(b, _, !0, _.length, ee, "", u.finish), _.pendingcb++, _.lastBufferedRequest = null, u.next ? (_.corkedRequestsFree = u.next, u.next = null) : _.corkedRequestsFree = new c(_), _.bufferedRequestCount = 0;
+    } else {
+      for (; C; ) {
+        var $ = C.chunk, fe = C.encoding, te = C.callback, ae = _.objectMode ? 1 : $.length;
+        if (se(b, _, !1, ae, $, fe, te), C = C.next, _.bufferedRequestCount--, _.writing)
+          break;
+      }
+      C === null && (_.lastBufferedRequest = null);
+    }
+    _.bufferedRequest = C, _.bufferProcessing = !1;
+  }
+  U.prototype._write = function(b, _, C) {
+    C(new J("_write()"));
+  }, U.prototype._writev = null, U.prototype.end = function(b, _, C) {
+    var Z = this._writableState;
+    return typeof b == "function" ? (C = b, b = null, _ = null) : typeof _ == "function" && (C = _, _ = null), b != null && this.write(b, _), Z.corked && (Z.corked = 1, this.uncork()), Z.ending || q(this, Z, C), this;
+  }, Object.defineProperty(U.prototype, "writableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState.length;
+    }
+  });
+  function Te(b) {
+    return b.ending && b.length === 0 && b.bufferedRequest === null && !b.finished && !b.writing;
+  }
+  function Le(b, _) {
+    b._final(function(C) {
+      _.pendingcb--, C && d(b, C), _.prefinished = !0, b.emit("prefinish"), F(b, _);
+    });
+  }
+  function I(b, _) {
+    !_.prefinished && !_.finalCalled && (typeof b._final == "function" && !_.destroyed ? (_.pendingcb++, _.finalCalled = !0, ue.nextTick(Le, b, _)) : (_.prefinished = !0, b.emit("prefinish")));
+  }
+  function F(b, _) {
+    var C = Te(_);
+    if (C && (I(b, _), _.pendingcb === 0 && (_.finished = !0, b.emit("finish"), _.autoDestroy))) {
+      var Z = b._readableState;
+      (!Z || Z.autoDestroy && Z.endEmitted) && b.destroy();
+    }
+    return C;
+  }
+  function q(b, _, C) {
+    _.ending = !0, F(b, _), C && (_.finished ? ue.nextTick(C) : b.once("finish", C)), _.ended = !0, b.writable = !1;
+  }
+  function re(b, _, C) {
+    var Z = b.entry;
+    for (b.entry = null; Z; ) {
+      var ee = Z.callback;
+      _.pendingcb--, ee(C), Z = Z.next;
+    }
+    _.corkedRequestsFree.next = b;
+  }
+  return Object.defineProperty(U.prototype, "destroyed", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState === void 0 ? !1 : this._writableState.destroyed;
+    },
+    set: function(_) {
+      this._writableState && (this._writableState.destroyed = _);
+    }
+  }), U.prototype.destroy = p.destroy, U.prototype._undestroy = p.undestroy, U.prototype._destroy = function(b, _) {
+    _(b);
+  }, br;
+}
+var _r, et;
+function Ze() {
+  if (et) return _r;
+  et = 1;
+  var c = Object.keys || function(N) {
+    var l = [];
+    for (var k in N) l.push(k);
+    return l;
+  };
+  _r = y;
+  var v = Bt(), P = vt();
+  Ye()(y, v);
+  for (var D = c(P.prototype), Y = 0; Y < D.length; Y++) {
+    var h = D[Y];
+    y.prototype[h] || (y.prototype[h] = P.prototype[h]);
+  }
+  function y(N) {
+    if (!(this instanceof y)) return new y(N);
+    v.call(this, N), P.call(this, N), this.allowHalfOpen = !0, N && (N.readable === !1 && (this.readable = !1), N.writable === !1 && (this.writable = !1), N.allowHalfOpen === !1 && (this.allowHalfOpen = !1, this.once("end", O)));
+  }
+  Object.defineProperty(y.prototype, "writableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState.highWaterMark;
+    }
+  }), Object.defineProperty(y.prototype, "writableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState && this._writableState.getBuffer();
+    }
+  }), Object.defineProperty(y.prototype, "writableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._writableState.length;
+    }
+  });
+  function O() {
+    this._writableState.ended || ue.nextTick(p, this);
+  }
+  function p(N) {
+    N.end();
+  }
+  return Object.defineProperty(y.prototype, "destroyed", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState === void 0 || this._writableState === void 0 ? !1 : this._readableState.destroyed && this._writableState.destroyed;
+    },
+    set: function(l) {
+      this._readableState === void 0 || this._writableState === void 0 || (this._readableState.destroyed = l, this._writableState.destroyed = l);
+    }
+  }), _r;
+}
+var vr = {}, rt;
+function tt() {
+  if (rt) return vr;
+  rt = 1;
+  var c = wt().Buffer, v = c.isEncoding || function(w) {
+    switch (w = "" + w, w && w.toLowerCase()) {
+      case "hex":
+      case "utf8":
+      case "utf-8":
+      case "ascii":
+      case "binary":
+      case "base64":
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+      case "raw":
+        return !0;
+      default:
+        return !1;
+    }
+  };
+  function P(w) {
+    if (!w) return "utf8";
+    for (var B; ; )
+      switch (w) {
+        case "utf8":
+        case "utf-8":
+          return "utf8";
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return "utf16le";
+        case "latin1":
+        case "binary":
+          return "latin1";
+        case "base64":
+        case "ascii":
+        case "hex":
+          return w;
+        default:
+          if (B) return;
+          w = ("" + w).toLowerCase(), B = !0;
+      }
+  }
+  function D(w) {
+    var B = P(w);
+    if (typeof B != "string" && (c.isEncoding === v || !v(w))) throw new Error("Unknown encoding: " + w);
+    return B || w;
+  }
+  vr.StringDecoder = Y;
+  function Y(w) {
+    this.encoding = D(w);
+    var B;
+    switch (this.encoding) {
+      case "utf16le":
+        this.text = k, this.end = j, B = 4;
+        break;
+      case "utf8":
+        this.fillLast = p, B = 4;
+        break;
+      case "base64":
+        this.text = J, this.end = V, B = 3;
+        break;
+      default:
+        this.write = X, this.end = K;
+        return;
+    }
+    this.lastNeed = 0, this.lastTotal = 0, this.lastChar = c.allocUnsafe(B);
+  }
+  Y.prototype.write = function(w) {
+    if (w.length === 0) return "";
+    var B, R;
+    if (this.lastNeed) {
+      if (B = this.fillLast(w), B === void 0) return "";
+      R = this.lastNeed, this.lastNeed = 0;
+    } else
+      R = 0;
+    return R < w.length ? B ? B + this.text(w, R) : this.text(w, R) : B || "";
+  }, Y.prototype.end = l, Y.prototype.text = N, Y.prototype.fillLast = function(w) {
+    if (this.lastNeed <= w.length)
+      return w.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    w.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, w.length), this.lastNeed -= w.length;
+  };
+  function h(w) {
+    return w <= 127 ? 0 : w >> 5 === 6 ? 2 : w >> 4 === 14 ? 3 : w >> 3 === 30 ? 4 : w >> 6 === 2 ? -1 : -2;
+  }
+  function y(w, B, R) {
+    var d = B.length - 1;
+    if (d < R) return 0;
+    var m = h(B[d]);
+    return m >= 0 ? (m > 0 && (w.lastNeed = m - 1), m) : --d < R || m === -2 ? 0 : (m = h(B[d]), m >= 0 ? (m > 0 && (w.lastNeed = m - 2), m) : --d < R || m === -2 ? 0 : (m = h(B[d]), m >= 0 ? (m > 0 && (m === 2 ? m = 0 : w.lastNeed = m - 3), m) : 0));
+  }
+  function O(w, B, R) {
+    if ((B[0] & 192) !== 128)
+      return w.lastNeed = 0, "�";
+    if (w.lastNeed > 1 && B.length > 1) {
+      if ((B[1] & 192) !== 128)
+        return w.lastNeed = 1, "�";
+      if (w.lastNeed > 2 && B.length > 2 && (B[2] & 192) !== 128)
+        return w.lastNeed = 2, "�";
+    }
+  }
+  function p(w) {
+    var B = this.lastTotal - this.lastNeed, R = O(this, w);
+    if (R !== void 0) return R;
+    if (this.lastNeed <= w.length)
+      return w.copy(this.lastChar, B, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    w.copy(this.lastChar, B, 0, w.length), this.lastNeed -= w.length;
+  }
+  function N(w, B) {
+    var R = y(this, w, B);
+    if (!this.lastNeed) return w.toString("utf8", B);
+    this.lastTotal = R;
+    var d = w.length - (R - this.lastNeed);
+    return w.copy(this.lastChar, 0, d), w.toString("utf8", B, d);
+  }
+  function l(w) {
+    var B = w && w.length ? this.write(w) : "";
+    return this.lastNeed ? B + "�" : B;
+  }
+  function k(w, B) {
+    if ((w.length - B) % 2 === 0) {
+      var R = w.toString("utf16le", B);
+      if (R) {
+        var d = R.charCodeAt(R.length - 1);
+        if (d >= 55296 && d <= 56319)
+          return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = w[w.length - 2], this.lastChar[1] = w[w.length - 1], R.slice(0, -1);
+      }
+      return R;
+    }
+    return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = w[w.length - 1], w.toString("utf16le", B, w.length - 1);
+  }
+  function j(w) {
+    var B = w && w.length ? this.write(w) : "";
+    if (this.lastNeed) {
+      var R = this.lastTotal - this.lastNeed;
+      return B + this.lastChar.toString("utf16le", 0, R);
+    }
+    return B;
+  }
+  function J(w, B) {
+    var R = (w.length - B) % 3;
+    return R === 0 ? w.toString("base64", B) : (this.lastNeed = 3 - R, this.lastTotal = 3, R === 1 ? this.lastChar[0] = w[w.length - 1] : (this.lastChar[0] = w[w.length - 2], this.lastChar[1] = w[w.length - 1]), w.toString("base64", B, w.length - R));
+  }
+  function V(w) {
+    var B = w && w.length ? this.write(w) : "";
+    return this.lastNeed ? B + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : B;
+  }
+  function X(w) {
+    return w.toString(this.encoding);
+  }
+  function K(w) {
+    return w && w.length ? this.write(w) : "";
+  }
+  return vr;
+}
+var Br, nt;
+function jr() {
+  if (nt) return Br;
+  nt = 1;
+  var c = ze().codes.ERR_STREAM_PREMATURE_CLOSE;
+  function v(h) {
+    var y = !1;
+    return function() {
+      if (!y) {
+        y = !0;
+        for (var O = arguments.length, p = new Array(O), N = 0; N < O; N++)
+          p[N] = arguments[N];
+        h.apply(this, p);
+      }
+    };
+  }
+  function P() {
+  }
+  function D(h) {
+    return h.setHeader && typeof h.abort == "function";
+  }
+  function Y(h, y, O) {
+    if (typeof y == "function") return Y(h, null, y);
+    y || (y = {}), O = v(O || P);
+    var p = y.readable || y.readable !== !1 && h.readable, N = y.writable || y.writable !== !1 && h.writable, l = function() {
+      h.writable || j();
+    }, k = h._writableState && h._writableState.finished, j = function() {
+      N = !1, k = !0, p || O.call(h);
+    }, J = h._readableState && h._readableState.endEmitted, V = function() {
+      p = !1, J = !0, N || O.call(h);
+    }, X = function(R) {
+      O.call(h, R);
+    }, K = function() {
+      var R;
+      if (p && !J)
+        return (!h._readableState || !h._readableState.ended) && (R = new c()), O.call(h, R);
+      if (N && !k)
+        return (!h._writableState || !h._writableState.ended) && (R = new c()), O.call(h, R);
+    }, w = function() {
+      h.req.on("finish", j);
+    };
+    return D(h) ? (h.on("complete", j), h.on("abort", K), h.req ? w() : h.on("request", w)) : N && !h._writableState && (h.on("end", l), h.on("close", l)), h.on("end", V), h.on("finish", j), y.error !== !1 && h.on("error", X), h.on("close", K), function() {
+      h.removeListener("complete", j), h.removeListener("abort", K), h.removeListener("request", w), h.req && h.req.removeListener("finish", j), h.removeListener("end", l), h.removeListener("close", l), h.removeListener("finish", j), h.removeListener("end", V), h.removeListener("error", X), h.removeListener("close", K);
+    };
+  }
+  return Br = Y, Br;
+}
+var Sr, it;
+function Qt() {
+  if (it) return Sr;
+  it = 1;
+  var c;
+  function v(R, d, m) {
+    return d = P(d), d in R ? Object.defineProperty(R, d, { value: m, enumerable: !0, configurable: !0, writable: !0 }) : R[d] = m, R;
+  }
+  function P(R) {
+    var d = D(R, "string");
+    return typeof d == "symbol" ? d : String(d);
+  }
+  function D(R, d) {
+    if (typeof R != "object" || R === null) return R;
+    var m = R[Symbol.toPrimitive];
+    if (m !== void 0) {
+      var A = m.call(R, d);
+      if (typeof A != "object") return A;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (d === "string" ? String : Number)(R);
+  }
+  var Y = jr(), h = /* @__PURE__ */ Symbol("lastResolve"), y = /* @__PURE__ */ Symbol("lastReject"), O = /* @__PURE__ */ Symbol("error"), p = /* @__PURE__ */ Symbol("ended"), N = /* @__PURE__ */ Symbol("lastPromise"), l = /* @__PURE__ */ Symbol("handlePromise"), k = /* @__PURE__ */ Symbol("stream");
+  function j(R, d) {
+    return {
+      value: R,
+      done: d
+    };
+  }
+  function J(R) {
+    var d = R[h];
+    if (d !== null) {
+      var m = R[k].read();
+      m !== null && (R[N] = null, R[h] = null, R[y] = null, d(j(m, !1)));
+    }
+  }
+  function V(R) {
+    ue.nextTick(J, R);
+  }
+  function X(R, d) {
+    return function(m, A) {
+      R.then(function() {
+        if (d[p]) {
+          m(j(void 0, !0));
+          return;
+        }
+        d[l](m, A);
+      }, A);
+    };
+  }
+  var K = Object.getPrototypeOf(function() {
+  }), w = Object.setPrototypeOf((c = {
+    get stream() {
+      return this[k];
+    },
+    next: function() {
+      var d = this, m = this[O];
+      if (m !== null)
+        return Promise.reject(m);
+      if (this[p])
+        return Promise.resolve(j(void 0, !0));
+      if (this[k].destroyed)
+        return new Promise(function(z, Q) {
+          ue.nextTick(function() {
+            d[O] ? Q(d[O]) : z(j(void 0, !0));
+          });
+        });
+      var A = this[N], M;
+      if (A)
+        M = new Promise(X(A, this));
+      else {
+        var U = this[k].read();
+        if (U !== null)
+          return Promise.resolve(j(U, !1));
+        M = new Promise(this[l]);
+      }
+      return this[N] = M, M;
+    }
+  }, v(c, Symbol.asyncIterator, function() {
+    return this;
+  }), v(c, "return", function() {
+    var d = this;
+    return new Promise(function(m, A) {
+      d[k].destroy(null, function(M) {
+        if (M) {
+          A(M);
+          return;
+        }
+        m(j(void 0, !0));
+      });
+    });
+  }), c), K), B = function(d) {
+    var m, A = Object.create(w, (m = {}, v(m, k, {
+      value: d,
+      writable: !0
+    }), v(m, h, {
+      value: null,
+      writable: !0
+    }), v(m, y, {
+      value: null,
+      writable: !0
+    }), v(m, O, {
+      value: null,
+      writable: !0
+    }), v(m, p, {
+      value: d._readableState.endEmitted,
+      writable: !0
+    }), v(m, l, {
+      value: function(U, z) {
+        var Q = A[k].read();
+        Q ? (A[N] = null, A[h] = null, A[y] = null, U(j(Q, !1))) : (A[h] = U, A[y] = z);
+      },
+      writable: !0
+    }), m));
+    return A[N] = null, Y(d, function(M) {
+      if (M && M.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+        var U = A[y];
+        U !== null && (A[N] = null, A[h] = null, A[y] = null, U(M)), A[O] = M;
+        return;
+      }
+      var z = A[h];
+      z !== null && (A[N] = null, A[h] = null, A[y] = null, z(j(void 0, !0))), A[p] = !0;
+    }), d.on("readable", V.bind(null, A)), A;
+  };
+  return Sr = B, Sr;
+}
+var Rr, ot;
+function $t() {
+  if (ot) return Rr;
+  ot = 1;
+  function c(N, l, k, j, J, V, X) {
+    try {
+      var K = N[V](X), w = K.value;
+    } catch (B) {
+      k(B);
+      return;
+    }
+    K.done ? l(w) : Promise.resolve(w).then(j, J);
+  }
+  function v(N) {
+    return function() {
+      var l = this, k = arguments;
+      return new Promise(function(j, J) {
+        var V = N.apply(l, k);
+        function X(w) {
+          c(V, j, J, X, K, "next", w);
+        }
+        function K(w) {
+          c(V, j, J, X, K, "throw", w);
+        }
+        X(void 0);
+      });
+    };
+  }
+  function P(N, l) {
+    var k = Object.keys(N);
+    if (Object.getOwnPropertySymbols) {
+      var j = Object.getOwnPropertySymbols(N);
+      l && (j = j.filter(function(J) {
+        return Object.getOwnPropertyDescriptor(N, J).enumerable;
+      })), k.push.apply(k, j);
+    }
+    return k;
+  }
+  function D(N) {
+    for (var l = 1; l < arguments.length; l++) {
+      var k = arguments[l] != null ? arguments[l] : {};
+      l % 2 ? P(Object(k), !0).forEach(function(j) {
+        Y(N, j, k[j]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(N, Object.getOwnPropertyDescriptors(k)) : P(Object(k)).forEach(function(j) {
+        Object.defineProperty(N, j, Object.getOwnPropertyDescriptor(k, j));
+      });
+    }
+    return N;
+  }
+  function Y(N, l, k) {
+    return l = h(l), l in N ? Object.defineProperty(N, l, { value: k, enumerable: !0, configurable: !0, writable: !0 }) : N[l] = k, N;
+  }
+  function h(N) {
+    var l = y(N, "string");
+    return typeof l == "symbol" ? l : String(l);
+  }
+  function y(N, l) {
+    if (typeof N != "object" || N === null) return N;
+    var k = N[Symbol.toPrimitive];
+    if (k !== void 0) {
+      var j = k.call(N, l);
+      if (typeof j != "object") return j;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (l === "string" ? String : Number)(N);
+  }
+  var O = ze().codes.ERR_INVALID_ARG_TYPE;
+  function p(N, l, k) {
+    var j;
+    if (l && typeof l.next == "function")
+      j = l;
+    else if (l && l[Symbol.asyncIterator]) j = l[Symbol.asyncIterator]();
+    else if (l && l[Symbol.iterator]) j = l[Symbol.iterator]();
+    else throw new O("iterable", ["Iterable"], l);
+    var J = new N(D({
+      objectMode: !0
+    }, k)), V = !1;
+    J._read = function() {
+      V || (V = !0, X());
+    };
+    function X() {
+      return K.apply(this, arguments);
+    }
+    function K() {
+      return K = v(function* () {
+        try {
+          var w = yield j.next(), B = w.value, R = w.done;
+          R ? J.push(null) : J.push(yield B) ? X() : V = !1;
+        } catch (d) {
+          J.destroy(d);
+        }
+      }), K.apply(this, arguments);
+    }
+    return J;
+  }
+  return Rr = p, Rr;
+}
+var Ar, ut;
+function Bt() {
+  if (ut) return Ar;
+  ut = 1, Ar = z;
+  var c;
+  z.ReadableState = U, mt().EventEmitter;
+  var v = function(s, H) {
+    return s.listeners(H).length;
+  }, P = Et(), D = or().Buffer, Y = (typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function h(u) {
+    return D.from(u);
+  }
+  function y(u) {
+    return D.isBuffer(u) || u instanceof Y;
+  }
+  var O = Cr(), p;
+  O && O.debuglog ? p = O.debuglog("stream") : p = function() {
+  };
+  var N = Zt(), l = bt(), k = _t(), j = k.getHighWaterMark, J = ze().codes, V = J.ERR_INVALID_ARG_TYPE, X = J.ERR_STREAM_PUSH_AFTER_EOF, K = J.ERR_METHOD_NOT_IMPLEMENTED, w = J.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, B, R, d;
+  Ye()(z, P);
+  var m = l.errorOrDestroy, A = ["error", "close", "destroy", "pause", "resume"];
+  function M(u, s, H) {
+    if (typeof u.prependListener == "function") return u.prependListener(s, H);
+    !u._events || !u._events[s] ? u.on(s, H) : Array.isArray(u._events[s]) ? u._events[s].unshift(H) : u._events[s] = [H, u._events[s]];
+  }
+  function U(u, s, H) {
+    c = c || Ze(), u = u || {}, typeof H != "boolean" && (H = s instanceof c), this.objectMode = !!u.objectMode, H && (this.objectMode = this.objectMode || !!u.readableObjectMode), this.highWaterMark = j(this, u, "readableHighWaterMark", H), this.buffer = new N(), this.length = 0, this.pipes = null, this.pipesCount = 0, this.flowing = null, this.ended = !1, this.endEmitted = !1, this.reading = !1, this.sync = !0, this.needReadable = !1, this.emittedReadable = !1, this.readableListening = !1, this.resumeScheduled = !1, this.paused = !0, this.emitClose = u.emitClose !== !1, this.autoDestroy = !!u.autoDestroy, this.destroyed = !1, this.defaultEncoding = u.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, u.encoding && (B || (B = tt().StringDecoder), this.decoder = new B(u.encoding), this.encoding = u.encoding);
+  }
+  function z(u) {
+    if (c = c || Ze(), !(this instanceof z)) return new z(u);
+    var s = this instanceof c;
+    this._readableState = new U(u, this, s), this.readable = !0, u && (typeof u.read == "function" && (this._read = u.read), typeof u.destroy == "function" && (this._destroy = u.destroy)), P.call(this);
+  }
+  Object.defineProperty(z.prototype, "destroyed", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState === void 0 ? !1 : this._readableState.destroyed;
+    },
+    set: function(s) {
+      this._readableState && (this._readableState.destroyed = s);
+    }
+  }), z.prototype.destroy = l.destroy, z.prototype._undestroy = l.undestroy, z.prototype._destroy = function(u, s) {
+    s(u);
+  }, z.prototype.push = function(u, s) {
+    var H = this._readableState, $;
+    return H.objectMode ? $ = !0 : typeof u == "string" && (s = s || H.defaultEncoding, s !== H.encoding && (u = D.from(u, s), s = ""), $ = !0), Q(this, u, s, !1, $);
+  }, z.prototype.unshift = function(u) {
+    return Q(this, u, null, !0, !1);
+  };
+  function Q(u, s, H, $, fe) {
+    p("readableAddChunk", s);
+    var te = u._readableState;
+    if (s === null)
+      te.reading = !1, Be(u, te);
+    else {
+      var ae;
+      if (fe || (ae = S(te, s)), ae)
+        m(u, ae);
+      else if (te.objectMode || s && s.length > 0)
+        if (typeof s != "string" && !te.objectMode && Object.getPrototypeOf(s) !== D.prototype && (s = h(s)), $)
+          te.endEmitted ? m(u, new w()) : ne(u, te, s, !0);
+        else if (te.ended)
+          m(u, new X());
+        else {
+          if (te.destroyed)
+            return !1;
+          te.reading = !1, te.decoder && !H ? (s = te.decoder.write(s), te.objectMode || s.length !== 0 ? ne(u, te, s, !1) : Se(u, te)) : ne(u, te, s, !1);
+        }
+      else $ || (te.reading = !1, Se(u, te));
+    }
+    return !te.ended && (te.length < te.highWaterMark || te.length === 0);
+  }
+  function ne(u, s, H, $) {
+    s.flowing && s.length === 0 && !s.sync ? (s.awaitDrain = 0, u.emit("data", H)) : (s.length += s.objectMode ? 1 : H.length, $ ? s.buffer.unshift(H) : s.buffer.push(H), s.needReadable && Re(u)), Se(u, s);
+  }
+  function S(u, s) {
+    var H;
+    return !y(s) && typeof s != "string" && s !== void 0 && !u.objectMode && (H = new V("chunk", ["string", "Buffer", "Uint8Array"], s)), H;
+  }
+  z.prototype.isPaused = function() {
+    return this._readableState.flowing === !1;
+  }, z.prototype.setEncoding = function(u) {
+    B || (B = tt().StringDecoder);
+    var s = new B(u);
+    this._readableState.decoder = s, this._readableState.encoding = this._readableState.decoder.encoding;
+    for (var H = this._readableState.buffer.head, $ = ""; H !== null; )
+      $ += s.write(H.data), H = H.next;
+    return this._readableState.buffer.clear(), $ !== "" && this._readableState.buffer.push($), this._readableState.length = $.length, this;
+  };
+  var se = 1073741824;
+  function he(u) {
+    return u >= se ? u = se : (u--, u |= u >>> 1, u |= u >>> 2, u |= u >>> 4, u |= u >>> 8, u |= u >>> 16, u++), u;
+  }
+  function ye(u, s) {
+    return u <= 0 || s.length === 0 && s.ended ? 0 : s.objectMode ? 1 : u !== u ? s.flowing && s.length ? s.buffer.head.data.length : s.length : (u > s.highWaterMark && (s.highWaterMark = he(u)), u <= s.length ? u : s.ended ? s.length : (s.needReadable = !0, 0));
+  }
+  z.prototype.read = function(u) {
+    p("read", u), u = parseInt(u, 10);
+    var s = this._readableState, H = u;
+    if (u !== 0 && (s.emittedReadable = !1), u === 0 && s.needReadable && ((s.highWaterMark !== 0 ? s.length >= s.highWaterMark : s.length > 0) || s.ended))
+      return p("read: emitReadable", s.length, s.ended), s.length === 0 && s.ended ? C(this) : Re(this), null;
+    if (u = ye(u, s), u === 0 && s.ended)
+      return s.length === 0 && C(this), null;
+    var $ = s.needReadable;
+    p("need readable", $), (s.length === 0 || s.length - u < s.highWaterMark) && ($ = !0, p("length less than watermark", $)), s.ended || s.reading ? ($ = !1, p("reading or ended", $)) : $ && (p("do read"), s.reading = !0, s.sync = !0, s.length === 0 && (s.needReadable = !0), this._read(s.highWaterMark), s.sync = !1, s.reading || (u = ye(H, s)));
+    var fe;
+    return u > 0 ? fe = _(u, s) : fe = null, fe === null ? (s.needReadable = s.length <= s.highWaterMark, u = 0) : (s.length -= u, s.awaitDrain = 0), s.length === 0 && (s.ended || (s.needReadable = !0), H !== u && s.ended && C(this)), fe !== null && this.emit("data", fe), fe;
+  };
+  function Be(u, s) {
+    if (p("onEofChunk"), !s.ended) {
+      if (s.decoder) {
+        var H = s.decoder.end();
+        H && H.length && (s.buffer.push(H), s.length += s.objectMode ? 1 : H.length);
+      }
+      s.ended = !0, s.sync ? Re(u) : (s.needReadable = !1, s.emittedReadable || (s.emittedReadable = !0, Ae(u)));
+    }
+  }
+  function Re(u) {
+    var s = u._readableState;
+    p("emitReadable", s.needReadable, s.emittedReadable), s.needReadable = !1, s.emittedReadable || (p("emitReadable", s.flowing), s.emittedReadable = !0, ue.nextTick(Ae, u));
+  }
+  function Ae(u) {
+    var s = u._readableState;
+    p("emitReadable_", s.destroyed, s.length, s.ended), !s.destroyed && (s.length || s.ended) && (u.emit("readable"), s.emittedReadable = !1), s.needReadable = !s.flowing && !s.ended && s.length <= s.highWaterMark, b(u);
+  }
+  function Se(u, s) {
+    s.readingMore || (s.readingMore = !0, ue.nextTick(Te, u, s));
+  }
+  function Te(u, s) {
+    for (; !s.reading && !s.ended && (s.length < s.highWaterMark || s.flowing && s.length === 0); ) {
+      var H = s.length;
+      if (p("maybeReadMore read 0"), u.read(0), H === s.length)
+        break;
+    }
+    s.readingMore = !1;
+  }
+  z.prototype._read = function(u) {
+    m(this, new K("_read()"));
+  }, z.prototype.pipe = function(u, s) {
+    var H = this, $ = this._readableState;
+    switch ($.pipesCount) {
+      case 0:
+        $.pipes = u;
+        break;
+      case 1:
+        $.pipes = [$.pipes, u];
+        break;
+      default:
+        $.pipes.push(u);
+        break;
+    }
+    $.pipesCount += 1, p("pipe count=%d opts=%j", $.pipesCount, s);
+    var fe = (!s || s.end !== !1) && u !== ue.stdout && u !== ue.stderr, te = fe ? Me : Ue;
+    $.endEmitted ? ue.nextTick(te) : H.once("end", te), u.on("unpipe", ae);
+    function ae(Ce, Ie) {
+      p("onunpipe"), Ce === H && Ie && Ie.hasUnpiped === !1 && (Ie.hasUnpiped = !0, Ke());
+    }
+    function Me() {
+      p("onend"), u.end();
+    }
+    var G = Le(H);
+    u.on("drain", G);
+    var je = !1;
+    function Ke() {
+      p("cleanup"), u.removeListener("close", Pe), u.removeListener("finish", Oe), u.removeListener("drain", G), u.removeListener("error", _e), u.removeListener("unpipe", ae), H.removeListener("end", Me), H.removeListener("end", Ue), H.removeListener("data", me), je = !0, $.awaitDrain && (!u._writableState || u._writableState.needDrain) && G();
+    }
+    H.on("data", me);
+    function me(Ce) {
+      p("ondata");
+      var Ie = u.write(Ce);
+      p("dest.write", Ie), Ie === !1 && (($.pipesCount === 1 && $.pipes === u || $.pipesCount > 1 && ee($.pipes, u) !== -1) && !je && (p("false write response, pause", $.awaitDrain), $.awaitDrain++), H.pause());
+    }
+    function _e(Ce) {
+      p("onerror", Ce), Ue(), u.removeListener("error", _e), v(u, "error") === 0 && m(u, Ce);
+    }
+    M(u, "error", _e);
+    function Pe() {
+      u.removeListener("finish", Oe), Ue();
+    }
+    u.once("close", Pe);
+    function Oe() {
+      p("onfinish"), u.removeListener("close", Pe), Ue();
+    }
+    u.once("finish", Oe);
+    function Ue() {
+      p("unpipe"), H.unpipe(u);
+    }
+    return u.emit("pipe", H), $.flowing || (p("pipe resume"), H.resume()), u;
+  };
+  function Le(u) {
+    return function() {
+      var H = u._readableState;
+      p("pipeOnDrain", H.awaitDrain), H.awaitDrain && H.awaitDrain--, H.awaitDrain === 0 && v(u, "data") && (H.flowing = !0, b(u));
+    };
+  }
+  z.prototype.unpipe = function(u) {
+    var s = this._readableState, H = {
+      hasUnpiped: !1
+    };
+    if (s.pipesCount === 0) return this;
+    if (s.pipesCount === 1)
+      return u && u !== s.pipes ? this : (u || (u = s.pipes), s.pipes = null, s.pipesCount = 0, s.flowing = !1, u && u.emit("unpipe", this, H), this);
+    if (!u) {
+      var $ = s.pipes, fe = s.pipesCount;
+      s.pipes = null, s.pipesCount = 0, s.flowing = !1;
+      for (var te = 0; te < fe; te++) $[te].emit("unpipe", this, {
+        hasUnpiped: !1
+      });
+      return this;
+    }
+    var ae = ee(s.pipes, u);
+    return ae === -1 ? this : (s.pipes.splice(ae, 1), s.pipesCount -= 1, s.pipesCount === 1 && (s.pipes = s.pipes[0]), u.emit("unpipe", this, H), this);
+  }, z.prototype.on = function(u, s) {
+    var H = P.prototype.on.call(this, u, s), $ = this._readableState;
+    return u === "data" ? ($.readableListening = this.listenerCount("readable") > 0, $.flowing !== !1 && this.resume()) : u === "readable" && !$.endEmitted && !$.readableListening && ($.readableListening = $.needReadable = !0, $.flowing = !1, $.emittedReadable = !1, p("on readable", $.length, $.reading), $.length ? Re(this) : $.reading || ue.nextTick(F, this)), H;
+  }, z.prototype.addListener = z.prototype.on, z.prototype.removeListener = function(u, s) {
+    var H = P.prototype.removeListener.call(this, u, s);
+    return u === "readable" && ue.nextTick(I, this), H;
+  }, z.prototype.removeAllListeners = function(u) {
+    var s = P.prototype.removeAllListeners.apply(this, arguments);
+    return (u === "readable" || u === void 0) && ue.nextTick(I, this), s;
+  };
+  function I(u) {
+    var s = u._readableState;
+    s.readableListening = u.listenerCount("readable") > 0, s.resumeScheduled && !s.paused ? s.flowing = !0 : u.listenerCount("data") > 0 && u.resume();
+  }
+  function F(u) {
+    p("readable nexttick read 0"), u.read(0);
+  }
+  z.prototype.resume = function() {
+    var u = this._readableState;
+    return u.flowing || (p("resume"), u.flowing = !u.readableListening, q(this, u)), u.paused = !1, this;
+  };
+  function q(u, s) {
+    s.resumeScheduled || (s.resumeScheduled = !0, ue.nextTick(re, u, s));
+  }
+  function re(u, s) {
+    p("resume", s.reading), s.reading || u.read(0), s.resumeScheduled = !1, u.emit("resume"), b(u), s.flowing && !s.reading && u.read(0);
+  }
+  z.prototype.pause = function() {
+    return p("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== !1 && (p("pause"), this._readableState.flowing = !1, this.emit("pause")), this._readableState.paused = !0, this;
+  };
+  function b(u) {
+    var s = u._readableState;
+    for (p("flow", s.flowing); s.flowing && u.read() !== null; ) ;
+  }
+  z.prototype.wrap = function(u) {
+    var s = this, H = this._readableState, $ = !1;
+    u.on("end", function() {
+      if (p("wrapped end"), H.decoder && !H.ended) {
+        var ae = H.decoder.end();
+        ae && ae.length && s.push(ae);
+      }
+      s.push(null);
+    }), u.on("data", function(ae) {
+      if (p("wrapped data"), H.decoder && (ae = H.decoder.write(ae)), !(H.objectMode && ae == null) && !(!H.objectMode && (!ae || !ae.length))) {
+        var Me = s.push(ae);
+        Me || ($ = !0, u.pause());
+      }
+    });
+    for (var fe in u)
+      this[fe] === void 0 && typeof u[fe] == "function" && (this[fe] = /* @__PURE__ */ (function(Me) {
+        return function() {
+          return u[Me].apply(u, arguments);
+        };
+      })(fe));
+    for (var te = 0; te < A.length; te++)
+      u.on(A[te], this.emit.bind(this, A[te]));
+    return this._read = function(ae) {
+      p("wrapped _read", ae), $ && ($ = !1, u.resume());
+    }, this;
+  }, typeof Symbol == "function" && (z.prototype[Symbol.asyncIterator] = function() {
+    return R === void 0 && (R = Qt()), R(this);
+  }), Object.defineProperty(z.prototype, "readableHighWaterMark", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState.highWaterMark;
+    }
+  }), Object.defineProperty(z.prototype, "readableBuffer", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState && this._readableState.buffer;
+    }
+  }), Object.defineProperty(z.prototype, "readableFlowing", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState.flowing;
+    },
+    set: function(s) {
+      this._readableState && (this._readableState.flowing = s);
+    }
+  }), z._fromList = _, Object.defineProperty(z.prototype, "readableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState.length;
+    }
+  });
+  function _(u, s) {
+    if (s.length === 0) return null;
+    var H;
+    return s.objectMode ? H = s.buffer.shift() : !u || u >= s.length ? (s.decoder ? H = s.buffer.join("") : s.buffer.length === 1 ? H = s.buffer.first() : H = s.buffer.concat(s.length), s.buffer.clear()) : H = s.buffer.consume(u, s.decoder), H;
+  }
+  function C(u) {
+    var s = u._readableState;
+    p("endReadable", s.endEmitted), s.endEmitted || (s.ended = !0, ue.nextTick(Z, s, u));
+  }
+  function Z(u, s) {
+    if (p("endReadableNT", u.endEmitted, u.length), !u.endEmitted && u.length === 0 && (u.endEmitted = !0, s.readable = !1, s.emit("end"), u.autoDestroy)) {
+      var H = s._writableState;
+      (!H || H.autoDestroy && H.finished) && s.destroy();
+    }
+  }
+  typeof Symbol == "function" && (z.from = function(u, s) {
+    return d === void 0 && (d = $t()), d(z, u, s);
+  });
+  function ee(u, s) {
+    for (var H = 0, $ = u.length; H < $; H++)
+      if (u[H] === s) return H;
+    return -1;
+  }
+  return Ar;
+}
+var Ir, at;
+function St() {
+  if (at) return Ir;
+  at = 1, Ir = O;
+  var c = ze().codes, v = c.ERR_METHOD_NOT_IMPLEMENTED, P = c.ERR_MULTIPLE_CALLBACK, D = c.ERR_TRANSFORM_ALREADY_TRANSFORMING, Y = c.ERR_TRANSFORM_WITH_LENGTH_0, h = Ze();
+  Ye()(O, h);
+  function y(l, k) {
+    var j = this._transformState;
+    j.transforming = !1;
+    var J = j.writecb;
+    if (J === null)
+      return this.emit("error", new P());
+    j.writechunk = null, j.writecb = null, k != null && this.push(k), J(l);
+    var V = this._readableState;
+    V.reading = !1, (V.needReadable || V.length < V.highWaterMark) && this._read(V.highWaterMark);
+  }
+  function O(l) {
+    if (!(this instanceof O)) return new O(l);
+    h.call(this, l), this._transformState = {
+      afterTransform: y.bind(this),
+      needTransform: !1,
+      transforming: !1,
+      writecb: null,
+      writechunk: null,
+      writeencoding: null
+    }, this._readableState.needReadable = !0, this._readableState.sync = !1, l && (typeof l.transform == "function" && (this._transform = l.transform), typeof l.flush == "function" && (this._flush = l.flush)), this.on("prefinish", p);
+  }
+  function p() {
+    var l = this;
+    typeof this._flush == "function" && !this._readableState.destroyed ? this._flush(function(k, j) {
+      N(l, k, j);
+    }) : N(this, null, null);
+  }
+  O.prototype.push = function(l, k) {
+    return this._transformState.needTransform = !1, h.prototype.push.call(this, l, k);
+  }, O.prototype._transform = function(l, k, j) {
+    j(new v("_transform()"));
+  }, O.prototype._write = function(l, k, j) {
+    var J = this._transformState;
+    if (J.writecb = j, J.writechunk = l, J.writeencoding = k, !J.transforming) {
+      var V = this._readableState;
+      (J.needTransform || V.needReadable || V.length < V.highWaterMark) && this._read(V.highWaterMark);
+    }
+  }, O.prototype._read = function(l) {
+    var k = this._transformState;
+    k.writechunk !== null && !k.transforming ? (k.transforming = !0, this._transform(k.writechunk, k.writeencoding, k.afterTransform)) : k.needTransform = !0;
+  }, O.prototype._destroy = function(l, k) {
+    h.prototype._destroy.call(this, l, function(j) {
+      k(j);
+    });
+  };
+  function N(l, k, j) {
+    if (k) return l.emit("error", k);
+    if (j != null && l.push(j), l._writableState.length) throw new Y();
+    if (l._transformState.transforming) throw new D();
+    return l.push(null);
+  }
+  return Ir;
+}
+var Tr, ft;
+function en() {
+  if (ft) return Tr;
+  ft = 1, Tr = v;
+  var c = St();
+  Ye()(v, c);
+  function v(P) {
+    if (!(this instanceof v)) return new v(P);
+    c.call(this, P);
+  }
+  return v.prototype._transform = function(P, D, Y) {
+    Y(null, P);
+  }, Tr;
+}
+var Or, st;
+function rn() {
+  if (st) return Or;
+  st = 1;
+  var c;
+  function v(j) {
+    var J = !1;
+    return function() {
+      J || (J = !0, j.apply(void 0, arguments));
+    };
+  }
+  var P = ze().codes, D = P.ERR_MISSING_ARGS, Y = P.ERR_STREAM_DESTROYED;
+  function h(j) {
+    if (j) throw j;
+  }
+  function y(j) {
+    return j.setHeader && typeof j.abort == "function";
+  }
+  function O(j, J, V, X) {
+    X = v(X);
+    var K = !1;
+    j.on("close", function() {
+      K = !0;
+    }), c === void 0 && (c = jr()), c(j, {
+      readable: J,
+      writable: V
+    }, function(B) {
+      if (B) return X(B);
+      K = !0, X();
+    });
+    var w = !1;
+    return function(B) {
+      if (!K && !w) {
+        if (w = !0, y(j)) return j.abort();
+        if (typeof j.destroy == "function") return j.destroy();
+        X(B || new Y("pipe"));
+      }
+    };
+  }
+  function p(j) {
+    j();
+  }
+  function N(j, J) {
+    return j.pipe(J);
+  }
+  function l(j) {
+    return !j.length || typeof j[j.length - 1] != "function" ? h : j.pop();
+  }
+  function k() {
+    for (var j = arguments.length, J = new Array(j), V = 0; V < j; V++)
+      J[V] = arguments[V];
+    var X = l(J);
+    if (Array.isArray(J[0]) && (J = J[0]), J.length < 2)
+      throw new D("streams");
+    var K, w = J.map(function(B, R) {
+      var d = R < J.length - 1, m = R > 0;
+      return O(B, d, m, function(A) {
+        K || (K = A), A && w.forEach(p), !d && (w.forEach(p), X(K));
+      });
+    });
+    return J.reduce(N);
+  }
+  return Or = k, Or;
+}
+var Lr, lt;
+function tn() {
+  if (lt) return Lr;
+  lt = 1, Lr = P;
+  var c = mt().EventEmitter, v = Ye();
+  v(P, c), P.Readable = Bt(), P.Writable = vt(), P.Duplex = Ze(), P.Transform = St(), P.PassThrough = en(), P.finished = jr(), P.pipeline = rn(), P.Stream = P;
+  function P() {
+    c.call(this);
+  }
+  return P.prototype.pipe = function(D, Y) {
+    var h = this;
+    function y(J) {
+      D.writable && D.write(J) === !1 && h.pause && h.pause();
+    }
+    h.on("data", y);
+    function O() {
+      h.readable && h.resume && h.resume();
+    }
+    D.on("drain", O), !D._isStdio && (!Y || Y.end !== !1) && (h.on("end", N), h.on("close", l));
+    var p = !1;
+    function N() {
+      p || (p = !0, D.end());
+    }
+    function l() {
+      p || (p = !0, typeof D.destroy == "function" && D.destroy());
+    }
+    function k(J) {
+      if (j(), c.listenerCount(this, "error") === 0)
+        throw J;
+    }
+    h.on("error", k), D.on("error", k);
+    function j() {
+      h.removeListener("data", y), D.removeListener("drain", O), h.removeListener("end", N), h.removeListener("close", l), h.removeListener("error", k), D.removeListener("error", k), h.removeListener("end", j), h.removeListener("close", j), D.removeListener("close", j);
+    }
+    return h.on("end", j), h.on("close", j), D.on("close", j), D.emit("pipe", h), D;
+  }, Lr;
+}
+export {
+  qt as B,
+  un as a,
+  fn as b,
+  or as c,
+  Ye as d,
+  Cr as e,
+  tn as f,
+  ue as p,
+  wt as r
+};