@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/readable-stream/lib/_stream_readable.mjs

@@ -0,0 +1,366 @@
+import { commonjsGlobal as G } from "../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { e as ge } from "../../events/events.mjs";
+import { s as _e } from "./internal/streams/stream-browser.mjs";
+import "../../buffer/index.mjs";
+import me from "../../../../../../../../_virtual/___vite-browser-external.mjs";
+import { __require as ye } from "./internal/streams/buffer_list.mjs";
+import { d as ve } from "./internal/streams/destroy.mjs";
+import { s as we } from "./internal/streams/state.mjs";
+import "../errors-browser.mjs";
+import { i as Re } from "../../inherits/inherits_browser.mjs";
+import { __require as $ } from "./_stream_duplex.mjs";
+import { __require as Y } from "../../string_decoder/lib/string_decoder.mjs";
+import { __require as Se } from "./internal/streams/async_iterator.mjs";
+import { __require as Ee } from "./internal/streams/from-browser.mjs";
+import { __exports as Me } from "../../../../../../../../_virtual/index78.mjs";
+import { __exports as Le } from "../../../../../../../../_virtual/errors-browser.mjs";
+var W, X;
+function ke() {
+  if (X)
+    return W;
+  X = 1, W = o;
+  var l;
+  o.ReadableState = q, ge.EventEmitter;
+  var x = function(e, i) {
+    return e.listeners(i).length;
+  }, b = _e, _ = Me.Buffer, z = (typeof G < "u" ? G : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function J(r) {
+    return _.from(r);
+  }
+  function K(r) {
+    return _.isBuffer(r) || r instanceof z;
+  }
+  var w = me, n;
+  w && w.debuglog ? n = w.debuglog("stream") : n = function() {
+  };
+  var Q = ye(), R = ve, Z = we, ee = Z.getHighWaterMark, m = Le.codes, re = m.ERR_INVALID_ARG_TYPE, ie = m.ERR_STREAM_PUSH_AFTER_EOF, te = m.ERR_METHOD_NOT_IMPLEMENTED, ne = m.ERR_STREAM_UNSHIFT_AFTER_END_EVENT, s, S, E;
+  Re(o, b);
+  var c = R.errorOrDestroy, M = ["error", "close", "destroy", "pause", "resume"];
+  function ae(r, e, i) {
+    if (typeof r.prependListener == "function")
+      return r.prependListener(e, i);
+    !r._events || !r._events[e] ? r.on(e, i) : Array.isArray(r._events[e]) ? r._events[e].unshift(i) : r._events[e] = [i, r._events[e]];
+  }
+  function q(r, e, i) {
+    l = l || $(), r = r || {}, typeof i != "boolean" && (i = e instanceof l), this.objectMode = !!r.objectMode, i && (this.objectMode = this.objectMode || !!r.readableObjectMode), this.highWaterMark = ee(this, r, "readableHighWaterMark", i), this.buffer = new Q(), 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 = r.emitClose !== !1, this.autoDestroy = !!r.autoDestroy, this.destroyed = !1, this.defaultEncoding = r.defaultEncoding || "utf8", this.awaitDrain = 0, this.readingMore = !1, this.decoder = null, this.encoding = null, r.encoding && (s || (s = Y().StringDecoder), this.decoder = new s(r.encoding), this.encoding = r.encoding);
+  }
+  function o(r) {
+    if (l = l || $(), !(this instanceof o))
+      return new o(r);
+    var e = this instanceof l;
+    this._readableState = new q(r, this, e), this.readable = !0, r && (typeof r.read == "function" && (this._read = r.read), typeof r.destroy == "function" && (this._destroy = r.destroy)), b.call(this);
+  }
+  Object.defineProperty(o.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(e) {
+      this._readableState && (this._readableState.destroyed = e);
+    }
+  }), o.prototype.destroy = R.destroy, o.prototype._undestroy = R.undestroy, o.prototype._destroy = function(r, e) {
+    e(r);
+  }, o.prototype.push = function(r, e) {
+    var i = this._readableState, t;
+    return i.objectMode ? t = !0 : typeof r == "string" && (e = e || i.defaultEncoding, e !== i.encoding && (r = _.from(r, e), e = ""), t = !0), N(this, r, e, !1, t);
+  }, o.prototype.unshift = function(r) {
+    return N(this, r, null, !0, !1);
+  };
+  function N(r, e, i, t, f) {
+    n("readableAddChunk", e);
+    var a = r._readableState;
+    if (e === null)
+      a.reading = !1, fe(r, a);
+    else {
+      var d;
+      if (f || (d = oe(a, e)), d)
+        c(r, d);
+      else if (a.objectMode || e && e.length > 0)
+        if (typeof e != "string" && !a.objectMode && Object.getPrototypeOf(e) !== _.prototype && (e = J(e)), t)
+          a.endEmitted ? c(r, new ne()) : L(r, a, e, !0);
+        else if (a.ended)
+          c(r, new ie());
+        else {
+          if (a.destroyed)
+            return !1;
+          a.reading = !1, a.decoder && !i ? (e = a.decoder.write(e), a.objectMode || e.length !== 0 ? L(r, a, e, !1) : T(r, a)) : L(r, a, e, !1);
+        }
+      else
+        t || (a.reading = !1, T(r, a));
+    }
+    return !a.ended && (a.length < a.highWaterMark || a.length === 0);
+  }
+  function L(r, e, i, t) {
+    e.flowing && e.length === 0 && !e.sync ? (e.awaitDrain = 0, r.emit("data", i)) : (e.length += e.objectMode ? 1 : i.length, t ? e.buffer.unshift(i) : e.buffer.push(i), e.needReadable && y(r)), T(r, e);
+  }
+  function oe(r, e) {
+    var i;
+    return !K(e) && typeof e != "string" && e !== void 0 && !r.objectMode && (i = new re("chunk", ["string", "Buffer", "Uint8Array"], e)), i;
+  }
+  o.prototype.isPaused = function() {
+    return this._readableState.flowing === !1;
+  }, o.prototype.setEncoding = function(r) {
+    s || (s = Y().StringDecoder);
+    var e = new s(r);
+    this._readableState.decoder = e, this._readableState.encoding = this._readableState.decoder.encoding;
+    for (var i = this._readableState.buffer.head, t = ""; i !== null; )
+      t += e.write(i.data), i = i.next;
+    return this._readableState.buffer.clear(), t !== "" && this._readableState.buffer.push(t), this._readableState.length = t.length, this;
+  };
+  var P = 1073741824;
+  function de(r) {
+    return r >= P ? r = P : (r--, r |= r >>> 1, r |= r >>> 2, r |= r >>> 4, r |= r >>> 8, r |= r >>> 16, r++), r;
+  }
+  function U(r, e) {
+    return r <= 0 || e.length === 0 && e.ended ? 0 : e.objectMode ? 1 : r !== r ? e.flowing && e.length ? e.buffer.head.data.length : e.length : (r > e.highWaterMark && (e.highWaterMark = de(r)), r <= e.length ? r : e.ended ? e.length : (e.needReadable = !0, 0));
+  }
+  o.prototype.read = function(r) {
+    n("read", r), r = parseInt(r, 10);
+    var e = this._readableState, i = r;
+    if (r !== 0 && (e.emittedReadable = !1), r === 0 && e.needReadable && ((e.highWaterMark !== 0 ? e.length >= e.highWaterMark : e.length > 0) || e.ended))
+      return n("read: emitReadable", e.length, e.ended), e.length === 0 && e.ended ? C(this) : y(this), null;
+    if (r = U(r, e), r === 0 && e.ended)
+      return e.length === 0 && C(this), null;
+    var t = e.needReadable;
+    n("need readable", t), (e.length === 0 || e.length - r < e.highWaterMark) && (t = !0, n("length less than watermark", t)), e.ended || e.reading ? (t = !1, n("reading or ended", t)) : t && (n("do read"), e.reading = !0, e.sync = !0, e.length === 0 && (e.needReadable = !0), this._read(e.highWaterMark), e.sync = !1, e.reading || (r = U(i, e)));
+    var f;
+    return r > 0 ? f = I(r, e) : f = null, f === null ? (e.needReadable = e.length <= e.highWaterMark, r = 0) : (e.length -= r, e.awaitDrain = 0), e.length === 0 && (e.ended || (e.needReadable = !0), i !== r && e.ended && C(this)), f !== null && this.emit("data", f), f;
+  };
+  function fe(r, e) {
+    if (n("onEofChunk"), !e.ended) {
+      if (e.decoder) {
+        var i = e.decoder.end();
+        i && i.length && (e.buffer.push(i), e.length += e.objectMode ? 1 : i.length);
+      }
+      e.ended = !0, e.sync ? y(r) : (e.needReadable = !1, e.emittedReadable || (e.emittedReadable = !0, F(r)));
+    }
+  }
+  function y(r) {
+    var e = r._readableState;
+    n("emitReadable", e.needReadable, e.emittedReadable), e.needReadable = !1, e.emittedReadable || (n("emitReadable", e.flowing), e.emittedReadable = !0, process.nextTick(F, r));
+  }
+  function F(r) {
+    var e = r._readableState;
+    n("emitReadable_", e.destroyed, e.length, e.ended), !e.destroyed && (e.length || e.ended) && (r.emit("readable"), e.emittedReadable = !1), e.needReadable = !e.flowing && !e.ended && e.length <= e.highWaterMark, D(r);
+  }
+  function T(r, e) {
+    e.readingMore || (e.readingMore = !0, process.nextTick(le, r, e));
+  }
+  function le(r, e) {
+    for (; !e.reading && !e.ended && (e.length < e.highWaterMark || e.flowing && e.length === 0); ) {
+      var i = e.length;
+      if (n("maybeReadMore read 0"), r.read(0), i === e.length)
+        break;
+    }
+    e.readingMore = !1;
+  }
+  o.prototype._read = function(r) {
+    c(this, new te("_read()"));
+  }, o.prototype.pipe = function(r, e) {
+    var i = this, t = this._readableState;
+    switch (t.pipesCount) {
+      case 0:
+        t.pipes = r;
+        break;
+      case 1:
+        t.pipes = [t.pipes, r];
+        break;
+      default:
+        t.pipes.push(r);
+        break;
+    }
+    t.pipesCount += 1, n("pipe count=%d opts=%j", t.pipesCount, e);
+    var f = (!e || e.end !== !1) && r !== process.stdout && r !== process.stderr, a = f ? u : g;
+    t.endEmitted ? process.nextTick(a) : i.once("end", a), r.on("unpipe", d);
+    function d(p, h) {
+      n("onunpipe"), p === i && h && h.hasUnpiped === !1 && (h.hasUnpiped = !0, ce());
+    }
+    function u() {
+      n("onend"), r.end();
+    }
+    var v = se(i);
+    r.on("drain", v);
+    var k = !1;
+    function ce() {
+      n("cleanup"), r.removeListener("close", j), r.removeListener("finish", O), r.removeListener("drain", v), r.removeListener("error", A), r.removeListener("unpipe", d), i.removeListener("end", u), i.removeListener("end", g), i.removeListener("data", V), k = !0, t.awaitDrain && (!r._writableState || r._writableState.needDrain) && v();
+    }
+    i.on("data", V);
+    function V(p) {
+      n("ondata");
+      var h = r.write(p);
+      n("dest.write", h), h === !1 && ((t.pipesCount === 1 && t.pipes === r || t.pipesCount > 1 && B(t.pipes, r) !== -1) && !k && (n("false write response, pause", t.awaitDrain), t.awaitDrain++), i.pause());
+    }
+    function A(p) {
+      n("onerror", p), g(), r.removeListener("error", A), x(r, "error") === 0 && c(r, p);
+    }
+    ae(r, "error", A);
+    function j() {
+      r.removeListener("finish", O), g();
+    }
+    r.once("close", j);
+    function O() {
+      n("onfinish"), r.removeListener("close", j), g();
+    }
+    r.once("finish", O);
+    function g() {
+      n("unpipe"), i.unpipe(r);
+    }
+    return r.emit("pipe", i), t.flowing || (n("pipe resume"), i.resume()), r;
+  };
+  function se(r) {
+    return function() {
+      var i = r._readableState;
+      n("pipeOnDrain", i.awaitDrain), i.awaitDrain && i.awaitDrain--, i.awaitDrain === 0 && x(r, "data") && (i.flowing = !0, D(r));
+    };
+  }
+  o.prototype.unpipe = function(r) {
+    var e = this._readableState, i = {
+      hasUnpiped: !1
+    };
+    if (e.pipesCount === 0)
+      return this;
+    if (e.pipesCount === 1)
+      return r && r !== e.pipes ? this : (r || (r = e.pipes), e.pipes = null, e.pipesCount = 0, e.flowing = !1, r && r.emit("unpipe", this, i), this);
+    if (!r) {
+      var t = e.pipes, f = e.pipesCount;
+      e.pipes = null, e.pipesCount = 0, e.flowing = !1;
+      for (var a = 0; a < f; a++)
+        t[a].emit("unpipe", this, {
+          hasUnpiped: !1
+        });
+      return this;
+    }
+    var d = B(e.pipes, r);
+    return d === -1 ? this : (e.pipes.splice(d, 1), e.pipesCount -= 1, e.pipesCount === 1 && (e.pipes = e.pipes[0]), r.emit("unpipe", this, i), this);
+  }, o.prototype.on = function(r, e) {
+    var i = b.prototype.on.call(this, r, e), t = this._readableState;
+    return r === "data" ? (t.readableListening = this.listenerCount("readable") > 0, t.flowing !== !1 && this.resume()) : r === "readable" && !t.endEmitted && !t.readableListening && (t.readableListening = t.needReadable = !0, t.flowing = !1, t.emittedReadable = !1, n("on readable", t.length, t.reading), t.length ? y(this) : t.reading || process.nextTick(ue, this)), i;
+  }, o.prototype.addListener = o.prototype.on, o.prototype.removeListener = function(r, e) {
+    var i = b.prototype.removeListener.call(this, r, e);
+    return r === "readable" && process.nextTick(H, this), i;
+  }, o.prototype.removeAllListeners = function(r) {
+    var e = b.prototype.removeAllListeners.apply(this, arguments);
+    return (r === "readable" || r === void 0) && process.nextTick(H, this), e;
+  };
+  function H(r) {
+    var e = r._readableState;
+    e.readableListening = r.listenerCount("readable") > 0, e.resumeScheduled && !e.paused ? e.flowing = !0 : r.listenerCount("data") > 0 && r.resume();
+  }
+  function ue(r) {
+    n("readable nexttick read 0"), r.read(0);
+  }
+  o.prototype.resume = function() {
+    var r = this._readableState;
+    return r.flowing || (n("resume"), r.flowing = !r.readableListening, pe(this, r)), r.paused = !1, this;
+  };
+  function pe(r, e) {
+    e.resumeScheduled || (e.resumeScheduled = !0, process.nextTick(he, r, e));
+  }
+  function he(r, e) {
+    n("resume", e.reading), e.reading || r.read(0), e.resumeScheduled = !1, r.emit("resume"), D(r), e.flowing && !e.reading && r.read(0);
+  }
+  o.prototype.pause = function() {
+    return n("call pause flowing=%j", this._readableState.flowing), this._readableState.flowing !== !1 && (n("pause"), this._readableState.flowing = !1, this.emit("pause")), this._readableState.paused = !0, this;
+  };
+  function D(r) {
+    var e = r._readableState;
+    for (n("flow", e.flowing); e.flowing && r.read() !== null; )
+      ;
+  }
+  o.prototype.wrap = function(r) {
+    var e = this, i = this._readableState, t = !1;
+    r.on("end", function() {
+      if (n("wrapped end"), i.decoder && !i.ended) {
+        var d = i.decoder.end();
+        d && d.length && e.push(d);
+      }
+      e.push(null);
+    }), r.on("data", function(d) {
+      if (n("wrapped data"), i.decoder && (d = i.decoder.write(d)), !(i.objectMode && d == null) && !(!i.objectMode && (!d || !d.length))) {
+        var u = e.push(d);
+        u || (t = !0, r.pause());
+      }
+    });
+    for (var f in r)
+      this[f] === void 0 && typeof r[f] == "function" && (this[f] = /* @__PURE__ */ function(u) {
+        return function() {
+          return r[u].apply(r, arguments);
+        };
+      }(f));
+    for (var a = 0; a < M.length; a++)
+      r.on(M[a], this.emit.bind(this, M[a]));
+    return this._read = function(d) {
+      n("wrapped _read", d), t && (t = !1, r.resume());
+    }, this;
+  }, typeof Symbol == "function" && (o.prototype[Symbol.asyncIterator] = function() {
+    return S === void 0 && (S = Se()), S(this);
+  }), Object.defineProperty(o.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(o.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(o.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(e) {
+      this._readableState && (this._readableState.flowing = e);
+    }
+  }), o._fromList = I, Object.defineProperty(o.prototype, "readableLength", {
+    // making it explicit this property is not enumerable
+    // because otherwise some prototype manipulation in
+    // userland will fail
+    enumerable: !1,
+    get: function() {
+      return this._readableState.length;
+    }
+  });
+  function I(r, e) {
+    if (e.length === 0)
+      return null;
+    var i;
+    return e.objectMode ? i = e.buffer.shift() : !r || r >= e.length ? (e.decoder ? i = e.buffer.join("") : e.buffer.length === 1 ? i = e.buffer.first() : i = e.buffer.concat(e.length), e.buffer.clear()) : i = e.buffer.consume(r, e.decoder), i;
+  }
+  function C(r) {
+    var e = r._readableState;
+    n("endReadable", e.endEmitted), e.endEmitted || (e.ended = !0, process.nextTick(be, e, r));
+  }
+  function be(r, e) {
+    if (n("endReadableNT", r.endEmitted, r.length), !r.endEmitted && r.length === 0 && (r.endEmitted = !0, e.readable = !1, e.emit("end"), r.autoDestroy)) {
+      var i = e._writableState;
+      (!i || i.autoDestroy && i.finished) && e.destroy();
+    }
+  }
+  typeof Symbol == "function" && (o.from = function(r, e) {
+    return E === void 0 && (E = Ee()), E(o, r, e);
+  });
+  function B(r, e) {
+    for (var i = 0, t = r.length; i < t; i++)
+      if (r[i] === e)
+        return i;
+    return -1;
+  }
+  return W;
+}
+export {
+  ke as __require
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/readable-stream/lib/_stream_transform.mjs

@@ -0,0 +1,68 @@
+import "../errors-browser.mjs";
+import { __require as _ } from "./_stream_duplex.mjs";
+import { i as h } from "../../inherits/inherits_browser.mjs";
+import { __exports as l } from "../../../../../../../../_virtual/errors-browser.mjs";
+var M = i, s = l.codes, u = s.ERR_METHOD_NOT_IMPLEMENTED, c = s.ERR_MULTIPLE_CALLBACK, m = s.ERR_TRANSFORM_ALREADY_TRANSFORMING, R = s.ERR_TRANSFORM_WITH_LENGTH_0, f = _();
+h(i, f);
+function d(r, t) {
+  var e = this._transformState;
+  e.transforming = !1;
+  var a = e.writecb;
+  if (a === null)
+    return this.emit("error", new c());
+  e.writechunk = null, e.writecb = null, t != null && this.push(t), a(r);
+  var n = this._readableState;
+  n.reading = !1, (n.needReadable || n.length < n.highWaterMark) && this._read(n.highWaterMark);
+}
+function i(r) {
+  if (!(this instanceof i))
+    return new i(r);
+  f.call(this, r), this._transformState = {
+    afterTransform: d.bind(this),
+    needTransform: !1,
+    transforming: !1,
+    writecb: null,
+    writechunk: null,
+    writeencoding: null
+  }, this._readableState.needReadable = !0, this._readableState.sync = !1, r && (typeof r.transform == "function" && (this._transform = r.transform), typeof r.flush == "function" && (this._flush = r.flush)), this.on("prefinish", p);
+}
+function p() {
+  var r = this;
+  typeof this._flush == "function" && !this._readableState.destroyed ? this._flush(function(t, e) {
+    o(r, t, e);
+  }) : o(this, null, null);
+}
+i.prototype.push = function(r, t) {
+  return this._transformState.needTransform = !1, f.prototype.push.call(this, r, t);
+};
+i.prototype._transform = function(r, t, e) {
+  e(new u("_transform()"));
+};
+i.prototype._write = function(r, t, e) {
+  var a = this._transformState;
+  if (a.writecb = e, a.writechunk = r, a.writeencoding = t, !a.transforming) {
+    var n = this._readableState;
+    (a.needTransform || n.needReadable || n.length < n.highWaterMark) && this._read(n.highWaterMark);
+  }
+};
+i.prototype._read = function(r) {
+  var t = this._transformState;
+  t.writechunk !== null && !t.transforming ? (t.transforming = !0, this._transform(t.writechunk, t.writeencoding, t.afterTransform)) : t.needTransform = !0;
+};
+i.prototype._destroy = function(r, t) {
+  f.prototype._destroy.call(this, r, function(e) {
+    t(e);
+  });
+};
+function o(r, t, e) {
+  if (t)
+    return r.emit("error", t);
+  if (e != null && r.push(e), r._writableState.length)
+    throw new R();
+  if (r._transformState.transforming)
+    throw new m();
+  return r.push(null);
+}
+export {
+  M as _
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/readable-stream/lib/_stream_writable.mjs

@@ -0,0 +1,246 @@
+import { commonjsGlobal as q } from "../../../../../../../../_virtual/_commonjsHelpers.mjs";
+import { b as ne } from "../../util-deprecate/browser.mjs";
+import { s as fe } from "./internal/streams/stream-browser.mjs";
+import "../../buffer/index.mjs";
+import { d as oe } from "./internal/streams/destroy.mjs";
+import { s as ue } from "./internal/streams/state.mjs";
+import "../errors-browser.mjs";
+import { i as le } from "../../inherits/inherits_browser.mjs";
+import { __require as A } from "./_stream_duplex.mjs";
+import { __exports as se } from "../../../../../../../../_virtual/index78.mjs";
+import { __exports as ae } from "../../../../../../../../_virtual/errors-browser.mjs";
+var E, D;
+function ve() {
+  if (D)
+    return E;
+  D = 1, E = f;
+  function g(r) {
+    var e = this;
+    this.next = null, this.entry = null, this.finish = function() {
+      re(e, r);
+    };
+  }
+  var s;
+  f.WritableState = d;
+  var B = {
+    deprecate: ne
+  }, v = fe, w = se.Buffer, m = (typeof q < "u" ? q : typeof window < "u" ? window : typeof self < "u" ? self : {}).Uint8Array || function() {
+  };
+  function x(r) {
+    return w.from(r);
+  }
+  function N(r) {
+    return w.isBuffer(r) || r instanceof m;
+  }
+  var y = oe, O = ue, C = O.getHighWaterMark, u = ae.codes, P = u.ERR_INVALID_ARG_TYPE, I = u.ERR_METHOD_NOT_IMPLEMENTED, L = u.ERR_MULTIPLE_CALLBACK, k = u.ERR_STREAM_CANNOT_PIPE, W = u.ERR_STREAM_DESTROYED, j = u.ERR_STREAM_NULL_VALUES, U = u.ERR_STREAM_WRITE_AFTER_END, F = u.ERR_UNKNOWN_ENCODING, a = y.errorOrDestroy;
+  le(f, v);
+  function H() {
+  }
+  function d(r, e, t) {
+    s = s || A(), r = r || {}, typeof t != "boolean" && (t = e instanceof s), this.objectMode = !!r.objectMode, t && (this.objectMode = this.objectMode || !!r.writableObjectMode), this.highWaterMark = C(this, r, "writableHighWaterMark", t), this.finalCalled = !1, this.needDrain = !1, this.ending = !1, this.ended = !1, this.finished = !1, this.destroyed = !1;
+    var i = r.decodeStrings === !1;
+    this.decodeStrings = !i, this.defaultEncoding = r.defaultEncoding || "utf8", this.length = 0, this.writing = !1, this.corked = 0, this.sync = !0, this.bufferProcessing = !1, this.onwrite = function(n) {
+      J(e, n);
+    }, this.writecb = null, this.writelen = 0, this.bufferedRequest = null, this.lastBufferedRequest = null, this.pendingcb = 0, this.prefinished = !1, this.errorEmitted = !1, this.emitClose = r.emitClose !== !1, this.autoDestroy = !!r.autoDestroy, this.bufferedRequestCount = 0, this.corkedRequestsFree = new g(this);
+  }
+  d.prototype.getBuffer = function() {
+    for (var e = this.bufferedRequest, t = []; e; )
+      t.push(e), e = e.next;
+    return t;
+  }, function() {
+    try {
+      Object.defineProperty(d.prototype, "buffer", {
+        get: B.deprecate(function() {
+          return this.getBuffer();
+        }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+      });
+    } catch {
+    }
+  }();
+  var b;
+  typeof Symbol == "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] == "function" ? (b = Function.prototype[Symbol.hasInstance], Object.defineProperty(f, Symbol.hasInstance, {
+    value: function(e) {
+      return b.call(this, e) ? !0 : this !== f ? !1 : e && e._writableState instanceof d;
+    }
+  })) : b = function(e) {
+    return e instanceof this;
+  };
+  function f(r) {
+    s = s || A();
+    var e = this instanceof s;
+    if (!e && !b.call(f, this))
+      return new f(r);
+    this._writableState = new d(r, this, e), this.writable = !0, r && (typeof r.write == "function" && (this._write = r.write), typeof r.writev == "function" && (this._writev = r.writev), typeof r.destroy == "function" && (this._destroy = r.destroy), typeof r.final == "function" && (this._final = r.final)), v.call(this);
+  }
+  f.prototype.pipe = function() {
+    a(this, new k());
+  };
+  function G(r, e) {
+    var t = new U();
+    a(r, t), process.nextTick(e, t);
+  }
+  function K(r, e, t, i) {
+    var n;
+    return t === null ? n = new j() : typeof t != "string" && !e.objectMode && (n = new P("chunk", ["string", "Buffer"], t)), n ? (a(r, n), process.nextTick(i, n), !1) : !0;
+  }
+  f.prototype.write = function(r, e, t) {
+    var i = this._writableState, n = !1, o = !i.objectMode && N(r);
+    return o && !w.isBuffer(r) && (r = x(r)), typeof e == "function" && (t = e, e = null), o ? e = "buffer" : e || (e = i.defaultEncoding), typeof t != "function" && (t = H), i.ending ? G(this, t) : (o || K(this, i, r, t)) && (i.pendingcb++, n = Y(this, i, o, r, e, t)), n;
+  }, f.prototype.cork = function() {
+    this._writableState.corked++;
+  }, f.prototype.uncork = function() {
+    var r = this._writableState;
+    r.corked && (r.corked--, !r.writing && !r.corked && !r.bufferProcessing && r.bufferedRequest && M(this, r));
+  }, f.prototype.setDefaultEncoding = function(e) {
+    if (typeof e == "string" && (e = e.toLowerCase()), !(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((e + "").toLowerCase()) > -1))
+      throw new F(e);
+    return this._writableState.defaultEncoding = e, this;
+  }, 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();
+    }
+  });
+  function V(r, e, t) {
+    return !r.objectMode && r.decodeStrings !== !1 && typeof e == "string" && (e = w.from(e, t)), e;
+  }
+  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;
+    }
+  });
+  function Y(r, e, t, i, n, o) {
+    if (!t) {
+      var l = V(e, i, n);
+      i !== l && (t = !0, n = "buffer", i = l);
+    }
+    var h = e.objectMode ? 1 : i.length;
+    e.length += h;
+    var _ = e.length < e.highWaterMark;
+    if (_ || (e.needDrain = !0), e.writing || e.corked) {
+      var p = e.lastBufferedRequest;
+      e.lastBufferedRequest = {
+        chunk: i,
+        encoding: n,
+        isBuf: t,
+        callback: o,
+        next: null
+      }, p ? p.next = e.lastBufferedRequest : e.bufferedRequest = e.lastBufferedRequest, e.bufferedRequestCount += 1;
+    } else
+      R(r, e, !1, h, i, n, o);
+    return _;
+  }
+  function R(r, e, t, i, n, o, l) {
+    e.writelen = i, e.writecb = l, e.writing = !0, e.sync = !0, e.destroyed ? e.onwrite(new W("write")) : t ? r._writev(n, e.onwrite) : r._write(n, o, e.onwrite), e.sync = !1;
+  }
+  function $(r, e, t, i, n) {
+    --e.pendingcb, t ? (process.nextTick(n, i), process.nextTick(c, r, e), r._writableState.errorEmitted = !0, a(r, i)) : (n(i), r._writableState.errorEmitted = !0, a(r, i), c(r, e));
+  }
+  function z(r) {
+    r.writing = !1, r.writecb = null, r.length -= r.writelen, r.writelen = 0;
+  }
+  function J(r, e) {
+    var t = r._writableState, i = t.sync, n = t.writecb;
+    if (typeof n != "function")
+      throw new L();
+    if (z(t), e)
+      $(r, t, i, e, n);
+    else {
+      var o = T(t) || r.destroyed;
+      !o && !t.corked && !t.bufferProcessing && t.bufferedRequest && M(r, t), i ? process.nextTick(S, r, t, o, n) : S(r, t, o, n);
+    }
+  }
+  function S(r, e, t, i) {
+    t || Q(r, e), e.pendingcb--, i(), c(r, e);
+  }
+  function Q(r, e) {
+    e.length === 0 && e.needDrain && (e.needDrain = !1, r.emit("drain"));
+  }
+  function M(r, e) {
+    e.bufferProcessing = !0;
+    var t = e.bufferedRequest;
+    if (r._writev && t && t.next) {
+      var i = e.bufferedRequestCount, n = new Array(i), o = e.corkedRequestsFree;
+      o.entry = t;
+      for (var l = 0, h = !0; t; )
+        n[l] = t, t.isBuf || (h = !1), t = t.next, l += 1;
+      n.allBuffers = h, R(r, e, !0, e.length, n, "", o.finish), e.pendingcb++, e.lastBufferedRequest = null, o.next ? (e.corkedRequestsFree = o.next, o.next = null) : e.corkedRequestsFree = new g(e), e.bufferedRequestCount = 0;
+    } else {
+      for (; t; ) {
+        var _ = t.chunk, p = t.encoding, te = t.callback, ie = e.objectMode ? 1 : _.length;
+        if (R(r, e, !1, ie, _, p, te), t = t.next, e.bufferedRequestCount--, e.writing)
+          break;
+      }
+      t === null && (e.lastBufferedRequest = null);
+    }
+    e.bufferedRequest = t, e.bufferProcessing = !1;
+  }
+  f.prototype._write = function(r, e, t) {
+    t(new I("_write()"));
+  }, f.prototype._writev = null, f.prototype.end = function(r, e, t) {
+    var i = this._writableState;
+    return typeof r == "function" ? (t = r, r = null, e = null) : typeof e == "function" && (t = e, e = null), r != null && this.write(r, e), i.corked && (i.corked = 1, this.uncork()), i.ending || ee(this, i, t), this;
+  }, 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 T(r) {
+    return r.ending && r.length === 0 && r.bufferedRequest === null && !r.finished && !r.writing;
+  }
+  function X(r, e) {
+    r._final(function(t) {
+      e.pendingcb--, t && a(r, t), e.prefinished = !0, r.emit("prefinish"), c(r, e);
+    });
+  }
+  function Z(r, e) {
+    !e.prefinished && !e.finalCalled && (typeof r._final == "function" && !e.destroyed ? (e.pendingcb++, e.finalCalled = !0, process.nextTick(X, r, e)) : (e.prefinished = !0, r.emit("prefinish")));
+  }
+  function c(r, e) {
+    var t = T(e);
+    if (t && (Z(r, e), e.pendingcb === 0 && (e.finished = !0, r.emit("finish"), e.autoDestroy))) {
+      var i = r._readableState;
+      (!i || i.autoDestroy && i.endEmitted) && r.destroy();
+    }
+    return t;
+  }
+  function ee(r, e, t) {
+    e.ending = !0, c(r, e), t && (e.finished ? process.nextTick(t) : r.once("finish", t)), e.ended = !0, r.writable = !1;
+  }
+  function re(r, e, t) {
+    var i = r.entry;
+    for (r.entry = null; i; ) {
+      var n = i.callback;
+      e.pendingcb--, n(t), i = i.next;
+    }
+    e.corkedRequestsFree.next = r;
+  }
+  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._writableState === void 0 ? !1 : this._writableState.destroyed;
+    },
+    set: function(e) {
+      this._writableState && (this._writableState.destroyed = e);
+    }
+  }), f.prototype.destroy = y.destroy, f.prototype._undestroy = y.undestroy, f.prototype._destroy = function(r, e) {
+    e(r);
+  }, E;
+}
+export {
+  ve as __require
+};