lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.113.cjs

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