@harbour-enterprises/superdoc 0.9.34 → 0.9.36

package/dist/chunks/index-XHRxRUhd.es.js

@@ -0,0 +1,1676 @@
+import { c as U, B as V, a as gt, g as wt } from "./jszip-DSGi1sNe.es.js";
+import { p as q } from "./vue-BDbTsTMu.es.js";
+import { e as rt, r as De, u as nt, i as Y, b as Rt, a as Be } from "./xml-js-Bzw8Bo_u.es.js";
+import { u as mt } from "./url-BWFemt_V.es.js";
+function Et(e, r) {
+  for (var a = 0; a < r.length; a++) {
+    const l = r[a];
+    if (typeof l != "string" && !Array.isArray(l)) {
+      for (const f in l)
+        if (f !== "default" && !(f in e)) {
+          const _ = Object.getOwnPropertyDescriptor(l, f);
+          _ && Object.defineProperty(e, f, _.get ? _ : {
+            enumerable: !0,
+            get: () => l[f]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var qe = {}, it = { exports: {} }, Ie = {};
+(function(e) {
+  e.fetch = f(U.fetch) && f(U.ReadableStream), e.writableStream = f(U.WritableStream), e.abortController = f(U.AbortController);
+  var r;
+  function a() {
+    if (r !== void 0) return r;
+    if (U.XMLHttpRequest) {
+      r = new U.XMLHttpRequest();
+      try {
+        r.open("GET", U.XDomainRequest ? "/" : "https://example.com");
+      } catch {
+        r = null;
+      }
+    } else
+      r = null;
+    return r;
+  }
+  function l(_) {
+    var h = a();
+    if (!h) return !1;
+    try {
+      return h.responseType = _, h.responseType === _;
+    } catch {
+    }
+    return !1;
+  }
+  e.arraybuffer = e.fetch || l("arraybuffer"), e.msstream = !e.fetch && l("ms-stream"), e.mozchunkedarraybuffer = !e.fetch && l("moz-chunked-arraybuffer"), e.overrideMimeType = e.fetch || (a() ? f(a().overrideMimeType) : !1);
+  function f(_) {
+    return typeof _ == "function";
+  }
+  r = null;
+})(Ie);
+var ce = {}, Ce = { exports: {} }, at = rt.EventEmitter, Se, We;
+function St() {
+  if (We) return Se;
+  We = 1;
+  function e(w, E) {
+    var y = Object.keys(w);
+    if (Object.getOwnPropertySymbols) {
+      var v = Object.getOwnPropertySymbols(w);
+      E && (v = v.filter(function(A) {
+        return Object.getOwnPropertyDescriptor(w, A).enumerable;
+      })), y.push.apply(y, v);
+    }
+    return y;
+  }
+  function r(w) {
+    for (var E = 1; E < arguments.length; E++) {
+      var y = arguments[E] != null ? arguments[E] : {};
+      E % 2 ? e(Object(y), !0).forEach(function(v) {
+        a(w, v, y[v]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(w, Object.getOwnPropertyDescriptors(y)) : e(Object(y)).forEach(function(v) {
+        Object.defineProperty(w, v, Object.getOwnPropertyDescriptor(y, v));
+      });
+    }
+    return w;
+  }
+  function a(w, E, y) {
+    return E = h(E), E in w ? Object.defineProperty(w, E, { value: y, enumerable: !0, configurable: !0, writable: !0 }) : w[E] = y, w;
+  }
+  function l(w, E) {
+    if (!(w instanceof E))
+      throw new TypeError("Cannot call a class as a function");
+  }
+  function f(w, E) {
+    for (var y = 0; y < E.length; y++) {
+      var v = E[y];
+      v.enumerable = v.enumerable || !1, v.configurable = !0, "value" in v && (v.writable = !0), Object.defineProperty(w, h(v.key), v);
+    }
+  }
+  function _(w, E, y) {
+    return E && f(w.prototype, E), Object.defineProperty(w, "prototype", { writable: !1 }), w;
+  }
+  function h(w) {
+    var E = c(w, "string");
+    return typeof E == "symbol" ? E : String(E);
+  }
+  function c(w, E) {
+    if (typeof w != "object" || w === null) return w;
+    var y = w[Symbol.toPrimitive];
+    if (y !== void 0) {
+      var v = y.call(w, E);
+      if (typeof v != "object") return v;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return String(w);
+  }
+  var d = De, R = d.Buffer, P = nt, b = P.inspect, C = b && b.custom || "inspect";
+  function j(w, E, y) {
+    R.prototype.copy.call(w, E, y);
+  }
+  return Se = /* @__PURE__ */ function() {
+    function w() {
+      l(this, w), this.head = null, this.tail = null, this.length = 0;
+    }
+    return _(w, [{
+      key: "push",
+      value: function(y) {
+        var v = {
+          data: y,
+          next: null
+        };
+        this.length > 0 ? this.tail.next = v : this.head = v, this.tail = v, ++this.length;
+      }
+    }, {
+      key: "unshift",
+      value: function(y) {
+        var v = {
+          data: y,
+          next: this.head
+        };
+        this.length === 0 && (this.tail = v), this.head = v, ++this.length;
+      }
+    }, {
+      key: "shift",
+      value: function() {
+        if (this.length !== 0) {
+          var y = this.head.data;
+          return this.length === 1 ? this.head = this.tail = null : this.head = this.head.next, --this.length, y;
+        }
+      }
+    }, {
+      key: "clear",
+      value: function() {
+        this.head = this.tail = null, this.length = 0;
+      }
+    }, {
+      key: "join",
+      value: function(y) {
+        if (this.length === 0) return "";
+        for (var v = this.head, A = "" + v.data; v = v.next; ) A += y + v.data;
+        return A;
+      }
+    }, {
+      key: "concat",
+      value: function(y) {
+        if (this.length === 0) return R.alloc(0);
+        for (var v = R.allocUnsafe(y >>> 0), A = this.head, S = 0; A; )
+          j(A.data, v, S), S += A.data.length, A = A.next;
+        return v;
+      }
+      // Consumes a specified amount of bytes or characters from the buffered data.
+    }, {
+      key: "consume",
+      value: function(y, v) {
+        var A;
+        return y < this.head.data.length ? (A = this.head.data.slice(0, y), this.head.data = this.head.data.slice(y)) : y === this.head.data.length ? A = this.shift() : A = v ? this._getString(y) : this._getBuffer(y), A;
+      }
+    }, {
+      key: "first",
+      value: function() {
+        return this.head.data;
+      }
+      // Consumes a specified amount of characters from the buffered data.
+    }, {
+      key: "_getString",
+      value: function(y) {
+        var v = this.head, A = 1, S = v.data;
+        for (y -= S.length; v = v.next; ) {
+          var g = v.data, T = y > g.length ? g.length : y;
+          if (T === g.length ? S += g : S += g.slice(0, y), y -= T, y === 0) {
+            T === g.length ? (++A, v.next ? this.head = v.next : this.head = this.tail = null) : (this.head = v, v.data = g.slice(T));
+            break;
+          }
+          ++A;
+        }
+        return this.length -= A, S;
+      }
+      // Consumes a specified amount of bytes from the buffered data.
+    }, {
+      key: "_getBuffer",
+      value: function(y) {
+        var v = R.allocUnsafe(y), A = this.head, S = 1;
+        for (A.data.copy(v), y -= A.data.length; A = A.next; ) {
+          var g = A.data, T = y > g.length ? g.length : y;
+          if (g.copy(v, v.length - y, 0, T), y -= T, y === 0) {
+            T === g.length ? (++S, A.next ? this.head = A.next : this.head = this.tail = null) : (this.head = A, A.data = g.slice(T));
+            break;
+          }
+          ++S;
+        }
+        return this.length -= S, v;
+      }
+      // Make sure the linked list only shows the minimal necessary information.
+    }, {
+      key: C,
+      value: function(y, v) {
+        return b(this, r(r({}, v), {}, {
+          // Only inspect one level.
+          depth: 0,
+          // It should not recurse.
+          customInspect: !1
+        }));
+      }
+    }]), w;
+  }(), Se;
+}
+function Tt(e, r) {
+  var a = this, l = this._readableState && this._readableState.destroyed, f = this._writableState && this._writableState.destroyed;
+  return l || f ? (r ? r(e) : e && (this._writableState ? this._writableState.errorEmitted || (this._writableState.errorEmitted = !0, q.nextTick(Ne, this, e)) : q.nextTick(Ne, this, e)), this) : (this._readableState && (this._readableState.destroyed = !0), this._writableState && (this._writableState.destroyed = !0), this._destroy(e || null, function(_) {
+    !r && _ ? a._writableState ? a._writableState.errorEmitted ? q.nextTick(de, a) : (a._writableState.errorEmitted = !0, q.nextTick(Fe, a, _)) : q.nextTick(Fe, a, _) : r ? (q.nextTick(de, a), r(_)) : q.nextTick(de, a);
+  }), this);
+}
+function Fe(e, r) {
+  Ne(e, r), de(e);
+}
+function de(e) {
+  e._writableState && !e._writableState.emitClose || e._readableState && !e._readableState.emitClose || e.emit("close");
+}
+function Mt() {
+  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 Ne(e, r) {
+  e.emit("error", r);
+}
+function At(e, r) {
+  var a = e._readableState, l = e._writableState;
+  a && a.autoDestroy || l && l.autoDestroy ? e.destroy(r) : e.emit("error", r);
+}
+var ot = {
+  destroy: Tt,
+  undestroy: Mt,
+  errorOrDestroy: At
+}, X = {};
+function Ot(e, r) {
+  e.prototype = Object.create(r.prototype), e.prototype.constructor = e, e.__proto__ = r;
+}
+var ft = {};
+function B(e, r, a) {
+  a || (a = Error);
+  function l(_, h, c) {
+    return typeof r == "string" ? r : r(_, h, c);
+  }
+  var f = /* @__PURE__ */ function(_) {
+    Ot(h, _);
+    function h(c, d, R) {
+      return _.call(this, l(c, d, R)) || this;
+    }
+    return h;
+  }(a);
+  f.prototype.name = a.name, f.prototype.code = e, ft[e] = f;
+}
+function Ge(e, r) {
+  if (Array.isArray(e)) {
+    var a = e.length;
+    return e = e.map(function(l) {
+      return String(l);
+    }), a > 2 ? "one of ".concat(r, " ").concat(e.slice(0, a - 1).join(", "), ", or ") + e[a - 1] : a === 2 ? "one of ".concat(r, " ").concat(e[0], " or ").concat(e[1]) : "of ".concat(r, " ").concat(e[0]);
+  } else
+    return "of ".concat(r, " ").concat(String(e));
+}
+function Pt(e, r, a) {
+  return e.substr(0, r.length) === r;
+}
+function Lt(e, r, a) {
+  return (a === void 0 || a > e.length) && (a = e.length), e.substring(a - r.length, a) === r;
+}
+function Ct(e, r, a) {
+  return typeof a != "number" && (a = 0), a + r.length > e.length ? !1 : e.indexOf(r, a) !== -1;
+}
+B("ERR_INVALID_OPT_VALUE", function(e, r) {
+  return 'The value "' + r + '" is invalid for option "' + e + '"';
+}, TypeError);
+B("ERR_INVALID_ARG_TYPE", function(e, r, a) {
+  var l;
+  typeof r == "string" && Pt(r, "not ") ? (l = "must not be", r = r.replace(/^not /, "")) : l = "must be";
+  var f;
+  if (Lt(e, " argument"))
+    f = "The ".concat(e, " ").concat(l, " ").concat(Ge(r, "type"));
+  else {
+    var _ = Ct(e, ".") ? "property" : "argument";
+    f = 'The "'.concat(e, '" ').concat(_, " ").concat(l, " ").concat(Ge(r, "type"));
+  }
+  return f += ". Received type ".concat(typeof a), f;
+}, TypeError);
+B("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
+B("ERR_METHOD_NOT_IMPLEMENTED", function(e) {
+  return "The " + e + " method is not implemented";
+});
+B("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
+B("ERR_STREAM_DESTROYED", function(e) {
+  return "Cannot call " + e + " after a stream was destroyed";
+});
+B("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
+B("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
+B("ERR_STREAM_WRITE_AFTER_END", "write after end");
+B("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
+B("ERR_UNKNOWN_ENCODING", function(e) {
+  return "Unknown encoding: " + e;
+}, TypeError);
+B("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
+X.codes = ft;
+var Nt = X.codes.ERR_INVALID_OPT_VALUE;
+function Dt(e, r, a) {
+  return e.highWaterMark != null ? e.highWaterMark : r ? e[a] : null;
+}
+function qt(e, r, a, l) {
+  var f = Dt(r, l, a);
+  if (f != null) {
+    if (!(isFinite(f) && Math.floor(f) === f) || f < 0) {
+      var _ = l ? a : "highWaterMark";
+      throw new Nt(_, f);
+    }
+    return Math.floor(f);
+  }
+  return e.objectMode ? 16 : 16 * 1024;
+}
+var lt = {
+  getHighWaterMark: qt
+}, Te, $e;
+function ut() {
+  if ($e) return Te;
+  $e = 1, Te = D;
+  function e(o) {
+    var i = this;
+    this.next = null, this.entry = null, this.finish = function() {
+      we(i, o);
+    };
+  }
+  var r;
+  D.WritableState = O;
+  var a = {
+    deprecate: Rt
+  }, l = at, f = De.Buffer, _ = (typeof U < "u" ? U : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function h(o) {
+    return f.from(o);
+  }
+  function c(o) {
+    return f.isBuffer(o) || o instanceof _;
+  }
+  var d = ot, R = lt, P = R.getHighWaterMark, b = X.codes, C = b.ERR_INVALID_ARG_TYPE, j = b.ERR_METHOD_NOT_IMPLEMENTED, w = b.ERR_MULTIPLE_CALLBACK, E = b.ERR_STREAM_CANNOT_PIPE, y = b.ERR_STREAM_DESTROYED, v = b.ERR_STREAM_NULL_VALUES, A = b.ERR_STREAM_WRITE_AFTER_END, S = b.ERR_UNKNOWN_ENCODING, g = d.errorOrDestroy;
+  Y(D, l);
+  function T() {
+  }
+  function O(o, i, s) {
+    r = r || te(), o = o || {}, typeof s != "boolean" && (s = i instanceof r), this.objectMode = !!o.objectMode, s && (this.objectMode = this.objectMode || !!o.writableObjectMode), this.highWaterMark = P(this, o, "writableHighWaterMark", s), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1;
+    var m = o.decodeStrings === !1;
+    this.decodeStrings = !m, this.defaultEncoding = o.defaultEncoding || "utf8", this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function(N) {
+      ye(i, N);
+    }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.emitClose = o.emitClose !== !1, this.autoDestroy = !!o.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new e(this);
+  }
+  O.prototype.getBuffer = function() {
+    for (var i = this.bufferedRequest, s = []; i; )
+      s.push(i), i = i.next;
+    return s;
+  }, function() {
+    try {
+      Object.defineProperty(O.prototype, "buffer", {
+        get: a.deprecate(function() {
+          return this.getBuffer();
+        }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+      });
+    } catch {
+    }
+  }();
+  var H;
+  typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (H = Function.prototype[Symbol.hasInstance], Object.defineProperty(D, Symbol.hasInstance, {
+    value: function(i) {
+      return H.call(this, i) ? !0 : this !== D ? !1 : i && i._writableState instanceof O;
+    }
+  })) : H = function(i) {
+    return i instanceof this;
+  };
+  function D(o) {
+    r = r || te();
+    var i = this instanceof r;
+    if (!i && !H.call(D, this)) return new D(o);
+    this._writableState = new O(o, this, i), this.writable = !0, o && (typeof o.write == "function" && (this._write = o.write), typeof o.writev == "function" && (this._writev = o.writev), typeof o.destroy == "function" && (this._destroy = o.destroy), typeof o.final == "function" && (this._final = o.final)), l.call(this);
+  }
+  D.prototype.pipe = function() {
+    g(this, new E());
+  };
+  function M(o, i) {
+    var s = new A();
+    g(o, s), q.nextTick(i, s);
+  }
+  function W(o, i, s, m) {
+    var N;
+    return s === null ? N = new v() : typeof s != "string" && !i.objectMode && (N = new C("chunk", ["string", "Buffer"], s)), N ? (g(o, N), q.nextTick(m, N), !1) : !0;
+  }
+  D.prototype.write = function(o, i, s) {
+    var m = this._writableState, N = !1, t = !m.objectMode && c(o);
+    return t && !f.isBuffer(o) && (o = h(o)), typeof i == "function" && (s = i, i = null), t ? i = "buffer" : i || (i = m.defaultEncoding), typeof s != "function" && (s = T), m.ending ? M(this, s) : (t || W(this, m, o, s)) && (m.pendingcb++, N = _e(this, m, t, o, i, s)), N;
+  }, D.prototype.cork = function() {
+    this._writableState.corked++;
+  }, D.prototype.uncork = function() {
+    var o = this._writableState;
+    o.corked && (o.corked--, !o.writing && !o.corked && !o.bufferProcessing && o.bufferedRequest && J(this, o));
+  }, D.prototype.setDefaultEncoding = function(i) {
+    if (typeof i == "string" && (i = i.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((i + "").toLowerCase()) > -1)) throw new S(i);
+    return this._writableState.defaultEncoding = i, this;
+  }, Object.defineProperty(D.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 re(o, i, s) {
+    return !o.objectMode && o.decodeStrings !== !1 && typeof i == "string" && (i = f.from(i, s)), i;
+  }
+  Object.defineProperty(D.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 _e(o, i, s, m, N, t) {
+    if (!s) {
+      var n = re(i, m, N);
+      m !== n && (s = !0, N = "buffer", m = n);
+    }
+    var u = i.objectMode ? 1 : m.length;
+    i.length += u;
+    var p = i.length < i.highWaterMark;
+    if (p || (i.needDrain = !0), i.writing || i.corked) {
+      var k = i.lastBufferedRequest;
+      i.lastBufferedRequest = {
+        chunk: m,
+        encoding: N,
+        isBuf: s,
+        callback: t,
+        next: null
+      }, k ? k.next = i.lastBufferedRequest : i.bufferedRequest = i.lastBufferedRequest, i.bufferedRequestCount += 1;
+    } else
+      z(o, i, !1, u, m, N, t);
+    return p;
+  }
+  function z(o, i, s, m, N, t, n) {
+    i.writelen = m, i.writecb = n, i.writing = !0, i.sync = !0, i.destroyed ? i.onwrite(new y("write")) : s ? o._writev(N, i.onwrite) : o._write(N, t, i.onwrite), i.sync = !1;
+  }
+  function be(o, i, s, m, N) {
+    --i.pendingcb, s ? (q.nextTick(N, m), q.nextTick($, o, i), o._writableState.errorEmitted = !0, g(o, m)) : (N(m), o._writableState.errorEmitted = !0, g(o, m), $(o, i));
+  }
+  function ae(o) {
+    o.writing = !1, o.writecb = null, o.length -= o.writelen, o.writelen = 0;
+  }
+  function ye(o, i) {
+    var s = o._writableState, m = s.sync, N = s.writecb;
+    if (typeof N != "function") throw new w();
+    if (ae(s), i) be(o, s, m, i, N);
+    else {
+      var t = fe(s) || o.destroyed;
+      !t && !s.corked && !s.bufferProcessing && s.bufferedRequest && J(o, s), m ? q.nextTick(G, o, s, t, N) : G(o, s, t, N);
+    }
+  }
+  function G(o, i, s, m) {
+    s || oe(o, i), i.pendingcb--, m(), $(o, i);
+  }
+  function oe(o, i) {
+    i.length === 0 && i.needDrain && (i.needDrain = !1, o.emit("drain"));
+  }
+  function J(o, i) {
+    i.bufferProcessing = !0;
+    var s = i.bufferedRequest;
+    if (o._writev && s && s.next) {
+      var m = i.bufferedRequestCount, N = new Array(m), t = i.corkedRequestsFree;
+      t.entry = s;
+      for (var n = 0, u = !0; s; )
+        N[n] = s, s.isBuf || (u = !1), s = s.next, n += 1;
+      N.allBuffers = u, z(o, i, !0, i.length, N, "", t.finish), i.pendingcb++, i.lastBufferedRequest = null, t.next ? (i.corkedRequestsFree = t.next, t.next = null) : i.corkedRequestsFree = new e(i), i.bufferedRequestCount = 0;
+    } else {
+      for (; s; ) {
+        var p = s.chunk, k = s.encoding, L = s.callback, I = i.objectMode ? 1 : p.length;
+        if (z(o, i, !1, I, p, k, L), s = s.next, i.bufferedRequestCount--, i.writing)
+          break;
+      }
+      s === null && (i.lastBufferedRequest = null);
+    }
+    i.bufferedRequest = s, i.bufferProcessing = !1;
+  }
+  D.prototype._write = function(o, i, s) {
+    s(new j("_write()"));
+  }, D.prototype._writev = null, D.prototype.end = function(o, i, s) {
+    var m = this._writableState;
+    return typeof o == "function" ? (s = o, o = null, i = null) : typeof i == "function" && (s = i, i = null), o != null && this.write(o, i), m.corked && (m.corked = 1, this.uncork()), m.ending || ge(this, m, s), this;
+  }, Object.defineProperty(D.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 fe(o) {
+    return o.ending && o.length === 0 && o.bufferedRequest === null && !o.finished && !o.writing;
+  }
+  function ve(o, i) {
+    o._final(function(s) {
+      i.pendingcb--, s && g(o, s), i.prefinished = !0, o.emit("prefinish"), $(o, i);
+    });
+  }
+  function le(o, i) {
+    !i.prefinished && !i.finalCalled && (typeof o._final == "function" && !i.destroyed ? (i.pendingcb++, i.finalCalled = !0, q.nextTick(ve, o, i)) : (i.prefinished = !0, o.emit("prefinish")));
+  }
+  function $(o, i) {
+    var s = fe(i);
+    if (s && (le(o, i), i.pendingcb === 0 && (i.finished = !0, o.emit("finish"), i.autoDestroy))) {
+      var m = o._readableState;
+      (!m || m.autoDestroy && m.endEmitted) && o.destroy();
+    }
+    return s;
+  }
+  function ge(o, i, s) {
+    i.ending = !0, $(o, i), s && (i.finished ? q.nextTick(s) : o.once("finish", s)), i.ended = !0, o.writable = !1;
+  }
+  function we(o, i, s) {
+    var m = o.entry;
+    for (o.entry = null; m; ) {
+      var N = m.callback;
+      i.pendingcb--, N(s), m = m.next;
+    }
+    i.corkedRequestsFree.next = o;
+  }
+  return Object.defineProperty(D.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(i) {
+      this._writableState && (this._writableState.destroyed = i);
+    }
+  }), D.prototype.destroy = d.destroy, D.prototype._undestroy = d.undestroy, D.prototype._destroy = function(o, i) {
+    i(o);
+  }, Te;
+}
+var Me, Ve;
+function te() {
+  if (Ve) return Me;
+  Ve = 1;
+  var e = Object.keys || function(R) {
+    var P = [];
+    for (var b in R) P.push(b);
+    return P;
+  };
+  Me = h;
+  var r = dt(), a = ut();
+  Y(h, r);
+  for (var l = e(a.prototype), f = 0; f < l.length; f++) {
+    var _ = l[f];
+    h.prototype[_] || (h.prototype[_] = a.prototype[_]);
+  }
+  function h(R) {
+    if (!(this instanceof h)) return new h(R);
+    r.call(this, R), a.call(this, R), this.allowHalfOpen = !0, R && (R.readable === !1 && (this.readable = !1), R.writable === !1 && (this.writable = !1), R.allowHalfOpen === !1 && (this.allowHalfOpen = !1, this.once("end", c)));
+  }
+  Object.defineProperty(h.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(h.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(h.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 c() {
+    this._writableState.ended || q.nextTick(d, this);
+  }
+  function d(R) {
+    R.end();
+  }
+  return Object.defineProperty(h.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(P) {
+      this._readableState === void 0 || this._writableState === void 0 || (this._readableState.destroyed = P, this._writableState.destroyed = P);
+    }
+  }), Me;
+}
+var Ke = X.codes.ERR_STREAM_PREMATURE_CLOSE;
+function It(e) {
+  var r = !1;
+  return function() {
+    if (!r) {
+      r = !0;
+      for (var a = arguments.length, l = new Array(a), f = 0; f < a; f++)
+        l[f] = arguments[f];
+      e.apply(this, l);
+    }
+  };
+}
+function kt() {
+}
+function jt(e) {
+  return e.setHeader && typeof e.abort == "function";
+}
+function st(e, r, a) {
+  if (typeof r == "function") return st(e, null, r);
+  r || (r = {}), a = It(a || kt);
+  var l = r.readable || r.readable !== !1 && e.readable, f = r.writable || r.writable !== !1 && e.writable, _ = function() {
+    e.writable || c();
+  }, h = e._writableState && e._writableState.finished, c = function() {
+    f = !1, h = !0, l || a.call(e);
+  }, d = e._readableState && e._readableState.endEmitted, R = function() {
+    l = !1, d = !0, f || a.call(e);
+  }, P = function(w) {
+    a.call(e, w);
+  }, b = function() {
+    var w;
+    if (l && !d)
+      return (!e._readableState || !e._readableState.ended) && (w = new Ke()), a.call(e, w);
+    if (f && !h)
+      return (!e._writableState || !e._writableState.ended) && (w = new Ke()), a.call(e, w);
+  }, C = function() {
+    e.req.on("finish", c);
+  };
+  return jt(e) ? (e.on("complete", c), e.on("abort", b), e.req ? C() : e.on("request", C)) : f && !e._writableState && (e.on("end", _), e.on("close", _)), e.on("end", R), e.on("finish", c), r.error !== !1 && e.on("error", P), e.on("close", b), function() {
+    e.removeListener("complete", c), e.removeListener("abort", b), e.removeListener("request", C), e.req && e.req.removeListener("finish", c), e.removeListener("end", _), e.removeListener("close", _), e.removeListener("finish", c), e.removeListener("end", R), e.removeListener("error", P), e.removeListener("close", b);
+  };
+}
+var ke = st, Ae, Ye;
+function Ht() {
+  if (Ye) return Ae;
+  Ye = 1;
+  var e;
+  function r(S, g, T) {
+    return g = a(g), g in S ? Object.defineProperty(S, g, { value: T, enumerable: !0, configurable: !0, writable: !0 }) : S[g] = T, S;
+  }
+  function a(S) {
+    var g = l(S, "string");
+    return typeof g == "symbol" ? g : String(g);
+  }
+  function l(S, g) {
+    if (typeof S != "object" || S === null) return S;
+    var T = S[Symbol.toPrimitive];
+    if (T !== void 0) {
+      var O = T.call(S, g);
+      if (typeof O != "object") return O;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (g === "string" ? String : Number)(S);
+  }
+  var f = ke, _ = Symbol("lastResolve"), h = Symbol("lastReject"), c = Symbol("error"), d = Symbol("ended"), R = Symbol("lastPromise"), P = Symbol("handlePromise"), b = Symbol("stream");
+  function C(S, g) {
+    return {
+      value: S,
+      done: g
+    };
+  }
+  function j(S) {
+    var g = S[_];
+    if (g !== null) {
+      var T = S[b].read();
+      T !== null && (S[R] = null, S[_] = null, S[h] = null, g(C(T, !1)));
+    }
+  }
+  function w(S) {
+    q.nextTick(j, S);
+  }
+  function E(S, g) {
+    return function(T, O) {
+      S.then(function() {
+        if (g[d]) {
+          T(C(void 0, !0));
+          return;
+        }
+        g[P](T, O);
+      }, O);
+    };
+  }
+  var y = Object.getPrototypeOf(function() {
+  }), v = Object.setPrototypeOf((e = {
+    get stream() {
+      return this[b];
+    },
+    next: function() {
+      var g = this, T = this[c];
+      if (T !== null)
+        return Promise.reject(T);
+      if (this[d])
+        return Promise.resolve(C(void 0, !0));
+      if (this[b].destroyed)
+        return new Promise(function(M, W) {
+          q.nextTick(function() {
+            g[c] ? W(g[c]) : M(C(void 0, !0));
+          });
+        });
+      var O = this[R], H;
+      if (O)
+        H = new Promise(E(O, this));
+      else {
+        var D = this[b].read();
+        if (D !== null)
+          return Promise.resolve(C(D, !1));
+        H = new Promise(this[P]);
+      }
+      return this[R] = H, H;
+    }
+  }, r(e, Symbol.asyncIterator, function() {
+    return this;
+  }), r(e, "return", function() {
+    var g = this;
+    return new Promise(function(T, O) {
+      g[b].destroy(null, function(H) {
+        if (H) {
+          O(H);
+          return;
+        }
+        T(C(void 0, !0));
+      });
+    });
+  }), e), y), A = function(g) {
+    var T, O = Object.create(v, (T = {}, r(T, b, {
+      value: g,
+      writable: !0
+    }), r(T, _, {
+      value: null,
+      writable: !0
+    }), r(T, h, {
+      value: null,
+      writable: !0
+    }), r(T, c, {
+      value: null,
+      writable: !0
+    }), r(T, d, {
+      value: g._readableState.endEmitted,
+      writable: !0
+    }), r(T, P, {
+      value: function(D, M) {
+        var W = O[b].read();
+        W ? (O[R] = null, O[_] = null, O[h] = null, D(C(W, !1))) : (O[_] = D, O[h] = M);
+      },
+      writable: !0
+    }), T));
+    return O[R] = null, f(g, function(H) {
+      if (H && H.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+        var D = O[h];
+        D !== null && (O[R] = null, O[_] = null, O[h] = null, D(H)), O[c] = H;
+        return;
+      }
+      var M = O[_];
+      M !== null && (O[R] = null, O[_] = null, O[h] = null, M(C(void 0, !0))), O[d] = !0;
+    }), g.on("readable", w.bind(null, O)), O;
+  };
+  return Ae = A, Ae;
+}
+var Oe, Xe;
+function Ut() {
+  return Xe || (Xe = 1, Oe = function() {
+    throw new Error("Readable.from is not available in the browser");
+  }), Oe;
+}
+var Pe, ze;
+function dt() {
+  if (ze) return Pe;
+  ze = 1, Pe = M;
+  var e;
+  M.ReadableState = D, rt.EventEmitter;
+  var r = function(n, u) {
+    return n.listeners(u).length;
+  }, a = at, l = De.Buffer, f = (typeof U < "u" ? U : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function _(t) {
+    return l.from(t);
+  }
+  function h(t) {
+    return l.isBuffer(t) || t instanceof f;
+  }
+  var c = nt, d;
+  c && c.debuglog ? d = c.debuglog("stream") : d = function() {
+  };
+  var R = St(), P = ot, b = lt, C = b.getHighWaterMark, j = X.codes, w = j.ERR_INVALID_ARG_TYPE, E = j.ERR_STREAM_PUSH_AFTER_EOF, y = j.ERR_METHOD_NOT_IMPLEMENTED, v = j.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, A, S, g;
+  Y(M, a);
+  var T = P.errorOrDestroy, O = ["error", "close", "destroy", "pause", "resume"];
+  function H(t, n, u) {
+    if (typeof t.prependListener == "function") return t.prependListener(n, u);
+    !t._events || !t._events[n] ? t.on(n, u) : Array.isArray(t._events[n]) ? t._events[n].unshift(u) : t._events[n] = [u, t._events[n]];
+  }
+  function D(t, n, u) {
+    e = e || te(), t = t || {}, typeof u != "boolean" && (u = n instanceof e), this.objectMode = !!t.objectMode, u && (this.objectMode = this.objectMode || !!t.readableObjectMode), this.highWaterMark = C(this, t, "readableHighWaterMark", u), this.buffer = new R(), 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 = t.emitClose !== !1, this.autoDestroy = !!t.autoDestroy, this.destroyed = !1, this.defaultEncoding = t.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, t.encoding && (A || (A = Be().StringDecoder), this.decoder = new A(t.encoding), this.encoding = t.encoding);
+  }
+  function M(t) {
+    if (e = e || te(), !(this instanceof M)) return new M(t);
+    var n = this instanceof e;
+    this._readableState = new D(t, this, n), this.readable = !0, t && (typeof t.read == "function" && (this._read = t.read), typeof t.destroy == "function" && (this._destroy = t.destroy)), a.call(this);
+  }
+  Object.defineProperty(M.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(n) {
+      this._readableState && (this._readableState.destroyed = n);
+    }
+  }), M.prototype.destroy = P.destroy, M.prototype._undestroy = P.undestroy, M.prototype._destroy = function(t, n) {
+    n(t);
+  }, M.prototype.push = function(t, n) {
+    var u = this._readableState, p;
+    return u.objectMode ? p = !0 : typeof t == "string" && (n = n || u.defaultEncoding, n !== u.encoding && (t = l.from(t, n), n = ""), p = !0), W(this, t, n, !1, p);
+  }, M.prototype.unshift = function(t) {
+    return W(this, t, null, !0, !1);
+  };
+  function W(t, n, u, p, k) {
+    d("readableAddChunk", n);
+    var L = t._readableState;
+    if (n === null)
+      L.reading = !1, ye(t, L);
+    else {
+      var I;
+      if (k || (I = _e(L, n)), I)
+        T(t, I);
+      else if (L.objectMode || n && n.length > 0)
+        if (typeof n != "string" && !L.objectMode && Object.getPrototypeOf(n) !== l.prototype && (n = _(n)), p)
+          L.endEmitted ? T(t, new v()) : re(t, L, n, !0);
+        else if (L.ended)
+          T(t, new E());
+        else {
+          if (L.destroyed)
+            return !1;
+          L.reading = !1, L.decoder && !u ? (n = L.decoder.write(n), L.objectMode || n.length !== 0 ? re(t, L, n, !1) : J(t, L)) : re(t, L, n, !1);
+        }
+      else p || (L.reading = !1, J(t, L));
+    }
+    return !L.ended && (L.length < L.highWaterMark || L.length === 0);
+  }
+  function re(t, n, u, p) {
+    n.flowing && n.length === 0 && !n.sync ? (n.awaitDrain = 0, t.emit("data", u)) : (n.length += n.objectMode ? 1 : u.length, p ? n.buffer.unshift(u) : n.buffer.push(u), n.needReadable && G(t)), J(t, n);
+  }
+  function _e(t, n) {
+    var u;
+    return !h(n) && typeof n != "string" && n !== void 0 && !t.objectMode && (u = new w("chunk", ["string", "Buffer", "Uint8Array"], n)), u;
+  }
+  M.prototype.isPaused = function() {
+    return this._readableState.flowing === !1;
+  }, M.prototype.setEncoding = function(t) {
+    A || (A = Be().StringDecoder);
+    var n = new A(t);
+    this._readableState.decoder = n, this._readableState.encoding = this._readableState.decoder.encoding;
+    for (var u = this._readableState.buffer.head, p = ""; u !== null; )
+      p += n.write(u.data), u = u.next;
+    return this._readableState.buffer.clear(), p !== "" && this._readableState.buffer.push(p), this._readableState.length = p.length, this;
+  };
+  var z = 1073741824;
+  function be(t) {
+    return t >= z ? t = z : (t--, t |= t >>> 1, t |= t >>> 2, t |= t >>> 4, t |= t >>> 8, t |= t >>> 16, t++), t;
+  }
+  function ae(t, n) {
+    return t <= 0 || n.length === 0 && n.ended ? 0 : n.objectMode ? 1 : t !== t ? n.flowing && n.length ? n.buffer.head.data.length : n.length : (t > n.highWaterMark && (n.highWaterMark = be(t)), t <= n.length ? t : n.ended ? n.length : (n.needReadable = !0, 0));
+  }
+  M.prototype.read = function(t) {
+    d("read", t), t = parseInt(t, 10);
+    var n = this._readableState, u = t;
+    if (t !== 0 && (n.emittedReadable = !1), t === 0 && n.needReadable && ((n.highWaterMark !== 0 ? n.length >= n.highWaterMark : n.length > 0) || n.ended))
+      return d("read: emitReadable", n.length, n.ended), n.length === 0 && n.ended ? s(this) : G(this), null;
+    if (t = ae(t, n), t === 0 && n.ended)
+      return n.length === 0 && s(this), null;
+    var p = n.needReadable;
+    d("need readable", p), (n.length === 0 || n.length - t < n.highWaterMark) && (p = !0, d("length less than watermark", p)), n.ended || n.reading ? (p = !1, d("reading or ended", p)) : p && (d("do read"), n.reading = !0, n.sync = !0, n.length === 0 && (n.needReadable = !0), this._read(n.highWaterMark), n.sync = !1, n.reading || (t = ae(u, n)));
+    var k;
+    return t > 0 ? k = i(t, n) : k = null, k === null ? (n.needReadable = n.length <= n.highWaterMark, t = 0) : (n.length -= t, n.awaitDrain = 0), n.length === 0 && (n.ended || (n.needReadable = !0), u !== t && n.ended && s(this)), k !== null && this.emit("data", k), k;
+  };
+  function ye(t, n) {
+    if (d("onEofChunk"), !n.ended) {
+      if (n.decoder) {
+        var u = n.decoder.end();
+        u && u.length && (n.buffer.push(u), n.length += n.objectMode ? 1 : u.length);
+      }
+      n.ended = !0, n.sync ? G(t) : (n.needReadable = !1, n.emittedReadable || (n.emittedReadable = !0, oe(t)));
+    }
+  }
+  function G(t) {
+    var n = t._readableState;
+    d("emitReadable", n.needReadable, n.emittedReadable), n.needReadable = !1, n.emittedReadable || (d("emitReadable", n.flowing), n.emittedReadable = !0, q.nextTick(oe, t));
+  }
+  function oe(t) {
+    var n = t._readableState;
+    d("emitReadable_", n.destroyed, n.length, n.ended), !n.destroyed && (n.length || n.ended) && (t.emit("readable"), n.emittedReadable = !1), n.needReadable = !n.flowing && !n.ended && n.length <= n.highWaterMark, o(t);
+  }
+  function J(t, n) {
+    n.readingMore || (n.readingMore = !0, q.nextTick(fe, t, n));
+  }
+  function fe(t, n) {
+    for (; !n.reading && !n.ended && (n.length < n.highWaterMark || n.flowing && n.length === 0); ) {
+      var u = n.length;
+      if (d("maybeReadMore read 0"), t.read(0), u === n.length)
+        break;
+    }
+    n.readingMore = !1;
+  }
+  M.prototype._read = function(t) {
+    T(this, new y("_read()"));
+  }, M.prototype.pipe = function(t, n) {
+    var u = this, p = this._readableState;
+    switch (p.pipesCount) {
+      case 0:
+        p.pipes = t;
+        break;
+      case 1:
+        p.pipes = [p.pipes, t];
+        break;
+      default:
+        p.pipes.push(t);
+        break;
+    }
+    p.pipesCount += 1, d("pipe count=%d opts=%j", p.pipesCount, n);
+    var k = (!n || n.end !== !1) && t !== q.stdout && t !== q.stderr, L = k ? Q : ne;
+    p.endEmitted ? q.nextTick(L) : u.once("end", L), t.on("unpipe", I);
+    function I(Z, ee) {
+      d("onunpipe"), Z === u && ee && ee.hasUnpiped === !1 && (ee.hasUnpiped = !0, vt());
+    }
+    function Q() {
+      d("onend"), t.end();
+    }
+    var ue = ve(u);
+    t.on("drain", ue);
+    var Ue = !1;
+    function vt() {
+      d("cleanup"), t.removeListener("close", me), t.removeListener("finish", Ee), t.removeListener("drain", ue), t.removeListener("error", Re), t.removeListener("unpipe", I), u.removeListener("end", Q), u.removeListener("end", ne), u.removeListener("data", xe), Ue = !0, p.awaitDrain && (!t._writableState || t._writableState.needDrain) && ue();
+    }
+    u.on("data", xe);
+    function xe(Z) {
+      d("ondata");
+      var ee = t.write(Z);
+      d("dest.write", ee), ee === !1 && ((p.pipesCount === 1 && p.pipes === t || p.pipesCount > 1 && N(p.pipes, t) !== -1) && !Ue && (d("false write response, pause", p.awaitDrain), p.awaitDrain++), u.pause());
+    }
+    function Re(Z) {
+      d("onerror", Z), ne(), t.removeListener("error", Re), r(t, "error") === 0 && T(t, Z);
+    }
+    H(t, "error", Re);
+    function me() {
+      t.removeListener("finish", Ee), ne();
+    }
+    t.once("close", me);
+    function Ee() {
+      d("onfinish"), t.removeListener("close", me), ne();
+    }
+    t.once("finish", Ee);
+    function ne() {
+      d("unpipe"), u.unpipe(t);
+    }
+    return t.emit("pipe", u), p.flowing || (d("pipe resume"), u.resume()), t;
+  };
+  function ve(t) {
+    return function() {
+      var u = t._readableState;
+      d("pipeOnDrain", u.awaitDrain), u.awaitDrain && u.awaitDrain--, u.awaitDrain === 0 && r(t, "data") && (u.flowing = !0, o(t));
+    };
+  }
+  M.prototype.unpipe = function(t) {
+    var n = this._readableState, u = {
+      hasUnpiped: !1
+    };
+    if (n.pipesCount === 0) return this;
+    if (n.pipesCount === 1)
+      return t && t !== n.pipes ? this : (t || (t = n.pipes), n.pipes = null, n.pipesCount = 0, n.flowing = !1, t && t.emit("unpipe", this, u), this);
+    if (!t) {
+      var p = n.pipes, k = n.pipesCount;
+      n.pipes = null, n.pipesCount = 0, n.flowing = !1;
+      for (var L = 0; L < k; L++) p[L].emit("unpipe", this, {
+        hasUnpiped: !1
+      });
+      return this;
+    }
+    var I = N(n.pipes, t);
+    return I === -1 ? this : (n.pipes.splice(I, 1), n.pipesCount -= 1, n.pipesCount === 1 && (n.pipes = n.pipes[0]), t.emit("unpipe", this, u), this);
+  }, M.prototype.on = function(t, n) {
+    var u = a.prototype.on.call(this, t, n), p = this._readableState;
+    return t === "data" ? (p.readableListening = this.listenerCount("readable") > 0, p.flowing !== !1 && this.resume()) : t === "readable" && !p.endEmitted && !p.readableListening && (p.readableListening = p.needReadable = !0, p.flowing = !1, p.emittedReadable = !1, d("on readable", p.length, p.reading), p.length ? G(this) : p.reading || q.nextTick($, this)), u;
+  }, M.prototype.addListener = M.prototype.on, M.prototype.removeListener = function(t, n) {
+    var u = a.prototype.removeListener.call(this, t, n);
+    return t === "readable" && q.nextTick(le, this), u;
+  }, M.prototype.removeAllListeners = function(t) {
+    var n = a.prototype.removeAllListeners.apply(this, arguments);
+    return (t === "readable" || t === void 0) && q.nextTick(le, this), n;
+  };
+  function le(t) {
+    var n = t._readableState;
+    n.readableListening = t.listenerCount("readable") > 0, n.resumeScheduled && !n.paused ? n.flowing = !0 : t.listenerCount("data") > 0 && t.resume();
+  }
+  function $(t) {
+    d("readable nexttick read 0"), t.read(0);
+  }
+  M.prototype.resume = function() {
+    var t = this._readableState;
+    return t.flowing || (d("resume"), t.flowing = !t.readableListening, ge(this, t)), t.paused = !1, this;
+  };
+  function ge(t, n) {
+    n.resumeScheduled || (n.resumeScheduled = !0, q.nextTick(we, t, n));
+  }
+  function we(t, n) {
+    d("resume", n.reading), n.reading || t.read(0), n.resumeScheduled = !1, t.emit("resume"), o(t), n.flowing && !n.reading && t.read(0);
+  }
+  M.prototype.pause = function() {
+    return d("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== !1 && (d("pause"), this._readableState.flowing = !1, this.emit("pause")), this._readableState.paused = !0, this;
+  };
+  function o(t) {
+    var n = t._readableState;
+    for (d("flow", n.flowing); n.flowing && t.read() !== null; ) ;
+  }
+  M.prototype.wrap = function(t) {
+    var n = this, u = this._readableState, p = !1;
+    t.on("end", function() {
+      if (d("wrapped end"), u.decoder && !u.ended) {
+        var I = u.decoder.end();
+        I && I.length && n.push(I);
+      }
+      n.push(null);
+    }), t.on("data", function(I) {
+      if (d("wrapped data"), u.decoder && (I = u.decoder.write(I)), !(u.objectMode && I == null) && !(!u.objectMode && (!I || !I.length))) {
+        var Q = n.push(I);
+        Q || (p = !0, t.pause());
+      }
+    });
+    for (var k in t)
+      this[k] === void 0 && typeof t[k] == "function" && (this[k] = /* @__PURE__ */ function(Q) {
+        return function() {
+          return t[Q].apply(t, arguments);
+        };
+      }(k));
+    for (var L = 0; L < O.length; L++)
+      t.on(O[L], this.emit.bind(this, O[L]));
+    return this._read = function(I) {
+      d("wrapped _read", I), p && (p = !1, t.resume());
+    }, this;
+  }, typeof Symbol == "function" && (M.prototype[Symbol.asyncIterator] = function() {
+    return S === void 0 && (S = Ht()), S(this);
+  }), Object.defineProperty(M.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(M.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(M.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(n) {
+      this._readableState && (this._readableState.flowing = n);
+    }
+  }), M._fromList = i, Object.defineProperty(M.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 i(t, n) {
+    if (n.length === 0) return null;
+    var u;
+    return n.objectMode ? u = n.buffer.shift() : !t || t >= n.length ? (n.decoder ? u = n.buffer.join("") : n.buffer.length === 1 ? u = n.buffer.first() : u = n.buffer.concat(n.length), n.buffer.clear()) : u = n.buffer.consume(t, n.decoder), u;
+  }
+  function s(t) {
+    var n = t._readableState;
+    d("endReadable", n.endEmitted), n.endEmitted || (n.ended = !0, q.nextTick(m, n, t));
+  }
+  function m(t, n) {
+    if (d("endReadableNT", t.endEmitted, t.length), !t.endEmitted && t.length === 0 && (t.endEmitted = !0, n.readable = !1, n.emit("end"), t.autoDestroy)) {
+      var u = n._writableState;
+      (!u || u.autoDestroy && u.finished) && n.destroy();
+    }
+  }
+  typeof Symbol == "function" && (M.from = function(t, n) {
+    return g === void 0 && (g = Ut()), g(M, t, n);
+  });
+  function N(t, n) {
+    for (var u = 0, p = t.length; u < p; u++)
+      if (t[u] === n) return u;
+    return -1;
+  }
+  return Pe;
+}
+var ct = F, he = X.codes, xt = he.ERR_METHOD_NOT_IMPLEMENTED, Bt = he.ERR_MULTIPLE_CALLBACK, Wt = he.ERR_TRANSFORM_ALREADY_TRANSFORMING, Ft = he.ERR_TRANSFORM_WITH_LENGTH_0, pe = te();
+Y(F, pe);
+function Gt(e, r) {
+  var a = this._transformState;
+  a.transforming = !1;
+  var l = a.writecb;
+  if (l === null)
+    return this.emit("error", new Bt());
+  a.writechunk = null, a.writecb = null, r != null && this.push(r), l(e);
+  var f = this._readableState;
+  f.reading = !1, (f.needReadable || f.length < f.highWaterMark) && this._read(f.highWaterMark);
+}
+function F(e) {
+  if (!(this instanceof F)) return new F(e);
+  pe.call(this, e), this._transformState = {
+    afterTransform: Gt.bind(this),
+    needTransform: !1,
+    transforming: !1,
+    writecb: null,
+    writechunk: null,
+    writeencoding: null
+  }, this._readableState.needReadable = !0, this._readableState.sync = !1, e && (typeof e.transform == "function" && (this._transform = e.transform), typeof e.flush == "function" && (this._flush = e.flush)), this.on("prefinish", $t);
+}
+function $t() {
+  var e = this;
+  typeof this._flush == "function" && !this._readableState.destroyed ? this._flush(function(r, a) {
+    Je(e, r, a);
+  }) : Je(this, null, null);
+}
+F.prototype.push = function(e, r) {
+  return this._transformState.needTransform = !1, pe.prototype.push.call(this, e, r);
+};
+F.prototype._transform = function(e, r, a) {
+  a(new xt("_transform()"));
+};
+F.prototype._write = function(e, r, a) {
+  var l = this._transformState;
+  if (l.writecb = a, l.writechunk = e, l.writeencoding = r, !l.transforming) {
+    var f = this._readableState;
+    (l.needTransform || f.needReadable || f.length < f.highWaterMark) && this._read(f.highWaterMark);
+  }
+};
+F.prototype._read = function(e) {
+  var r = this._transformState;
+  r.writechunk !== null && !r.transforming ? (r.transforming = !0, this._transform(r.writechunk, r.writeencoding, r.afterTransform)) : r.needTransform = !0;
+};
+F.prototype._destroy = function(e, r) {
+  pe.prototype._destroy.call(this, e, function(a) {
+    r(a);
+  });
+};
+function Je(e, r, a) {
+  if (r) return e.emit("error", r);
+  if (a != null && e.push(a), e._writableState.length) throw new Ft();
+  if (e._transformState.transforming) throw new Wt();
+  return e.push(null);
+}
+var Vt = ie, ht = ct;
+Y(ie, ht);
+function ie(e) {
+  if (!(this instanceof ie)) return new ie(e);
+  ht.call(this, e);
+}
+ie.prototype._transform = function(e, r, a) {
+  a(null, e);
+};
+var Le;
+function Kt(e) {
+  var r = !1;
+  return function() {
+    r || (r = !0, e.apply(void 0, arguments));
+  };
+}
+var pt = X.codes, Yt = pt.ERR_MISSING_ARGS, Xt = pt.ERR_STREAM_DESTROYED;
+function Qe(e) {
+  if (e) throw e;
+}
+function zt(e) {
+  return e.setHeader && typeof e.abort == "function";
+}
+function Jt(e, r, a, l) {
+  l = Kt(l);
+  var f = !1;
+  e.on("close", function() {
+    f = !0;
+  }), Le === void 0 && (Le = ke), Le(e, {
+    readable: r,
+    writable: a
+  }, function(h) {
+    if (h) return l(h);
+    f = !0, l();
+  });
+  var _ = !1;
+  return function(h) {
+    if (!f && !_) {
+      if (_ = !0, zt(e)) return e.abort();
+      if (typeof e.destroy == "function") return e.destroy();
+      l(h || new Xt("pipe"));
+    }
+  };
+}
+function Ze(e) {
+  e();
+}
+function Qt(e, r) {
+  return e.pipe(r);
+}
+function Zt(e) {
+  return !e.length || typeof e[e.length - 1] != "function" ? Qe : e.pop();
+}
+function er() {
+  for (var e = arguments.length, r = new Array(e), a = 0; a < e; a++)
+    r[a] = arguments[a];
+  var l = Zt(r);
+  if (Array.isArray(r[0]) && (r = r[0]), r.length < 2)
+    throw new Yt("streams");
+  var f, _ = r.map(function(h, c) {
+    var d = c < r.length - 1, R = c > 0;
+    return Jt(h, d, R, function(P) {
+      f || (f = P), P && _.forEach(Ze), !d && (_.forEach(Ze), l(f));
+    });
+  });
+  return r.reduce(Qt);
+}
+var tr = er;
+(function(e, r) {
+  r = e.exports = dt(), r.Stream = r, r.Readable = r, r.Writable = ut(), r.Duplex = te(), r.Transform = ct, r.PassThrough = Vt, r.finished = ke, r.pipeline = tr;
+})(Ce, Ce.exports);
+var _t = Ce.exports, et = Ie, rr = Y, bt = _t, se = ce.readyStates = {
+  UNSENT: 0,
+  OPENED: 1,
+  HEADERS_RECEIVED: 2,
+  LOADING: 3,
+  DONE: 4
+}, je = ce.IncomingMessage = function(e, r, a, l) {
+  var f = this;
+  if (bt.Readable.call(f), f._mode = a, f.headers = {}, f.rawHeaders = [], f.trailers = {}, f.rawTrailers = [], f.on("end", function() {
+    q.nextTick(function() {
+      f.emit("close");
+    });
+  }), a === "fetch") {
+    let P = function() {
+      h.read().then(function(b) {
+        if (!f._destroyed) {
+          if (l(b.done), b.done) {
+            f.push(null);
+            return;
+          }
+          f.push(V.from(b.value)), P();
+        }
+      }).catch(function(b) {
+        l(!0), f._destroyed || f.emit("error", b);
+      });
+    };
+    if (f._fetchResponse = r, f.url = r.url, f.statusCode = r.status, f.statusMessage = r.statusText, r.headers.forEach(function(b, C) {
+      f.headers[C.toLowerCase()] = b, f.rawHeaders.push(C, b);
+    }), et.writableStream) {
+      var _ = new WritableStream({
+        write: function(b) {
+          return l(!1), new Promise(function(C, j) {
+            f._destroyed ? j() : f.push(V.from(b)) ? C() : f._resumeFetch = C;
+          });
+        },
+        close: function() {
+          l(!0), f._destroyed || f.push(null);
+        },
+        abort: function(b) {
+          l(!0), f._destroyed || f.emit("error", b);
+        }
+      });
+      try {
+        r.body.pipeTo(_).catch(function(b) {
+          l(!0), f._destroyed || f.emit("error", b);
+        });
+        return;
+      } catch {
+      }
+    }
+    var h = r.body.getReader();
+    P();
+  } else {
+    f._xhr = e, f._pos = 0, f.url = e.responseURL, f.statusCode = e.status, f.statusMessage = e.statusText;
+    var c = e.getAllResponseHeaders().split(/\r?\n/);
+    if (c.forEach(function(P) {
+      var b = P.match(/^([^:]+):\s*(.*)/);
+      if (b) {
+        var C = b[1].toLowerCase();
+        C === "set-cookie" ? (f.headers[C] === void 0 && (f.headers[C] = []), f.headers[C].push(b[2])) : f.headers[C] !== void 0 ? f.headers[C] += ", " + b[2] : f.headers[C] = b[2], f.rawHeaders.push(b[1], b[2]);
+      }
+    }), f._charset = "x-user-defined", !et.overrideMimeType) {
+      var d = f.rawHeaders["mime-type"];
+      if (d) {
+        var R = d.match(/;\s*charset=([^;])(;|$)/);
+        R && (f._charset = R[1].toLowerCase());
+      }
+      f._charset || (f._charset = "utf-8");
+    }
+  }
+};
+rr(je, bt.Readable);
+je.prototype._read = function() {
+  var e = this, r = e._resumeFetch;
+  r && (e._resumeFetch = null, r());
+};
+je.prototype._onXHRProgress = function(e) {
+  var r = this, a = r._xhr, l = null;
+  switch (r._mode) {
+    case "text":
+      if (l = a.responseText, l.length > r._pos) {
+        var f = l.substr(r._pos);
+        if (r._charset === "x-user-defined") {
+          for (var _ = V.alloc(f.length), h = 0; h < f.length; h++)
+            _[h] = f.charCodeAt(h) & 255;
+          r.push(_);
+        } else
+          r.push(f, r._charset);
+        r._pos = l.length;
+      }
+      break;
+    case "arraybuffer":
+      if (a.readyState !== se.DONE || !a.response)
+        break;
+      l = a.response, r.push(V.from(new Uint8Array(l)));
+      break;
+    case "moz-chunked-arraybuffer":
+      if (l = a.response, a.readyState !== se.LOADING || !l)
+        break;
+      r.push(V.from(new Uint8Array(l)));
+      break;
+    case "ms-stream":
+      if (l = a.response, a.readyState !== se.LOADING)
+        break;
+      var c = new U.MSStreamReader();
+      c.onprogress = function() {
+        c.result.byteLength > r._pos && (r.push(V.from(new Uint8Array(c.result.slice(r._pos)))), r._pos = c.result.byteLength);
+      }, c.onload = function() {
+        e(!0), r.push(null);
+      }, c.readAsArrayBuffer(l);
+      break;
+  }
+  r._xhr.readyState === se.DONE && r._mode !== "ms-stream" && (e(!0), r.push(null));
+};
+var K = Ie, nr = Y, yt = ce, He = _t, ir = yt.IncomingMessage, tt = yt.readyStates;
+function ar(e, r) {
+  return K.fetch && r ? "fetch" : K.mozchunkedarraybuffer ? "moz-chunked-arraybuffer" : K.msstream ? "ms-stream" : K.arraybuffer && e ? "arraybuffer" : "text";
+}
+var x = it.exports = function(e) {
+  var r = this;
+  He.Writable.call(r), r._opts = e, r._body = [], r._headers = {}, e.auth && r.setHeader("Authorization", "Basic " + V.from(e.auth).toString("base64")), Object.keys(e.headers).forEach(function(f) {
+    r.setHeader(f, e.headers[f]);
+  });
+  var a, l = !0;
+  if (e.mode === "disable-fetch" || "requestTimeout" in e && !K.abortController)
+    l = !1, a = !0;
+  else if (e.mode === "prefer-streaming")
+    a = !1;
+  else if (e.mode === "allow-wrong-content-type")
+    a = !K.overrideMimeType;
+  else if (!e.mode || e.mode === "default" || e.mode === "prefer-fast")
+    a = !0;
+  else
+    throw new Error("Invalid value for opts.mode");
+  r._mode = ar(a, l), r._fetchTimer = null, r._socketTimeout = null, r._socketTimer = null, r.on("finish", function() {
+    r._onFinish();
+  });
+};
+nr(x, He.Writable);
+x.prototype.setHeader = function(e, r) {
+  var a = this, l = e.toLowerCase();
+  fr.indexOf(l) === -1 && (a._headers[l] = {
+    name: e,
+    value: r
+  });
+};
+x.prototype.getHeader = function(e) {
+  var r = this._headers[e.toLowerCase()];
+  return r ? r.value : null;
+};
+x.prototype.removeHeader = function(e) {
+  var r = this;
+  delete r._headers[e.toLowerCase()];
+};
+x.prototype._onFinish = function() {
+  var e = this;
+  if (!e._destroyed) {
+    var r = e._opts;
+    "timeout" in r && r.timeout !== 0 && e.setTimeout(r.timeout);
+    var a = e._headers, l = null;
+    r.method !== "GET" && r.method !== "HEAD" && (l = new Blob(e._body, {
+      type: (a["content-type"] || {}).value || ""
+    }));
+    var f = [];
+    if (Object.keys(a).forEach(function(d) {
+      var R = a[d].name, P = a[d].value;
+      Array.isArray(P) ? P.forEach(function(b) {
+        f.push([R, b]);
+      }) : f.push([R, P]);
+    }), e._mode === "fetch") {
+      var _ = null;
+      if (K.abortController) {
+        var h = new AbortController();
+        _ = h.signal, e._fetchAbortController = h, "requestTimeout" in r && r.requestTimeout !== 0 && (e._fetchTimer = U.setTimeout(function() {
+          e.emit("requestTimeout"), e._fetchAbortController && e._fetchAbortController.abort();
+        }, r.requestTimeout));
+      }
+      U.fetch(e._opts.url, {
+        method: e._opts.method,
+        headers: f,
+        body: l || void 0,
+        mode: "cors",
+        credentials: r.withCredentials ? "include" : "same-origin",
+        signal: _
+      }).then(function(d) {
+        e._fetchResponse = d, e._resetTimers(!1), e._connect();
+      }, function(d) {
+        e._resetTimers(!0), e._destroyed || e.emit("error", d);
+      });
+    } else {
+      var c = e._xhr = new U.XMLHttpRequest();
+      try {
+        c.open(e._opts.method, e._opts.url, !0);
+      } catch (d) {
+        q.nextTick(function() {
+          e.emit("error", d);
+        });
+        return;
+      }
+      "responseType" in c && (c.responseType = e._mode), "withCredentials" in c && (c.withCredentials = !!r.withCredentials), e._mode === "text" && "overrideMimeType" in c && c.overrideMimeType("text/plain; charset=x-user-defined"), "requestTimeout" in r && (c.timeout = r.requestTimeout, c.ontimeout = function() {
+        e.emit("requestTimeout");
+      }), f.forEach(function(d) {
+        c.setRequestHeader(d[0], d[1]);
+      }), e._response = null, c.onreadystatechange = function() {
+        switch (c.readyState) {
+          case tt.LOADING:
+          case tt.DONE:
+            e._onXHRProgress();
+            break;
+        }
+      }, e._mode === "moz-chunked-arraybuffer" && (c.onprogress = function() {
+        e._onXHRProgress();
+      }), c.onerror = function() {
+        e._destroyed || (e._resetTimers(!0), e.emit("error", new Error("XHR error")));
+      };
+      try {
+        c.send(l);
+      } catch (d) {
+        q.nextTick(function() {
+          e.emit("error", d);
+        });
+        return;
+      }
+    }
+  }
+};
+function or(e) {
+  try {
+    var r = e.status;
+    return r !== null && r !== 0;
+  } catch {
+    return !1;
+  }
+}
+x.prototype._onXHRProgress = function() {
+  var e = this;
+  e._resetTimers(!1), !(!or(e._xhr) || e._destroyed) && (e._response || e._connect(), e._response._onXHRProgress(e._resetTimers.bind(e)));
+};
+x.prototype._connect = function() {
+  var e = this;
+  e._destroyed || (e._response = new ir(e._xhr, e._fetchResponse, e._mode, e._resetTimers.bind(e)), e._response.on("error", function(r) {
+    e.emit("error", r);
+  }), e.emit("response", e._response));
+};
+x.prototype._write = function(e, r, a) {
+  var l = this;
+  l._body.push(e), a();
+};
+x.prototype._resetTimers = function(e) {
+  var r = this;
+  U.clearTimeout(r._socketTimer), r._socketTimer = null, e ? (U.clearTimeout(r._fetchTimer), r._fetchTimer = null) : r._socketTimeout && (r._socketTimer = U.setTimeout(function() {
+    r.emit("timeout");
+  }, r._socketTimeout));
+};
+x.prototype.abort = x.prototype.destroy = function(e) {
+  var r = this;
+  r._destroyed = !0, r._resetTimers(!0), r._response && (r._response._destroyed = !0), r._xhr ? r._xhr.abort() : r._fetchAbortController && r._fetchAbortController.abort(), e && r.emit("error", e);
+};
+x.prototype.end = function(e, r, a) {
+  var l = this;
+  typeof e == "function" && (a = e, e = void 0), He.Writable.prototype.end.call(l, e, r, a);
+};
+x.prototype.setTimeout = function(e, r) {
+  var a = this;
+  r && a.once("timeout", r), a._socketTimeout = e, a._resetTimers(!1);
+};
+x.prototype.flushHeaders = function() {
+};
+x.prototype.setNoDelay = function() {
+};
+x.prototype.setSocketKeepAlive = function() {
+};
+var fr = [
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "cookie2",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "referer",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+], lr = it.exports, ur = dr, sr = Object.prototype.hasOwnProperty;
+function dr() {
+  for (var e = {}, r = 0; r < arguments.length; r++) {
+    var a = arguments[r];
+    for (var l in a)
+      sr.call(a, l) && (e[l] = a[l]);
+  }
+  return e;
+}
+var cr = {
+  100: "Continue",
+  101: "Switching Protocols",
+  102: "Processing",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  203: "Non-Authoritative Information",
+  204: "No Content",
+  205: "Reset Content",
+  206: "Partial Content",
+  207: "Multi-Status",
+  208: "Already Reported",
+  226: "IM Used",
+  300: "Multiple Choices",
+  301: "Moved Permanently",
+  302: "Found",
+  303: "See Other",
+  304: "Not Modified",
+  305: "Use Proxy",
+  307: "Temporary Redirect",
+  308: "Permanent Redirect",
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Unordered Collection",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  509: "Bandwidth Limit Exceeded",
+  510: "Not Extended",
+  511: "Network Authentication Required"
+};
+const hr = /* @__PURE__ */ gt(mt);
+(function(e) {
+  var r = lr, a = ce, l = ur, f = cr, _ = hr, h = e;
+  h.request = function(c, d) {
+    typeof c == "string" ? c = _.parse(c) : c = l(c);
+    var R = U.location.protocol.search(/^https?:$/) === -1 ? "http:" : "", P = c.protocol || R, b = c.hostname || c.host, C = c.port, j = c.path || "/";
+    b && b.indexOf(":") !== -1 && (b = "[" + b + "]"), c.url = (b ? P + "//" + b : "") + (C ? ":" + C : "") + j, c.method = (c.method || "GET").toUpperCase(), c.headers = c.headers || {};
+    var w = new r(c);
+    return d && w.on("response", d), w;
+  }, h.get = function(d, R) {
+    var P = h.request(d, R);
+    return P.end(), P;
+  }, h.ClientRequest = r, h.IncomingMessage = a.IncomingMessage, h.Agent = function() {
+  }, h.Agent.defaultMaxSockets = 4, h.globalAgent = new h.Agent(), h.STATUS_CODES = f, h.METHODS = [
+    "CHECKOUT",
+    "CONNECT",
+    "COPY",
+    "DELETE",
+    "GET",
+    "HEAD",
+    "LOCK",
+    "M-SEARCH",
+    "MERGE",
+    "MKACTIVITY",
+    "MKCOL",
+    "MOVE",
+    "NOTIFY",
+    "OPTIONS",
+    "PATCH",
+    "POST",
+    "PROPFIND",
+    "PROPPATCH",
+    "PURGE",
+    "PUT",
+    "REPORT",
+    "SEARCH",
+    "SUBSCRIBE",
+    "TRACE",
+    "UNLOCK",
+    "UNSUBSCRIBE"
+  ];
+})(qe);
+const pr = /* @__PURE__ */ wt(qe), gr = /* @__PURE__ */ Et({
+  __proto__: null,
+  default: pr
+}, [qe]);
+export {
+  gr as i,
+  hr as r,
+  qe as s
+};