lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.161.cjs

@@ -1,1224 +1,543 @@
-/* Build Date: Mon Nov 24 2025 00:55:42 GMT+0800 (China Standard Time) */
+/* Build Date: Mon Nov 24 2025 18:02:01 GMT+0800 (China Standard Time) */
 "use strict";
 
 const e = require("./Package.internal.8.cjs");
 
-const t = require("./Package.internal.55.cjs");
+const t = require("events");
 
-const o = require("./Package.internal.162.cjs");
+const r = require("worker_threads");
 
-const n = require("node:stream");
+const s = require("path");
 
-const r = require("./Package.internal.159.cjs");
+const i = require("url");
 
-const s = require("node:worker_threads");
+const n = require("buffer");
 
-const c = require("./Package.internal.156.cjs");
+const o = require("assert");
 
-const i = require("./Package.internal.148.cjs");
-
-const l = require("./Package.internal.86.cjs");
-
-const u = require("./Package.internal.61.cjs");
-
-const a = require("./Package.internal.92.cjs");
-
-const f = e => e && e.__esModule ? e : {
+const a = e => e && e.__esModule ? e : {
     default: e
 };
 
-const p = f(n);
-
-const m = f(s);
+const f = a(t);
 
-var y = {
-    exports: {}
-};
+const u = a(r);
 
-var d = {
-    DATE_FORMAT: "yyyy-mm-dd HH:MM:ss.l o",
-    DATE_FORMAT_SIMPLE: "HH:MM:ss.l",
-    ERROR_LIKE_KEYS: [ "err", "error" ],
-    MESSAGE_KEY: "msg",
-    LEVEL_KEY: "level",
-    LEVEL_LABEL: "levelLabel",
-    TIMESTAMP_KEY: "time",
-    LEVELS: {
-        default: "USERLVL",
-        60: "FATAL",
-        50: "ERROR",
-        40: "WARN",
-        30: "INFO",
-        20: "DEBUG",
-        10: "TRACE"
-    },
-    LEVEL_NAMES: {
-        fatal: 60,
-        error: 50,
-        warn: 40,
-        info: 30,
-        debug: 20,
-        trace: 10
-    },
-    LOGGER_KEYS: [ "pid", "hostname", "name", "level", "time", "timestamp", "caller" ]
-};
+const l = a(s);
 
-var g = h;
+const c = a(i);
 
-const {LEVELS: L, LEVEL_NAMES: E} = d;
+const h = a(n);
 
-function h(e, t, o) {
-    const n = e ? t || L : Object.assign({}, L, t);
-    const r = e ? o || E : Object.assign({}, E, o);
-    return function(e) {
-        let t = "default";
-        if (Number.isInteger(+e)) {
-            t = Object.prototype.hasOwnProperty.call(n, e) ? e : t;
-        } else {
-            t = Object.prototype.hasOwnProperty.call(r, e.toLowerCase()) ? r[e.toLowerCase()] : t;
-        }
-        return [ n[t], t ];
-    };
-}
+const d = a(o);
 
-const v = e => e;
+var m = "3.1.0";
 
-const b = {
-    default: v,
-    60: v,
-    50: v,
-    40: v,
-    30: v,
-    20: v,
-    10: v,
-    message: v,
-    greyMessage: v,
-    property: v
+const w = {
+    version: m
 };
 
-const {createColors: O} = t.colorette;
-
-const j = g;
+var g;
 
-const x = O({
-    useColor: true
-});
+var b;
 
-const {white: K, bgRed: P, red: S, yellow: C, green: _, blue: k, gray: $, cyan: A, magenta: T} = x;
-
-const M = {
-    default: K,
-    60: P,
-    50: S,
-    40: C,
-    30: _,
-    20: k,
-    10: $,
-    message: A,
-    greyMessage: $,
-    property: T
-};
-
-function w(e) {
-    return e.reduce(function(e, [t, o]) {
-        e[t] = typeof x[o] === "function" ? x[o] : K;
-        return e;
-    }, {
-        default: K,
-        message: A,
-        greyMessage: $,
-        property: T
-    });
-}
-
-function F(e) {
-    return function(t, o, {customLevels: n, customLevelNames: r} = {}) {
-        const [s, c] = j(e, n, r)(t);
-        return Object.prototype.hasOwnProperty.call(o, c) ? o[c](s) : o.default(s);
-    };
-}
-
-function N(e) {
-    const t = F(e);
-    const o = function(e, o) {
-        return t(e, b, o);
-    };
-    o.message = b.message;
-    o.greyMessage = b.greyMessage;
-    o.property = b.property;
-    o.colors = O({
-        useColor: false
-    });
-    return o;
-}
-
-function R(e) {
-    const t = F(e);
-    const o = function(e, o) {
-        return t(e, M, o);
-    };
-    o.message = M.message;
-    o.property = M.property;
-    o.greyMessage = M.greyMessage;
-    o.colors = x;
-    return o;
-}
-
-function D(e, t) {
-    const o = w(e);
-    const n = t ? o : Object.assign({}, M, o);
-    const r = F(t);
-    const s = function(e, t) {
-        return r(e, n, t);
-    };
-    s.colors = x;
-    s.message = s.message || n.message;
-    s.property = s.property || n.property;
-    s.greyMessage = s.greyMessage || n.greyMessage;
-    return s;
-}
-
-var V = function e(t = false, o, n) {
-    if (t && o !== undefined) {
-        return D(o, n);
-    } else if (t) {
-        return R(n);
-    }
-    return N(n);
-};
-
-var I = function e() {};
-
-var z = U;
-
-const {isMainThread: Y} = m.default;
-
-const G = c.sonicBoom;
-
-const q = I;
-
-function U(e) {
-    const t = new G(e);
-    t.on("error", o);
-    if (!e.sync && Y) {
-        B(t);
-    }
-    return t;
-    function o(e) {
-        if (e.code === "EPIPE") {
-            t.write = q;
-            t.end = q;
-            t.flushSync = q;
-            t.destroy = q;
+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;
         }
-        t.removeListener("error", o);
-    }
-}
-
-function B(t) {
-    if (e.commonjsGlobal.WeakRef && e.commonjsGlobal.WeakMap && e.commonjsGlobal.FinalizationRegistry) {
-        const e = i.onExitLeakFree;
-        e.register(t, W);
-        t.on("close", function() {
-            e.unregister(t);
-        });
-    }
-}
-
-function W(e, t) {
-    if (e.destroyed) {
-        return;
-    }
-    if (t === "beforeExit") {
-        e.flush();
-        e.on("drain", function() {
-            e.end();
-        });
-    } else {
-        e.flushSync();
-    }
-}
-
-var H = J;
-
-function J(e) {
-    return e instanceof Date && !Number.isNaN(e.getTime());
-}
-
-var Q = Z;
-
-const X = H;
-
-function Z(e) {
-    let t = new Date(e);
-    if (X(t)) {
-        return t;
+        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);
     }
-    t = new Date(+e);
-    return t;
-}
-
-var ee = te;
-
-function te(e) {
-    const t = [];
-    let o = false;
-    let n = "";
-    for (let r = 0; r < e.length; r++) {
-        const s = e.charAt(r);
-        if (s === "\\") {
-            o = true;
-            continue;
-        }
-        if (o) {
-            o = false;
-            n += s;
-            continue;
-        }
-        if (s === ".") {
-            t.push(n);
-            n = "";
-            continue;
+    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;
         }
-        n += s;
-    }
-    if (n.length) {
-        t.push(n);
+        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);
+            }
+        };
+        f(1);
     }
