lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.109.cjs

@@ -1,1306 +1,96 @@
-/* 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("node:events");
-
-const s = require("node:stream");
-
-const i = require("node:string_decoder");
-
-const r = t => t && t.__esModule ? t : {
-    default: t
+var t = function t(e) {
+    return e != null && typeof e === "object" && Array.isArray(e) === false;
 };
 
-const n = r(e);
-
-const o = r(s);
-
-const h = r(i);
-
-var f = {};
-
-var l;
+const e = t;
 
-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
-            };
+exports.getValue = function(t, u, o) {
+    if (!e(o)) {
+        o = {
+            default: o
         };
-        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;
-            }
-        }
-        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);
-
-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);
+    if (!f(t)) {
+        return typeof o.default !== "undefined" ? o.default : t;
     }
-    proxyErrors(t) {}
-    end() {
-        this.unpipe();
-        if (this.opts.end) this.dest.end();
+    if (typeof u === "number") {
+        u = String(u);
     }
-}
-
-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);
+    const l = Array.isArray(u);
+    const a = typeof u === "string";
+    const s = o.separator || ".";
+    const c = o.joinChar || (typeof s === "string" ? s : ".");
+    if (!a && !l) {
+        return t;
     }
-    get aborted() {
-        return this[G];
+    if (a && u in t) {
+        return i(u, t, o) ? t[u] : o.default;
     }
-    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;
+    let y = l ? u : n(u, s, o);
+    let p = y.length;
+    let d = 0;
+    do {
+        let e = y[d];
+        if (typeof e === "number") {
+            e = String(e);
         }
-        if (typeof e === "function") {
-            s = e;
-            e = "utf8";
+        while (e && e.slice(-1) === "\\") {
+            e = r([ e.slice(0, -1), y[++d] || "" ], c, o);
         }
-        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 (e in t) {
+            if (!i(e, t, o)) {
+                return o.default;
             }
-        }
-        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();
+            t = t[e];
         } 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;
+            let n = false;
+            let f = d + 1;
+            while (f < p) {
+                e = r([ e, y[f++] ], c, o);
+                if (n = e in t) {
+                    if (!i(e, t, o)) {
+                        return o.default;
+                    }
+                    t = t[e];
+                    d = f - 1;
+                    break;
                 }
-                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;
+            if (!n) {
+                return o.default;
             }
         }
-        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");
+    } while (++d < p && f(t));
+    if (d === p) {
         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;
+    return o.default;
+};
+
+function r(t, e, r) {
+    if (typeof r.join === "function") {
+        return r.join(t);
     }
-    static get isStream() {
-        return c;
+    return t[0] + e + t[1];
+}
+
+function n(t, e, r) {
+    if (typeof r.split === "function") {
+        return r.split(t);
     }
+    return t.split(e);
 }
 
-exports.Minipass = Minipass;
+function i(t, e, r) {
+    if (typeof r.isValid === "function") {
+        return r.isValid(t, e);
+    }
+    return true;
+}
 
-exports.requireCommonjs = a;
+function f(t) {
+    return e(t) || Array.isArray(t) || typeof t === "function";
+}