lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.113.mjs

@@ -1,52 +1,1292 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
-import { k as e } from "./Package.internal.114.mjs";
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import { c as t } from "./Package.internal.8.mjs";
 
-const r = e;
+import e, { EventEmitter as s } from "node:events";
 
-var s = function e(s) {
-    switch (r(s)) {
-      case "boolean":
-      case "date":
-      case "function":
-      case "null":
-      case "number":
-        return true;
+import i from "node:stream";
 
-      case "undefined":
-        return false;
+import r, { StringDecoder as n } from "node:string_decoder";
 
-      case "regexp":
-        return s.source !== "(?:)" && s.source !== "";
+var o = {};
 
-      case "buffer":
-        return s.toString() !== "";
+var h;
 
-      case "error":
-        return s.message !== "";
+function f() {
+    if (h) return o;
+    h = 1;
+    (function(s) {
+        var n = t && t.__importDefault || function(t) {
+            return t && t.__esModule ? t : {
+                default: t
+            };
+        };
+        Object.defineProperty(s, "__esModule", {
+            value: true
+        });
+        s.Minipass = s.isWritable = s.isReadable = s.isStream = void 0;
+        const o = typeof process === "object" && process ? process : {
+            stdout: null,
+            stderr: null
+        };
+        const h = e;
+        const f = n(i);
+        const a = r;
+        const l = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof f.default || (0, 
+        s.isReadable)(t) || (0, s.isWritable)(t));
+        s.isStream = l;
+        const u = t => !!t && typeof t === "object" && t instanceof h.EventEmitter && typeof t.pipe === "function" && t.pipe !== f.default.Writable.prototype.pipe;
+        s.isReadable = u;
+        const c = t => !!t && typeof t === "object" && t instanceof h.EventEmitter && typeof t.write === "function" && typeof t.end === "function";
+        s.isWritable = c;
+        const d = Symbol("EOF");
+        const m = Symbol("maybeEmitEnd");
+        const p = Symbol("emittedEnd");
+        const b = Symbol("emittingEnd");
+        const y = Symbol("emittedError");
+        const g = Symbol("closed");
+        const w = Symbol("read");
+        const E = Symbol("flush");
+        const S = Symbol("flushChunk");
+        const v = Symbol("encoding");
+        const j = Symbol("decoder");
+        const L = Symbol("flowing");
+        const x = Symbol("paused");
+        const M = Symbol("resume");
+        const P = Symbol("buffer");
+        const B = Symbol("pipes");
+        const A = Symbol("bufferLength");
+        const O = Symbol("bufferPush");
+        const R = Symbol("bufferShift");
+        const _ = Symbol("objectMode");
+        const D = Symbol("destroyed");
+        const T = Symbol("error");
+        const W = Symbol("emitData");
+        const C = Symbol("emitEnd");
+        const I = Symbol("emitEnd2");
+        const N = Symbol("async");
+        const k = Symbol("abort");
+        const F = Symbol("aborted");
+        const V = Symbol("signal");
+        const Y = Symbol("dataListeners");
+        const q = Symbol("discarded");
+        const z = t => Promise.resolve().then(t);
+        const G = t => t();
+        const H = t => t === "end" || t === "finish" || t === "prefinish";
+        const J = t => t instanceof ArrayBuffer || !!t && typeof t === "object" && t.constructor && t.constructor.name === "ArrayBuffer" && t.byteLength >= 0;
+        const K = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
+        class Pipe {
+            src;
+            dest;
+            opts;
+            ondrain;
+            constructor(t, e, s) {
+                this.src = t;
+                this.dest = e;
+                this.opts = s;
+                this.ondrain = () => t[M]();
+                this.dest.on("drain", this.ondrain);
+            }
+            unpipe() {
+                this.dest.removeListener("drain", this.ondrain);
+            }
+            proxyErrors(t) {}
+            end() {
+                this.unpipe();
+                if (this.opts.end) this.dest.end();
+            }
+        }
+        class PipeProxyErrors extends Pipe {
+            unpipe() {
+                this.src.removeListener("error", this.proxyErrors);
+                super.unpipe();
+            }
+            constructor(t, e, s) {
+                super(t, e, s);
+                this.proxyErrors = t => e.emit("error", t);
+                t.on("error", this.proxyErrors);
+            }
+        }
+        const Q = t => !!t.objectMode;
+        const U = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
+        class Minipass extends h.EventEmitter {
+            [L]=false;
+            [x]=false;
+            [B]=[];
+            [P]=[];
+            [_];
+            [v];
+            [N];
+            [j];
+            [d]=false;
+            [p]=false;
+            [b]=false;
+            [g]=false;
+            [y]=null;
+            [A]=0;
+            [D]=false;
+            [V];
+            [F]=false;
+            [Y]=0;
+            [q]=false;
+            writable=true;
+            readable=true;
+            constructor(...t) {
+                const e = t[0] || {};
+                super();
+                if (e.objectMode && typeof e.encoding === "string") {
+                    throw new TypeError("Encoding and objectMode may not be used together");
+                }
+                if (Q(e)) {
+                    this[_] = true;
+                    this[v] = null;
+                } else if (U(e)) {
+                    this[v] = e.encoding;
+                    this[_] = false;
+                } else {
+                    this[_] = false;
+                    this[v] = null;
+                }
+                this[N] = !!e.async;
+                this[j] = this[v] ? new a.StringDecoder(this[v]) : null;
+                if (e && e.debugExposeBuffer === true) {
+                    Object.defineProperty(this, "buffer", {
+                        get: () => this[P]
+                    });
+                }
+                if (e && e.debugExposePipes === true) {
+                    Object.defineProperty(this, "pipes", {
+                        get: () => this[B]
+                    });
+                }
+                const {signal: s} = e;
+                if (s) {
+                    this[V] = s;
+                    if (s.aborted) {
+                        this[k]();
+                    } else {
+                        s.addEventListener("abort", () => this[k]());
+                    }
+                }
+            }
+            get bufferLength() {
+                return this[A];
+            }
+            get encoding() {
+                return this[v];
+            }
+            set encoding(t) {
+                throw new Error("Encoding must be set at instantiation time");
+            }
+            setEncoding(t) {
+                throw new Error("Encoding must be set at instantiation time");
+            }
+            get objectMode() {
+                return this[_];
+            }
+            set objectMode(t) {
+                throw new Error("objectMode must be set at instantiation time");
+            }
+            get ["async"]() {
+                return this[N];
+            }
+            set ["async"](t) {
+                this[N] = this[N] || !!t;
+            }
+            [k]() {
+                this[F] = true;
+                this.emit("abort", this[V]?.reason);
+                this.destroy(this[V]?.reason);
+            }
+            get aborted() {
+                return this[F];
+            }
+            set aborted(t) {}
+            write(t, e, s) {
+                if (this[F]) return false;
+                if (this[d]) throw new Error("write after end");
+                if (this[D]) {
+                    this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), {
+                        code: "ERR_STREAM_DESTROYED"
+                    }));
+                    return true;
+                }
+                if (typeof e === "function") {
+                    s = e;
+                    e = "utf8";
+                }
+                if (!e) e = "utf8";
+                const i = this[N] ? z : G;
+                if (!this[_] && !Buffer.isBuffer(t)) {
+                    if (K(t)) {
+                        t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+                    } else if (J(t)) {
+                        t = Buffer.from(t);
+                    } else if (typeof t !== "string") {
+                        throw new Error("Non-contiguous data written to non-objectMode stream");
+                    }
+                }
+                if (this[_]) {
+                    if (this[L] && this[A] !== 0) this[E](true);
+                    if (this[L]) this.emit("data", t); else this[O](t);
+                    if (this[A] !== 0) this.emit("readable");
+                    if (s) i(s);
+                    return this[L];
+                }
+                if (!t.length) {
+                    if (this[A] !== 0) this.emit("readable");
+                    if (s) i(s);
+                    return this[L];
+                }
+                if (typeof t === "string" && !(e === this[v] && !this[j]?.lastNeed)) {
+                    t = Buffer.from(t, e);
+                }
+                if (Buffer.isBuffer(t) && this[v]) {
+                    t = this[j].write(t);
+                }
+                if (this[L] && this[A] !== 0) this[E](true);
+                if (this[L]) this.emit("data", t); else this[O](t);
+                if (this[A] !== 0) this.emit("readable");
+                if (s) i(s);
+                return this[L];
+            }
+            read(t) {
+                if (this[D]) return null;
+                this[q] = false;
+                if (this[A] === 0 || t === 0 || t && t > this[A]) {
+                    this[m]();
+                    return null;
+                }
+                if (this[_]) t = null;
+                if (this[P].length > 1 && !this[_]) {
+                    this[P] = [ this[v] ? this[P].join("") : Buffer.concat(this[P], this[A]) ];
+                }
+                const e = this[w](t || null, this[P][0]);
+                this[m]();
+                return e;
+            }
+            [w](t, e) {
+                if (this[_]) this[R](); else {
+                    const s = e;
+                    if (t === s.length || t === null) this[R](); else if (typeof s === "string") {
+                        this[P][0] = s.slice(t);
+                        e = s.slice(0, t);
+                        this[A] -= t;
+                    } else {
+                        this[P][0] = s.subarray(t);
+                        e = s.subarray(0, t);
+                        this[A] -= t;
+                    }
+                }
+                this.emit("data", e);
+                if (!this[P].length && !this[d]) this.emit("drain");
+                return e;
+            }
+            end(t, e, s) {
+                if (typeof t === "function") {
+                    s = t;
+                    t = undefined;
+                }
+                if (typeof e === "function") {
+                    s = e;
+                    e = "utf8";
+                }
+                if (t !== undefined) this.write(t, e);
+                if (s) this.once("end", s);
+                this[d] = true;
+                this.writable = false;
+                if (this[L] || !this[x]) this[m]();
+                return this;
+            }
+            [M]() {
+                if (this[D]) return;
+                if (!this[Y] && !this[B].length) {
+                    this[q] = true;
+                }
+                this[x] = false;
+                this[L] = true;
+                this.emit("resume");
+                if (this[P].length) this[E](); else if (this[d]) this[m](); else this.emit("drain");
+            }
+            resume() {
+                return this[M]();
+            }
+            pause() {
+                this[L] = false;
+                this[x] = true;
+                this[q] = false;
+            }
+            get destroyed() {
+                return this[D];
+            }
+            get flowing() {
+                return this[L];
+            }
+            get paused() {
+                return this[x];
+            }
+            [O](t) {
+                if (this[_]) this[A] += 1; else this[A] += t.length;
+                this[P].push(t);
+            }
+            [R]() {
+                if (this[_]) this[A] -= 1; else this[A] -= this[P][0].length;
+                return this[P].shift();
+            }
+            [E](t = false) {
+                do {} while (this[S](this[R]()) && this[P].length);
+                if (!t && !this[P].length && !this[d]) this.emit("drain");
+            }
+            [S](t) {
+                this.emit("data", t);
+                return this[L];
+            }
+            pipe(t, e) {
+                if (this[D]) return t;
+                this[q] = false;
+                const s = this[p];
+                e = e || {};
+                if (t === o.stdout || t === o.stderr) e.end = false; else e.end = e.end !== false;
+                e.proxyErrors = !!e.proxyErrors;
+                if (s) {
+                    if (e.end) t.end();
+                } else {
+                    this[B].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
+                    if (this[N]) z(() => this[M]()); else this[M]();
+                }
+                return t;
+            }
+            unpipe(t) {
+                const e = this[B].find(e => e.dest === t);
+                if (e) {
+                    if (this[B].length === 1) {
+                        if (this[L] && this[Y] === 0) {
+                            this[L] = false;
+                        }
+                        this[B] = [];
+                    } else this[B].splice(this[B].indexOf(e), 1);
+                    e.unpipe();
+                }
+            }
+            addListener(t, e) {
+                return this.on(t, e);
+            }
+            on(t, e) {
+                const s = super.on(t, e);
+                if (t === "data") {
+                    this[q] = false;
+                    this[Y]++;
+                    if (!this[B].length && !this[L]) {
+                        this[M]();
+                    }
+                } else if (t === "readable" && this[A] !== 0) {
+                    super.emit("readable");
+                } else if (H(t) && this[p]) {
+                    super.emit(t);
+                    this.removeAllListeners(t);
+                } else if (t === "error" && this[y]) {
+                    const t = e;
+                    if (this[N]) z(() => t.call(this, this[y])); else t.call(this, this[y]);
+                }
+                return s;
+            }
+            removeListener(t, e) {
+                return this.off(t, e);
+            }
+            off(t, e) {
+                const s = super.off(t, e);
+                if (t === "data") {
+                    this[Y] = this.listeners("data").length;
+                    if (this[Y] === 0 && !this[q] && !this[B].length) {
+                        this[L] = false;
+                    }
+                }
+                return s;
+            }
+            removeAllListeners(t) {
+                const e = super.removeAllListeners(t);
+                if (t === "data" || t === undefined) {
+                    this[Y] = 0;
+                    if (!this[q] && !this[B].length) {
+                        this[L] = false;
+                    }
+                }
+                return e;
+            }
+            get emittedEnd() {
+                return this[p];
+            }
+            [m]() {
+                if (!this[b] && !this[p] && !this[D] && this[P].length === 0 && this[d]) {
+                    this[b] = true;
+                    this.emit("end");
+                    this.emit("prefinish");
+                    this.emit("finish");
+                    if (this[g]) this.emit("close");
+                    this[b] = false;
+                }
+            }
+            emit(t, ...e) {
+                const s = e[0];
+                if (t !== "error" && t !== "close" && t !== D && this[D]) {
+                    return false;
+                } else if (t === "data") {
+                    return !this[_] && !s ? false : this[N] ? (z(() => this[W](s)), true) : this[W](s);
+                } else if (t === "end") {
+                    return this[C]();
+                } else if (t === "close") {
+                    this[g] = true;
+                    if (!this[p] && !this[D]) return false;
+                    const t = super.emit("close");
+                    this.removeAllListeners("close");
+                    return t;
+                } else if (t === "error") {
+                    this[y] = s;
+                    super.emit(T, s);
+                    const t = !this[V] || this.listeners("error").length ? super.emit("error", s) : false;
+                    this[m]();
+                    return t;
+                } else if (t === "resume") {
+                    const t = super.emit("resume");
+                    this[m]();
+                    return t;
+                } else if (t === "finish" || t === "prefinish") {
+                    const e = super.emit(t);
+                    this.removeAllListeners(t);
+                    return e;
+                }
+                const i = super.emit(t, ...e);
+                this[m]();
+                return i;
+            }
+            [W](t) {
+                for (const e of this[B]) {
+                    if (e.dest.write(t) === false) this.pause();
+                }
+                const e = this[q] ? false : super.emit("data", t);
+                this[m]();
+                return e;
+            }
+            [C]() {
+                if (this[p]) return false;
+                this[p] = true;
+                this.readable = false;
+                return this[N] ? (z(() => this[I]()), true) : this[I]();
+            }
+            [I]() {
+                if (this[j]) {
+                    const t = this[j].end();
+                    if (t) {
+                        for (const e of this[B]) {
+                            e.dest.write(t);
+                        }
+                        if (!this[q]) super.emit("data", t);
+                    }
+                }
+                for (const t of this[B]) {
+                    t.end();
+                }
+                const t = super.emit("end");
+                this.removeAllListeners("end");
+                return t;
+            }
+            async collect() {
+                const t = Object.assign([], {
+                    dataLength: 0
+                });
+                if (!this[_]) t.dataLength = 0;
+                const e = this.promise();
+                this.on("data", e => {
+                    t.push(e);
+                    if (!this[_]) t.dataLength += e.length;
+                });
+                await e;
+                return t;
+            }
+            async concat() {
+                if (this[_]) {
+                    throw new Error("cannot concat in objectMode");
+                }
+                const t = await this.collect();
+                return this[v] ? t.join("") : Buffer.concat(t, t.dataLength);
+            }
+            async promise() {
+                return new Promise((t, e) => {
+                    this.on(D, () => e(new Error("stream destroyed")));
+                    this.on("error", t => e(t));
+                    this.on("end", () => t());
+                });
+            }
+            [Symbol.asyncIterator]() {
+                this[q] = false;
+                let t = false;
+                const e = async () => {
+                    this.pause();
+                    t = true;
+                    return {
+                        value: undefined,
+                        done: true
+                    };
+                };
+                const s = () => {
+                    if (t) return e();
+                    const s = this.read();
+                    if (s !== null) return Promise.resolve({
+                        done: false,
+                        value: s
+                    });
+                    if (this[d]) return e();
+                    let i;
+                    let r;
+                    const n = t => {
+                        this.off("data", o);
+                        this.off("end", h);
+                        this.off(D, f);
+                        e();
+                        r(t);
+                    };
+                    const o = t => {
+                        this.off("error", n);
+                        this.off("end", h);
+                        this.off(D, f);
+                        this.pause();
+                        i({
+                            value: t,
+                            done: !!this[d]
+                        });
+                    };
+                    const h = () => {
+                        this.off("error", n);
+                        this.off("data", o);
+                        this.off(D, f);
+                        e();
+                        i({
+                            done: true,
+                            value: undefined
+                        });
+                    };
+                    const f = () => n(new Error("stream destroyed"));
+                    return new Promise((t, e) => {
+                        r = e;
+                        i = t;
+                        this.once(D, f);
+                        this.once("error", n);
+                        this.once("end", h);
+                        this.once("data", o);
+                    });
+                };
+                return {
+                    next: s,
+                    throw: e,
+                    return: e,
+                    [Symbol.asyncIterator]() {
+                        return this;
+                    }
+                };
+            }
+            [Symbol.iterator]() {
+                this[q] = false;
+                let t = false;
+                const e = () => {
+                    this.pause();
+                    this.off(T, e);
+                    this.off(D, e);
+                    this.off("end", e);
+                    t = true;
+                    return {
+                        done: true,
+                        value: undefined
+                    };
+                };
+                const s = () => {
+                    if (t) return e();
+                    const s = this.read();
+                    return s === null ? e() : {
+                        done: false,
+                        value: s
+                    };
+                };
+                this.once("end", e);
+                this.once(T, e);
+                this.once(D, e);
+                return {
+                    next: s,
+                    throw: e,
+                    return: e,
+                    [Symbol.iterator]() {
+                        return this;
+                    }
+                };
+            }
+            destroy(t) {
+                if (this[D]) {
+                    if (t) this.emit("error", t); else this.emit(D);
+                    return this;
+                }
+                this[D] = true;
+                this[q] = true;
+                this[P].length = 0;
+                this[A] = 0;
+                const e = this;
+                if (typeof e.close === "function" && !this[g]) e.close();
+                if (t) this.emit("error", t); else this.emit(D);
+                return this;
+            }
+            static get isStream() {
+                return s.isStream;
+            }
+        }
+        s.Minipass = Minipass;
+    })(o);
+    return o;
+}
+
+const a = typeof process === "object" && process ? process : {
+    stdout: null,
+    stderr: null
+};
+
+const l = t => !!t && typeof t === "object" && (t instanceof Minipass || t instanceof i || u(t) || c(t));
+
+const u = t => !!t && typeof t === "object" && t instanceof s && typeof t.pipe === "function" && t.pipe !== i.Writable.prototype.pipe;
+
+const c = t => !!t && typeof t === "object" && t instanceof s && typeof t.write === "function" && typeof t.end === "function";
+
+const d = Symbol("EOF");
+
+const m = Symbol("maybeEmitEnd");
+
+const p = Symbol("emittedEnd");
+
+const b = Symbol("emittingEnd");
+
+const y = Symbol("emittedError");
+
+const g = Symbol("closed");
+
+const w = Symbol("read");
+
+const E = Symbol("flush");
+
+const S = Symbol("flushChunk");
+
+const v = Symbol("encoding");
+
+const j = Symbol("decoder");
+
+const L = Symbol("flowing");
+
+const x = Symbol("paused");
+
+const M = Symbol("resume");
+
+const P = Symbol("buffer");
+
+const B = Symbol("pipes");
+
+const A = Symbol("bufferLength");
+
+const O = Symbol("bufferPush");
+
+const R = Symbol("bufferShift");
+
+const _ = Symbol("objectMode");
+
+const D = Symbol("destroyed");
+
+const T = Symbol("error");
+
+const W = Symbol("emitData");
+
+const C = Symbol("emitEnd");
+
+const I = Symbol("emitEnd2");
+
+const N = Symbol("async");
+
+const k = Symbol("abort");
+
+const F = Symbol("aborted");
+
+const V = Symbol("signal");
+
+const Y = Symbol("dataListeners");
+
+const q = Symbol("discarded");
+
+const z = t => Promise.resolve().then(t);
+
+const G = t => t();
+
+const H = t => t === "end" || t === "finish" || t === "prefinish";
 
