@opencloud-eu/web-client 0.1.0

package/dist/index-Pl8khka8.js

@@ -0,0 +1,1141 @@
+const it = globalThis || void 0 || self;
+function Vr(c) {
+  return c && c.__esModule && Object.prototype.hasOwnProperty.call(c, "default") ? c.default : c;
+}
+var Er = { exports: {} }, g = Er.exports = {}, b, S;
+function er() {
+  throw new Error("setTimeout has not been defined");
+}
+function nr() {
+  throw new Error("clearTimeout has not been defined");
+}
+(function() {
+  try {
+    typeof setTimeout == "function" ? b = setTimeout : b = er;
+  } catch {
+    b = er;
+  }
+  try {
+    typeof clearTimeout == "function" ? S = clearTimeout : S = nr;
+  } catch {
+    S = nr;
+  }
+})();
+function dr(c) {
+  if (b === setTimeout)
+    return setTimeout(c, 0);
+  if ((b === er || !b) && setTimeout)
+    return b = setTimeout, setTimeout(c, 0);
+  try {
+    return b(c, 0);
+  } catch {
+    try {
+      return b.call(null, c, 0);
+    } catch {
+      return b.call(this, c, 0);
+    }
+  }
+}
+function Xr(c) {
+  if (S === clearTimeout)
+    return clearTimeout(c);
+  if ((S === nr || !S) && clearTimeout)
+    return S = clearTimeout, clearTimeout(c);
+  try {
+    return S(c);
+  } catch {
+    try {
+      return S.call(null, c);
+    } catch {
+      return S.call(this, c);
+    }
+  }
+}
+var M = [], q = !1, O, V = -1;
+function Jr() {
+  !q || !O || (q = !1, O.length ? M = O.concat(M) : V = -1, M.length && mr());
+}
+function mr() {
+  if (!q) {
+    var c = dr(Jr);
+    q = !0;
+    for (var f = M.length; f; ) {
+      for (O = M, M = []; ++V < f; )
+        O && O[V].run();
+      V = -1, f = M.length;
+    }
+    O = null, q = !1, Xr(c);
+  }
+}
+g.nextTick = function(c) {
+  var f = new Array(arguments.length - 1);
+  if (arguments.length > 1)
+    for (var l = 1; l < arguments.length; l++)
+      f[l - 1] = arguments[l];
+  M.push(new gr(c, f)), M.length === 1 && !q && dr(mr);
+};
+function gr(c, f) {
+  this.fun = c, this.array = f;
+}
+gr.prototype.run = function() {
+  this.fun.apply(null, this.array);
+};
+g.title = "browser";
+g.browser = !0;
+g.env = {};
+g.argv = [];
+g.version = "";
+g.versions = {};
+function D() {
+}
+g.on = D;
+g.addListener = D;
+g.once = D;
+g.off = D;
+g.removeListener = D;
+g.removeAllListeners = D;
+g.emit = D;
+g.prependListener = D;
+g.prependOnceListener = D;
+g.listeners = function(c) {
+  return [];
+};
+g.binding = function(c) {
+  throw new Error("process.binding is not supported");
+};
+g.cwd = function() {
+  return "/";
+};
+g.chdir = function(c) {
+  throw new Error("process.chdir is not supported");
+};
+g.umask = function() {
+  return 0;
+};
+var zr = Er.exports;
+const ot = /* @__PURE__ */ Vr(zr);
+var Ir = {}, X = {};
+X.byteLength = Zr;
+X.toByteArray = rt;
+X.fromByteArray = nt;
+var L = [], C = [], Qr = typeof Uint8Array < "u" ? Uint8Array : Array, tr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var j = 0, Kr = tr.length; j < Kr; ++j)
+  L[j] = tr[j], C[tr.charCodeAt(j)] = j;
+C[45] = 62;
+C[95] = 63;
+function Fr(c) {
+  var f = c.length;
+  if (f % 4 > 0)
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  var l = c.indexOf("=");
+  l === -1 && (l = f);
+  var x = l === f ? 0 : 4 - l % 4;
+  return [l, x];
+}
+function Zr(c) {
+  var f = Fr(c), l = f[0], x = f[1];
+  return (l + x) * 3 / 4 - x;
+}
+function vr(c, f, l) {
+  return (f + l) * 3 / 4 - l;
+}
+function rt(c) {
+  var f, l = Fr(c), x = l[0], w = l[1], p = new Qr(vr(c, x, w)), s = 0, I = w > 0 ? x - 4 : x, B;
+  for (B = 0; B < I; B += 4)
+    f = C[c.charCodeAt(B)] << 18 | C[c.charCodeAt(B + 1)] << 12 | C[c.charCodeAt(B + 2)] << 6 | C[c.charCodeAt(B + 3)], p[s++] = f >> 16 & 255, p[s++] = f >> 8 & 255, p[s++] = f & 255;
+  return w === 2 && (f = C[c.charCodeAt(B)] << 2 | C[c.charCodeAt(B + 1)] >> 4, p[s++] = f & 255), w === 1 && (f = C[c.charCodeAt(B)] << 10 | C[c.charCodeAt(B + 1)] << 4 | C[c.charCodeAt(B + 2)] >> 2, p[s++] = f >> 8 & 255, p[s++] = f & 255), p;
+}
+function tt(c) {
+  return L[c >> 18 & 63] + L[c >> 12 & 63] + L[c >> 6 & 63] + L[c & 63];
+}
+function et(c, f, l) {
+  for (var x, w = [], p = f; p < l; p += 3)
+    x = (c[p] << 16 & 16711680) + (c[p + 1] << 8 & 65280) + (c[p + 2] & 255), w.push(tt(x));
+  return w.join("");
+}
+function nt(c) {
+  for (var f, l = c.length, x = l % 3, w = [], p = 16383, s = 0, I = l - x; s < I; s += p)
+    w.push(et(c, s, s + p > I ? I : s + p));
+  return x === 1 ? (f = c[l - 1], w.push(
+    L[f >> 2] + L[f << 4 & 63] + "=="
+  )) : x === 2 && (f = (c[l - 2] << 8) + c[l - 1], w.push(
+    L[f >> 10] + L[f >> 4 & 63] + L[f << 2 & 63] + "="
+  )), w.join("");
+}
+var ir = {};
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+ir.read = function(c, f, l, x, w) {
+  var p, s, I = w * 8 - x - 1, B = (1 << I) - 1, T = B >> 1, o = -7, A = l ? w - 1 : 0, N = l ? -1 : 1, R = c[f + A];
+  for (A += N, p = R & (1 << -o) - 1, R >>= -o, o += I; o > 0; p = p * 256 + c[f + A], A += N, o -= 8)
+    ;
+  for (s = p & (1 << -o) - 1, p >>= -o, o += x; o > 0; s = s * 256 + c[f + A], A += N, o -= 8)
+    ;
+  if (p === 0)
+    p = 1 - T;
+  else {
+    if (p === B)
+      return s ? NaN : (R ? -1 : 1) * (1 / 0);
+    s = s + Math.pow(2, x), p = p - T;
+  }
+  return (R ? -1 : 1) * s * Math.pow(2, p - x);
+};
+ir.write = function(c, f, l, x, w, p) {
+  var s, I, B, T = p * 8 - w - 1, o = (1 << T) - 1, A = o >> 1, N = w === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, R = x ? 0 : p - 1, P = x ? 1 : -1, J = f < 0 || f === 0 && 1 / f < 0 ? 1 : 0;
+  for (f = Math.abs(f), isNaN(f) || f === 1 / 0 ? (I = isNaN(f) ? 1 : 0, s = o) : (s = Math.floor(Math.log(f) / Math.LN2), f * (B = Math.pow(2, -s)) < 1 && (s--, B *= 2), s + A >= 1 ? f += N / B : f += N * Math.pow(2, 1 - A), f * B >= 2 && (s++, B /= 2), s + A >= o ? (I = 0, s = o) : s + A >= 1 ? (I = (f * B - 1) * Math.pow(2, w), s = s + A) : (I = f * Math.pow(2, A - 1) * Math.pow(2, w), s = 0)); w >= 8; c[l + R] = I & 255, R += P, I /= 256, w -= 8)
+    ;
+  for (s = s << w | I, T += w; T > 0; c[l + R] = s & 255, R += P, s /= 256, T -= 8)
+    ;
+  c[l + R - P] |= J * 128;
+};
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+(function(c) {
+  const f = X, l = ir, x = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
+  c.Buffer = o, c.SlowBuffer = Ur, c.INSPECT_MAX_BYTES = 50;
+  const w = 2147483647;
+  c.kMaxLength = w;
+  const { Uint8Array: p, ArrayBuffer: s, SharedArrayBuffer: I } = globalThis;
+  o.TYPED_ARRAY_SUPPORT = B(), !o.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error(
+    "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+  );
+  function B() {
+    try {
+      const e = new p(1), r = { foo: function() {
+        return 42;
+      } };
+      return Object.setPrototypeOf(r, p.prototype), Object.setPrototypeOf(e, r), e.foo() === 42;
+    } catch {
+      return !1;
+    }
+  }
+  Object.defineProperty(o.prototype, "parent", {
+    enumerable: !0,
+    get: function() {
+      if (o.isBuffer(this))
+        return this.buffer;
+    }
+  }), Object.defineProperty(o.prototype, "offset", {
+    enumerable: !0,
+    get: function() {
+      if (o.isBuffer(this))
+        return this.byteOffset;
+    }
+  });
+  function T(e) {
+    if (e > w)
+      throw new RangeError('The value "' + e + '" is invalid for option "size"');
+    const r = new p(e);
+    return Object.setPrototypeOf(r, o.prototype), r;
+  }
+  function o(e, r, t) {
+    if (typeof e == "number") {
+      if (typeof r == "string")
+        throw new TypeError(
+          'The "string" argument must be of type string. Received type number'
+        );
+      return P(e);
+    }
+    return A(e, r, t);
+  }
+  o.poolSize = 8192;
+  function A(e, r, t) {
+    if (typeof e == "string")
+      return J(e, r);
+    if (s.isView(e))
+      return Tr(e);
+    if (e == null)
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof e
+      );
+    if (_(e, s) || e && _(e.buffer, s) || typeof I < "u" && (_(e, I) || e && _(e.buffer, I)))
+      return Q(e, r, t);
+    if (typeof e == "number")
+      throw new TypeError(
+        'The "value" argument must not be of type number. Received type number'
+      );
+    const n = e.valueOf && e.valueOf();
+    if (n != null && n !== e)
+      return o.from(n, r, t);
+    const i = Ar(e);
+    if (i) return i;
+    if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof e[Symbol.toPrimitive] == "function")
+      return o.from(e[Symbol.toPrimitive]("string"), r, t);
+    throw new TypeError(
+      "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof e
+    );
+  }
+  o.from = function(e, r, t) {
+    return A(e, r, t);
+  }, Object.setPrototypeOf(o.prototype, p.prototype), Object.setPrototypeOf(o, p);
+  function N(e) {
+    if (typeof e != "number")
+      throw new TypeError('"size" argument must be of type number');
+    if (e < 0)
+      throw new RangeError('The value "' + e + '" is invalid for option "size"');
+  }
+  function R(e, r, t) {
+    return N(e), e <= 0 ? T(e) : r !== void 0 ? typeof t == "string" ? T(e).fill(r, t) : T(e).fill(r) : T(e);
+  }
+  o.alloc = function(e, r, t) {
+    return R(e, r, t);
+  };
+  function P(e) {
+    return N(e), T(e < 0 ? 0 : K(e) | 0);
+  }
+  o.allocUnsafe = function(e) {
+    return P(e);
+  }, o.allocUnsafeSlow = function(e) {
+    return P(e);
+  };
+  function J(e, r) {
+    if ((typeof r != "string" || r === "") && (r = "utf8"), !o.isEncoding(r))
+      throw new TypeError("Unknown encoding: " + r);
+    const t = or(e, r) | 0;
+    let n = T(t);
+    const i = n.write(e, r);
+    return i !== t && (n = n.slice(0, i)), n;
+  }
+  function z(e) {
+    const r = e.length < 0 ? 0 : K(e.length) | 0, t = T(r);
+    for (let n = 0; n < r; n += 1)
+      t[n] = e[n] & 255;
+    return t;
+  }
+  function Tr(e) {
+    if (_(e, p)) {
+      const r = new p(e);
+      return Q(r.buffer, r.byteOffset, r.byteLength);
+    }
+    return z(e);
+  }
+  function Q(e, r, t) {
+    if (r < 0 || e.byteLength < r)
+      throw new RangeError('"offset" is outside of buffer bounds');
+    if (e.byteLength < r + (t || 0))
+      throw new RangeError('"length" is outside of buffer bounds');
+    let n;
+    return r === void 0 && t === void 0 ? n = new p(e) : t === void 0 ? n = new p(e, r) : n = new p(e, r, t), Object.setPrototypeOf(n, o.prototype), n;
+  }
+  function Ar(e) {
+    if (o.isBuffer(e)) {
+      const r = K(e.length) | 0, t = T(r);
+      return t.length === 0 || e.copy(t, 0, 0, r), t;
+    }
+    if (e.length !== void 0)
+      return typeof e.length != "number" || rr(e.length) ? T(0) : z(e);
+    if (e.type === "Buffer" && Array.isArray(e.data))
+      return z(e.data);
+  }
+  function K(e) {
+    if (e >= w)
+      throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + w.toString(16) + " bytes");
+    return e | 0;
+  }
+  function Ur(e) {
+    return +e != e && (e = 0), o.alloc(+e);
+  }
+  o.isBuffer = function(r) {
+    return r != null && r._isBuffer === !0 && r !== o.prototype;
+  }, o.compare = function(r, t) {
+    if (_(r, p) && (r = o.from(r, r.offset, r.byteLength)), _(t, p) && (t = o.from(t, t.offset, t.byteLength)), !o.isBuffer(r) || !o.isBuffer(t))
+      throw new TypeError(
+        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+      );
+    if (r === t) return 0;
+    let n = r.length, i = t.length;
+    for (let u = 0, h = Math.min(n, i); u < h; ++u)
+      if (r[u] !== t[u]) {
+        n = r[u], i = t[u];
+        break;
+      }
+    return n < i ? -1 : i < n ? 1 : 0;
+  }, o.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;
+    }
+  }, o.concat = function(r, t) {
+    if (!Array.isArray(r))
+      throw new TypeError('"list" argument must be an Array of Buffers');
+    if (r.length === 0)
+      return o.alloc(0);
+    let n;
+    if (t === void 0)
+      for (t = 0, n = 0; n < r.length; ++n)
+        t += r[n].length;
+    const i = o.allocUnsafe(t);
+    let u = 0;
+    for (n = 0; n < r.length; ++n) {
+      let h = r[n];
+      if (_(h, p))
+        u + h.length > i.length ? (o.isBuffer(h) || (h = o.from(h)), h.copy(i, u)) : p.prototype.set.call(
+          i,
+          h,
+          u
+        );
+      else if (o.isBuffer(h))
+        h.copy(i, u);
+      else
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      u += h.length;
+    }
+    return i;
+  };
+  function or(e, r) {
+    if (o.isBuffer(e))
+      return e.length;
+    if (s.isView(e) || _(e, s))
+      return e.byteLength;
+    if (typeof e != "string")
+      throw new TypeError(
+        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof e
+      );
+    const t = e.length, n = arguments.length > 2 && arguments[2] === !0;
+    if (!n && t === 0) return 0;
+    let i = !1;
+    for (; ; )
+      switch (r) {
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return t;
+        case "utf8":
+        case "utf-8":
+          return v(e).length;
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return t * 2;
+        case "hex":
+          return t >>> 1;
+        case "base64":
+          return Br(e).length;
+        default:
+          if (i)
+            return n ? -1 : v(e).length;
+          r = ("" + r).toLowerCase(), i = !0;
+      }
+  }
+  o.byteLength = or;
+  function Rr(e, r, t) {
+    let n = !1;
+    if ((r === void 0 || r < 0) && (r = 0), r > this.length || ((t === void 0 || t > this.length) && (t = this.length), t <= 0) || (t >>>= 0, r >>>= 0, t <= r))
+      return "";
+    for (e || (e = "utf8"); ; )
+      switch (e) {
+        case "hex":
+          return Pr(this, r, t);
+        case "utf8":
+        case "utf-8":
+          return cr(this, r, t);
+        case "ascii":
+          return Dr(this, r, t);
+        case "latin1":
+        case "binary":
+          return kr(this, r, t);
+        case "base64":
+          return Nr(this, r, t);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return $r(this, r, t);
+        default:
+          if (n) throw new TypeError("Unknown encoding: " + e);
+          e = (e + "").toLowerCase(), n = !0;
+      }
+  }
+  o.prototype._isBuffer = !0;
+  function $(e, r, t) {
+    const n = e[r];
+    e[r] = e[t], e[t] = n;
+  }
+  o.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 t = 0; t < r; t += 2)
+      $(this, t, t + 1);
+    return this;
+  }, o.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 t = 0; t < r; t += 4)
+      $(this, t, t + 3), $(this, t + 1, t + 2);
+    return this;
+  }, o.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 t = 0; t < r; t += 8)
+      $(this, t, t + 7), $(this, t + 1, t + 6), $(this, t + 2, t + 5), $(this, t + 3, t + 4);
+    return this;
+  }, o.prototype.toString = function() {
+    const r = this.length;
+    return r === 0 ? "" : arguments.length === 0 ? cr(this, 0, r) : Rr.apply(this, arguments);
+  }, o.prototype.toLocaleString = o.prototype.toString, o.prototype.equals = function(r) {
+    if (!o.isBuffer(r)) throw new TypeError("Argument must be a Buffer");
+    return this === r ? !0 : o.compare(this, r) === 0;
+  }, o.prototype.inspect = function() {
+    let r = "";
+    const t = c.INSPECT_MAX_BYTES;
+    return r = this.toString("hex", 0, t).replace(/(.{2})/g, "$1 ").trim(), this.length > t && (r += " ... "), "<Buffer " + r + ">";
+  }, x && (o.prototype[x] = o.prototype.inspect), o.prototype.compare = function(r, t, n, i, u) {
+    if (_(r, p) && (r = o.from(r, r.offset, r.byteLength)), !o.isBuffer(r))
+      throw new TypeError(
+        'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof r
+      );
+    if (t === void 0 && (t = 0), n === void 0 && (n = r ? r.length : 0), i === void 0 && (i = 0), u === void 0 && (u = this.length), t < 0 || n > r.length || i < 0 || u > this.length)
+      throw new RangeError("out of range index");
+    if (i >= u && t >= n)
+      return 0;
+    if (i >= u)
+      return -1;
+    if (t >= n)
+      return 1;
+    if (t >>>= 0, n >>>= 0, i >>>= 0, u >>>= 0, this === r) return 0;
+    let h = u - i, a = n - t;
+    const d = Math.min(h, a), E = this.slice(i, u), m = r.slice(t, n);
+    for (let y = 0; y < d; ++y)
+      if (E[y] !== m[y]) {
+        h = E[y], a = m[y];
+        break;
+      }
+    return h < a ? -1 : a < h ? 1 : 0;
+  };
+  function ur(e, r, t, n, i) {
+    if (e.length === 0) return -1;
+    if (typeof t == "string" ? (n = t, t = 0) : t > 2147483647 ? t = 2147483647 : t < -2147483648 && (t = -2147483648), t = +t, rr(t) && (t = i ? 0 : e.length - 1), t < 0 && (t = e.length + t), t >= e.length) {
+      if (i) return -1;
+      t = e.length - 1;
+    } else if (t < 0)
+      if (i) t = 0;
+      else return -1;
+    if (typeof r == "string" && (r = o.from(r, n)), o.isBuffer(r))
+      return r.length === 0 ? -1 : hr(e, r, t, n, i);
+    if (typeof r == "number")
+      return r = r & 255, typeof p.prototype.indexOf == "function" ? i ? p.prototype.indexOf.call(e, r, t) : p.prototype.lastIndexOf.call(e, r, t) : hr(e, [r], t, n, i);
+    throw new TypeError("val must be string, number or Buffer");
+  }
+  function hr(e, r, t, n, i) {
+    let u = 1, h = e.length, a = r.length;
+    if (n !== void 0 && (n = String(n).toLowerCase(), n === "ucs2" || n === "ucs-2" || n === "utf16le" || n === "utf-16le")) {
+      if (e.length < 2 || r.length < 2)
+        return -1;
+      u = 2, h /= 2, a /= 2, t /= 2;
+    }
+    function d(m, y) {
+      return u === 1 ? m[y] : m.readUInt16BE(y * u);
+    }
+    let E;
+    if (i) {
+      let m = -1;
+      for (E = t; E < h; E++)
+        if (d(e, E) === d(r, m === -1 ? 0 : E - m)) {
+          if (m === -1 && (m = E), E - m + 1 === a) return m * u;
+        } else
+          m !== -1 && (E -= E - m), m = -1;
+    } else
+      for (t + a > h && (t = h - a), E = t; E >= 0; E--) {
+        let m = !0;
+        for (let y = 0; y < a; y++)
+          if (d(e, E + y) !== d(r, y)) {
+            m = !1;
+            break;
+          }
+        if (m) return E;
+      }
+    return -1;
+  }
+  o.prototype.includes = function(r, t, n) {
+    return this.indexOf(r, t, n) !== -1;
+  }, o.prototype.indexOf = function(r, t, n) {
+    return ur(this, r, t, n, !0);
+  }, o.prototype.lastIndexOf = function(r, t, n) {
+    return ur(this, r, t, n, !1);
+  };
+  function Cr(e, r, t, n) {
+    t = Number(t) || 0;
+    const i = e.length - t;
+    n ? (n = Number(n), n > i && (n = i)) : n = i;
+    const u = r.length;
+    n > u / 2 && (n = u / 2);
+    let h;
+    for (h = 0; h < n; ++h) {
+      const a = parseInt(r.substr(h * 2, 2), 16);
+      if (rr(a)) return h;
+      e[t + h] = a;
+    }
+    return h;
+  }
+  function _r(e, r, t, n) {
+    return H(v(r, e.length - t), e, t, n);
+  }
+  function br(e, r, t, n) {
+    return H(jr(r), e, t, n);
+  }
+  function Sr(e, r, t, n) {
+    return H(Br(r), e, t, n);
+  }
+  function Lr(e, r, t, n) {
+    return H(qr(r, e.length - t), e, t, n);
+  }
+  o.prototype.write = function(r, t, n, i) {
+    if (t === void 0)
+      i = "utf8", n = this.length, t = 0;
+    else if (n === void 0 && typeof t == "string")
+      i = t, n = this.length, t = 0;
+    else if (isFinite(t))
+      t = t >>> 0, isFinite(n) ? (n = n >>> 0, i === void 0 && (i = "utf8")) : (i = n, n = void 0);
+    else
+      throw new Error(
+        "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+      );
+    const u = this.length - t;
+    if ((n === void 0 || n > u) && (n = u), r.length > 0 && (n < 0 || t < 0) || t > this.length)
+      throw new RangeError("Attempt to write outside buffer bounds");
+    i || (i = "utf8");
+    let h = !1;
+    for (; ; )
+      switch (i) {
+        case "hex":
+          return Cr(this, r, t, n);
+        case "utf8":
+        case "utf-8":
+          return _r(this, r, t, n);
+        case "ascii":
+        case "latin1":
+        case "binary":
+          return br(this, r, t, n);
+        case "base64":
+          return Sr(this, r, t, n);
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return Lr(this, r, t, n);
+        default:
+          if (h) throw new TypeError("Unknown encoding: " + i);
+          i = ("" + i).toLowerCase(), h = !0;
+      }
+  }, o.prototype.toJSON = function() {
+    return {
+      type: "Buffer",
+      data: Array.prototype.slice.call(this._arr || this, 0)
+    };
+  };
+  function Nr(e, r, t) {
+    return r === 0 && t === e.length ? f.fromByteArray(e) : f.fromByteArray(e.slice(r, t));
+  }
+  function cr(e, r, t) {
+    t = Math.min(e.length, t);
+    const n = [];
+    let i = r;
+    for (; i < t; ) {
+      const u = e[i];
+      let h = null, a = u > 239 ? 4 : u > 223 ? 3 : u > 191 ? 2 : 1;
+      if (i + a <= t) {
+        let d, E, m, y;
+        switch (a) {
+          case 1:
+            u < 128 && (h = u);
+            break;
+          case 2:
+            d = e[i + 1], (d & 192) === 128 && (y = (u & 31) << 6 | d & 63, y > 127 && (h = y));
+            break;
+          case 3:
+            d = e[i + 1], E = e[i + 2], (d & 192) === 128 && (E & 192) === 128 && (y = (u & 15) << 12 | (d & 63) << 6 | E & 63, y > 2047 && (y < 55296 || y > 57343) && (h = y));
+            break;
+          case 4:
+            d = e[i + 1], E = e[i + 2], m = e[i + 3], (d & 192) === 128 && (E & 192) === 128 && (m & 192) === 128 && (y = (u & 15) << 18 | (d & 63) << 12 | (E & 63) << 6 | m & 63, y > 65535 && y < 1114112 && (h = y));
+        }
+      }
+      h === null ? (h = 65533, a = 1) : h > 65535 && (h -= 65536, n.push(h >>> 10 & 1023 | 55296), h = 56320 | h & 1023), n.push(h), i += a;
+    }
+    return Mr(n);
+  }
+  const fr = 4096;
+  function Mr(e) {
+    const r = e.length;
+    if (r <= fr)
+      return String.fromCharCode.apply(String, e);
+    let t = "", n = 0;
+    for (; n < r; )
+      t += String.fromCharCode.apply(
+        String,
+        e.slice(n, n += fr)
+      );
+    return t;
+  }
+  function Dr(e, r, t) {
+    let n = "";
+    t = Math.min(e.length, t);
+    for (let i = r; i < t; ++i)
+      n += String.fromCharCode(e[i] & 127);
+    return n;
+  }
+  function kr(e, r, t) {
+    let n = "";
+    t = Math.min(e.length, t);
+    for (let i = r; i < t; ++i)
+      n += String.fromCharCode(e[i]);
+    return n;
+  }
+  function Pr(e, r, t) {
+    const n = e.length;
+    (!r || r < 0) && (r = 0), (!t || t < 0 || t > n) && (t = n);
+    let i = "";
+    for (let u = r; u < t; ++u)
+      i += Wr[e[u]];
+    return i;
+  }
+  function $r(e, r, t) {
+    const n = e.slice(r, t);
+    let i = "";
+    for (let u = 0; u < n.length - 1; u += 2)
+      i += String.fromCharCode(n[u] + n[u + 1] * 256);
+    return i;
+  }
+  o.prototype.slice = function(r, t) {
+    const n = this.length;
+    r = ~~r, t = t === void 0 ? n : ~~t, r < 0 ? (r += n, r < 0 && (r = 0)) : r > n && (r = n), t < 0 ? (t += n, t < 0 && (t = 0)) : t > n && (t = n), t < r && (t = r);
+    const i = this.subarray(r, t);
+    return Object.setPrototypeOf(i, o.prototype), i;
+  };
+  function F(e, r, t) {
+    if (e % 1 !== 0 || e < 0) throw new RangeError("offset is not uint");
+    if (e + r > t) throw new RangeError("Trying to access beyond buffer length");
+  }
+  o.prototype.readUintLE = o.prototype.readUIntLE = function(r, t, n) {
+    r = r >>> 0, t = t >>> 0, n || F(r, t, this.length);
+    let i = this[r], u = 1, h = 0;
+    for (; ++h < t && (u *= 256); )
+      i += this[r + h] * u;
+    return i;
+  }, o.prototype.readUintBE = o.prototype.readUIntBE = function(r, t, n) {
+    r = r >>> 0, t = t >>> 0, n || F(r, t, this.length);
+    let i = this[r + --t], u = 1;
+    for (; t > 0 && (u *= 256); )
+      i += this[r + --t] * u;
+    return i;
+  }, o.prototype.readUint8 = o.prototype.readUInt8 = function(r, t) {
+    return r = r >>> 0, t || F(r, 1, this.length), this[r];
+  }, o.prototype.readUint16LE = o.prototype.readUInt16LE = function(r, t) {
+    return r = r >>> 0, t || F(r, 2, this.length), this[r] | this[r + 1] << 8;
+  }, o.prototype.readUint16BE = o.prototype.readUInt16BE = function(r, t) {
+    return r = r >>> 0, t || F(r, 2, this.length), this[r] << 8 | this[r + 1];
+  }, o.prototype.readUint32LE = o.prototype.readUInt32LE = function(r, t) {
+    return r = r >>> 0, t || F(r, 4, this.length), (this[r] | this[r + 1] << 8 | this[r + 2] << 16) + this[r + 3] * 16777216;
+  }, o.prototype.readUint32BE = o.prototype.readUInt32BE = function(r, t) {
+    return r = r >>> 0, t || F(r, 4, this.length), this[r] * 16777216 + (this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3]);
+  }, o.prototype.readBigUInt64LE = k(function(r) {
+    r = r >>> 0, Y(r, "offset");
+    const t = this[r], n = this[r + 7];
+    (t === void 0 || n === void 0) && W(r, this.length - 8);
+    const i = t + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + this[++r] * 2 ** 24, u = this[++r] + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + n * 2 ** 24;
+    return BigInt(i) + (BigInt(u) << BigInt(32));
+  }), o.prototype.readBigUInt64BE = k(function(r) {
+    r = r >>> 0, Y(r, "offset");
+    const t = this[r], n = this[r + 7];
+    (t === void 0 || n === void 0) && W(r, this.length - 8);
+    const i = t * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + this[++r], u = this[++r] * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + n;
+    return (BigInt(i) << BigInt(32)) + BigInt(u);
+  }), o.prototype.readIntLE = function(r, t, n) {
+    r = r >>> 0, t = t >>> 0, n || F(r, t, this.length);
+    let i = this[r], u = 1, h = 0;
+    for (; ++h < t && (u *= 256); )
+      i += this[r + h] * u;
+    return u *= 128, i >= u && (i -= Math.pow(2, 8 * t)), i;
+  }, o.prototype.readIntBE = function(r, t, n) {
+    r = r >>> 0, t = t >>> 0, n || F(r, t, this.length);
+    let i = t, u = 1, h = this[r + --i];
+    for (; i > 0 && (u *= 256); )
+      h += this[r + --i] * u;
+    return u *= 128, h >= u && (h -= Math.pow(2, 8 * t)), h;
+  }, o.prototype.readInt8 = function(r, t) {
+    return r = r >>> 0, t || F(r, 1, this.length), this[r] & 128 ? (255 - this[r] + 1) * -1 : this[r];
+  }, o.prototype.readInt16LE = function(r, t) {
+    r = r >>> 0, t || F(r, 2, this.length);
+    const n = this[r] | this[r + 1] << 8;
+    return n & 32768 ? n | 4294901760 : n;
+  }, o.prototype.readInt16BE = function(r, t) {
+    r = r >>> 0, t || F(r, 2, this.length);
+    const n = this[r + 1] | this[r] << 8;
+    return n & 32768 ? n | 4294901760 : n;
+  }, o.prototype.readInt32LE = function(r, t) {
+    return r = r >>> 0, t || F(r, 4, this.length), this[r] | this[r + 1] << 8 | this[r + 2] << 16 | this[r + 3] << 24;
+  }, o.prototype.readInt32BE = function(r, t) {
+    return r = r >>> 0, t || F(r, 4, this.length), this[r] << 24 | this[r + 1] << 16 | this[r + 2] << 8 | this[r + 3];
+  }, o.prototype.readBigInt64LE = k(function(r) {
+    r = r >>> 0, Y(r, "offset");
+    const t = this[r], n = this[r + 7];
+    (t === void 0 || n === void 0) && W(r, this.length - 8);
+    const i = this[r + 4] + this[r + 5] * 2 ** 8 + this[r + 6] * 2 ** 16 + (n << 24);
+    return (BigInt(i) << BigInt(32)) + BigInt(t + this[++r] * 2 ** 8 + this[++r] * 2 ** 16 + this[++r] * 2 ** 24);
+  }), o.prototype.readBigInt64BE = k(function(r) {
+    r = r >>> 0, Y(r, "offset");
+    const t = this[r], n = this[r + 7];
+    (t === void 0 || n === void 0) && W(r, this.length - 8);
+    const i = (t << 24) + // Overflow
+    this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + this[++r];
+    return (BigInt(i) << BigInt(32)) + BigInt(this[++r] * 2 ** 24 + this[++r] * 2 ** 16 + this[++r] * 2 ** 8 + n);
+  }), o.prototype.readFloatLE = function(r, t) {
+    return r = r >>> 0, t || F(r, 4, this.length), l.read(this, r, !0, 23, 4);
+  }, o.prototype.readFloatBE = function(r, t) {
+    return r = r >>> 0, t || F(r, 4, this.length), l.read(this, r, !1, 23, 4);
+  }, o.prototype.readDoubleLE = function(r, t) {
+    return r = r >>> 0, t || F(r, 8, this.length), l.read(this, r, !0, 52, 8);
+  }, o.prototype.readDoubleBE = function(r, t) {
+    return r = r >>> 0, t || F(r, 8, this.length), l.read(this, r, !1, 52, 8);
+  };
+  function U(e, r, t, n, i, u) {
+    if (!o.isBuffer(e)) throw new TypeError('"buffer" argument must be a Buffer instance');
+    if (r > i || r < u) throw new RangeError('"value" argument is out of bounds');
+    if (t + n > e.length) throw new RangeError("Index out of range");
+  }
+  o.prototype.writeUintLE = o.prototype.writeUIntLE = function(r, t, n, i) {
+    if (r = +r, t = t >>> 0, n = n >>> 0, !i) {
+      const a = Math.pow(2, 8 * n) - 1;
+      U(this, r, t, n, a, 0);
+    }
+    let u = 1, h = 0;
+    for (this[t] = r & 255; ++h < n && (u *= 256); )
+      this[t + h] = r / u & 255;
+    return t + n;
+  }, o.prototype.writeUintBE = o.prototype.writeUIntBE = function(r, t, n, i) {
+    if (r = +r, t = t >>> 0, n = n >>> 0, !i) {
+      const a = Math.pow(2, 8 * n) - 1;
+      U(this, r, t, n, a, 0);
+    }
+    let u = n - 1, h = 1;
+    for (this[t + u] = r & 255; --u >= 0 && (h *= 256); )
+      this[t + u] = r / h & 255;
+    return t + n;
+  }, o.prototype.writeUint8 = o.prototype.writeUInt8 = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 1, 255, 0), this[t] = r & 255, t + 1;
+  }, o.prototype.writeUint16LE = o.prototype.writeUInt16LE = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 2, 65535, 0), this[t] = r & 255, this[t + 1] = r >>> 8, t + 2;
+  }, o.prototype.writeUint16BE = o.prototype.writeUInt16BE = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 2, 65535, 0), this[t] = r >>> 8, this[t + 1] = r & 255, t + 2;
+  }, o.prototype.writeUint32LE = o.prototype.writeUInt32LE = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 4, 4294967295, 0), this[t + 3] = r >>> 24, this[t + 2] = r >>> 16, this[t + 1] = r >>> 8, this[t] = r & 255, t + 4;
+  }, o.prototype.writeUint32BE = o.prototype.writeUInt32BE = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 4, 4294967295, 0), this[t] = r >>> 24, this[t + 1] = r >>> 16, this[t + 2] = r >>> 8, this[t + 3] = r & 255, t + 4;
+  };
+  function pr(e, r, t, n, i) {
+    xr(r, n, i, e, t, 7);
+    let u = Number(r & BigInt(4294967295));
+    e[t++] = u, u = u >> 8, e[t++] = u, u = u >> 8, e[t++] = u, u = u >> 8, e[t++] = u;
+    let h = Number(r >> BigInt(32) & BigInt(4294967295));
+    return e[t++] = h, h = h >> 8, e[t++] = h, h = h >> 8, e[t++] = h, h = h >> 8, e[t++] = h, t;
+  }
+  function sr(e, r, t, n, i) {
+    xr(r, n, i, e, t, 7);
+    let u = Number(r & BigInt(4294967295));
+    e[t + 7] = u, u = u >> 8, e[t + 6] = u, u = u >> 8, e[t + 5] = u, u = u >> 8, e[t + 4] = u;
+    let h = Number(r >> BigInt(32) & BigInt(4294967295));
+    return e[t + 3] = h, h = h >> 8, e[t + 2] = h, h = h >> 8, e[t + 1] = h, h = h >> 8, e[t] = h, t + 8;
+  }
+  o.prototype.writeBigUInt64LE = k(function(r, t = 0) {
+    return pr(this, r, t, BigInt(0), BigInt("0xffffffffffffffff"));
+  }), o.prototype.writeBigUInt64BE = k(function(r, t = 0) {
+    return sr(this, r, t, BigInt(0), BigInt("0xffffffffffffffff"));
+  }), o.prototype.writeIntLE = function(r, t, n, i) {
+    if (r = +r, t = t >>> 0, !i) {
+      const d = Math.pow(2, 8 * n - 1);
+      U(this, r, t, n, d - 1, -d);
+    }
+    let u = 0, h = 1, a = 0;
+    for (this[t] = r & 255; ++u < n && (h *= 256); )
+      r < 0 && a === 0 && this[t + u - 1] !== 0 && (a = 1), this[t + u] = (r / h >> 0) - a & 255;
+    return t + n;
+  }, o.prototype.writeIntBE = function(r, t, n, i) {
+    if (r = +r, t = t >>> 0, !i) {
+      const d = Math.pow(2, 8 * n - 1);
+      U(this, r, t, n, d - 1, -d);
+    }
+    let u = n - 1, h = 1, a = 0;
+    for (this[t + u] = r & 255; --u >= 0 && (h *= 256); )
+      r < 0 && a === 0 && this[t + u + 1] !== 0 && (a = 1), this[t + u] = (r / h >> 0) - a & 255;
+    return t + n;
+  }, o.prototype.writeInt8 = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 1, 127, -128), r < 0 && (r = 255 + r + 1), this[t] = r & 255, t + 1;
+  }, o.prototype.writeInt16LE = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 2, 32767, -32768), this[t] = r & 255, this[t + 1] = r >>> 8, t + 2;
+  }, o.prototype.writeInt16BE = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 2, 32767, -32768), this[t] = r >>> 8, this[t + 1] = r & 255, t + 2;
+  }, o.prototype.writeInt32LE = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 4, 2147483647, -2147483648), this[t] = r & 255, this[t + 1] = r >>> 8, this[t + 2] = r >>> 16, this[t + 3] = r >>> 24, t + 4;
+  }, o.prototype.writeInt32BE = function(r, t, n) {
+    return r = +r, t = t >>> 0, n || U(this, r, t, 4, 2147483647, -2147483648), r < 0 && (r = 4294967295 + r + 1), this[t] = r >>> 24, this[t + 1] = r >>> 16, this[t + 2] = r >>> 8, this[t + 3] = r & 255, t + 4;
+  }, o.prototype.writeBigInt64LE = k(function(r, t = 0) {
+    return pr(this, r, t, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  }), o.prototype.writeBigInt64BE = k(function(r, t = 0) {
+    return sr(this, r, t, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+  });
+  function lr(e, r, t, n, i, u) {
+    if (t + n > e.length) throw new RangeError("Index out of range");
+    if (t < 0) throw new RangeError("Index out of range");
+  }
+  function ar(e, r, t, n, i) {
+    return r = +r, t = t >>> 0, i || lr(e, r, t, 4), l.write(e, r, t, n, 23, 4), t + 4;
+  }
+  o.prototype.writeFloatLE = function(r, t, n) {
+    return ar(this, r, t, !0, n);
+  }, o.prototype.writeFloatBE = function(r, t, n) {
+    return ar(this, r, t, !1, n);
+  };
+  function wr(e, r, t, n, i) {
+    return r = +r, t = t >>> 0, i || lr(e, r, t, 8), l.write(e, r, t, n, 52, 8), t + 8;
+  }
+  o.prototype.writeDoubleLE = function(r, t, n) {
+    return wr(this, r, t, !0, n);
+  }, o.prototype.writeDoubleBE = function(r, t, n) {
+    return wr(this, r, t, !1, n);
+  }, o.prototype.copy = function(r, t, n, i) {
+    if (!o.isBuffer(r)) throw new TypeError("argument should be a Buffer");
+    if (n || (n = 0), !i && i !== 0 && (i = this.length), t >= r.length && (t = r.length), t || (t = 0), i > 0 && i < n && (i = n), i === n || r.length === 0 || this.length === 0) return 0;
+    if (t < 0)
+      throw new RangeError("targetStart out of bounds");
+    if (n < 0 || n >= this.length) throw new RangeError("Index out of range");
+    if (i < 0) throw new RangeError("sourceEnd out of bounds");
+    i > this.length && (i = this.length), r.length - t < i - n && (i = r.length - t + n);
+    const u = i - n;
+    return this === r && typeof p.prototype.copyWithin == "function" ? this.copyWithin(t, n, i) : p.prototype.set.call(
+      r,
+      this.subarray(n, i),
+      t
+    ), u;
+  }, o.prototype.fill = function(r, t, n, i) {
+    if (typeof r == "string") {
+      if (typeof t == "string" ? (i = t, t = 0, n = this.length) : typeof n == "string" && (i = n, n = this.length), i !== void 0 && typeof i != "string")
+        throw new TypeError("encoding must be a string");
+      if (typeof i == "string" && !o.isEncoding(i))
+        throw new TypeError("Unknown encoding: " + i);
+      if (r.length === 1) {
+        const h = r.charCodeAt(0);
+        (i === "utf8" && h < 128 || i === "latin1") && (r = h);
+      }
+    } else typeof r == "number" ? r = r & 255 : typeof r == "boolean" && (r = Number(r));
+    if (t < 0 || this.length < t || this.length < n)
+      throw new RangeError("Out of range index");
+    if (n <= t)
+      return this;
+    t = t >>> 0, n = n === void 0 ? this.length : n >>> 0, r || (r = 0);
+    let u;
+    if (typeof r == "number")
+      for (u = t; u < n; ++u)
+        this[u] = r;
+    else {
+      const h = o.isBuffer(r) ? r : o.from(r, i), a = h.length;
+      if (a === 0)
+        throw new TypeError('The value "' + r + '" is invalid for argument "value"');
+      for (u = 0; u < n - t; ++u)
+        this[u + t] = h[u % a];
+    }
+    return this;
+  };
+  const G = {};
+  function Z(e, r, t) {
+    G[e] = class extends t {
+      constructor() {
+        super(), Object.defineProperty(this, "message", {
+          value: r.apply(this, arguments),
+          writable: !0,
+          configurable: !0
+        }), this.name = `${this.name} [${e}]`, this.stack, delete this.name;
+      }
+      get code() {
+        return e;
+      }
+      set code(i) {
+        Object.defineProperty(this, "code", {
+          configurable: !0,
+          enumerable: !0,
+          value: i,
+          writable: !0
+        });
+      }
+      toString() {
+        return `${this.name} [${e}]: ${this.message}`;
+      }
+    };
+  }
+  Z(
+    "ERR_BUFFER_OUT_OF_BOUNDS",
+    function(e) {
+      return e ? `${e} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
+    },
+    RangeError
+  ), Z(
+    "ERR_INVALID_ARG_TYPE",
+    function(e, r) {
+      return `The "${e}" argument must be of type number. Received type ${typeof r}`;
+    },
+    TypeError
+  ), Z(
+    "ERR_OUT_OF_RANGE",
+    function(e, r, t) {
+      let n = `The value of "${e}" is out of range.`, i = t;
+      return Number.isInteger(t) && Math.abs(t) > 2 ** 32 ? i = yr(String(t)) : typeof t == "bigint" && (i = String(t), (t > BigInt(2) ** BigInt(32) || t < -(BigInt(2) ** BigInt(32))) && (i = yr(i)), i += "n"), n += ` It must be ${r}. Received ${i}`, n;
+    },
+    RangeError
+  );
+  function yr(e) {
+    let r = "", t = e.length;
+    const n = e[0] === "-" ? 1 : 0;
+    for (; t >= n + 4; t -= 3)
+      r = `_${e.slice(t - 3, t)}${r}`;
+    return `${e.slice(0, t)}${r}`;
+  }
+  function Or(e, r, t) {
+    Y(r, "offset"), (e[r] === void 0 || e[r + t] === void 0) && W(r, e.length - (t + 1));
+  }
+  function xr(e, r, t, n, i, u) {
+    if (e > t || e < r) {
+      const h = typeof r == "bigint" ? "n" : "";
+      let a;
+      throw r === 0 || r === BigInt(0) ? a = `>= 0${h} and < 2${h} ** ${(u + 1) * 8}${h}` : a = `>= -(2${h} ** ${(u + 1) * 8 - 1}${h}) and < 2 ** ${(u + 1) * 8 - 1}${h}`, new G.ERR_OUT_OF_RANGE("value", a, e);
+    }
+    Or(n, i, u);
+  }
+  function Y(e, r) {
+    if (typeof e != "number")
+      throw new G.ERR_INVALID_ARG_TYPE(r, "number", e);
+  }
+  function W(e, r, t) {
+    throw Math.floor(e) !== e ? (Y(e, t), new G.ERR_OUT_OF_RANGE("offset", "an integer", e)) : r < 0 ? new G.ERR_BUFFER_OUT_OF_BOUNDS() : new G.ERR_OUT_OF_RANGE(
+      "offset",
+      `>= 0 and <= ${r}`,
+      e
+    );
+  }
+  const Gr = /[^+/0-9A-Za-z-_]/g;
+  function Yr(e) {
+    if (e = e.split("=")[0], e = e.trim().replace(Gr, ""), e.length < 2) return "";
+    for (; e.length % 4 !== 0; )
+      e = e + "=";
+    return e;
+  }
+  function v(e, r) {
+    r = r || 1 / 0;
+    let t;
+    const n = e.length;
+    let i = null;
+    const u = [];
+    for (let h = 0; h < n; ++h) {
+      if (t = e.charCodeAt(h), t > 55295 && t < 57344) {
+        if (!i) {
+          if (t > 56319) {
+            (r -= 3) > -1 && u.push(239, 191, 189);
+            continue;
+          } else if (h + 1 === n) {
+            (r -= 3) > -1 && u.push(239, 191, 189);
+            continue;
+          }
+          i = t;
+          continue;
+        }
+        if (t < 56320) {
+          (r -= 3) > -1 && u.push(239, 191, 189), i = t;
+          continue;
+        }
+        t = (i - 55296 << 10 | t - 56320) + 65536;
+      } else i && (r -= 3) > -1 && u.push(239, 191, 189);
+      if (i = null, t < 128) {
+        if ((r -= 1) < 0) break;
+        u.push(t);
+      } else if (t < 2048) {
+        if ((r -= 2) < 0) break;
+        u.push(
+          t >> 6 | 192,
+          t & 63 | 128
+        );
+      } else if (t < 65536) {
+        if ((r -= 3) < 0) break;
+        u.push(
+          t >> 12 | 224,
+          t >> 6 & 63 | 128,
+          t & 63 | 128
+        );
+      } else if (t < 1114112) {
+        if ((r -= 4) < 0) break;
+        u.push(
+          t >> 18 | 240,
+          t >> 12 & 63 | 128,
+          t >> 6 & 63 | 128,
+          t & 63 | 128
+        );
+      } else
+        throw new Error("Invalid code point");
+    }
+    return u;
+  }
+  function jr(e) {
+    const r = [];
+    for (let t = 0; t < e.length; ++t)
+      r.push(e.charCodeAt(t) & 255);
+    return r;
+  }
+  function qr(e, r) {
+    let t, n, i;
+    const u = [];
+    for (let h = 0; h < e.length && !((r -= 2) < 0); ++h)
+      t = e.charCodeAt(h), n = t >> 8, i = t % 256, u.push(i), u.push(n);
+    return u;
+  }
+  function Br(e) {
+    return f.toByteArray(Yr(e));
+  }
+  function H(e, r, t, n) {
+    let i;
+    for (i = 0; i < n && !(i + t >= r.length || i >= e.length); ++i)
+      r[i + t] = e[i];
+    return i;
+  }
+  function _(e, r) {
+    return e instanceof r || e != null && e.constructor != null && e.constructor.name != null && e.constructor.name === r.name;
+  }
+  function rr(e) {
+    return e !== e;
+  }
+  const Wr = function() {
+    const e = "0123456789abcdef", r = new Array(256);
+    for (let t = 0; t < 16; ++t) {
+      const n = t * 16;
+      for (let i = 0; i < 16; ++i)
+        r[n + i] = e[t] + e[i];
+    }
+    return r;
+  }();
+  function k(e) {
+    return typeof BigInt > "u" ? Hr : e;
+  }
+  function Hr() {
+    throw new Error("BigInt not supported");
+  }
+})(Ir);
+const ht = Ir.Buffer;
+export {
+  ht as B,
+  it as g,
+  ot as p
+};