lakutata 2.0.94 → 2.0.96

package/vendor/Package.internal.165.cjs

@@ -1,55 +1,1224 @@
-/* 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";
 
-exports.querystringify = {};
+const e = require("./Package.internal.8.cjs");
 
-var n = Object.prototype.hasOwnProperty, r;
+const t = require("./Package.internal.59.cjs");
 
-function t(n) {
-    try {
-        return decodeURIComponent(n.replace(/\+/g, " "));
-    } catch (n) {
-        return null;
+const o = require("./Package.internal.166.cjs");
+
+const n = require("node:stream");
+
+const r = require("./Package.internal.163.cjs");
+
+const s = require("node:worker_threads");
+
+const c = require("./Package.internal.160.cjs");
+
+const i = require("./Package.internal.152.cjs");
+
+const l = require("./Package.internal.90.cjs");
+
+const u = require("./Package.internal.65.cjs");
+
+const a = require("./Package.internal.96.cjs");
+
+const f = e => e && e.__esModule ? e : {
+    default: e
+};
+
+const p = f(n);
+
+const m = f(s);
+
+var y = {
+    exports: {}
+};
+
+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" ]
+};
+
+var g = h;
+
+const {LEVELS: L, LEVEL_NAMES: E} = d;
+
+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 v = e => e;
+
+const b = {
+    default: v,
+    60: v,
+    50: v,
+    40: v,
+    30: v,
+    20: v,
+    10: v,
+    message: v,
+    greyMessage: v,
+    property: v
+};
+
+const {createColors: O} = t.colorette;
+
+const j = g;
+
+const x = O({
+    useColor: true
+});
+
+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;
+            return;
+        }
+        t.removeListener("error", o);
     }
 }
 
-function e(n) {
-    try {
-        return encodeURIComponent(n);
-    } catch (n) {
-        return null;
+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 i(n) {
-    var r = /([^=?#&]+)=?([^&]*)/g, e = {}, i;
-    while (i = r.exec(n)) {
-        var u = t(i[1]), o = t(i[2]);
-        if (u === null || o === null || u in e) continue;
-        e[u] = o;
+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;
+    }
+    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;
+        }
+        n += s;
+    }
+    if (n.length) {
+        t.push(n);
+    }
+    return t;
+}
+
+var oe = re;
+
+const ne = ee;
+
+function re(e, t) {
+    const o = Array.isArray(t) ? t : ne(t);
+    for (const t of o) {
+        if (!Object.prototype.hasOwnProperty.call(e, t)) {
+            return;
+        }
+        e = e[t];
     }
     return e;
 }
 
-function u(t, i) {
-    i = i || "";
-    var u = [], o, l;
-    if ("string" !== typeof i) i = "?";
-    for (l in t) {
-        if (n.call(t, l)) {
-            o = t[l];
-            if (!o && (o === null || o === r || isNaN(o))) {
-                o = "";
+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);
+    });
+    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"
+        });
+    } 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);
+        } else {
+            return "";
+        }
+    }
+}
+
+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.");
+        }
+    }
+    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;
+
+const Ve = ke;
+
+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);
+            } else {
+                r += t;
+            }
+        } else {
+            r += t;
+        }
+    }
+    return r;
+}
+
+var ze = Be;
+
+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;
+            }
+        }
+        return {
+            plain: t,
+            errors: o
+        };
+    }, {
+        plain: {},
+        errors: {}
+    });
+    if (u) {
+        if (Object.keys(m).length > 0) {
+            p += l.greyMessage(Ge(m));
+        }
+        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}`;
+        });
+    }
+    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);
+        }
+        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;
+            }
+            l = `${l}${n}${s}: ${e[s]}${o}`;
+        }
+    }
+    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];
+            }
+            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;
+        }
+        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;
             }
-            l = e(l);
-            o = e(o);
-            if (l === null || o === null) continue;
-            u.push(l + "=" + o);
         }
+        if (e.hostname) {
+            const t = o.hostname ? o.hostname(e.hostname, "hostname", e, {
+                colors: n.colors
+            }) : e.hostname;
+            r += `${r === "(" ? "on" : " on"} ${t}`;
+        }
+        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;
     }
-    return u.length ? i + u.join("&") : "";
 }
 
-exports.querystringify.stringify = u;
+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;
+        }
+    }
+    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;
+        }
+    } else if (r !== "ignore" && s === "ignore") {
+        if (gt.test(e) === false) {
+            return n;
+        }
+    } else {
+        if (Lt.test(e) === false) {
+            return n;
+        }
+    }
+    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);
+                }
+            }
+        }
+    }
+    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;
+        }
+        t = o.value;
+    } else {
+        t = e;
+    }
+    if (this.minimumLevel) {
+        let e;
+        if (this.useOnlyCustomProps) {
+            e = this.customLevels;
+        } else {
+            e = this.customLevelNames[this.minimumLevel] !== undefined;
+        }
+        let o;
+        if (e) {
+            o = this.customLevelNames[this.minimumLevel];
+        } else {
+            o = wt[this.minimumLevel];
+        }
+        if (!o) {
+            o = typeof this.minimumLevel === "string" ? wt[this.minimumLevel] : wt[Tt[this.minimumLevel].toLowerCase()];
+        }
+        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
+        });
+    }
+    const n = St({
+        log: t,
+        context: {
+            ...this.context,
+            ...this.context.customProperties
+        }
+    });
+    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;
+        }
+    }
+    if (r) {
+        if (c.length > 0) {
+            c = `${c} ${r}:`;
+        } else {
+            c = r;
+        }
+    }
+    if (c.endsWith(":") === false && c !== "") {
+        c += ":";
+    }
+    if (o !== undefined) {
+        if (c.length > 0) {
+            c = `${c} ${o}`;
+        } else {
+            c = o;
+        }
+    }
+    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 += " ";
+        }
+        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);
+            }
+        });
+        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);
+            });
+        }
+    });
+}
+
+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.querystringify.parse = i;
+exports.PinoPretty = to;