-    return t;
+    g = {
+        wait: t,
+        waitDiff: r
+    };
+    return g;
 }
 
-var oe = re;
+var y;
 
-const ne = ee;
+var A;
 
-function re(e, t) {
-    const o = Array.isArray(t) ? t : ne(t);
-    for (const t of o) {
-        if (!Object.prototype.hasOwnProperty.call(e, t)) {
+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;
         }
-        e = e[t];
-    }
-    return e;
-}
-
-var se = le;
-
-const ce = oe;
-
-const ie = ee;
-
-function le(e, t) {
-    const o = ie(t);
-    const n = o.pop();
-    e = ce(e, o);
-    if (e !== null && typeof e === "object" && Object.prototype.hasOwnProperty.call(e, n)) {
-        delete e[n];
-    }
-}
-
-var ue = me;
-
-const {createCopier: ae} = l.cjs;
-
-const fe = ae({});
-
-const pe = se;
-
-function me({log: e, context: t}) {
-    const {ignoreKeys: o, includeKeys: n} = t;
-    const r = fe(e);
-    if (n) {
-        const e = {};
-        n.forEach(t => {
-            e[t] = r[t];
-        });
-        return e;
-    }
-    o.forEach(e => {
-        pe(r, e);
+        e.terminate();
     });
-    return r;
-}
-
-var ye = ve;
-
-const {DATE_FORMAT: de, DATE_FORMAT_SIMPLE: ge} = d;
-
-const Le = u.dateformatExports;
-
-const Ee = Q;
-
-const he = H;
-
-function ve(e, t = false) {
-    if (t === false) {
-        return e;
-    }
-    const o = Ee(e);
-    if (!he(o)) {
-        return e;
-    }
-    if (t === true) {
-        return Le(o, ge);
-    }
-    const n = t.toUpperCase();
-    if (n === "SYS:STANDARD") {
-        return Le(o, de);
-    }
-    const r = n.substr(0, 4);
-    if (r === "SYS:" || r === "UTC:") {
-        if (r === "UTC:") {
-            return Le(o, t);
-        }
-        return Le(o, t.slice(4));
-    }
-    return Le(o, `UTC:${t}`);
-}
-
-var be = Oe;
-
-function Oe(e) {
-    if (!e) return {};
-    if (typeof e === "string") {
-        return e.split(",").reduce((e, t, o) => {
-            const [n, r = o] = t.split(":");
-            e[n.toLowerCase()] = r;
-            return e;
-        }, {});
-    } else if (Object.prototype.toString.call(e) === "[object Object]") {
-        return Object.keys(e).reduce((t, o) => {
-            t[o.toLowerCase()] = e[o];
-            return t;
-        }, {});
-    } else {
-        return {};
-    }
-}
-
-var je = xe;
-
-function xe(e) {
-    if (!e) return {};
-    if (typeof e === "string") {
-        return e.split(",").reduce((e, t, o) => {
-            const [n, r = o] = t.split(":");
-            e[r] = n.toUpperCase();
-            return e;
-        }, {
-            default: "USERLVL"
-        });
-    } else if (Object.prototype.toString.call(e) === "[object Object]") {
-        return Object.keys(e).reduce((t, o) => {
-            t[e[o]] = o.toUpperCase();
-            return t;
-        }, {
-            default: "USERLVL"
+    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
+                }
+            }
         });
