@rife/logger 0.0.6-beta.10 → 0.0.6-beta.11

package/dist/cjs/pino/worker/pino-pretty.cjs

@@ -0,0 +1,2870 @@
+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/dateformat@4.6.3/node_modules/dateformat/lib/dateformat.js": function(module1, exports) {
+        "use strict";
+        function _typeof(obj) {
+            _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
+                return typeof obj;
+            } : function(obj) {
+                return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+            };
+            return _typeof(obj);
+        }
+        (function(global1) {
+            var _arguments = arguments;
+            var dateFormat = function() {
+                var token = /d{1,4}|D{3,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\1?|W{1,2}|[LlopSZN]|"[^"]*"|'[^']*'/g;
+                var timezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g;
+                var timezoneClip = /[^-+\dA-Z]/g;
+                return function(date, mask, utc, gmt) {
+                    if (1 === _arguments.length && "string" === kindOf(date) && !/\d/.test(date)) {
+                        mask = date;
+                        date = void 0;
+                    }
+                    date = date || 0 === date ? date : new Date;
+                    if (!(date instanceof Date)) date = new Date(date);
+                    if (isNaN(date)) throw TypeError("Invalid date");
+                    mask = String(dateFormat.masks[mask] || mask || dateFormat.masks["default"]);
+                    var maskSlice = mask.slice(0, 4);
+                    if ("UTC:" === maskSlice || "GMT:" === maskSlice) {
+                        mask = mask.slice(4);
+                        utc = true;
+                        if ("GMT:" === maskSlice) gmt = true;
+                    }
+                    var _ = function() {
+                        return utc ? "getUTC" : "get";
+                    };
+                    var _d = function() {
+                        return date[_() + "Date"]();
+                    };
+                    var D = function() {
+                        return date[_() + "Day"]();
+                    };
+                    var _m = function() {
+                        return date[_() + "Month"]();
+                    };
+                    var y = function() {
+                        return date[_() + "FullYear"]();
+                    };
+                    var _H = function() {
+                        return date[_() + "Hours"]();
+                    };
+                    var _M = function() {
+                        return date[_() + "Minutes"]();
+                    };
+                    var _s = function() {
+                        return date[_() + "Seconds"]();
+                    };
+                    var _L = function() {
+                        return date[_() + "Milliseconds"]();
+                    };
+                    var _o = function() {
+                        return utc ? 0 : date.getTimezoneOffset();
+                    };
+                    var _W = function() {
+                        return getWeek(date);
+                    };
+                    var _N = function() {
+                        return getDayOfWeek(date);
+                    };
+                    var flags = {
+                        d: function() {
+                            return _d();
+                        },
+                        dd: function() {
+                            return pad(_d());
+                        },
+                        ddd: function() {
+                            return dateFormat.i18n.dayNames[D()];
+                        },
+                        DDD: function() {
+                            return getDayName({
+                                y: y(),
+                                m: _m(),
+                                d: _d(),
+                                _: _(),
+                                dayName: dateFormat.i18n.dayNames[D()],
+                                short: true
+                            });
+                        },
+                        dddd: function() {
+                            return dateFormat.i18n.dayNames[D() + 7];
+                        },
+                        DDDD: function() {
+                            return getDayName({
+                                y: y(),
+                                m: _m(),
+                                d: _d(),
+                                _: _(),
+                                dayName: dateFormat.i18n.dayNames[D() + 7]
+                            });
+                        },
+                        m: function() {
+                            return _m() + 1;
+                        },
+                        mm: function() {
+                            return pad(_m() + 1);
+                        },
+                        mmm: function() {
+                            return dateFormat.i18n.monthNames[_m()];
+                        },
+                        mmmm: function() {
+                            return dateFormat.i18n.monthNames[_m() + 12];
+                        },
+                        yy: function() {
+                            return String(y()).slice(2);
+                        },
+                        yyyy: function() {
+                            return pad(y(), 4);
+                        },
+                        h: function() {
+                            return _H() % 12 || 12;
+                        },
+                        hh: function() {
+                            return pad(_H() % 12 || 12);
+                        },
+                        H: function() {
+                            return _H();
+                        },
+                        HH: function() {
+                            return pad(_H());
+                        },
+                        M: function() {
+                            return _M();
+                        },
+                        MM: function() {
+                            return pad(_M());
+                        },
+                        s: function() {
+                            return _s();
+                        },
+                        ss: function() {
+                            return pad(_s());
+                        },
+                        l: function() {
+                            return pad(_L(), 3);
+                        },
+                        L: function() {
+                            return pad(Math.floor(_L() / 10));
+                        },
+                        t: function() {
+                            return _H() < 12 ? dateFormat.i18n.timeNames[0] : dateFormat.i18n.timeNames[1];
+                        },
+                        tt: function() {
+                            return _H() < 12 ? dateFormat.i18n.timeNames[2] : dateFormat.i18n.timeNames[3];
+                        },
+                        T: function() {
+                            return _H() < 12 ? dateFormat.i18n.timeNames[4] : dateFormat.i18n.timeNames[5];
+                        },
+                        TT: function() {
+                            return _H() < 12 ? dateFormat.i18n.timeNames[6] : dateFormat.i18n.timeNames[7];
+                        },
+                        Z: function() {
+                            return gmt ? "GMT" : utc ? "UTC" : (String(date).match(timezone) || [
+                                ""
+                            ]).pop().replace(timezoneClip, "").replace(/GMT\+0000/g, "UTC");
+                        },
+                        o: function() {
+                            return (_o() > 0 ? "-" : "+") + pad(100 * Math.floor(Math.abs(_o()) / 60) + Math.abs(_o()) % 60, 4);
+                        },
+                        p: function() {
+                            return (_o() > 0 ? "-" : "+") + pad(Math.floor(Math.abs(_o()) / 60), 2) + ":" + pad(Math.floor(Math.abs(_o()) % 60), 2);
+                        },
+                        S: function() {
+                            return [
+                                "th",
+                                "st",
+                                "nd",
+                                "rd"
+                            ][_d() % 10 > 3 ? 0 : (_d() % 100 - _d() % 10 != 10) * _d() % 10];
+                        },
+                        W: function() {
+                            return _W();
+                        },
+                        WW: function() {
+                            return pad(_W());
+                        },
+                        N: function() {
+                            return _N();
+                        }
+                    };
+                    return mask.replace(token, function(match) {
+                        if (match in flags) return flags[match]();
+                        return match.slice(1, match.length - 1);
+                    });
+                };
+            }();
+            dateFormat.masks = {
+                default: "ddd mmm dd yyyy HH:MM:ss",
+                shortDate: "m/d/yy",
+                paddedShortDate: "mm/dd/yyyy",
+                mediumDate: "mmm d, yyyy",
+                longDate: "mmmm d, yyyy",
+                fullDate: "dddd, mmmm d, yyyy",
+                shortTime: "h:MM TT",
+                mediumTime: "h:MM:ss TT",
+                longTime: "h:MM:ss TT Z",
+                isoDate: "yyyy-mm-dd",
+                isoTime: "HH:MM:ss",
+                isoDateTime: "yyyy-mm-dd'T'HH:MM:sso",
+                isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'",
+                expiresHeaderFormat: "ddd, dd mmm yyyy HH:MM:ss Z"
+            };
+            dateFormat.i18n = {
+                dayNames: [
+                    "Sun",
+                    "Mon",
+                    "Tue",
+                    "Wed",
+                    "Thu",
+                    "Fri",
+                    "Sat",
+                    "Sunday",
+                    "Monday",
+                    "Tuesday",
+                    "Wednesday",
+                    "Thursday",
+                    "Friday",
+                    "Saturday"
+                ],
+                monthNames: [
+                    "Jan",
+                    "Feb",
+                    "Mar",
+                    "Apr",
+                    "May",
+                    "Jun",
+                    "Jul",
+                    "Aug",
+                    "Sep",
+                    "Oct",
+                    "Nov",
+                    "Dec",
+                    "January",
+                    "February",
+                    "March",
+                    "April",
+                    "May",
+                    "June",
+                    "July",
+                    "August",
+                    "September",
+                    "October",
+                    "November",
+                    "December"
+                ],
+                timeNames: [
+                    "a",
+                    "p",
+                    "am",
+                    "pm",
+                    "A",
+                    "P",
+                    "AM",
+                    "PM"
+                ]
+            };
+            var pad = function(val, len) {
+                val = String(val);
+                len = len || 2;
+                while(val.length < len)val = "0" + val;
+                return val;
+            };
+            var getDayName = function(_ref) {
+                var y = _ref.y, m = _ref.m, d = _ref.d, _ = _ref._, dayName = _ref.dayName, _ref$short = _ref["short"], _short = void 0 === _ref$short ? false : _ref$short;
+                var today = new Date;
+                var yesterday = new Date;
+                yesterday.setDate(yesterday[_ + "Date"]() - 1);
+                var tomorrow = new Date;
+                tomorrow.setDate(tomorrow[_ + "Date"]() + 1);
+                var today_d = function() {
+                    return today[_ + "Date"]();
+                };
+                var today_m = function() {
+                    return today[_ + "Month"]();
+                };
+                var today_y = function() {
+                    return today[_ + "FullYear"]();
+                };
+                var yesterday_d = function() {
+                    return yesterday[_ + "Date"]();
+                };
+                var yesterday_m = function() {
+                    return yesterday[_ + "Month"]();
+                };
+                var yesterday_y = function() {
+                    return yesterday[_ + "FullYear"]();
+                };
+                var tomorrow_d = function() {
+                    return tomorrow[_ + "Date"]();
+                };
+                var tomorrow_m = function() {
+                    return tomorrow[_ + "Month"]();
+                };
+                var tomorrow_y = function() {
+                    return tomorrow[_ + "FullYear"]();
+                };
+                if (today_y() === y && today_m() === m && today_d() === d) return _short ? "Tdy" : "Today";
+                if (yesterday_y() === y && yesterday_m() === m && yesterday_d() === d) return _short ? "Ysd" : "Yesterday";
+                if (tomorrow_y() === y && tomorrow_m() === m && tomorrow_d() === d) return _short ? "Tmw" : "Tomorrow";
+                return dayName;
+            };
+            var getWeek = function(date) {
+                var targetThursday = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+                targetThursday.setDate(targetThursday.getDate() - (targetThursday.getDay() + 6) % 7 + 3);
+                var firstThursday = new Date(targetThursday.getFullYear(), 0, 4);
+                firstThursday.setDate(firstThursday.getDate() - (firstThursday.getDay() + 6) % 7 + 3);
+                var ds = targetThursday.getTimezoneOffset() - firstThursday.getTimezoneOffset();
+                targetThursday.setHours(targetThursday.getHours() - ds);
+                var weekDiff = (targetThursday - firstThursday) / (864e5 * 7);
+                return 1 + Math.floor(weekDiff);
+            };
+            var getDayOfWeek = function(date) {
+                var dow = date.getDay();
+                if (0 === dow) dow = 7;
+                return dow;
+            };
+            var kindOf = function(val) {
+                if (null === val) return "null";
+                if (void 0 === val) return "undefined";
+                if ("object" !== _typeof(val)) return _typeof(val);
+                if (Array.isArray(val)) return "array";
+                return ({}).toString.call(val).slice(8, -1).toLowerCase();
+            };
+            if ("function" == typeof define && define.amd) define(function() {
+                return dateFormat;
+            });
+            else if ("object" === _typeof(exports)) module1.exports = dateFormat;
+            else global1.dateFormat = dateFormat;
+        })(void 0);
+    },
+    "../../node_modules/.pnpm/end-of-stream@1.4.4/node_modules/end-of-stream/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        var once = __webpack_require__("../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js");
+        var noop = function() {};
+        var isRequest = function(stream) {
+            return stream.setHeader && 'function' == typeof stream.abort;
+        };
+        var isChildProcess = function(stream) {
+            return stream.stdio && Array.isArray(stream.stdio) && 3 === stream.stdio.length;
+        };
+        var eos = function(stream, opts, callback) {
+            if ('function' == typeof opts) return eos(stream, null, opts);
+            if (!opts) opts = {};
+            callback = once(callback || noop);
+            var ws = stream._writableState;
+            var rs = stream._readableState;
+            var readable = opts.readable || false !== opts.readable && stream.readable;
+            var writable = opts.writable || false !== opts.writable && stream.writable;
+            var cancelled = false;
+            var onlegacyfinish = function() {
+                if (!stream.writable) onfinish();
+            };
+            var onfinish = function() {
+                writable = false;
+                if (!readable) callback.call(stream);
+            };
+            var onend = function() {
+                readable = false;
+                if (!writable) callback.call(stream);
+            };
+            var onexit = function(exitCode) {
+                callback.call(stream, exitCode ? new Error('exited with error code: ' + exitCode) : null);
+            };
+            var onerror = function(err) {
+                callback.call(stream, err);
+            };
+            var onclose = function() {
+                process.nextTick(onclosenexttick);
+            };
+            var onclosenexttick = function() {
+                if (cancelled) return;
+                if (readable && !(rs && rs.ended && !rs.destroyed)) return callback.call(stream, new Error('premature close'));
+                if (writable && !(ws && ws.ended && !ws.destroyed)) return callback.call(stream, new Error('premature close'));
+            };
+            var onrequest = function() {
+                stream.req.on('finish', onfinish);
+            };
+            if (isRequest(stream)) {
+                stream.on('complete', onfinish);
+                stream.on('abort', onclose);
+                if (stream.req) onrequest();
+                else stream.on('request', onrequest);
+            } else if (writable && !ws) {
+                stream.on('end', onlegacyfinish);
+                stream.on('close', onlegacyfinish);
+            }
+            if (isChildProcess(stream)) stream.on('exit', onexit);
+            stream.on('end', onend);
+            stream.on('finish', onfinish);
+            if (false !== opts.error) stream.on('error', onerror);
+            stream.on('close', onclose);
+            return function() {
+                cancelled = true;
+                stream.removeListener('complete', onfinish);
+                stream.removeListener('abort', onclose);
+                stream.removeListener('request', onrequest);
+                if (stream.req) stream.req.removeListener('finish', onfinish);
+                stream.removeListener('end', onlegacyfinish);
+                stream.removeListener('close', onlegacyfinish);
+                stream.removeListener('finish', onfinish);
+                stream.removeListener('exit', onexit);
+                stream.removeListener('end', onend);
+                stream.removeListener('error', onerror);
+                stream.removeListener('close', onclose);
+            };
+        };
+        module1.exports = eos;
+    },
+    "../../node_modules/.pnpm/fast-safe-stringify@2.1.1/node_modules/fast-safe-stringify/index.js": function(module1) {
+        module1.exports = stringify;
+        stringify.default = stringify;
+        stringify.stable = deterministicStringify;
+        stringify.stableStringify = deterministicStringify;
+        var LIMIT_REPLACE_NODE = '[...]';
+        var CIRCULAR_REPLACE_NODE = '[Circular]';
+        var arr = [];
+        var replacerStack = [];
+        function defaultOptions() {
+            return {
+                depthLimit: Number.MAX_SAFE_INTEGER,
+                edgesLimit: Number.MAX_SAFE_INTEGER
+            };
+        }
+        function stringify(obj, replacer, spacer, options) {
+            if (void 0 === options) options = defaultOptions();
+            decirc(obj, '', 0, [], void 0, 0, options);
+            var res;
+            try {
+                res = 0 === replacerStack.length ? JSON.stringify(obj, replacer, spacer) : JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+            } catch (_) {
+                return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]');
+            } finally{
+                while(0 !== arr.length){
+                    var part = arr.pop();
+                    if (4 === part.length) Object.defineProperty(part[0], part[1], part[3]);
+                    else part[0][part[1]] = part[2];
+                }
+            }
+            return res;
+        }
+        function setReplace(replace, val, k, parent) {
+            var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
+            if (void 0 !== propertyDescriptor.get) if (propertyDescriptor.configurable) {
+                Object.defineProperty(parent, k, {
+                    value: replace
+                });
+                arr.push([
+                    parent,
+                    k,
+                    val,
+                    propertyDescriptor
+                ]);
+            } else replacerStack.push([
+                val,
+                k,
+                replace
+            ]);
+            else {
+                parent[k] = replace;
+                arr.push([
+                    parent,
+                    k,
+                    val
+                ]);
+            }
+        }
+        function decirc(val, k, edgeIndex, stack, parent, depth, options) {
+            depth += 1;
+            var i;
+            if ('object' == typeof val && null !== val) {
+                for(i = 0; i < stack.length; i++)if (stack[i] === val) return void setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                if (void 0 !== options.depthLimit && depth > options.depthLimit) return void setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+                if (void 0 !== options.edgesLimit && edgeIndex + 1 > options.edgesLimit) return void setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+                stack.push(val);
+                if (Array.isArray(val)) for(i = 0; i < val.length; i++)decirc(val[i], i, i, stack, val, depth, options);
+                else {
+                    var keys = Object.keys(val);
+                    for(i = 0; i < keys.length; i++){
+                        var key = keys[i];
+                        decirc(val[key], key, i, stack, val, depth, options);
+                    }
+                }
+                stack.pop();
+            }
+        }
+        function compareFunction(a, b) {
+            if (a < b) return -1;
+            if (a > b) return 1;
+            return 0;
+        }
+        function deterministicStringify(obj, replacer, spacer, options) {
+            if (void 0 === options) options = defaultOptions();
+            var tmp = deterministicDecirc(obj, '', 0, [], void 0, 0, options) || obj;
+            var res;
+            try {
+                res = 0 === replacerStack.length ? JSON.stringify(tmp, replacer, spacer) : JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
+            } catch (_) {
+                return JSON.stringify('[unable to serialize, circular reference is too complex to analyze]');
+            } finally{
+                while(0 !== arr.length){
+                    var part = arr.pop();
+                    if (4 === part.length) Object.defineProperty(part[0], part[1], part[3]);
+                    else part[0][part[1]] = part[2];
+                }
+            }
+            return res;
+        }
+        function deterministicDecirc(val, k, edgeIndex, stack, parent, depth, options) {
+            depth += 1;
+            var i;
+            if ('object' == typeof val && null !== val) {
+                for(i = 0; i < stack.length; i++)if (stack[i] === val) return void setReplace(CIRCULAR_REPLACE_NODE, val, k, parent);
+                try {
+                    if ('function' == typeof val.toJSON) return;
+                } catch (_) {
+                    return;
+                }
+                if (void 0 !== options.depthLimit && depth > options.depthLimit) return void setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+                if (void 0 !== options.edgesLimit && edgeIndex + 1 > options.edgesLimit) return void setReplace(LIMIT_REPLACE_NODE, val, k, parent);
+                stack.push(val);
+                if (Array.isArray(val)) for(i = 0; i < val.length; i++)deterministicDecirc(val[i], i, i, stack, val, depth, options);
+                else {
+                    var tmp = {};
+                    var keys = Object.keys(val).sort(compareFunction);
+                    for(i = 0; i < keys.length; i++){
+                        var key = keys[i];
+                        deterministicDecirc(val[key], key, i, stack, val, depth, options);
+                        tmp[key] = val[key];
+                    }
+                    if (void 0 === parent) return tmp;
+                    arr.push([
+                        parent,
+                        k,
+                        val
+                    ]);
+                    parent[k] = tmp;
+                }
+                stack.pop();
+            }
+        }
+        function replaceGetterValues(replacer) {
+            replacer = void 0 !== replacer ? replacer : function(k, v) {
+                return v;
+            };
+            return function(key, val) {
+                if (replacerStack.length > 0) for(var i = 0; i < replacerStack.length; i++){
+                    var part = replacerStack[i];
+                    if (part[1] === key && part[0] === val) {
+                        val = part[2];
+                        replacerStack.splice(i, 1);
+                        break;
+                    }
+                }
+                return replacer.call(this, key, val);
+            };
+        }
+    },
+    "../../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/once@1.4.0/node_modules/once/once.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        var wrappy = __webpack_require__("../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js");
+        module1.exports = wrappy(once);
+        module1.exports.strict = wrappy(onceStrict);
+        once.proto = once(function() {
+            Object.defineProperty(Function.prototype, 'once', {
+                value: function() {
+                    return once(this);
+                },
+                configurable: true
+            });
+            Object.defineProperty(Function.prototype, 'onceStrict', {
+                value: function() {
+                    return onceStrict(this);
+                },
+                configurable: true
+            });
+        });
+        function once(fn) {
+            var f = function() {
+                if (f.called) return f.value;
+                f.called = true;
+                return f.value = fn.apply(this, arguments);
+            };
+            f.called = false;
+            return f;
+        }
+        function onceStrict(fn) {
+            var f = function() {
+                if (f.called) throw new Error(f.onceError);
+                f.called = true;
+                return f.value = fn.apply(this, arguments);
+            };
+            var name = fn.name || 'Function wrapped with `once`';
+            f.onceError = name + " shouldn't be called more than once";
+            f.called = false;
+            return f;
+        }
+    },
+    "../../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/pump@3.0.2/node_modules/pump/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        var once = __webpack_require__("../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js");
+        var eos = __webpack_require__("../../node_modules/.pnpm/end-of-stream@1.4.4/node_modules/end-of-stream/index.js");
+        var fs;
+        try {
+            fs = __webpack_require__("fs");
+        } catch (e) {}
+        var noop = function() {};
+        var ancient = /^v?\.0/.test(process.version);
+        var isFn = function(fn) {
+            return 'function' == typeof fn;
+        };
+        var isFS = function(stream) {
+            if (!ancient) return false;
+            if (!fs) return false;
+            return (stream instanceof (fs.ReadStream || noop) || stream instanceof (fs.WriteStream || noop)) && isFn(stream.close);
+        };
+        var isRequest = function(stream) {
+            return stream.setHeader && isFn(stream.abort);
+        };
+        var destroyer = function(stream, reading, writing, callback) {
+            callback = once(callback);
+            var closed = false;
+            stream.on('close', function() {
+                closed = true;
+            });
+            eos(stream, {
+                readable: reading,
+                writable: writing
+            }, function(err) {
+                if (err) return callback(err);
+                closed = true;
+                callback();
+            });
+            var destroyed = false;
+            return function(err) {
+                if (closed) return;
+                if (destroyed) return;
+                destroyed = true;
+                if (isFS(stream)) return stream.close(noop);
+                if (isRequest(stream)) return stream.abort();
+                if (isFn(stream.destroy)) return stream.destroy();
+                callback(err || new Error('stream was destroyed'));
+            };
+        };
+        var call = function(fn) {
+            fn();
+        };
+        var pipe = function(from, to) {
+            return from.pipe(to);
+        };
+        var pump = function() {
+            var streams = Array.prototype.slice.call(arguments);
+            var callback = isFn(streams[streams.length - 1] || noop) && streams.pop() || noop;
+            if (Array.isArray(streams[0])) streams = streams[0];
+            if (streams.length < 2) throw new Error('pump requires two streams per minimum');
+            var error;
+            var destroys = streams.map(function(stream, i) {
+                var reading = i < streams.length - 1;
+                var writing = i > 0;
+                return destroyer(stream, reading, writing, function(err) {
+                    if (!error) error = err;
+                    if (err) destroys.forEach(call);
+                    if (reading) return;
+                    destroys.forEach(call);
+                    callback(error);
+                });
+            });
+            return streams.reduce(pipe);
+        };
+        module1.exports = pump;
+    },
+    "../../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/wrappy@1.0.2/node_modules/wrappy/wrappy.js": function(module1) {
+        module1.exports = wrappy;
+        function wrappy(fn, cb) {
+            if (fn && cb) return wrappy(fn)(cb);
+            if ('function' != typeof fn) throw new TypeError('need wrapper function');
+            Object.keys(fn).forEach(function(k) {
+                wrapper[k] = fn[k];
+            });
+            return wrapper;
+            function wrapper() {
+                var args = new Array(arguments.length);
+                for(var i = 0; i < args.length; i++)args[i] = arguments[i];
+                var ret = fn.apply(this, args);
+                var cb = args[args.length - 1];
+                if ('function' == typeof ret && ret !== cb) Object.keys(cb).forEach(function(k) {
+                    ret[k] = cb[k];
+                });
+                return ret;
+            }
+        }
+    },
+    assert: function(module1) {
+        "use strict";
+        module1.exports = require("assert");
+    },
+    events: function(module1) {
+        "use strict";
+        module1.exports = require("events");
+    },
+    fs: function(module1) {
+        "use strict";
+        module1.exports = require("fs");
+    },
+    "node:stream": function(module1) {
+        "use strict";
+        module1.exports = require("node:stream");
+    },
+    "node:worker_threads": function(module1) {
+        "use strict";
+        module1.exports = require("node:worker_threads");
+    },
+    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");
+    },
+    tty: function(module1) {
+        "use strict";
+        module1.exports = require("tty");
+    },
+    util: function(module1) {
+        "use strict";
+        module1.exports = require("util");
+    },
+    worker_threads: function(module1) {
+        "use strict";
+        module1.exports = require("worker_threads");
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { isColorSupported } = __webpack_require__("../../node_modules/.pnpm/colorette@2.0.20/node_modules/colorette/index.cjs");
+        const pump = __webpack_require__("../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js");
+        const { Transform } = __webpack_require__("node:stream");
+        const abstractTransport = __webpack_require__("../../node_modules/.pnpm/pino-abstract-transport@2.0.0/node_modules/pino-abstract-transport/index.js");
+        const colors = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/colors.js");
+        const { ERROR_LIKE_KEYS, LEVEL_KEY, LEVEL_LABEL, MESSAGE_KEY, TIMESTAMP_KEY } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js");
+        const { buildSafeSonicBoom, parseFactoryOptions } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/index.js");
+        const pretty = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/pretty.js");
+        const defaultOptions = {
+            colorize: isColorSupported,
+            colorizeObjects: true,
+            crlf: false,
+            customColors: null,
+            customLevels: null,
+            customPrettifiers: {},
+            errorLikeObjectKeys: ERROR_LIKE_KEYS,
+            errorProps: '',
+            hideObject: false,
+            ignore: 'hostname',
+            include: void 0,
+            levelFirst: false,
+            levelKey: LEVEL_KEY,
+            levelLabel: LEVEL_LABEL,
+            messageFormat: null,
+            messageKey: MESSAGE_KEY,
+            minimumLevel: void 0,
+            outputStream: process.stdout,
+            singleLine: false,
+            timestampKey: TIMESTAMP_KEY,
+            translateTime: true,
+            useOnlyCustomProps: true
+        };
+        function prettyFactory(options) {
+            const context = parseFactoryOptions(Object.assign({}, defaultOptions, options));
+            return pretty.bind({
+                ...context,
+                context
+            });
+        }
+        function build(opts = {}) {
+            let pretty = prettyFactory(opts);
+            let destination;
+            return abstractTransport(function(source) {
+                source.on('message', function pinoConfigListener(message) {
+                    if (!message || 'PINO_CONFIG' !== message.code) return;
+                    Object.assign(opts, {
+                        messageKey: message.config.messageKey,
+                        errorLikeObjectKeys: Array.from(new Set([
+                            ...opts.errorLikeObjectKeys || ERROR_LIKE_KEYS,
+                            message.config.errorKey
+                        ])),
+                        customLevels: message.config.levels.values
+                    });
+                    pretty = prettyFactory(opts);
+                    source.off('message', pinoConfigListener);
+                });
+                const stream = new Transform({
+                    objectMode: true,
+                    autoDestroy: true,
+                    transform (chunk, enc, cb) {
+                        const line = pretty(chunk);
+                        cb(null, line);
+                    }
+                });
+                destination = 'object' == typeof opts.destination && 'function' == typeof opts.destination.write ? opts.destination : buildSafeSonicBoom({
+                    dest: opts.destination || 1,
+                    append: opts.append,
+                    mkdir: opts.mkdir,
+                    sync: opts.sync
+                });
+                source.on('unknown', function(line) {
+                    destination.write(line + '\n');
+                });
+                pump(source, stream, destination);
+                return stream;
+            }, {
+                parse: 'lines',
+                close (err, cb) {
+                    destination.on('close', ()=>{
+                        cb(err);
+                    });
+                }
+            });
+        }
+        module1.exports = build;
+        module1.exports.build = build;
+        module1.exports.PinoPretty = build;
+        module1.exports.prettyFactory = prettyFactory;
+        module1.exports.colorizerFactory = colors;
+        module1.exports.isColorSupported = isColorSupported;
+        module1.exports["default"] = build;
+    },
+    "../../node_modules/.pnpm/colorette@2.0.20/node_modules/colorette/index.cjs": function(__unused_webpack_module, exports, __webpack_require__) {
+        "use strict";
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        var tty = __webpack_require__("tty");
+        function _interopNamespace(e) {
+            if (e && e.__esModule) return e;
+            var n = Object.create(null);
+            if (e) Object.keys(e).forEach(function(k) {
+                if ('default' !== k) {
+                    var d = Object.getOwnPropertyDescriptor(e, k);
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: function() {
+                            return e[k];
+                        }
+                    });
+                }
+            });
+            n["default"] = e;
+            return Object.freeze(n);
+        }
+        var tty__namespace = /*#__PURE__*/ _interopNamespace(tty);
+        const { env = {}, argv = [], platform = "" } = "undefined" == typeof process ? {} : process;
+        const isDisabled = "NO_COLOR" in env || argv.includes("--no-color");
+        const isForced = "FORCE_COLOR" in env || argv.includes("--color");
+        const isWindows = "win32" === platform;
+        const isDumbTerminal = "dumb" === env.TERM;
+        const isCompatibleTerminal = tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env.TERM && !isDumbTerminal;
+        const isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
+        const isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
+        const replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close))=>head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+        const clearBleed = (index, string, open, close, replace)=>index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
+        const filterEmpty = (open, close, replace = open, at = open.length + 1)=>(string)=>string || !("" === string || void 0 === string) ? clearBleed(("" + string).indexOf(close, at), string, open, close, replace) : "";
+        const init = (open, close, replace)=>filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+        const colors = {
+            reset: init(0, 0),
+            bold: init(1, 22, "\x1b[22m\x1b[1m"),
+            dim: init(2, 22, "\x1b[22m\x1b[2m"),
+            italic: init(3, 23),
+            underline: init(4, 24),
+            inverse: init(7, 27),
+            hidden: init(8, 28),
+            strikethrough: init(9, 29),
+            black: init(30, 39),
+            red: init(31, 39),
+            green: init(32, 39),
+            yellow: init(33, 39),
+            blue: init(34, 39),
+            magenta: init(35, 39),
+            cyan: init(36, 39),
+            white: init(37, 39),
+            gray: init(90, 39),
+            bgBlack: init(40, 49),
+            bgRed: init(41, 49),
+            bgGreen: init(42, 49),
+            bgYellow: init(43, 49),
+            bgBlue: init(44, 49),
+            bgMagenta: init(45, 49),
+            bgCyan: init(46, 49),
+            bgWhite: init(47, 49),
+            blackBright: init(90, 39),
+            redBright: init(91, 39),
+            greenBright: init(92, 39),
+            yellowBright: init(93, 39),
+            blueBright: init(94, 39),
+            magentaBright: init(95, 39),
+            cyanBright: init(96, 39),
+            whiteBright: init(97, 39),
+            bgBlackBright: init(100, 49),
+            bgRedBright: init(101, 49),
+            bgGreenBright: init(102, 49),
+            bgYellowBright: init(103, 49),
+            bgBlueBright: init(104, 49),
+            bgMagentaBright: init(105, 49),
+            bgCyanBright: init(106, 49),
+            bgWhiteBright: init(107, 49)
+        };
+        const createColors = ({ useColor = isColorSupported } = {})=>useColor ? colors : Object.keys(colors).reduce((colors, key)=>({
+                    ...colors,
+                    [key]: String
+                }), {});
+        const { reset, bold, dim, italic, underline, inverse, hidden, strikethrough, black, red, green, yellow, blue, magenta, cyan, white, gray, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, blackBright, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlackBright, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = createColors();
+        exports.bgBlack = bgBlack;
+        exports.bgBlackBright = bgBlackBright;
+        exports.bgBlue = bgBlue;
+        exports.bgBlueBright = bgBlueBright;
+        exports.bgCyan = bgCyan;
+        exports.bgCyanBright = bgCyanBright;
+        exports.bgGreen = bgGreen;
+        exports.bgGreenBright = bgGreenBright;
+        exports.bgMagenta = bgMagenta;
+        exports.bgMagentaBright = bgMagentaBright;
+        exports.bgRed = bgRed;
+        exports.bgRedBright = bgRedBright;
+        exports.bgWhite = bgWhite;
+        exports.bgWhiteBright = bgWhiteBright;
+        exports.bgYellow = bgYellow;
+        exports.bgYellowBright = bgYellowBright;
+        exports.black = black;
+        exports.blackBright = blackBright;
+        exports.blue = blue;
+        exports.blueBright = blueBright;
+        exports.bold = bold;
+        exports.createColors = createColors;
+        exports.cyan = cyan;
+        exports.cyanBright = cyanBright;
+        exports.dim = dim;
+        exports.gray = gray;
+        exports.green = green;
+        exports.greenBright = greenBright;
+        exports.hidden = hidden;
+        exports.inverse = inverse;
+        exports.isColorSupported = isColorSupported;
+        exports.italic = italic;
+        exports.magenta = magenta;
+        exports.magentaBright = magentaBright;
+        exports.red = red;
+        exports.redBright = redBright;
+        exports.reset = reset;
+        exports.strikethrough = strikethrough;
+        exports.underline = underline;
+        exports.white = white;
+        exports.whiteBright = whiteBright;
+        exports.yellow = yellow;
+        exports.yellowBright = yellowBright;
+    },
+    "../../node_modules/.pnpm/fast-copy@3.0.2/node_modules/fast-copy/dist/cjs/index.cjs": function(__unused_webpack_module, exports) {
+        "use strict";
+        Object.defineProperty(exports, "__esModule", {
+            value: true
+        });
+        var toStringFunction = Function.prototype.toString;
+        var create = Object.create;
+        var toStringObject = Object.prototype.toString;
+        var LegacyCache = function() {
+            function LegacyCache() {
+                this._keys = [];
+                this._values = [];
+            }
+            LegacyCache.prototype.has = function(key) {
+                return !!~this._keys.indexOf(key);
+            };
+            LegacyCache.prototype.get = function(key) {
+                return this._values[this._keys.indexOf(key)];
+            };
+            LegacyCache.prototype.set = function(key, value) {
+                this._keys.push(key);
+                this._values.push(value);
+            };
+            return LegacyCache;
+        }();
+        function createCacheLegacy() {
+            return new LegacyCache();
+        }
+        function createCacheModern() {
+            return new WeakMap();
+        }
+        var createCache = 'undefined' != typeof WeakMap ? createCacheModern : createCacheLegacy;
+        function getCleanClone(prototype) {
+            if (!prototype) return create(null);
+            var Constructor = prototype.constructor;
+            if (Constructor === Object) return prototype === Object.prototype ? {} : create(prototype);
+            if (Constructor && ~toStringFunction.call(Constructor).indexOf('[native code]')) try {
+                return new Constructor();
+            } catch (_a) {}
+            return create(prototype);
+        }
+        function getRegExpFlagsLegacy(regExp) {
+            var flags = '';
+            if (regExp.global) flags += 'g';
+            if (regExp.ignoreCase) flags += 'i';
+            if (regExp.multiline) flags += 'm';
+            if (regExp.unicode) flags += 'u';
+            if (regExp.sticky) flags += 'y';
+            return flags;
+        }
+        function getRegExpFlagsModern(regExp) {
+            return regExp.flags;
+        }
+        var getRegExpFlags = 'g' === /test/g.flags ? getRegExpFlagsModern : getRegExpFlagsLegacy;
+        function getTagLegacy(value) {
+            var type = toStringObject.call(value);
+            return type.substring(8, type.length - 1);
+        }
+        function getTagModern(value) {
+            return value[Symbol.toStringTag] || getTagLegacy(value);
+        }
+        var getTag = 'undefined' != typeof Symbol ? getTagModern : getTagLegacy;
+        var defineProperty = Object.defineProperty, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;
+        var _a = Object.prototype, hasOwnProperty = _a.hasOwnProperty, propertyIsEnumerable = _a.propertyIsEnumerable;
+        var SUPPORTS_SYMBOL = 'function' == typeof getOwnPropertySymbols;
+        function getStrictPropertiesModern(object) {
+            return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
+        }
+        var getStrictProperties = SUPPORTS_SYMBOL ? getStrictPropertiesModern : getOwnPropertyNames;
+        function copyOwnPropertiesStrict(value, clone, state) {
+            var properties = getStrictProperties(value);
+            for(var index = 0, length_1 = properties.length, property = void 0, descriptor = void 0; index < length_1; ++index){
+                property = properties[index];
+                if ('callee' !== property && 'caller' !== property) {
+                    descriptor = getOwnPropertyDescriptor(value, property);
+                    if (!descriptor) {
+                        clone[property] = state.copier(value[property], state);
+                        continue;
+                    }
+                    if (!descriptor.get && !descriptor.set) descriptor.value = state.copier(descriptor.value, state);
+                    try {
+                        defineProperty(clone, property, descriptor);
+                    } catch (error) {
+                        clone[property] = descriptor.value;
+                    }
+                }
+            }
+            return clone;
+        }
+        function copyArrayLoose(array, state) {
+            var clone = new state.Constructor();
+            state.cache.set(array, clone);
+            for(var index = 0, length_2 = array.length; index < length_2; ++index)clone[index] = state.copier(array[index], state);
+            return clone;
+        }
+        function copyArrayStrict(array, state) {
+            var clone = new state.Constructor();
+            state.cache.set(array, clone);
+            return copyOwnPropertiesStrict(array, clone, state);
+        }
+        function copyArrayBuffer(arrayBuffer, _state) {
+            return arrayBuffer.slice(0);
+        }
+        function copyBlob(blob, _state) {
+            return blob.slice(0, blob.size, blob.type);
+        }
+        function copyDataView(dataView, state) {
+            return new state.Constructor(copyArrayBuffer(dataView.buffer));
+        }
+        function copyDate(date, state) {
+            return new state.Constructor(date.getTime());
+        }
+        function copyMapLoose(map, state) {
+            var clone = new state.Constructor();
+            state.cache.set(map, clone);
+            map.forEach(function(value, key) {
+                clone.set(key, state.copier(value, state));
+            });
+            return clone;
+        }
+        function copyMapStrict(map, state) {
+            return copyOwnPropertiesStrict(map, copyMapLoose(map, state), state);
+        }
+        function copyObjectLooseLegacy(object, state) {
+            var clone = getCleanClone(state.prototype);
+            state.cache.set(object, clone);
+            for(var key in object)if (hasOwnProperty.call(object, key)) clone[key] = state.copier(object[key], state);
+            return clone;
+        }
+        function copyObjectLooseModern(object, state) {
+            var clone = getCleanClone(state.prototype);
+            state.cache.set(object, clone);
+            for(var key in object)if (hasOwnProperty.call(object, key)) clone[key] = state.copier(object[key], state);
+            var symbols = getOwnPropertySymbols(object);
+            for(var index = 0, length_3 = symbols.length, symbol = void 0; index < length_3; ++index){
+                symbol = symbols[index];
+                if (propertyIsEnumerable.call(object, symbol)) clone[symbol] = state.copier(object[symbol], state);
+            }
+            return clone;
+        }
+        var copyObjectLoose = SUPPORTS_SYMBOL ? copyObjectLooseModern : copyObjectLooseLegacy;
+        function copyObjectStrict(object, state) {
+            var clone = getCleanClone(state.prototype);
+            state.cache.set(object, clone);
+            return copyOwnPropertiesStrict(object, clone, state);
+        }
+        function copyPrimitiveWrapper(primitiveObject, state) {
+            return new state.Constructor(primitiveObject.valueOf());
+        }
+        function copyRegExp(regExp, state) {
+            var clone = new state.Constructor(regExp.source, getRegExpFlags(regExp));
+            clone.lastIndex = regExp.lastIndex;
+            return clone;
+        }
+        function copySelf(value, _state) {
+            return value;
+        }
+        function copySetLoose(set, state) {
+            var clone = new state.Constructor();
+            state.cache.set(set, clone);
+            set.forEach(function(value) {
+                clone.add(state.copier(value, state));
+            });
+            return clone;
+        }
+        function copySetStrict(set, state) {
+            return copyOwnPropertiesStrict(set, copySetLoose(set, state), state);
+        }
+        var isArray = Array.isArray;
+        var assign = Object.assign;
+        var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+            return obj.__proto__;
+        };
+        var DEFAULT_LOOSE_OPTIONS = {
+            array: copyArrayLoose,
+            arrayBuffer: copyArrayBuffer,
+            blob: copyBlob,
+            dataView: copyDataView,
+            date: copyDate,
+            error: copySelf,
+            map: copyMapLoose,
+            object: copyObjectLoose,
+            regExp: copyRegExp,
+            set: copySetLoose
+        };
+        var DEFAULT_STRICT_OPTIONS = assign({}, DEFAULT_LOOSE_OPTIONS, {
+            array: copyArrayStrict,
+            map: copyMapStrict,
+            object: copyObjectStrict,
+            set: copySetStrict
+        });
+        function getTagSpecificCopiers(options) {
+            return {
+                Arguments: options.object,
+                Array: options.array,
+                ArrayBuffer: options.arrayBuffer,
+                Blob: options.blob,
+                Boolean: copyPrimitiveWrapper,
+                DataView: options.dataView,
+                Date: options.date,
+                Error: options.error,
+                Float32Array: options.arrayBuffer,
+                Float64Array: options.arrayBuffer,
+                Int8Array: options.arrayBuffer,
+                Int16Array: options.arrayBuffer,
+                Int32Array: options.arrayBuffer,
+                Map: options.map,
+                Number: copyPrimitiveWrapper,
+                Object: options.object,
+                Promise: copySelf,
+                RegExp: options.regExp,
+                Set: options.set,
+                String: copyPrimitiveWrapper,
+                WeakMap: copySelf,
+                WeakSet: copySelf,
+                Uint8Array: options.arrayBuffer,
+                Uint8ClampedArray: options.arrayBuffer,
+                Uint16Array: options.arrayBuffer,
+                Uint32Array: options.arrayBuffer,
+                Uint64Array: options.arrayBuffer
+            };
+        }
+        function createCopier(options) {
+            var normalizedOptions = assign({}, DEFAULT_LOOSE_OPTIONS, options);
+            var tagSpecificCopiers = getTagSpecificCopiers(normalizedOptions);
+            var array = tagSpecificCopiers.Array, object = tagSpecificCopiers.Object;
+            function copier(value, state) {
+                state.prototype = state.Constructor = void 0;
+                if (!value || 'object' != typeof value) return value;
+                if (state.cache.has(value)) return state.cache.get(value);
+                state.prototype = getPrototypeOf(value);
+                state.Constructor = state.prototype && state.prototype.constructor;
+                if (!state.Constructor || state.Constructor === Object) return object(value, state);
+                if (isArray(value)) return array(value, state);
+                var tagSpecificCopier = tagSpecificCopiers[getTag(value)];
+                if (tagSpecificCopier) return tagSpecificCopier(value, state);
+                return 'function' == typeof value.then ? value : object(value, state);
+            }
+            return function(value) {
+                return copier(value, {
+                    Constructor: void 0,
+                    cache: createCache(),
+                    copier: copier,
+                    prototype: void 0
+                });
+            };
+        }
+        function createStrictCopier(options) {
+            return createCopier(assign({}, DEFAULT_STRICT_OPTIONS, options));
+        }
+        var copyStrict = createStrictCopier({});
+        var index = createCopier({});
+        exports.copyStrict = copyStrict;
+        exports.createCopier = createCopier;
+        exports.createStrictCopier = createStrictCopier;
+        exports["default"] = index;
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/colors.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const nocolor = (input)=>input;
+        const plain = {
+            default: nocolor,
+            60: nocolor,
+            50: nocolor,
+            40: nocolor,
+            30: nocolor,
+            20: nocolor,
+            10: nocolor,
+            message: nocolor,
+            greyMessage: nocolor,
+            property: nocolor
+        };
+        const { createColors } = __webpack_require__("../../node_modules/.pnpm/colorette@2.0.20/node_modules/colorette/index.cjs");
+        const getLevelLabelData = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-level-label-data.js");
+        const availableColors = createColors({
+            useColor: true
+        });
+        const { white, bgRed, red, yellow, green, blue, gray, cyan, magenta } = availableColors;
+        const colored = {
+            default: white,
+            60: bgRed,
+            50: red,
+            40: yellow,
+            30: green,
+            20: blue,
+            10: gray,
+            message: cyan,
+            greyMessage: gray,
+            property: magenta
+        };
+        function resolveCustomColoredColorizer(customColors) {
+            return customColors.reduce(function(agg, [level, color]) {
+                agg[level] = 'function' == typeof availableColors[color] ? availableColors[color] : white;
+                return agg;
+            }, {
+                default: white,
+                message: cyan,
+                greyMessage: gray,
+                property: magenta
+            });
+        }
+        function colorizeLevel(useOnlyCustomProps) {
+            return function(level, colorizer, { customLevels, customLevelNames } = {}) {
+                const [levelStr, levelNum] = getLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames)(level);
+                return Object.prototype.hasOwnProperty.call(colorizer, levelNum) ? colorizer[levelNum](levelStr) : colorizer.default(levelStr);
+            };
+        }
+        function plainColorizer(useOnlyCustomProps) {
+            const newPlainColorizer = colorizeLevel(useOnlyCustomProps);
+            const customColoredColorizer = function(level, opts) {
+                return newPlainColorizer(level, plain, opts);
+            };
+            customColoredColorizer.message = plain.message;
+            customColoredColorizer.greyMessage = plain.greyMessage;
+            customColoredColorizer.property = plain.property;
+            customColoredColorizer.colors = createColors({
+                useColor: false
+            });
+            return customColoredColorizer;
+        }
+        function coloredColorizer(useOnlyCustomProps) {
+            const newColoredColorizer = colorizeLevel(useOnlyCustomProps);
+            const customColoredColorizer = function(level, opts) {
+                return newColoredColorizer(level, colored, opts);
+            };
+            customColoredColorizer.message = colored.message;
+            customColoredColorizer.property = colored.property;
+            customColoredColorizer.greyMessage = colored.greyMessage;
+            customColoredColorizer.colors = availableColors;
+            return customColoredColorizer;
+        }
+        function customColoredColorizerFactory(customColors, useOnlyCustomProps) {
+            const onlyCustomColored = resolveCustomColoredColorizer(customColors);
+            const customColored = useOnlyCustomProps ? onlyCustomColored : Object.assign({}, colored, onlyCustomColored);
+            const colorizeLevelCustom = colorizeLevel(useOnlyCustomProps);
+            const customColoredColorizer = function(level, opts) {
+                return colorizeLevelCustom(level, customColored, opts);
+            };
+            customColoredColorizer.colors = availableColors;
+            customColoredColorizer.message = customColoredColorizer.message || customColored.message;
+            customColoredColorizer.property = customColoredColorizer.property || customColored.property;
+            customColoredColorizer.greyMessage = customColoredColorizer.greyMessage || customColored.greyMessage;
+            return customColoredColorizer;
+        }
+        module1.exports = function(useColors = false, customColors, useOnlyCustomProps) {
+            if (useColors && void 0 !== customColors) return customColoredColorizerFactory(customColors, useOnlyCustomProps);
+            if (useColors) return coloredColorizer(useOnlyCustomProps);
+            return plainColorizer(useOnlyCustomProps);
+        };
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js": function(module1) {
+        "use strict";
+        module1.exports = {
+            DATE_FORMAT: 'yyyy-mm-dd HH:MM:ss.l o',
+            DATE_FORMAT_SIMPLE: 'HH:MM:ss.l',
+            ERROR_LIKE_KEYS: [
+                'err',
+                'error'
+            ],
+            MESSAGE_KEY: 'msg',
+            LEVEL_KEY: 'level',
+            LEVEL_LABEL: 'levelLabel',
+            TIMESTAMP_KEY: 'time',
+            LEVELS: {
+                default: 'USERLVL',
+                60: 'FATAL',
+                50: 'ERROR',
+                40: 'WARN',
+                30: 'INFO',
+                20: 'DEBUG',
+                10: 'TRACE'
+            },
+            LEVEL_NAMES: {
+                fatal: 60,
+                error: 50,
+                warn: 40,
+                info: 30,
+                debug: 20,
+                trace: 10
+            },
+            LOGGER_KEYS: [
+                'pid',
+                'hostname',
+                'name',
+                'level',
+                'time',
+                'timestamp',
+                'caller'
+            ]
+        };
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/pretty.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = pretty;
+        const sjs = __webpack_require__("../../node_modules/.pnpm/secure-json-parse@4.0.0/node_modules/secure-json-parse/index.js");
+        const isObject = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/is-object.js");
+        const prettifyErrorLog = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-error-log.js");
+        const prettifyLevel = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-level.js");
+        const prettifyMessage = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-message.js");
+        const prettifyMetadata = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-metadata.js");
+        const prettifyObject = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-object.js");
+        const prettifyTime = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-time.js");
+        const filterLog = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/filter-log.js");
+        const { LEVELS, LEVEL_KEY, LEVEL_NAMES } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js");
+        const jsonParser = (input)=>{
+            try {
+                return {
+                    value: sjs.parse(input, {
+                        protoAction: 'remove'
+                    })
+                };
+            } catch (err) {
+                return {
+                    err
+                };
+            }
+        };
+        function pretty(inputData) {
+            let log;
+            if (isObject(inputData)) log = inputData;
+            else {
+                const parsed = jsonParser(inputData);
+                if (parsed.err || !isObject(parsed.value)) return inputData + this.EOL;
+                log = parsed.value;
+            }
+            if (this.minimumLevel) {
+                let condition;
+                condition = this.useOnlyCustomProps ? this.customLevels : void 0 !== this.customLevelNames[this.minimumLevel];
+                let minimum;
+                minimum = condition ? this.customLevelNames[this.minimumLevel] : LEVEL_NAMES[this.minimumLevel];
+                if (!minimum) minimum = 'string' == typeof this.minimumLevel ? LEVEL_NAMES[this.minimumLevel] : LEVEL_NAMES[LEVELS[this.minimumLevel].toLowerCase()];
+                const level = log[void 0 === this.levelKey ? LEVEL_KEY : this.levelKey];
+                if (level < minimum) return;
+            }
+            const prettifiedMessage = prettifyMessage({
+                log,
+                context: this.context
+            });
+            if (this.ignoreKeys || this.includeKeys) log = filterLog({
+                log,
+                context: this.context
+            });
+            const prettifiedLevel = prettifyLevel({
+                log,
+                context: {
+                    ...this.context,
+                    ...this.context.customProperties
+                }
+            });
+            const prettifiedMetadata = prettifyMetadata({
+                log,
+                context: this.context
+            });
+            const prettifiedTime = prettifyTime({
+                log,
+                context: this.context
+            });
+            let line = '';
+            if (this.levelFirst && prettifiedLevel) line = `${prettifiedLevel}`;
+            if (prettifiedTime && '' === line) line = `${prettifiedTime}`;
+            else if (prettifiedTime) line = `${line} ${prettifiedTime}`;
+            if (!this.levelFirst && prettifiedLevel) line = line.length > 0 ? `${line} ${prettifiedLevel}` : prettifiedLevel;
+            if (prettifiedMetadata) line = line.length > 0 ? `${line} ${prettifiedMetadata}:` : prettifiedMetadata;
+            if (false === line.endsWith(':') && '' !== line) line += ':';
+            if (void 0 !== prettifiedMessage) line = line.length > 0 ? `${line} ${prettifiedMessage}` : prettifiedMessage;
+            if (line.length > 0 && !this.singleLine) line += this.EOL;
+            if ('Error' === log.type && 'string' == typeof log.stack) {
+                const prettifiedErrorLog = prettifyErrorLog({
+                    log,
+                    context: this.context
+                });
+                if (this.singleLine) line += this.EOL;
+                line += prettifiedErrorLog;
+            } else if (false === this.hideObject) {
+                const skipKeys = [
+                    this.messageKey,
+                    this.levelKey,
+                    this.timestampKey
+                ].map((key)=>key.replaceAll(/\\/g, '')).filter((key)=>'string' == typeof log[key] || 'number' == typeof log[key] || 'boolean' == typeof log[key]);
+                const prettifiedObject = prettifyObject({
+                    log,
+                    skipKeys,
+                    context: this.context
+                });
+                if (this.singleLine && !/^\s$/.test(prettifiedObject)) line += ' ';
+                line += prettifiedObject;
+            }
+            return line;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/build-safe-sonic-boom.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = buildSafeSonicBoom;
+        const { isMainThread } = __webpack_require__("node:worker_threads");
+        const SonicBoom = __webpack_require__("../../node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js");
+        const noop = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/noop.js");
+        function buildSafeSonicBoom(opts) {
+            const stream = new SonicBoom(opts);
+            stream.on('error', filterBrokenPipe);
+            if (!opts.sync && isMainThread) setupOnExit(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);
+            }
+        }
+        function setupOnExit(stream) {
+            if (global.WeakRef && global.WeakMap && global.FinalizationRegistry) {
+                const onExit = __webpack_require__("../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js");
+                onExit.register(stream, autoEnd);
+                stream.on('close', function() {
+                    onExit.unregister(stream);
+                });
+            }
+        }
+        function autoEnd(stream, eventName) {
+            if (stream.destroyed) return;
+            if ('beforeExit' === eventName) {
+                stream.flush();
+                stream.on('drain', function() {
+                    stream.end();
+                });
+            } else stream.flushSync();
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/create-date.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = createDate;
+        const isValidDate = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/is-valid-date.js");
+        function createDate(epoch) {
+            let date = new Date(epoch);
+            if (isValidDate(date)) return date;
+            date = new Date(+epoch);
+            return date;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/delete-log-property.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = deleteLogProperty;
+        const getPropertyValue = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-property-value.js");
+        const splitPropertyKey = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/split-property-key.js");
+        function deleteLogProperty(log, property) {
+            const props = splitPropertyKey(property);
+            const propToDelete = props.pop();
+            log = getPropertyValue(log, props);
+            if (null !== log && 'object' == typeof log && Object.prototype.hasOwnProperty.call(log, propToDelete)) delete log[propToDelete];
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/filter-log.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = filterLog;
+        const { createCopier } = __webpack_require__("../../node_modules/.pnpm/fast-copy@3.0.2/node_modules/fast-copy/dist/cjs/index.cjs");
+        const fastCopy = createCopier({});
+        const deleteLogProperty = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/delete-log-property.js");
+        function filterLog({ log, context }) {
+            const { ignoreKeys, includeKeys } = context;
+            const logCopy = fastCopy(log);
+            if (includeKeys) {
+                const logIncluded = {};
+                includeKeys.forEach((key)=>{
+                    logIncluded[key] = logCopy[key];
+                });
+                return logIncluded;
+            }
+            ignoreKeys.forEach((ignoreKey)=>{
+                deleteLogProperty(logCopy, ignoreKey);
+            });
+            return logCopy;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/format-time.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = formatTime;
+        const { DATE_FORMAT, DATE_FORMAT_SIMPLE } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js");
+        const dateformat = __webpack_require__("../../node_modules/.pnpm/dateformat@4.6.3/node_modules/dateformat/lib/dateformat.js");
+        const createDate = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/create-date.js");
+        const isValidDate = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/is-valid-date.js");
+        function formatTime(epoch, translateTime = false) {
+            if (false === translateTime) return epoch;
+            const instant = createDate(epoch);
+            if (!isValidDate(instant)) return epoch;
+            if (true === translateTime) return dateformat(instant, DATE_FORMAT_SIMPLE);
+            const upperFormat = translateTime.toUpperCase();
+            if ('SYS:STANDARD' === upperFormat) return dateformat(instant, DATE_FORMAT);
+            const prefix = upperFormat.substr(0, 4);
+            if ('SYS:' === prefix || 'UTC:' === prefix) {
+                if ('UTC:' === prefix) return dateformat(instant, translateTime);
+                return dateformat(instant, translateTime.slice(4));
+            }
+            return dateformat(instant, `UTC:${translateTime}`);
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-level-label-data.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = getLevelLabelData;
+        const { LEVELS, LEVEL_NAMES } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js");
+        function getLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames) {
+            const levels = useOnlyCustomProps ? customLevels || LEVELS : Object.assign({}, LEVELS, customLevels);
+            const levelNames = useOnlyCustomProps ? customLevelNames || LEVEL_NAMES : Object.assign({}, LEVEL_NAMES, customLevelNames);
+            return function(level) {
+                let levelNum = 'default';
+                levelNum = Number.isInteger(+level) ? Object.prototype.hasOwnProperty.call(levels, level) ? level : levelNum : Object.prototype.hasOwnProperty.call(levelNames, level.toLowerCase()) ? levelNames[level.toLowerCase()] : levelNum;
+                return [
+                    levels[levelNum],
+                    levelNum
+                ];
+            };
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-property-value.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = getPropertyValue;
+        const splitPropertyKey = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/split-property-key.js");
+        function getPropertyValue(obj, property) {
+            const props = Array.isArray(property) ? property : splitPropertyKey(property);
+            for (const prop of props){
+                if (!Object.prototype.hasOwnProperty.call(obj, prop)) return;
+                obj = obj[prop];
+            }
+            return obj;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.js": function(module1) {
+        "use strict";
+        module1.exports = handleCustomLevelsNamesOpts;
+        function handleCustomLevelsNamesOpts(cLevels) {
+            if (!cLevels) return {};
+            if ('string' == typeof cLevels) return cLevels.split(',').reduce((agg, value, idx)=>{
+                const [levelName, levelNum = idx] = value.split(':');
+                agg[levelName.toLowerCase()] = levelNum;
+                return agg;
+            }, {});
+            if ('[object Object]' === Object.prototype.toString.call(cLevels)) return Object.keys(cLevels).reduce((agg, levelName)=>{
+                agg[levelName.toLowerCase()] = cLevels[levelName];
+                return agg;
+            }, {});
+            return {};
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.js": function(module1) {
+        "use strict";
+        module1.exports = handleCustomLevelsOpts;
+        function handleCustomLevelsOpts(cLevels) {
+            if (!cLevels) return {};
+            if ('string' == typeof cLevels) return cLevels.split(',').reduce((agg, value, idx)=>{
+                const [levelName, levelNum = idx] = value.split(':');
+                agg[levelNum] = levelName.toUpperCase();
+                return agg;
+            }, {
+                default: 'USERLVL'
+            });
+            if ('[object Object]' === Object.prototype.toString.call(cLevels)) return Object.keys(cLevels).reduce((agg, levelName)=>{
+                agg[cLevels[levelName]] = levelName.toUpperCase();
+                return agg;
+            }, {
+                default: 'USERLVL'
+            });
+            return {};
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = {
+            buildSafeSonicBoom: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/build-safe-sonic-boom.js"),
+            createDate: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/create-date.js"),
+            deleteLogProperty: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/delete-log-property.js"),
+            filterLog: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/filter-log.js"),
+            formatTime: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/format-time.js"),
+            getPropertyValue: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-property-value.js"),
+            handleCustomLevelsNamesOpts: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.js"),
+            handleCustomLevelsOpts: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.js"),
+            interpretConditionals: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/interpret-conditionals.js"),
+            isObject: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/is-object.js"),
+            isValidDate: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/is-valid-date.js"),
+            joinLinesWithIndentation: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js"),
+            noop: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/noop.js"),
+            parseFactoryOptions: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/parse-factory-options.js"),
+            prettifyErrorLog: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-error-log.js"),
+            prettifyError: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-error.js"),
+            prettifyLevel: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-level.js"),
+            prettifyMessage: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-message.js"),
+            prettifyMetadata: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-metadata.js"),
+            prettifyObject: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-object.js"),
+            prettifyTime: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-time.js"),
+            splitPropertyKey: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/split-property-key.js"),
+            getLevelLabelData: __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-level-label-data.js")
+        };
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/interpret-conditionals.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = interpretConditionals;
+        const getPropertyValue = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-property-value.js");
+        function interpretConditionals(messageFormat, log) {
+            messageFormat = messageFormat.replace(/{if (.*?)}(.*?){end}/g, replacer);
+            messageFormat = messageFormat.replace(/{if (.*?)}/g, '');
+            messageFormat = messageFormat.replace(/{end}/g, '');
+            return messageFormat.replace(/\s+/g, ' ').trim();
+            function replacer(_, key, value) {
+                const propertyValue = getPropertyValue(log, key);
+                if (propertyValue && value.includes(key)) return value.replace(new RegExp('{' + key + '}', 'g'), propertyValue);
+                return '';
+            }
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/is-object.js": function(module1) {
+        "use strict";
+        module1.exports = isObject;
+        function isObject(input) {
+            return '[object Object]' === Object.prototype.toString.apply(input);
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/is-valid-date.js": function(module1) {
+        "use strict";
+        module1.exports = isValidDate;
+        function isValidDate(date) {
+            return date instanceof Date && !Number.isNaN(date.getTime());
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js": function(module1) {
+        "use strict";
+        module1.exports = joinLinesWithIndentation;
+        function joinLinesWithIndentation({ input, ident = '    ', eol = '\n' }) {
+            const lines = input.split(/\r?\n/);
+            for(let i = 1; i < lines.length; i += 1)lines[i] = ident + lines[i];
+            return lines.join(eol);
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/noop.js": function(module1) {
+        "use strict";
+        module1.exports = function() {};
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/parse-factory-options.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = parseFactoryOptions;
+        const { LEVEL_NAMES } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js");
+        const colors = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/colors.js");
+        const handleCustomLevelsOpts = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.js");
+        const handleCustomLevelsNamesOpts = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.js");
+        const handleLevelLabelData = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-level-label-data.js");
+        function parseFactoryOptions(options) {
+            const EOL = options.crlf ? '\r\n' : '\n';
+            const IDENT = '    ';
+            const { customPrettifiers, errorLikeObjectKeys, hideObject, levelFirst, levelKey, levelLabel, messageFormat, messageKey, minimumLevel, singleLine, timestampKey, translateTime } = options;
+            const errorProps = options.errorProps.split(',');
+            const useOnlyCustomProps = 'boolean' == typeof options.useOnlyCustomProps ? options.useOnlyCustomProps : 'true' === options.useOnlyCustomProps;
+            const customLevels = handleCustomLevelsOpts(options.customLevels);
+            const customLevelNames = handleCustomLevelsNamesOpts(options.customLevels);
+            const getLevelLabelData = handleLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames);
+            let customColors;
+            if (options.customColors) if ('string' == typeof options.customColors) customColors = options.customColors.split(',').reduce((agg, value)=>{
+                const [level, color] = value.split(':');
+                const condition = useOnlyCustomProps ? options.customLevels : void 0 !== customLevelNames[level];
+                const levelNum = condition ? customLevelNames[level] : LEVEL_NAMES[level];
+                const colorIdx = void 0 !== levelNum ? levelNum : level;
+                agg.push([
+                    colorIdx,
+                    color
+                ]);
+                return agg;
+            }, []);
+            else if ('object' == typeof options.customColors) customColors = Object.keys(options.customColors).reduce((agg, value)=>{
+                const [level, color] = [
+                    value,
+                    options.customColors[value]
+                ];
+                const condition = useOnlyCustomProps ? options.customLevels : void 0 !== customLevelNames[level];
+                const levelNum = condition ? customLevelNames[level] : LEVEL_NAMES[level];
+                const colorIdx = void 0 !== levelNum ? levelNum : level;
+                agg.push([
+                    colorIdx,
+                    color
+                ]);
+                return agg;
+            }, []);
+            else throw new Error('options.customColors must be of type string or object.');
+            const customProperties = {
+                customLevels,
+                customLevelNames
+            };
+            if (true === useOnlyCustomProps && !options.customLevels) {
+                customProperties.customLevels = void 0;
+                customProperties.customLevelNames = void 0;
+            }
+            const includeKeys = void 0 !== options.include ? new Set(options.include.split(',')) : void 0;
+            const ignoreKeys = !includeKeys && options.ignore ? new Set(options.ignore.split(',')) : void 0;
+            const colorizer = colors(options.colorize, customColors, useOnlyCustomProps);
+            const objectColorizer = options.colorizeObjects ? colorizer : colors(false, [], false);
+            return {
+                EOL,
+                IDENT,
+                colorizer,
+                customColors,
+                customLevelNames,
+                customLevels,
+                customPrettifiers,
+                customProperties,
+                errorLikeObjectKeys,
+                errorProps,
+                getLevelLabelData,
+                hideObject,
+                ignoreKeys,
+                includeKeys,
+                levelFirst,
+                levelKey,
+                levelLabel,
+                messageFormat,
+                messageKey,
+                minimumLevel,
+                objectColorizer,
+                singleLine,
+                timestampKey,
+                translateTime,
+                useOnlyCustomProps
+            };
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-error-log.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = prettifyErrorLog;
+        const { LOGGER_KEYS } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js");
+        const isObject = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/is-object.js");
+        const joinLinesWithIndentation = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js");
+        const prettifyObject = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-object.js");
+        function prettifyErrorLog({ log, context }) {
+            const { EOL: eol, IDENT: ident, errorProps: errorProperties, messageKey } = context;
+            const stack = log.stack;
+            const joinedLines = joinLinesWithIndentation({
+                input: stack,
+                ident,
+                eol
+            });
+            let result = `${ident}${joinedLines}${eol}`;
+            if (errorProperties.length > 0) {
+                const excludeProperties = LOGGER_KEYS.concat(messageKey, 'type', 'stack');
+                let propertiesToPrint;
+                propertiesToPrint = '*' === errorProperties[0] ? Object.keys(log).filter((k)=>false === excludeProperties.includes(k)) : errorProperties.filter((k)=>false === excludeProperties.includes(k));
+                for(let i = 0; i < propertiesToPrint.length; i += 1){
+                    const key = propertiesToPrint[i];
+                    if (key in log !== false) {
+                        if (isObject(log[key])) {
+                            const prettifiedObject = prettifyObject({
+                                log: log[key],
+                                excludeLoggerKeys: false,
+                                context: {
+                                    ...context,
+                                    IDENT: ident + ident
+                                }
+                            });
+                            result = `${result}${ident}${key}: {${eol}${prettifiedObject}${ident}}${eol}`;
+                            continue;
+                        }
+                        result = `${result}${ident}${key}: ${log[key]}${eol}`;
+                    }
+                }
+            }
+            return result;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-error.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = prettifyError;
+        const joinLinesWithIndentation = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js");
+        function prettifyError({ keyName, lines, eol, ident }) {
+            let result = '';
+            const joinedLines = joinLinesWithIndentation({
+                input: lines,
+                ident,
+                eol
+            });
+            const splitLines = `${ident}${keyName}: ${joinedLines}${eol}`.split(eol);
+            for(let j = 0; j < splitLines.length; j += 1){
+                if (0 !== j) result += eol;
+                const line = splitLines[j];
+                if (/^\s*"stack"/.test(line)) {
+                    const matches = /^(\s*"stack":)\s*(".*"),?$/.exec(line);
+                    if (matches && 3 === matches.length) {
+                        const indentSize = /^\s*/.exec(line)[0].length + 4;
+                        const indentation = ' '.repeat(indentSize);
+                        const stackMessage = matches[2];
+                        result += matches[1] + eol + indentation + JSON.parse(stackMessage).replace(/\n/g, eol + indentation);
+                    } else result += line;
+                } else result += line;
+            }
+            return result;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-level.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = prettifyLevel;
+        const getPropertyValue = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-property-value.js");
+        function prettifyLevel({ log, context }) {
+            const { colorizer, customLevels, customLevelNames, levelKey, getLevelLabelData } = context;
+            const prettifier = context.customPrettifiers?.level;
+            const output = getPropertyValue(log, levelKey);
+            if (void 0 === output) return;
+            const labelColorized = colorizer(output, {
+                customLevels,
+                customLevelNames
+            });
+            if (prettifier) {
+                const [label] = getLevelLabelData(output);
+                return prettifier(output, levelKey, log, {
+                    label,
+                    labelColorized,
+                    colors: colorizer.colors
+                });
+            }
+            return labelColorized;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-message.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = prettifyMessage;
+        const { LEVELS } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js");
+        const getPropertyValue = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/get-property-value.js");
+        const interpretConditionals = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/interpret-conditionals.js");
+        function prettifyMessage({ log, context }) {
+            const { colorizer, customLevels, levelKey, levelLabel, messageFormat, messageKey, useOnlyCustomProps } = context;
+            if (messageFormat && 'string' == typeof messageFormat) {
+                const parsedMessageFormat = interpretConditionals(messageFormat, log);
+                const message = String(parsedMessageFormat).replace(/{([^{}]+)}/g, function(match, p1) {
+                    let level;
+                    if (p1 === levelLabel && void 0 !== (level = getPropertyValue(log, levelKey))) {
+                        const condition = useOnlyCustomProps ? void 0 === customLevels : void 0 === customLevels[level];
+                        return condition ? LEVELS[level] : customLevels[level];
+                    }
+                    return getPropertyValue(log, p1) || '';
+                });
+                return colorizer.message(message);
+            }
+            if (messageFormat && 'function' == typeof messageFormat) {
+                const msg = messageFormat(log, messageKey, levelLabel, {
+                    colors: colorizer.colors
+                });
+                return colorizer.message(msg);
+            }
+            if (messageKey in log === false) return;
+            if ('string' != typeof log[messageKey] && 'number' != typeof log[messageKey] && 'boolean' != typeof log[messageKey]) return;
+            return colorizer.message(log[messageKey]);
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-metadata.js": function(module1) {
+        "use strict";
+        module1.exports = prettifyMetadata;
+        function prettifyMetadata({ log, context }) {
+            const { customPrettifiers: prettifiers, colorizer } = context;
+            let line = '';
+            if (log.name || log.pid || log.hostname) {
+                line += '(';
+                if (log.name) line += prettifiers.name ? prettifiers.name(log.name, 'name', log, {
+                    colors: colorizer.colors
+                }) : log.name;
+                if (log.pid) {
+                    const prettyPid = prettifiers.pid ? prettifiers.pid(log.pid, 'pid', log, {
+                        colors: colorizer.colors
+                    }) : log.pid;
+                    if (log.name && log.pid) line += '/' + prettyPid;
+                    else line += prettyPid;
+                }
+                if (log.hostname) {
+                    const prettyHostname = prettifiers.hostname ? prettifiers.hostname(log.hostname, 'hostname', log, {
+                        colors: colorizer.colors
+                    }) : log.hostname;
+                    line += `${'(' === line ? 'on' : ' on'} ${prettyHostname}`;
+                }
+                line += ')';
+            }
+            if (log.caller) {
+                const prettyCaller = prettifiers.caller ? prettifiers.caller(log.caller, 'caller', log, {
+                    colors: colorizer.colors
+                }) : log.caller;
+                line += `${'' === line ? '' : ' '}<${prettyCaller}>`;
+            }
+            if ('' === line) return;
+            return line;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-object.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = prettifyObject;
+        const { LOGGER_KEYS } = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/constants.js");
+        const stringifySafe = __webpack_require__("../../node_modules/.pnpm/fast-safe-stringify@2.1.1/node_modules/fast-safe-stringify/index.js");
+        const joinLinesWithIndentation = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js");
+        const prettifyError = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-error.js");
+        function prettifyObject({ log, excludeLoggerKeys = true, skipKeys = [], context }) {
+            const { EOL: eol, IDENT: ident, customPrettifiers, errorLikeObjectKeys: errorLikeKeys, objectColorizer, singleLine, colorizer } = context;
+            const keysToIgnore = [].concat(skipKeys);
+            if (true === excludeLoggerKeys) Array.prototype.push.apply(keysToIgnore, LOGGER_KEYS);
+            let result = '';
+            const { plain, errors } = Object.entries(log).reduce(({ plain, errors }, [k, v])=>{
+                if (false === keysToIgnore.includes(k)) {
+                    const pretty = 'function' == typeof customPrettifiers[k] ? customPrettifiers[k](v, k, log, {
+                        colors: colorizer.colors
+                    }) : v;
+                    if (errorLikeKeys.includes(k)) errors[k] = pretty;
+                    else plain[k] = pretty;
+                }
+                return {
+                    plain,
+                    errors
+                };
+            }, {
+                plain: {},
+                errors: {}
+            });
+            if (singleLine) {
+                if (Object.keys(plain).length > 0) result += objectColorizer.greyMessage(stringifySafe(plain));
+                result += eol;
+                result = result.replace(/\\\\/gi, '\\');
+            } else Object.entries(plain).forEach(([keyName, keyValue])=>{
+                let lines = 'function' == typeof customPrettifiers[keyName] ? keyValue : stringifySafe(keyValue, null, 2);
+                if (void 0 === lines) return;
+                lines = lines.replace(/\\\\/gi, '\\');
+                const joinedLines = joinLinesWithIndentation({
+                    input: lines,
+                    ident,
+                    eol
+                });
+                result += `${ident}${objectColorizer.property(keyName)}:${joinedLines.startsWith(eol) ? '' : ' '}${joinedLines}${eol}`;
+            });
+            Object.entries(errors).forEach(([keyName, keyValue])=>{
+                const lines = 'function' == typeof customPrettifiers[keyName] ? keyValue : stringifySafe(keyValue, null, 2);
+                if (void 0 === lines) return;
+                result += prettifyError({
+                    keyName,
+                    lines,
+                    eol,
+                    ident
+                });
+            });
+            return result;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/prettify-time.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = prettifyTime;
+        const formatTime = __webpack_require__("../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/format-time.js");
+        function prettifyTime({ log, context }) {
+            const { timestampKey, translateTime: translateFormat } = context;
+            const prettifier = context.customPrettifiers?.time;
+            let time = null;
+            if (timestampKey in log) time = log[timestampKey];
+            else if ('timestamp' in log) time = log.timestamp;
+            if (null === time) return;
+            const output = translateFormat ? formatTime(time, translateFormat) : time;
+            return prettifier ? prettifier(output) : `[${output}]`;
+        }
+    },
+    "../../node_modules/.pnpm/pino-pretty@13.1.2/node_modules/pino-pretty/lib/utils/split-property-key.js": function(module1) {
+        "use strict";
+        module1.exports = splitPropertyKey;
+        function splitPropertyKey(key) {
+            const result = [];
+            let backslash = false;
+            let segment = '';
+            for(let i = 0; i < key.length; i++){
+                const c = key.charAt(i);
+                if ('\\' === c) {
+                    backslash = true;
+                    continue;
+                }
+                if (backslash) {
+                    backslash = false;
+                    segment += c;
+                    continue;
+                }
+                if ('.' === c) {
+                    result.push(segment);
+                    segment = '';
+                    continue;
+                }
+                segment += c;
+            }
+            if (segment.length) result.push(segment);
+            return result;
+        }
+    },
+    "../../node_modules/.pnpm/secure-json-parse@4.0.0/node_modules/secure-json-parse/index.js": function(module1) {
+        "use strict";
+        const hasBuffer = 'undefined' != typeof Buffer;
+        const suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
+        const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+        function _parse(text, reviver, options) {
+            if (null == options) {
+                if (null !== reviver && 'object' == typeof reviver) {
+                    options = reviver;
+                    reviver = void 0;
+                }
+            }
+            if (hasBuffer && Buffer.isBuffer(text)) text = text.toString();
+            if (text && 0xFEFF === text.charCodeAt(0)) text = text.slice(1);
+            const obj = JSON.parse(text, reviver);
+            if (null === obj || 'object' != typeof obj) return obj;
+            const protoAction = options && options.protoAction || 'error';
+            const constructorAction = options && options.constructorAction || 'error';
+            if ('ignore' === protoAction && 'ignore' === constructorAction) return obj;
+            if ('ignore' !== protoAction && 'ignore' !== constructorAction) {
+                if (false === suspectProtoRx.test(text) && false === suspectConstructorRx.test(text)) return obj;
+            } else if ('ignore' !== protoAction && 'ignore' === constructorAction) {
+                if (false === suspectProtoRx.test(text)) return obj;
+            } else if (false === suspectConstructorRx.test(text)) return obj;
+            return filter(obj, {
+                protoAction,
+                constructorAction,
+                safe: options && options.safe
+            });
+        }
+        function filter(obj, { protoAction = 'error', constructorAction = 'error', safe } = {}) {
+            let next = [
+                obj
+            ];
+            while(next.length){
+                const nodes = next;
+                next = [];
+                for (const node of nodes){
+                    if ('ignore' !== protoAction && Object.prototype.hasOwnProperty.call(node, '__proto__')) {
+                        if (true === safe) return null;
+                        if ('error' === protoAction) throw new SyntaxError('Object contains forbidden prototype property');
+                        delete node.__proto__;
+                    }
+                    if ('ignore' !== constructorAction && Object.prototype.hasOwnProperty.call(node, 'constructor') && Object.prototype.hasOwnProperty.call(node.constructor, 'prototype')) {
+                        if (true === safe) return null;
+                        if ('error' === constructorAction) throw new SyntaxError('Object contains forbidden prototype property');
+                        delete node.constructor;
+                    }
+                    for(const key in node){
+                        const value = node[key];
+                        if (value && 'object' == typeof value) next.push(value);
+                    }
+                }
+            }
+            return obj;
+        }
+        function parse(text, reviver, options) {
+            const { stackTraceLimit } = Error;
+            Error.stackTraceLimit = 0;
+            try {
+                return _parse(text, reviver, options);
+            } finally{
+                Error.stackTraceLimit = stackTraceLimit;
+            }
+        }
+        function safeParse(text, reviver) {
+            const { stackTraceLimit } = Error;
+            Error.stackTraceLimit = 0;
+            try {
+                return _parse(text, reviver, {
+                    safe: true
+                });
+            } catch  {
+                return;
+            } finally{
+                Error.stackTraceLimit = stackTraceLimit;
+            }
+        }
+        module1.exports = parse;
+        module1.exports["default"] = parse;
+        module1.exports.parse = parse;
+        module1.exports.safeParse = safeParse;
+        module1.exports.scan = filter;
+    },
+    "../../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, n)=>{
+                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', n);
+                const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n);
+                this._len = releasedBufObj.len;
+                this._writingBuf = releasedBufObj.writingBuf;
+                if (this._writingBuf.length) {
+                    if (!this.sync) return void fsWrite();
+                    try {
+                        do {
+                            const n = fsWriteSync();
+                            const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n);
+                            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, n) {
+            if ('string' == typeof writingBuf && Buffer.byteLength(writingBuf) !== n) n = Buffer.from(writingBuf).subarray(0, n).toString().length;
+            len = Math.max(len - n, 0);
+            writingBuf = writingBuf.slice(n);
+            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 n = fs.writeSync(this.fd, buf, 'utf8');
+                    const releasedBufObj = releaseWritingBuf(buf, this._len, n);
+                    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 n = fs.writeSync(this.fd, buf);
+                    buf = buf.subarray(n);
+                    this._len = Math.max(this._len - n, 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;
+    }
+};
+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-pretty@13.1.2/node_modules/pino-pretty/index.js");
+module.exports = __webpack_exports__;