lakutata 2.0.95 → 2.0.96

package/vendor/Package.internal.157.cjs

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