lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.185.cjs

@@ -1,1090 +1,8 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
-const t = require("./Package.internal.8.cjs");
-
-const e = require("./Package.internal.84.cjs");
-
-const i = require("./Package.internal.87.cjs");
-
-const s = require("./Package.internal.186.cjs");
-
-const {EventEmitter: a} = e._default;
-
-const r = new Error("Stream was destroyed");
-
-const n = new Error("Premature close");
-
-const l = i.fastFifo;
-
-const u = s.textDecoder;
-
-const h = typeof queueMicrotask === "undefined" ? e => t.commonjsGlobal.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 q = 4096 << 4;
-
-const L = 8192 << 4;
-
-const M = y | g;
-
-const E = x | q;
-
-const R = m | x;
-
-const A = N | w;
-
-const U = y | L;
-
-const C = d ^ x;
-
-const D = d ^ m;
-
-const F = d ^ (m | q);
-
-const I = d ^ q;
-
-const j = d ^ y;
-
-const B = d ^ (w | P);
-
-const O = d ^ k;
-
-const G = d ^ M;
-
-const z = d ^ v;
-
-const H = d ^ b;
-
-const J = d ^ L;
-
-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 st = 512 << 18;
-
-const at = 1024 << 18;
-
-const rt = d ^ (Q | it);
-
-const nt = d ^ X;
-
-const lt = d ^ (Q | st);
-
-const ut = d ^ Z;
-
-const ht = d ^ Y;
-
-const dt = d ^ et;
-
-const ot = d ^ V;
-
-const ft = d ^ at;
-
-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 | q | L;
-
-const vt = St | k | W;
-
-const qt = b | xt | v | m;
-
-const Lt = v | o;
-
-const Mt = xt | st | $;
-
-const Et = Y | Z;
-
-const Rt = Y | Q;
-
-const At = Y | Z | xt | Q;
-
-const Ut = xt | Q | Y | at;
-
-const Ct = X | Q;
-
-const Dt = Q | it;
-
-const Ft = xt | st | Rt | $;
-
-const It = Z | St | st | $;
-
-const jt = V | xt | et | X;
-
-const Bt = st | $ | St;
-
-const Ot = Symbol.asyncIterator || Symbol("asyncIterator");
-
-class WritableState {
-    constructor(t, {highWaterMark: e = 16384, map: i = null, mapWritable: s, byteLength: a, 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 || a || fe;
-        this.map = s || 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 |= Et;
-        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 | st) & nt;
-    }
-    autoBatch(t, e) {
-        const i = [];
-        const s = this.stream;
-        i.push(t);
-        while ((s._duplexState & Ut) === Rt) {
-            i.push(s._writableState.shift());
-        }
-        if ((s._duplexState & xt) !== 0) return e(null);
-        s._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) === st) {
-            t._duplexState = t._duplexState | Q;
-            t._final(zt.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);
-    }
-}
-
-class ReadableState {
-    constructor(t, {highWaterMark: e = 16384, map: i = null, mapReadable: s, byteLength: a, 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 || a || fe;
-        this.map = s || 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", Gt.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 &= G;
-            if ((t._duplexState & T) !== 0) t.emit("data", e);
-            return e;
-        }
-        if (this.readAhead === false) {
-            t._duplexState |= L;
-            this.updateNextTick();
-        }
-        return null;
-    }
-    drain() {
-        const t = this.stream;
-        while ((t._duplexState & Tt) === w && (t._duplexState & M) !== 0) {
-            const e = this.shift();
-            if (this.pipeTo !== null && this.pipeTo.write(e) === false) t._duplexState &= G;
-            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) === L) {
-                t._duplexState |= E;
-                t._read(this.afterRead);
-                this.drain();
-            }
-            if ((t._duplexState & Pt) === A) {
-                t._duplexState |= P;
-                t.emit("readable");
-            }
-            if ((t._duplexState & R) === 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));
-        }
-    }
-    continueUpdate() {
-        if ((this.stream._duplexState & v) === 0) return false;
-        this.stream._duplexState &= z;
-        return true;
-    }
-    updateCallback() {
-        if ((this.stream._duplexState & qt) === m) this.update(); else this.updateNextTick();
-    }
-    updateNextTickIfOpen() {
-        if ((this.stream._duplexState & Lt) !== 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;
-            }
-        }
-        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;
-            }
-        }
-        if (this.afterPipe !== null) this.afterPipe(this.error);
-        this.to = this.from = this.afterPipe = null;
-    }
-}
-
-function Gt() {
-    this.stream._duplexState |= g;
-    this.updateCallback();
-}
-
-function zt(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 s = e._writableState;
-    if (i !== null && i.pipeline !== null) i.pipeline.done(e, t);
-    if (s !== null) {
-        while (s.drains !== null && s.drains.length > 0) s.drains.shift().resolve(false);
-        if (s.pipeline !== null) s.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 &= z;
-        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 & Mt) === 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 a {
-    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 | $ | L;
-        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 || se;
-        this._readableState.map = s;
-        return this;
-        function s(t) {
-            const s = e.push(t);
-            return s === "" && (t.byteLength !== 0 || e.remaining > 0) ? null : i(s);
-        }
-    }
-    _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 s = new Readable({
-            ...e,
-            read(e) {
-                t.next().then(a).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 s;
-        function a(t) {
-            if (t.done) s.push(null); else s.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 s = null;
-        this.on("error", t => {
-            e = t;
-        });
-        this.on("readable", a);
-        this.on("close", n);
-        return {
-            [Ot]() {
-                return this;
-            },
-            next() {
-                return new Promise(function(e, a) {
-                    i = e;
-                    s = a;
-                    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 a() {
-            if (i !== null) l(t.read());
-        }
-        function n() {
-            if (i !== null) l(null);
-        }
-        function l(a) {
-            if (s === null) return;
-            if (e) s(e); else if (a === null && (t._duplexState & W) === 0) s(r); else i({
-                value: a,
-                done: a === null
-            });
-            s = i = null;
-        }
-        function u(e) {
-            t.destroy(e);
-            return new Promise((i, s) => {
-                if (t._duplexState & c) return i({
-                    value: undefined,
-                    done: true
-                });
-                t.once("close", function() {
-                    if (e) s(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 |= at;
-    }
-    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 s = i + (t._duplexState & it ? 1 : 0);
-        if (s === 0) return Promise.resolve(true);
-        if (e.drains === null) e.drains = [];
-        return new Promise(t => {
-            e.drains.push({
-                writes: s,
-                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 & L;
-        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 |= at;
-    }
-    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 s = 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 a = i[0];
-    let r = null;
-    let l = null;
-    for (let t = 1; t < i.length; t++) {
-        r = i[t];
-        if (re(a)) {
-            a.pipe(r, h);
-        } else {
-            u(a, true, t > 1, h);
-            a.pipe(r);
-        }
-        a = r;
-    }
-    if (s) {
-        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) s(l);
-        });
-        if (e) {
-            r.on("close", () => s(l || (t ? null : n)));
-        }
-    }
-    return r;
-    function u(t, e, i, s) {
-        t.on("error", s);
-        t.on("close", a);
-        function a() {
-            if (t._readableState && !t._readableState.ended) return s(n);
-            if (i && t._writableState && !t._writableState.ended) return s(n);
-        }
-    }
-    function h(t) {
-        if (!t || l) return;
-        l = t;
-        for (const e of i) {
-            e.destroy(t);
-        }
-    }
-}
-
-function se(t) {
-    return t;
-}
-
-function ae(t) {
-    return !!t._readableState || !!t._writableState;
-}
-
-function re(t) {
-    return typeof t._duplexState === "number" && ae(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;
-}
-
-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;
+function t(t) {
+    return import(t);
 }
 
-exports.streamx = {
-    pipeline: ie,
-    pipelinePromise: ee,
-    isStream: ae,
-    isStreamx: re,
-    isEnded: ne,
-    isFinished: le,
-    isDisturbed: de,
-    getStreamError: ue,
-    Stream: Stream,
-    Writable: Writable,
-    Readable: Readable,
-    Duplex: Duplex,
-    Transform: Transform,
-    PassThrough: PassThrough
-};
+exports.importModule = t;