lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.189.mjs

@@ -1,47 +1,1090 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
-import { g as r } from "./Package.internal.8.mjs";
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import { c as t } from "./Package.internal.8.mjs";
 
-import { r as e } from "./Package.internal.126.mjs";
+import { _ as e } from "./Package.internal.88.mjs";
 
-import { h as t } from "./Package.internal.112.mjs";
+import { f as i } from "./Package.internal.91.mjs";
 
-var o = e;
+import { t as a } from "./Package.internal.190.mjs";
 
-var a = t;
+const {EventEmitter: s} = e;
 
-const n = r => r === "__proto__" || r === "constructor" || r === "prototype";
+const r = new Error("Stream was destroyed");
 
-const s = r => {
-    if (n(r)) {
-        throw new Error(`Cannot set unsafe key: "${r}"`);
+const n = new Error("Premature close");
+
+const l = i;
+
+const u = a;
+
+const h = typeof queueMicrotask === "undefined" ? e => t.process.nextTick(e) : queueMicrotask;
+
+const d = (1 << 29) - 1;
+
+const o = 1;
+
+const f = 2;
+
+const p = 4;
+
+const c = 8;
+
+const _ = d ^ o;
+
+const S = d ^ f;
+
+const x = 1 << 4;
+
+const b = 2 << 4;
+
+const m = 4 << 4;
+
+const w = 8 << 4;
+
+const y = 16 << 4;
+
+const g = 32 << 4;
+
+const k = 64 << 4;
+
+const T = 128 << 4;
+
+const N = 256 << 4;
+
+const P = 512 << 4;
+
+const W = 1024 << 4;
+
+const v = 2048 << 4;
+
+const L = 4096 << 4;
+
+const M = 8192 << 4;
+
+const E = y | g;
+
+const R = x | L;
+
+const q = m | x;
+
+const A = N | w;
+
+const U = y | M;
+
+const C = d ^ x;
+
+const D = d ^ m;
+
+const F = d ^ (m | L);
+
+const I = d ^ L;
+
+const j = d ^ y;
+
+const B = d ^ (w | P);
+
+const O = d ^ k;
+
+const z = d ^ E;
+
+const G = d ^ v;
+
+const H = d ^ b;
+
+const J = d ^ M;
+
+const K = d ^ U;
+
+const Q = 1 << 18;
+
+const V = 2 << 18;
+
+const X = 4 << 18;
+
+const Y = 8 << 18;
+
+const Z = 16 << 18;
+
+const $ = 32 << 18;
+
+const tt = 64 << 18;
+
+const et = 128 << 18;
+
+const it = 256 << 18;
+
+const at = 512 << 18;
+
+const st = 1024 << 18;
+
+const rt = d ^ (Q | it);
+
+const nt = d ^ X;
+
+const lt = d ^ (Q | at);
+
+const ut = d ^ Z;
+
+const ht = d ^ Y;
+
+const dt = d ^ et;
+
+const ot = d ^ V;
+
+const ft = d ^ st;
+
+const pt = x | Q;
+
+const ct = d ^ pt;
+
+const _t = W | $;
+
+const St = p | c | f;
+
+const xt = St | o;
+
+const bt = St | _t;
+
+const mt = nt & D;
+
+const wt = et | v;
+
+const yt = wt & ct;
+
+const gt = xt | yt;
+
+const kt = xt | k | W;
+
+const Tt = xt | W | w;
+
+const Nt = xt | k | w;
+
+const Pt = xt | N | w | P;
+
+const Wt = xt | x | k | W | L | M;
+
+const vt = St | k | W;
+
+const Lt = b | xt | v | m;
+
+const Mt = v | o;
+
+const Et = xt | at | $;
+
+const Rt = Y | Z;
+
+const qt = Y | Q;
+
+const At = Y | Z | xt | Q;
+
+const Ut = xt | Q | Y | st;
+
+const Ct = X | Q;
+
+const Dt = Q | it;
+
+const Ft = xt | at | qt | $;
+
+const It = Z | St | at | $;
+
+const jt = V | xt | et | X;
+
+const Bt = at | $ | St;
+
+const Ot = Symbol.asyncIterator || Symbol("asyncIterator");
+
+class WritableState {
+    constructor(t, {highWaterMark: e = 16384, map: i = null, mapWritable: a, byteLength: s, byteLengthWritable: r} = {}) {
+        this.stream = t;
+        this.queue = new l;
+        this.highWaterMark = e;
+        this.buffered = 0;
+        this.error = null;
+        this.pipeline = null;
+        this.drains = null;
+        this.byteLength = r || s || fe;
+        this.map = a || i;
+        this.afterWrite = Jt.bind(this);
+        this.afterUpdateNextTick = Vt.bind(this);
     }
-};
+    get ended() {
+        return (this.stream._duplexState & $) !== 0;
+    }
+    push(t) {
+        if ((this.stream._duplexState & Bt) !== 0) return false;
+        if (this.map !== null) t = this.map(t);
+        this.buffered += this.byteLength(t);
+        this.queue.push(t);
+        if (this.buffered < this.highWaterMark) {
+            this.stream._duplexState |= Y;
+            return true;
+        }
+        this.stream._duplexState |= Rt;
+        return false;
+    }
+    shift() {
+        const t = this.queue.shift();
+        this.buffered -= this.byteLength(t);
+        if (this.buffered === 0) this.stream._duplexState &= ht;
+        return t;
+    }
+    end(t) {
+        if (typeof t === "function") this.stream.once("finish", t); else if (t !== undefined && t !== null) this.push(t);
+        this.stream._duplexState = (this.stream._duplexState | at) & nt;
+    }
+    autoBatch(t, e) {
+        const i = [];
+        const a = this.stream;
+        i.push(t);
+        while ((a._duplexState & Ut) === qt) {
+            i.push(a._writableState.shift());
+        }
+        if ((a._duplexState & xt) !== 0) return e(null);
+        a._writev(i, e);
+    }
+    update() {
+        const t = this.stream;
+        t._duplexState |= V;
+        do {
+            while ((t._duplexState & Ut) === Y) {
+                const e = this.shift();
+                t._duplexState |= Dt;
+                t._write(e, this.afterWrite);
+            }
+            if ((t._duplexState & Ct) === 0) this.updateNonPrimary();
+        } while (this.continueUpdate() === true);
+        t._duplexState &= ot;
+    }
+    updateNonPrimary() {
+        const t = this.stream;
+        if ((t._duplexState & Ft) === at) {
+            t._duplexState = t._duplexState | Q;
+            t._final(Gt.bind(this));
+            return;
+        }
+        if ((t._duplexState & St) === p) {
+            if ((t._duplexState & wt) === 0) {
+                t._duplexState |= pt;
+                t._destroy(Ht.bind(this));
+            }
+            return;
+        }
+        if ((t._duplexState & gt) === o) {
+            t._duplexState = (t._duplexState | pt) & _;
+            t._open(Yt.bind(this));
+        }
+    }
+    continueUpdate() {
+        if ((this.stream._duplexState & et) === 0) return false;
+        this.stream._duplexState &= dt;
+        return true;
+    }
+    updateCallback() {
+        if ((this.stream._duplexState & jt) === X) this.update(); else this.updateNextTick();
+    }
+    updateNextTick() {
+        if ((this.stream._duplexState & et) !== 0) return;
+        this.stream._duplexState |= et;
+        if ((this.stream._duplexState & V) === 0) h(this.afterUpdateNextTick);
+    }
+}
 
-var i = function r(e, t) {
-    if (!o(e)) {
-        throw new TypeError("expected an object.");
+class ReadableState {
+    constructor(t, {highWaterMark: e = 16384, map: i = null, mapReadable: a, byteLength: s, byteLengthReadable: r} = {}) {
+        this.stream = t;
+        this.queue = new l;
+        this.highWaterMark = e === 0 ? 1 : e;
+        this.buffered = 0;
+        this.readAhead = e > 0;
+        this.error = null;
+        this.pipeline = null;
+        this.byteLength = r || s || fe;
+        this.map = a || i;
+        this.pipeTo = null;
+        this.afterRead = Kt.bind(this);
+        this.afterUpdateNextTick = Qt.bind(this);
+    }
+    get ended() {
+        return (this.stream._duplexState & W) !== 0;
+    }
+    pipe(t, e) {
+        if (this.pipeTo !== null) throw new Error("Can only pipe to one destination");
+        if (typeof e !== "function") e = null;
+        this.stream._duplexState |= g;
+        this.pipeTo = t;
+        this.pipeline = new Pipeline(this.stream, t, e);
+        if (e) this.stream.on("error", pe);
+        if (re(t)) {
+            t._writableState.pipeline = this.pipeline;
+            if (e) t.on("error", pe);
+            t.on("finish", this.pipeline.finished.bind(this.pipeline));
+        } else {
+            const e = this.pipeline.done.bind(this.pipeline, t);
+            const i = this.pipeline.done.bind(this.pipeline, t, null);
+            t.on("error", e);
+            t.on("close", i);
+            t.on("finish", this.pipeline.finished.bind(this.pipeline));
+        }
+        t.on("drain", zt.bind(this));
+        this.stream.emit("piping", t);
+        t.emit("pipe", this.stream);
+    }
+    push(t) {
+        const e = this.stream;
+        if (t === null) {
+            this.highWaterMark = 0;
+            e._duplexState = (e._duplexState | k) & F;
+            return false;
+        }
+        if (this.map !== null) {
+            t = this.map(t);
+            if (t === null) {
+                e._duplexState &= I;
+                return this.buffered < this.highWaterMark;
+            }
+        }
+        this.buffered += this.byteLength(t);
+        this.queue.push(t);
+        e._duplexState = (e._duplexState | w) & I;
+        return this.buffered < this.highWaterMark;
+    }
+    shift() {
+        const t = this.queue.shift();
+        this.buffered -= this.byteLength(t);
+        if (this.buffered === 0) this.stream._duplexState &= B;
+        return t;
+    }
+    unshift(t) {
+        const e = [ this.map !== null ? this.map(t) : t ];
+        while (this.buffered > 0) e.push(this.shift());
+        for (let t = 0; t < e.length - 1; t++) {
+            const i = e[t];
+            this.buffered += this.byteLength(i);
+            this.queue.push(i);
+        }
+        this.push(e[e.length - 1]);
+    }
+    read() {
+        const t = this.stream;
+        if ((t._duplexState & Tt) === w) {
+            const e = this.shift();
+            if (this.pipeTo !== null && this.pipeTo.write(e) === false) t._duplexState &= z;
+            if ((t._duplexState & T) !== 0) t.emit("data", e);
+            return e;
+        }
+        if (this.readAhead === false) {
+            t._duplexState |= M;
+            this.updateNextTick();
+        }
+        return null;
+    }
+    drain() {
+        const t = this.stream;
+        while ((t._duplexState & Tt) === w && (t._duplexState & E) !== 0) {
+            const e = this.shift();
+            if (this.pipeTo !== null && this.pipeTo.write(e) === false) t._duplexState &= z;
+            if ((t._duplexState & T) !== 0) t.emit("data", e);
+        }
+    }
+    update() {
+        const t = this.stream;
+        t._duplexState |= b;
+        do {
+            this.drain();
+            while (this.buffered < this.highWaterMark && (t._duplexState & Wt) === M) {
+                t._duplexState |= R;
+                t._read(this.afterRead);
+                this.drain();
+            }
+            if ((t._duplexState & Pt) === A) {
+                t._duplexState |= P;
+                t.emit("readable");
+            }
+            if ((t._duplexState & q) === 0) this.updateNonPrimary();
+        } while (this.continueUpdate() === true);
+        t._duplexState &= H;
+    }
+    updateNonPrimary() {
+        const t = this.stream;
+        if ((t._duplexState & Nt) === k) {
+            t._duplexState = (t._duplexState | W) & O;
+            t.emit("end");
+            if ((t._duplexState & bt) === _t) t._duplexState |= p;
+            if (this.pipeTo !== null) this.pipeTo.end();
+        }
+        if ((t._duplexState & St) === p) {
+            if ((t._duplexState & wt) === 0) {
+                t._duplexState |= pt;
+                t._destroy(Ht.bind(this));
+            }
+            return;
+        }
+        if ((t._duplexState & gt) === o) {
+            t._duplexState = (t._duplexState | pt) & _;
+            t._open(Yt.bind(this));
+        }
     }
-    var n = Array.isArray(t);
-    if (!n && e.hasOwnProperty(t)) {
-        delete e[t];
+    continueUpdate() {
+        if ((this.stream._duplexState & v) === 0) return false;
+        this.stream._duplexState &= G;
         return true;
     }
-    if (a(e, t)) {
-        var i = n ? t.slice() : t.split(".");
-        var p = i.pop();
-        while (i.length && i[i.length - 1].slice(-1) === "\\") {
-            p = i.pop().slice(0, -1) + "." + p;
+    updateCallback() {
+        if ((this.stream._duplexState & Lt) === m) this.update(); else this.updateNextTick();
+    }
+    updateNextTickIfOpen() {
+        if ((this.stream._duplexState & Mt) !== 0) return;
+        this.stream._duplexState |= v;
+        if ((this.stream._duplexState & b) === 0) h(this.afterUpdateNextTick);
+    }
+    updateNextTick() {
+        if ((this.stream._duplexState & v) !== 0) return;
+        this.stream._duplexState |= v;
+        if ((this.stream._duplexState & b) === 0) h(this.afterUpdateNextTick);
+    }
+}
+
+class TransformState {
+    constructor(t) {
+        this.data = null;
+        this.afterTransform = Zt.bind(t);
+        this.afterFinal = null;
+    }
+}
+
+class Pipeline {
+    constructor(t, e, i) {
+        this.from = t;
+        this.to = e;
+        this.afterPipe = i;
+        this.error = null;
+        this.pipeToFinished = false;
+    }
+    finished() {
+        this.pipeToFinished = true;
+    }
+    done(t, e) {
+        if (e) this.error = e;
+        if (t === this.to) {
+            this.to = null;
+            if (this.from !== null) {
+                if ((this.from._duplexState & W) === 0 || !this.pipeToFinished) {
+                    this.from.destroy(this.error || new Error("Writable stream closed prematurely"));
+                }
+                return;
+            }
         }
-        while (i.length) {
-            t = i.shift();
-            s(t);
-            e = e[t];
+        if (t === this.from) {
+            this.from = null;
+            if (this.to !== null) {
+                if ((t._duplexState & W) === 0) {
+                    this.to.destroy(this.error || new Error("Readable stream closed before ending"));
+                }
+                return;
+            }
         }
-        return delete e[p];
+        if (this.afterPipe !== null) this.afterPipe(this.error);
+        this.to = this.from = this.afterPipe = null;
     }
-    return true;
-};
+}
+
+function zt() {
+    this.stream._duplexState |= g;
+    this.updateCallback();
+}
+
+function Gt(t) {
+    const e = this.stream;
+    if (t) e.destroy(t);
+    if ((e._duplexState & St) === 0) {
+        e._duplexState |= $;
+        e.emit("finish");
+    }
+    if ((e._duplexState & bt) === _t) {
+        e._duplexState |= p;
+    }
+    e._duplexState &= lt;
+    if ((e._duplexState & V) === 0) this.update(); else this.updateNextTick();
+}
+
+function Ht(t) {
+    const e = this.stream;
+    if (!t && this.error !== r) t = this.error;
+    if (t) e.emit("error", t);
+    e._duplexState |= c;
+    e.emit("close");
+    const i = e._readableState;
+    const a = e._writableState;
+    if (i !== null && i.pipeline !== null) i.pipeline.done(e, t);
+    if (a !== null) {
+        while (a.drains !== null && a.drains.length > 0) a.drains.shift().resolve(false);
+        if (a.pipeline !== null) a.pipeline.done(e, t);
+    }
+}
+
+function Jt(t) {
+    const e = this.stream;
+    if (t) e.destroy(t);
+    e._duplexState &= rt;
+    if (this.drains !== null) Xt(this.drains);
+    if ((e._duplexState & At) === Z) {
+        e._duplexState &= ut;
+        if ((e._duplexState & tt) === tt) {
+            e.emit("drain");
+        }
+    }
+    this.updateCallback();
+}
+
+function Kt(t) {
+    if (t) this.stream.destroy(t);
+    this.stream._duplexState &= C;
+    if (this.readAhead === false && (this.stream._duplexState & y) === 0) this.stream._duplexState &= J;
+    this.updateCallback();
+}
+
+function Qt() {
+    if ((this.stream._duplexState & b) === 0) {
+        this.stream._duplexState &= G;
+        this.update();
+    }
+}
+
+function Vt() {
+    if ((this.stream._duplexState & V) === 0) {
+        this.stream._duplexState &= dt;
+        this.update();
+    }
+}
+
+function Xt(t) {
+    for (let e = 0; e < t.length; e++) {
+        if (--t[e].writes === 0) {
+            t.shift().resolve(true);
+            e--;
+        }
+    }
+}
+
+function Yt(t) {
+    const e = this.stream;
+    if (t) e.destroy(t);
+    if ((e._duplexState & p) === 0) {
+        if ((e._duplexState & kt) === 0) e._duplexState |= m;
+        if ((e._duplexState & Et) === 0) e._duplexState |= X;
+        e.emit("open");
+    }
+    e._duplexState &= ct;
+    if (e._writableState !== null) {
+        e._writableState.updateCallback();
+    }
+    if (e._readableState !== null) {
+        e._readableState.updateCallback();
+    }
+}
+
+function Zt(t, e) {
+    if (e !== undefined && e !== null) this.push(e);
+    this._writableState.afterWrite(t);
+}
+
+function $t(t) {
+    if (this._readableState !== null) {
+        if (t === "data") {
+            this._duplexState |= T | U;
+            this._readableState.updateNextTick();
+        }
+        if (t === "readable") {
+            this._duplexState |= N;
+            this._readableState.updateNextTick();
+        }
+    }
+    if (this._writableState !== null) {
+        if (t === "drain") {
+            this._duplexState |= tt;
+            this._writableState.updateNextTick();
+        }
+    }
+}
+
+class Stream extends s {
+    constructor(t) {
+        super();
+        this._duplexState = 0;
+        this._readableState = null;
+        this._writableState = null;
+        if (t) {
+            if (t.open) this._open = t.open;
+            if (t.destroy) this._destroy = t.destroy;
+            if (t.predestroy) this._predestroy = t.predestroy;
+            if (t.signal) {
+                t.signal.addEventListener("abort", ce.bind(this));
+            }
+        }
+        this.on("newListener", $t);
+    }
+    _open(t) {
+        t(null);
+    }
+    _destroy(t) {
+        t(null);
+    }
+    _predestroy() {}
+    get readable() {
+        return this._readableState !== null ? true : undefined;
+    }
+    get writable() {
+        return this._writableState !== null ? true : undefined;
+    }
+    get destroyed() {
+        return (this._duplexState & c) !== 0;
+    }
+    get destroying() {
+        return (this._duplexState & St) !== 0;
+    }
+    destroy(t) {
+        if ((this._duplexState & St) === 0) {
+            if (!t) t = r;
+            this._duplexState = (this._duplexState | p) & mt;
+            if (this._readableState !== null) {
+                this._readableState.highWaterMark = 0;
+                this._readableState.error = t;
+            }
+            if (this._writableState !== null) {
+                this._writableState.highWaterMark = 0;
+                this._writableState.error = t;
+            }
+            this._duplexState |= f;
+            this._predestroy();
+            this._duplexState &= S;
+            if (this._readableState !== null) this._readableState.updateNextTick();
+            if (this._writableState !== null) this._writableState.updateNextTick();
+        }
+    }
+}
+
+class Readable extends Stream {
+    constructor(t) {
+        super(t);
+        this._duplexState |= o | $ | M;
+        this._readableState = new ReadableState(this, t);
+        if (t) {
+            if (this._readableState.readAhead === false) this._duplexState &= J;
+            if (t.read) this._read = t.read;
+            if (t.eagerOpen) this._readableState.updateNextTick();
+            if (t.encoding) this.setEncoding(t.encoding);
+        }
+    }
+    setEncoding(t) {
+        const e = new u(t);
+        const i = this._readableState.map || ae;
+        this._readableState.map = a;
+        return this;
+        function a(t) {
+            const a = e.push(t);
+            return a === "" && (t.byteLength !== 0 || e.remaining > 0) ? null : i(a);
+        }
+    }
+    _read(t) {
+        t(null);
+    }
+    pipe(t, e) {
+        this._readableState.updateNextTick();
+        this._readableState.pipe(t, e);
+        return t;
+    }
+    read() {
+        this._readableState.updateNextTick();
+        return this._readableState.read();
+    }
+    push(t) {
+        this._readableState.updateNextTickIfOpen();
+        return this._readableState.push(t);
+    }
+    unshift(t) {
+        this._readableState.updateNextTickIfOpen();
+        return this._readableState.unshift(t);
+    }
+    resume() {
+        this._duplexState |= U;
+        this._readableState.updateNextTick();
+        return this;
+    }
+    pause() {
+        this._duplexState &= this._readableState.readAhead === false ? K : j;
+        return this;
+    }
+    static _fromAsyncIterator(t, e) {
+        let i;
+        const a = new Readable({
+            ...e,
+            read(e) {
+                t.next().then(s).then(e.bind(null, null)).catch(e);
+            },
+            predestroy() {
+                i = t.return();
+            },
+            destroy(t) {
+                if (!i) return t(null);
+                i.then(t.bind(null, null)).catch(t);
+            }
+        });
+        return a;
+        function s(t) {
+            if (t.done) a.push(null); else a.push(t.value);
+        }
+    }
+    static from(t, e) {
+        if (he(t)) return t;
+        if (t[Ot]) return this._fromAsyncIterator(t[Ot](), e);
+        if (!Array.isArray(t)) t = t === undefined ? [] : [ t ];
+        let i = 0;
+        return new Readable({
+            ...e,
+            read(e) {
+                this.push(i === t.length ? null : t[i++]);
+                e(null);
+            }
+        });
+    }
+    static isBackpressured(t) {
+        return (t._duplexState & vt) !== 0 || t._readableState.buffered >= t._readableState.highWaterMark;
+    }
+    static isPaused(t) {
+        return (t._duplexState & y) === 0;
+    }
+    [Ot]() {
+        const t = this;
+        let e = null;
+        let i = null;
+        let a = null;
+        this.on("error", t => {
+            e = t;
+        });
+        this.on("readable", s);
+        this.on("close", n);
+        return {
+            [Ot]() {
+                return this;
+            },
+            next() {
+                return new Promise(function(e, s) {
+                    i = e;
+                    a = s;
+                    const r = t.read();
+                    if (r !== null) l(r); else if ((t._duplexState & c) !== 0) l(null);
+                });
+            },
+            return() {
+                return u(null);
+            },
+            throw(t) {
+                return u(t);
+            }
+        };
+        function s() {
+            if (i !== null) l(t.read());
+        }
+        function n() {
+            if (i !== null) l(null);
+        }
+        function l(s) {
+            if (a === null) return;
+            if (e) a(e); else if (s === null && (t._duplexState & W) === 0) a(r); else i({
+                value: s,
+                done: s === null
+            });
+            a = i = null;
+        }
+        function u(e) {
+            t.destroy(e);
+            return new Promise((i, a) => {
+                if (t._duplexState & c) return i({
+                    value: undefined,
+                    done: true
+                });
+                t.once("close", function() {
+                    if (e) a(e); else i({
+                        value: undefined,
+                        done: true
+                    });
+                });
+            });
+        }
+    }
+}
+
+class Writable extends Stream {
+    constructor(t) {
+        super(t);
+        this._duplexState |= o | W;
+        this._writableState = new WritableState(this, t);
+        if (t) {
+            if (t.writev) this._writev = t.writev;
+            if (t.write) this._write = t.write;
+            if (t.final) this._final = t.final;
+            if (t.eagerOpen) this._writableState.updateNextTick();
+        }
+    }
+    cork() {
+        this._duplexState |= st;
+    }
+    uncork() {
+        this._duplexState &= ft;
+        this._writableState.updateNextTick();
+    }
+    _writev(t, e) {
+        e(null);
+    }
+    _write(t, e) {
+        this._writableState.autoBatch(t, e);
+    }
+    _final(t) {
+        t(null);
+    }
+    static isBackpressured(t) {
+        return (t._duplexState & It) !== 0;
+    }
+    static drained(t) {
+        if (t.destroyed) return Promise.resolve(false);
+        const e = t._writableState;
+        const i = _e(t) ? Math.min(1, e.queue.length) : e.queue.length;
+        const a = i + (t._duplexState & it ? 1 : 0);
+        if (a === 0) return Promise.resolve(true);
+        if (e.drains === null) e.drains = [];
+        return new Promise(t => {
+            e.drains.push({
+                writes: a,
+                resolve: t
+            });
+        });
+    }
+    write(t) {
+        this._writableState.updateNextTick();
+        return this._writableState.push(t);
+    }
+    end(t) {
+        this._writableState.updateNextTick();
+        this._writableState.end(t);
+        return this;
+    }
+}
+
+class Duplex extends Readable {
+    constructor(t) {
+        super(t);
+        this._duplexState = o | this._duplexState & M;
+        this._writableState = new WritableState(this, t);
+        if (t) {
+            if (t.writev) this._writev = t.writev;
+            if (t.write) this._write = t.write;
+            if (t.final) this._final = t.final;
+        }
+    }
+    cork() {
+        this._duplexState |= st;
+    }
+    uncork() {
+        this._duplexState &= ft;
+        this._writableState.updateNextTick();
+    }
+    _writev(t, e) {
+        e(null);
+    }
+    _write(t, e) {
+        this._writableState.autoBatch(t, e);
+    }
+    _final(t) {
+        t(null);
+    }
+    write(t) {
+        this._writableState.updateNextTick();
+        return this._writableState.push(t);
+    }
+    end(t) {
+        this._writableState.updateNextTick();
+        this._writableState.end(t);
+        return this;
+    }
+}
+
+class Transform extends Duplex {
+    constructor(t) {
+        super(t);
+        this._transformState = new TransformState(this);
+        if (t) {
+            if (t.transform) this._transform = t.transform;
+            if (t.flush) this._flush = t.flush;
+        }
+    }
+    _write(t, e) {
+        if (this._readableState.buffered >= this._readableState.highWaterMark) {
+            this._transformState.data = t;
+        } else {
+            this._transform(t, this._transformState.afterTransform);
+        }
+    }
+    _read(t) {
+        if (this._transformState.data !== null) {
+            const e = this._transformState.data;
+            this._transformState.data = null;
+            t(null);
+            this._transform(e, this._transformState.afterTransform);
+        } else {
+            t(null);
+        }
+    }
+    destroy(t) {
+        super.destroy(t);
+        if (this._transformState.data !== null) {
+            this._transformState.data = null;
+            this._transformState.afterTransform();
+        }
+    }
+    _transform(t, e) {
+        e(null, t);
+    }
+    _flush(t) {
+        t(null);
+    }
+    _final(t) {
+        this._transformState.afterFinal = t;
+        this._flush(te.bind(this));
+    }
+}
+
+class PassThrough extends Transform {}
+
+function te(t, e) {
+    const i = this._transformState.afterFinal;
+    if (t) return i(t);
+    if (e !== null && e !== undefined) this.push(e);
+    this.push(null);
+    i(null);
+}
+
+function ee(...t) {
+    return new Promise((e, i) => ie(...t, t => {
+        if (t) return i(t);
+        e();
+    }));
+}
+
+function ie(t, ...e) {
+    const i = Array.isArray(t) ? [ ...t, ...e ] : [ t, ...e ];
+    const a = i.length && typeof i[i.length - 1] === "function" ? i.pop() : null;
+    if (i.length < 2) throw new Error("Pipeline requires at least 2 streams");
+    let s = i[0];
+    let r = null;
+    let l = null;
+    for (let t = 1; t < i.length; t++) {
+        r = i[t];
+        if (re(s)) {
+            s.pipe(r, h);
+        } else {
+            u(s, true, t > 1, h);
+            s.pipe(r);
+        }
+        s = r;
+    }
+    if (a) {
+        let t = false;
+        const e = re(r) || !!(r._writableState && r._writableState.autoDestroy);
+        r.on("error", t => {
+            if (l === null) l = t;
+        });
+        r.on("finish", () => {
+            t = true;
+            if (!e) a(l);
+        });
+        if (e) {
+            r.on("close", () => a(l || (t ? null : n)));
+        }
+    }
+    return r;
+    function u(t, e, i, a) {
+        t.on("error", a);
+        t.on("close", s);
+        function s() {
+            if (t._readableState && !t._readableState.ended) return a(n);
+            if (i && t._writableState && !t._writableState.ended) return a(n);
+        }
+    }
+    function h(t) {
+        if (!t || l) return;
+        l = t;
+        for (const e of i) {
+            e.destroy(t);
+        }
+    }
+}
+
+function ae(t) {
+    return t;
+}
+
+function se(t) {
+    return !!t._readableState || !!t._writableState;
+}
+
+function re(t) {
+    return typeof t._duplexState === "number" && se(t);
+}
+
+function ne(t) {
+    return !!t._readableState && t._readableState.ended;
+}
+
+function le(t) {
+    return !!t._writableState && t._writableState.ended;
+}
+
+function ue(t, e = {}) {
+    const i = t._readableState && t._readableState.error || t._writableState && t._writableState.error;
+    return !e.all && i === r ? null : i;
+}
 
-const p = r(i);
+function he(t) {
+    return re(t) && t.readable;
+}
+
+function de(t) {
+    return (t._duplexState & o) !== o || (t._duplexState & wt) !== 0;
+}
+
+function oe(t) {
+    return typeof t === "object" && t !== null && typeof t.byteLength === "number";
+}
+
+function fe(t) {
+    return oe(t) ? t.byteLength : 1024;
+}
+
+function pe() {}
+
+function ce() {
+    this.destroy(new Error("Stream aborted."));
+}
+
+function _e(t) {
+    return t._writev !== Writable.prototype._writev && t._writev !== Duplex.prototype._writev;
+}
+
+var Se = {
+    pipeline: ie,
+    pipelinePromise: ee,
+    isStream: se,
+    isStreamx: re,
+    isEnded: ne,
+    isFinished: le,
+    isDisturbed: de,
+    getStreamError: ue,
+    Stream: Stream,
+    Writable: Writable,
+    Readable: Readable,
+    Duplex: Duplex,
+    Transform: Transform,
+    PassThrough: PassThrough
+};
 
-export { p as u };
+export { Se as s };