-    } else {
-        return {};
-    }
-}
-
-var Ke = Se;
-
-const Pe = oe;
-
-function Se(e, t) {
-    e = e.replace(/{if (.*?)}(.*?){end}/g, o);
-    e = e.replace(/{if (.*?)}/g, "");
-    e = e.replace(/{end}/g, "");
-    return e.replace(/\s+/g, " ").trim();
-    function o(e, o, n) {
-        const r = Pe(t, o);
-        if (r && n.includes(o)) {
-            return n.replace(new RegExp("{" + o + "}", "g"), r);
+        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);
+                }
+                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));
+            } 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));
+                });
+            }
+        } else if (r === 0) {
+            if (t === 0 && e[y].buf.length === 0) {
+                return;
+            }
+            e.flush(() => {
+                Atomics.store(e[y].state, m, 0);
+                Atomics.store(e[y].state, a, 0);
+                B(e);
+            });
         } else {
-            return "";
+            N(e, new Error("overwritten"));
         }
     }
-}
-
-var Ce = _e;
-
-function _e(e) {
-    return Object.prototype.toString.apply(e) === "[object Object]";
-}
-
-var ke = $e;
-
-function $e({input: e, ident: t = "    ", eol: o = "\n"}) {
-    const n = e.split(/\r?\n/);
-    for (let e = 1; e < n.length; e += 1) {
-        n[e] = t + n[e];
-    }
-    return n.join(o);
-}
-
-var Ae = Re;
-
-const {LEVEL_NAMES: Te} = d;
-
-const Me = V;
-
-const we = je;
-
-const Fe = be;
-
-const Ne = g;
-
-function Re(e) {
-    const t = e.crlf ? "\r\n" : "\n";
-    const o = "    ";
-    const {customPrettifiers: n, errorLikeObjectKeys: r, hideObject: s, levelFirst: c, levelKey: i, levelLabel: l, messageFormat: u, messageKey: a, minimumLevel: f, singleLine: p, timestampKey: m, translateTime: y} = e;
-    const d = e.errorProps.split(",");
-    const g = typeof e.useOnlyCustomProps === "boolean" ? e.useOnlyCustomProps : e.useOnlyCustomProps === "true";
-    const L = we(e.customLevels);
-    const E = Fe(e.customLevels);
-    const h = Ne(g, L, E);
-    let v;
-    if (e.customColors) {
-        if (typeof e.customColors === "string") {
-            v = e.customColors.split(",").reduce((t, o) => {
-                const [n, r] = o.split(":");
-                const s = g ? e.customLevels : E[n] !== undefined;
-                const c = s ? E[n] : Te[n];
-                const i = c !== undefined ? c : n;
-                t.push([ i, r ]);
-                return t;
-            }, []);
-        } else if (typeof e.customColors === "object") {
-            v = Object.keys(e.customColors).reduce((t, o) => {
-                const [n, r] = [ o, e.customColors[o] ];
-                const s = g ? e.customLevels : E[n] !== undefined;
-                const c = s ? E[n] : Te[n];
-                const i = c !== undefined ? c : n;
-                t.push([ i, r ]);
-                return t;
-            }, []);
-        } else {
-            throw new Error("options.customColors must be of type string or object.");
+    function S(e) {
+        const t = this.stream.deref();
+        if (t === undefined) {
+            this.exited = true;
+            this.terminate();
+            return;
         }
-    }
-    const b = {
-        customLevels: L,
-        customLevelNames: E
-    };
-    if (g === true && !e.customLevels) {
-        b.customLevels = undefined;
-        b.customLevelNames = undefined;
-    }
-    const O = e.include !== undefined ? new Set(e.include.split(",")) : undefined;
-    const j = !O && e.ignore ? new Set(e.ignore.split(",")) : undefined;
-    const x = Me(e.colorize, v, g);
-    const K = e.colorizeObjects ? x : Me(false, [], false);
-    return {
-        EOL: t,
-        IDENT: o,
-        colorizer: x,
-        customColors: v,
-        customLevelNames: E,
-        customLevels: L,
-        customPrettifiers: n,
-        customProperties: b,
-        errorLikeObjectKeys: r,
-        errorProps: d,
-        getLevelLabelData: h,
-        hideObject: s,
-        ignoreKeys: j,
-        includeKeys: O,
-        levelFirst: c,
-        levelKey: i,
-        levelLabel: l,
-        messageFormat: u,
-        messageKey: a,
-        minimumLevel: f,
-        objectColorizer: K,
-        singleLine: p,
-        timestampKey: m,
-        translateTime: y,
-        useOnlyCustomProps: g
-    };
-}
-
-var De = Ie;
+        switch (e.code) {
+          case "READY":
+            this.stream = new p(t);
+            t.flush(() => {
+                t[y].ready = true;
+                t.emit("ready");
+            });
+            break;
 
-const Ve = ke;
+          case "ERROR":
+            N(t, e.err);
+            break;
 
-function Ie({keyName: e, lines: t, eol: o, ident: n}) {
-    let r = "";
-    const s = Ve({
-        input: t,
-        ident: n,
-        eol: o
-    });
-    const c = `${n}${e}: ${s}${o}`.split(o);
-    for (let e = 0; e < c.length; e += 1) {
-        if (e !== 0) r += o;
-        const t = c[e];
-        if (/^\s*"stack"/.test(t)) {
-            const e = /^(\s*"stack":)\s*(".*"),?$/.exec(t);
-            if (e && e.length === 3) {
-                const n = /^\s*/.exec(t)[0].length + 4;
-                const s = " ".repeat(n);
-                const c = e[2];
-                r += e[1] + o + s + JSON.parse(c).replace(/\n/g, o + s);
+          case "EVENT":
+            if (Array.isArray(e.args)) {
+                t.emit(e.name, ...e.args);
             } else {
-                r += t;
+                t.emit(e.name, e.args);
             }
-        } else {
-            r += t;
-        }
-    }
-    return r;
-}
+            break;
 
-var ze = Be;
+          case "WARNING":
+            process.emitWarning(e.err);
+            break;
 
-const {LOGGER_KEYS: Ye} = d;
-
-const Ge = a.fastSafeStringify;
-
-const qe = ke;
-
-const Ue = De;
-
-function Be({log: e, excludeLoggerKeys: t = true, skipKeys: o = [], context: n}) {
-    const {EOL: r, IDENT: s, customPrettifiers: c, errorLikeObjectKeys: i, objectColorizer: l, singleLine: u, colorizer: a} = n;
-    const f = [].concat(o);
-    if (t === true) Array.prototype.push.apply(f, Ye);
-    let p = "";
-    const {plain: m, errors: y} = Object.entries(e).reduce(({plain: t, errors: o}, [n, r]) => {
-        if (f.includes(n) === false) {
-            const s = typeof c[n] === "function" ? c[n](r, n, e, {
-                colors: a.colors
-            }) : r;
-            if (i.includes(n)) {
-                o[n] = s;
-            } else {
-                t[n] = s;
-            }
+          default:
+            N(t, new Error("this should not happen: " + e.code));
         }
-        return {
-            plain: t,
-            errors: o
-        };
-    }, {
-        plain: {},
-        errors: {}
-    });
-    if (u) {
-        if (Object.keys(m).length > 0) {
-            p += l.greyMessage(Ge(m));
+    }
+    function F(e) {
+        const t = this.stream.deref();
+        if (t === undefined) {
+            return;
         }
-        p += r;
-        p = p.replace(/\\\\/gi, "\\");
-    } else {
-        Object.entries(m).forEach(([e, t]) => {
-            let o = typeof c[e] === "function" ? t : Ge(t, null, 2);
-            if (o === undefined) return;
-            o = o.replace(/\\\\/gi, "\\");
-            const n = qe({
-                input: o,
-                ident: s,
-                eol: r
-            });
-            p += `${s}${l.property(e)}:${n.startsWith(r) ? "" : " "}${n}${r}`;
-        });
+        v.unregister(t);
+        t.worker.exited = true;
+        t.worker.off("exit", F);
+        N(t, e !== 0 ? new Error("the worker thread exited") : null);
     }
-    Object.entries(y).forEach(([e, t]) => {
-        const o = typeof c[e] === "function" ? t : Ge(t, null, 2);
-        if (o === undefined) return;
-        p += Ue({
-            keyName: e,
-            lines: o,
-            eol: r,
-            ident: s
-        });
-    });
-    return p;
-}
-
-var We = Ze;
-
-const {LOGGER_KEYS: He} = d;
-
-const Je = Ce;
-
-const Qe = ke;
-
-const Xe = ze;
-
-function Ze({log: e, context: t}) {
-    const {EOL: o, IDENT: n, errorProps: r, messageKey: s} = t;
-    const c = e.stack;
-    const i = Qe({
-        input: c,
-        ident: n,
-        eol: o
-    });
-    let l = `${n}${i}${o}`;
-    if (r.length > 0) {
-        const c = He.concat(s, "type", "stack");
-        let i;
-        if (r[0] === "*") {
-            i = Object.keys(e).filter(e => c.includes(e) === false);
-        } else {
-            i = r.filter(e => c.includes(e) === false);
+    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);
+            });
         }
-        for (let r = 0; r < i.length; r += 1) {
-            const s = i[r];
-            if (s in e === false) continue;
-            if (Je(e[s])) {
-                const r = Xe({
-                    log: e[s],
-                    excludeLoggerKeys: false,
-                    context: {
-                        ...t,
-                        IDENT: n + n
-                    }
-                });
-                l = `${l}${n}${s}: {${o}${r}${n}}${o}`;
-                continue;
+        write(e) {
+            if (this[y].destroyed) {
+                I(this, new Error("the worker has exited"));
+                return false;
+            }
+            if (this[y].ending) {
+                I(this, new Error("the worker is ending"));
+                return false;
+            }
+            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;
+                }
+            }
+            this[y].buf += e;
+            if (this[y].sync) {
+                try {
+                    W(this);
+                    return true;
+                } catch (e) {
+                    N(this, e);
+                    return false;
+                }
             }
-            l = `${l}${n}${s}: ${e[s]}${o}`;
+            if (!this[y].flushing) {
+                this[y].flushing = true;
+                setImmediate(B, this);
+            }
+            this[y].needDrain = this[y].data.length - this[y].buf.length - Atomics.load(this[y].state, a) <= 0;
+            return !this[y].needDrain;
         }
-    }
-    return l;
-}
-
-var et = ot;
-
-const tt = oe;
-
-function ot({log: e, context: t}) {
-    const {colorizer: o, customLevels: n, customLevelNames: r, levelKey: s, getLevelLabelData: c} = t;
-    const i = t.customPrettifiers?.level;
-    const l = tt(e, s);
-    if (l === undefined) return undefined;
-    const u = o(l, {
-        customLevels: n,
-        customLevelNames: r
-    });
-    if (i) {
-        const [t] = c(l);
-        return i(l, s, e, {
-            label: t,
-            labelColorized: u,
-            colors: o.colors
-        });
-    }
-    return u;
-}
-
-var nt = it;
-
-const {LEVELS: rt} = d;
-
-const st = oe;
-
-const ct = Ke;
-
-function it({log: e, context: t}) {
-    const {colorizer: o, customLevels: n, levelKey: r, levelLabel: s, messageFormat: c, messageKey: i, useOnlyCustomProps: l} = t;
-    if (c && typeof c === "string") {
-        const t = ct(c, e);
-        const i = String(t).replace(/{([^{}]+)}/g, function(t, o) {
-            let c;
-            if (o === s && (c = st(e, r)) !== undefined) {
-                const e = l ? n === undefined : n[c] === undefined;
-                return e ? rt[c] : n[c];
+        end() {
+            if (this[y].destroyed) {
+                return;
             }
-            return st(e, o) || "";
-        });
-        return o.message(i);
-    }
-    if (c && typeof c === "function") {
-        const t = c(e, i, s, {
-            colors: o.colors
-        });
-        return o.message(t);
-    }
-    if (i in e === false) return undefined;
-    if (typeof e[i] !== "string" && typeof e[i] !== "number" && typeof e[i] !== "boolean") return undefined;
-    return o.message(e[i]);
-}
-
-var lt = ut;
-
-function ut({log: e, context: t}) {
-    const {customPrettifiers: o, colorizer: n} = t;
-    let r = "";
-    if (e.name || e.pid || e.hostname) {
-        r += "(";
-        if (e.name) {
-            r += o.name ? o.name(e.name, "name", e, {
-                colors: n.colors
-            }) : e.name;
+            this[y].ending = true;
+            O(this);
         }
-        if (e.pid) {
-            const t = o.pid ? o.pid(e.pid, "pid", e, {
-                colors: n.colors
-            }) : e.pid;
-            if (e.name && e.pid) {
-                r += "/" + t;
-            } else {
-                r += t;
+        flush(e) {
+            if (this[y].destroyed) {
+                if (typeof e === "function") {
+                    process.nextTick(e, new Error("the worker has exited"));
+                }
+                return;
             }
+            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);
+            });
         }
-        if (e.hostname) {
-            const t = o.hostname ? o.hostname(e.hostname, "hostname", e, {
-                colors: n.colors
-            }) : e.hostname;
-            r += `${r === "(" ? "on" : " on"} ${t}`;
+        flushSync() {
+            if (this[y].destroyed) {
+                return;
+            }
+            W(this);
+            z(this);
         }
-        r += ")";
-    }
-    if (e.caller) {
-        const t = o.caller ? o.caller(e.caller, "caller", e, {
-            colors: n.colors
-        }) : e.caller;
-        r += `${r === "" ? "" : " "}<${t}>`;
-    }
-    if (r === "") {
-        return undefined;
-    } else {
-        return r;
-    }
-}
-
-var at = pt;
-
-const ft = ye;
-
-function pt({log: e, context: t}) {
-    const {timestampKey: o, translateTime: n} = t;
-    const r = t.customPrettifiers?.time;
-    let s = null;
-    if (o in e) {
-        s = e[o];
-    } else if ("timestamp" in e) {
-        s = e.timestamp;
-    }
-    if (s === null) return undefined;
-    const c = n ? ft(s, n) : s;
-    return r ? r(c) : `[${c}]`;
-}
-
-var mt = {
-    buildSafeSonicBoom: z,
-    createDate: Q,
-    deleteLogProperty: se,
-    filterLog: ue,
-    formatTime: ye,
-    getPropertyValue: oe,
-    handleCustomLevelsNamesOpts: be,
-    handleCustomLevelsOpts: je,
-    interpretConditionals: Ke,
-    isObject: Ce,
-    isValidDate: H,
-    joinLinesWithIndentation: ke,
-    noop: I,
-    parseFactoryOptions: Ae,
-    prettifyErrorLog: We,
-    prettifyError: De,
-    prettifyLevel: et,
-    prettifyMessage: nt,
-    prettifyMetadata: lt,
-    prettifyObject: ze,
-    prettifyTime: at,
-    splitPropertyKey: ee,
-    getLevelLabelData: g
-};
-
-var yt = {
-    exports: {}
-};
-
-yt.exports;
-
-const dt = typeof Buffer !== "undefined";
-
-const gt = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
-
-const Lt = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
-
-function Et(e, t, o) {
-    if (o == null) {
-        if (t !== null && typeof t === "object") {
-            o = t;
-            t = undefined;
+        unref() {
+            this.worker.unref();
         }
-    }
-    if (dt && Buffer.isBuffer(e)) {
-        e = e.toString();
-    }
-    if (e && e.charCodeAt(0) === 65279) {
-        e = e.slice(1);
-    }
-    const n = JSON.parse(e, t);
-    if (n === null || typeof n !== "object") {
-        return n;
-    }
-    const r = o && o.protoAction || "error";
-    const s = o && o.constructorAction || "error";
-    if (r === "ignore" && s === "ignore") {
-        return n;
-    }
-    if (r !== "ignore" && s !== "ignore") {
-        if (gt.test(e) === false && Lt.test(e) === false) {
-            return n;
+        ref() {
+            this.worker.ref();
         }
-    } else if (r !== "ignore" && s === "ignore") {
-        if (gt.test(e) === false) {
-            return n;
+        get ready() {
+            return this[y].ready;
         }
-    } else {
-        if (Lt.test(e) === false) {
-            return n;
+        get destroyed() {
+            return this[y].destroyed;
         }
-    }
-    return ht(n, {
-        protoAction: r,
-        constructorAction: s,
-        safe: o && o.safe
-    });
-}
-
-function ht(e, {protoAction: t = "error", constructorAction: o = "error", safe: n} = {}) {
-    let r = [ e ];
-    while (r.length) {
-        const e = r;
-        r = [];
-        for (const s of e) {
-            if (t !== "ignore" && Object.prototype.hasOwnProperty.call(s, "__proto__")) {
-                if (n === true) {
-                    return null;
-                } else if (t === "error") {
-                    throw new SyntaxError("Object contains forbidden prototype property");
-                }
-                delete s.__proto__;
-            }
-            if (o !== "ignore" && Object.prototype.hasOwnProperty.call(s, "constructor") && s.constructor !== null && typeof s.constructor === "object" && Object.prototype.hasOwnProperty.call(s.constructor, "prototype")) {
-                if (n === true) {
-                    return null;
-                } else if (o === "error") {
-                    throw new SyntaxError("Object contains forbidden prototype property");
-                }
-                delete s.constructor;
-            }
-            for (const e in s) {
-                const t = s[e];
-                if (t && typeof t === "object") {
-                    r.push(t);
-                }
-            }
+        get closed() {
+            return this[y].closed;
         }
-    }
-    return e;
-}
-
-function vt(e, t, o) {
-    const {stackTraceLimit: n} = Error;
-    Error.stackTraceLimit = 0;
-    try {
-        return Et(e, t, o);
-    } finally {
-        Error.stackTraceLimit = n;
-    }
-}
-
-function bt(e, t) {
-    const {stackTraceLimit: o} = Error;
-    Error.stackTraceLimit = 0;
-    try {
-        return Et(e, t, {
-            safe: true
-        });
-    } catch {
-        return undefined;
-    } finally {
-        Error.stackTraceLimit = o;
-    }
-}
-
-yt.exports = vt;
-
-yt.exports.default = vt;
-
-yt.exports.parse = vt;
-
-yt.exports.safeParse = bt;
-
-yt.exports.scan = ht;
-
-var Ot = yt.exports;
-
-var jt = Nt;
-
-const xt = Ot;
-
-const Kt = Ce;
-
-const Pt = We;
-
-const St = et;
-
-const Ct = nt;
-
-const _t = lt;
-
-const kt = ze;
-
-const $t = at;
-
-const At = ue;
-
-const {LEVELS: Tt, LEVEL_KEY: Mt, LEVEL_NAMES: wt} = d;
-
-const Ft = e => {
-    try {
-        return {
-            value: xt.parse(e, {
-                protoAction: "remove"
-            })
-        };
-    } catch (e) {
-        return {
-            err: e
-        };
-    }
-};
-
-function Nt(e) {
-    let t;
-    if (!Kt(e)) {
-        const o = Ft(e);
-        if (o.err || !Kt(o.value)) {
-            return e + this.EOL;
+        get writable() {
+            return !this[y].destroyed && !this[y].ending;
         }
-        t = o.value;
-    } else {
-        t = e;
-    }
-    if (this.minimumLevel) {
-        let e;
-        if (this.useOnlyCustomProps) {
-            e = this.customLevels;
-        } else {
-            e = this.customLevelNames[this.minimumLevel] !== undefined;
+        get writableEnded() {
+            return this[y].ending;
         }
-        let o;
-        if (e) {
-            o = this.customLevelNames[this.minimumLevel];
-        } else {
-            o = wt[this.minimumLevel];
+        get writableFinished() {
+            return this[y].finished;
+        }
+        get writableNeedDrain() {
+            return this[y].needDrain;
         }
-        if (!o) {
-            o = typeof this.minimumLevel === "string" ? wt[this.minimumLevel] : wt[Tt[this.minimumLevel].toLowerCase()];
+        get writableObjectMode() {
+            return false;
+        }
+        get writableErrored() {
+            return this[y].errored;
         }
-        const n = t[this.levelKey === undefined ? Mt : this.levelKey];
-        if (n < o) return;
     }
-    const o = Ct({
-        log: t,
-        context: this.context
-    });
-    if (this.ignoreKeys || this.includeKeys) {
-        t = At({
-            log: t,
-            context: this.context
+    function I(e, t) {
+        setImmediate(() => {
+            e.emit("error", t);
         });
     }
-    const n = St({
-        log: t,
-        context: {
-            ...this.context,
-            ...this.context.customProperties
+    function N(e, t) {
+        if (e[y].destroyed) {
+            return;
         }
-    });
-    const r = _t({
-        log: t,
-        context: this.context
-    });
-    const s = $t({
-        log: t,
-        context: this.context
-    });
-    let c = "";
-    if (this.levelFirst && n) {
-        c = `${n}`;
-    }
-    if (s && c === "") {
-        c = `${s}`;
-    } else if (s) {
-        c = `${c} ${s}`;
-    }
-    if (!this.levelFirst && n) {
-        if (c.length > 0) {
-            c = `${c} ${n}`;
-        } else {
-            c = n;
+        e[y].destroyed = true;
+        if (t) {
+            e[y].errored = t;
+            I(e, t);
         }
-    }
-    if (r) {
-        if (c.length > 0) {
-            c = `${c} ${r}:`;
+        if (!e.worker.exited) {
+            e.worker.terminate().catch(() => {}).then(() => {
+                e[y].closed = true;
+                e.emit("close");
+            });
         } else {
-            c = r;
+            setImmediate(() => {
+                e[y].closed = true;
+                e.emit("close");
+            });
         }
     }
-    if (c.endsWith(":") === false && c !== "") {
-        c += ":";
+    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;
     }
-    if (o !== undefined) {
-        if (c.length > 0) {
-            c = `${c} ${o}`;
-        } else {
-            c = o;
+    function O(e) {
+        if (e[y].ended || !e[y].ending || e[y].flushing) {
+            return;
         }
-    }
-    if (c.length > 0 && !this.singleLine) {
-        c += this.EOL;
-    }
-    if (t.type === "Error" && typeof t.stack === "string") {
-        const e = Pt({
-            log: t,
-            context: this.context
-        });
-        if (this.singleLine) c += this.EOL;
-        c += e;
-    } else if (this.hideObject === false) {
-        const e = [ this.messageKey, this.levelKey, this.timestampKey ].map(e => e.replaceAll(/\\/g, "")).filter(e => typeof t[e] === "string" || typeof t[e] === "number" || typeof t[e] === "boolean");
-        const o = kt({
-            log: t,
-            skipKeys: e,
-            context: this.context
-        });
-        if (this.singleLine && !/^\s$/.test(o)) {
-            c += " ";
+        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;
+                }
+                if (++r === 10) {
+                    N(e, new Error("end() took too long (10s)"));
+                    return;
+                }
+            }
+            process.nextTick(() => {
+                e[y].finished = true;
+                e.emit("finish");
+            });
+        } catch (t) {
+            N(e, t);
         }
-        c += o;
     }
-    return c;
-}
-
-y.exports;
-
-const {isColorSupported: Rt} = t.colorette;
-
-const Dt = o.pump_1;
-
-const {Transform: Vt} = p.default;
-
-const It = r.pinoAbstractTransport;
-
-const zt = V;
-
-const {ERROR_LIKE_KEYS: Yt, LEVEL_KEY: Gt, LEVEL_LABEL: qt, MESSAGE_KEY: Ut, TIMESTAMP_KEY: Bt} = d;
-
-const {buildSafeSonicBoom: Wt, parseFactoryOptions: Ht} = mt;
-
-const Jt = jt;
-
-const Qt = {
-    colorize: Rt,
-    colorizeObjects: true,
-    crlf: false,
-    customColors: null,
-    customLevels: null,
-    customPrettifiers: {},
-    errorLikeObjectKeys: Yt,
-    errorProps: "",
-    hideObject: false,
-    ignore: "hostname",
-    include: undefined,
-    levelFirst: false,
-    levelKey: Gt,
-    levelLabel: qt,
-    messageFormat: null,
-    messageKey: Ut,
-    minimumLevel: undefined,
-    outputStream: process.stdout,
-    singleLine: false,
-    timestampKey: Bt,
-    translateTime: true,
-    useOnlyCustomProps: true
-};
-
-function Xt(e) {
-    const t = Ht(Object.assign({}, Qt, e));
-    return Jt.bind({
-        ...t,
-        context: t
-    });
-}
-
-function Zt(e = {}) {
-    let t = Xt(e);
-    let o;
-    return It(function(n) {
-        n.on("message", function o(r) {
-            if (!r || r.code !== "PINO_CONFIG") return;
-            Object.assign(e, {
-                messageKey: r.config.messageKey,
-                errorLikeObjectKeys: Array.from(new Set([ ...e.errorLikeObjectKeys || Yt, r.config.errorKey ])),
-                customLevels: r.config.levels.values
-            });
-            t = Xt(e);
-            n.off("message", o);
-        });
-        const r = new Vt({
-            objectMode: true,
-            autoDestroy: true,
-            transform(e, o, n) {
-                const r = t(e);
-                n(null, r);
+    function W(e) {
+        const t = () => {
+            if (e[y].ending) {
+                O(e);
+            } else if (e[y].needDrain) {
+                process.nextTick(T, e);
+            }
+        };
+        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");
+            }
+            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);
+            } 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);
             }
-        });
-        if (typeof e.destination === "object" && typeof e.destination.write === "function") {
-            o = e.destination;
-        } else {
-            o = Wt({
-                dest: e.destination || 1,
-                append: e.append,
-                mkdir: e.mkdir,
-                sync: e.sync
-            });
         }
-        n.on("unknown", function(e) {
-            o.write(e + "\n");
-        });
-        Dt(n, r, o);
-        return r;
-    }, {
-        parse: "lines",
-        close(e, t) {
-            o.on("close", () => {
-                t(e);
-            });
+    }
+    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");
+            }
+            if (s !== t) {
+                Atomics.wait(e[y].state, m, s, 1e3);
+            } else {
+                break;
+            }
+            if (++r === 10) {
+                throw new Error("_flushSync took too long (10s)");
+            }
+        }
+    }
+    D = ThreadStream;
+    return D;
 }
 
-y.exports = Zt;
-
-y.exports.build = Zt;
-
-y.exports.PinoPretty = Zt;
-
-y.exports.prettyFactory = Xt;
-
-y.exports.colorizerFactory = zt;
-
-y.exports.isColorSupported = Rt;
-
-y.exports.default = Zt;
-
-var eo = y.exports;
-
-const to = e.getDefaultExportFromCjs(eo);
-
-exports.PinoPretty = to;
+exports.requireThreadStream = R;