@genome-spy/app 0.37.4 → 0.39.0

package/dist/index-Pv3tKJ1W.js

@@ -0,0 +1,2190 @@
+import { b as ce } from "./index-1QVesMzU.js";
+import { _ as Vt } from "./__vite-browser-external-ENoMJThg.js";
+import { a as Gt } from "./_commonjsHelpers-QtkX90xp.js";
+var He = { exports: {} }, z = typeof Reflect == "object" ? Reflect : null, Je = z && typeof z.apply == "function" ? z.apply : function(e, r, a) {
+  return Function.prototype.apply.call(e, r, a);
+}, ue;
+z && typeof z.ownKeys == "function" ? ue = z.ownKeys : Object.getOwnPropertySymbols ? ue = function(e) {
+  return Object.getOwnPropertyNames(e).concat(Object.getOwnPropertySymbols(e));
+} : ue = function(e) {
+  return Object.getOwnPropertyNames(e);
+};
+function Kt(t) {
+  console && console.warn && console.warn(t);
+}
+var bt = Number.isNaN || function(e) {
+  return e !== e;
+};
+function q() {
+  q.init.call(this);
+}
+He.exports = q;
+He.exports.once = Jt;
+q.EventEmitter = q;
+q.prototype._events = void 0;
+q.prototype._eventsCount = 0;
+q.prototype._maxListeners = void 0;
+var Qe = 10;
+function he(t) {
+  if (typeof t != "function")
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof t);
+}
+Object.defineProperty(q, "defaultMaxListeners", {
+  enumerable: !0,
+  get: function() {
+    return Qe;
+  },
+  set: function(t) {
+    if (typeof t != "number" || t < 0 || bt(t))
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + t + ".");
+    Qe = t;
+  }
+});
+q.init = function() {
+  (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+};
+q.prototype.setMaxListeners = function(e) {
+  if (typeof e != "number" || e < 0 || bt(e))
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + e + ".");
+  return this._maxListeners = e, this;
+};
+function gt(t) {
+  return t._maxListeners === void 0 ? q.defaultMaxListeners : t._maxListeners;
+}
+q.prototype.getMaxListeners = function() {
+  return gt(this);
+};
+q.prototype.emit = function(e) {
+  for (var r = [], a = 1; a < arguments.length; a++)
+    r.push(arguments[a]);
+  var o = e === "error", s = this._events;
+  if (s !== void 0)
+    o = o && s.error === void 0;
+  else if (!o)
+    return !1;
+  if (o) {
+    var f;
+    if (r.length > 0 && (f = r[0]), f instanceof Error)
+      throw f;
+    var u = new Error("Unhandled error." + (f ? " (" + f.message + ")" : ""));
+    throw u.context = f, u;
+  }
+  var l = s[e];
+  if (l === void 0)
+    return !1;
+  if (typeof l == "function")
+    Je(l, this, r);
+  else
+    for (var h = l.length, g = St(l, h), a = 0; a < h; ++a)
+      Je(g[a], this, r);
+  return !0;
+};
+function yt(t, e, r, a) {
+  var o, s, f;
+  if (he(r), s = t._events, s === void 0 ? (s = t._events = /* @__PURE__ */ Object.create(null), t._eventsCount = 0) : (s.newListener !== void 0 && (t.emit(
+    "newListener",
+    e,
+    r.listener ? r.listener : r
+  ), s = t._events), f = s[e]), f === void 0)
+    f = s[e] = r, ++t._eventsCount;
+  else if (typeof f == "function" ? f = s[e] = a ? [r, f] : [f, r] : a ? f.unshift(r) : f.push(r), o = gt(t), o > 0 && f.length > o && !f.warned) {
+    f.warned = !0;
+    var u = new Error("Possible EventEmitter memory leak detected. " + f.length + " " + String(e) + " listeners added. Use emitter.setMaxListeners() to increase limit");
+    u.name = "MaxListenersExceededWarning", u.emitter = t, u.type = e, u.count = f.length, Kt(u);
+  }
+  return t;
+}
+q.prototype.addListener = function(e, r) {
+  return yt(this, e, r, !1);
+};
+q.prototype.on = q.prototype.addListener;
+q.prototype.prependListener = function(e, r) {
+  return yt(this, e, r, !0);
+};
+function Yt() {
+  if (!this.fired)
+    return this.target.removeListener(this.type, this.wrapFn), this.fired = !0, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
+}
+function wt(t, e, r) {
+  var a = { fired: !1, wrapFn: void 0, target: t, type: e, listener: r }, o = Yt.bind(a);
+  return o.listener = r, a.wrapFn = o, o;
+}
+q.prototype.once = function(e, r) {
+  return he(r), this.on(e, wt(this, e, r)), this;
+};
+q.prototype.prependOnceListener = function(e, r) {
+  return he(r), this.prependListener(e, wt(this, e, r)), this;
+};
+q.prototype.removeListener = function(e, r) {
+  var a, o, s, f, u;
+  if (he(r), o = this._events, o === void 0)
+    return this;
+  if (a = o[e], a === void 0)
+    return this;
+  if (a === r || a.listener === r)
+    --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete o[e], o.removeListener && this.emit("removeListener", e, a.listener || r));
+  else if (typeof a != "function") {
+    for (s = -1, f = a.length - 1; f >= 0; f--)
+      if (a[f] === r || a[f].listener === r) {
+        u = a[f].listener, s = f;
+        break;
+      }
+    if (s < 0)
+      return this;
+    s === 0 ? a.shift() : zt(a, s), a.length === 1 && (o[e] = a[0]), o.removeListener !== void 0 && this.emit("removeListener", e, u || r);
+  }
+  return this;
+};
+q.prototype.off = q.prototype.removeListener;
+q.prototype.removeAllListeners = function(e) {
+  var r, a, o;
+  if (a = this._events, a === void 0)
+    return this;
+  if (a.removeListener === void 0)
+    return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : a[e] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete a[e]), this;
+  if (arguments.length === 0) {
+    var s = Object.keys(a), f;
+    for (o = 0; o < s.length; ++o)
+      f = s[o], f !== "removeListener" && this.removeAllListeners(f);
+    return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
+  }
+  if (r = a[e], typeof r == "function")
+    this.removeListener(e, r);
+  else if (r !== void 0)
+    for (o = r.length - 1; o >= 0; o--)
+      this.removeListener(e, r[o]);
+  return this;
+};
+function mt(t, e, r) {
+  var a = t._events;
+  if (a === void 0)
+    return [];
+  var o = a[e];
+  return o === void 0 ? [] : typeof o == "function" ? r ? [o.listener || o] : [o] : r ? Xt(o) : St(o, o.length);
+}
+q.prototype.listeners = function(e) {
+  return mt(this, e, !0);
+};
+q.prototype.rawListeners = function(e) {
+  return mt(this, e, !1);
+};
+q.listenerCount = function(t, e) {
+  return typeof t.listenerCount == "function" ? t.listenerCount(e) : Et.call(t, e);
+};
+q.prototype.listenerCount = Et;
+function Et(t) {
+  var e = this._events;
+  if (e !== void 0) {
+    var r = e[t];
+    if (typeof r == "function")
+      return 1;
+    if (r !== void 0)
+      return r.length;
+  }
+  return 0;
+}
+q.prototype.eventNames = function() {
+  return this._eventsCount > 0 ? ue(this._events) : [];
+};
+function St(t, e) {
+  for (var r = new Array(e), a = 0; a < e; ++a)
+    r[a] = t[a];
+  return r;
+}
+function zt(t, e) {
+  for (; e + 1 < t.length; e++)
+    t[e] = t[e + 1];
+  t.pop();
+}
+function Xt(t) {
+  for (var e = new Array(t.length), r = 0; r < e.length; ++r)
+    e[r] = t[r].listener || t[r];
+  return e;
+}
+function Jt(t, e) {
+  return new Promise(function(r, a) {
+    function o(f) {
+      t.removeListener(e, s), a(f);
+    }
+    function s() {
+      typeof t.removeListener == "function" && t.removeListener("error", o), r([].slice.call(arguments));
+    }
+    Rt(t, e, s, { once: !0 }), e !== "error" && Qt(t, o, { once: !0 });
+  });
+}
+function Qt(t, e, r) {
+  typeof t.on == "function" && Rt(t, "error", e, r);
+}
+function Rt(t, e, r, a) {
+  if (typeof t.on == "function")
+    a.once ? t.once(e, r) : t.on(e, r);
+  else if (typeof t.addEventListener == "function")
+    t.addEventListener(e, function o(s) {
+      a.once && t.removeEventListener(e, o), r(s);
+    });
+  else
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof t);
+}
+var $e = He.exports, Fe = { exports: {} };
+typeof Object.create == "function" ? Fe.exports = function(e, r) {
+  r && (e.super_ = r, e.prototype = Object.create(r.prototype, {
+    constructor: {
+      value: e,
+      enumerable: !1,
+      writable: !0,
+      configurable: !0
+    }
+  }));
+} : Fe.exports = function(e, r) {
+  if (r) {
+    e.super_ = r;
+    var a = function() {
+    };
+    a.prototype = r.prototype, e.prototype = new a(), e.prototype.constructor = e;
+  }
+};
+var J = Fe.exports, Se, Ze;
+function Lt() {
+  return Ze || (Ze = 1, Se = $e.EventEmitter), Se;
+}
+const Tt = /* @__PURE__ */ Gt(Vt);
+var Re, et;
+function Zt() {
+  if (et)
+    return Re;
+  et = 1;
+  function t(m, S) {
+    var b = Object.keys(m);
+    if (Object.getOwnPropertySymbols) {
+      var w = Object.getOwnPropertySymbols(m);
+      S && (w = w.filter(function(T) {
+        return Object.getOwnPropertyDescriptor(m, T).enumerable;
+      })), b.push.apply(b, w);
+    }
+    return b;
+  }
+  function e(m) {
+    for (var S = 1; S < arguments.length; S++) {
+      var b = arguments[S] != null ? arguments[S] : {};
+      S % 2 ? t(Object(b), !0).forEach(function(w) {
+        r(m, w, b[w]);
+      }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(m, Object.getOwnPropertyDescriptors(b)) : t(Object(b)).forEach(function(w) {
+        Object.defineProperty(m, w, Object.getOwnPropertyDescriptor(b, w));
+      });
+    }
+    return m;
+  }
+  function r(m, S, b) {
+    return S = f(S), S in m ? Object.defineProperty(m, S, { value: b, enumerable: !0, configurable: !0, writable: !0 }) : m[S] = b, m;
+  }
+  function a(m, S) {
+    if (!(m instanceof S))
+      throw new TypeError("Cannot call a class as a function");
+  }
+  function o(m, S) {
+    for (var b = 0; b < S.length; b++) {
+      var w = S[b];
+      w.enumerable = w.enumerable || !1, w.configurable = !0, "value" in w && (w.writable = !0), Object.defineProperty(m, f(w.key), w);
+    }
+  }
+  function s(m, S, b) {
+    return S && o(m.prototype, S), b && o(m, b), Object.defineProperty(m, "prototype", { writable: !1 }), m;
+  }
+  function f(m) {
+    var S = u(m, "string");
+    return typeof S == "symbol" ? S : String(S);
+  }
+  function u(m, S) {
+    if (typeof m != "object" || m === null)
+      return m;
+    var b = m[Symbol.toPrimitive];
+    if (b !== void 0) {
+      var w = b.call(m, S || "default");
+      if (typeof w != "object")
+        return w;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (S === "string" ? String : Number)(m);
+  }
+  var l = ce, h = l.Buffer, g = Tt, y = g.inspect, _ = y && y.custom || "inspect";
+  function M(m, S, b) {
+    h.prototype.copy.call(m, S, b);
+  }
+  return Re = /* @__PURE__ */ function() {
+    function m() {
+      a(this, m), this.head = null, this.tail = null, this.length = 0;
+    }
+    return s(m, [{
+      key: "push",
+      value: function(b) {
+        var w = {
+          data: b,
+          next: null
+        };
+        this.length > 0 ? this.tail.next = w : this.head = w, this.tail = w, ++this.length;
+      }
+    }, {
+      key: "unshift",
+      value: function(b) {
+        var w = {
+          data: b,
+          next: this.head
+        };
+        this.length === 0 && (this.tail = w), this.head = w, ++this.length;
+      }
+    }, {
+      key: "shift",
+      value: function() {
+        if (this.length !== 0) {
+          var b = this.head.data;
+          return this.length === 1 ? this.head = this.tail = null : this.head = this.head.next, --this.length, b;
+        }
+      }
+    }, {
+      key: "clear",
+      value: function() {
+        this.head = this.tail = null, this.length = 0;
+      }
+    }, {
+      key: "join",
+      value: function(b) {
+        if (this.length === 0)
+          return "";
+        for (var w = this.head, T = "" + w.data; w = w.next; )
+          T += b + w.data;
+        return T;
+      }
+    }, {
+      key: "concat",
+      value: function(b) {
+        if (this.length === 0)
+          return h.alloc(0);
+        for (var w = h.allocUnsafe(b >>> 0), T = this.head, L = 0; T; )
+          M(T.data, w, L), L += T.data.length, T = T.next;
+        return w;
+      }
+      // Consumes a specified amount of bytes or characters from the buffered data.
+    }, {
+      key: "consume",
+      value: function(b, w) {
+        var T;
+        return b < this.head.data.length ? (T = this.head.data.slice(0, b), this.head.data = this.head.data.slice(b)) : b === this.head.data.length ? T = this.shift() : T = w ? this._getString(b) : this._getBuffer(b), T;
+      }
+    }, {
+      key: "first",
+      value: function() {
+        return this.head.data;
+      }
+      // Consumes a specified amount of characters from the buffered data.
+    }, {
+      key: "_getString",
+      value: function(b) {
+        var w = this.head, T = 1, L = w.data;
+        for (b -= L.length; w = w.next; ) {
+          var R = w.data, A = b > R.length ? R.length : b;
+          if (A === R.length ? L += R : L += R.slice(0, b), b -= A, b === 0) {
+            A === R.length ? (++T, w.next ? this.head = w.next : this.head = this.tail = null) : (this.head = w, w.data = R.slice(A));
+            break;
+          }
+          ++T;
+        }
+        return this.length -= T, L;
+      }
+      // Consumes a specified amount of bytes from the buffered data.
+    }, {
+      key: "_getBuffer",
+      value: function(b) {
+        var w = h.allocUnsafe(b), T = this.head, L = 1;
+        for (T.data.copy(w), b -= T.data.length; T = T.next; ) {
+          var R = T.data, A = b > R.length ? R.length : b;
+          if (R.copy(w, w.length - b, 0, A), b -= A, b === 0) {
+            A === R.length ? (++L, T.next ? this.head = T.next : this.head = this.tail = null) : (this.head = T, T.data = R.slice(A));
+            break;
+          }
+          ++L;
+        }
+        return this.length -= L, w;
+      }
+      // Make sure the linked list only shows the minimal necessary information.
+    }, {
+      key: _,
+      value: function(b, w) {
+        return y(this, e(e({}, w), {}, {
+          // Only inspect one level.
+          depth: 0,
+          // It should not recurse.
+          customInspect: !1
+        }));
+      }
+    }]), m;
+  }(), Re;
+}
+var Le, tt;
+function Ct() {
+  if (tt)
+    return Le;
+  tt = 1;
+  function t(f, u) {
+    var l = this, h = this._readableState && this._readableState.destroyed, g = this._writableState && this._writableState.destroyed;
+    return h || g ? (u ? u(f) : f && (this._writableState ? this._writableState.errorEmitted || (this._writableState.errorEmitted = !0, process.nextTick(o, this, f)) : process.nextTick(o, this, f)), this) : (this._readableState && (this._readableState.destroyed = !0), this._writableState && (this._writableState.destroyed = !0), this._destroy(f || null, function(y) {
+      !u && y ? l._writableState ? l._writableState.errorEmitted ? process.nextTick(r, l) : (l._writableState.errorEmitted = !0, process.nextTick(e, l, y)) : process.nextTick(e, l, y) : u ? (process.nextTick(r, l), u(y)) : process.nextTick(r, l);
+    }), this);
+  }
+  function e(f, u) {
+    o(f, u), r(f);
+  }
+  function r(f) {
+    f._writableState && !f._writableState.emitClose || f._readableState && !f._readableState.emitClose || f.emit("close");
+  }
+  function a() {
+    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 o(f, u) {
+    f.emit("error", u);
+  }
+  function s(f, u) {
+    var l = f._readableState, h = f._writableState;
+    l && l.autoDestroy || h && h.autoDestroy ? f.destroy(u) : f.emit("error", u);
+  }
+  return Le = {
+    destroy: t,
+    undestroy: a,
+    errorOrDestroy: s
+  }, Le;
+}
+var Te = {}, rt;
+function Q() {
+  if (rt)
+    return Te;
+  rt = 1;
+  function t(u, l) {
+    u.prototype = Object.create(l.prototype), u.prototype.constructor = u, u.__proto__ = l;
+  }
+  var e = {};
+  function r(u, l, h) {
+    h || (h = Error);
+    function g(_, M, m) {
+      return typeof l == "string" ? l : l(_, M, m);
+    }
+    var y = /* @__PURE__ */ function(_) {
+      t(M, _);
+      function M(m, S, b) {
+        return _.call(this, g(m, S, b)) || this;
+      }
+      return M;
+    }(h);
+    y.prototype.name = h.name, y.prototype.code = u, e[u] = y;
+  }
+  function a(u, l) {
+    if (Array.isArray(u)) {
+      var h = u.length;
+      return u = u.map(function(g) {
+        return String(g);
+      }), h > 2 ? "one of ".concat(l, " ").concat(u.slice(0, h - 1).join(", "), ", or ") + u[h - 1] : h === 2 ? "one of ".concat(l, " ").concat(u[0], " or ").concat(u[1]) : "of ".concat(l, " ").concat(u[0]);
+    } else
+      return "of ".concat(l, " ").concat(String(u));
+  }
+  function o(u, l, h) {
+    return u.substr(!h || h < 0 ? 0 : +h, l.length) === l;
+  }
+  function s(u, l, h) {
+    return (h === void 0 || h > u.length) && (h = u.length), u.substring(h - l.length, h) === l;
+  }
+  function f(u, l, h) {
+    return typeof h != "number" && (h = 0), h + l.length > u.length ? !1 : u.indexOf(l, h) !== -1;
+  }
+  return r("ERR_INVALID_OPT_VALUE", function(u, l) {
+    return 'The value "' + l + '" is invalid for option "' + u + '"';
+  }, TypeError), r("ERR_INVALID_ARG_TYPE", function(u, l, h) {
+    var g;
+    typeof l == "string" && o(l, "not ") ? (g = "must not be", l = l.replace(/^not /, "")) : g = "must be";
+    var y;
+    if (s(u, " argument"))
+      y = "The ".concat(u, " ").concat(g, " ").concat(a(l, "type"));
+    else {
+      var _ = f(u, ".") ? "property" : "argument";
+      y = 'The "'.concat(u, '" ').concat(_, " ").concat(g, " ").concat(a(l, "type"));
+    }
+    return y += ". Received type ".concat(typeof h), y;
+  }, TypeError), r("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF"), r("ERR_METHOD_NOT_IMPLEMENTED", function(u) {
+    return "The " + u + " method is not implemented";
+  }), r("ERR_STREAM_PREMATURE_CLOSE", "Premature close"), r("ERR_STREAM_DESTROYED", function(u) {
+    return "Cannot call " + u + " after a stream was destroyed";
+  }), r("ERR_MULTIPLE_CALLBACK", "Callback called multiple times"), r("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable"), r("ERR_STREAM_WRITE_AFTER_END", "write after end"), r("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError), r("ERR_UNKNOWN_ENCODING", function(u) {
+    return "Unknown encoding: " + u;
+  }, TypeError), r("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event"), Te.codes = e, Te;
+}
+var Ce, nt;
+function At() {
+  if (nt)
+    return Ce;
+  nt = 1;
+  var t = Q().codes.ERR_INVALID_OPT_VALUE;
+  function e(a, o, s) {
+    return a.highWaterMark != null ? a.highWaterMark : o ? a[s] : null;
+  }
+  function r(a, o, s, f) {
+    var u = e(o, f, s);
+    if (u != null) {
+      if (!(isFinite(u) && Math.floor(u) === u) || u < 0) {
+        var l = f ? s : "highWaterMark";
+        throw new t(l, u);
+      }
+      return Math.floor(u);
+    }
+    return a.objectMode ? 16 : 16 * 1024;
+  }
+  return Ce = {
+    getHighWaterMark: r
+  }, Ce;
+}
+var Ae, it;
+function er() {
+  if (it)
+    return Ae;
+  it = 1, Ae = t;
+  function t(r, a) {
+    if (e("noDeprecation"))
+      return r;
+    var o = !1;
+    function s() {
+      if (!o) {
+        if (e("throwDeprecation"))
+          throw new Error(a);
+        e("traceDeprecation") ? console.trace(a) : console.warn(a), o = !0;
+      }
+      return r.apply(this, arguments);
+    }
+    return s;
+  }
+  function e(r) {
+    try {
+      if (!globalThis.localStorage)
+        return !1;
+    } catch {
+      return !1;
+    }
+    var a = globalThis.localStorage[r];
+    return a == null ? !1 : String(a).toLowerCase() === "true";
+  }
+  return Ae;
+}
+var Me, at;
+function Mt() {
+  if (at)
+    return Me;
+  at = 1, Me = N;
+  function t(c) {
+    var d = this;
+    this.next = null, this.entry = null, this.finish = function() {
+      ye(d, c);
+    };
+  }
+  var e;
+  N.WritableState = O;
+  var r = {
+    deprecate: er()
+  }, a = Lt(), o = ce.Buffer, s = (typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function f(c) {
+    return o.from(c);
+  }
+  function u(c) {
+    return o.isBuffer(c) || c instanceof s;
+  }
+  var l = Ct(), h = At(), g = h.getHighWaterMark, y = Q().codes, _ = y.ERR_INVALID_ARG_TYPE, M = y.ERR_METHOD_NOT_IMPLEMENTED, m = y.ERR_MULTIPLE_CALLBACK, S = y.ERR_STREAM_CANNOT_PIPE, b = y.ERR_STREAM_DESTROYED, w = y.ERR_STREAM_NULL_VALUES, T = y.ERR_STREAM_WRITE_AFTER_END, L = y.ERR_UNKNOWN_ENCODING, R = l.errorOrDestroy;
+  J(N, a);
+  function A() {
+  }
+  function O(c, d, v) {
+    e = e || X(), c = c || {}, typeof v != "boolean" && (v = d instanceof e), this.objectMode = !!c.objectMode, v && (this.objectMode = this.objectMode || !!c.writableObjectMode), this.highWaterMark = g(this, c, "writableHighWaterMark", v), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1;
+    var C = c.decodeStrings === !1;
+    this.decodeStrings = !C, this.defaultEncoding = c.defaultEncoding || "utf8", this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function(P) {
+      _e(d, P);
+    }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.emitClose = c.emitClose !== !1, this.autoDestroy = !!c.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new t(this);
+  }
+  O.prototype.getBuffer = function() {
+    for (var d = this.bufferedRequest, v = []; d; )
+      v.push(d), d = d.next;
+    return v;
+  }, function() {
+    try {
+      Object.defineProperty(O.prototype, "buffer", {
+        get: r.deprecate(function() {
+          return this.getBuffer();
+        }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+      });
+    } catch {
+    }
+  }();
+  var I;
+  typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (I = Function.prototype[Symbol.hasInstance], Object.defineProperty(N, Symbol.hasInstance, {
+    value: function(d) {
+      return I.call(this, d) ? !0 : this !== N ? !1 : d && d._writableState instanceof O;
+    }
+  })) : I = function(d) {
+    return d instanceof this;
+  };
+  function N(c) {
+    e = e || X();
+    var d = this instanceof e;
+    if (!d && !I.call(N, this))
+      return new N(c);
+    this._writableState = new O(c, this, d), this.writable = !0, c && (typeof c.write == "function" && (this._write = c.write), typeof c.writev == "function" && (this._writev = c.writev), typeof c.destroy == "function" && (this._destroy = c.destroy), typeof c.final == "function" && (this._final = c.final)), a.call(this);
+  }
+  N.prototype.pipe = function() {
+    R(this, new S());
+  };
+  function D(c, d) {
+    var v = new T();
+    R(c, v), process.nextTick(d, v);
+  }
+  function B(c, d, v, C) {
+    var P;
+    return v === null ? P = new w() : typeof v != "string" && !d.objectMode && (P = new _("chunk", ["string", "Buffer"], v)), P ? (R(c, P), process.nextTick(C, P), !1) : !0;
+  }
+  N.prototype.write = function(c, d, v) {
+    var C = this._writableState, P = !1, n = !C.objectMode && u(c);
+    return n && !o.isBuffer(c) && (c = f(c)), typeof d == "function" && (v = d, d = null), n ? d = "buffer" : d || (d = C.defaultEncoding), typeof v != "function" && (v = A), C.ending ? D(this, v) : (n || B(this, C, c, v)) && (C.pendingcb++, P = pe(this, C, n, c, d, v)), P;
+  }, N.prototype.cork = function() {
+    this._writableState.corked++;
+  }, N.prototype.uncork = function() {
+    var c = this._writableState;
+    c.corked && (c.corked--, !c.writing && !c.corked && !c.bufferProcessing && c.bufferedRequest && V(this, c));
+  }, N.prototype.setDefaultEncoding = function(d) {
+    if (typeof d == "string" && (d = d.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((d + "").toLowerCase()) > -1))
+      throw new L(d);
+    return this._writableState.defaultEncoding = d, this;
+  }, Object.defineProperty(N.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 Z(c, d, v) {
+    return !c.objectMode && c.decodeStrings !== !1 && typeof d == "string" && (d = o.from(d, v)), d;
+  }
+  Object.defineProperty(N.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 pe(c, d, v, C, P, n) {
+    if (!v) {
+      var i = Z(d, C, P);
+      C !== i && (v = !0, P = "buffer", C = i);
+    }
+    var p = d.objectMode ? 1 : C.length;
+    d.length += p;
+    var E = d.length < d.highWaterMark;
+    if (E || (d.needDrain = !0), d.writing || d.corked) {
+      var j = d.lastBufferedRequest;
+      d.lastBufferedRequest = {
+        chunk: C,
+        encoding: P,
+        isBuf: v,
+        callback: n,
+        next: null
+      }, j ? j.next = d.lastBufferedRequest : d.bufferedRequest = d.lastBufferedRequest, d.bufferedRequestCount += 1;
+    } else
+      $(c, d, !1, p, C, P, n);
+    return E;
+  }
+  function $(c, d, v, C, P, n, i) {
+    d.writelen = C, d.writecb = i, d.writing = !0, d.sync = !0, d.destroyed ? d.onwrite(new b("write")) : v ? c._writev(P, d.onwrite) : c._write(P, n, d.onwrite), d.sync = !1;
+  }
+  function ve(c, d, v, C, P) {
+    --d.pendingcb, v ? (process.nextTick(P, C), process.nextTick(H, c, d), c._writableState.errorEmitted = !0, R(c, C)) : (P(C), c._writableState.errorEmitted = !0, R(c, C), H(c, d));
+  }
+  function ie(c) {
+    c.writing = !1, c.writecb = null, c.length -= c.writelen, c.writelen = 0;
+  }
+  function _e(c, d) {
+    var v = c._writableState, C = v.sync, P = v.writecb;
+    if (typeof P != "function")
+      throw new m();
+    if (ie(v), d)
+      ve(c, v, C, d, P);
+    else {
+      var n = se(v) || c.destroyed;
+      !n && !v.corked && !v.bufferProcessing && v.bufferedRequest && V(c, v), C ? process.nextTick(U, c, v, n, P) : U(c, v, n, P);
+    }
+  }
+  function U(c, d, v, C) {
+    v || ae(c, d), d.pendingcb--, C(), H(c, d);
+  }
+  function ae(c, d) {
+    d.length === 0 && d.needDrain && (d.needDrain = !1, c.emit("drain"));
+  }
+  function V(c, d) {
+    d.bufferProcessing = !0;
+    var v = d.bufferedRequest;
+    if (c._writev && v && v.next) {
+      var C = d.bufferedRequestCount, P = new Array(C), n = d.corkedRequestsFree;
+      n.entry = v;
+      for (var i = 0, p = !0; v; )
+        P[i] = v, v.isBuf || (p = !1), v = v.next, i += 1;
+      P.allBuffers = p, $(c, d, !0, d.length, P, "", n.finish), d.pendingcb++, d.lastBufferedRequest = null, n.next ? (d.corkedRequestsFree = n.next, n.next = null) : d.corkedRequestsFree = new t(d), d.bufferedRequestCount = 0;
+    } else {
+      for (; v; ) {
+        var E = v.chunk, j = v.encoding, x = v.callback, k = d.objectMode ? 1 : E.length;
+        if ($(c, d, !1, k, E, j, x), v = v.next, d.bufferedRequestCount--, d.writing)
+          break;
+      }
+      v === null && (d.lastBufferedRequest = null);
+    }
+    d.bufferedRequest = v, d.bufferProcessing = !1;
+  }
+  N.prototype._write = function(c, d, v) {
+    v(new M("_write()"));
+  }, N.prototype._writev = null, N.prototype.end = function(c, d, v) {
+    var C = this._writableState;
+    return typeof c == "function" ? (v = c, c = null, d = null) : typeof d == "function" && (v = d, d = null), c != null && this.write(c, d), C.corked && (C.corked = 1, this.uncork()), C.ending || ge(this, C, v), this;
+  }, Object.defineProperty(N.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 se(c) {
+    return c.ending && c.length === 0 && c.bufferedRequest === null && !c.finished && !c.writing;
+  }
+  function be(c, d) {
+    c._final(function(v) {
+      d.pendingcb--, v && R(c, v), d.prefinished = !0, c.emit("prefinish"), H(c, d);
+    });
+  }
+  function oe(c, d) {
+    !d.prefinished && !d.finalCalled && (typeof c._final == "function" && !d.destroyed ? (d.pendingcb++, d.finalCalled = !0, process.nextTick(be, c, d)) : (d.prefinished = !0, c.emit("prefinish")));
+  }
+  function H(c, d) {
+    var v = se(d);
+    if (v && (oe(c, d), d.pendingcb === 0 && (d.finished = !0, c.emit("finish"), d.autoDestroy))) {
+      var C = c._readableState;
+      (!C || C.autoDestroy && C.endEmitted) && c.destroy();
+    }
+    return v;
+  }
+  function ge(c, d, v) {
+    d.ending = !0, H(c, d), v && (d.finished ? process.nextTick(v) : c.once("finish", v)), d.ended = !0, c.writable = !1;
+  }
+  function ye(c, d, v) {
+    var C = c.entry;
+    for (c.entry = null; C; ) {
+      var P = C.callback;
+      d.pendingcb--, P(v), C = C.next;
+    }
+    d.corkedRequestsFree.next = c;
+  }
+  return Object.defineProperty(N.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(d) {
+      this._writableState && (this._writableState.destroyed = d);
+    }
+  }), N.prototype.destroy = l.destroy, N.prototype._undestroy = l.undestroy, N.prototype._destroy = function(c, d) {
+    d(c);
+  }, Me;
+}
+var Oe, st;
+function X() {
+  if (st)
+    return Oe;
+  st = 1;
+  var t = Object.keys || function(h) {
+    var g = [];
+    for (var y in h)
+      g.push(y);
+    return g;
+  };
+  Oe = f;
+  var e = Ot(), r = Mt();
+  J(f, e);
+  for (var a = t(r.prototype), o = 0; o < a.length; o++) {
+    var s = a[o];
+    f.prototype[s] || (f.prototype[s] = r.prototype[s]);
+  }
+  function f(h) {
+    if (!(this instanceof f))
+      return new f(h);
+    e.call(this, h), r.call(this, h), this.allowHalfOpen = !0, h && (h.readable === !1 && (this.readable = !1), h.writable === !1 && (this.writable = !1), h.allowHalfOpen === !1 && (this.allowHalfOpen = !1, this.once("end", u)));
+  }
+  Object.defineProperty(f.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(f.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(f.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 u() {
+    this._writableState.ended || process.nextTick(l, this);
+  }
+  function l(h) {
+    h.end();
+  }
+  return Object.defineProperty(f.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(g) {
+      this._readableState === void 0 || this._writableState === void 0 || (this._readableState.destroyed = g, this._writableState.destroyed = g);
+    }
+  }), Oe;
+}
+var Be = {}, We = { exports: {} };
+(function(t, e) {
+  var r = ce, a = r.Buffer;
+  function o(f, u) {
+    for (var l in f)
+      u[l] = f[l];
+  }
+  a.from && a.alloc && a.allocUnsafe && a.allocUnsafeSlow ? t.exports = r : (o(r, e), e.Buffer = s);
+  function s(f, u, l) {
+    return a(f, u, l);
+  }
+  o(a, s), s.from = function(f, u, l) {
+    if (typeof f == "number")
+      throw new TypeError("Argument must not be a number");
+    return a(f, u, l);
+  }, s.alloc = function(f, u, l) {
+    if (typeof f != "number")
+      throw new TypeError("Argument must be a number");
+    var h = a(f);
+    return u !== void 0 ? typeof l == "string" ? h.fill(u, l) : h.fill(u) : h.fill(0), h;
+  }, s.allocUnsafe = function(f) {
+    if (typeof f != "number")
+      throw new TypeError("Argument must be a number");
+    return a(f);
+  }, s.allocUnsafeSlow = function(f) {
+    if (typeof f != "number")
+      throw new TypeError("Argument must be a number");
+    return r.SlowBuffer(f);
+  };
+})(We, We.exports);
+var tr = We.exports, Ve = tr.Buffer, ot = Ve.isEncoding || function(t) {
+  switch (t = "" + t, t && t.toLowerCase()) {
+    case "hex":
+    case "utf8":
+    case "utf-8":
+    case "ascii":
+    case "binary":
+    case "base64":
+    case "ucs2":
+    case "ucs-2":
+    case "utf16le":
+    case "utf-16le":
+    case "raw":
+      return !0;
+    default:
+      return !1;
+  }
+};
+function rr(t) {
+  if (!t)
+    return "utf8";
+  for (var e; ; )
+    switch (t) {
+      case "utf8":
+      case "utf-8":
+        return "utf8";
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return "utf16le";
+      case "latin1":
+      case "binary":
+        return "latin1";
+      case "base64":
+      case "ascii":
+      case "hex":
+        return t;
+      default:
+        if (e)
+          return;
+        t = ("" + t).toLowerCase(), e = !0;
+    }
+}
+function nr(t) {
+  var e = rr(t);
+  if (typeof e != "string" && (Ve.isEncoding === ot || !ot(t)))
+    throw new Error("Unknown encoding: " + t);
+  return e || t;
+}
+var ir = Be.StringDecoder = ne;
+function ne(t) {
+  this.encoding = nr(t);
+  var e;
+  switch (this.encoding) {
+    case "utf16le":
+      this.text = lr, this.end = dr, e = 4;
+      break;
+    case "utf8":
+      this.fillLast = or, e = 4;
+      break;
+    case "base64":
+      this.text = cr, this.end = hr, e = 3;
+      break;
+    default:
+      this.write = pr, this.end = vr;
+      return;
+  }
+  this.lastNeed = 0, this.lastTotal = 0, this.lastChar = Ve.allocUnsafe(e);
+}
+ne.prototype.write = function(t) {
+  if (t.length === 0)
+    return "";
+  var e, r;
+  if (this.lastNeed) {
+    if (e = this.fillLast(t), e === void 0)
+      return "";
+    r = this.lastNeed, this.lastNeed = 0;
+  } else
+    r = 0;
+  return r < t.length ? e ? e + this.text(t, r) : this.text(t, r) : e || "";
+};
+ne.prototype.end = ur;
+ne.prototype.text = fr;
+ne.prototype.fillLast = function(t) {
+  if (this.lastNeed <= t.length)
+    return t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  t.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, t.length), this.lastNeed -= t.length;
+};
+function De(t) {
+  return t <= 127 ? 0 : t >> 5 === 6 ? 2 : t >> 4 === 14 ? 3 : t >> 3 === 30 ? 4 : t >> 6 === 2 ? -1 : -2;
+}
+function ar(t, e, r) {
+  var a = e.length - 1;
+  if (a < r)
+    return 0;
+  var o = De(e[a]);
+  return o >= 0 ? (o > 0 && (t.lastNeed = o - 1), o) : --a < r || o === -2 ? 0 : (o = De(e[a]), o >= 0 ? (o > 0 && (t.lastNeed = o - 2), o) : --a < r || o === -2 ? 0 : (o = De(e[a]), o >= 0 ? (o > 0 && (o === 2 ? o = 0 : t.lastNeed = o - 3), o) : 0));
+}
+function sr(t, e, r) {
+  if ((e[0] & 192) !== 128)
+    return t.lastNeed = 0, "�";
+  if (t.lastNeed > 1 && e.length > 1) {
+    if ((e[1] & 192) !== 128)
+      return t.lastNeed = 1, "�";
+    if (t.lastNeed > 2 && e.length > 2 && (e[2] & 192) !== 128)
+      return t.lastNeed = 2, "�";
+  }
+}
+function or(t) {
+  var e = this.lastTotal - this.lastNeed, r = sr(this, t);
+  if (r !== void 0)
+    return r;
+  if (this.lastNeed <= t.length)
+    return t.copy(this.lastChar, e, 0, this.lastNeed), this.lastChar.toString(this.encoding, 0, this.lastTotal);
+  t.copy(this.lastChar, e, 0, t.length), this.lastNeed -= t.length;
+}
+function fr(t, e) {
+  var r = ar(this, t, e);
+  if (!this.lastNeed)
+    return t.toString("utf8", e);
+  this.lastTotal = r;
+  var a = t.length - (r - this.lastNeed);
+  return t.copy(this.lastChar, 0, a), t.toString("utf8", e, a);
+}
+function ur(t) {
+  var e = t && t.length ? this.write(t) : "";
+  return this.lastNeed ? e + "�" : e;
+}
+function lr(t, e) {
+  if ((t.length - e) % 2 === 0) {
+    var r = t.toString("utf16le", e);
+    if (r) {
+      var a = r.charCodeAt(r.length - 1);
+      if (a >= 55296 && a <= 56319)
+        return this.lastNeed = 2, this.lastTotal = 4, this.lastChar[0] = t[t.length - 2], this.lastChar[1] = t[t.length - 1], r.slice(0, -1);
+    }
+    return r;
+  }
+  return this.lastNeed = 1, this.lastTotal = 2, this.lastChar[0] = t[t.length - 1], t.toString("utf16le", e, t.length - 1);
+}
+function dr(t) {
+  var e = t && t.length ? this.write(t) : "";
+  if (this.lastNeed) {
+    var r = this.lastTotal - this.lastNeed;
+    return e + this.lastChar.toString("utf16le", 0, r);
+  }
+  return e;
+}
+function cr(t, e) {
+  var r = (t.length - e) % 3;
+  return r === 0 ? t.toString("base64", e) : (this.lastNeed = 3 - r, this.lastTotal = 3, r === 1 ? this.lastChar[0] = t[t.length - 1] : (this.lastChar[0] = t[t.length - 2], this.lastChar[1] = t[t.length - 1]), t.toString("base64", e, t.length - r));
+}
+function hr(t) {
+  var e = t && t.length ? this.write(t) : "";
+  return this.lastNeed ? e + this.lastChar.toString("base64", 0, 3 - this.lastNeed) : e;
+}
+function pr(t) {
+  return t.toString(this.encoding);
+}
+function vr(t) {
+  return t && t.length ? this.write(t) : "";
+}
+var xe, ft;
+function Ge() {
+  if (ft)
+    return xe;
+  ft = 1;
+  var t = Q().codes.ERR_STREAM_PREMATURE_CLOSE;
+  function e(s) {
+    var f = !1;
+    return function() {
+      if (!f) {
+        f = !0;
+        for (var u = arguments.length, l = new Array(u), h = 0; h < u; h++)
+          l[h] = arguments[h];
+        s.apply(this, l);
+      }
+    };
+  }
+  function r() {
+  }
+  function a(s) {
+    return s.setHeader && typeof s.abort == "function";
+  }
+  function o(s, f, u) {
+    if (typeof f == "function")
+      return o(s, null, f);
+    f || (f = {}), u = e(u || r);
+    var l = f.readable || f.readable !== !1 && s.readable, h = f.writable || f.writable !== !1 && s.writable, g = function() {
+      s.writable || _();
+    }, y = s._writableState && s._writableState.finished, _ = function() {
+      h = !1, y = !0, l || u.call(s);
+    }, M = s._readableState && s._readableState.endEmitted, m = function() {
+      l = !1, M = !0, h || u.call(s);
+    }, S = function(L) {
+      u.call(s, L);
+    }, b = function() {
+      var L;
+      if (l && !M)
+        return (!s._readableState || !s._readableState.ended) && (L = new t()), u.call(s, L);
+      if (h && !y)
+        return (!s._writableState || !s._writableState.ended) && (L = new t()), u.call(s, L);
+    }, w = function() {
+      s.req.on("finish", _);
+    };
+    return a(s) ? (s.on("complete", _), s.on("abort", b), s.req ? w() : s.on("request", w)) : h && !s._writableState && (s.on("end", g), s.on("close", g)), s.on("end", m), s.on("finish", _), f.error !== !1 && s.on("error", S), s.on("close", b), function() {
+      s.removeListener("complete", _), s.removeListener("abort", b), s.removeListener("request", w), s.req && s.req.removeListener("finish", _), s.removeListener("end", g), s.removeListener("close", g), s.removeListener("finish", _), s.removeListener("end", m), s.removeListener("error", S), s.removeListener("close", b);
+    };
+  }
+  return xe = o, xe;
+}
+var Pe, ut;
+function _r() {
+  if (ut)
+    return Pe;
+  ut = 1;
+  var t;
+  function e(L, R, A) {
+    return R = r(R), R in L ? Object.defineProperty(L, R, { value: A, enumerable: !0, configurable: !0, writable: !0 }) : L[R] = A, L;
+  }
+  function r(L) {
+    var R = a(L, "string");
+    return typeof R == "symbol" ? R : String(R);
+  }
+  function a(L, R) {
+    if (typeof L != "object" || L === null)
+      return L;
+    var A = L[Symbol.toPrimitive];
+    if (A !== void 0) {
+      var O = A.call(L, R || "default");
+      if (typeof O != "object")
+        return O;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return (R === "string" ? String : Number)(L);
+  }
+  var o = Ge(), s = Symbol("lastResolve"), f = Symbol("lastReject"), u = Symbol("error"), l = Symbol("ended"), h = Symbol("lastPromise"), g = Symbol("handlePromise"), y = Symbol("stream");
+  function _(L, R) {
+    return {
+      value: L,
+      done: R
+    };
+  }
+  function M(L) {
+    var R = L[s];
+    if (R !== null) {
+      var A = L[y].read();
+      A !== null && (L[h] = null, L[s] = null, L[f] = null, R(_(A, !1)));
+    }
+  }
+  function m(L) {
+    process.nextTick(M, L);
+  }
+  function S(L, R) {
+    return function(A, O) {
+      L.then(function() {
+        if (R[l]) {
+          A(_(void 0, !0));
+          return;
+        }
+        R[g](A, O);
+      }, O);
+    };
+  }
+  var b = Object.getPrototypeOf(function() {
+  }), w = Object.setPrototypeOf((t = {
+    get stream() {
+      return this[y];
+    },
+    next: function() {
+      var R = this, A = this[u];
+      if (A !== null)
+        return Promise.reject(A);
+      if (this[l])
+        return Promise.resolve(_(void 0, !0));
+      if (this[y].destroyed)
+        return new Promise(function(D, B) {
+          process.nextTick(function() {
+            R[u] ? B(R[u]) : D(_(void 0, !0));
+          });
+        });
+      var O = this[h], I;
+      if (O)
+        I = new Promise(S(O, this));
+      else {
+        var N = this[y].read();
+        if (N !== null)
+          return Promise.resolve(_(N, !1));
+        I = new Promise(this[g]);
+      }
+      return this[h] = I, I;
+    }
+  }, e(t, Symbol.asyncIterator, function() {
+    return this;
+  }), e(t, "return", function() {
+    var R = this;
+    return new Promise(function(A, O) {
+      R[y].destroy(null, function(I) {
+        if (I) {
+          O(I);
+          return;
+        }
+        A(_(void 0, !0));
+      });
+    });
+  }), t), b), T = function(R) {
+    var A, O = Object.create(w, (A = {}, e(A, y, {
+      value: R,
+      writable: !0
+    }), e(A, s, {
+      value: null,
+      writable: !0
+    }), e(A, f, {
+      value: null,
+      writable: !0
+    }), e(A, u, {
+      value: null,
+      writable: !0
+    }), e(A, l, {
+      value: R._readableState.endEmitted,
+      writable: !0
+    }), e(A, g, {
+      value: function(N, D) {
+        var B = O[y].read();
+        B ? (O[h] = null, O[s] = null, O[f] = null, N(_(B, !1))) : (O[s] = N, O[f] = D);
+      },
+      writable: !0
+    }), A));
+    return O[h] = null, o(R, function(I) {
+      if (I && I.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+        var N = O[f];
+        N !== null && (O[h] = null, O[s] = null, O[f] = null, N(I)), O[u] = I;
+        return;
+      }
+      var D = O[s];
+      D !== null && (O[h] = null, O[s] = null, O[f] = null, D(_(void 0, !0))), O[l] = !0;
+    }), R.on("readable", m.bind(null, O)), O;
+  };
+  return Pe = T, Pe;
+}
+var Ne, lt;
+function br() {
+  return lt || (lt = 1, Ne = function() {
+    throw new Error("Readable.from is not available in the browser");
+  }), Ne;
+}
+var qe, dt;
+function Ot() {
+  if (dt)
+    return qe;
+  dt = 1, qe = D;
+  var t;
+  D.ReadableState = N, $e.EventEmitter;
+  var e = function(i, p) {
+    return i.listeners(p).length;
+  }, r = Lt(), a = ce.Buffer, o = (typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function s(n) {
+    return a.from(n);
+  }
+  function f(n) {
+    return a.isBuffer(n) || n instanceof o;
+  }
+  var u = Tt, l;
+  u && u.debuglog ? l = u.debuglog("stream") : l = function() {
+  };
+  var h = Zt(), g = Ct(), y = At(), _ = y.getHighWaterMark, M = Q().codes, m = M.ERR_INVALID_ARG_TYPE, S = M.ERR_STREAM_PUSH_AFTER_EOF, b = M.ERR_METHOD_NOT_IMPLEMENTED, w = M.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, T, L, R;
+  J(D, r);
+  var A = g.errorOrDestroy, O = ["error", "close", "destroy", "pause", "resume"];
+  function I(n, i, p) {
+    if (typeof n.prependListener == "function")
+      return n.prependListener(i, p);
+    !n._events || !n._events[i] ? n.on(i, p) : Array.isArray(n._events[i]) ? n._events[i].unshift(p) : n._events[i] = [p, n._events[i]];
+  }
+  function N(n, i, p) {
+    t = t || X(), n = n || {}, typeof p != "boolean" && (p = i instanceof t), this.objectMode = !!n.objectMode, p && (this.objectMode = this.objectMode || !!n.readableObjectMode), this.highWaterMark = _(this, n, "readableHighWaterMark", p), this.buffer = new h(), 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 = n.emitClose !== !1, this.autoDestroy = !!n.autoDestroy, this.destroyed = !1, this.defaultEncoding = n.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, n.encoding && (T || (T = Be.StringDecoder), this.decoder = new T(n.encoding), this.encoding = n.encoding);
+  }
+  function D(n) {
+    if (t = t || X(), !(this instanceof D))
+      return new D(n);
+    var i = this instanceof t;
+    this._readableState = new N(n, this, i), this.readable = !0, n && (typeof n.read == "function" && (this._read = n.read), typeof n.destroy == "function" && (this._destroy = n.destroy)), r.call(this);
+  }
+  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._readableState === void 0 ? !1 : this._readableState.destroyed;
+    },
+    set: function(i) {
+      this._readableState && (this._readableState.destroyed = i);
+    }
+  }), D.prototype.destroy = g.destroy, D.prototype._undestroy = g.undestroy, D.prototype._destroy = function(n, i) {
+    i(n);
+  }, D.prototype.push = function(n, i) {
+    var p = this._readableState, E;
+    return p.objectMode ? E = !0 : typeof n == "string" && (i = i || p.defaultEncoding, i !== p.encoding && (n = a.from(n, i), i = ""), E = !0), B(this, n, i, !1, E);
+  }, D.prototype.unshift = function(n) {
+    return B(this, n, null, !0, !1);
+  };
+  function B(n, i, p, E, j) {
+    l("readableAddChunk", i);
+    var x = n._readableState;
+    if (i === null)
+      x.reading = !1, _e(n, x);
+    else {
+      var k;
+      if (j || (k = pe(x, i)), k)
+        A(n, k);
+      else if (x.objectMode || i && i.length > 0)
+        if (typeof i != "string" && !x.objectMode && Object.getPrototypeOf(i) !== a.prototype && (i = s(i)), E)
+          x.endEmitted ? A(n, new w()) : Z(n, x, i, !0);
+        else if (x.ended)
+          A(n, new S());
+        else {
+          if (x.destroyed)
+            return !1;
+          x.reading = !1, x.decoder && !p ? (i = x.decoder.write(i), x.objectMode || i.length !== 0 ? Z(n, x, i, !1) : V(n, x)) : Z(n, x, i, !1);
+        }
+      else
+        E || (x.reading = !1, V(n, x));
+    }
+    return !x.ended && (x.length < x.highWaterMark || x.length === 0);
+  }
+  function Z(n, i, p, E) {
+    i.flowing && i.length === 0 && !i.sync ? (i.awaitDrain = 0, n.emit("data", p)) : (i.length += i.objectMode ? 1 : p.length, E ? i.buffer.unshift(p) : i.buffer.push(p), i.needReadable && U(n)), V(n, i);
+  }
+  function pe(n, i) {
+    var p;
+    return !f(i) && typeof i != "string" && i !== void 0 && !n.objectMode && (p = new m("chunk", ["string", "Buffer", "Uint8Array"], i)), p;
+  }
+  D.prototype.isPaused = function() {
+    return this._readableState.flowing === !1;
+  }, D.prototype.setEncoding = function(n) {
+    T || (T = Be.StringDecoder);
+    var i = new T(n);
+    this._readableState.decoder = i, this._readableState.encoding = this._readableState.decoder.encoding;
+    for (var p = this._readableState.buffer.head, E = ""; p !== null; )
+      E += i.write(p.data), p = p.next;
+    return this._readableState.buffer.clear(), E !== "" && this._readableState.buffer.push(E), this._readableState.length = E.length, this;
+  };
+  var $ = 1073741824;
+  function ve(n) {
+    return n >= $ ? n = $ : (n--, n |= n >>> 1, n |= n >>> 2, n |= n >>> 4, n |= n >>> 8, n |= n >>> 16, n++), n;
+  }
+  function ie(n, i) {
+    return n <= 0 || i.length === 0 && i.ended ? 0 : i.objectMode ? 1 : n !== n ? i.flowing && i.length ? i.buffer.head.data.length : i.length : (n > i.highWaterMark && (i.highWaterMark = ve(n)), n <= i.length ? n : i.ended ? i.length : (i.needReadable = !0, 0));
+  }
+  D.prototype.read = function(n) {
+    l("read", n), n = parseInt(n, 10);
+    var i = this._readableState, p = n;
+    if (n !== 0 && (i.emittedReadable = !1), n === 0 && i.needReadable && ((i.highWaterMark !== 0 ? i.length >= i.highWaterMark : i.length > 0) || i.ended))
+      return l("read: emitReadable", i.length, i.ended), i.length === 0 && i.ended ? v(this) : U(this), null;
+    if (n = ie(n, i), n === 0 && i.ended)
+      return i.length === 0 && v(this), null;
+    var E = i.needReadable;
+    l("need readable", E), (i.length === 0 || i.length - n < i.highWaterMark) && (E = !0, l("length less than watermark", E)), i.ended || i.reading ? (E = !1, l("reading or ended", E)) : E && (l("do read"), i.reading = !0, i.sync = !0, i.length === 0 && (i.needReadable = !0), this._read(i.highWaterMark), i.sync = !1, i.reading || (n = ie(p, i)));
+    var j;
+    return n > 0 ? j = d(n, i) : j = null, j === null ? (i.needReadable = i.length <= i.highWaterMark, n = 0) : (i.length -= n, i.awaitDrain = 0), i.length === 0 && (i.ended || (i.needReadable = !0), p !== n && i.ended && v(this)), j !== null && this.emit("data", j), j;
+  };
+  function _e(n, i) {
+    if (l("onEofChunk"), !i.ended) {
+      if (i.decoder) {
+        var p = i.decoder.end();
+        p && p.length && (i.buffer.push(p), i.length += i.objectMode ? 1 : p.length);
+      }
+      i.ended = !0, i.sync ? U(n) : (i.needReadable = !1, i.emittedReadable || (i.emittedReadable = !0, ae(n)));
+    }
+  }
+  function U(n) {
+    var i = n._readableState;
+    l("emitReadable", i.needReadable, i.emittedReadable), i.needReadable = !1, i.emittedReadable || (l("emitReadable", i.flowing), i.emittedReadable = !0, process.nextTick(ae, n));
+  }
+  function ae(n) {
+    var i = n._readableState;
+    l("emitReadable_", i.destroyed, i.length, i.ended), !i.destroyed && (i.length || i.ended) && (n.emit("readable"), i.emittedReadable = !1), i.needReadable = !i.flowing && !i.ended && i.length <= i.highWaterMark, c(n);
+  }
+  function V(n, i) {
+    i.readingMore || (i.readingMore = !0, process.nextTick(se, n, i));
+  }
+  function se(n, i) {
+    for (; !i.reading && !i.ended && (i.length < i.highWaterMark || i.flowing && i.length === 0); ) {
+      var p = i.length;
+      if (l("maybeReadMore read 0"), n.read(0), p === i.length)
+        break;
+    }
+    i.readingMore = !1;
+  }
+  D.prototype._read = function(n) {
+    A(this, new b("_read()"));
+  }, D.prototype.pipe = function(n, i) {
+    var p = this, E = this._readableState;
+    switch (E.pipesCount) {
+      case 0:
+        E.pipes = n;
+        break;
+      case 1:
+        E.pipes = [E.pipes, n];
+        break;
+      default:
+        E.pipes.push(n);
+        break;
+    }
+    E.pipesCount += 1, l("pipe count=%d opts=%j", E.pipesCount, i);
+    var j = (!i || i.end !== !1) && n !== process.stdout && n !== process.stderr, x = j ? G : ee;
+    E.endEmitted ? process.nextTick(x) : p.once("end", x), n.on("unpipe", k);
+    function k(K, Y) {
+      l("onunpipe"), K === p && Y && Y.hasUnpiped === !1 && (Y.hasUnpiped = !0, $t());
+    }
+    function G() {
+      l("onend"), n.end();
+    }
+    var fe = be(p);
+    n.on("drain", fe);
+    var ze = !1;
+    function $t() {
+      l("cleanup"), n.removeListener("close", me), n.removeListener("finish", Ee), n.removeListener("drain", fe), n.removeListener("error", we), n.removeListener("unpipe", k), p.removeListener("end", G), p.removeListener("end", ee), p.removeListener("data", Xe), ze = !0, E.awaitDrain && (!n._writableState || n._writableState.needDrain) && fe();
+    }
+    p.on("data", Xe);
+    function Xe(K) {
+      l("ondata");
+      var Y = n.write(K);
+      l("dest.write", Y), Y === !1 && ((E.pipesCount === 1 && E.pipes === n || E.pipesCount > 1 && P(E.pipes, n) !== -1) && !ze && (l("false write response, pause", E.awaitDrain), E.awaitDrain++), p.pause());
+    }
+    function we(K) {
+      l("onerror", K), ee(), n.removeListener("error", we), e(n, "error") === 0 && A(n, K);
+    }
+    I(n, "error", we);
+    function me() {
+      n.removeListener("finish", Ee), ee();
+    }
+    n.once("close", me);
+    function Ee() {
+      l("onfinish"), n.removeListener("close", me), ee();
+    }
+    n.once("finish", Ee);
+    function ee() {
+      l("unpipe"), p.unpipe(n);
+    }
+    return n.emit("pipe", p), E.flowing || (l("pipe resume"), p.resume()), n;
+  };
+  function be(n) {
+    return function() {
+      var p = n._readableState;
+      l("pipeOnDrain", p.awaitDrain), p.awaitDrain && p.awaitDrain--, p.awaitDrain === 0 && e(n, "data") && (p.flowing = !0, c(n));
+    };
+  }
+  D.prototype.unpipe = function(n) {
+    var i = this._readableState, p = {
+      hasUnpiped: !1
+    };
+    if (i.pipesCount === 0)
+      return this;
+    if (i.pipesCount === 1)
+      return n && n !== i.pipes ? this : (n || (n = i.pipes), i.pipes = null, i.pipesCount = 0, i.flowing = !1, n && n.emit("unpipe", this, p), this);
+    if (!n) {
+      var E = i.pipes, j = i.pipesCount;
+      i.pipes = null, i.pipesCount = 0, i.flowing = !1;
+      for (var x = 0; x < j; x++)
+        E[x].emit("unpipe", this, {
+          hasUnpiped: !1
+        });
+      return this;
+    }
+    var k = P(i.pipes, n);
+    return k === -1 ? this : (i.pipes.splice(k, 1), i.pipesCount -= 1, i.pipesCount === 1 && (i.pipes = i.pipes[0]), n.emit("unpipe", this, p), this);
+  }, D.prototype.on = function(n, i) {
+    var p = r.prototype.on.call(this, n, i), E = this._readableState;
+    return n === "data" ? (E.readableListening = this.listenerCount("readable") > 0, E.flowing !== !1 && this.resume()) : n === "readable" && !E.endEmitted && !E.readableListening && (E.readableListening = E.needReadable = !0, E.flowing = !1, E.emittedReadable = !1, l("on readable", E.length, E.reading), E.length ? U(this) : E.reading || process.nextTick(H, this)), p;
+  }, D.prototype.addListener = D.prototype.on, D.prototype.removeListener = function(n, i) {
+    var p = r.prototype.removeListener.call(this, n, i);
+    return n === "readable" && process.nextTick(oe, this), p;
+  }, D.prototype.removeAllListeners = function(n) {
+    var i = r.prototype.removeAllListeners.apply(this, arguments);
+    return (n === "readable" || n === void 0) && process.nextTick(oe, this), i;
+  };
+  function oe(n) {
+    var i = n._readableState;
+    i.readableListening = n.listenerCount("readable") > 0, i.resumeScheduled && !i.paused ? i.flowing = !0 : n.listenerCount("data") > 0 && n.resume();
+  }
+  function H(n) {
+    l("readable nexttick read 0"), n.read(0);
+  }
+  D.prototype.resume = function() {
+    var n = this._readableState;
+    return n.flowing || (l("resume"), n.flowing = !n.readableListening, ge(this, n)), n.paused = !1, this;
+  };
+  function ge(n, i) {
+    i.resumeScheduled || (i.resumeScheduled = !0, process.nextTick(ye, n, i));
+  }
+  function ye(n, i) {
+    l("resume", i.reading), i.reading || n.read(0), i.resumeScheduled = !1, n.emit("resume"), c(n), i.flowing && !i.reading && n.read(0);
+  }
+  D.prototype.pause = function() {
+    return l("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== !1 && (l("pause"), this._readableState.flowing = !1, this.emit("pause")), this._readableState.paused = !0, this;
+  };
+  function c(n) {
+    var i = n._readableState;
+    for (l("flow", i.flowing); i.flowing && n.read() !== null; )
+      ;
+  }
+  D.prototype.wrap = function(n) {
+    var i = this, p = this._readableState, E = !1;
+    n.on("end", function() {
+      if (l("wrapped end"), p.decoder && !p.ended) {
+        var k = p.decoder.end();
+        k && k.length && i.push(k);
+      }
+      i.push(null);
+    }), n.on("data", function(k) {
+      if (l("wrapped data"), p.decoder && (k = p.decoder.write(k)), !(p.objectMode && k == null) && !(!p.objectMode && (!k || !k.length))) {
+        var G = i.push(k);
+        G || (E = !0, n.pause());
+      }
+    });
+    for (var j in n)
+      this[j] === void 0 && typeof n[j] == "function" && (this[j] = function(G) {
+        return function() {
+          return n[G].apply(n, arguments);
+        };
+      }(j));
+    for (var x = 0; x < O.length; x++)
+      n.on(O[x], this.emit.bind(this, O[x]));
+    return this._read = function(k) {
+      l("wrapped _read", k), E && (E = !1, n.resume());
+    }, this;
+  }, typeof Symbol == "function" && (D.prototype[Symbol.asyncIterator] = function() {
+    return L === void 0 && (L = _r()), L(this);
+  }), Object.defineProperty(D.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(D.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(D.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(i) {
+      this._readableState && (this._readableState.flowing = i);
+    }
+  }), D._fromList = d, Object.defineProperty(D.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 d(n, i) {
+    if (i.length === 0)
+      return null;
+    var p;
+    return i.objectMode ? p = i.buffer.shift() : !n || n >= i.length ? (i.decoder ? p = i.buffer.join("") : i.buffer.length === 1 ? p = i.buffer.first() : p = i.buffer.concat(i.length), i.buffer.clear()) : p = i.buffer.consume(n, i.decoder), p;
+  }
+  function v(n) {
+    var i = n._readableState;
+    l("endReadable", i.endEmitted), i.endEmitted || (i.ended = !0, process.nextTick(C, i, n));
+  }
+  function C(n, i) {
+    if (l("endReadableNT", n.endEmitted, n.length), !n.endEmitted && n.length === 0 && (n.endEmitted = !0, i.readable = !1, i.emit("end"), n.autoDestroy)) {
+      var p = i._writableState;
+      (!p || p.autoDestroy && p.finished) && i.destroy();
+    }
+  }
+  typeof Symbol == "function" && (D.from = function(n, i) {
+    return R === void 0 && (R = br()), R(D, n, i);
+  });
+  function P(n, i) {
+    for (var p = 0, E = n.length; p < E; p++)
+      if (n[p] === i)
+        return p;
+    return -1;
+  }
+  return qe;
+}
+var ke, ct;
+function Dt() {
+  if (ct)
+    return ke;
+  ct = 1, ke = u;
+  var t = Q().codes, e = t.ERR_METHOD_NOT_IMPLEMENTED, r = t.ERR_MULTIPLE_CALLBACK, a = t.ERR_TRANSFORM_ALREADY_TRANSFORMING, o = t.ERR_TRANSFORM_WITH_LENGTH_0, s = X();
+  J(u, s);
+  function f(g, y) {
+    var _ = this._transformState;
+    _.transforming = !1;
+    var M = _.writecb;
+    if (M === null)
+      return this.emit("error", new r());
+    _.writechunk = null, _.writecb = null, y != null && this.push(y), M(g);
+    var m = this._readableState;
+    m.reading = !1, (m.needReadable || m.length < m.highWaterMark) && this._read(m.highWaterMark);
+  }
+  function u(g) {
+    if (!(this instanceof u))
+      return new u(g);
+    s.call(this, g), this._transformState = {
+      afterTransform: f.bind(this),
+      needTransform: !1,
+      transforming: !1,
+      writecb: null,
+      writechunk: null,
+      writeencoding: null
+    }, this._readableState.needReadable = !0, this._readableState.sync = !1, g && (typeof g.transform == "function" && (this._transform = g.transform), typeof g.flush == "function" && (this._flush = g.flush)), this.on("prefinish", l);
+  }
+  function l() {
+    var g = this;
+    typeof this._flush == "function" && !this._readableState.destroyed ? this._flush(function(y, _) {
+      h(g, y, _);
+    }) : h(this, null, null);
+  }
+  u.prototype.push = function(g, y) {
+    return this._transformState.needTransform = !1, s.prototype.push.call(this, g, y);
+  }, u.prototype._transform = function(g, y, _) {
+    _(new e("_transform()"));
+  }, u.prototype._write = function(g, y, _) {
+    var M = this._transformState;
+    if (M.writecb = _, M.writechunk = g, M.writeencoding = y, !M.transforming) {
+      var m = this._readableState;
+      (M.needTransform || m.needReadable || m.length < m.highWaterMark) && this._read(m.highWaterMark);
+    }
+  }, u.prototype._read = function(g) {
+    var y = this._transformState;
+    y.writechunk !== null && !y.transforming ? (y.transforming = !0, this._transform(y.writechunk, y.writeencoding, y.afterTransform)) : y.needTransform = !0;
+  }, u.prototype._destroy = function(g, y) {
+    s.prototype._destroy.call(this, g, function(_) {
+      y(_);
+    });
+  };
+  function h(g, y, _) {
+    if (y)
+      return g.emit("error", y);
+    if (_ != null && g.push(_), g._writableState.length)
+      throw new o();
+    if (g._transformState.transforming)
+      throw new a();
+    return g.push(null);
+  }
+  return ke;
+}
+var je, ht;
+function gr() {
+  if (ht)
+    return je;
+  ht = 1, je = e;
+  var t = Dt();
+  J(e, t);
+  function e(r) {
+    if (!(this instanceof e))
+      return new e(r);
+    t.call(this, r);
+  }
+  return e.prototype._transform = function(r, a, o) {
+    o(null, r);
+  }, je;
+}
+var Ie, pt;
+function yr() {
+  if (pt)
+    return Ie;
+  pt = 1;
+  var t;
+  function e(_) {
+    var M = !1;
+    return function() {
+      M || (M = !0, _.apply(void 0, arguments));
+    };
+  }
+  var r = Q().codes, a = r.ERR_MISSING_ARGS, o = r.ERR_STREAM_DESTROYED;
+  function s(_) {
+    if (_)
+      throw _;
+  }
+  function f(_) {
+    return _.setHeader && typeof _.abort == "function";
+  }
+  function u(_, M, m, S) {
+    S = e(S);
+    var b = !1;
+    _.on("close", function() {
+      b = !0;
+    }), t === void 0 && (t = Ge()), t(_, {
+      readable: M,
+      writable: m
+    }, function(T) {
+      if (T)
+        return S(T);
+      b = !0, S();
+    });
+    var w = !1;
+    return function(T) {
+      if (!b && !w) {
+        if (w = !0, f(_))
+          return _.abort();
+        if (typeof _.destroy == "function")
+          return _.destroy();
+        S(T || new o("pipe"));
+      }
+    };
+  }
+  function l(_) {
+    _();
+  }
+  function h(_, M) {
+    return _.pipe(M);
+  }
+  function g(_) {
+    return !_.length || typeof _[_.length - 1] != "function" ? s : _.pop();
+  }
+  function y() {
+    for (var _ = arguments.length, M = new Array(_), m = 0; m < _; m++)
+      M[m] = arguments[m];
+    var S = g(M);
+    if (Array.isArray(M[0]) && (M = M[0]), M.length < 2)
+      throw new a("streams");
+    var b, w = M.map(function(T, L) {
+      var R = L < M.length - 1, A = L > 0;
+      return u(T, R, A, function(O) {
+        b || (b = O), O && w.forEach(l), !R && (w.forEach(l), S(b));
+      });
+    });
+    return M.reduce(h);
+  }
+  return Ie = y, Ie;
+}
+var xt = F, Ke = $e.EventEmitter, wr = J;
+wr(F, Ke);
+F.Readable = Ot();
+F.Writable = Mt();
+F.Duplex = X();
+F.Transform = Dt();
+F.PassThrough = gr();
+F.finished = Ge();
+F.pipeline = yr();
+F.Stream = F;
+function F() {
+  Ke.call(this);
+}
+F.prototype.pipe = function(t, e) {
+  var r = this;
+  function a(g) {
+    t.writable && t.write(g) === !1 && r.pause && r.pause();
+  }
+  r.on("data", a);
+  function o() {
+    r.readable && r.resume && r.resume();
+  }
+  t.on("drain", o), !t._isStdio && (!e || e.end !== !1) && (r.on("end", f), r.on("close", u));
+  var s = !1;
+  function f() {
+    s || (s = !0, t.end());
+  }
+  function u() {
+    s || (s = !0, typeof t.destroy == "function" && t.destroy());
+  }
+  function l(g) {
+    if (h(), Ke.listenerCount(this, "error") === 0)
+      throw g;
+  }
+  r.on("error", l), t.on("error", l);
+  function h() {
+    r.removeListener("data", a), t.removeListener("drain", o), r.removeListener("end", f), r.removeListener("close", u), r.removeListener("error", l), t.removeListener("error", l), r.removeListener("end", h), r.removeListener("close", h), t.removeListener("close", h);
+  }
+  return r.on("end", h), r.on("close", h), t.on("close", h), t.emit("pipe", r), t;
+};
+function re(t) {
+  return t.replace(/%([0-9A-Fa-f]{2})/g, (e, r) => String.fromCharCode(parseInt(r, 16)));
+}
+function Pt(t, e) {
+  return String(e).replace(t, (r) => `%${r.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`);
+}
+function te(t) {
+  return Pt(/[\n;\r\t=%&,\x00-\x1f\x7f-\xff]/g, t);
+}
+function W(t) {
+  return Pt(/[\n\r\t%\x00-\x1f\x7f-\xff]/g, t);
+}
+function Nt(t) {
+  if (!(t && t.length) || t === ".")
+    return {};
+  const e = {};
+  return t.replace(/\r?\n$/, "").split(";").forEach((r) => {
+    const a = r.split("=", 2);
+    if (!(a[1] && a[1].length))
+      return;
+    a[0] = a[0].trim();
+    let o = e[a[0].trim()];
+    o || (o = [], e[a[0]] = o), o.push(...a[1].split(",").map((s) => s.trim()).map(re));
+  }), e;
+}
+function qt(t) {
+  const e = t.split("	").map((a) => a === "." || a === "" ? null : a);
+  return {
+    seq_id: e[0] && re(e[0]),
+    source: e[1] && re(e[1]),
+    type: e[2] && re(e[2]),
+    start: e[3] === null ? null : parseInt(e[3], 10),
+    end: e[4] === null ? null : parseInt(e[4], 10),
+    score: e[5] === null ? null : parseFloat(e[5]),
+    strand: e[6],
+    phase: e[7],
+    attributes: e[8] === null ? null : Nt(e[8])
+  };
+}
+function kt(t) {
+  const e = /^\s*##\s*(\S+)\s*(.*)/.exec(t);
+  if (!e)
+    return null;
+  const [, r] = e;
+  let [, , a] = e;
+  const o = { directive: r };
+  if (a.length && (a = a.replace(/\r?\n$/, ""), o.value = a), r === "sequence-region") {
+    const s = a.split(/\s+/, 3);
+    return {
+      ...o,
+      seq_id: s[0],
+      start: s[1] && s[1].replace(/\D/g, ""),
+      end: s[2] && s[2].replace(/\D/g, "")
+    };
+  } else if (r === "genome-build") {
+    const [s, f] = a.split(/\s+/, 2);
+    return {
+      ...o,
+      source: s,
+      buildName: f
+    };
+  }
+  return o;
+}
+function jt(t) {
+  const e = [];
+  return Object.entries(t).forEach(([r, a]) => {
+    if (!a)
+      return;
+    let o;
+    a.hasOwnProperty("toString") ? o = te(a.toString()) : Array.isArray(a) ? o = a.map(te).join(",") : o = te(a), e.push(`${te(r)}=${o}`);
+  }), e.length ? e.join(";") : ".";
+}
+function mr(t, e) {
+  const r = t.attributes === null || t.attributes === void 0 ? "." : jt(t.attributes), o = `${[
+    t.seq_id === null ? "." : W(t.seq_id),
+    t.source === null ? "." : W(t.source),
+    t.type === null ? "." : W(t.type),
+    t.start === null ? "." : W(t.start),
+    t.end === null ? "." : W(t.end),
+    t.score === null ? "." : W(t.score),
+    t.strand === null ? "." : W(t.strand),
+    t.phase === null ? "." : W(t.phase),
+    r
+  ].join("	")}
+`;
+  return e[o] ? "" : (e[o] = !0, o);
+}
+function le(t, e) {
+  if (Array.isArray(t))
+    return t.map((a) => le(a, e)).join("");
+  const r = [mr(t, e)];
+  return Er(t) && r.push(...t.child_features.map((a) => le(a, e)), ...t.derived_features.map((a) => le(a, e))), r.join("");
+}
+function It(t) {
+  return le(t, {});
+}
+function Ft(t) {
+  let e = `##${t.directive}`;
+  return t.value && (e += ` ${t.value}`), e += `
+`, e;
+}
+function Bt(t) {
+  return `# ${t.comment}
+`;
+}
+function Ye(t) {
+  return `>${t.id}${t.description ? ` ${t.description}` : ""}
+${t.sequence}
+`;
+}
+function de(t) {
+  function e(r) {
+    return "attributes" in r ? It(r) : "directive" in r ? Ft(r) : "sequence" in r ? Ye(r) : "comment" in r ? Bt(r) : `# (invalid item found during format)
+`;
+  }
+  return Array.isArray(t) ? t.map(e) : e(t);
+}
+function Er(t) {
+  return t.child_features !== void 0 && t.derived_features !== void 0;
+}
+const Sr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  escape: te,
+  escapeColumn: W,
+  formatAttributes: jt,
+  formatComment: Bt,
+  formatDirective: Ft,
+  formatFeature: It,
+  formatItem: de,
+  formatSequence: Ye,
+  parseAttributes: Nt,
+  parseDirective: kt,
+  parseFeature: qt,
+  unescape: re
+}, Symbol.toStringTag, { value: "Module" })), vt = {
+  Parent: "child_features",
+  Derives_from: "derived_features"
+};
+class _t {
+  constructor(e) {
+    this.seqCallback = e, this.currentSequence = void 0;
+  }
+  addLine(e) {
+    const r = /^>\s*(\S+)\s*(.*)/.exec(e);
+    r ? (this._flush(), this.currentSequence = { id: r[1], sequence: "" }, r[2] && (this.currentSequence.description = r[2].trim())) : this.currentSequence && /\S/.test(e) && (this.currentSequence.sequence += e.replace(/\s/g, ""));
+  }
+  _flush() {
+    this.currentSequence && this.seqCallback(this.currentSequence);
+  }
+  finish() {
+    this._flush();
+  }
+}
+class Wt {
+  constructor(e) {
+    this.fastaParser = void 0, this.eof = !1, this.lineNumber = 0, this._underConstructionTopLevel = [], this._underConstructionById = {}, this._completedReferences = {}, this._underConstructionOrphans = {};
+    const r = () => {
+    };
+    this.featureCallback = e.featureCallback || r, this.endCallback = e.endCallback || r, this.commentCallback = e.commentCallback || r, this.errorCallback = e.errorCallback || r, this.directiveCallback = e.directiveCallback || r, this.sequenceCallback = e.sequenceCallback || r, this.disableDerivesFromReferences = e.disableDerivesFromReferences || !1, this.bufferSize = e.bufferSize === void 0 ? 1e3 : e.bufferSize;
+  }
+  addLine(e) {
+    if (this.fastaParser) {
+      this.fastaParser.addLine(e);
+      return;
+    }
+    if (this.eof)
+      return;
+    if (this.lineNumber += 1, /^\s*[^#\s>]/.test(e)) {
+      this._bufferLine(e);
+      return;
+    }
+    const r = /^\s*(#+)(.*)/.exec(e);
+    if (r) {
+      const [, a] = r;
+      let [, , o] = r;
+      if (a.length === 3)
+        this._emitAllUnderConstructionFeatures();
+      else if (a.length === 2) {
+        const s = kt(e);
+        s && (s.directive === "FASTA" ? (this._emitAllUnderConstructionFeatures(), this.eof = !0, this.fastaParser = new _t(this.sequenceCallback)) : this._emitItem(s));
+      } else
+        o = o.replace(/\s*/, ""), this._emitItem({ comment: o });
+    } else if (!/^\s*$/.test(e))
+      if (/^\s*>/.test(e))
+        this._emitAllUnderConstructionFeatures(), this.eof = !0, this.fastaParser = new _t(this.sequenceCallback), this.fastaParser.addLine(e);
+      else {
+        const a = e.replace(/\r?\n?$/g, "");
+        throw new Error(`GFF3 parse error.  Cannot parse '${a}'.`);
+      }
+  }
+  finish() {
+    this._emitAllUnderConstructionFeatures(), this.fastaParser && this.fastaParser.finish(), this.endCallback();
+  }
+  _emitItem(e) {
+    Array.isArray(e) ? this.featureCallback(e) : "directive" in e ? this.directiveCallback(e) : "comment" in e && this.commentCallback(e);
+  }
+  _enforceBufferSizeLimit(e = 0) {
+    const r = (a) => {
+      a && Array.isArray(a) && a[0].attributes && a[0].attributes.ID && a[0].attributes.ID[0] && (a[0].attributes.ID.forEach((s) => {
+        delete this._underConstructionById[s], delete this._completedReferences[s];
+      }), a.forEach((s) => {
+        s.child_features && s.child_features.forEach((f) => r(f)), s.derived_features && s.derived_features.forEach((f) => r(f));
+      }));
+    };
+    for (; this._underConstructionTopLevel.length + e > this.bufferSize; ) {
+      const a = this._underConstructionTopLevel.shift();
+      a && (this._emitItem(a), r(a));
+    }
+  }
+  /**
+   * return all under-construction features, called when we know
+   * there will be no additional data to attach to them
+   */
+  _emitAllUnderConstructionFeatures() {
+    if (this._underConstructionTopLevel.forEach(this._emitItem.bind(this)), this._underConstructionTopLevel = [], this._underConstructionById = {}, this._completedReferences = {}, Array.from(Object.values(this._underConstructionOrphans)).length)
+      throw new Error(`some features reference other features that do not exist in the file (or in the same '###' scope). ${Object.keys(this._underConstructionOrphans)}`);
+  }
+  // do the right thing with a newly-parsed feature line
+  _bufferLine(e) {
+    var r, a, o;
+    const f = {
+      ...qt(e),
+      child_features: [],
+      derived_features: []
+    }, u = ((r = f.attributes) === null || r === void 0 ? void 0 : r.ID) || [], l = ((a = f.attributes) === null || a === void 0 ? void 0 : a.Parent) || [], h = this.disableDerivesFromReferences ? [] : ((o = f.attributes) === null || o === void 0 ? void 0 : o.Derives_from) || [];
+    if (!u.length && !l.length && !h.length) {
+      this._emitItem([f]);
+      return;
+    }
+    let g;
+    u.forEach((y) => {
+      const _ = this._underConstructionById[y];
+      _ ? (_[_.length - 1].type !== f.type && this._parseError(`multi-line feature "${y}" has inconsistent types: "${f.type}", "${_[_.length - 1].type}"`), _.push(f), g = _) : (g = [f], this._enforceBufferSizeLimit(1), !l.length && !h.length && this._underConstructionTopLevel.push(g), this._underConstructionById[y] = g, this._resolveReferencesTo(g, y));
+    }), this._resolveReferencesFrom(g || [f], { Parent: l, Derives_from: h }, u);
+  }
+  _resolveReferencesTo(e, r) {
+    const a = this._underConstructionOrphans[r];
+    a && (e.forEach((o) => {
+      o.child_features.push(...a.Parent);
+    }), e.forEach((o) => {
+      o.derived_features.push(...a.Derives_from);
+    }), delete this._underConstructionOrphans[r]);
+  }
+  _parseError(e) {
+    this.eof = !0, this.errorCallback(`${this.lineNumber}: ${e}`);
+  }
+  _resolveReferencesFrom(e, r, a) {
+    function o(s, f, u) {
+      let l = s[f];
+      l || (l = {}, s[f] = l);
+      const h = l[u] || !1;
+      return l[u] = !0, h;
+    }
+    r.Parent.forEach((s) => {
+      const f = this._underConstructionById[s];
+      if (f) {
+        const u = vt.Parent;
+        a.filter((l) => o(this._completedReferences, l, `Parent,${s}`)).length || f.forEach((l) => {
+          l[u].push(e);
+        });
+      } else {
+        let u = this._underConstructionOrphans[s];
+        u || (u = {
+          Parent: [],
+          Derives_from: []
+        }, this._underConstructionOrphans[s] = u), u.Parent.push(e);
+      }
+    }), r.Derives_from.forEach((s) => {
+      const f = this._underConstructionById[s];
+      if (f) {
+        const u = vt.Derives_from;
+        a.filter((l) => o(this._completedReferences, l, `Derives_from,${s}`)).length || f.forEach((l) => {
+          l[u].push(e);
+        });
+      } else {
+        let u = this._underConstructionOrphans[s];
+        u || (u = {
+          Parent: [],
+          Derives_from: []
+        }, this._underConstructionOrphans[s] = u), u.Derives_from.push(e);
+      }
+    });
+  }
+}
+function Ue(t) {
+  process && process.nextTick ? process.nextTick(t) : t();
+}
+function Ut(t) {
+  const e = {
+    encoding: "utf8",
+    parseFeatures: !0,
+    parseDirectives: !1,
+    parseSequences: !0,
+    parseComments: !1,
+    bufferSize: 1e3,
+    disableDerivesFromReferences: !1,
+    ...t
+  };
+  return t.parseAll && (e.parseFeatures = !0, e.parseDirectives = !0, e.parseComments = !0, e.parseSequences = !0), e;
+}
+class Rr extends xt.Transform {
+  constructor(e = {}) {
+    super({ objectMode: !0 }), this.textBuffer = "";
+    const r = Ut(e);
+    this.encoding = e.encoding || "utf8", this.decoder = new ir();
+    const a = this.push.bind(this);
+    this.parser = new Wt({
+      featureCallback: r.parseFeatures ? a : void 0,
+      directiveCallback: r.parseDirectives ? a : void 0,
+      commentCallback: r.parseComments ? a : void 0,
+      sequenceCallback: r.parseSequences ? a : void 0,
+      errorCallback: (o) => this.emit("error", o),
+      bufferSize: r.bufferSize,
+      disableDerivesFromReferences: r.disableDerivesFromReferences
+    });
+  }
+  _addLine(e) {
+    e && this.parser.addLine(e);
+  }
+  _nextText(e) {
+    const r = (this.textBuffer + e).split(/\r?\n/);
+    this.textBuffer = r.pop() || "", r.forEach((a) => this._addLine(a));
+  }
+  _transform(e, r, a) {
+    this._nextText(this.decoder.write(e)), Ue(a);
+  }
+  _flush(e) {
+    this.decoder.end && this._nextText(this.decoder.end()), this.textBuffer != null && this._addLine(this.textBuffer), this.parser.finish(), Ue(e);
+  }
+}
+function Lr(t = {}) {
+  return new Rr(t);
+}
+function Tr(t, e = {}) {
+  if (!t)
+    return [];
+  const r = Ut(e), a = [], o = a.push.bind(a), s = new Wt({
+    featureCallback: r.parseFeatures ? o : void 0,
+    directiveCallback: r.parseDirectives ? o : void 0,
+    commentCallback: r.parseComments ? o : void 0,
+    sequenceCallback: r.parseSequences ? o : void 0,
+    disableDerivesFromReferences: r.disableDerivesFromReferences || !1,
+    bufferSize: 1 / 0,
+    errorCallback: (f) => {
+      throw f;
+    }
+  });
+  return t.split(/\r?\n/).forEach(s.addLine.bind(s)), s.finish(), a;
+}
+function Cr(t) {
+  const e = [], r = [];
+  t.forEach((o) => {
+    "sequence" in o ? r.push(o) : e.push(o);
+  });
+  let a = e.map(de).join("");
+  return r.length && (a += `##FASTA
+`, a += r.map(Ye).join("")), a;
+}
+class Ht extends xt.Transform {
+  constructor(e = {}) {
+    super(Object.assign(e, { objectMode: !0 })), this.linesSinceLastSyncMark = 0, this.haveWeEmittedData = !1, this.fastaMode = !1, this.minLinesBetweenSyncMarks = e.minSyncLines || 100, this.insertVersionDirective = e.insertVersionDirective || !1;
+  }
+  _transform(e, r, a) {
+    let o;
+    if (!this.haveWeEmittedData && this.insertVersionDirective) {
+      const s = Array.isArray(e) ? e[0] : e;
+      "directive" in s && s.directive !== "gff-version" && this.push(`##gff-version 3
+`);
+    }
+    if ("sequence" in e && !this.fastaMode && (this.push(`##FASTA
+`), this.fastaMode = !0), Array.isArray(e) ? o = e.map(de).join("") : o = de(e), this.push(o), this.linesSinceLastSyncMark >= this.minLinesBetweenSyncMarks)
+      this.push(`###
+`), this.linesSinceLastSyncMark = 0;
+    else {
+      let s = 0;
+      for (let f = 0; f < o.length; f += 1)
+        o[f] === `
+` && (s += 1);
+      this.linesSinceLastSyncMark += s;
+    }
+    this.haveWeEmittedData = !0, Ue(a);
+  }
+}
+function Ar(t = {}) {
+  return new Ht(t);
+}
+function Mr(t, e, r = {}) {
+  const a = {
+    insertVersionDirective: !0,
+    ...r
+  };
+  return new Promise((o, s) => {
+    t.pipe(new Ht(a)).on("end", () => o(null)).on("error", s).pipe(e);
+  });
+}
+const Pr = {
+  parseStream: Lr,
+  parseStringSync: Tr,
+  formatSync: Cr,
+  formatStream: Ar,
+  formatFile: Mr,
+  util: Sr
+};
+export {
+  Pr as default
+};