lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.157.mjs

@@ -1,17 +1,31 @@
-/* Build Date: Mon Nov 24 2025 17:58:53 GMT+0800 (China Standard Time) */
-import { c as e } from "./Package.internal.8.mjs";
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
+import e from "node:os";
 
-import t from "events";
+import { p as t } from "./Package.internal.158.mjs";
 
-import r from "worker_threads";
+import { r as n } from "./Package.internal.19.mjs";
 
-import s from "path";
+import s from "node:events";
 
-import i from "url";
+import r from "node:diagnostics_channel";
 
-import n from "buffer";
+import { q as o } from "./Package.internal.159.mjs";
 
-import o from "assert";
+import { s as i } from "./Package.internal.160.mjs";
+
+import { o as l } from "./Package.internal.152.mjs";
+
+import c from "worker_threads";
+
+import a from "module";
+
+import f from "node:path";
+
+import { r as m } from "./Package.internal.33.mjs";
+
+import { r as u } from "./Package.internal.161.mjs";
+
+import { s as y } from "./Package.internal.162.mjs";
 
 
 // -- Shims --
@@ -21,513 +35,1506 @@ import cjsModule from 'node:module';
 const __filename = cjsUrl.fileURLToPath(import.meta.url);
 const __dirname = cjsPath.dirname(__filename);
 const require = cjsModule.createRequire(import.meta.url);
-var a = "3.1.0";
+var d = {
+    exports: {}
+};
+
+function p(e, t) {
+    return t;
+}
 
