@genome-spy/app 0.57.0 → 0.58.1

package/dist/index-CalimFw3.js

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