-      case "string":
-      case "arguments":
-        return s.length !== 0;
+const J = t => t instanceof ArrayBuffer || !!t && typeof t === "object" && t.constructor && t.constructor.name === "ArrayBuffer" && t.byteLength >= 0;
 
-      case "file":
-      case "map":
-      case "set":
-        return s.size !== 0;
+const K = t => !Buffer.isBuffer(t) && ArrayBuffer.isView(t);
 
-      case "array":
-      case "object":
-        for (const r of Object.keys(s)) {
-            if (e(s[r])) {
-                return true;
+class Pipe {
+    src;
+    dest;
+    opts;
+    ondrain;
+    constructor(t, e, s) {
+        this.src = t;
+        this.dest = e;
+        this.opts = s;
+        this.ondrain = () => t[M]();
+        this.dest.on("drain", this.ondrain);
+    }
+    unpipe() {
+        this.dest.removeListener("drain", this.ondrain);
+    }
+    proxyErrors(t) {}
+    end() {
+        this.unpipe();
+        if (this.opts.end) this.dest.end();
+    }
+}
+
+class PipeProxyErrors extends Pipe {
+    unpipe() {
+        this.src.removeListener("error", this.proxyErrors);
+        super.unpipe();
+    }
+    constructor(t, e, s) {
+        super(t, e, s);
+        this.proxyErrors = t => e.emit("error", t);
+        t.on("error", this.proxyErrors);
+    }
+}
+
+const Q = t => !!t.objectMode;
+
+const U = t => !t.objectMode && !!t.encoding && t.encoding !== "buffer";
+
+class Minipass extends s {
+    [L]=false;
+    [x]=false;
+    [B]=[];
+    [P]=[];
+    [_];
+    [v];
+    [N];
+    [j];
+    [d]=false;
+    [p]=false;
+    [b]=false;
+    [g]=false;
+    [y]=null;
+    [A]=0;
+    [D]=false;
+    [V];
+    [F]=false;
+    [Y]=0;
+    [q]=false;
+    writable=true;
+    readable=true;
+    constructor(...t) {
+        const e = t[0] || {};
+        super();
+        if (e.objectMode && typeof e.encoding === "string") {
+            throw new TypeError("Encoding and objectMode may not be used together");
+        }
+        if (Q(e)) {
+            this[_] = true;
+            this[v] = null;
+        } else if (U(e)) {
+            this[v] = e.encoding;
+            this[_] = false;
+        } else {
+            this[_] = false;
+            this[v] = null;
+        }
+        this[N] = !!e.async;
+        this[j] = this[v] ? new n(this[v]) : null;
+        if (e && e.debugExposeBuffer === true) {
+            Object.defineProperty(this, "buffer", {
+                get: () => this[P]
+            });
+        }
+        if (e && e.debugExposePipes === true) {
+            Object.defineProperty(this, "pipes", {
+                get: () => this[B]
+            });
+        }
+        const {signal: s} = e;
+        if (s) {
+            this[V] = s;
+            if (s.aborted) {
+                this[k]();
+            } else {
+                s.addEventListener("abort", () => this[k]());
             }
         }
-        return false;
-
-      default:
-        {
+    }
+    get bufferLength() {
+        return this[A];
+    }
+    get encoding() {
+        return this[v];
+    }
+    set encoding(t) {
+        throw new Error("Encoding must be set at instantiation time");
+    }
+    setEncoding(t) {
+        throw new Error("Encoding must be set at instantiation time");
+    }
+    get objectMode() {
+        return this[_];
+    }
+    set objectMode(t) {
+        throw new Error("objectMode must be set at instantiation time");
+    }
+    get ["async"]() {
+        return this[N];
+    }
+    set ["async"](t) {
+        this[N] = this[N] || !!t;
+    }
+    [k]() {
+        this[F] = true;
+        this.emit("abort", this[V]?.reason);
+        this.destroy(this[V]?.reason);
+    }
+    get aborted() {
+        return this[F];
+    }
+    set aborted(t) {}
+    write(t, e, s) {
+        if (this[F]) return false;
+        if (this[d]) throw new Error("write after end");
+        if (this[D]) {
+            this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), {
+                code: "ERR_STREAM_DESTROYED"
+            }));
             return true;
         }
+        if (typeof e === "function") {
+            s = e;
+            e = "utf8";
+        }
+        if (!e) e = "utf8";
+        const i = this[N] ? z : G;
+        if (!this[_] && !Buffer.isBuffer(t)) {
+            if (K(t)) {
+                t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+            } else if (J(t)) {
+                t = Buffer.from(t);
+            } else if (typeof t !== "string") {
+                throw new Error("Non-contiguous data written to non-objectMode stream");
+            }
+        }
+        if (this[_]) {
+            if (this[L] && this[A] !== 0) this[E](true);
+            if (this[L]) this.emit("data", t); else this[O](t);
+            if (this[A] !== 0) this.emit("readable");
+            if (s) i(s);
+            return this[L];
+        }
+        if (!t.length) {
+            if (this[A] !== 0) this.emit("readable");
+            if (s) i(s);
+            return this[L];
+        }
+        if (typeof t === "string" && !(e === this[v] && !this[j]?.lastNeed)) {
+            t = Buffer.from(t, e);
+        }
+        if (Buffer.isBuffer(t) && this[v]) {
+            t = this[j].write(t);
+        }
+        if (this[L] && this[A] !== 0) this[E](true);
+        if (this[L]) this.emit("data", t); else this[O](t);
+        if (this[A] !== 0) this.emit("readable");
+        if (s) i(s);
+        return this[L];
     }
-};
+    read(t) {
+        if (this[D]) return null;
+        this[q] = false;
+        if (this[A] === 0 || t === 0 || t && t > this[A]) {
+            this[m]();
+            return null;
+        }
+        if (this[_]) t = null;
+        if (this[P].length > 1 && !this[_]) {
+            this[P] = [ this[v] ? this[P].join("") : Buffer.concat(this[P], this[A]) ];
+        }
+        const e = this[w](t || null, this[P][0]);
+        this[m]();
+        return e;
+    }
+    [w](t, e) {
+        if (this[_]) this[R](); else {
+            const s = e;
+            if (t === s.length || t === null) this[R](); else if (typeof s === "string") {
+                this[P][0] = s.slice(t);
+                e = s.slice(0, t);
+                this[A] -= t;
+            } else {
+                this[P][0] = s.subarray(t);
+                e = s.subarray(0, t);
+                this[A] -= t;
+            }
+        }
+        this.emit("data", e);
+        if (!this[P].length && !this[d]) this.emit("drain");
+        return e;
+    }
+    end(t, e, s) {
+        if (typeof t === "function") {
+            s = t;
+            t = undefined;
+        }
+        if (typeof e === "function") {
+            s = e;
+            e = "utf8";
+        }
+        if (t !== undefined) this.write(t, e);
+        if (s) this.once("end", s);
+        this[d] = true;
+        this.writable = false;
+        if (this[L] || !this[x]) this[m]();
+        return this;
+    }
+    [M]() {
+        if (this[D]) return;
+        if (!this[Y] && !this[B].length) {
+            this[q] = true;
+        }
+        this[x] = false;
+        this[L] = true;
+        this.emit("resume");
+        if (this[P].length) this[E](); else if (this[d]) this[m](); else this.emit("drain");
+    }
+    resume() {
+        return this[M]();
+    }
+    pause() {
+        this[L] = false;
+        this[x] = true;
+        this[q] = false;
+    }
+    get destroyed() {
+        return this[D];
+    }
+    get flowing() {
+        return this[L];
+    }
+    get paused() {
+        return this[x];
+    }
+    [O](t) {
+        if (this[_]) this[A] += 1; else this[A] += t.length;
+        this[P].push(t);
+    }
+    [R]() {
+        if (this[_]) this[A] -= 1; else this[A] -= this[P][0].length;
+        return this[P].shift();
+    }
+    [E](t = false) {
+        do {} while (this[S](this[R]()) && this[P].length);
+        if (!t && !this[P].length && !this[d]) this.emit("drain");
+    }
+    [S](t) {
+        this.emit("data", t);
+        return this[L];
+    }
+    pipe(t, e) {
+        if (this[D]) return t;
+        this[q] = false;
+        const s = this[p];
+        e = e || {};
+        if (t === a.stdout || t === a.stderr) e.end = false; else e.end = e.end !== false;
+        e.proxyErrors = !!e.proxyErrors;
+        if (s) {
+            if (e.end) t.end();
+        } else {
+            this[B].push(!e.proxyErrors ? new Pipe(this, t, e) : new PipeProxyErrors(this, t, e));
+            if (this[N]) z(() => this[M]()); else this[M]();
+        }
+        return t;
+    }
+    unpipe(t) {
+        const e = this[B].find(e => e.dest === t);
+        if (e) {
+            if (this[B].length === 1) {
+                if (this[L] && this[Y] === 0) {
+                    this[L] = false;
+                }
+                this[B] = [];
+            } else this[B].splice(this[B].indexOf(e), 1);
+            e.unpipe();
+        }
+    }
+    addListener(t, e) {
+        return this.on(t, e);
+    }
+    on(t, e) {
+        const s = super.on(t, e);
+        if (t === "data") {
+            this[q] = false;
+            this[Y]++;
+            if (!this[B].length && !this[L]) {
+                this[M]();
+            }
+        } else if (t === "readable" && this[A] !== 0) {
+            super.emit("readable");
+        } else if (H(t) && this[p]) {
+            super.emit(t);
+            this.removeAllListeners(t);
+        } else if (t === "error" && this[y]) {
+            const t = e;
+            if (this[N]) z(() => t.call(this, this[y])); else t.call(this, this[y]);
+        }
+        return s;
+    }
+    removeListener(t, e) {
+        return this.off(t, e);
+    }
+    off(t, e) {
+        const s = super.off(t, e);
+        if (t === "data") {
+            this[Y] = this.listeners("data").length;
+            if (this[Y] === 0 && !this[q] && !this[B].length) {
+                this[L] = false;
+            }
+        }
+        return s;
+    }
+    removeAllListeners(t) {
+        const e = super.removeAllListeners(t);
+        if (t === "data" || t === undefined) {
+            this[Y] = 0;
+            if (!this[q] && !this[B].length) {
+                this[L] = false;
+            }
+        }
+        return e;
+    }
+    get emittedEnd() {
+        return this[p];
+    }
+    [m]() {
+        if (!this[b] && !this[p] && !this[D] && this[P].length === 0 && this[d]) {
+            this[b] = true;
+            this.emit("end");
+            this.emit("prefinish");
+            this.emit("finish");
+            if (this[g]) this.emit("close");
+            this[b] = false;
+        }
+    }
+    emit(t, ...e) {
+        const s = e[0];
+        if (t !== "error" && t !== "close" && t !== D && this[D]) {
+            return false;
+        } else if (t === "data") {
+            return !this[_] && !s ? false : this[N] ? (z(() => this[W](s)), true) : this[W](s);
+        } else if (t === "end") {
+            return this[C]();
+        } else if (t === "close") {
+            this[g] = true;
+            if (!this[p] && !this[D]) return false;
+            const t = super.emit("close");
+            this.removeAllListeners("close");
+            return t;
+        } else if (t === "error") {
+            this[y] = s;
+            super.emit(T, s);
+            const t = !this[V] || this.listeners("error").length ? super.emit("error", s) : false;
+            this[m]();
+            return t;
+        } else if (t === "resume") {
+            const t = super.emit("resume");
+            this[m]();
+            return t;
+        } else if (t === "finish" || t === "prefinish") {
+            const e = super.emit(t);
+            this.removeAllListeners(t);
+            return e;
+        }
+        const i = super.emit(t, ...e);
+        this[m]();
+        return i;
+    }
+    [W](t) {
+        for (const e of this[B]) {
+            if (e.dest.write(t) === false) this.pause();
+        }
+        const e = this[q] ? false : super.emit("data", t);
+        this[m]();
+        return e;
+    }
+    [C]() {
+        if (this[p]) return false;
+        this[p] = true;
+        this.readable = false;
+        return this[N] ? (z(() => this[I]()), true) : this[I]();
+    }
+    [I]() {
+        if (this[j]) {
+            const t = this[j].end();
+            if (t) {
+                for (const e of this[B]) {
+                    e.dest.write(t);
+                }
+                if (!this[q]) super.emit("data", t);
+            }
+        }
+        for (const t of this[B]) {
+            t.end();
+        }
+        const t = super.emit("end");
+        this.removeAllListeners("end");
+        return t;
+    }
+    async collect() {
+        const t = Object.assign([], {
+            dataLength: 0
+        });
+        if (!this[_]) t.dataLength = 0;
+        const e = this.promise();
+        this.on("data", e => {
+            t.push(e);
+            if (!this[_]) t.dataLength += e.length;
+        });
+        await e;
+        return t;
+    }
+    async concat() {
+        if (this[_]) {
+            throw new Error("cannot concat in objectMode");
+        }
+        const t = await this.collect();
+        return this[v] ? t.join("") : Buffer.concat(t, t.dataLength);
+    }
+    async promise() {
+        return new Promise((t, e) => {
+            this.on(D, () => e(new Error("stream destroyed")));
+            this.on("error", t => e(t));
+            this.on("end", () => t());
+        });
+    }
+    [Symbol.asyncIterator]() {
+        this[q] = false;
+        let t = false;
+        const e = async () => {
+            this.pause();
+            t = true;
+            return {
+                value: undefined,
+                done: true
+            };
+        };
+        const s = () => {
+            if (t) return e();
+            const s = this.read();
+            if (s !== null) return Promise.resolve({
+                done: false,
+                value: s
+            });
+            if (this[d]) return e();
+            let i;
+            let r;
+            const n = t => {
+                this.off("data", o);
+                this.off("end", h);
+                this.off(D, f);
+                e();
+                r(t);
+            };
+            const o = t => {
+                this.off("error", n);
+                this.off("end", h);
+                this.off(D, f);
+                this.pause();
+                i({
+                    value: t,
+                    done: !!this[d]
+                });
+            };
+            const h = () => {
+                this.off("error", n);
+                this.off("data", o);
+                this.off(D, f);
+                e();
+                i({
+                    done: true,
+                    value: undefined
+                });
+            };
+            const f = () => n(new Error("stream destroyed"));
+            return new Promise((t, e) => {
+                r = e;
+                i = t;
+                this.once(D, f);
+                this.once("error", n);
+                this.once("end", h);
+                this.once("data", o);
+            });
+        };
+        return {
+            next: s,
+            throw: e,
+            return: e,
+            [Symbol.asyncIterator]() {
+                return this;
+            }
+        };
+    }
+    [Symbol.iterator]() {
+        this[q] = false;
+        let t = false;
+        const e = () => {
+            this.pause();
+            this.off(T, e);
+            this.off(D, e);
+            this.off("end", e);
+            t = true;
+            return {
+                done: true,
+                value: undefined
+            };
+        };
+        const s = () => {
+            if (t) return e();
+            const s = this.read();
+            return s === null ? e() : {
+                done: false,
+                value: s
+            };
+        };
+        this.once("end", e);
+        this.once(T, e);
+        this.once(D, e);
+        return {
+            next: s,
+            throw: e,
+            return: e,
+            [Symbol.iterator]() {
+                return this;
+            }
+        };
+    }
+    destroy(t) {
+        if (this[D]) {
+            if (t) this.emit("error", t); else this.emit(D);
+            return this;
+        }
+        this[D] = true;
+        this[q] = true;
+        this[P].length = 0;
+        this[A] = 0;
+        const e = this;
+        if (typeof e.close === "function" && !this[g]) e.close();
+        if (t) this.emit("error", t); else this.emit(D);
+        return this;
+    }
+    static get isStream() {
+        return l;
+    }
+}
 
-export { s as h };
+export { Minipass as M, f as r };