-const f = {
-    version: a
+var g = function e() {
+    const t = Error.prepareStackTrace;
+    Error.prepareStackTrace = p;
+    const n = (new Error).stack;
+    Error.prepareStackTrace = t;
+    if (!Array.isArray(n)) {
+        return undefined;
+    }
+    const s = n.slice(2);
+    const r = [];
+    for (const e of s) {
+        if (!e) {
+            continue;
+        }
+        r.push(e.getFileName());
+    }
+    return r;
 };
 
-var l;
+const h = Symbol("pino.setLevel");
 
-var u;
+const S = Symbol("pino.getLevel");
 
-function h() {
-    if (u) return l;
-    u = 1;
-    const e = 1e3;
-    function t(t, r, s, i, n) {
-        const o = Date.now() + i;
-        let a = Atomics.load(t, r);
-        if (a === s) {
-            n(null, "ok");
-            return;
+const v = Symbol("pino.levelVal");
+
+const b = Symbol("pino.levelComp");
+
+const w = Symbol("pino.useLevelLabels");
+
+const O = Symbol("pino.useOnlyCustomLevels");
+
+const L = Symbol("pino.mixin");
+
+const j = Symbol("pino.lsCache");
+
+const C = Symbol("pino.chindings");
+
+const x = Symbol("pino.asJson");
+
+const E = Symbol("pino.write");
+
+const k = Symbol("pino.redactFmt");
+
+const P = Symbol("pino.time");
+
+const T = Symbol("pino.timeSliceIndex");
+
+const F = Symbol("pino.stream");
+
+const D = Symbol("pino.stringify");
+
+const K = Symbol("pino.stringifySafe");
+
+const z = Symbol("pino.stringifiers");
+
+const N = Symbol("pino.end");
+
+const A = Symbol("pino.formatOpts");
+
+const _ = Symbol("pino.messageKey");
+
+const I = Symbol("pino.errorKey");
+
+const $ = Symbol("pino.nestedKey");
+
+const M = Symbol("pino.nestedKeyStr");
+
+const V = Symbol("pino.mixinMergeStrategy");
+
+const R = Symbol("pino.msgPrefix");
+
+const J = Symbol("pino.wildcardFirst");
+
+const U = Symbol.for("pino.serializers");
+
+const B = Symbol.for("pino.formatters");
+
+const G = Symbol.for("pino.hooks");
+
+const q = Symbol.for("pino.metadata");
+
+var H = {
+    setLevelSym: h,
+    getLevelSym: S,
+    levelValSym: v,
+    levelCompSym: b,
+    useLevelLabelsSym: w,
+    mixinSym: L,
+    lsCacheSym: j,
+    chindingsSym: C,
+    asJsonSym: x,
+    writeSym: E,
+    serializersSym: U,
+    redactFmtSym: k,
+    timeSym: P,
+    timeSliceIndexSym: T,
+    streamSym: F,
+    stringifySym: D,
+    stringifySafeSym: K,
+    stringifiersSym: z,
+    endSym: N,
+    formatOptsSym: A,
+    messageKeySym: _,
+    errorKeySym: I,
+    nestedKeySym: $,
+    wildcardFirstSym: J,
+    needsMetadataGsym: q,
+    useOnlyCustomLevelsSym: O,
+    formattersSym: B,
+    hooksSym: G,
+    nestedKeyStrSym: M,
+    mixinMergeStrategySym: V,
+    msgPrefixSym: R
+};
+
+const W = n;
+
+const {redactFmtSym: Y, wildcardFirstSym: Z} = H;
+
+const Q = /[^.[\]]+|\[([^[\]]*?)\]/g;
+
+const X = "[Redacted]";
+
+const ee = false;
+
+function te(e, t) {
+    const {paths: n, censor: s, remove: r} = ne(e);
+    const o = n.reduce((e, t) => {
+        Q.lastIndex = 0;
+        const n = Q.exec(t);
+        const s = Q.exec(t);
+        let r = n[1] !== undefined ? n[1].replace(/^(?:"|'|`)(.*)(?:"|'|`)$/, "$1") : n[0];
+        if (r === "*") {
+            r = Z;
         }
-        let f = a;
-        const l = i => {
-            if (Date.now() > o) {
-                n(null, "timed-out");
-            } else {
-                setTimeout(() => {
-                    f = a;
-                    a = Atomics.load(t, r);
-                    if (a === f) {
-                        l(i >= e ? e : i * 2);
-                    } else {
-                        if (a === s) n(null, "ok"); else n(null, "not-equal");
-                    }
-                }, i);
-            }
-        };
-        l(1);
-    }
-    function r(t, r, s, i, n) {
-        const o = Date.now() + i;
-        let a = Atomics.load(t, r);
-        if (a !== s) {
-            n(null, "ok");
-            return;
+        if (s === null) {
+            e[r] = null;
+            return e;
         }
-        const f = i => {
-            if (Date.now() > o) {
-                n(null, "timed-out");
-            } else {
-                setTimeout(() => {
-                    a = Atomics.load(t, r);
-                    if (a !== s) {
-                        n(null, "ok");
-                    } else {
-                        f(i >= e ? e : i * 2);
-                    }
-                }, i);
-            }
+        if (e[r] === null) {
+            return e;
+        }
+        const {index: o} = s;
+        const i = `${t.substr(o, t.length - 1)}`;
+        e[r] = e[r] || [];
+        if (r !== Z && e[r].length === 0) {
+            e[r].push(...e[Z] || []);
+        }
+        if (r === Z) {
+            Object.keys(e).forEach(function(t) {
+                if (e[t]) {
+                    e[t].push(i);
+                }
+            });
+        }
+        e[r].push(i);
+        return e;
+    }, {});
+    const i = {
+        [Y]: W({
+            paths: n,
+            censor: s,
+            serialize: t,
+            strict: ee,
+            remove: r
+        })
+    };
+    const l = (...e) => typeof s === "function" ? t(s(...e)) : t(s);
+    return [ ...Object.keys(o), ...Object.getOwnPropertySymbols(o) ].reduce((e, n) => {
+        if (o[n] === null) {
+            e[n] = e => l(e, [ n ]);
+        } else {
+            const i = typeof s === "function" ? (e, t) => s(e, [ n, ...t ]) : s;
+            e[n] = W({
+                paths: o[n],
+                censor: i,
+                serialize: t,
+                strict: ee,
+                remove: r
+            });
+        }
+        return e;
+    }, i);
+}
+
+function ne(e) {
+    if (Array.isArray(e)) {
+        e = {
+            paths: e,
+            censor: X
         };
-        f(1);
+        return e;
+    }
+    let {paths: t, censor: n = X, remove: s} = e;
+    if (Array.isArray(t) === false) {
+        throw Error("pino – redact must contain an array of strings");
     }
-    l = {
-        wait: t,
-        waitDiff: r
+    if (s === true) n = undefined;
+    return {
+        paths: t,
+        censor: n,
+        remove: s
     };
-    return l;
 }
 
-var c;
+var se = te;
 
-var d;
+const re = () => "";
 
-function m() {
-    if (d) return c;
-    d = 1;
-    const e = 4;
-    const t = 8;
-    c = {
-        WRITE_INDEX: e,
-        READ_INDEX: t
-    };
-    return c;
-}
-
-var w;
-
-var g;
-
-function k() {
-    if (g) return w;
-    g = 1;
-    const {version: a} = f;
-    const {EventEmitter: l} = t;
-    const {Worker: u} = r;
-    const {join: c} = s;
-    const {pathToFileURL: d} = i;
-    const {wait: k} = h();
-    const {WRITE_INDEX: b, READ_INDEX: y} = m();
-    const A = n;
-    const E = o;
-    const p = Symbol("kImpl");
-    const D = A.constants.MAX_STRING_LENGTH;
-    class FakeWeakRef {
-        constructor(e) {
-            this._value = e;
-        }
-        deref() {
-            return this._value;
-        }
-    }
-    class FakeFinalizationRegistry {
-        register() {}
-        unregister() {}
-    }
-    const R = process.env.NODE_V8_COVERAGE ? FakeFinalizationRegistry : e.FinalizationRegistry || FakeFinalizationRegistry;
-    const _ = process.env.NODE_V8_COVERAGE ? FakeWeakRef : e.WeakRef || FakeWeakRef;
-    const v = new R(e => {
-        if (e.exited) {
-            return;
+const oe = () => `,"time":${Date.now()}`;
+
+const ie = () => `,"time":${Math.round(Date.now() / 1e3)}`;
+
+const le = () => `,"time":"${new Date(Date.now()).toISOString()}"`;
+
+const ce = 1000000n;
+
+const ae = 1000000000n;
+
+const fe = BigInt(Date.now()) * ce;
+
+const me = process.hrtime.bigint();
+
+const ue = () => {
+    const e = process.hrtime.bigint() - me;
+    const t = fe + e;
+    const n = t / ae;
+    const s = t % ae;
+    const r = Number(n * 1000n + s / 1000000n);
+    const o = new Date(r);
+    const i = o.getUTCFullYear();
+    const l = (o.getUTCMonth() + 1).toString().padStart(2, "0");
+    const c = o.getUTCDate().toString().padStart(2, "0");
+    const a = o.getUTCHours().toString().padStart(2, "0");
+    const f = o.getUTCMinutes().toString().padStart(2, "0");
+    const m = o.getUTCSeconds().toString().padStart(2, "0");
+    return `,"time":"${i}-${l}-${c}T${a}:${f}:${m}.${s.toString().padStart(9, "0")}Z"`;
+};
+
+var ye = {
+    nullTime: re,
+    epochTime: oe,
+    unixTime: ie,
+    isoTime: le,
+    isoTimeNano: ue
+};
+
+var de;
+
+var pe;
+
+function ge() {
+    if (pe) return de;
+    pe = 1;
+    const {createRequire: e} = a;
+    const t = g;
+    const {join: n, isAbsolute: s, sep: r} = f;
+    const o = m();
+    const i = l;
+    const c = u();
+    function y(e) {
+        i.register(e, p);
+        i.registerBeforeExit(e, h);
+        e.on("close", function() {
+            i.unregister(e);
+        });
+    }
+    function d(e, t, n, s) {
+        const r = new c({
+            filename: e,
+            workerData: t,
+            workerOpts: n,
+            sync: s
+        });
+        r.on("ready", i);
+        r.on("close", function() {
+            process.removeListener("exit", l);
+        });
+        process.on("exit", l);
+        function i() {
+            process.removeListener("exit", l);
+            r.unref();
+            if (n.autoEnd !== false) {
+                y(r);
+            }
         }
-        e.terminate();
-    });
-    function x(e, t) {
-        const {filename: r, workerData: s} = t;
-        const i = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-        const n = i["thread-stream-worker"] || c(__dirname, "lib", "worker.js");
-        const o = new u(n, {
-            ...t.workerOpts,
-            trackUnmanagedFds: false,
-            workerData: {
-                filename: r.indexOf("file://") === 0 ? r : d(r).href,
-                dataBuf: e[p].dataBuf,
-                stateBuf: e[p].stateBuf,
-                workerData: {
-                    $context: {
-                        threadStreamVersion: a
-                    },
-                    ...s
-                }
+        function l() {
+            if (r.closed) {
+                return;
             }
+            r.flushSync();
+            o(100);
+            r.end();
+        }
+        return r;
+    }
+    function p(e) {
+        e.ref();
+        e.flushSync();
+        e.end();
+        e.once("close", function() {
+            e.unref();
         });
-        o.stream = new FakeWeakRef(e);
-        o.on("message", F);
-        o.on("exit", I);
-        v.register(e, o);
-        return o;
-    }
-    function T(e) {
-        E(!e[p].sync);
-        if (e[p].needDrain) {
-            e[p].needDrain = false;
-            e.emit("drain");
-        }
-    }
-    function B(e) {
-        const t = Atomics.load(e[p].state, b);
-        let r = e[p].data.length - t;
-        if (r > 0) {
-            if (e[p].buf.length === 0) {
-                e[p].flushing = false;
-                if (e[p].ending) {
-                    W(e);
-                } else if (e[p].needDrain) {
-                    process.nextTick(T, e);
+    }
+    function h(e) {
+        e.flushSync();
+    }
+    function S(o) {
+        const {pipeline: i, targets: l, levels: c, dedupe: a, worker: f = {}, caller: m = t(), sync: u = false} = o;
+        const y = {
+            ...o.options
+        };
+        const p = typeof m === "string" ? [ m ] : m;
+        const g = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
+        let h = o.target;
+        if (h && l) {
+            throw new Error("only one of target or targets can be specified");
+        }
+        if (l) {
+            h = g["pino-worker"] || n(__dirname, "worker.js");
+            y.targets = l.filter(e => e.target).map(e => ({
+                ...e,
+                target: S(e.target)
+            }));
+            y.pipelines = l.filter(e => e.pipeline).map(e => e.pipeline.map(t => ({
+                ...t,
+                level: e.level,
+                target: S(t.target)
+            })));
+        } else if (i) {
+            h = g["pino-worker"] || n(__dirname, "worker.js");
+            y.pipelines = [ i.map(e => ({
+                ...e,
+                target: S(e.target)
+            })) ];
+        }
+        if (c) {
+            y.levels = c;
+        }
+        if (a) {
+            y.dedupe = a;
+        }
+        y.pinoWillSendConfig = true;
+        return d(S(h), y, f, u);
+        function S(t) {
+            t = g[t] || t;
+            if (s(t) || t.indexOf("file://") === 0) {
+                return t;
+            }
+            if (t === "pino/file") {
+                return n(__dirname, "..", "file.js");
+            }
+            let o;
+            for (const n of p) {
+                try {
+                    const s = n === "node:repl" ? process.cwd() + r : n;
+                    o = e(s).resolve(t);
+                    break;
+                } catch (e) {
+                    continue;
+                }
+            }
+            if (!o) {
+                throw new Error(`unable to determine transport target for "${t}"`);
+            }
+            return o;
+        }
+    }
+    de = S;
+    return de;
+}
+
+const he = r;
+
+const Se = o;
+
+const {mapHttpRequest: ve, mapHttpResponse: be} = t;
+
+const we = i;
+
+const Oe = l;
+
+const {lsCacheSym: Le, chindingsSym: je, writeSym: Ce, serializersSym: xe, formatOptsSym: Ee, endSym: ke, stringifiersSym: Pe, stringifySym: Te, stringifySafeSym: Fe, wildcardFirstSym: De, nestedKeySym: Ke, formattersSym: ze, messageKeySym: Ne, errorKeySym: Ae, nestedKeyStrSym: _e, msgPrefixSym: Ie} = H;
+
+const {isMainThread: $e} = c;
+
+const Me = ge();
+
+const Ve = he.tracingChannel("pino_asJson");
+
+function Re() {}
+
+function Je(e, t) {
+    if (!t) return n;
+    return function s(...r) {
+        t.call(this, r, n, e);
+    };
+    function n(t, ...n) {
+        if (typeof t === "object") {
+            let s = t;
+            if (t !== null) {
+                if (t.method && t.headers && t.socket) {
+                    t = ve(t);
+                } else if (typeof t.setHeader === "function") {
+                    t = be(t);
                 }
-                return;
             }
-            let t = e[p].buf.slice(0, r);
-            let s = Buffer.byteLength(t);
-            if (s <= r) {
-                e[p].buf = e[p].buf.slice(r);
-                O(e, t, B.bind(null, e));
+            let r;
+            if (s === null && n.length === 0) {
+                r = [ null ];
             } else {
-                e.flush(() => {
-                    if (e.destroyed) {
-                        return;
-                    }
-                    Atomics.store(e[p].state, y, 0);
-                    Atomics.store(e[p].state, b, 0);
-                    while (s > e[p].data.length) {
-                        r = r / 2;
-                        t = e[p].buf.slice(0, r);
-                        s = Buffer.byteLength(t);
-                    }
-                    e[p].buf = e[p].buf.slice(r);
-                    O(e, t, B.bind(null, e));
-                });
+                s = n.shift();
+                r = n;
             }
-        } else if (r === 0) {
-            if (t === 0 && e[p].buf.length === 0) {
-                return;
+            if (typeof this[Ie] === "string" && s !== undefined && s !== null) {
+                s = this[Ie] + s;
             }
-            e.flush(() => {
-                Atomics.store(e[p].state, y, 0);
-                Atomics.store(e[p].state, b, 0);
-                B(e);
-            });
+            this[Ce](t, Se(s, r, this[Ee]), e);
         } else {
-            N(e, new Error("overwritten"));
+            let s = t === undefined ? n.shift() : t;
+            if (typeof this[Ie] === "string" && s !== undefined && s !== null) {
+                s = this[Ie] + s;
+            }
+            this[Ce](null, Se(s, n, this[Ee]), e);
         }
     }
-    function F(e) {
-        const t = this.stream.deref();
-        if (t === undefined) {
-            this.exited = true;
-            this.terminate();
-            return;
+}
+
+function Ue(e) {
+    let t = "";
+    let n = 0;
+    let s = false;
+    let r = 255;
+    const o = e.length;
+    if (o > 100) {
+        return JSON.stringify(e);
+    }
+    for (var i = 0; i < o && r >= 32; i++) {
+        r = e.charCodeAt(i);
+        if (r === 34 || r === 92) {
+            t += e.slice(n, i) + "\\";
+            n = i;
+            s = true;
         }
-        switch (e.code) {
-          case "READY":
-            this.stream = new _(t);
-            t.flush(() => {
-                t[p].ready = true;
-                t.emit("ready");
-            });
-            break;
+    }
+    if (!s) {
+        t = e;
+    } else {
+        t += e.slice(n);
+    }
+    return r < 32 ? JSON.stringify(e) : '"' + t + '"';
+}
+
+function Be(e, t, n, s) {
+    if (Ve.hasSubscribers === false) {
+        return Ge.call(this, e, t, n, s);
+    }
+    const r = {
+        instance: this,
+        arguments: arguments
+    };
+    return Ve.traceSync(Ge, r, this, e, t, n, s);
+}
+
+function Ge(e, t, n, s) {
+    const r = this[Te];
+    const o = this[Fe];
+    const i = this[Pe];
+    const l = this[ke];
+    const c = this[je];
+    const a = this[xe];
+    const f = this[ze];
+    const m = this[Ne];
+    const u = this[Ae];
+    let y = this[Le][n] + s;
+    y = y + c;
+    let d;
+    if (f.log) {
+        e = f.log(e);
+    }
+    const p = i[De];
+    let g = "";
+    for (const t in e) {
+        d = e[t];
+        if (Object.prototype.hasOwnProperty.call(e, t) && d !== undefined) {
+            if (a[t]) {
+                d = a[t](d);
+            } else if (t === u && a.err) {
+                d = a.err(d);
+            }
+            const e = i[t] || p;
+            switch (typeof d) {
+              case "undefined":
+              case "function":
+                continue;
 
-          case "ERROR":
-            N(t, e.err);
+              case "number":
+                if (Number.isFinite(d) === false) {
+                    d = null;
+                }
+
+              case "boolean":
+                if (e) d = e(d);
+                break;
+
+              case "string":
+                d = (e || Ue)(d);
+                break;
+
+              default:
+                d = (e || r)(d, o);
+            }
+            if (d === undefined) continue;
+            const n = Ue(t);
+            g += "," + n + ":" + d;
+        }
+    }
+    let h = "";
+    if (t !== undefined) {
+        d = a[m] ? a[m](t) : t;
+        const e = i[m] || p;
+        switch (typeof d) {
+          case "function":
             break;
 
-          case "EVENT":
-            if (Array.isArray(e.args)) {
-                t.emit(e.name, ...e.args);
-            } else {
-                t.emit(e.name, e.args);
+          case "number":
+            if (Number.isFinite(d) === false) {
+                d = null;
             }
+
+          case "boolean":
+            if (e) d = e(d);
+            h = ',"' + m + '":' + d;
             break;
 
-          case "WARNING":
-            process.emitWarning(e.err);
+          case "string":
+            d = (e || Ue)(d);
+            h = ',"' + m + '":' + d;
             break;
 
           default:
-            N(t, new Error("this should not happen: " + e.code));
+            d = (e || r)(d, o);
+            h = ',"' + m + '":' + d;
         }
     }
-    function I(e) {
-        const t = this.stream.deref();
-        if (t === undefined) {
+    if (this[Ke] && g) {
+        return y + this[_e] + g.slice(1) + "}" + h + l;
+    } else {
+        return y + g + h + l;
+    }
+}
+
+function qe(e, t) {
+    let n;
+    let s = e[je];
+    const r = e[Te];
+    const o = e[Fe];
+    const i = e[Pe];
+    const l = i[De];
+    const c = e[xe];
+    const a = e[ze].bindings;
+    t = a(t);
+    for (const e in t) {
+        n = t[e];
+        const a = (e.length < 5 || e !== "level" && e !== "serializers" && e !== "formatters" && e !== "customLevels") && t.hasOwnProperty(e) && n !== undefined;
+        if (a === true) {
+            n = c[e] ? c[e](n) : n;
+            n = (i[e] || l || r)(n, o);
+            if (n === undefined) continue;
+            s += ',"' + e + '":' + n;
+        }
+    }
+    return s;
+}
+
+function He(e) {
+    return e.write !== e.constructor.prototype.write;
+}
+
+function We(e) {
+    const t = new we(e);
+    t.on("error", n);
+    if (!e.sync && $e) {
+        Oe.register(t, Ye);
+        t.on("close", function() {
+            Oe.unregister(t);
+        });
+    }
+    return t;
+    function n(e) {
+        if (e.code === "EPIPE") {
+            t.write = Re;
+            t.end = Re;
+            t.flushSync = Re;
+            t.destroy = Re;
             return;
         }
-        v.unregister(t);
-        t.worker.exited = true;
-        t.worker.off("exit", I);
-        N(t, e !== 0 ? new Error("the worker thread exited") : null);
+        t.removeListener("error", n);
+        t.emit("error", e);
     }
-    class ThreadStream extends l {
-        constructor(e = {}) {
-            super();
-            if (e.bufferSize < 4) {
-                throw new Error("bufferSize must at least fit a 4-byte utf-8 char");
-            }
-            this[p] = {};
-            this[p].stateBuf = new SharedArrayBuffer(128);
-            this[p].state = new Int32Array(this[p].stateBuf);
-            this[p].dataBuf = new SharedArrayBuffer(e.bufferSize || 4 * 1024 * 1024);
-            this[p].data = Buffer.from(this[p].dataBuf);
-            this[p].sync = e.sync || false;
-            this[p].ending = false;
-            this[p].ended = false;
-            this[p].needDrain = false;
-            this[p].destroyed = false;
-            this[p].flushing = false;
-            this[p].ready = false;
-            this[p].finished = false;
-            this[p].errored = null;
-            this[p].closed = false;
-            this[p].buf = "";
-            this.worker = x(this, e);
-            this.on("message", (e, t) => {
-                this.worker.postMessage(e, t);
+}
+
+function Ye(e, t) {
+    if (e.destroyed) {
+        return;
+    }
+    if (t === "beforeExit") {
+        e.flush();
+        e.on("drain", function() {
+            e.end();
+        });
+    } else {
+        e.flushSync();
+    }
+}
+
+function Ze(e) {
+    return function t(n, s, r = {}, o) {
+        if (typeof r === "string") {
+            o = We({
+                dest: r
             });
-        }
-        write(e) {
-            if (this[p].destroyed) {
-                S(this, new Error("the worker has exited"));
-                return false;
+            r = {};
+        } else if (typeof o === "string") {
+            if (r && r.transport) {
+                throw Error("only one of option.transport or stream can be specified");
             }
-            if (this[p].ending) {
-                S(this, new Error("the worker is ending"));
-                return false;
+            o = We({
+                dest: o
+            });
+        } else if (r instanceof we || r.writable || r._writableState) {
+            o = r;
+            r = {};
+        } else if (r.transport) {
+            if (r.transport instanceof we || r.transport.writable || r.transport._writableState) {
+                throw Error("option.transport do not allow stream, please pass to option directly. e.g. pino(transport)");
             }
-            if (this[p].flushing && this[p].buf.length + e.length >= D) {
-                try {
-                    z(this);
-                    this[p].flushing = true;
-                } catch (e) {
-                    N(this, e);
-                    return false;
-                }
+            if (r.transport.targets && r.transport.targets.length && r.formatters && typeof r.formatters.level === "function") {
+                throw Error("option.transport.targets do not allow custom level formatters");
             }
-            this[p].buf += e;
-            if (this[p].sync) {
-                try {
-                    z(this);
-                    return true;
-                } catch (e) {
-                    N(this, e);
-                    return false;
-                }
-            }
-            if (!this[p].flushing) {
-                this[p].flushing = true;
-                setImmediate(B, this);
+            let e;
+            if (r.customLevels) {
+                e = r.useOnlyCustomLevels ? r.customLevels : Object.assign({}, r.levels, r.customLevels);
             }
-            this[p].needDrain = this[p].data.length - this[p].buf.length - Atomics.load(this[p].state, b) <= 0;
-            return !this[p].needDrain;
+            o = Me({
+                caller: s,
+                ...r.transport,
+                levels: e
+            });
         }
-        end() {
-            if (this[p].destroyed) {
-                return;
-            }
-            this[p].ending = true;
-            W(this);
+        r = Object.assign({}, e, r);
+        r.serializers = Object.assign({}, e.serializers, r.serializers);
+        r.formatters = Object.assign({}, e.formatters, r.formatters);
+        if (r.prettyPrint) {
+            throw new Error("prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)");
         }
-        flush(e) {
-            if (this[p].destroyed) {
-                if (typeof e === "function") {
-                    process.nextTick(e, new Error("the worker has exited"));
-                }
-                return;
+        const {enabled: i, onChild: l} = r;
+        if (i === false) r.level = "silent";
+        if (!l) r.onChild = Re;
+        if (!o) {
+            if (!He(process.stdout)) {
+                o = We({
+                    fd: process.stdout.fd || 1
+                });
+            } else {
+                o = process.stdout;
             }
-            const t = Atomics.load(this[p].state, b);
-            k(this[p].state, y, t, Infinity, (t, r) => {
-                if (t) {
-                    N(this, t);
-                    process.nextTick(e, t);
-                    return;
-                }
-                if (r === "not-equal") {
-                    this.flush(e);
-                    return;
-                }
-                process.nextTick(e);
-            });
         }
-        flushSync() {
-            if (this[p].destroyed) {
-                return;
+        return {
+            opts: r,
+            stream: o
+        };
+    };
+}
+
+function Qe(e, t) {
+    try {
+        return JSON.stringify(e);
+    } catch (n) {
+        try {
+            const n = t || this[Fe];
+            return n(e);
+        } catch (e) {
+            return '"[unable to serialize, circular reference is too complex to analyze]"';
+        }
+    }
+}
+
+function Xe(e, t, n) {
+    return {
+        level: e,
+        bindings: t,
+        log: n
+    };
+}
+
+function et(e) {
+    const t = Number(e);
+    if (typeof e === "string" && Number.isFinite(t)) {
+        return t;
+    }
+    if (e === undefined) {
+        return 1;
+    }
+    return e;
+}
+
+var tt = {
+    noop: Re,
+    buildSafeSonicBoom: We,
+    asChindings: qe,
+    asJson: Be,
+    genLog: Je,
+    createArgsNormalizer: Ze,
+    stringify: Qe,
+    buildFormatters: Xe,
+    normalizeDestFileDescriptor: et
+};
+
+const nt = {
+    trace: 10,
+    debug: 20,
+    info: 30,
+    warn: 40,
+    error: 50,
+    fatal: 60
+};
+
+const st = {
+    ASC: "ASC",
+    DESC: "DESC"
+};
+
+var rt = {
+    DEFAULT_LEVELS: nt,
+    SORTING_ORDER: st
+};
+
+const {lsCacheSym: ot, levelValSym: it, useOnlyCustomLevelsSym: lt, streamSym: ct, formattersSym: at, hooksSym: ft, levelCompSym: mt} = H;
+
+const {noop: ut, genLog: yt} = tt;
+
+const {DEFAULT_LEVELS: dt, SORTING_ORDER: pt} = rt;
+
+const gt = {
+    fatal: e => {
+        const t = yt(dt.fatal, e);
+        return function(...e) {
+            const n = this[ct];
+            t.call(this, ...e);
+            if (typeof n.flushSync === "function") {
+                try {
+                    n.flushSync();
+                } catch (e) {}
             }
-            z(this);
-            L(this);
+        };
+    },
+    error: e => yt(dt.error, e),
+    warn: e => yt(dt.warn, e),
+    info: e => yt(dt.info, e),
+    debug: e => yt(dt.debug, e),
+    trace: e => yt(dt.trace, e)
+};
+
+const ht = Object.keys(dt).reduce((e, t) => {
+    e[dt[t]] = t;
+    return e;
+}, {});
+
+const St = Object.keys(ht).reduce((e, t) => {
+    e[t] = '{"level":' + Number(t);
+    return e;
+}, {});
+
+function vt(e) {
+    const t = e[at].level;
+    const {labels: n} = e.levels;
+    const s = {};
+    for (const e in n) {
+        const r = t(n[e], Number(e));
+        s[e] = JSON.stringify(r).slice(0, -1);
+    }
+    e[ot] = s;
+    return e;
+}
+
+function bt(e, t) {
+    if (t) {
+        return false;
+    }
+    switch (e) {
+      case "fatal":
+      case "error":
+      case "warn":
+      case "info":
+      case "debug":
+      case "trace":
+        return true;
+
+      default:
+        return false;
+    }
+}
+
+function wt(e) {
+    const {labels: t, values: n} = this.levels;
+    if (typeof e === "number") {
+        if (t[e] === undefined) throw Error("unknown level value" + e);
+        e = t[e];
+    }
+    if (n[e] === undefined) throw Error("unknown level " + e);
+    const s = this[it];
+    const r = this[it] = n[e];
+    const o = this[lt];
+    const i = this[mt];
+    const l = this[ft].logMethod;
+    for (const e in n) {
+        if (i(n[e], r) === false) {
+            this[e] = ut;
+            continue;
+        }
+        this[e] = bt(e, o) ? gt[e](l) : yt(n[e], l);
+    }
+    this.emit("level-change", e, r, t[s], s, this);
+}
+
+function Ot(e) {
+    const {levels: t, levelVal: n} = this;
+    return t && t.labels ? t.labels[n] : "";
+}
+
+function Lt(e) {
+    const {values: t} = this.levels;
+    const n = t[e];
+    return n !== undefined && this[mt](n, this[it]);
+}
+
+function jt(e, t, n) {
+    if (e === pt.DESC) {
+        return t <= n;
+    }
+    return t >= n;
+}
+
+function Ct(e) {
+    if (typeof e === "string") {
+        return jt.bind(null, e);
+    }
+    return e;
+}
+
+function xt(e = null, t = false) {
+    const n = e ? Object.keys(e).reduce((t, n) => {
+        t[e[n]] = n;
+        return t;
+    }, {}) : null;
+    const s = Object.assign(Object.create(Object.prototype, {
+        Infinity: {
+            value: "silent"
         }
-        unref() {
-            this.worker.unref();
+    }), t ? null : ht, n);
+    const r = Object.assign(Object.create(Object.prototype, {
+        silent: {
+            value: Infinity
         }
-        ref() {
-            this.worker.ref();
+    }), t ? null : dt, e);
+    return {
+        labels: s,
+        values: r
+    };
+}
+
+function Et(e, t, n) {
+    if (typeof e === "number") {
+        const s = [].concat(Object.keys(t || {}).map(e => t[e]), n ? [] : Object.keys(ht).map(e => +e), Infinity);
+        if (!s.includes(e)) {
+            throw Error(`default level:${e} must be included in custom levels`);
         }
-        get ready() {
-            return this[p].ready;
+        return;
+    }
+    const s = Object.assign(Object.create(Object.prototype, {
+        silent: {
+            value: Infinity
         }
-        get destroyed() {
-            return this[p].destroyed;
+    }), n ? null : dt, t);
+    if (!(e in s)) {
+        throw Error(`default level:${e} must be included in custom levels`);
+    }
+}
+
+function kt(e, t) {
+    const {labels: n, values: s} = e;
+    for (const e in t) {
+        if (e in s) {
+            throw Error("levels cannot be overridden");
         }
-        get closed() {
-            return this[p].closed;
+        if (t[e] in n) {
+            throw Error("pre-existing level values cannot be used for new levels");
         }
-        get writable() {
-            return !this[p].destroyed && !this[p].ending;
+    }
+}
+
+function Pt(e) {
+    if (typeof e === "function") {
+        return;
+    }
+    if (typeof e === "string" && Object.values(pt).includes(e)) {
+        return;
+    }
+    throw new Error('Levels comparison should be one of "ASC", "DESC" or "function" type');
+}
+
+var Tt = {
+    initialLsCache: St,
+    genLsCache: vt,
+    levelMethods: gt,
+    getLevel: Ot,
+    setLevel: wt,
+    isLevelEnabled: Lt,
+    mappings: xt,
+    assertNoLevelCollisions: kt,
+    assertDefaultLevelFound: Et,
+    genLevelComparison: Ct,
+    assertLevelComparison: Pt
+};
+
+var Ft = {
+    version: "10.1.0"
+};
+
+const {EventEmitter: Dt} = s;
+
+const {lsCacheSym: Kt, levelValSym: zt, setLevelSym: Nt, getLevelSym: At, chindingsSym: _t, mixinSym: It, asJsonSym: $t, writeSym: Mt, mixinMergeStrategySym: Vt, timeSym: Rt, timeSliceIndexSym: Jt, streamSym: Ut, serializersSym: Bt, formattersSym: Gt, errorKeySym: qt, messageKeySym: Ht, useOnlyCustomLevelsSym: Wt, needsMetadataGsym: Yt, redactFmtSym: Zt, stringifySym: Qt, formatOptsSym: Xt, stringifiersSym: en, msgPrefixSym: tn, hooksSym: nn} = H;
+
+const {getLevel: sn, setLevel: rn, isLevelEnabled: on, mappings: ln, initialLsCache: cn, genLsCache: an, assertNoLevelCollisions: fn} = Tt;
+
+const {asChindings: mn, asJson: un, buildFormatters: yn, stringify: dn, noop: pn} = tt;
+
+const {version: gn} = Ft;
+
+const hn = se;
+
+const Sn = class Pino {};
+
+const vn = {
+    constructor: Sn,
+    child: On,
+    bindings: Ln,
+    setBindings: jn,
+    flush: En,
+    isLevelEnabled: on,
+    version: gn,
+    get level() {
+        return this[At]();
+    },
+    set level(e) {
+        this[Nt](e);
+    },
+    get levelVal() {
+        return this[zt];
+    },
+    set levelVal(e) {
+        throw Error("levelVal is read-only");
+    },
+    get msgPrefix() {
+        return this[tn];
+    },
+    get [Symbol.toStringTag]() {
+        return "Pino";
+    },
+    [Kt]: cn,
+    [Mt]: xn,
+    [$t]: un,
+    [At]: sn,
+    [Nt]: rn
+};
+
+Object.setPrototypeOf(vn, Dt.prototype);
+
+var bn = function() {
+    return Object.create(vn);
+};
+
+const wn = e => e;
+
+function On(e, t) {
+    if (!e) {
+        throw Error("missing bindings for child Pino");
+    }
+    const n = this[Bt];
+    const s = this[Gt];
+    const r = Object.create(this);
+    if (t == null) {
+        if (r[Gt].bindings !== wn) {
+            r[Gt] = yn(s.level, wn, s.log);
         }
-        get writableEnded() {
-            return this[p].ending;
+        r[_t] = mn(r, e);
+        if (this.onChild !== pn) {
+            this.onChild(r);
         }
-        get writableFinished() {
-            return this[p].finished;
+        return r;
+    }
+    if (t.hasOwnProperty("serializers") === true) {
+        r[Bt] = Object.create(null);
+        for (const e in n) {
+            r[Bt][e] = n[e];
         }
-        get writableNeedDrain() {
-            return this[p].needDrain;
+        const e = Object.getOwnPropertySymbols(n);
+        for (var o = 0; o < e.length; o++) {
+            const t = e[o];
+            r[Bt][t] = n[t];
         }
-        get writableObjectMode() {
-            return false;
+        for (const e in t.serializers) {
+            r[Bt][e] = t.serializers[e];
         }
-        get writableErrored() {
-            return this[p].errored;
+        const s = Object.getOwnPropertySymbols(t.serializers);
+        for (var i = 0; i < s.length; i++) {
+            const e = s[i];
+            r[Bt][e] = t.serializers[e];
         }
+    } else r[Bt] = n;
+    if (t.hasOwnProperty("formatters")) {
+        const {level: e, bindings: n, log: o} = t.formatters;
+        r[Gt] = yn(e || s.level, n || wn, o || s.log);
+    } else {
+        r[Gt] = yn(s.level, wn, s.log);
     }
-    function S(e, t) {
-        setImmediate(() => {
-            e.emit("error", t);
-        });
+    if (t.hasOwnProperty("customLevels") === true) {
+        fn(this.levels, t.customLevels);
+        r.levels = ln(t.customLevels, r[Wt]);
+        an(r);
     }
-    function N(e, t) {
-        if (e[p].destroyed) {
-            return;
+    if (typeof t.redact === "object" && t.redact !== null || Array.isArray(t.redact)) {
+        r.redact = t.redact;
+        const e = hn(r.redact, dn);
+        const n = {
+            stringify: e[Zt]
+        };
+        r[Qt] = dn;
+        r[en] = e;
+        r[Xt] = n;
+    }
+    if (typeof t.msgPrefix === "string") {
+        r[tn] = (this[tn] || "") + t.msgPrefix;
+    }
+    r[_t] = mn(r, e);
+    if (t.level !== undefined && t.level !== this.level || t.hasOwnProperty("customLevels")) {
+        const e = t.level || this.level;
+        r[Nt](e);
+    }
+    this.onChild(r);
+    return r;
+}
+
+function Ln() {
+    const e = this[_t];
+    const t = `{${e.substr(1)}}`;
+    const n = JSON.parse(t);
+    delete n.pid;
+    delete n.hostname;
+    return n;
+}
+
+function jn(e) {
+    const t = mn(this, e);
+    this[_t] = t;
+}
+
+function Cn(e, t) {
+    return Object.assign(t, e);
+}
+
+function xn(e, t, n) {
+    const s = this[Rt]();
+    const r = this[It];
+    const o = this[qt];
+    const i = this[Ht];
+    const l = this[Vt] || Cn;
+    let c;
+    const a = this[nn].streamWrite;
+    if (e === undefined || e === null) {
+        c = {};
+    } else if (e instanceof Error) {
+        c = {
+            [o]: e
+        };
+        if (t === undefined) {
+            t = e.message;
         }
-        e[p].destroyed = true;
-        if (t) {
-            e[p].errored = t;
-            S(e, t);
+    } else {
+        c = e;
+        if (t === undefined && e[i] === undefined && e[o]) {
+            t = e[o].message;
         }
-        if (!e.worker.exited) {
-            e.worker.terminate().catch(() => {}).then(() => {
-                e[p].closed = true;
-                e.emit("close");
+    }
+    if (r) {
+        c = l(c, r(c, n, this));
+    }
+    const f = this[$t](c, t, n, s);
+    const m = this[Ut];
+    if (m[Yt] === true) {
+        m.lastLevel = n;
+        m.lastObj = c;
+        m.lastMsg = t;
+        m.lastTime = s.slice(this[Jt]);
+        m.lastLogger = this;
+    }
+    m.write(a ? a(f) : f);
+}
+
+function En(e) {
+    if (e != null && typeof e !== "function") {
+        throw Error("callback must be a function");
+    }
+    const t = this[Ut];
+    if (typeof t.flush === "function") {
+        t.flush(e || pn);
+    } else if (e) e();
+}
+
+var kn;
+
+var Pn;
+
+function Tn() {
+    if (Pn) return kn;
+    Pn = 1;
+    const e = Symbol.for("pino.metadata");
+    const {DEFAULT_LEVELS: t} = rt;
+    const n = t.info;
+    function s(s, c) {
+        s = s || [];
+        c = c || {
+            dedupe: false
+        };
+        const a = Object.create(t);
+        a.silent = Infinity;
+        if (c.levels && typeof c.levels === "object") {
+            Object.keys(c.levels).forEach(e => {
+                a[e] = c.levels[e];
             });
+        }
+        const f = {
+            write: m,
+            add: d,
+            remove: p,
+            emit: u,
+            flushSync: y,
+            end: g,
+            minLevel: 0,
+            lastId: 0,
+            streams: [],
+            clone: h,
+            [e]: true,
+            streamLevels: a
+        };
+        if (Array.isArray(s)) {
+            s.forEach(d, f);
         } else {
-            setImmediate(() => {
-                e[p].closed = true;
-                e.emit("close");
-            });
+            d.call(f, s);
         }
-    }
-    function O(e, t, r) {
-        const s = Atomics.load(e[p].state, b);
-        const i = Buffer.byteLength(t);
-        e[p].data.write(t, s);
-        Atomics.store(e[p].state, b, s + i);
-        Atomics.notify(e[p].state, b);
-        r();
-        return true;
-    }
-    function W(e) {
-        if (e[p].ended || !e[p].ending || e[p].flushing) {
-            return;
+        s = null;
+        return f;
+        function m(t) {
+            let n;
+            const s = this.lastLevel;
+            const {streams: r} = this;
+            let a = 0;
+            let f;
+            for (let m = o(r.length, c.dedupe); l(m, r.length, c.dedupe); m = i(m, c.dedupe)) {
+                n = r[m];
+                if (n.level <= s) {
+                    if (a !== 0 && a !== n.level) {
+                        break;
+                    }
+                    f = n.stream;
+                    if (f[e]) {
+                        const {lastTime: e, lastMsg: t, lastObj: n, lastLogger: r} = this;
+                        f.lastLevel = s;
+                        f.lastTime = e;
+                        f.lastMsg = t;
+                        f.lastObj = n;
+                        f.lastLogger = r;
+                    }
+                    f.write(t);
+                    if (c.dedupe) {
+                        a = n.level;
+                    }
+                } else if (!c.dedupe) {
+                    break;
+                }
+            }
         }
-        e[p].ended = true;
-        try {
-            e.flushSync();
-            let t = Atomics.load(e[p].state, y);
-            Atomics.store(e[p].state, b, -1);
-            Atomics.notify(e[p].state, b);
-            let r = 0;
-            while (t !== -1) {
-                Atomics.wait(e[p].state, y, t, 1e3);
-                t = Atomics.load(e[p].state, y);
-                if (t === -2) {
-                    N(e, new Error("end() failed"));
-                    return;
+        function u(...e) {
+            for (const {stream: t} of this.streams) {
+                if (typeof t.emit === "function") {
+                    t.emit(...e);
                 }
-                if (++r === 10) {
-                    N(e, new Error("end() took too long (10s)"));
-                    return;
+            }
+        }
+        function y() {
+            for (const {stream: e} of this.streams) {
+                if (typeof e.flushSync === "function") {
+                    e.flushSync();
                 }
             }
-            process.nextTick(() => {
-                e[p].finished = true;
-                e.emit("finish");
-            });
-        } catch (t) {
-            N(e, t);
         }
-    }
-    function z(e) {
-        const t = () => {
-            if (e[p].ending) {
-                W(e);
-            } else if (e[p].needDrain) {
-                process.nextTick(T, e);
+        function d(e) {
+            if (!e) {
+                return f;
             }
-        };
-        e[p].flushing = false;
-        while (e[p].buf.length !== 0) {
-            const r = Atomics.load(e[p].state, b);
-            let s = e[p].data.length - r;
-            if (s === 0) {
-                L(e);
-                Atomics.store(e[p].state, y, 0);
-                Atomics.store(e[p].state, b, 0);
-                continue;
-            } else if (s < 0) {
-                throw new Error("overwritten");
+            const t = typeof e.write === "function" || e.stream;
+            const s = e.write ? e : e.stream;
+            if (!t) {
+                throw Error("stream object needs to implement either StreamEntry or DestinationStream interface");
             }
-            let i = e[p].buf.slice(0, s);
-            let n = Buffer.byteLength(i);
-            if (n <= s) {
-                e[p].buf = e[p].buf.slice(s);
-                O(e, i, t);
+            const {streams: o, streamLevels: i} = this;
+            let l;
+            if (typeof e.levelVal === "number") {
+                l = e.levelVal;
+            } else if (typeof e.level === "string") {
+                l = i[e.level];
+            } else if (typeof e.level === "number") {
+                l = e.level;
             } else {
-                L(e);
-                Atomics.store(e[p].state, y, 0);
-                Atomics.store(e[p].state, b, 0);
-                while (n > e[p].buf.length) {
-                    s = s / 2;
-                    i = e[p].buf.slice(0, s);
-                    n = Buffer.byteLength(i);
-                }
-                e[p].buf = e[p].buf.slice(s);
-                O(e, i, t);
+                l = n;
             }
+            const c = {
+                stream: s,
+                level: l,
+                levelVal: undefined,
+                id: ++f.lastId
+            };
+            o.unshift(c);
+            o.sort(r);
+            this.minLevel = o[0].level;
+            return f;
         }
-    }
-    function L(e) {
-        if (e[p].flushing) {
-            throw new Error("unable to flush while flushing");
-        }
-        const t = Atomics.load(e[p].state, b);
-        let r = 0;
-        while (true) {
-            const s = Atomics.load(e[p].state, y);
-            if (s === -2) {
-                throw Error("_flushSync failed");
+        function p(e) {
+            const {streams: t} = this;
+            const n = t.findIndex(t => t.id === e);
+            if (n >= 0) {
+                t.splice(n, 1);
+                t.sort(r);
+                this.minLevel = t.length > 0 ? t[0].level : -1;
             }
-            if (s !== t) {
-                Atomics.wait(e[p].state, y, s, 1e3);
-            } else {
-                break;
+            return f;
+        }
+        function g() {
+            for (const {stream: e} of this.streams) {
+                if (typeof e.flushSync === "function") {
+                    e.flushSync();
+                }
+                e.end();
             }
-            if (++r === 10) {
-                throw new Error("_flushSync took too long (10s)");
+        }
+        function h(t) {
+            const n = new Array(this.streams.length);
+            for (let e = 0; e < n.length; e++) {
+                n[e] = {
+                    level: t,
+                    stream: this.streams[e].stream
+                };
             }
+            return {
+                write: m,
+                add: d,
+                remove: p,
+                minLevel: t,
+                streams: n,
+                clone: h,
+                emit: u,
+                flushSync: y,
+                [e]: true
+            };
+        }
+    }
+    function r(e, t) {
+        return e.level - t.level;
+    }
+    function o(e, t) {
+        return t ? e - 1 : 0;
+    }
+    function i(e, t) {
+        return t ? e - 1 : e + 1;
+    }
+    function l(e, t, n) {
+        return n ? e >= 0 : e < t;
+    }
+    kn = s;
+    return kn;
+}
+
+d.exports;
+
+const Fn = e;
+
+const Dn = t;
+
+const Kn = g;
+
+const zn = se;
+
+const Nn = ye;
+
+const An = bn;
+
+const _n = H;
+
+const {configure: In} = y;
+
+const {assertDefaultLevelFound: $n, mappings: Mn, genLsCache: Vn, genLevelComparison: Rn, assertLevelComparison: Jn} = Tt;
+
+const {DEFAULT_LEVELS: Un, SORTING_ORDER: Bn} = rt;
+
+const {createArgsNormalizer: Gn, asChindings: qn, buildSafeSonicBoom: Hn, buildFormatters: Wn, stringify: Yn, normalizeDestFileDescriptor: Zn, noop: Qn} = tt;
+
+const {version: Xn} = Ft;
+
+const {chindingsSym: es, redactFmtSym: ts, serializersSym: ns, timeSym: ss, timeSliceIndexSym: rs, streamSym: os, stringifySym: is, stringifySafeSym: ls, stringifiersSym: cs, setLevelSym: as, endSym: fs, formatOptsSym: ms, messageKeySym: us, errorKeySym: ys, nestedKeySym: ds, mixinSym: ps, levelCompSym: gs, useOnlyCustomLevelsSym: hs, formattersSym: Ss, hooksSym: vs, nestedKeyStrSym: bs, mixinMergeStrategySym: ws, msgPrefixSym: Os} = _n;
+
+const {epochTime: Ls, nullTime: js} = Nn;
+
+const {pid: Cs} = process;
+
+const xs = Fn.hostname();
+
+const Es = Dn.err;
+
+const ks = {
+    level: "info",
+    levelComparison: Bn.ASC,
+    levels: Un,
+    messageKey: "msg",
+    errorKey: "err",
+    nestedKey: null,
+    enabled: true,
+    base: {
+        pid: Cs,
+        hostname: xs
+    },
+    serializers: Object.assign(Object.create(null), {
+        err: Es
+    }),
+    formatters: Object.assign(Object.create(null), {
+        bindings(e) {
+            return e;
+        },
+        level(e, t) {
+            return {
+                level: t
+            };
+        }
+    }),
+    hooks: {
+        logMethod: undefined,
+        streamWrite: undefined
+    },
+    timestamp: Ls,
+    name: undefined,
+    redact: null,
+    customLevels: null,
+    useOnlyCustomLevels: false,
+    depthLimit: 5,
+    edgeLimit: 100
+};
+
+const Ps = Gn(ks);
+
+const Ts = Object.assign(Object.create(null), Dn);
+
+function Fs(...e) {
+    const t = {};
+    const {opts: n, stream: s} = Ps(t, Kn(), ...e);
+    if (n.level && typeof n.level === "string" && Un[n.level.toLowerCase()] !== undefined) n.level = n.level.toLowerCase();
+    const {redact: r, crlf: o, serializers: i, timestamp: l, messageKey: c, errorKey: a, nestedKey: f, base: m, name: u, level: y, customLevels: d, levelComparison: p, mixin: g, mixinMergeStrategy: h, useOnlyCustomLevels: S, formatters: v, hooks: b, depthLimit: w, edgeLimit: O, onChild: L, msgPrefix: j} = n;
+    const C = In({
+        maximumDepth: w,
+        maximumBreadth: O
+    });
+    const x = Wn(v.level, v.bindings, v.log);
+    const E = Yn.bind({
+        [ls]: C
+    });
+    const k = r ? zn(r, E) : {};
+    const P = r ? {
+        stringify: k[ts]
+    } : {
+        stringify: E
+    };
+    const T = "}" + (o ? "\r\n" : "\n");
+    const F = qn.bind(null, {
+        [es]: "",
+        [ns]: i,
+        [cs]: k,
+        [is]: Yn,
+        [ls]: C,
+        [Ss]: x
+    });
+    let D = "";
+    if (m !== null) {
+        if (u === undefined) {
+            D = F(m);
+        } else {
+            D = F(Object.assign({}, m, {
+                name: u
+            }));
         }
     }
-    w = ThreadStream;
-    return w;
+    const K = l instanceof Function ? l : l ? Ls : js;
+    const z = K().indexOf(":") + 1;
+    if (S && !d) throw Error("customLevels is required if useOnlyCustomLevels is set true");
+    if (g && typeof g !== "function") throw Error(`Unknown mixin type "${typeof g}" - expected "function"`);
+    if (j && typeof j !== "string") throw Error(`Unknown msgPrefix type "${typeof j}" - expected "string"`);
+    $n(y, d, S);
+    const N = Mn(d, S);
+    if (typeof s.emit === "function") {
+        s.emit("message", {
+            code: "PINO_CONFIG",
+            config: {
+                levels: N,
+                messageKey: c,
+                errorKey: a
+            }
+        });
+    }
+    Jn(p);
+    const A = Rn(p);
+    Object.assign(t, {
+        levels: N,
+        [gs]: A,
+        [hs]: S,
+        [os]: s,
+        [ss]: K,
+        [rs]: z,
+        [is]: Yn,
+        [ls]: C,
+        [cs]: k,
+        [fs]: T,
+        [ms]: P,
+        [us]: c,
+        [ys]: a,
+        [ds]: f,
+        [bs]: f ? `,${JSON.stringify(f)}:{` : "",
+        [ns]: i,
+        [ps]: g,
+        [ws]: h,
+        [es]: D,
+        [Ss]: x,
+        [vs]: b,
+        silent: Qn,
+        onChild: L,
+        [Os]: j
+    });
+    Object.setPrototypeOf(t, An());
+    Vn(t);
+    t[as](y);
+    return t;
 }
 
-export { k as r };
+d.exports = Fs;
+
+var Ds = d.exports.destination = (e = process.stdout.fd) => {
+    if (typeof e === "object") {
+        e.dest = Zn(e.dest || process.stdout.fd);
+        return Hn(e);
+    } else {
+        return Hn({
+            dest: Zn(e),
+            minLength: 0
+        });
+    }
+};
+
+d.exports.transport = ge();
+
+var Ks = d.exports.multistream = Tn();
+
+d.exports.levels = Mn();
+
+d.exports.stdSerializers = Ts;
+
+d.exports.stdTimeFunctions = Object.assign({}, Nn);
+
+d.exports.symbols = _n;
+
+d.exports.version = Xn;
+
+d.exports.default = Fs;
+
+var zs = d.exports.pino = Fs;
+
+d.exports;
+
+export { Ds as d, Ks as m, zs as p };