@rife/logger 0.0.5-beta.9 → 0.0.6-beta.10

package/dist/worker/pino-worker.cjs

@@ -0,0 +1,3835 @@
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/atomic-sleep@1.0.0/node_modules/atomic-sleep/index.js": function(module1) {
+        "use strict";
+        if ('undefined' != typeof SharedArrayBuffer && 'undefined' != typeof Atomics) {
+            const nil = new Int32Array(new SharedArrayBuffer(4));
+            function sleep(ms) {
+                const valid = ms > 0 && ms < 1 / 0;
+                if (false === valid) {
+                    if ('number' != typeof ms && 'bigint' != typeof ms) throw TypeError('sleep: ms must be a number');
+                    throw RangeError('sleep: ms must be a number that is greater than 0 but less than Infinity');
+                }
+                Atomics.wait(nil, 0, 0, Number(ms));
+            }
+            module1.exports = sleep;
+        } else {
+            function sleep1(ms) {
+                const valid = ms > 0 && ms < 1 / 0;
+                if (false === valid) {
+                    if ('number' != typeof ms && 'bigint' != typeof ms) throw TypeError('sleep: ms must be a number');
+                    throw RangeError('sleep: ms must be a number that is greater than 0 but less than Infinity');
+                }
+                const target = Date.now() + Number(ms);
+                while(target > Date.now());
+            }
+            module1.exports = sleep1;
+        }
+    },
+    "../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const validator = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/validator.js");
+        const parse = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/parse.js");
+        const redactor = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/redactor.js");
+        const restorer = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/restorer.js");
+        const { groupRedact, nestedRedact } = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/modifiers.js");
+        const state = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/state.js");
+        const rx = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/rx.js");
+        const validate = validator();
+        const noop = (o)=>o;
+        noop.restore = noop;
+        const DEFAULT_CENSOR = '[REDACTED]';
+        fastRedact.rx = rx;
+        fastRedact.validator = validator;
+        module1.exports = fastRedact;
+        function fastRedact(opts = {}) {
+            const paths = Array.from(new Set(opts.paths || []));
+            const serialize = 'serialize' in opts ? false === opts.serialize ? opts.serialize : 'function' == typeof opts.serialize ? opts.serialize : JSON.stringify : JSON.stringify;
+            const remove = opts.remove;
+            if (true === remove && serialize !== JSON.stringify) throw Error('fast-redact – remove option may only be set when serializer is JSON.stringify');
+            const censor = true === remove ? void 0 : 'censor' in opts ? opts.censor : DEFAULT_CENSOR;
+            const isCensorFct = 'function' == typeof censor;
+            const censorFctTakesPath = isCensorFct && censor.length > 1;
+            if (0 === paths.length) return serialize || noop;
+            validate({
+                paths,
+                serialize,
+                censor
+            });
+            const { wildcards, wcLen, secret } = parse({
+                paths,
+                censor
+            });
+            const compileRestore = restorer();
+            const strict = 'strict' in opts ? opts.strict : true;
+            return redactor({
+                secret,
+                wcLen,
+                serialize,
+                strict,
+                isCensorFct,
+                censorFctTakesPath
+            }, state({
+                secret,
+                censor,
+                compileRestore,
+                serialize,
+                groupRedact,
+                nestedRedact,
+                wildcards,
+                wcLen
+            }));
+        }
+    },
+    "../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/modifiers.js": function(module1) {
+        "use strict";
+        module1.exports = {
+            groupRedact,
+            groupRestore,
+            nestedRedact,
+            nestedRestore
+        };
+        function groupRestore({ keys, values, target }) {
+            if (null == target || 'string' == typeof target) return;
+            const length = keys.length;
+            for(var i = 0; i < length; i++){
+                const k = keys[i];
+                target[k] = values[i];
+            }
+        }
+        function groupRedact(o, path, censor, isCensorFct, censorFctTakesPath) {
+            const target = get(o, path);
+            if (null == target || 'string' == typeof target) return {
+                keys: null,
+                values: null,
+                target,
+                flat: true
+            };
+            const keys = Object.keys(target);
+            const keysLength = keys.length;
+            const pathLength = path.length;
+            const pathWithKey = censorFctTakesPath ? [
+                ...path
+            ] : void 0;
+            const values = new Array(keysLength);
+            for(var i = 0; i < keysLength; i++){
+                const key = keys[i];
+                values[i] = target[key];
+                if (censorFctTakesPath) {
+                    pathWithKey[pathLength] = key;
+                    target[key] = censor(target[key], pathWithKey);
+                } else if (isCensorFct) target[key] = censor(target[key]);
+                else target[key] = censor;
+            }
+            return {
+                keys,
+                values,
+                target,
+                flat: true
+            };
+        }
+        function nestedRestore(instructions) {
+            for(let i = 0; i < instructions.length; i++){
+                const { target, path, value } = instructions[i];
+                let current = target;
+                for(let i = path.length - 1; i > 0; i--)current = current[path[i]];
+                current[path[0]] = value;
+            }
+        }
+        function nestedRedact(store, o, path, ns, censor, isCensorFct, censorFctTakesPath) {
+            const target = get(o, path);
+            if (null == target) return;
+            const keys = Object.keys(target);
+            const keysLength = keys.length;
+            for(var i = 0; i < keysLength; i++){
+                const key = keys[i];
+                specialSet(store, target, key, path, ns, censor, isCensorFct, censorFctTakesPath);
+            }
+            return store;
+        }
+        function has(obj, prop) {
+            return null != obj ? 'hasOwn' in Object ? Object.hasOwn(obj, prop) : Object.prototype.hasOwnProperty.call(obj, prop) : false;
+        }
+        function specialSet(store, o, k, path, afterPath, censor, isCensorFct, censorFctTakesPath) {
+            const afterPathLen = afterPath.length;
+            const lastPathIndex = afterPathLen - 1;
+            const originalKey = k;
+            var i = -1;
+            var n1;
+            var nv;
+            var ov;
+            var oov = null;
+            var wc = null;
+            var kIsWc;
+            var wcov;
+            var consecutive = false;
+            var level = 0;
+            var depth = 0;
+            var redactPathCurrent = tree();
+            ov = n1 = o[k];
+            if ('object' != typeof n1) return;
+            while(null != n1 && ++i < afterPathLen){
+                depth += 1;
+                k = afterPath[i];
+                if ('*' !== k && !wc && !('object' == typeof n1 && k in n1)) break;
+                if ('*' === k) {
+                    if ('*' === wc) consecutive = true;
+                    wc = k;
+                    if (i !== lastPathIndex) continue;
+                }
+                if (wc) {
+                    const wcKeys = Object.keys(n1);
+                    for(var j = 0; j < wcKeys.length; j++){
+                        const wck = wcKeys[j];
+                        wcov = n1[wck];
+                        kIsWc = '*' === k;
+                        if (consecutive) {
+                            redactPathCurrent = node(redactPathCurrent, wck, depth);
+                            level = i;
+                            ov = iterateNthLevel(wcov, level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n1, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, o[originalKey], depth + 1);
+                        } else if (kIsWc || 'object' == typeof wcov && null !== wcov && k in wcov) {
+                            ov = kIsWc ? wcov : wcov[k];
+                            nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
+                                ...path,
+                                originalKey,
+                                ...afterPath
+                            ]) : censor(ov) : censor;
+                            if (kIsWc) {
+                                const rv = restoreInstr(node(redactPathCurrent, wck, depth), ov, o[originalKey]);
+                                store.push(rv);
+                                n1[wck] = nv;
+                            } else if (wcov[k] === nv) ;
+                            else if (void 0 === nv && void 0 !== censor || has(wcov, k) && nv === ov) redactPathCurrent = node(redactPathCurrent, wck, depth);
+                            else {
+                                redactPathCurrent = node(redactPathCurrent, wck, depth);
+                                const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, o[originalKey]);
+                                store.push(rv);
+                                wcov[k] = nv;
+                            }
+                        }
+                    }
+                    wc = null;
+                } else {
+                    ov = n1[k];
+                    redactPathCurrent = node(redactPathCurrent, k, depth);
+                    nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
+                        ...path,
+                        originalKey,
+                        ...afterPath
+                    ]) : censor(ov) : censor;
+                    if (has(n1, k) && nv === ov || void 0 === nv && void 0 !== censor) ;
+                    else {
+                        const rv = restoreInstr(redactPathCurrent, ov, o[originalKey]);
+                        store.push(rv);
+                        n1[k] = nv;
+                    }
+                    n1 = n1[k];
+                }
+                if ('object' != typeof n1) break;
+            }
+        }
+        function get(o, p) {
+            var i = -1;
+            var l = p.length;
+            var n1 = o;
+            while(null != n1 && ++i < l)n1 = n1[p[i]];
+            return n1;
+        }
+        function iterateNthLevel(wcov, level, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n1, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth) {
+            if (0 === level) {
+                if (kIsWc || 'object' == typeof wcov && null !== wcov && k in wcov) {
+                    ov = kIsWc ? wcov : wcov[k];
+                    nv = i !== lastPathIndex ? ov : isCensorFct ? censorFctTakesPath ? censor(ov, [
+                        ...path,
+                        originalKey,
+                        ...afterPath
+                    ]) : censor(ov) : censor;
+                    if (kIsWc) {
+                        const rv = restoreInstr(redactPathCurrent, ov, parent);
+                        store.push(rv);
+                        n1[wck] = nv;
+                    } else if (wcov[k] === nv) ;
+                    else if (void 0 === nv && void 0 !== censor || has(wcov, k) && nv === ov) ;
+                    else {
+                        const rv = restoreInstr(node(redactPathCurrent, k, depth + 1), ov, parent);
+                        store.push(rv);
+                        wcov[k] = nv;
+                    }
+                }
+            }
+            for(const key in wcov)if ('object' == typeof wcov[key]) {
+                redactPathCurrent = node(redactPathCurrent, key, depth);
+                iterateNthLevel(wcov[key], level - 1, k, path, afterPath, censor, isCensorFct, censorFctTakesPath, originalKey, n1, nv, ov, kIsWc, wck, i, lastPathIndex, redactPathCurrent, store, parent, depth + 1);
+            }
+        }
+        function tree() {
+            return {
+                parent: null,
+                key: null,
+                children: [],
+                depth: 0
+            };
+        }
+        function node(parent, key, depth) {
+            if (parent.depth === depth) return node(parent.parent, key, depth);
+            var child = {
+                parent,
+                key,
+                depth,
+                children: []
+            };
+            parent.children.push(child);
+            return child;
+        }
+        function restoreInstr(node, value, target) {
+            let current = node;
+            const path = [];
+            do {
+                path.push(current.key);
+                current = current.parent;
+            }while (null != current.parent);
+            return {
+                path,
+                value,
+                target
+            };
+        }
+    },
+    "../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/parse.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const rx = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/rx.js");
+        module1.exports = parse;
+        function parse({ paths }) {
+            const wildcards = [];
+            var wcLen = 0;
+            const secret = paths.reduce(function(o, strPath, ix) {
+                var path = strPath.match(rx).map((p)=>p.replace(/'|"|`/g, ''));
+                const leadingBracket = '[' === strPath[0];
+                path = path.map((p)=>{
+                    if ('[' === p[0]) return p.substr(1, p.length - 2);
+                    return p;
+                });
+                const star = path.indexOf('*');
+                if (star > -1) {
+                    const before = path.slice(0, star);
+                    const beforeStr = before.join('.');
+                    const after = path.slice(star + 1, path.length);
+                    const nested = after.length > 0;
+                    wcLen++;
+                    wildcards.push({
+                        before,
+                        beforeStr,
+                        after,
+                        nested
+                    });
+                } else o[strPath] = {
+                    path: path,
+                    val: void 0,
+                    precensored: false,
+                    circle: '',
+                    escPath: JSON.stringify(strPath),
+                    leadingBracket: leadingBracket
+                };
+                return o;
+            }, {});
+            return {
+                wildcards,
+                wcLen,
+                secret
+            };
+        }
+    },
+    "../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/redactor.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const rx = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/rx.js");
+        module1.exports = redactor;
+        function redactor({ secret, serialize, wcLen, strict, isCensorFct, censorFctTakesPath }, state) {
+            const redact = Function('o', `
+    if (typeof o !== 'object' || o == null) {
+      ${strictImpl(strict, serialize)}
+    }
+    const { censor, secret } = this
+    const originalSecret = {}
+    const secretKeys = Object.keys(secret)
+    for (var i = 0; i < secretKeys.length; i++) {
+      originalSecret[secretKeys[i]] = secret[secretKeys[i]]
+    }
+
+    ${redactTmpl(secret, isCensorFct, censorFctTakesPath)}
+    this.compileRestore()
+    ${dynamicRedactTmpl(wcLen > 0, isCensorFct, censorFctTakesPath)}
+    this.secret = originalSecret
+    ${resultTmpl(serialize)}
+  `).bind(state);
+            redact.state = state;
+            if (false === serialize) redact.restore = (o)=>state.restore(o);
+            return redact;
+        }
+        function redactTmpl(secret, isCensorFct, censorFctTakesPath) {
+            return Object.keys(secret).map((path)=>{
+                const { escPath, leadingBracket, path: arrPath } = secret[path];
+                const skip = leadingBracket ? 1 : 0;
+                const delim = leadingBracket ? '' : '.';
+                const hops = [];
+                var match;
+                while(null !== (match = rx.exec(path))){
+                    const [, ix] = match;
+                    const { index, input } = match;
+                    if (index > skip) hops.push(input.substring(0, index - (ix ? 0 : 1)));
+                }
+                var existence = hops.map((p)=>`o${delim}${p}`).join(' && ');
+                if (0 === existence.length) existence += `o${delim}${path} != null`;
+                else existence += ` && o${delim}${path} != null`;
+                const circularDetection = `
+      switch (true) {
+        ${hops.reverse().map((p)=>`
+          case o${delim}${p} === censor:
+            secret[${escPath}].circle = ${JSON.stringify(p)}
+            break
+        `).join('\n')}
+      }
+    `;
+                const censorArgs = censorFctTakesPath ? `val, ${JSON.stringify(arrPath)}` : "val";
+                return `
+      if (${existence}) {
+        const val = o${delim}${path}
+        if (val === censor) {
+          secret[${escPath}].precensored = true
+        } else {
+          secret[${escPath}].val = val
+          o${delim}${path} = ${isCensorFct ? `censor(${censorArgs})` : 'censor'}
+          ${circularDetection}
+        }
+      }
+    `;
+            }).join('\n');
+        }
+        function dynamicRedactTmpl(hasWildcards, isCensorFct, censorFctTakesPath) {
+            return true === hasWildcards ? `
+    {
+      const { wildcards, wcLen, groupRedact, nestedRedact } = this
+      for (var i = 0; i < wcLen; i++) {
+        const { before, beforeStr, after, nested } = wildcards[i]
+        if (nested === true) {
+          secret[beforeStr] = secret[beforeStr] || []
+          nestedRedact(secret[beforeStr], o, before, after, censor, ${isCensorFct}, ${censorFctTakesPath})
+        } else secret[beforeStr] = groupRedact(o, before, censor, ${isCensorFct}, ${censorFctTakesPath})
+      }
+    }
+  ` : '';
+        }
+        function resultTmpl(serialize) {
+            return false === serialize ? "return o" : `
+    var s = this.serialize(o)
+    this.restore(o)
+    return s
+  `;
+        }
+        function strictImpl(strict, serialize) {
+            return true === strict ? "throw Error('fast-redact: primitives cannot be redacted')" : false === serialize ? "return o" : "return this.serialize(o)";
+        }
+    },
+    "../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/restorer.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { groupRestore, nestedRestore } = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/modifiers.js");
+        module1.exports = restorer;
+        function restorer() {
+            return function() {
+                if (this.restore) {
+                    this.restore.state.secret = this.secret;
+                    return;
+                }
+                const { secret, wcLen } = this;
+                const paths = Object.keys(secret);
+                const resetters = resetTmpl(secret, paths);
+                const hasWildcards = wcLen > 0;
+                const state = hasWildcards ? {
+                    secret,
+                    groupRestore,
+                    nestedRestore
+                } : {
+                    secret
+                };
+                this.restore = Function('o', restoreTmpl(resetters, paths, hasWildcards)).bind(state);
+                this.restore.state = state;
+            };
+        }
+        function resetTmpl(secret, paths) {
+            return paths.map((path)=>{
+                const { circle, escPath, leadingBracket } = secret[path];
+                const delim = leadingBracket ? '' : '.';
+                const reset = circle ? `o.${circle} = secret[${escPath}].val` : `o${delim}${path} = secret[${escPath}].val`;
+                const clear = `secret[${escPath}].val = undefined`;
+                return `
+      if (secret[${escPath}].val !== undefined) {
+        try { ${reset} } catch (e) {}
+        ${clear}
+      }
+    `;
+            }).join('');
+        }
+        function restoreTmpl(resetters, paths, hasWildcards) {
+            const dynamicReset = true === hasWildcards ? `
+    const keys = Object.keys(secret)
+    const len = keys.length
+    for (var i = len - 1; i >= ${paths.length}; i--) {
+      const k = keys[i]
+      const o = secret[k]
+      if (o) {
+        if (o.flat === true) this.groupRestore(o)
+        else this.nestedRestore(o)
+        secret[k] = null
+      }
+    }
+  ` : '';
+            return `
+    const secret = this.secret
+    ${dynamicReset}
+    ${resetters}
+    return o
+  `;
+        }
+    },
+    "../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/rx.js": function(module1) {
+        "use strict";
+        module1.exports = /[^.[\]]+|\[((?:.)*?)\]/g;
+    },
+    "../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/state.js": function(module1) {
+        "use strict";
+        module1.exports = state;
+        function state(o) {
+            const { secret, censor, compileRestore, serialize, groupRedact, nestedRedact, wildcards, wcLen } = o;
+            const builder = [
+                {
+                    secret,
+                    censor,
+                    compileRestore
+                }
+            ];
+            if (false !== serialize) builder.push({
+                serialize
+            });
+            if (wcLen > 0) builder.push({
+                groupRedact,
+                nestedRedact,
+                wildcards,
+                wcLen
+            });
+            return Object.assign(...builder);
+        }
+    },
+    "../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/lib/validator.js": function(module1) {
+        "use strict";
+        module1.exports = validator;
+        function validator(opts = {}) {
+            const { ERR_PATHS_MUST_BE_STRINGS = ()=>'fast-redact - Paths must be (non-empty) strings', ERR_INVALID_PATH = (s)=>`fast-redact – Invalid path (${s})` } = opts;
+            return function({ paths }) {
+                paths.forEach((s)=>{
+                    if ('string' != typeof s) throw Error(ERR_PATHS_MUST_BE_STRINGS());
+                    try {
+                        if (/〇/.test(s)) throw Error();
+                        const expr = ('[' === s[0] ? '' : '.') + s.replace(/^\*/, '〇').replace(/\.\*/g, '.〇').replace(/\[\*\]/g, '[〇]');
+                        if (/\n|\r|;/.test(expr)) throw Error();
+                        if (/\/\*/.test(expr)) throw Error();
+                        Function(`
+            'use strict'
+            const o = new Proxy({}, { get: () => o, set: () => { throw Error() } });
+            const 〇 = null;
+            o${expr}
+            if ([o${expr}].length !== 1) throw Error()`)();
+                    } catch (e) {
+                        throw Error(ERR_INVALID_PATH(s));
+                    }
+                });
+            };
+        }
+    },
+    "../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js": function(module1) {
+        "use strict";
+        const refs = {
+            exit: [],
+            beforeExit: []
+        };
+        const functions = {
+            exit: onExit,
+            beforeExit: onBeforeExit
+        };
+        let registry;
+        function ensureRegistry() {
+            if (void 0 === registry) registry = new FinalizationRegistry(clear);
+        }
+        function install(event) {
+            if (refs[event].length > 0) return;
+            process.on(event, functions[event]);
+        }
+        function uninstall(event) {
+            if (refs[event].length > 0) return;
+            process.removeListener(event, functions[event]);
+            if (0 === refs.exit.length && 0 === refs.beforeExit.length) registry = void 0;
+        }
+        function onExit() {
+            callRefs('exit');
+        }
+        function onBeforeExit() {
+            callRefs('beforeExit');
+        }
+        function callRefs(event) {
+            for (const ref of refs[event]){
+                const obj = ref.deref();
+                const fn = ref.fn;
+                if (void 0 !== obj) fn(obj, event);
+            }
+            refs[event] = [];
+        }
+        function clear(ref) {
+            for (const event of [
+                'exit',
+                'beforeExit'
+            ]){
+                const index = refs[event].indexOf(ref);
+                refs[event].splice(index, index + 1);
+                uninstall(event);
+            }
+        }
+        function _register(event, obj, fn) {
+            if (void 0 === obj) throw new Error('the object can\'t be undefined');
+            install(event);
+            const ref = new WeakRef(obj);
+            ref.fn = fn;
+            ensureRegistry();
+            registry.register(obj, ref);
+            refs[event].push(ref);
+        }
+        function register(obj, fn) {
+            _register('exit', obj, fn);
+        }
+        function registerBeforeExit(obj, fn) {
+            _register('beforeExit', obj, fn);
+        }
+        function unregister(obj) {
+            if (void 0 === registry) return;
+            registry.unregister(obj);
+            for (const event of [
+                'exit',
+                'beforeExit'
+            ]){
+                refs[event] = refs[event].filter((ref)=>{
+                    const _obj = ref.deref();
+                    return _obj && _obj !== obj;
+                });
+                uninstall(event);
+            }
+        }
+        module1.exports = {
+            register,
+            registerBeforeExit,
+            unregister
+        };
+    },
+    "../../node_modules/.pnpm/pino-abstract-transport@2.0.0/node_modules/pino-abstract-transport/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const metadata = Symbol.for('pino.metadata');
+        const split = __webpack_require__("../../node_modules/.pnpm/split2@4.2.0/node_modules/split2/index.js");
+        const { Duplex } = __webpack_require__("stream");
+        const { parentPort, workerData } = __webpack_require__("worker_threads");
+        function createDeferred() {
+            let resolve;
+            let reject;
+            const promise = new Promise((_resolve, _reject)=>{
+                resolve = _resolve;
+                reject = _reject;
+            });
+            promise.resolve = resolve;
+            promise.reject = reject;
+            return promise;
+        }
+        module1.exports = function(fn, opts = {}) {
+            const waitForConfig = true === opts.expectPinoConfig && workerData?.workerData?.pinoWillSendConfig === true;
+            const parseLines = 'lines' === opts.parse;
+            const parseLine = 'function' == typeof opts.parseLine ? opts.parseLine : JSON.parse;
+            const close = opts.close || defaultClose;
+            const stream = split(function(line) {
+                let value;
+                try {
+                    value = parseLine(line);
+                } catch (error) {
+                    this.emit('unknown', line, error);
+                    return;
+                }
+                if (null === value) return void this.emit('unknown', line, 'Null value ignored');
+                if ('object' != typeof value) value = {
+                    data: value,
+                    time: Date.now()
+                };
+                if (stream[metadata]) {
+                    stream.lastTime = value.time;
+                    stream.lastLevel = value.level;
+                    stream.lastObj = value;
+                }
+                if (parseLines) return line;
+                return value;
+            }, {
+                autoDestroy: true
+            });
+            stream._destroy = function(err, cb) {
+                const promise = close(err, cb);
+                if (promise && 'function' == typeof promise.then) promise.then(cb, cb);
+            };
+            if (true === opts.expectPinoConfig && workerData?.workerData?.pinoWillSendConfig !== true) setImmediate(()=>{
+                stream.emit('error', new Error('This transport is not compatible with the current version of pino. Please upgrade pino to the latest version.'));
+            });
+            if (false !== opts.metadata) {
+                stream[metadata] = true;
+                stream.lastTime = 0;
+                stream.lastLevel = 0;
+                stream.lastObj = null;
+            }
+            if (waitForConfig) {
+                let pinoConfig = {};
+                const configReceived = createDeferred();
+                parentPort.on('message', function handleMessage(message) {
+                    if ('PINO_CONFIG' === message.code) {
+                        pinoConfig = message.config;
+                        configReceived.resolve();
+                        parentPort.off('message', handleMessage);
+                    }
+                });
+                Object.defineProperties(stream, {
+                    levels: {
+                        get () {
+                            return pinoConfig.levels;
+                        }
+                    },
+                    messageKey: {
+                        get () {
+                            return pinoConfig.messageKey;
+                        }
+                    },
+                    errorKey: {
+                        get () {
+                            return pinoConfig.errorKey;
+                        }
+                    }
+                });
+                return configReceived.then(finish);
+            }
+            return finish();
+            function finish() {
+                let res = fn(stream);
+                if (res && 'function' == typeof res.catch) {
+                    res.catch((err)=>{
+                        stream.destroy(err);
+                    });
+                    res = null;
+                } else if (opts.enablePipelining && res) return Duplex.from({
+                    writable: stream,
+                    readable: res
+                });
+                return stream;
+            }
+        };
+        function defaultClose(err, cb) {
+            process.nextTick(cb, err);
+        }
+    },
+    "../../node_modules/.pnpm/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js": function(module1) {
+        "use strict";
+        function tryStringify(o) {
+            try {
+                return JSON.stringify(o);
+            } catch (e) {
+                return '"[Circular]"';
+            }
+        }
+        module1.exports = format;
+        function format(f, args, opts) {
+            var ss = opts && opts.stringify || tryStringify;
+            var offset = 1;
+            if ('object' == typeof f && null !== f) {
+                var len = args.length + offset;
+                if (1 === len) return f;
+                var objects = new Array(len);
+                objects[0] = ss(f);
+                for(var index = 1; index < len; index++)objects[index] = ss(args[index]);
+                return objects.join(' ');
+            }
+            if ('string' != typeof f) return f;
+            var argLen = args.length;
+            if (0 === argLen) return f;
+            var str = '';
+            var a = 1 - offset;
+            var lastPos = -1;
+            var flen = f && f.length || 0;
+            for(var i = 0; i < flen;){
+                if (37 === f.charCodeAt(i) && i + 1 < flen) {
+                    lastPos = lastPos > -1 ? lastPos : 0;
+                    switch(f.charCodeAt(i + 1)){
+                        case 100:
+                        case 102:
+                            if (a >= argLen) break;
+                            if (null == args[a]) break;
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            str += Number(args[a]);
+                            lastPos = i + 2;
+                            i++;
+                            break;
+                        case 105:
+                            if (a >= argLen) break;
+                            if (null == args[a]) break;
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            str += Math.floor(Number(args[a]));
+                            lastPos = i + 2;
+                            i++;
+                            break;
+                        case 79:
+                        case 111:
+                        case 106:
+                            if (a >= argLen) break;
+                            if (void 0 === args[a]) break;
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            var type = typeof args[a];
+                            if ('string' === type) {
+                                str += '\'' + args[a] + '\'';
+                                lastPos = i + 2;
+                                i++;
+                                break;
+                            }
+                            if ('function' === type) {
+                                str += args[a].name || '<anonymous>';
+                                lastPos = i + 2;
+                                i++;
+                                break;
+                            }
+                            str += ss(args[a]);
+                            lastPos = i + 2;
+                            i++;
+                            break;
+                        case 115:
+                            if (a >= argLen) break;
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            str += String(args[a]);
+                            lastPos = i + 2;
+                            i++;
+                            break;
+                        case 37:
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            str += '%';
+                            lastPos = i + 2;
+                            i++;
+                            a--;
+                            break;
+                    }
+                    ++a;
+                }
+                ++i;
+            }
+            if (-1 === lastPos) return f;
+            if (lastPos < flen) str += f.slice(lastPos);
+            return str;
+        }
+    },
+    "../../node_modules/.pnpm/real-require@0.2.0/node_modules/real-require/src/index.js": function(module1) {
+        const realImport = new Function('modulePath', 'return import(modulePath)');
+        function realRequire(modulePath) {
+            if ('function' == typeof __non_webpack__require__) return __non_webpack__require__(modulePath);
+            return require(modulePath);
+        }
+        module1.exports = {
+            realImport,
+            realRequire
+        };
+    },
+    "../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js": function(module1, exports) {
+        "use strict";
+        const { hasOwnProperty } = Object.prototype;
+        const stringify = configure();
+        stringify.configure = configure;
+        stringify.stringify = stringify;
+        stringify.default = stringify;
+        exports.stringify = stringify;
+        exports.configure = configure;
+        module1.exports = stringify;
+        const strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+        function strEscape(str) {
+            if (str.length < 5000 && !strEscapeSequencesRegExp.test(str)) return `"${str}"`;
+            return JSON.stringify(str);
+        }
+        function sort(array, comparator) {
+            if (array.length > 2e2 || comparator) return array.sort(comparator);
+            for(let i = 1; i < array.length; i++){
+                const currentValue = array[i];
+                let position = i;
+                while(0 !== position && array[position - 1] > currentValue){
+                    array[position] = array[position - 1];
+                    position--;
+                }
+                array[position] = currentValue;
+            }
+            return array;
+        }
+        const typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Object.getPrototypeOf(new Int8Array())), Symbol.toStringTag).get;
+        function isTypedArrayWithEntries(value) {
+            return void 0 !== typedArrayPrototypeGetSymbolToStringTag.call(value) && 0 !== value.length;
+        }
+        function stringifyTypedArray(array, separator, maximumBreadth) {
+            if (array.length < maximumBreadth) maximumBreadth = array.length;
+            const whitespace = ',' === separator ? '' : ' ';
+            let res = `"0":${whitespace}${array[0]}`;
+            for(let i = 1; i < maximumBreadth; i++)res += `${separator}"${i}":${whitespace}${array[i]}`;
+            return res;
+        }
+        function getCircularValueOption(options) {
+            if (hasOwnProperty.call(options, 'circularValue')) {
+                const circularValue = options.circularValue;
+                if ('string' == typeof circularValue) return `"${circularValue}"`;
+                if (null == circularValue) return circularValue;
+                if (circularValue === Error || circularValue === TypeError) return {
+                    toString () {
+                        throw new TypeError('Converting circular structure to JSON');
+                    }
+                };
+                throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
+            }
+            return '"[Circular]"';
+        }
+        function getDeterministicOption(options) {
+            let value;
+            if (hasOwnProperty.call(options, 'deterministic')) {
+                value = options.deterministic;
+                if ('boolean' != typeof value && 'function' != typeof value) throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
+            }
+            return void 0 === value ? true : value;
+        }
+        function getBooleanOption(options, key) {
+            let value;
+            if (hasOwnProperty.call(options, key)) {
+                value = options[key];
+                if ('boolean' != typeof value) throw new TypeError(`The "${key}" argument must be of type boolean`);
+            }
+            return void 0 === value ? true : value;
+        }
+        function getPositiveIntegerOption(options, key) {
+            let value;
+            if (hasOwnProperty.call(options, key)) {
+                value = options[key];
+                if ('number' != typeof value) throw new TypeError(`The "${key}" argument must be of type number`);
+                if (!Number.isInteger(value)) throw new TypeError(`The "${key}" argument must be an integer`);
+                if (value < 1) throw new RangeError(`The "${key}" argument must be >= 1`);
+            }
+            return void 0 === value ? 1 / 0 : value;
+        }
+        function getItemCount(number) {
+            if (1 === number) return '1 item';
+            return `${number} items`;
+        }
+        function getUniqueReplacerSet(replacerArray) {
+            const replacerSet = new Set();
+            for (const value of replacerArray)if ('string' == typeof value || 'number' == typeof value) replacerSet.add(String(value));
+            return replacerSet;
+        }
+        function getStrictOption(options) {
+            if (hasOwnProperty.call(options, 'strict')) {
+                const value = options.strict;
+                if ('boolean' != typeof value) throw new TypeError('The "strict" argument must be of type boolean');
+                if (value) return (value)=>{
+                    let message = `Object can not safely be stringified. Received type ${typeof value}`;
+                    if ('function' != typeof value) message += ` (${value.toString()})`;
+                    throw new Error(message);
+                };
+            }
+        }
+        function configure(options) {
+            options = {
+                ...options
+            };
+            const fail = getStrictOption(options);
+            if (fail) {
+                if (void 0 === options.bigint) options.bigint = false;
+                if (!('circularValue' in options)) options.circularValue = Error;
+            }
+            const circularValue = getCircularValueOption(options);
+            const bigint = getBooleanOption(options, 'bigint');
+            const deterministic = getDeterministicOption(options);
+            const comparator = 'function' == typeof deterministic ? deterministic : void 0;
+            const maximumDepth = getPositiveIntegerOption(options, 'maximumDepth');
+            const maximumBreadth = getPositiveIntegerOption(options, 'maximumBreadth');
+            function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
+                let value = parent[key];
+                if ('object' == typeof value && null !== value && 'function' == typeof value.toJSON) value = value.toJSON(key);
+                value = replacer.call(parent, key, value);
+                switch(typeof value){
+                    case 'string':
+                        return strEscape(value);
+                    case 'object':
+                        {
+                            if (null === value) return 'null';
+                            if (-1 !== stack.indexOf(value)) return circularValue;
+                            let res = '';
+                            let join = ',';
+                            const originalIndentation = indentation;
+                            if (Array.isArray(value)) {
+                                if (0 === value.length) return '[]';
+                                if (maximumDepth < stack.length + 1) return '"[Array]"';
+                                stack.push(value);
+                                if ('' !== spacer) {
+                                    indentation += spacer;
+                                    res += `\n${indentation}`;
+                                    join = `,\n${indentation}`;
+                                }
+                                const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+                                let i = 0;
+                                for(; i < maximumValuesToStringify - 1; i++){
+                                    const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+                                    res += void 0 !== tmp ? tmp : 'null';
+                                    res += join;
+                                }
+                                const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+                                res += void 0 !== tmp ? tmp : 'null';
+                                if (value.length - 1 > maximumBreadth) {
+                                    const removedKeys = value.length - maximumBreadth - 1;
+                                    res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+                                }
+                                if ('' !== spacer) res += `\n${originalIndentation}`;
+                                stack.pop();
+                                return `[${res}]`;
+                            }
+                            let keys = Object.keys(value);
+                            const keyLength = keys.length;
+                            if (0 === keyLength) return '{}';
+                            if (maximumDepth < stack.length + 1) return '"[Object]"';
+                            let whitespace = '';
+                            let separator = '';
+                            if ('' !== spacer) {
+                                indentation += spacer;
+                                join = `,\n${indentation}`;
+                                whitespace = ' ';
+                            }
+                            const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+                            if (deterministic && !isTypedArrayWithEntries(value)) keys = sort(keys, comparator);
+                            stack.push(value);
+                            for(let i = 0; i < maximumPropertiesToStringify; i++){
+                                const key = keys[i];
+                                const tmp = stringifyFnReplacer(key, value, stack, replacer, spacer, indentation);
+                                if (void 0 !== tmp) {
+                                    res += `${separator}${strEscape(key)}:${whitespace}${tmp}`;
+                                    separator = join;
+                                }
+                            }
+                            if (keyLength > maximumBreadth) {
+                                const removedKeys = keyLength - maximumBreadth;
+                                res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
+                                separator = join;
+                            }
+                            if ('' !== spacer && separator.length > 1) res = `\n${indentation}${res}\n${originalIndentation}`;
+                            stack.pop();
+                            return `{${res}}`;
+                        }
+                    case 'number':
+                        return isFinite(value) ? String(value) : fail ? fail(value) : 'null';
+                    case 'boolean':
+                        return true === value ? 'true' : 'false';
+                    case 'undefined':
+                        return;
+                    case 'bigint':
+                        if (bigint) return String(value);
+                    default:
+                        return fail ? fail(value) : void 0;
+                }
+            }
+            function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
+                if ('object' == typeof value && null !== value && 'function' == typeof value.toJSON) value = value.toJSON(key);
+                switch(typeof value){
+                    case 'string':
+                        return strEscape(value);
+                    case 'object':
+                        {
+                            if (null === value) return 'null';
+                            if (-1 !== stack.indexOf(value)) return circularValue;
+                            const originalIndentation = indentation;
+                            let res = '';
+                            let join = ',';
+                            if (Array.isArray(value)) {
+                                if (0 === value.length) return '[]';
+                                if (maximumDepth < stack.length + 1) return '"[Array]"';
+                                stack.push(value);
+                                if ('' !== spacer) {
+                                    indentation += spacer;
+                                    res += `\n${indentation}`;
+                                    join = `,\n${indentation}`;
+                                }
+                                const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+                                let i = 0;
+                                for(; i < maximumValuesToStringify - 1; i++){
+                                    const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+                                    res += void 0 !== tmp ? tmp : 'null';
+                                    res += join;
+                                }
+                                const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+                                res += void 0 !== tmp ? tmp : 'null';
+                                if (value.length - 1 > maximumBreadth) {
+                                    const removedKeys = value.length - maximumBreadth - 1;
+                                    res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+                                }
+                                if ('' !== spacer) res += `\n${originalIndentation}`;
+                                stack.pop();
+                                return `[${res}]`;
+                            }
+                            stack.push(value);
+                            let whitespace = '';
+                            if ('' !== spacer) {
+                                indentation += spacer;
+                                join = `,\n${indentation}`;
+                                whitespace = ' ';
+                            }
+                            let separator = '';
+                            for (const key of replacer){
+                                const tmp = stringifyArrayReplacer(key, value[key], stack, replacer, spacer, indentation);
+                                if (void 0 !== tmp) {
+                                    res += `${separator}${strEscape(key)}:${whitespace}${tmp}`;
+                                    separator = join;
+                                }
+                            }
+                            if ('' !== spacer && separator.length > 1) res = `\n${indentation}${res}\n${originalIndentation}`;
+                            stack.pop();
+                            return `{${res}}`;
+                        }
+                    case 'number':
+                        return isFinite(value) ? String(value) : fail ? fail(value) : 'null';
+                    case 'boolean':
+                        return true === value ? 'true' : 'false';
+                    case 'undefined':
+                        return;
+                    case 'bigint':
+                        if (bigint) return String(value);
+                    default:
+                        return fail ? fail(value) : void 0;
+                }
+            }
+            function stringifyIndent(key, value, stack, spacer, indentation) {
+                switch(typeof value){
+                    case 'string':
+                        return strEscape(value);
+                    case 'object':
+                        {
+                            if (null === value) return 'null';
+                            if ('function' == typeof value.toJSON) {
+                                value = value.toJSON(key);
+                                if ('object' != typeof value) return stringifyIndent(key, value, stack, spacer, indentation);
+                                if (null === value) return 'null';
+                            }
+                            if (-1 !== stack.indexOf(value)) return circularValue;
+                            const originalIndentation = indentation;
+                            if (Array.isArray(value)) {
+                                if (0 === value.length) return '[]';
+                                if (maximumDepth < stack.length + 1) return '"[Array]"';
+                                stack.push(value);
+                                indentation += spacer;
+                                let res = `\n${indentation}`;
+                                const join = `,\n${indentation}`;
+                                const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+                                let i = 0;
+                                for(; i < maximumValuesToStringify - 1; i++){
+                                    const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+                                    res += void 0 !== tmp ? tmp : 'null';
+                                    res += join;
+                                }
+                                const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+                                res += void 0 !== tmp ? tmp : 'null';
+                                if (value.length - 1 > maximumBreadth) {
+                                    const removedKeys = value.length - maximumBreadth - 1;
+                                    res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+                                }
+                                res += `\n${originalIndentation}`;
+                                stack.pop();
+                                return `[${res}]`;
+                            }
+                            let keys = Object.keys(value);
+                            const keyLength = keys.length;
+                            if (0 === keyLength) return '{}';
+                            if (maximumDepth < stack.length + 1) return '"[Object]"';
+                            indentation += spacer;
+                            const join = `,\n${indentation}`;
+                            let res = '';
+                            let separator = '';
+                            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+                            if (isTypedArrayWithEntries(value)) {
+                                res += stringifyTypedArray(value, join, maximumBreadth);
+                                keys = keys.slice(value.length);
+                                maximumPropertiesToStringify -= value.length;
+                                separator = join;
+                            }
+                            if (deterministic) keys = sort(keys, comparator);
+                            stack.push(value);
+                            for(let i = 0; i < maximumPropertiesToStringify; i++){
+                                const key = keys[i];
+                                const tmp = stringifyIndent(key, value[key], stack, spacer, indentation);
+                                if (void 0 !== tmp) {
+                                    res += `${separator}${strEscape(key)}: ${tmp}`;
+                                    separator = join;
+                                }
+                            }
+                            if (keyLength > maximumBreadth) {
+                                const removedKeys = keyLength - maximumBreadth;
+                                res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
+                                separator = join;
+                            }
+                            if ('' !== separator) res = `\n${indentation}${res}\n${originalIndentation}`;
+                            stack.pop();
+                            return `{${res}}`;
+                        }
+                    case 'number':
+                        return isFinite(value) ? String(value) : fail ? fail(value) : 'null';
+                    case 'boolean':
+                        return true === value ? 'true' : 'false';
+                    case 'undefined':
+                        return;
+                    case 'bigint':
+                        if (bigint) return String(value);
+                    default:
+                        return fail ? fail(value) : void 0;
+                }
+            }
+            function stringifySimple(key, value, stack) {
+                switch(typeof value){
+                    case 'string':
+                        return strEscape(value);
+                    case 'object':
+                        {
+                            if (null === value) return 'null';
+                            if ('function' == typeof value.toJSON) {
+                                value = value.toJSON(key);
+                                if ('object' != typeof value) return stringifySimple(key, value, stack);
+                                if (null === value) return 'null';
+                            }
+                            if (-1 !== stack.indexOf(value)) return circularValue;
+                            let res = '';
+                            const hasLength = void 0 !== value.length;
+                            if (hasLength && Array.isArray(value)) {
+                                if (0 === value.length) return '[]';
+                                if (maximumDepth < stack.length + 1) return '"[Array]"';
+                                stack.push(value);
+                                const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+                                let i = 0;
+                                for(; i < maximumValuesToStringify - 1; i++){
+                                    const tmp = stringifySimple(String(i), value[i], stack);
+                                    res += void 0 !== tmp ? tmp : 'null';
+                                    res += ',';
+                                }
+                                const tmp = stringifySimple(String(i), value[i], stack);
+                                res += void 0 !== tmp ? tmp : 'null';
+                                if (value.length - 1 > maximumBreadth) {
+                                    const removedKeys = value.length - maximumBreadth - 1;
+                                    res += `,"... ${getItemCount(removedKeys)} not stringified"`;
+                                }
+                                stack.pop();
+                                return `[${res}]`;
+                            }
+                            let keys = Object.keys(value);
+                            const keyLength = keys.length;
+                            if (0 === keyLength) return '{}';
+                            if (maximumDepth < stack.length + 1) return '"[Object]"';
+                            let separator = '';
+                            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+                            if (hasLength && isTypedArrayWithEntries(value)) {
+                                res += stringifyTypedArray(value, ',', maximumBreadth);
+                                keys = keys.slice(value.length);
+                                maximumPropertiesToStringify -= value.length;
+                                separator = ',';
+                            }
+                            if (deterministic) keys = sort(keys, comparator);
+                            stack.push(value);
+                            for(let i = 0; i < maximumPropertiesToStringify; i++){
+                                const key = keys[i];
+                                const tmp = stringifySimple(key, value[key], stack);
+                                if (void 0 !== tmp) {
+                                    res += `${separator}${strEscape(key)}:${tmp}`;
+                                    separator = ',';
+                                }
+                            }
+                            if (keyLength > maximumBreadth) {
+                                const removedKeys = keyLength - maximumBreadth;
+                                res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
+                            }
+                            stack.pop();
+                            return `{${res}}`;
+                        }
+                    case 'number':
+                        return isFinite(value) ? String(value) : fail ? fail(value) : 'null';
+                    case 'boolean':
+                        return true === value ? 'true' : 'false';
+                    case 'undefined':
+                        return;
+                    case 'bigint':
+                        if (bigint) return String(value);
+                    default:
+                        return fail ? fail(value) : void 0;
+                }
+            }
+            function stringify(value, replacer, space) {
+                if (arguments.length > 1) {
+                    let spacer = '';
+                    if ('number' == typeof space) spacer = ' '.repeat(Math.min(space, 10));
+                    else if ('string' == typeof space) spacer = space.slice(0, 10);
+                    if (null != replacer) {
+                        if ('function' == typeof replacer) return stringifyFnReplacer('', {
+                            '': value
+                        }, [], replacer, spacer, '');
+                        if (Array.isArray(replacer)) return stringifyArrayReplacer('', value, [], getUniqueReplacerSet(replacer), spacer, '');
+                    }
+                    if (0 !== spacer.length) return stringifyIndent('', value, [], spacer, '');
+                }
+                return stringifySimple('', value, []);
+            }
+            return stringify;
+        }
+    },
+    "../../node_modules/.pnpm/split2@4.2.0/node_modules/split2/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { Transform } = __webpack_require__("stream");
+        const { StringDecoder } = __webpack_require__("string_decoder");
+        const kLast = Symbol('last');
+        const kDecoder = Symbol('decoder');
+        function transform(chunk, enc, cb) {
+            let list;
+            if (this.overflow) {
+                const buf = this[kDecoder].write(chunk);
+                list = buf.split(this.matcher);
+                if (1 === list.length) return cb();
+                list.shift();
+                this.overflow = false;
+            } else {
+                this[kLast] += this[kDecoder].write(chunk);
+                list = this[kLast].split(this.matcher);
+            }
+            this[kLast] = list.pop();
+            for(let i = 0; i < list.length; i++)try {
+                push(this, this.mapper(list[i]));
+            } catch (error) {
+                return cb(error);
+            }
+            this.overflow = this[kLast].length > this.maxLength;
+            if (this.overflow && !this.skipOverflow) return void cb(new Error('maximum buffer reached'));
+            cb();
+        }
+        function flush(cb) {
+            this[kLast] += this[kDecoder].end();
+            if (this[kLast]) try {
+                push(this, this.mapper(this[kLast]));
+            } catch (error) {
+                return cb(error);
+            }
+            cb();
+        }
+        function push(self, val) {
+            if (void 0 !== val) self.push(val);
+        }
+        function noop(incoming) {
+            return incoming;
+        }
+        function split(matcher, mapper, options) {
+            matcher = matcher || /\r?\n/;
+            mapper = mapper || noop;
+            options = options || {};
+            switch(arguments.length){
+                case 1:
+                    if ('function' == typeof matcher) {
+                        mapper = matcher;
+                        matcher = /\r?\n/;
+                    } else if ('object' == typeof matcher && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
+                        options = matcher;
+                        matcher = /\r?\n/;
+                    }
+                    break;
+                case 2:
+                    if ('function' == typeof matcher) {
+                        options = mapper;
+                        mapper = matcher;
+                        matcher = /\r?\n/;
+                    } else if ('object' == typeof mapper) {
+                        options = mapper;
+                        mapper = noop;
+                    }
+            }
+            options = Object.assign({}, options);
+            options.autoDestroy = true;
+            options.transform = transform;
+            options.flush = flush;
+            options.readableObjectMode = true;
+            const stream = new Transform(options);
+            stream[kLast] = '';
+            stream[kDecoder] = new StringDecoder('utf8');
+            stream.matcher = matcher;
+            stream.mapper = mapper;
+            stream.maxLength = options.maxLength;
+            stream.skipOverflow = options.skipOverflow || false;
+            stream.overflow = false;
+            stream._destroy = function(err, cb) {
+                this._writableState.errorEmitted = false;
+                cb(err);
+            };
+            return stream;
+        }
+        module1.exports = split;
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { version } = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/package.json");
+        const { EventEmitter } = __webpack_require__("events");
+        const { Worker } = __webpack_require__("worker_threads");
+        const { join } = __webpack_require__("path");
+        const { pathToFileURL } = __webpack_require__("url");
+        const { wait } = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/wait.js");
+        const { WRITE_INDEX, READ_INDEX } = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/indexes.js");
+        const buffer = __webpack_require__("buffer");
+        const assert = __webpack_require__("assert");
+        const kImpl = Symbol('kImpl');
+        const MAX_STRING = buffer.constants.MAX_STRING_LENGTH;
+        class FakeWeakRef {
+            constructor(value){
+                this._value = value;
+            }
+            deref() {
+                return this._value;
+            }
+        }
+        class FakeFinalizationRegistry {
+            register() {}
+            unregister() {}
+        }
+        const FinalizationRegistry1 = process.env.NODE_V8_COVERAGE ? FakeFinalizationRegistry : global.FinalizationRegistry || FakeFinalizationRegistry;
+        const WeakRef1 = process.env.NODE_V8_COVERAGE ? FakeWeakRef : global.WeakRef || FakeWeakRef;
+        const registry = new FinalizationRegistry1((worker)=>{
+            if (worker.exited) return;
+            worker.terminate();
+        });
+        function createWorker(stream, opts) {
+            const { filename, workerData } = opts;
+            const bundlerOverrides = '__bundlerPathsOverrides' in globalThis ? globalThis.__bundlerPathsOverrides : {};
+            const toExecute = bundlerOverrides['thread-stream-worker'] || join(__dirname, 'lib', 'worker.js');
+            const worker = new Worker(toExecute, {
+                ...opts.workerOpts,
+                trackUnmanagedFds: false,
+                workerData: {
+                    filename: 0 === filename.indexOf('file://') ? filename : pathToFileURL(filename).href,
+                    dataBuf: stream[kImpl].dataBuf,
+                    stateBuf: stream[kImpl].stateBuf,
+                    workerData: {
+                        $context: {
+                            threadStreamVersion: version
+                        },
+                        ...workerData
+                    }
+                }
+            });
+            worker.stream = new FakeWeakRef(stream);
+            worker.on('message', onWorkerMessage);
+            worker.on('exit', onWorkerExit);
+            registry.register(stream, worker);
+            return worker;
+        }
+        function drain(stream) {
+            assert(!stream[kImpl].sync);
+            if (stream[kImpl].needDrain) {
+                stream[kImpl].needDrain = false;
+                stream.emit('drain');
+            }
+        }
+        function nextFlush(stream) {
+            const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+            let leftover = stream[kImpl].data.length - writeIndex;
+            if (leftover > 0) {
+                if (0 === stream[kImpl].buf.length) {
+                    stream[kImpl].flushing = false;
+                    if (stream[kImpl].ending) end(stream);
+                    else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
+                    return;
+                }
+                let toWrite = stream[kImpl].buf.slice(0, leftover);
+                let toWriteBytes = Buffer.byteLength(toWrite);
+                if (toWriteBytes <= leftover) {
+                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+                    write(stream, toWrite, nextFlush.bind(null, stream));
+                } else stream.flush(()=>{
+                    if (stream.destroyed) return;
+                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+                    while(toWriteBytes > stream[kImpl].data.length){
+                        leftover /= 2;
+                        toWrite = stream[kImpl].buf.slice(0, leftover);
+                        toWriteBytes = Buffer.byteLength(toWrite);
+                    }
+                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+                    write(stream, toWrite, nextFlush.bind(null, stream));
+                });
+            } else if (0 === leftover) {
+                if (0 === writeIndex && 0 === stream[kImpl].buf.length) return;
+                stream.flush(()=>{
+                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+                    nextFlush(stream);
+                });
+            } else destroy(stream, new Error('overwritten'));
+        }
+        function onWorkerMessage(msg) {
+            const stream = this.stream.deref();
+            if (void 0 === stream) {
+                this.exited = true;
+                this.terminate();
+                return;
+            }
+            switch(msg.code){
+                case 'READY':
+                    this.stream = new WeakRef1(stream);
+                    stream.flush(()=>{
+                        stream[kImpl].ready = true;
+                        stream.emit('ready');
+                    });
+                    break;
+                case 'ERROR':
+                    destroy(stream, msg.err);
+                    break;
+                case 'EVENT':
+                    if (Array.isArray(msg.args)) stream.emit(msg.name, ...msg.args);
+                    else stream.emit(msg.name, msg.args);
+                    break;
+                case 'WARNING':
+                    process.emitWarning(msg.err);
+                    break;
+                default:
+                    destroy(stream, new Error('this should not happen: ' + msg.code));
+            }
+        }
+        function onWorkerExit(code) {
+            const stream = this.stream.deref();
+            if (void 0 === stream) return;
+            registry.unregister(stream);
+            stream.worker.exited = true;
+            stream.worker.off('exit', onWorkerExit);
+            destroy(stream, 0 !== code ? new Error('the worker thread exited') : null);
+        }
+        class ThreadStream extends EventEmitter {
+            constructor(opts = {}){
+                super();
+                if (opts.bufferSize < 4) throw new Error('bufferSize must at least fit a 4-byte utf-8 char');
+                this[kImpl] = {};
+                this[kImpl].stateBuf = new SharedArrayBuffer(128);
+                this[kImpl].state = new Int32Array(this[kImpl].stateBuf);
+                this[kImpl].dataBuf = new SharedArrayBuffer(opts.bufferSize || 4194304);
+                this[kImpl].data = Buffer.from(this[kImpl].dataBuf);
+                this[kImpl].sync = opts.sync || false;
+                this[kImpl].ending = false;
+                this[kImpl].ended = false;
+                this[kImpl].needDrain = false;
+                this[kImpl].destroyed = false;
+                this[kImpl].flushing = false;
+                this[kImpl].ready = false;
+                this[kImpl].finished = false;
+                this[kImpl].errored = null;
+                this[kImpl].closed = false;
+                this[kImpl].buf = '';
+                this.worker = createWorker(this, opts);
+                this.on('message', (message, transferList)=>{
+                    this.worker.postMessage(message, transferList);
+                });
+            }
+            write(data) {
+                if (this[kImpl].destroyed) {
+                    error(this, new Error('the worker has exited'));
+                    return false;
+                }
+                if (this[kImpl].ending) {
+                    error(this, new Error('the worker is ending'));
+                    return false;
+                }
+                if (this[kImpl].flushing && this[kImpl].buf.length + data.length >= MAX_STRING) try {
+                    writeSync(this);
+                    this[kImpl].flushing = true;
+                } catch (err) {
+                    destroy(this, err);
+                    return false;
+                }
+                this[kImpl].buf += data;
+                if (this[kImpl].sync) try {
+                    writeSync(this);
+                    return true;
+                } catch (err) {
+                    destroy(this, err);
+                    return false;
+                }
+                if (!this[kImpl].flushing) {
+                    this[kImpl].flushing = true;
+                    setImmediate(nextFlush, this);
+                }
+                this[kImpl].needDrain = this[kImpl].data.length - this[kImpl].buf.length - Atomics.load(this[kImpl].state, WRITE_INDEX) <= 0;
+                return !this[kImpl].needDrain;
+            }
+            end() {
+                if (this[kImpl].destroyed) return;
+                this[kImpl].ending = true;
+                end(this);
+            }
+            flush(cb) {
+                if (this[kImpl].destroyed) {
+                    if ('function' == typeof cb) process.nextTick(cb, new Error('the worker has exited'));
+                    return;
+                }
+                const writeIndex = Atomics.load(this[kImpl].state, WRITE_INDEX);
+                wait(this[kImpl].state, READ_INDEX, writeIndex, 1 / 0, (err, res)=>{
+                    if (err) {
+                        destroy(this, err);
+                        process.nextTick(cb, err);
+                        return;
+                    }
+                    if ('not-equal' === res) return void this.flush(cb);
+                    process.nextTick(cb);
+                });
+            }
+            flushSync() {
+                if (this[kImpl].destroyed) return;
+                writeSync(this);
+                flushSync(this);
+            }
+            unref() {
+                this.worker.unref();
+            }
+            ref() {
+                this.worker.ref();
+            }
+            get ready() {
+                return this[kImpl].ready;
+            }
+            get destroyed() {
+                return this[kImpl].destroyed;
+            }
+            get closed() {
+                return this[kImpl].closed;
+            }
+            get writable() {
+                return !this[kImpl].destroyed && !this[kImpl].ending;
+            }
+            get writableEnded() {
+                return this[kImpl].ending;
+            }
+            get writableFinished() {
+                return this[kImpl].finished;
+            }
+            get writableNeedDrain() {
+                return this[kImpl].needDrain;
+            }
+            get writableObjectMode() {
+                return false;
+            }
+            get writableErrored() {
+                return this[kImpl].errored;
+            }
+        }
+        function error(stream, err) {
+            setImmediate(()=>{
+                stream.emit('error', err);
+            });
+        }
+        function destroy(stream, err) {
+            if (stream[kImpl].destroyed) return;
+            stream[kImpl].destroyed = true;
+            if (err) {
+                stream[kImpl].errored = err;
+                error(stream, err);
+            }
+            if (stream.worker.exited) setImmediate(()=>{
+                stream[kImpl].closed = true;
+                stream.emit('close');
+            });
+            else stream.worker.terminate().catch(()=>{}).then(()=>{
+                stream[kImpl].closed = true;
+                stream.emit('close');
+            });
+        }
+        function write(stream, data, cb) {
+            const current = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+            const length = Buffer.byteLength(data);
+            stream[kImpl].data.write(data, current);
+            Atomics.store(stream[kImpl].state, WRITE_INDEX, current + length);
+            Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+            cb();
+            return true;
+        }
+        function end(stream) {
+            if (stream[kImpl].ended || !stream[kImpl].ending || stream[kImpl].flushing) return;
+            stream[kImpl].ended = true;
+            try {
+                stream.flushSync();
+                let readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+                Atomics.store(stream[kImpl].state, WRITE_INDEX, -1);
+                Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+                let spins = 0;
+                while(-1 !== readIndex){
+                    Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1000);
+                    readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+                    if (-2 === readIndex) return void destroy(stream, new Error('end() failed'));
+                    if (10 === ++spins) return void destroy(stream, new Error('end() took too long (10s)'));
+                }
+                process.nextTick(()=>{
+                    stream[kImpl].finished = true;
+                    stream.emit('finish');
+                });
+            } catch (err) {
+                destroy(stream, err);
+            }
+        }
+        function writeSync(stream) {
+            const cb = ()=>{
+                if (stream[kImpl].ending) end(stream);
+                else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
+            };
+            stream[kImpl].flushing = false;
+            while(0 !== stream[kImpl].buf.length){
+                const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+                let leftover = stream[kImpl].data.length - writeIndex;
+                if (0 === leftover) {
+                    flushSync(stream);
+                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+                    continue;
+                }
+                if (leftover < 0) throw new Error('overwritten');
+                let toWrite = stream[kImpl].buf.slice(0, leftover);
+                let toWriteBytes = Buffer.byteLength(toWrite);
+                if (toWriteBytes <= leftover) {
+                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+                    write(stream, toWrite, cb);
+                } else {
+                    flushSync(stream);
+                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+                    while(toWriteBytes > stream[kImpl].buf.length){
+                        leftover /= 2;
+                        toWrite = stream[kImpl].buf.slice(0, leftover);
+                        toWriteBytes = Buffer.byteLength(toWrite);
+                    }
+                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+                    write(stream, toWrite, cb);
+                }
+            }
+        }
+        function flushSync(stream) {
+            if (stream[kImpl].flushing) throw new Error('unable to flush while flushing');
+            const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+            let spins = 0;
+            while(true){
+                const readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+                if (-2 === readIndex) throw Error('_flushSync failed');
+                if (readIndex !== writeIndex) Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1000);
+                else break;
+                if (10 === ++spins) throw new Error('_flushSync took too long (10s)');
+            }
+        }
+        module1.exports = ThreadStream;
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/indexes.js": function(module1) {
+        "use strict";
+        const WRITE_INDEX = 4;
+        const READ_INDEX = 8;
+        module1.exports = {
+            WRITE_INDEX,
+            READ_INDEX
+        };
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/wait.js": function(module1) {
+        "use strict";
+        const MAX_TIMEOUT = 1000;
+        function wait(state, index, expected, timeout, done) {
+            const max = Date.now() + timeout;
+            let current = Atomics.load(state, index);
+            if (current === expected) return void done(null, 'ok');
+            let prior = current;
+            const check = (backoff)=>{
+                if (Date.now() > max) done(null, 'timed-out');
+                else setTimeout(()=>{
+                    prior = current;
+                    current = Atomics.load(state, index);
+                    if (current === prior) check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : 2 * backoff);
+                    else current === expected ? done(null, 'ok') : done(null, 'not-equal');
+                }, backoff);
+            };
+            check(1);
+        }
+        function waitDiff(state, index, expected, timeout, done) {
+            const max = Date.now() + timeout;
+            let current = Atomics.load(state, index);
+            if (current !== expected) return void done(null, 'ok');
+            const check = (backoff)=>{
+                if (Date.now() > max) done(null, 'timed-out');
+                else setTimeout(()=>{
+                    current = Atomics.load(state, index);
+                    if (current !== expected) done(null, 'ok');
+                    else check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : 2 * backoff);
+                }, backoff);
+            };
+            check(1);
+        }
+        module1.exports = {
+            wait,
+            waitDiff
+        };
+    },
+    assert: function(module1) {
+        "use strict";
+        module1.exports = require("assert");
+    },
+    buffer: function(module1) {
+        "use strict";
+        module1.exports = require("buffer");
+    },
+    events: function(module1) {
+        "use strict";
+        module1.exports = require("events");
+    },
+    fs: function(module1) {
+        "use strict";
+        module1.exports = require("fs");
+    },
+    module: function(module1) {
+        "use strict";
+        module1.exports = require("module");
+    },
+    "node:events": function(module1) {
+        "use strict";
+        module1.exports = require("node:events");
+    },
+    "node:os": function(module1) {
+        "use strict";
+        module1.exports = require("node:os");
+    },
+    "node:path": function(module1) {
+        "use strict";
+        module1.exports = require("node:path");
+    },
+    "node:stream": function(module1) {
+        "use strict";
+        module1.exports = require("node:stream");
+    },
+    path: function(module1) {
+        "use strict";
+        module1.exports = require("path");
+    },
+    stream: function(module1) {
+        "use strict";
+        module1.exports = require("stream");
+    },
+    string_decoder: function(module1) {
+        "use strict";
+        module1.exports = require("string_decoder");
+    },
+    url: function(module1) {
+        "use strict";
+        module1.exports = require("url");
+    },
+    util: function(module1) {
+        "use strict";
+        module1.exports = require("util");
+    },
+    worker_threads: function(module1) {
+        "use strict";
+        module1.exports = require("worker_threads");
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const errSerializer = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err.js");
+        const errWithCauseSerializer = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-with-cause.js");
+        const reqSerializers = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/req.js");
+        const resSerializers = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/res.js");
+        module1.exports = {
+            err: errSerializer,
+            errWithCause: errWithCauseSerializer,
+            mapHttpRequest: reqSerializers.mapHttpRequest,
+            mapHttpResponse: resSerializers.mapHttpResponse,
+            req: reqSerializers.reqSerializer,
+            res: resSerializers.resSerializer,
+            wrapErrorSerializer: function(customSerializer) {
+                if (customSerializer === errSerializer) return customSerializer;
+                return function(err) {
+                    return customSerializer(errSerializer(err));
+                };
+            },
+            wrapRequestSerializer: function(customSerializer) {
+                if (customSerializer === reqSerializers.reqSerializer) return customSerializer;
+                return function(req) {
+                    return customSerializer(reqSerializers.reqSerializer(req));
+                };
+            },
+            wrapResponseSerializer: function(customSerializer) {
+                if (customSerializer === resSerializers.resSerializer) return customSerializer;
+                return function(res) {
+                    return customSerializer(resSerializers.resSerializer(res));
+                };
+            }
+        };
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-helpers.js": function(module1) {
+        "use strict";
+        const isErrorLike = (err)=>err && 'string' == typeof err.message;
+        const getErrorCause = (err)=>{
+            if (!err) return;
+            const cause = err.cause;
+            if ('function' != typeof cause) return isErrorLike(cause) ? cause : void 0;
+            {
+                const causeResult = err.cause();
+                return isErrorLike(causeResult) ? causeResult : void 0;
+            }
+        };
+        const _stackWithCauses = (err, seen)=>{
+            if (!isErrorLike(err)) return '';
+            const stack = err.stack || '';
+            if (seen.has(err)) return stack + '\ncauses have become circular...';
+            const cause = getErrorCause(err);
+            if (!cause) return stack;
+            seen.add(err);
+            return stack + '\ncaused by: ' + _stackWithCauses(cause, seen);
+        };
+        const stackWithCauses = (err)=>_stackWithCauses(err, new Set());
+        const _messageWithCauses = (err, seen, skip)=>{
+            if (!isErrorLike(err)) return '';
+            const message = skip ? '' : err.message || '';
+            if (seen.has(err)) return message + ': ...';
+            const cause = getErrorCause(err);
+            if (!cause) return message;
+            {
+                seen.add(err);
+                const skipIfVErrorStyleCause = 'function' == typeof err.cause;
+                return message + (skipIfVErrorStyleCause ? '' : ': ') + _messageWithCauses(cause, seen, skipIfVErrorStyleCause);
+            }
+        };
+        const messageWithCauses = (err)=>_messageWithCauses(err, new Set());
+        module1.exports = {
+            isErrorLike,
+            getErrorCause,
+            stackWithCauses,
+            messageWithCauses
+        };
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-proto.js": function(module1) {
+        "use strict";
+        const seen = Symbol('circular-ref-tag');
+        const rawSymbol = Symbol('pino-raw-err-ref');
+        const pinoErrProto = Object.create({}, {
+            type: {
+                enumerable: true,
+                writable: true,
+                value: void 0
+            },
+            message: {
+                enumerable: true,
+                writable: true,
+                value: void 0
+            },
+            stack: {
+                enumerable: true,
+                writable: true,
+                value: void 0
+            },
+            aggregateErrors: {
+                enumerable: true,
+                writable: true,
+                value: void 0
+            },
+            raw: {
+                enumerable: false,
+                get: function() {
+                    return this[rawSymbol];
+                },
+                set: function(val) {
+                    this[rawSymbol] = val;
+                }
+            }
+        });
+        Object.defineProperty(pinoErrProto, rawSymbol, {
+            writable: true,
+            value: {}
+        });
+        module1.exports = {
+            pinoErrProto,
+            pinoErrorSymbols: {
+                seen,
+                rawSymbol
+            }
+        };
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-with-cause.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = errWithCauseSerializer;
+        const { isErrorLike } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-helpers.js");
+        const { pinoErrProto, pinoErrorSymbols } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-proto.js");
+        const { seen } = pinoErrorSymbols;
+        const { toString } = Object.prototype;
+        function errWithCauseSerializer(err) {
+            if (!isErrorLike(err)) return err;
+            err[seen] = void 0;
+            const _err = Object.create(pinoErrProto);
+            _err.type = '[object Function]' === toString.call(err.constructor) ? err.constructor.name : err.name;
+            _err.message = err.message;
+            _err.stack = err.stack;
+            if (Array.isArray(err.errors)) _err.aggregateErrors = err.errors.map((err)=>errWithCauseSerializer(err));
+            if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) _err.cause = errWithCauseSerializer(err.cause);
+            for(const key in err)if (void 0 === _err[key]) {
+                const val = err[key];
+                if (isErrorLike(val)) {
+                    if (!Object.prototype.hasOwnProperty.call(val, seen)) _err[key] = errWithCauseSerializer(val);
+                } else _err[key] = val;
+            }
+            delete err[seen];
+            _err.raw = err;
+            return _err;
+        }
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = errSerializer;
+        const { messageWithCauses, stackWithCauses, isErrorLike } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-helpers.js");
+        const { pinoErrProto, pinoErrorSymbols } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-proto.js");
+        const { seen } = pinoErrorSymbols;
+        const { toString } = Object.prototype;
+        function errSerializer(err) {
+            if (!isErrorLike(err)) return err;
+            err[seen] = void 0;
+            const _err = Object.create(pinoErrProto);
+            _err.type = '[object Function]' === toString.call(err.constructor) ? err.constructor.name : err.name;
+            _err.message = messageWithCauses(err);
+            _err.stack = stackWithCauses(err);
+            if (Array.isArray(err.errors)) _err.aggregateErrors = err.errors.map((err)=>errSerializer(err));
+            for(const key in err)if (void 0 === _err[key]) {
+                const val = err[key];
+                if (isErrorLike(val)) {
+                    if ('cause' !== key && !Object.prototype.hasOwnProperty.call(val, seen)) _err[key] = errSerializer(val);
+                } else _err[key] = val;
+            }
+            delete err[seen];
+            _err.raw = err;
+            return _err;
+        }
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/req.js": function(module1) {
+        "use strict";
+        module1.exports = {
+            mapHttpRequest,
+            reqSerializer
+        };
+        const rawSymbol = Symbol('pino-raw-req-ref');
+        const pinoReqProto = Object.create({}, {
+            id: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            method: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            url: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            query: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            params: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            headers: {
+                enumerable: true,
+                writable: true,
+                value: {}
+            },
+            remoteAddress: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            remotePort: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            raw: {
+                enumerable: false,
+                get: function() {
+                    return this[rawSymbol];
+                },
+                set: function(val) {
+                    this[rawSymbol] = val;
+                }
+            }
+        });
+        Object.defineProperty(pinoReqProto, rawSymbol, {
+            writable: true,
+            value: {}
+        });
+        function reqSerializer(req) {
+            const connection = req.info || req.socket;
+            const _req = Object.create(pinoReqProto);
+            _req.id = 'function' == typeof req.id ? req.id() : req.id || (req.info ? req.info.id : void 0);
+            _req.method = req.method;
+            if (req.originalUrl) _req.url = req.originalUrl;
+            else {
+                const path = req.path;
+                _req.url = 'string' == typeof path ? path : req.url ? req.url.path || req.url : void 0;
+            }
+            if (req.query) _req.query = req.query;
+            if (req.params) _req.params = req.params;
+            _req.headers = req.headers;
+            _req.remoteAddress = connection && connection.remoteAddress;
+            _req.remotePort = connection && connection.remotePort;
+            _req.raw = req.raw || req;
+            return _req;
+        }
+        function mapHttpRequest(req) {
+            return {
+                req: reqSerializer(req)
+            };
+        }
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/res.js": function(module1) {
+        "use strict";
+        module1.exports = {
+            mapHttpResponse,
+            resSerializer
+        };
+        const rawSymbol = Symbol('pino-raw-res-ref');
+        const pinoResProto = Object.create({}, {
+            statusCode: {
+                enumerable: true,
+                writable: true,
+                value: 0
+            },
+            headers: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            raw: {
+                enumerable: false,
+                get: function() {
+                    return this[rawSymbol];
+                },
+                set: function(val) {
+                    this[rawSymbol] = val;
+                }
+            }
+        });
+        Object.defineProperty(pinoResProto, rawSymbol, {
+            writable: true,
+            value: {}
+        });
+        function resSerializer(res) {
+            const _res = Object.create(pinoResProto);
+            _res.statusCode = res.headersSent ? res.statusCode : null;
+            _res.headers = res.getHeaders ? res.getHeaders() : res._headers;
+            _res.raw = res;
+            return _res;
+        }
+        function mapHttpResponse(res) {
+            return {
+                res: resSerializer(res)
+            };
+        }
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/caller.js": function(module1) {
+        "use strict";
+        function noOpPrepareStackTrace(_, stack) {
+            return stack;
+        }
+        module1.exports = function() {
+            const originalPrepare = Error.prepareStackTrace;
+            Error.prepareStackTrace = noOpPrepareStackTrace;
+            const stack = new Error().stack;
+            Error.prepareStackTrace = originalPrepare;
+            if (!Array.isArray(stack)) return;
+            const entries = stack.slice(2);
+            const fileNames = [];
+            for (const entry of entries)if (entry) fileNames.push(entry.getFileName());
+            return fileNames;
+        };
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/constants.js": function(module1) {
+        const DEFAULT_LEVELS = {
+            trace: 10,
+            debug: 20,
+            info: 30,
+            warn: 40,
+            error: 50,
+            fatal: 60
+        };
+        const SORTING_ORDER = {
+            ASC: 'ASC',
+            DESC: 'DESC'
+        };
+        module1.exports = {
+            DEFAULT_LEVELS,
+            SORTING_ORDER
+        };
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/levels.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { lsCacheSym, levelValSym, useOnlyCustomLevelsSym, streamSym, formattersSym, hooksSym, levelCompSym } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/symbols.js");
+        const { noop, genLog } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/tools.js");
+        const { DEFAULT_LEVELS, SORTING_ORDER } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/constants.js");
+        const levelMethods = {
+            fatal: (hook)=>{
+                const logFatal = genLog(DEFAULT_LEVELS.fatal, hook);
+                return function(...args) {
+                    const stream = this[streamSym];
+                    logFatal.call(this, ...args);
+                    if ('function' == typeof stream.flushSync) try {
+                        stream.flushSync();
+                    } catch (e) {}
+                };
+            },
+            error: (hook)=>genLog(DEFAULT_LEVELS.error, hook),
+            warn: (hook)=>genLog(DEFAULT_LEVELS.warn, hook),
+            info: (hook)=>genLog(DEFAULT_LEVELS.info, hook),
+            debug: (hook)=>genLog(DEFAULT_LEVELS.debug, hook),
+            trace: (hook)=>genLog(DEFAULT_LEVELS.trace, hook)
+        };
+        const nums = Object.keys(DEFAULT_LEVELS).reduce((o, k)=>{
+            o[DEFAULT_LEVELS[k]] = k;
+            return o;
+        }, {});
+        const initialLsCache = Object.keys(nums).reduce((o, k)=>{
+            o[k] = '{"level":' + Number(k);
+            return o;
+        }, {});
+        function genLsCache(instance) {
+            const formatter = instance[formattersSym].level;
+            const { labels } = instance.levels;
+            const cache = {};
+            for(const label in labels){
+                const level = formatter(labels[label], Number(label));
+                cache[label] = JSON.stringify(level).slice(0, -1);
+            }
+            instance[lsCacheSym] = cache;
+            return instance;
+        }
+        function isStandardLevel(level, useOnlyCustomLevels) {
+            if (useOnlyCustomLevels) return false;
+            switch(level){
+                case 'fatal':
+                case 'error':
+                case 'warn':
+                case 'info':
+                case 'debug':
+                case 'trace':
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        function setLevel(level) {
+            const { labels, values } = this.levels;
+            if ('number' == typeof level) {
+                if (void 0 === labels[level]) throw Error('unknown level value' + level);
+                level = labels[level];
+            }
+            if (void 0 === values[level]) throw Error('unknown level ' + level);
+            const preLevelVal = this[levelValSym];
+            const levelVal = this[levelValSym] = values[level];
+            const useOnlyCustomLevelsVal = this[useOnlyCustomLevelsSym];
+            const levelComparison = this[levelCompSym];
+            const hook = this[hooksSym].logMethod;
+            for(const key in values){
+                if (false === levelComparison(values[key], levelVal)) {
+                    this[key] = noop;
+                    continue;
+                }
+                this[key] = isStandardLevel(key, useOnlyCustomLevelsVal) ? levelMethods[key](hook) : genLog(values[key], hook);
+            }
+            this.emit('level-change', level, levelVal, labels[preLevelVal], preLevelVal, this);
+        }
+        function getLevel(level) {
+            const { levels, levelVal } = this;
+            return levels && levels.labels ? levels.labels[levelVal] : '';
+        }
+        function isLevelEnabled(logLevel) {
+            const { values } = this.levels;
+            const logLevelVal = values[logLevel];
+            return void 0 !== logLevelVal && this[levelCompSym](logLevelVal, this[levelValSym]);
+        }
+        function compareLevel(direction, current, expected) {
+            if (direction === SORTING_ORDER.DESC) return current <= expected;
+            return current >= expected;
+        }
+        function genLevelComparison(levelComparison) {
+            if ('string' == typeof levelComparison) return compareLevel.bind(null, levelComparison);
+            return levelComparison;
+        }
+        function mappings(customLevels = null, useOnlyCustomLevels = false) {
+            const customNums = customLevels ? Object.keys(customLevels).reduce((o, k)=>{
+                o[customLevels[k]] = k;
+                return o;
+            }, {}) : null;
+            const labels = Object.assign(Object.create(Object.prototype, {
+                Infinity: {
+                    value: 'silent'
+                }
+            }), useOnlyCustomLevels ? null : nums, customNums);
+            const values = Object.assign(Object.create(Object.prototype, {
+                silent: {
+                    value: 1 / 0
+                }
+            }), useOnlyCustomLevels ? null : DEFAULT_LEVELS, customLevels);
+            return {
+                labels,
+                values
+            };
+        }
+        function assertDefaultLevelFound(defaultLevel, customLevels, useOnlyCustomLevels) {
+            if ('number' == typeof defaultLevel) {
+                const values = [].concat(Object.keys(customLevels || {}).map((key)=>customLevels[key]), useOnlyCustomLevels ? [] : Object.keys(nums).map((level)=>+level), 1 / 0);
+                if (!values.includes(defaultLevel)) throw Error(`default level:${defaultLevel} must be included in custom levels`);
+                return;
+            }
+            const labels = Object.assign(Object.create(Object.prototype, {
+                silent: {
+                    value: 1 / 0
+                }
+            }), useOnlyCustomLevels ? null : DEFAULT_LEVELS, customLevels);
+            if (!(defaultLevel in labels)) throw Error(`default level:${defaultLevel} must be included in custom levels`);
+        }
+        function assertNoLevelCollisions(levels, customLevels) {
+            const { labels, values } = levels;
+            for(const k in customLevels){
+                if (k in values) throw Error('levels cannot be overridden');
+                if (customLevels[k] in labels) throw Error('pre-existing level values cannot be used for new levels');
+            }
+        }
+        function assertLevelComparison(levelComparison) {
+            if ('function' == typeof levelComparison) return;
+            if ('string' == typeof levelComparison && Object.values(SORTING_ORDER).includes(levelComparison)) return;
+            throw new Error('Levels comparison should be one of "ASC", "DESC" or "function" type');
+        }
+        module1.exports = {
+            initialLsCache,
+            genLsCache,
+            levelMethods,
+            getLevel,
+            setLevel,
+            isLevelEnabled,
+            mappings,
+            assertNoLevelCollisions,
+            assertDefaultLevelFound,
+            genLevelComparison,
+            assertLevelComparison
+        };
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/meta.js": function(module1) {
+        "use strict";
+        module1.exports = {
+            version: '9.7.0'
+        };
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/multistream.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const metadata = Symbol.for('pino.metadata');
+        const { DEFAULT_LEVELS } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/constants.js");
+        const DEFAULT_INFO_LEVEL = DEFAULT_LEVELS.info;
+        function multistream(streamsArray, opts) {
+            let counter = 0;
+            streamsArray = streamsArray || [];
+            opts = opts || {
+                dedupe: false
+            };
+            const streamLevels = Object.create(DEFAULT_LEVELS);
+            streamLevels.silent = 1 / 0;
+            if (opts.levels && 'object' == typeof opts.levels) Object.keys(opts.levels).forEach((i)=>{
+                streamLevels[i] = opts.levels[i];
+            });
+            const res = {
+                write,
+                add,
+                emit,
+                flushSync,
+                end,
+                minLevel: 0,
+                streams: [],
+                clone,
+                [metadata]: true,
+                streamLevels
+            };
+            if (Array.isArray(streamsArray)) streamsArray.forEach(add, res);
+            else add.call(res, streamsArray);
+            streamsArray = null;
+            return res;
+            function write(data) {
+                let dest;
+                const level = this.lastLevel;
+                const { streams } = this;
+                let recordedLevel = 0;
+                let stream;
+                for(let i = initLoopVar(streams.length, opts.dedupe); checkLoopVar(i, streams.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)){
+                    dest = streams[i];
+                    if (dest.level <= level) {
+                        if (0 !== recordedLevel && recordedLevel !== dest.level) break;
+                        stream = dest.stream;
+                        if (stream[metadata]) {
+                            const { lastTime, lastMsg, lastObj, lastLogger } = this;
+                            stream.lastLevel = level;
+                            stream.lastTime = lastTime;
+                            stream.lastMsg = lastMsg;
+                            stream.lastObj = lastObj;
+                            stream.lastLogger = lastLogger;
+                        }
+                        stream.write(data);
+                        if (opts.dedupe) recordedLevel = dest.level;
+                    } else if (!opts.dedupe) break;
+                }
+            }
+            function emit(...args) {
+                for (const { stream } of this.streams)if ('function' == typeof stream.emit) stream.emit(...args);
+            }
+            function flushSync() {
+                for (const { stream } of this.streams)if ('function' == typeof stream.flushSync) stream.flushSync();
+            }
+            function add(dest) {
+                if (!dest) return res;
+                const isStream = 'function' == typeof dest.write || dest.stream;
+                const stream_ = dest.write ? dest : dest.stream;
+                if (!isStream) throw Error('stream object needs to implement either StreamEntry or DestinationStream interface');
+                const { streams, streamLevels } = this;
+                let level;
+                level = 'number' == typeof dest.levelVal ? dest.levelVal : 'string' == typeof dest.level ? streamLevels[dest.level] : 'number' == typeof dest.level ? dest.level : DEFAULT_INFO_LEVEL;
+                const dest_ = {
+                    stream: stream_,
+                    level,
+                    levelVal: void 0,
+                    id: counter++
+                };
+                streams.unshift(dest_);
+                streams.sort(compareByLevel);
+                this.minLevel = streams[0].level;
+                return res;
+            }
+            function end() {
+                for (const { stream } of this.streams){
+                    if ('function' == typeof stream.flushSync) stream.flushSync();
+                    stream.end();
+                }
+            }
+            function clone(level) {
+                const streams = new Array(this.streams.length);
+                for(let i = 0; i < streams.length; i++)streams[i] = {
+                    level,
+                    stream: this.streams[i].stream
+                };
+                return {
+                    write,
+                    add,
+                    minLevel: level,
+                    streams,
+                    clone,
+                    emit,
+                    flushSync,
+                    [metadata]: true
+                };
+            }
+        }
+        function compareByLevel(a, b) {
+            return a.level - b.level;
+        }
+        function initLoopVar(length, dedupe) {
+            return dedupe ? length - 1 : 0;
+        }
+        function adjustLoopVar(i, dedupe) {
+            return dedupe ? i - 1 : i + 1;
+        }
+        function checkLoopVar(i, length, dedupe) {
+            return dedupe ? i >= 0 : i < length;
+        }
+        module1.exports = multistream;
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/proto.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { EventEmitter } = __webpack_require__("node:events");
+        const { lsCacheSym, levelValSym, setLevelSym, getLevelSym, chindingsSym, parsedChindingsSym, mixinSym, asJsonSym, writeSym, mixinMergeStrategySym, timeSym, timeSliceIndexSym, streamSym, serializersSym, formattersSym, errorKeySym, messageKeySym, useOnlyCustomLevelsSym, needsMetadataGsym, redactFmtSym, stringifySym, formatOptsSym, stringifiersSym, msgPrefixSym, hooksSym } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/symbols.js");
+        const { getLevel, setLevel, isLevelEnabled, mappings, initialLsCache, genLsCache, assertNoLevelCollisions } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/levels.js");
+        const { asChindings, asJson, buildFormatters, stringify } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/tools.js");
+        const { version } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/meta.js");
+        const redaction = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/redaction.js");
+        const constructor = class {
+        };
+        const prototype = {
+            constructor,
+            child,
+            bindings,
+            setBindings,
+            flush,
+            isLevelEnabled,
+            version,
+            get level () {
+                return this[getLevelSym]();
+            },
+            set level (lvl){
+                this[setLevelSym](lvl);
+            },
+            get levelVal () {
+                return this[levelValSym];
+            },
+            set levelVal (n){
+                throw Error('levelVal is read-only');
+            },
+            [lsCacheSym]: initialLsCache,
+            [writeSym]: write,
+            [asJsonSym]: asJson,
+            [getLevelSym]: getLevel,
+            [setLevelSym]: setLevel
+        };
+        Object.setPrototypeOf(prototype, EventEmitter.prototype);
+        module1.exports = function() {
+            return Object.create(prototype);
+        };
+        const resetChildingsFormatter = (bindings)=>bindings;
+        function child(bindings, options) {
+            if (!bindings) throw Error('missing bindings for child Pino');
+            options = options || {};
+            const serializers = this[serializersSym];
+            const formatters = this[formattersSym];
+            const instance = Object.create(this);
+            if (true === options.hasOwnProperty('serializers')) {
+                instance[serializersSym] = Object.create(null);
+                for(const k in serializers)instance[serializersSym][k] = serializers[k];
+                const parentSymbols = Object.getOwnPropertySymbols(serializers);
+                for(var i = 0; i < parentSymbols.length; i++){
+                    const ks = parentSymbols[i];
+                    instance[serializersSym][ks] = serializers[ks];
+                }
+                for(const bk in options.serializers)instance[serializersSym][bk] = options.serializers[bk];
+                const bindingsSymbols = Object.getOwnPropertySymbols(options.serializers);
+                for(var bi = 0; bi < bindingsSymbols.length; bi++){
+                    const bks = bindingsSymbols[bi];
+                    instance[serializersSym][bks] = options.serializers[bks];
+                }
+            } else instance[serializersSym] = serializers;
+            if (options.hasOwnProperty('formatters')) {
+                const { level, bindings: chindings, log } = options.formatters;
+                instance[formattersSym] = buildFormatters(level || formatters.level, chindings || resetChildingsFormatter, log || formatters.log);
+            } else instance[formattersSym] = buildFormatters(formatters.level, resetChildingsFormatter, formatters.log);
+            if (true === options.hasOwnProperty('customLevels')) {
+                assertNoLevelCollisions(this.levels, options.customLevels);
+                instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym]);
+                genLsCache(instance);
+            }
+            if ('object' == typeof options.redact && null !== options.redact || Array.isArray(options.redact)) {
+                instance.redact = options.redact;
+                const stringifiers = redaction(instance.redact, stringify);
+                const formatOpts = {
+                    stringify: stringifiers[redactFmtSym]
+                };
+                instance[stringifySym] = stringify;
+                instance[stringifiersSym] = stringifiers;
+                instance[formatOptsSym] = formatOpts;
+            }
+            if ('string' == typeof options.msgPrefix) instance[msgPrefixSym] = (this[msgPrefixSym] || '') + options.msgPrefix;
+            instance[chindingsSym] = asChindings(instance, bindings);
+            const childLevel = options.level || this.level;
+            instance[setLevelSym](childLevel);
+            this.onChild(instance);
+            return instance;
+        }
+        function bindings() {
+            const chindings = this[chindingsSym];
+            const chindingsJson = `{${chindings.substr(1)}}`;
+            const bindingsFromJson = JSON.parse(chindingsJson);
+            delete bindingsFromJson.pid;
+            delete bindingsFromJson.hostname;
+            return bindingsFromJson;
+        }
+        function setBindings(newBindings) {
+            const chindings = asChindings(this, newBindings);
+            this[chindingsSym] = chindings;
+            delete this[parsedChindingsSym];
+        }
+        function defaultMixinMergeStrategy(mergeObject, mixinObject) {
+            return Object.assign(mixinObject, mergeObject);
+        }
+        function write(_obj, msg, num) {
+            const t = this[timeSym]();
+            const mixin = this[mixinSym];
+            const errorKey = this[errorKeySym];
+            const messageKey = this[messageKeySym];
+            const mixinMergeStrategy = this[mixinMergeStrategySym] || defaultMixinMergeStrategy;
+            let obj;
+            const streamWriteHook = this[hooksSym].streamWrite;
+            if (null == _obj) obj = {};
+            else if (_obj instanceof Error) {
+                obj = {
+                    [errorKey]: _obj
+                };
+                if (void 0 === msg) msg = _obj.message;
+            } else {
+                obj = _obj;
+                if (void 0 === msg && void 0 === _obj[messageKey] && _obj[errorKey]) msg = _obj[errorKey].message;
+            }
+            if (mixin) obj = mixinMergeStrategy(obj, mixin(obj, num, this));
+            const s = this[asJsonSym](obj, msg, num, t);
+            const stream = this[streamSym];
+            if (true === stream[needsMetadataGsym]) {
+                stream.lastLevel = num;
+                stream.lastObj = obj;
+                stream.lastMsg = msg;
+                stream.lastTime = t.slice(this[timeSliceIndexSym]);
+                stream.lastLogger = this;
+            }
+            stream.write(streamWriteHook ? streamWriteHook(s) : s);
+        }
+        function noop() {}
+        function flush(cb) {
+            if (null != cb && 'function' != typeof cb) throw Error('callback must be a function');
+            const stream = this[streamSym];
+            if ('function' == typeof stream.flush) stream.flush(cb || noop);
+            else if (cb) cb();
+        }
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/redaction.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const fastRedact = __webpack_require__("../../node_modules/.pnpm/fast-redact@3.5.0/node_modules/fast-redact/index.js");
+        const { redactFmtSym, wildcardFirstSym } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/symbols.js");
+        const { rx, validator } = fastRedact;
+        const validate = validator({
+            ERR_PATHS_MUST_BE_STRINGS: ()=>'pino – redacted paths must be strings',
+            ERR_INVALID_PATH: (s)=>`pino – redact paths array contains an invalid path (${s})`
+        });
+        const CENSOR = '[Redacted]';
+        const strict = false;
+        function redaction(opts, serialize) {
+            const { paths, censor } = handle(opts);
+            const shape = paths.reduce((o, str)=>{
+                rx.lastIndex = 0;
+                const first = rx.exec(str);
+                const next = rx.exec(str);
+                let ns = void 0 !== first[1] ? first[1].replace(/^(?:"|'|`)(.*)(?:"|'|`)$/, '$1') : first[0];
+                if ('*' === ns) ns = wildcardFirstSym;
+                if (null === next) {
+                    o[ns] = null;
+                    return o;
+                }
+                if (null === o[ns]) return o;
+                const { index } = next;
+                const nextPath = `${str.substr(index, str.length - 1)}`;
+                o[ns] = o[ns] || [];
+                if (ns !== wildcardFirstSym && 0 === o[ns].length) o[ns].push(...o[wildcardFirstSym] || []);
+                if (ns === wildcardFirstSym) Object.keys(o).forEach(function(k) {
+                    if (o[k]) o[k].push(nextPath);
+                });
+                o[ns].push(nextPath);
+                return o;
+            }, {});
+            const result = {
+                [redactFmtSym]: fastRedact({
+                    paths,
+                    censor,
+                    serialize,
+                    strict
+                })
+            };
+            const topCensor = (...args)=>'function' == typeof censor ? serialize(censor(...args)) : serialize(censor);
+            return [
+                ...Object.keys(shape),
+                ...Object.getOwnPropertySymbols(shape)
+            ].reduce((o, k)=>{
+                if (null === shape[k]) o[k] = (value)=>topCensor(value, [
+                        k
+                    ]);
+                else {
+                    const wrappedCensor = 'function' == typeof censor ? (value, path)=>censor(value, [
+                            k,
+                            ...path
+                        ]) : censor;
+                    o[k] = fastRedact({
+                        paths: shape[k],
+                        censor: wrappedCensor,
+                        serialize,
+                        strict
+                    });
+                }
+                return o;
+            }, result);
+        }
+        function handle(opts) {
+            if (Array.isArray(opts)) {
+                opts = {
+                    paths: opts,
+                    censor: CENSOR
+                };
+                validate(opts);
+                return opts;
+            }
+            let { paths, censor = CENSOR, remove } = opts;
+            if (false === Array.isArray(paths)) throw Error('pino – redact must contain an array of strings');
+            if (true === remove) censor = void 0;
+            validate({
+                paths,
+                censor
+            });
+            return {
+                paths,
+                censor
+            };
+        }
+        module1.exports = redaction;
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/symbols.js": function(module1) {
+        "use strict";
+        const setLevelSym = Symbol('pino.setLevel');
+        const getLevelSym = Symbol('pino.getLevel');
+        const levelValSym = Symbol('pino.levelVal');
+        const levelCompSym = Symbol('pino.levelComp');
+        const useLevelLabelsSym = Symbol('pino.useLevelLabels');
+        const useOnlyCustomLevelsSym = Symbol('pino.useOnlyCustomLevels');
+        const mixinSym = Symbol('pino.mixin');
+        const lsCacheSym = Symbol('pino.lsCache');
+        const chindingsSym = Symbol('pino.chindings');
+        const asJsonSym = Symbol('pino.asJson');
+        const writeSym = Symbol('pino.write');
+        const redactFmtSym = Symbol('pino.redactFmt');
+        const timeSym = Symbol('pino.time');
+        const timeSliceIndexSym = Symbol('pino.timeSliceIndex');
+        const streamSym = Symbol('pino.stream');
+        const stringifySym = Symbol('pino.stringify');
+        const stringifySafeSym = Symbol('pino.stringifySafe');
+        const stringifiersSym = Symbol('pino.stringifiers');
+        const endSym = Symbol('pino.end');
+        const formatOptsSym = Symbol('pino.formatOpts');
+        const messageKeySym = Symbol('pino.messageKey');
+        const errorKeySym = Symbol('pino.errorKey');
+        const nestedKeySym = Symbol('pino.nestedKey');
+        const nestedKeyStrSym = Symbol('pino.nestedKeyStr');
+        const mixinMergeStrategySym = Symbol('pino.mixinMergeStrategy');
+        const msgPrefixSym = Symbol('pino.msgPrefix');
+        const wildcardFirstSym = Symbol('pino.wildcardFirst');
+        const serializersSym = Symbol.for('pino.serializers');
+        const formattersSym = Symbol.for('pino.formatters');
+        const hooksSym = Symbol.for('pino.hooks');
+        const needsMetadataGsym = Symbol.for('pino.metadata');
+        module1.exports = {
+            setLevelSym,
+            getLevelSym,
+            levelValSym,
+            levelCompSym,
+            useLevelLabelsSym,
+            mixinSym,
+            lsCacheSym,
+            chindingsSym,
+            asJsonSym,
+            writeSym,
+            serializersSym,
+            redactFmtSym,
+            timeSym,
+            timeSliceIndexSym,
+            streamSym,
+            stringifySym,
+            stringifySafeSym,
+            stringifiersSym,
+            endSym,
+            formatOptsSym,
+            messageKeySym,
+            errorKeySym,
+            nestedKeySym,
+            wildcardFirstSym,
+            needsMetadataGsym,
+            useOnlyCustomLevelsSym,
+            formattersSym,
+            hooksSym,
+            nestedKeyStrSym,
+            mixinMergeStrategySym,
+            msgPrefixSym
+        };
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/time.js": function(module1) {
+        "use strict";
+        const nullTime = ()=>'';
+        const epochTime = ()=>`,"time":${Date.now()}`;
+        const unixTime = ()=>`,"time":${Math.round(Date.now() / 1000.0)}`;
+        const isoTime = ()=>`,"time":"${new Date(Date.now()).toISOString()}"`;
+        module1.exports = {
+            nullTime,
+            epochTime,
+            unixTime,
+            isoTime
+        };
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/tools.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const format = __webpack_require__("../../node_modules/.pnpm/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js");
+        const { mapHttpRequest, mapHttpResponse } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/index.js");
+        const SonicBoom = __webpack_require__("../../node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js");
+        const onExit = __webpack_require__("../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js");
+        const { lsCacheSym, chindingsSym, writeSym, serializersSym, formatOptsSym, endSym, stringifiersSym, stringifySym, stringifySafeSym, wildcardFirstSym, nestedKeySym, formattersSym, messageKeySym, errorKeySym, nestedKeyStrSym, msgPrefixSym } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/symbols.js");
+        const { isMainThread } = __webpack_require__("worker_threads");
+        const transport = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/transport.js");
+        function noop() {}
+        function genLog(level, hook) {
+            if (!hook) return LOG;
+            return function(...args) {
+                hook.call(this, args, LOG, level);
+            };
+            function LOG(o, ...n1) {
+                if ('object' == typeof o) {
+                    let msg = o;
+                    if (null !== o) {
+                        if (o.method && o.headers && o.socket) o = mapHttpRequest(o);
+                        else if ('function' == typeof o.setHeader) o = mapHttpResponse(o);
+                    }
+                    let formatParams;
+                    if (null === msg && 0 === n1.length) formatParams = [
+                        null
+                    ];
+                    else {
+                        msg = n1.shift();
+                        formatParams = n1;
+                    }
+                    if ('string' == typeof this[msgPrefixSym] && null != msg) msg = this[msgPrefixSym] + msg;
+                    this[writeSym](o, format(msg, formatParams, this[formatOptsSym]), level);
+                } else {
+                    let msg = void 0 === o ? n1.shift() : o;
+                    if ('string' == typeof this[msgPrefixSym] && null != msg) msg = this[msgPrefixSym] + msg;
+                    this[writeSym](null, format(msg, n1, this[formatOptsSym]), level);
+                }
+            }
+        }
+        function asString(str) {
+            let result = '';
+            let last = 0;
+            let found = false;
+            let point = 255;
+            const l = str.length;
+            if (l > 100) return JSON.stringify(str);
+            for(var i = 0; i < l && point >= 32; i++){
+                point = str.charCodeAt(i);
+                if (34 === point || 92 === point) {
+                    result += str.slice(last, i) + '\\';
+                    last = i;
+                    found = true;
+                }
+            }
+            if (found) result += str.slice(last);
+            else result = str;
+            return point < 32 ? JSON.stringify(str) : '"' + result + '"';
+        }
+        function asJson(obj, msg, num, time) {
+            const stringify = this[stringifySym];
+            const stringifySafe = this[stringifySafeSym];
+            const stringifiers = this[stringifiersSym];
+            const end = this[endSym];
+            const chindings = this[chindingsSym];
+            const serializers = this[serializersSym];
+            const formatters = this[formattersSym];
+            const messageKey = this[messageKeySym];
+            const errorKey = this[errorKeySym];
+            let data = this[lsCacheSym][num] + time;
+            data += chindings;
+            let value;
+            if (formatters.log) obj = formatters.log(obj);
+            const wildcardStringifier = stringifiers[wildcardFirstSym];
+            let propStr = '';
+            for(const key in obj){
+                value = obj[key];
+                if (Object.prototype.hasOwnProperty.call(obj, key) && void 0 !== value) {
+                    if (serializers[key]) value = serializers[key](value);
+                    else if (key === errorKey && serializers.err) value = serializers.err(value);
+                    const stringifier = stringifiers[key] || wildcardStringifier;
+                    switch(typeof value){
+                        case 'undefined':
+                        case 'function':
+                            continue;
+                        case 'number':
+                            if (false === Number.isFinite(value)) value = null;
+                        case 'boolean':
+                            if (stringifier) value = stringifier(value);
+                            break;
+                        case 'string':
+                            value = (stringifier || asString)(value);
+                            break;
+                        default:
+                            value = (stringifier || stringify)(value, stringifySafe);
+                    }
+                    if (void 0 === value) continue;
+                    const strKey = asString(key);
+                    propStr += ',' + strKey + ':' + value;
+                }
+            }
+            let msgStr = '';
+            if (void 0 !== msg) {
+                value = serializers[messageKey] ? serializers[messageKey](msg) : msg;
+                const stringifier = stringifiers[messageKey] || wildcardStringifier;
+                switch(typeof value){
+                    case 'function':
+                        break;
+                    case 'number':
+                        if (false === Number.isFinite(value)) value = null;
+                    case 'boolean':
+                        if (stringifier) value = stringifier(value);
+                        msgStr = ',"' + messageKey + '":' + value;
+                        break;
+                    case 'string':
+                        value = (stringifier || asString)(value);
+                        msgStr = ',"' + messageKey + '":' + value;
+                        break;
+                    default:
+                        value = (stringifier || stringify)(value, stringifySafe);
+                        msgStr = ',"' + messageKey + '":' + value;
+                }
+            }
+            if (this[nestedKeySym] && propStr) return data + this[nestedKeyStrSym] + propStr.slice(1) + '}' + msgStr + end;
+            return data + propStr + msgStr + end;
+        }
+        function asChindings(instance, bindings) {
+            let value;
+            let data = instance[chindingsSym];
+            const stringify = instance[stringifySym];
+            const stringifySafe = instance[stringifySafeSym];
+            const stringifiers = instance[stringifiersSym];
+            const wildcardStringifier = stringifiers[wildcardFirstSym];
+            const serializers = instance[serializersSym];
+            const formatter = instance[formattersSym].bindings;
+            bindings = formatter(bindings);
+            for(const key in bindings){
+                value = bindings[key];
+                const valid = 'level' !== key && 'serializers' !== key && 'formatters' !== key && 'customLevels' !== key && bindings.hasOwnProperty(key) && void 0 !== value;
+                if (true === valid) {
+                    value = serializers[key] ? serializers[key](value) : value;
+                    value = (stringifiers[key] || wildcardStringifier || stringify)(value, stringifySafe);
+                    if (void 0 === value) continue;
+                    data += ',"' + key + '":' + value;
+                }
+            }
+            return data;
+        }
+        function hasBeenTampered(stream) {
+            return stream.write !== stream.constructor.prototype.write;
+        }
+        function buildSafeSonicBoom(opts) {
+            const stream = new SonicBoom(opts);
+            stream.on('error', filterBrokenPipe);
+            if (!opts.sync && isMainThread) {
+                onExit.register(stream, autoEnd);
+                stream.on('close', function() {
+                    onExit.unregister(stream);
+                });
+            }
+            return stream;
+            function filterBrokenPipe(err) {
+                if ('EPIPE' === err.code) {
+                    stream.write = noop;
+                    stream.end = noop;
+                    stream.flushSync = noop;
+                    stream.destroy = noop;
+                    return;
+                }
+                stream.removeListener('error', filterBrokenPipe);
+                stream.emit('error', err);
+            }
+        }
+        function autoEnd(stream, eventName) {
+            if (stream.destroyed) return;
+            if ('beforeExit' === eventName) {
+                stream.flush();
+                stream.on('drain', function() {
+                    stream.end();
+                });
+            } else stream.flushSync();
+        }
+        function createArgsNormalizer(defaultOptions) {
+            return function(instance, caller, opts = {}, stream) {
+                if ('string' == typeof opts) {
+                    stream = buildSafeSonicBoom({
+                        dest: opts
+                    });
+                    opts = {};
+                } else if ('string' == typeof stream) {
+                    if (opts && opts.transport) throw Error('only one of option.transport or stream can be specified');
+                    stream = buildSafeSonicBoom({
+                        dest: stream
+                    });
+                } else if (opts instanceof SonicBoom || opts.writable || opts._writableState) {
+                    stream = opts;
+                    opts = {};
+                } else if (opts.transport) {
+                    if (opts.transport instanceof SonicBoom || opts.transport.writable || opts.transport._writableState) throw Error('option.transport do not allow stream, please pass to option directly. e.g. pino(transport)');
+                    if (opts.transport.targets && opts.transport.targets.length && opts.formatters && 'function' == typeof opts.formatters.level) throw Error('option.transport.targets do not allow custom level formatters');
+                    let customLevels;
+                    if (opts.customLevels) customLevels = opts.useOnlyCustomLevels ? opts.customLevels : Object.assign({}, opts.levels, opts.customLevels);
+                    stream = transport({
+                        caller,
+                        ...opts.transport,
+                        levels: customLevels
+                    });
+                }
+                opts = Object.assign({}, defaultOptions, opts);
+                opts.serializers = Object.assign({}, defaultOptions.serializers, opts.serializers);
+                opts.formatters = Object.assign({}, defaultOptions.formatters, opts.formatters);
+                if (opts.prettyPrint) throw new Error('prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)');
+                const { enabled, onChild } = opts;
+                if (false === enabled) opts.level = 'silent';
+                if (!onChild) opts.onChild = noop;
+                if (!stream) stream = hasBeenTampered(process.stdout) ? process.stdout : buildSafeSonicBoom({
+                    fd: process.stdout.fd || 1
+                });
+                return {
+                    opts,
+                    stream
+                };
+            };
+        }
+        function stringify(obj, stringifySafeFn) {
+            try {
+                return JSON.stringify(obj);
+            } catch (_) {
+                try {
+                    const stringify = stringifySafeFn || this[stringifySafeSym];
+                    return stringify(obj);
+                } catch (_) {
+                    return '"[unable to serialize, circular reference is too complex to analyze]"';
+                }
+            }
+        }
+        function buildFormatters(level, bindings, log) {
+            return {
+                level,
+                bindings,
+                log
+            };
+        }
+        function normalizeDestFileDescriptor(destination) {
+            const fd = Number(destination);
+            if ('string' == typeof destination && Number.isFinite(fd)) return fd;
+            if (void 0 === destination) return 1;
+            return destination;
+        }
+        module1.exports = {
+            noop,
+            buildSafeSonicBoom,
+            asChindings,
+            asJson,
+            genLog,
+            createArgsNormalizer,
+            stringify,
+            buildFormatters,
+            normalizeDestFileDescriptor
+        };
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/transport-stream.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { realImport, realRequire } = __webpack_require__("../../node_modules/.pnpm/real-require@0.2.0/node_modules/real-require/src/index.js");
+        module1.exports = loadTransportStreamBuilder;
+        async function loadTransportStreamBuilder(target) {
+            let fn;
+            try {
+                const toLoad = target.startsWith('file://') ? target : 'file://' + target;
+                if (toLoad.endsWith('.ts') || toLoad.endsWith('.cts')) {
+                    if (process[Symbol.for('ts-node.register.instance')]) realRequire('ts-node/register');
+                    else if (process.env && process.env.TS_NODE_DEV) realRequire('ts-node-dev');
+                    fn = realRequire(decodeURIComponent(target));
+                } else fn = await realImport(toLoad);
+            } catch (error) {
+                if ('ENOTDIR' === error.code || 'ERR_MODULE_NOT_FOUND' === error.code) fn = realRequire(target);
+                else if (void 0 === error.code || 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING' === error.code) try {
+                    fn = realRequire(decodeURIComponent(target));
+                } catch  {
+                    throw error;
+                }
+                else throw error;
+            }
+            if ('object' == typeof fn) fn = fn.default;
+            if ('object' == typeof fn) fn = fn.default;
+            if ('function' != typeof fn) throw Error('exported worker is not a function');
+            return fn;
+        }
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/transport.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { createRequire } = __webpack_require__("module");
+        const getCallers = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/caller.js");
+        const { join, isAbsolute, sep } = __webpack_require__("node:path");
+        const sleep = __webpack_require__("../../node_modules/.pnpm/atomic-sleep@1.0.0/node_modules/atomic-sleep/index.js");
+        const onExit = __webpack_require__("../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js");
+        const ThreadStream = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/index.js");
+        function setupOnExit(stream) {
+            onExit.register(stream, autoEnd);
+            onExit.registerBeforeExit(stream, flush);
+            stream.on('close', function() {
+                onExit.unregister(stream);
+            });
+        }
+        function buildStream(filename, workerData, workerOpts, sync) {
+            const stream = new ThreadStream({
+                filename,
+                workerData,
+                workerOpts,
+                sync
+            });
+            stream.on('ready', onReady);
+            stream.on('close', function() {
+                process.removeListener('exit', onExit);
+            });
+            process.on('exit', onExit);
+            function onReady() {
+                process.removeListener('exit', onExit);
+                stream.unref();
+                if (false !== workerOpts.autoEnd) setupOnExit(stream);
+            }
+            function onExit() {
+                if (stream.closed) return;
+                stream.flushSync();
+                sleep(100);
+                stream.end();
+            }
+            return stream;
+        }
+        function autoEnd(stream) {
+            stream.ref();
+            stream.flushSync();
+            stream.end();
+            stream.once('close', function() {
+                stream.unref();
+            });
+        }
+        function flush(stream) {
+            stream.flushSync();
+        }
+        function transport(fullOptions) {
+            const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions;
+            const options = {
+                ...fullOptions.options
+            };
+            const callers = 'string' == typeof caller ? [
+                caller
+            ] : caller;
+            const bundlerOverrides = '__bundlerPathsOverrides' in globalThis ? globalThis.__bundlerPathsOverrides : {};
+            let target = fullOptions.target;
+            if (target && targets) throw new Error('only one of target or targets can be specified');
+            if (targets) {
+                target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js');
+                options.targets = targets.filter((dest)=>dest.target).map((dest)=>({
+                        ...dest,
+                        target: fixTarget(dest.target)
+                    }));
+                options.pipelines = targets.filter((dest)=>dest.pipeline).map((dest)=>dest.pipeline.map((t)=>({
+                            ...t,
+                            level: dest.level,
+                            target: fixTarget(t.target)
+                        })));
+            } else if (pipeline) {
+                target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js');
+                options.pipelines = [
+                    pipeline.map((dest)=>({
+                            ...dest,
+                            target: fixTarget(dest.target)
+                        }))
+                ];
+            }
+            if (levels) options.levels = levels;
+            if (dedupe) options.dedupe = dedupe;
+            options.pinoWillSendConfig = true;
+            return buildStream(fixTarget(target), options, worker, sync);
+            function fixTarget(origin) {
+                origin = bundlerOverrides[origin] || origin;
+                if (isAbsolute(origin) || 0 === origin.indexOf('file://')) return origin;
+                if ('pino/file' === origin) return join(__dirname, '..', 'file.js');
+                let fixTarget;
+                for (const filePath of callers)try {
+                    const context = 'node:repl' === filePath ? process.cwd() + sep : filePath;
+                    fixTarget = createRequire(context).resolve(origin);
+                    break;
+                } catch (err) {
+                    continue;
+                }
+                if (!fixTarget) throw new Error(`unable to determine transport target for "${origin}"`);
+                return fixTarget;
+            }
+        }
+        module1.exports = transport;
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/pino.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const os = __webpack_require__("node:os");
+        const stdSerializers = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/index.js");
+        const caller = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/caller.js");
+        const redaction = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/redaction.js");
+        const time = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/time.js");
+        const proto = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/proto.js");
+        const symbols = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/symbols.js");
+        const { configure } = __webpack_require__("../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js");
+        const { assertDefaultLevelFound, mappings, genLsCache, genLevelComparison, assertLevelComparison } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/levels.js");
+        const { DEFAULT_LEVELS, SORTING_ORDER } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/constants.js");
+        const { createArgsNormalizer, asChindings, buildSafeSonicBoom, buildFormatters, stringify, normalizeDestFileDescriptor, noop } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/tools.js");
+        const { version } = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/meta.js");
+        const { chindingsSym, redactFmtSym, serializersSym, timeSym, timeSliceIndexSym, streamSym, stringifySym, stringifySafeSym, stringifiersSym, setLevelSym, endSym, formatOptsSym, messageKeySym, errorKeySym, nestedKeySym, mixinSym, levelCompSym, useOnlyCustomLevelsSym, formattersSym, hooksSym, nestedKeyStrSym, mixinMergeStrategySym, msgPrefixSym } = symbols;
+        const { epochTime, nullTime } = time;
+        const { pid } = process;
+        const hostname = os.hostname();
+        const defaultErrorSerializer = stdSerializers.err;
+        const defaultOptions = {
+            level: 'info',
+            levelComparison: SORTING_ORDER.ASC,
+            levels: DEFAULT_LEVELS,
+            messageKey: 'msg',
+            errorKey: 'err',
+            nestedKey: null,
+            enabled: true,
+            base: {
+                pid,
+                hostname
+            },
+            serializers: Object.assign(Object.create(null), {
+                err: defaultErrorSerializer
+            }),
+            formatters: Object.assign(Object.create(null), {
+                bindings (bindings) {
+                    return bindings;
+                },
+                level (label, number) {
+                    return {
+                        level: number
+                    };
+                }
+            }),
+            hooks: {
+                logMethod: void 0,
+                streamWrite: void 0
+            },
+            timestamp: epochTime,
+            name: void 0,
+            redact: null,
+            customLevels: null,
+            useOnlyCustomLevels: false,
+            depthLimit: 5,
+            edgeLimit: 100
+        };
+        const normalize = createArgsNormalizer(defaultOptions);
+        const serializers = Object.assign(Object.create(null), stdSerializers);
+        function pino(...args) {
+            const instance = {};
+            const { opts, stream } = normalize(instance, caller(), ...args);
+            if (opts.level && 'string' == typeof opts.level && void 0 !== DEFAULT_LEVELS[opts.level.toLowerCase()]) opts.level = opts.level.toLowerCase();
+            const { redact, crlf, serializers, timestamp, messageKey, errorKey, nestedKey, base, name, level, customLevels, levelComparison, mixin, mixinMergeStrategy, useOnlyCustomLevels, formatters, hooks, depthLimit, edgeLimit, onChild, msgPrefix } = opts;
+            const stringifySafe = configure({
+                maximumDepth: depthLimit,
+                maximumBreadth: edgeLimit
+            });
+            const allFormatters = buildFormatters(formatters.level, formatters.bindings, formatters.log);
+            const stringifyFn = stringify.bind({
+                [stringifySafeSym]: stringifySafe
+            });
+            const stringifiers = redact ? redaction(redact, stringifyFn) : {};
+            const formatOpts = redact ? {
+                stringify: stringifiers[redactFmtSym]
+            } : {
+                stringify: stringifyFn
+            };
+            const end = '}' + (crlf ? '\r\n' : '\n');
+            const coreChindings = asChindings.bind(null, {
+                [chindingsSym]: '',
+                [serializersSym]: serializers,
+                [stringifiersSym]: stringifiers,
+                [stringifySym]: stringify,
+                [stringifySafeSym]: stringifySafe,
+                [formattersSym]: allFormatters
+            });
+            let chindings = '';
+            if (null !== base) chindings = void 0 === name ? coreChindings(base) : coreChindings(Object.assign({}, base, {
+                name
+            }));
+            const time = timestamp instanceof Function ? timestamp : timestamp ? epochTime : nullTime;
+            const timeSliceIndex = time().indexOf(':') + 1;
+            if (useOnlyCustomLevels && !customLevels) throw Error('customLevels is required if useOnlyCustomLevels is set true');
+            if (mixin && 'function' != typeof mixin) throw Error(`Unknown mixin type "${typeof mixin}" - expected "function"`);
+            if (msgPrefix && 'string' != typeof msgPrefix) throw Error(`Unknown msgPrefix type "${typeof msgPrefix}" - expected "string"`);
+            assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels);
+            const levels = mappings(customLevels, useOnlyCustomLevels);
+            if ('function' == typeof stream.emit) stream.emit('message', {
+                code: 'PINO_CONFIG',
+                config: {
+                    levels,
+                    messageKey,
+                    errorKey
+                }
+            });
+            assertLevelComparison(levelComparison);
+            const levelCompFunc = genLevelComparison(levelComparison);
+            Object.assign(instance, {
+                levels,
+                [levelCompSym]: levelCompFunc,
+                [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
+                [streamSym]: stream,
+                [timeSym]: time,
+                [timeSliceIndexSym]: timeSliceIndex,
+                [stringifySym]: stringify,
+                [stringifySafeSym]: stringifySafe,
+                [stringifiersSym]: stringifiers,
+                [endSym]: end,
+                [formatOptsSym]: formatOpts,
+                [messageKeySym]: messageKey,
+                [errorKeySym]: errorKey,
+                [nestedKeySym]: nestedKey,
+                [nestedKeyStrSym]: nestedKey ? `,${JSON.stringify(nestedKey)}:{` : '',
+                [serializersSym]: serializers,
+                [mixinSym]: mixin,
+                [mixinMergeStrategySym]: mixinMergeStrategy,
+                [chindingsSym]: chindings,
+                [formattersSym]: allFormatters,
+                [hooksSym]: hooks,
+                silent: noop,
+                onChild,
+                [msgPrefixSym]: msgPrefix
+            });
+            Object.setPrototypeOf(instance, proto());
+            genLsCache(instance);
+            instance[setLevelSym](level);
+            return instance;
+        }
+        module1.exports = pino;
+        module1.exports.destination = (dest = process.stdout.fd)=>{
+            if ('object' != typeof dest) return buildSafeSonicBoom({
+                dest: normalizeDestFileDescriptor(dest),
+                minLength: 0
+            });
+            dest.dest = normalizeDestFileDescriptor(dest.dest || process.stdout.fd);
+            return buildSafeSonicBoom(dest);
+        };
+        module1.exports.transport = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/transport.js");
+        module1.exports.multistream = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/multistream.js");
+        module1.exports.levels = mappings();
+        module1.exports.stdSerializers = serializers;
+        module1.exports.stdTimeFunctions = Object.assign({}, time);
+        module1.exports.symbols = symbols;
+        module1.exports.version = version;
+        module1.exports["default"] = pino;
+        module1.exports.pino = pino;
+    },
+    "../../node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const fs = __webpack_require__("fs");
+        const EventEmitter = __webpack_require__("events");
+        const inherits = __webpack_require__("util").inherits;
+        const path = __webpack_require__("path");
+        const sleep = __webpack_require__("../../node_modules/.pnpm/atomic-sleep@1.0.0/node_modules/atomic-sleep/index.js");
+        const assert = __webpack_require__("assert");
+        const BUSY_WRITE_TIMEOUT = 100;
+        const kEmptyBuffer = Buffer.allocUnsafe(0);
+        const MAX_WRITE = 16384;
+        const kContentModeBuffer = 'buffer';
+        const kContentModeUtf8 = 'utf8';
+        const [major, minor] = (process.versions.node || '0.0').split('.').map(Number);
+        const kCopyBuffer = major >= 22 && minor >= 7;
+        function openFile(file, sonic) {
+            sonic._opening = true;
+            sonic._writing = true;
+            sonic._asyncDrainScheduled = false;
+            function fileOpened(err, fd) {
+                if (err) {
+                    sonic._reopening = false;
+                    sonic._writing = false;
+                    sonic._opening = false;
+                    if (sonic.sync) process.nextTick(()=>{
+                        if (sonic.listenerCount('error') > 0) sonic.emit('error', err);
+                    });
+                    else sonic.emit('error', err);
+                    return;
+                }
+                const reopening = sonic._reopening;
+                sonic.fd = fd;
+                sonic.file = file;
+                sonic._reopening = false;
+                sonic._opening = false;
+                sonic._writing = false;
+                if (sonic.sync) process.nextTick(()=>sonic.emit('ready'));
+                else sonic.emit('ready');
+                if (sonic.destroyed) return;
+                if (!sonic._writing && sonic._len > sonic.minLength || sonic._flushPending) sonic._actualWrite();
+                else if (reopening) process.nextTick(()=>sonic.emit('drain'));
+            }
+            const flags = sonic.append ? 'a' : 'w';
+            const mode = sonic.mode;
+            if (sonic.sync) try {
+                if (sonic.mkdir) fs.mkdirSync(path.dirname(file), {
+                    recursive: true
+                });
+                const fd = fs.openSync(file, flags, mode);
+                fileOpened(null, fd);
+            } catch (err) {
+                fileOpened(err);
+                throw err;
+            }
+            else if (sonic.mkdir) fs.mkdir(path.dirname(file), {
+                recursive: true
+            }, (err)=>{
+                if (err) return fileOpened(err);
+                fs.open(file, flags, mode, fileOpened);
+            });
+            else fs.open(file, flags, mode, fileOpened);
+        }
+        function SonicBoom(opts) {
+            if (!(this instanceof SonicBoom)) return new SonicBoom(opts);
+            let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+            fd = fd || dest;
+            this._len = 0;
+            this.fd = -1;
+            this._bufs = [];
+            this._lens = [];
+            this._writing = false;
+            this._ending = false;
+            this._reopening = false;
+            this._asyncDrainScheduled = false;
+            this._flushPending = false;
+            this._hwm = Math.max(minLength || 0, 16387);
+            this.file = null;
+            this.destroyed = false;
+            this.minLength = minLength || 0;
+            this.maxLength = maxLength || 0;
+            this.maxWrite = maxWrite || MAX_WRITE;
+            this._periodicFlush = periodicFlush || 0;
+            this._periodicFlushTimer = void 0;
+            this.sync = sync || false;
+            this.writable = true;
+            this._fsync = fsync || false;
+            this.append = append || false;
+            this.mode = mode;
+            this.retryEAGAIN = retryEAGAIN || (()=>true);
+            this.mkdir = mkdir || false;
+            let fsWriteSync;
+            let fsWrite;
+            if (contentMode === kContentModeBuffer) {
+                this._writingBuf = kEmptyBuffer;
+                this.write = writeBuffer;
+                this.flush = flushBuffer;
+                this.flushSync = flushBufferSync;
+                this._actualWrite = actualWriteBuffer;
+                fsWriteSync = ()=>fs.writeSync(this.fd, this._writingBuf);
+                fsWrite = ()=>fs.write(this.fd, this._writingBuf, this.release);
+            } else if (void 0 === contentMode || contentMode === kContentModeUtf8) {
+                this._writingBuf = '';
+                this.write = write;
+                this.flush = flush;
+                this.flushSync = flushSync;
+                this._actualWrite = actualWrite;
+                fsWriteSync = ()=>fs.writeSync(this.fd, this._writingBuf, 'utf8');
+                fsWrite = ()=>fs.write(this.fd, this._writingBuf, 'utf8', this.release);
+            } else throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
+            if ('number' == typeof fd) {
+                this.fd = fd;
+                process.nextTick(()=>this.emit('ready'));
+            } else if ('string' == typeof fd) openFile(fd, this);
+            else throw new Error("SonicBoom supports only file descriptors and files");
+            if (this.minLength >= this.maxWrite) throw new Error(`minLength should be smaller than maxWrite (${this.maxWrite})`);
+            this.release = (err, n1)=>{
+                if (err) {
+                    if (('EAGAIN' === err.code || 'EBUSY' === err.code) && this.retryEAGAIN(err, this._writingBuf.length, this._len - this._writingBuf.length)) if (this.sync) try {
+                        sleep(BUSY_WRITE_TIMEOUT);
+                        this.release(void 0, 0);
+                    } catch (err) {
+                        this.release(err);
+                    }
+                    else setTimeout(fsWrite, BUSY_WRITE_TIMEOUT);
+                    else {
+                        this._writing = false;
+                        this.emit('error', err);
+                    }
+                    return;
+                }
+                this.emit('write', n1);
+                const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n1);
+                this._len = releasedBufObj.len;
+                this._writingBuf = releasedBufObj.writingBuf;
+                if (this._writingBuf.length) {
+                    if (!this.sync) return void fsWrite();
+                    try {
+                        do {
+                            const n1 = fsWriteSync();
+                            const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n1);
+                            this._len = releasedBufObj.len;
+                            this._writingBuf = releasedBufObj.writingBuf;
+                        }while (this._writingBuf.length);
+                    } catch (err) {
+                        this.release(err);
+                        return;
+                    }
+                }
+                if (this._fsync) fs.fsyncSync(this.fd);
+                const len = this._len;
+                if (this._reopening) {
+                    this._writing = false;
+                    this._reopening = false;
+                    this.reopen();
+                } else if (len > this.minLength) this._actualWrite();
+                else if (this._ending) if (len > 0) this._actualWrite();
+                else {
+                    this._writing = false;
+                    actualClose(this);
+                }
+                else {
+                    this._writing = false;
+                    if (this.sync) {
+                        if (!this._asyncDrainScheduled) {
+                            this._asyncDrainScheduled = true;
+                            process.nextTick(emitDrain, this);
+                        }
+                    } else this.emit('drain');
+                }
+            };
+            this.on('newListener', function(name) {
+                if ('drain' === name) this._asyncDrainScheduled = false;
+            });
+            if (0 !== this._periodicFlush) {
+                this._periodicFlushTimer = setInterval(()=>this.flush(null), this._periodicFlush);
+                this._periodicFlushTimer.unref();
+            }
+        }
+        function releaseWritingBuf(writingBuf, len, n1) {
+            if ('string' == typeof writingBuf && Buffer.byteLength(writingBuf) !== n1) n1 = Buffer.from(writingBuf).subarray(0, n1).toString().length;
+            len = Math.max(len - n1, 0);
+            writingBuf = writingBuf.slice(n1);
+            return {
+                writingBuf,
+                len
+            };
+        }
+        function emitDrain(sonic) {
+            const hasListeners = sonic.listenerCount('drain') > 0;
+            if (!hasListeners) return;
+            sonic._asyncDrainScheduled = false;
+            sonic.emit('drain');
+        }
+        inherits(SonicBoom, EventEmitter);
+        function mergeBuf(bufs, len) {
+            if (0 === bufs.length) return kEmptyBuffer;
+            if (1 === bufs.length) return bufs[0];
+            return Buffer.concat(bufs, len);
+        }
+        function write(data) {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            const len = this._len + data.length;
+            const bufs = this._bufs;
+            if (this.maxLength && len > this.maxLength) {
+                this.emit('drop', data);
+                return this._len < this._hwm;
+            }
+            if (0 === bufs.length || bufs[bufs.length - 1].length + data.length > this.maxWrite) bufs.push('' + data);
+            else bufs[bufs.length - 1] += data;
+            this._len = len;
+            if (!this._writing && this._len >= this.minLength) this._actualWrite();
+            return this._len < this._hwm;
+        }
+        function writeBuffer(data) {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            const len = this._len + data.length;
+            const bufs = this._bufs;
+            const lens = this._lens;
+            if (this.maxLength && len > this.maxLength) {
+                this.emit('drop', data);
+                return this._len < this._hwm;
+            }
+            if (0 === bufs.length || lens[lens.length - 1] + data.length > this.maxWrite) {
+                bufs.push([
+                    data
+                ]);
+                lens.push(data.length);
+            } else {
+                bufs[bufs.length - 1].push(data);
+                lens[lens.length - 1] += data.length;
+            }
+            this._len = len;
+            if (!this._writing && this._len >= this.minLength) this._actualWrite();
+            return this._len < this._hwm;
+        }
+        function callFlushCallbackOnDrain(cb) {
+            this._flushPending = true;
+            const onDrain = ()=>{
+                if (this._fsync) {
+                    this._flushPending = false;
+                    cb();
+                } else try {
+                    fs.fsync(this.fd, (err)=>{
+                        this._flushPending = false;
+                        cb(err);
+                    });
+                } catch (err) {
+                    cb(err);
+                }
+                this.off('error', onError);
+            };
+            const onError = (err)=>{
+                this._flushPending = false;
+                cb(err);
+                this.off('drain', onDrain);
+            };
+            this.once('drain', onDrain);
+            this.once('error', onError);
+        }
+        function flush(cb) {
+            if (null != cb && 'function' != typeof cb) throw new Error('flush cb must be a function');
+            if (this.destroyed) {
+                const error = new Error('SonicBoom destroyed');
+                if (cb) return void cb(error);
+                throw error;
+            }
+            if (this.minLength <= 0) return void cb?.();
+            if (cb) callFlushCallbackOnDrain.call(this, cb);
+            if (this._writing) return;
+            if (0 === this._bufs.length) this._bufs.push('');
+            this._actualWrite();
+        }
+        function flushBuffer(cb) {
+            if (null != cb && 'function' != typeof cb) throw new Error('flush cb must be a function');
+            if (this.destroyed) {
+                const error = new Error('SonicBoom destroyed');
+                if (cb) return void cb(error);
+                throw error;
+            }
+            if (this.minLength <= 0) return void cb?.();
+            if (cb) callFlushCallbackOnDrain.call(this, cb);
+            if (this._writing) return;
+            if (0 === this._bufs.length) {
+                this._bufs.push([]);
+                this._lens.push(0);
+            }
+            this._actualWrite();
+        }
+        SonicBoom.prototype.reopen = function(file) {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            if (this._opening) return void this.once('ready', ()=>{
+                this.reopen(file);
+            });
+            if (this._ending) return;
+            if (!this.file) throw new Error("Unable to reopen a file descriptor, you must pass a file to SonicBoom");
+            if (file) this.file = file;
+            this._reopening = true;
+            if (this._writing) return;
+            const fd = this.fd;
+            this.once('ready', ()=>{
+                if (fd !== this.fd) fs.close(fd, (err)=>{
+                    if (err) return this.emit('error', err);
+                });
+            });
+            openFile(this.file, this);
+        };
+        SonicBoom.prototype.end = function() {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            if (this._opening) return void this.once('ready', ()=>{
+                this.end();
+            });
+            if (this._ending) return;
+            this._ending = true;
+            if (this._writing) return;
+            if (this._len > 0 && this.fd >= 0) this._actualWrite();
+            else actualClose(this);
+        };
+        function flushSync() {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            if (this.fd < 0) throw new Error('sonic boom is not ready yet');
+            if (!this._writing && this._writingBuf.length > 0) {
+                this._bufs.unshift(this._writingBuf);
+                this._writingBuf = '';
+            }
+            let buf = '';
+            while(this._bufs.length || buf){
+                if (buf.length <= 0) buf = this._bufs[0];
+                try {
+                    const n1 = fs.writeSync(this.fd, buf, 'utf8');
+                    const releasedBufObj = releaseWritingBuf(buf, this._len, n1);
+                    buf = releasedBufObj.writingBuf;
+                    this._len = releasedBufObj.len;
+                    if (buf.length <= 0) this._bufs.shift();
+                } catch (err) {
+                    const shouldRetry = 'EAGAIN' === err.code || 'EBUSY' === err.code;
+                    if (shouldRetry && !this.retryEAGAIN(err, buf.length, this._len - buf.length)) throw err;
+                    sleep(BUSY_WRITE_TIMEOUT);
+                }
+            }
+            try {
+                fs.fsyncSync(this.fd);
+            } catch  {}
+        }
+        function flushBufferSync() {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            if (this.fd < 0) throw new Error('sonic boom is not ready yet');
+            if (!this._writing && this._writingBuf.length > 0) {
+                this._bufs.unshift([
+                    this._writingBuf
+                ]);
+                this._writingBuf = kEmptyBuffer;
+            }
+            let buf = kEmptyBuffer;
+            while(this._bufs.length || buf.length){
+                if (buf.length <= 0) buf = mergeBuf(this._bufs[0], this._lens[0]);
+                try {
+                    const n1 = fs.writeSync(this.fd, buf);
+                    buf = buf.subarray(n1);
+                    this._len = Math.max(this._len - n1, 0);
+                    if (buf.length <= 0) {
+                        this._bufs.shift();
+                        this._lens.shift();
+                    }
+                } catch (err) {
+                    const shouldRetry = 'EAGAIN' === err.code || 'EBUSY' === err.code;
+                    if (shouldRetry && !this.retryEAGAIN(err, buf.length, this._len - buf.length)) throw err;
+                    sleep(BUSY_WRITE_TIMEOUT);
+                }
+            }
+        }
+        SonicBoom.prototype.destroy = function() {
+            if (this.destroyed) return;
+            actualClose(this);
+        };
+        function actualWrite() {
+            const release = this.release;
+            this._writing = true;
+            this._writingBuf = this._writingBuf || this._bufs.shift() || '';
+            if (this.sync) try {
+                const written = fs.writeSync(this.fd, this._writingBuf, 'utf8');
+                release(null, written);
+            } catch (err) {
+                release(err);
+            }
+            else fs.write(this.fd, this._writingBuf, 'utf8', release);
+        }
+        function actualWriteBuffer() {
+            const release = this.release;
+            this._writing = true;
+            this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
+            if (this.sync) try {
+                const written = fs.writeSync(this.fd, this._writingBuf);
+                release(null, written);
+            } catch (err) {
+                release(err);
+            }
+            else {
+                if (kCopyBuffer) this._writingBuf = Buffer.from(this._writingBuf);
+                fs.write(this.fd, this._writingBuf, release);
+            }
+        }
+        function actualClose(sonic) {
+            if (-1 === sonic.fd) return void sonic.once('ready', actualClose.bind(null, sonic));
+            if (void 0 !== sonic._periodicFlushTimer) clearInterval(sonic._periodicFlushTimer);
+            sonic.destroyed = true;
+            sonic._bufs = [];
+            sonic._lens = [];
+            assert('number' == typeof sonic.fd, `sonic.fd must be a number, got ${typeof sonic.fd}`);
+            try {
+                fs.fsync(sonic.fd, closeWrapped);
+            } catch  {}
+            function closeWrapped() {
+                if (1 !== sonic.fd && 2 !== sonic.fd) fs.close(sonic.fd, done);
+                else done();
+            }
+            function done(err) {
+                if (err) return void sonic.emit('error', err);
+                if (sonic._ending && !sonic._writing) sonic.emit('finish');
+                sonic.emit('close');
+            }
+        }
+        SonicBoom.SonicBoom = SonicBoom;
+        SonicBoom.default = SonicBoom;
+        module1.exports = SonicBoom;
+    },
+    "../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/worker.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const EE = __webpack_require__("node:events");
+        const { pipeline, PassThrough } = __webpack_require__("node:stream");
+        const pino = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/pino.js");
+        const build = __webpack_require__("../../node_modules/.pnpm/pino-abstract-transport@2.0.0/node_modules/pino-abstract-transport/index.js");
+        const loadTransportStreamBuilder = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/transport-stream.js");
+        module1.exports = async function({ targets, pipelines, levels, dedupe }) {
+            const targetStreams = [];
+            if (targets && targets.length) {
+                targets = await Promise.all(targets.map(async (t)=>{
+                    const fn = await loadTransportStreamBuilder(t.target);
+                    const stream = await fn(t.options);
+                    return {
+                        level: t.level,
+                        stream
+                    };
+                }));
+                targetStreams.push(...targets);
+            }
+            if (pipelines && pipelines.length) {
+                pipelines = await Promise.all(pipelines.map(async (p)=>{
+                    let level;
+                    const pipeDests = await Promise.all(p.map(async (t)=>{
+                        level = t.level;
+                        const fn = await loadTransportStreamBuilder(t.target);
+                        const stream = await fn(t.options);
+                        return stream;
+                    }));
+                    return {
+                        level,
+                        stream: createPipeline(pipeDests)
+                    };
+                }));
+                targetStreams.push(...pipelines);
+            }
+            if (1 === targetStreams.length) return targetStreams[0].stream;
+            return build(process1, {
+                parse: 'lines',
+                metadata: true,
+                close (err, cb) {
+                    let expected = 0;
+                    for (const transport of targetStreams){
+                        expected++;
+                        transport.stream.on('close', closeCb);
+                        transport.stream.end();
+                    }
+                    function closeCb() {
+                        if (0 === --expected) cb(err);
+                    }
+                }
+            });
+            function process1(stream) {
+                const multi = pino.multistream(targetStreams, {
+                    levels,
+                    dedupe
+                });
+                stream.on('data', function(chunk) {
+                    const { lastTime, lastMsg, lastObj, lastLevel } = this;
+                    multi.lastLevel = lastLevel;
+                    multi.lastTime = lastTime;
+                    multi.lastMsg = lastMsg;
+                    multi.lastObj = lastObj;
+                    multi.write(chunk + '\n');
+                });
+            }
+            function createPipeline(streams) {
+                const ee = new EE();
+                const stream = new PassThrough({
+                    autoDestroy: true,
+                    destroy (_, cb) {
+                        ee.on('error', cb);
+                        ee.on('closed', cb);
+                    }
+                });
+                pipeline(stream, ...streams, function(err) {
+                    if (err && 'ERR_STREAM_PREMATURE_CLOSE' !== err.code) return void ee.emit('error', err);
+                    ee.emit('closed');
+                });
+                return stream;
+            }
+        };
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/package.json": function(module1) {
+        "use strict";
+        module1.exports = JSON.parse('{"name":"thread-stream","version":"3.1.0","description":"A streaming way to send data to a Node.js Worker Thread","main":"index.js","types":"index.d.ts","dependencies":{"real-require":"^0.2.0"},"devDependencies":{"@types/node":"^20.1.0","@types/tap":"^15.0.0","@yao-pkg/pkg":"^5.11.5","desm":"^1.3.0","fastbench":"^1.0.1","husky":"^9.0.6","pino-elasticsearch":"^8.0.0","sonic-boom":"^4.0.1","standard":"^17.0.0","tap":"^16.2.0","ts-node":"^10.8.0","typescript":"^5.3.2","why-is-node-running":"^2.2.2"},"scripts":{"build":"tsc --noEmit","test":"standard && npm run build && npm run transpile && tap \\"test/**/*.test.*js\\" && tap --ts test/*.test.*ts","test:ci":"standard && npm run transpile && npm run test:ci:js && npm run test:ci:ts","test:ci:js":"tap --no-check-coverage --timeout=120 --coverage-report=lcovonly \\"test/**/*.test.*js\\"","test:ci:ts":"tap --ts --no-check-coverage --coverage-report=lcovonly \\"test/**/*.test.*ts\\"","test:yarn":"npm run transpile && tap \\"test/**/*.test.js\\" --no-check-coverage","transpile":"sh ./test/ts/transpile.sh","prepare":"husky install"},"standard":{"ignore":["test/ts/**/*","test/syntax-error.mjs"]},"repository":{"type":"git","url":"git+https://github.com/mcollina/thread-stream.git"},"keywords":["worker","thread","threads","stream"],"author":"Matteo Collina <hello@matteocollina.com>","license":"MIT","bugs":{"url":"https://github.com/mcollina/thread-stream/issues"},"homepage":"https://github.com/mcollina/thread-stream#readme"}');
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module1 = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module1, module1.exports, __webpack_require__);
+    return module1.exports;
+}
+var __webpack_exports__ = __webpack_require__("../../node_modules/.pnpm/pino@9.7.0/node_modules/pino/lib/worker.js");
+module.exports = __webpack_exports__;