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

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

@@ -0,0 +1,3353 @@
+var __webpack_modules__ = {
+    "../../node_modules/.pnpm/@pinojs+redact@0.4.0/node_modules/@pinojs/redact/index.js": function(module1) {
+        "use strict";
+        function deepClone(obj) {
+            if (null === obj || 'object' != typeof obj) return obj;
+            if (obj instanceof Date) return new Date(obj.getTime());
+            if (obj instanceof Array) {
+                const cloned = [];
+                for(let i = 0; i < obj.length; i++)cloned[i] = deepClone(obj[i]);
+                return cloned;
+            }
+            if ('object' == typeof obj) {
+                const cloned = Object.create(Object.getPrototypeOf(obj));
+                for(const key in obj)if (Object.prototype.hasOwnProperty.call(obj, key)) cloned[key] = deepClone(obj[key]);
+                return cloned;
+            }
+            return obj;
+        }
+        function parsePath(path) {
+            const parts = [];
+            let current = '';
+            let inBrackets = false;
+            let inQuotes = false;
+            let quoteChar = '';
+            for(let i = 0; i < path.length; i++){
+                const char = path[i];
+                if (inBrackets || '.' !== char) if ('[' === char) {
+                    if (current) {
+                        parts.push(current);
+                        current = '';
+                    }
+                    inBrackets = true;
+                } else if (']' === char && inBrackets) {
+                    parts.push(current);
+                    current = '';
+                    inBrackets = false;
+                    inQuotes = false;
+                } else if (('"' === char || "'" === char) && inBrackets) if (inQuotes) if (char === quoteChar) {
+                    inQuotes = false;
+                    quoteChar = '';
+                } else current += char;
+                else {
+                    inQuotes = true;
+                    quoteChar = char;
+                }
+                else current += char;
+                else if (current) {
+                    parts.push(current);
+                    current = '';
+                }
+            }
+            if (current) parts.push(current);
+            return parts;
+        }
+        function setValue(obj, parts, value) {
+            let current = obj;
+            for(let i = 0; i < parts.length - 1; i++){
+                const key = parts[i];
+                if ('object' != typeof current || null === current || !(key in current)) return false;
+                if ('object' != typeof current[key] || null === current[key]) return false;
+                current = current[key];
+            }
+            const lastKey = parts[parts.length - 1];
+            if ('*' === lastKey) {
+                if (Array.isArray(current)) for(let i = 0; i < current.length; i++)current[i] = value;
+                else if ('object' == typeof current && null !== current) {
+                    for(const key in current)if (Object.prototype.hasOwnProperty.call(current, key)) current[key] = value;
+                }
+            } else if ('object' == typeof current && null !== current && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) current[lastKey] = value;
+            return true;
+        }
+        function removeKey(obj, parts) {
+            let current = obj;
+            for(let i = 0; i < parts.length - 1; i++){
+                const key = parts[i];
+                if ('object' != typeof current || null === current || !(key in current)) return false;
+                if ('object' != typeof current[key] || null === current[key]) return false;
+                current = current[key];
+            }
+            const lastKey = parts[parts.length - 1];
+            if ('*' === lastKey) {
+                if (Array.isArray(current)) for(let i = 0; i < current.length; i++)current[i] = void 0;
+                else if ('object' == typeof current && null !== current) {
+                    for(const key in current)if (Object.prototype.hasOwnProperty.call(current, key)) delete current[key];
+                }
+            } else if ('object' == typeof current && null !== current && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey)) delete current[lastKey];
+            return true;
+        }
+        const PATH_NOT_FOUND = Symbol('PATH_NOT_FOUND');
+        function getValueIfExists(obj, parts) {
+            let current = obj;
+            for (const part of parts){
+                if (null == current) return PATH_NOT_FOUND;
+                if ('object' != typeof current || null === current) return PATH_NOT_FOUND;
+                if (!(part in current)) return PATH_NOT_FOUND;
+                current = current[part];
+            }
+            return current;
+        }
+        function getValue(obj, parts) {
+            let current = obj;
+            for (const part of parts){
+                if (null == current) return;
+                if ('object' != typeof current || null === current) return;
+                current = current[part];
+            }
+            return current;
+        }
+        function redactPaths(obj, paths, censor, remove = false) {
+            for (const path of paths){
+                const parts = parsePath(path);
+                if (parts.includes('*')) redactWildcardPath(obj, parts, censor, path, remove);
+                else if (remove) removeKey(obj, parts);
+                else {
+                    const value = getValueIfExists(obj, parts);
+                    if (value === PATH_NOT_FOUND) continue;
+                    const actualCensor = 'function' == typeof censor ? censor(value, parts) : censor;
+                    setValue(obj, parts, actualCensor);
+                }
+            }
+        }
+        function redactWildcardPath(obj, parts, censor, originalPath, remove = false) {
+            const wildcardIndex = parts.indexOf('*');
+            if (wildcardIndex === parts.length - 1) {
+                const parentParts = parts.slice(0, -1);
+                let current = obj;
+                for (const part of parentParts){
+                    if (null == current) return;
+                    if ('object' != typeof current || null === current) return;
+                    current = current[part];
+                }
+                if (Array.isArray(current)) if (remove) for(let i = 0; i < current.length; i++)current[i] = void 0;
+                else for(let i = 0; i < current.length; i++){
+                    const indexPath = [
+                        ...parentParts,
+                        i.toString()
+                    ];
+                    const actualCensor = 'function' == typeof censor ? censor(current[i], indexPath) : censor;
+                    current[i] = actualCensor;
+                }
+                else if ('object' == typeof current && null !== current) if (remove) {
+                    const keysToDelete = [];
+                    for(const key in current)if (Object.prototype.hasOwnProperty.call(current, key)) keysToDelete.push(key);
+                    for (const key of keysToDelete)delete current[key];
+                } else for(const key in current){
+                    const keyPath = [
+                        ...parentParts,
+                        key
+                    ];
+                    const actualCensor = 'function' == typeof censor ? censor(current[key], keyPath) : censor;
+                    current[key] = actualCensor;
+                }
+            } else redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove);
+        }
+        function redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove = false) {
+            const beforeWildcard = parts.slice(0, wildcardIndex);
+            const afterWildcard = parts.slice(wildcardIndex + 1);
+            const pathArray = [];
+            function traverse(current, pathLength) {
+                if (pathLength === beforeWildcard.length) {
+                    if (Array.isArray(current)) for(let i = 0; i < current.length; i++){
+                        pathArray[pathLength] = i.toString();
+                        traverse(current[i], pathLength + 1);
+                    }
+                    else if ('object' == typeof current && null !== current) for(const key in current){
+                        pathArray[pathLength] = key;
+                        traverse(current[key], pathLength + 1);
+                    }
+                } else if (pathLength < beforeWildcard.length) {
+                    const nextKey = beforeWildcard[pathLength];
+                    if (current && 'object' == typeof current && null !== current && nextKey in current) {
+                        pathArray[pathLength] = nextKey;
+                        traverse(current[nextKey], pathLength + 1);
+                    }
+                } else if (afterWildcard.includes('*')) {
+                    const wrappedCensor = 'function' == typeof censor ? (value, path)=>{
+                        const fullPath = [
+                            ...pathArray.slice(0, pathLength),
+                            ...path
+                        ];
+                        return censor(value, fullPath);
+                    } : censor;
+                    redactWildcardPath(current, afterWildcard, wrappedCensor, originalPath, remove);
+                } else if (remove) removeKey(current, afterWildcard);
+                else {
+                    const actualCensor = 'function' == typeof censor ? censor(getValue(current, afterWildcard), [
+                        ...pathArray.slice(0, pathLength),
+                        ...afterWildcard
+                    ]) : censor;
+                    setValue(current, afterWildcard, actualCensor);
+                }
+            }
+            if (0 === beforeWildcard.length) traverse(obj, 0);
+            else {
+                let current = obj;
+                for(let i = 0; i < beforeWildcard.length; i++){
+                    const part = beforeWildcard[i];
+                    if (null == current) return;
+                    if ('object' != typeof current || null === current) return;
+                    current = current[part];
+                    pathArray[i] = part;
+                }
+                if (null != current) traverse(current, beforeWildcard.length);
+            }
+        }
+        function buildPathStructure(pathsToClone) {
+            if (0 === pathsToClone.length) return null;
+            const pathStructure = new Map();
+            for (const path of pathsToClone){
+                const parts = parsePath(path);
+                let current = pathStructure;
+                for(let i = 0; i < parts.length; i++){
+                    const part = parts[i];
+                    if (!current.has(part)) current.set(part, new Map());
+                    current = current.get(part);
+                }
+            }
+            return pathStructure;
+        }
+        function selectiveClone(obj, pathStructure) {
+            if (!pathStructure) return obj;
+            function cloneSelectively(source, pathMap, depth = 0) {
+                if (!pathMap || 0 === pathMap.size) return source;
+                if (null === source || 'object' != typeof source) return source;
+                if (source instanceof Date) return new Date(source.getTime());
+                if (Array.isArray(source)) {
+                    const cloned = [];
+                    for(let i = 0; i < source.length; i++){
+                        const indexStr = i.toString();
+                        if (pathMap.has(indexStr) || pathMap.has('*')) cloned[i] = cloneSelectively(source[i], pathMap.get(indexStr) || pathMap.get('*'));
+                        else cloned[i] = source[i];
+                    }
+                    return cloned;
+                }
+                const cloned = Object.create(Object.getPrototypeOf(source));
+                for(const key in source)if (Object.prototype.hasOwnProperty.call(source, key)) if (pathMap.has(key) || pathMap.has('*')) cloned[key] = cloneSelectively(source[key], pathMap.get(key) || pathMap.get('*'));
+                else cloned[key] = source[key];
+                return cloned;
+            }
+            return cloneSelectively(obj, pathStructure);
+        }
+        function validatePath(path) {
+            if ('string' != typeof path) throw new Error('Paths must be (non-empty) strings');
+            if ('' === path) throw new Error('Invalid redaction path ()');
+            if (path.includes('..')) throw new Error(`Invalid redaction path (${path})`);
+            if (path.includes(',')) throw new Error(`Invalid redaction path (${path})`);
+            let bracketCount = 0;
+            let inQuotes = false;
+            let quoteChar = '';
+            for(let i = 0; i < path.length; i++){
+                const char = path[i];
+                if (('"' === char || "'" === char) && bracketCount > 0) if (inQuotes) {
+                    if (char === quoteChar) {
+                        inQuotes = false;
+                        quoteChar = '';
+                    }
+                } else {
+                    inQuotes = true;
+                    quoteChar = char;
+                }
+                else if ('[' !== char || inQuotes) {
+                    if (']' === char && !inQuotes) {
+                        bracketCount--;
+                        if (bracketCount < 0) throw new Error(`Invalid redaction path (${path})`);
+                    }
+                } else bracketCount++;
+            }
+            if (0 !== bracketCount) throw new Error(`Invalid redaction path (${path})`);
+        }
+        function validatePaths(paths) {
+            if (!Array.isArray(paths)) throw new TypeError('paths must be an array');
+            for (const path of paths)validatePath(path);
+        }
+        function slowRedact(options = {}) {
+            const { paths = [], censor = '[REDACTED]', serialize = JSON.stringify, strict = true, remove = false } = options;
+            validatePaths(paths);
+            const pathStructure = buildPathStructure(paths);
+            return function(obj) {
+                if (strict && (null === obj || 'object' != typeof obj)) {
+                    if (null == obj) return serialize ? serialize(obj) : obj;
+                    if ('object' != typeof obj) return serialize ? serialize(obj) : obj;
+                }
+                const cloned = selectiveClone(obj, pathStructure);
+                const original = obj;
+                let actualCensor = censor;
+                if ('function' == typeof censor) actualCensor = censor;
+                redactPaths(cloned, paths, actualCensor, remove);
+                if (false === serialize) {
+                    cloned.restore = function() {
+                        return deepClone(original);
+                    };
+                    return cloned;
+                }
+                if ('function' == typeof serialize) return serialize(cloned);
+                return JSON.stringify(cloned);
+            };
+        }
+        module1.exports = slowRedact;
+    },
+    "../../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/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/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js": function(module1) {
+        "use strict";
+        function tryStringify(o) {
+            try {
+                return JSON.stringify(o);
+            } catch (e) {
+                return '"[Circular]"';
+            }
+        }
+        module1.exports = format;
+        function format(f, args, opts) {
+            var ss = opts && opts.stringify || tryStringify;
+            var offset = 1;
+            if ('object' == typeof f && null !== f) {
+                var len = args.length + offset;
+                if (1 === len) return f;
+                var objects = new Array(len);
+                objects[0] = ss(f);
+                for(var index = 1; index < len; index++)objects[index] = ss(args[index]);
+                return objects.join(' ');
+            }
+            if ('string' != typeof f) return f;
+            var argLen = args.length;
+            if (0 === argLen) return f;
+            var str = '';
+            var a = 1 - offset;
+            var lastPos = -1;
+            var flen = f && f.length || 0;
+            for(var i = 0; i < flen;){
+                if (37 === f.charCodeAt(i) && i + 1 < flen) {
+                    lastPos = lastPos > -1 ? lastPos : 0;
+                    switch(f.charCodeAt(i + 1)){
+                        case 100:
+                        case 102:
+                            if (a >= argLen) break;
+                            if (null == args[a]) break;
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            str += Number(args[a]);
+                            lastPos = i + 2;
+                            i++;
+                            break;
+                        case 105:
+                            if (a >= argLen) break;
+                            if (null == args[a]) break;
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            str += Math.floor(Number(args[a]));
+                            lastPos = i + 2;
+                            i++;
+                            break;
+                        case 79:
+                        case 111:
+                        case 106:
+                            if (a >= argLen) break;
+                            if (void 0 === args[a]) break;
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            var type = typeof args[a];
+                            if ('string' === type) {
+                                str += '\'' + args[a] + '\'';
+                                lastPos = i + 2;
+                                i++;
+                                break;
+                            }
+                            if ('function' === type) {
+                                str += args[a].name || '<anonymous>';
+                                lastPos = i + 2;
+                                i++;
+                                break;
+                            }
+                            str += ss(args[a]);
+                            lastPos = i + 2;
+                            i++;
+                            break;
+                        case 115:
+                            if (a >= argLen) break;
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            str += String(args[a]);
+                            lastPos = i + 2;
+                            i++;
+                            break;
+                        case 37:
+                            if (lastPos < i) str += f.slice(lastPos, i);
+                            str += '%';
+                            lastPos = i + 2;
+                            i++;
+                            a--;
+                            break;
+                    }
+                    ++a;
+                }
+                ++i;
+            }
+            if (-1 === lastPos) return f;
+            if (lastPos < flen) str += f.slice(lastPos);
+            return str;
+        }
+    },
+    "../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js": function(module1, exports) {
+        "use strict";
+        const { hasOwnProperty } = Object.prototype;
+        const stringify = configure();
+        stringify.configure = configure;
+        stringify.stringify = stringify;
+        stringify.default = stringify;
+        exports.stringify = stringify;
+        exports.configure = configure;
+        module1.exports = stringify;
+        const strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+        function strEscape(str) {
+            if (str.length < 5000 && !strEscapeSequencesRegExp.test(str)) return `"${str}"`;
+            return JSON.stringify(str);
+        }
+        function sort(array, comparator) {
+            if (array.length > 2e2 || comparator) return array.sort(comparator);
+            for(let i = 1; i < array.length; i++){
+                const currentValue = array[i];
+                let position = i;
+                while(0 !== position && array[position - 1] > currentValue){
+                    array[position] = array[position - 1];
+                    position--;
+                }
+                array[position] = currentValue;
+            }
+            return array;
+        }
+        const typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Object.getPrototypeOf(new Int8Array())), Symbol.toStringTag).get;
+        function isTypedArrayWithEntries(value) {
+            return void 0 !== typedArrayPrototypeGetSymbolToStringTag.call(value) && 0 !== value.length;
+        }
+        function stringifyTypedArray(array, separator, maximumBreadth) {
+            if (array.length < maximumBreadth) maximumBreadth = array.length;
+            const whitespace = ',' === separator ? '' : ' ';
+            let res = `"0":${whitespace}${array[0]}`;
+            for(let i = 1; i < maximumBreadth; i++)res += `${separator}"${i}":${whitespace}${array[i]}`;
+            return res;
+        }
+        function getCircularValueOption(options) {
+            if (hasOwnProperty.call(options, 'circularValue')) {
+                const circularValue = options.circularValue;
+                if ('string' == typeof circularValue) return `"${circularValue}"`;
+                if (null == circularValue) return circularValue;
+                if (circularValue === Error || circularValue === TypeError) return {
+                    toString () {
+                        throw new TypeError('Converting circular structure to JSON');
+                    }
+                };
+                throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
+            }
+            return '"[Circular]"';
+        }
+        function getDeterministicOption(options) {
+            let value;
+            if (hasOwnProperty.call(options, 'deterministic')) {
+                value = options.deterministic;
+                if ('boolean' != typeof value && 'function' != typeof value) throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
+            }
+            return void 0 === value ? true : value;
+        }
+        function getBooleanOption(options, key) {
+            let value;
+            if (hasOwnProperty.call(options, key)) {
+                value = options[key];
+                if ('boolean' != typeof value) throw new TypeError(`The "${key}" argument must be of type boolean`);
+            }
+            return void 0 === value ? true : value;
+        }
+        function getPositiveIntegerOption(options, key) {
+            let value;
+            if (hasOwnProperty.call(options, key)) {
+                value = options[key];
+                if ('number' != typeof value) throw new TypeError(`The "${key}" argument must be of type number`);
+                if (!Number.isInteger(value)) throw new TypeError(`The "${key}" argument must be an integer`);
+                if (value < 1) throw new RangeError(`The "${key}" argument must be >= 1`);
+            }
+            return void 0 === value ? 1 / 0 : value;
+        }
+        function getItemCount(number) {
+            if (1 === number) return '1 item';
+            return `${number} items`;
+        }
+        function getUniqueReplacerSet(replacerArray) {
+            const replacerSet = new Set();
+            for (const value of replacerArray)if ('string' == typeof value || 'number' == typeof value) replacerSet.add(String(value));
+            return replacerSet;
+        }
+        function getStrictOption(options) {
+            if (hasOwnProperty.call(options, 'strict')) {
+                const value = options.strict;
+                if ('boolean' != typeof value) throw new TypeError('The "strict" argument must be of type boolean');
+                if (value) return (value)=>{
+                    let message = `Object can not safely be stringified. Received type ${typeof value}`;
+                    if ('function' != typeof value) message += ` (${value.toString()})`;
+                    throw new Error(message);
+                };
+            }
+        }
+        function configure(options) {
+            options = {
+                ...options
+            };
+            const fail = getStrictOption(options);
+            if (fail) {
+                if (void 0 === options.bigint) options.bigint = false;
+                if (!('circularValue' in options)) options.circularValue = Error;
+            }
+            const circularValue = getCircularValueOption(options);
+            const bigint = getBooleanOption(options, 'bigint');
+            const deterministic = getDeterministicOption(options);
+            const comparator = 'function' == typeof deterministic ? deterministic : void 0;
+            const maximumDepth = getPositiveIntegerOption(options, 'maximumDepth');
+            const maximumBreadth = getPositiveIntegerOption(options, 'maximumBreadth');
+            function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
+                let value = parent[key];
+                if ('object' == typeof value && null !== value && 'function' == typeof value.toJSON) value = value.toJSON(key);
+                value = replacer.call(parent, key, value);
+                switch(typeof value){
+                    case 'string':
+                        return strEscape(value);
+                    case 'object':
+                        {
+                            if (null === value) return 'null';
+                            if (-1 !== stack.indexOf(value)) return circularValue;
+                            let res = '';
+                            let join = ',';
+                            const originalIndentation = indentation;
+                            if (Array.isArray(value)) {
+                                if (0 === value.length) return '[]';
+                                if (maximumDepth < stack.length + 1) return '"[Array]"';
+                                stack.push(value);
+                                if ('' !== spacer) {
+                                    indentation += spacer;
+                                    res += `\n${indentation}`;
+                                    join = `,\n${indentation}`;
+                                }
+                                const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+                                let i = 0;
+                                for(; i < maximumValuesToStringify - 1; i++){
+                                    const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+                                    res += void 0 !== tmp ? tmp : 'null';
+                                    res += join;
+                                }
+                                const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+                                res += void 0 !== tmp ? tmp : 'null';
+                                if (value.length - 1 > maximumBreadth) {
+                                    const removedKeys = value.length - maximumBreadth - 1;
+                                    res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+                                }
+                                if ('' !== spacer) res += `\n${originalIndentation}`;
+                                stack.pop();
+                                return `[${res}]`;
+                            }
+                            let keys = Object.keys(value);
+                            const keyLength = keys.length;
+                            if (0 === keyLength) return '{}';
+                            if (maximumDepth < stack.length + 1) return '"[Object]"';
+                            let whitespace = '';
+                            let separator = '';
+                            if ('' !== spacer) {
+                                indentation += spacer;
+                                join = `,\n${indentation}`;
+                                whitespace = ' ';
+                            }
+                            const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+                            if (deterministic && !isTypedArrayWithEntries(value)) keys = sort(keys, comparator);
+                            stack.push(value);
+                            for(let i = 0; i < maximumPropertiesToStringify; i++){
+                                const key = keys[i];
+                                const tmp = stringifyFnReplacer(key, value, stack, replacer, spacer, indentation);
+                                if (void 0 !== tmp) {
+                                    res += `${separator}${strEscape(key)}:${whitespace}${tmp}`;
+                                    separator = join;
+                                }
+                            }
+                            if (keyLength > maximumBreadth) {
+                                const removedKeys = keyLength - maximumBreadth;
+                                res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
+                                separator = join;
+                            }
+                            if ('' !== spacer && separator.length > 1) res = `\n${indentation}${res}\n${originalIndentation}`;
+                            stack.pop();
+                            return `{${res}}`;
+                        }
+                    case 'number':
+                        return isFinite(value) ? String(value) : fail ? fail(value) : 'null';
+                    case 'boolean':
+                        return true === value ? 'true' : 'false';
+                    case 'undefined':
+                        return;
+                    case 'bigint':
+                        if (bigint) return String(value);
+                    default:
+                        return fail ? fail(value) : void 0;
+                }
+            }
+            function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
+                if ('object' == typeof value && null !== value && 'function' == typeof value.toJSON) value = value.toJSON(key);
+                switch(typeof value){
+                    case 'string':
+                        return strEscape(value);
+                    case 'object':
+                        {
+                            if (null === value) return 'null';
+                            if (-1 !== stack.indexOf(value)) return circularValue;
+                            const originalIndentation = indentation;
+                            let res = '';
+                            let join = ',';
+                            if (Array.isArray(value)) {
+                                if (0 === value.length) return '[]';
+                                if (maximumDepth < stack.length + 1) return '"[Array]"';
+                                stack.push(value);
+                                if ('' !== spacer) {
+                                    indentation += spacer;
+                                    res += `\n${indentation}`;
+                                    join = `,\n${indentation}`;
+                                }
+                                const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+                                let i = 0;
+                                for(; i < maximumValuesToStringify - 1; i++){
+                                    const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+                                    res += void 0 !== tmp ? tmp : 'null';
+                                    res += join;
+                                }
+                                const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+                                res += void 0 !== tmp ? tmp : 'null';
+                                if (value.length - 1 > maximumBreadth) {
+                                    const removedKeys = value.length - maximumBreadth - 1;
+                                    res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+                                }
+                                if ('' !== spacer) res += `\n${originalIndentation}`;
+                                stack.pop();
+                                return `[${res}]`;
+                            }
+                            stack.push(value);
+                            let whitespace = '';
+                            if ('' !== spacer) {
+                                indentation += spacer;
+                                join = `,\n${indentation}`;
+                                whitespace = ' ';
+                            }
+                            let separator = '';
+                            for (const key of replacer){
+                                const tmp = stringifyArrayReplacer(key, value[key], stack, replacer, spacer, indentation);
+                                if (void 0 !== tmp) {
+                                    res += `${separator}${strEscape(key)}:${whitespace}${tmp}`;
+                                    separator = join;
+                                }
+                            }
+                            if ('' !== spacer && separator.length > 1) res = `\n${indentation}${res}\n${originalIndentation}`;
+                            stack.pop();
+                            return `{${res}}`;
+                        }
+                    case 'number':
+                        return isFinite(value) ? String(value) : fail ? fail(value) : 'null';
+                    case 'boolean':
+                        return true === value ? 'true' : 'false';
+                    case 'undefined':
+                        return;
+                    case 'bigint':
+                        if (bigint) return String(value);
+                    default:
+                        return fail ? fail(value) : void 0;
+                }
+            }
+            function stringifyIndent(key, value, stack, spacer, indentation) {
+                switch(typeof value){
+                    case 'string':
+                        return strEscape(value);
+                    case 'object':
+                        {
+                            if (null === value) return 'null';
+                            if ('function' == typeof value.toJSON) {
+                                value = value.toJSON(key);
+                                if ('object' != typeof value) return stringifyIndent(key, value, stack, spacer, indentation);
+                                if (null === value) return 'null';
+                            }
+                            if (-1 !== stack.indexOf(value)) return circularValue;
+                            const originalIndentation = indentation;
+                            if (Array.isArray(value)) {
+                                if (0 === value.length) return '[]';
+                                if (maximumDepth < stack.length + 1) return '"[Array]"';
+                                stack.push(value);
+                                indentation += spacer;
+                                let res = `\n${indentation}`;
+                                const join = `,\n${indentation}`;
+                                const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+                                let i = 0;
+                                for(; i < maximumValuesToStringify - 1; i++){
+                                    const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+                                    res += void 0 !== tmp ? tmp : 'null';
+                                    res += join;
+                                }
+                                const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+                                res += void 0 !== tmp ? tmp : 'null';
+                                if (value.length - 1 > maximumBreadth) {
+                                    const removedKeys = value.length - maximumBreadth - 1;
+                                    res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+                                }
+                                res += `\n${originalIndentation}`;
+                                stack.pop();
+                                return `[${res}]`;
+                            }
+                            let keys = Object.keys(value);
+                            const keyLength = keys.length;
+                            if (0 === keyLength) return '{}';
+                            if (maximumDepth < stack.length + 1) return '"[Object]"';
+                            indentation += spacer;
+                            const join = `,\n${indentation}`;
+                            let res = '';
+                            let separator = '';
+                            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+                            if (isTypedArrayWithEntries(value)) {
+                                res += stringifyTypedArray(value, join, maximumBreadth);
+                                keys = keys.slice(value.length);
+                                maximumPropertiesToStringify -= value.length;
+                                separator = join;
+                            }
+                            if (deterministic) keys = sort(keys, comparator);
+                            stack.push(value);
+                            for(let i = 0; i < maximumPropertiesToStringify; i++){
+                                const key = keys[i];
+                                const tmp = stringifyIndent(key, value[key], stack, spacer, indentation);
+                                if (void 0 !== tmp) {
+                                    res += `${separator}${strEscape(key)}: ${tmp}`;
+                                    separator = join;
+                                }
+                            }
+                            if (keyLength > maximumBreadth) {
+                                const removedKeys = keyLength - maximumBreadth;
+                                res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
+                                separator = join;
+                            }
+                            if ('' !== separator) res = `\n${indentation}${res}\n${originalIndentation}`;
+                            stack.pop();
+                            return `{${res}}`;
+                        }
+                    case 'number':
+                        return isFinite(value) ? String(value) : fail ? fail(value) : 'null';
+                    case 'boolean':
+                        return true === value ? 'true' : 'false';
+                    case 'undefined':
+                        return;
+                    case 'bigint':
+                        if (bigint) return String(value);
+                    default:
+                        return fail ? fail(value) : void 0;
+                }
+            }
+            function stringifySimple(key, value, stack) {
+                switch(typeof value){
+                    case 'string':
+                        return strEscape(value);
+                    case 'object':
+                        {
+                            if (null === value) return 'null';
+                            if ('function' == typeof value.toJSON) {
+                                value = value.toJSON(key);
+                                if ('object' != typeof value) return stringifySimple(key, value, stack);
+                                if (null === value) return 'null';
+                            }
+                            if (-1 !== stack.indexOf(value)) return circularValue;
+                            let res = '';
+                            const hasLength = void 0 !== value.length;
+                            if (hasLength && Array.isArray(value)) {
+                                if (0 === value.length) return '[]';
+                                if (maximumDepth < stack.length + 1) return '"[Array]"';
+                                stack.push(value);
+                                const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+                                let i = 0;
+                                for(; i < maximumValuesToStringify - 1; i++){
+                                    const tmp = stringifySimple(String(i), value[i], stack);
+                                    res += void 0 !== tmp ? tmp : 'null';
+                                    res += ',';
+                                }
+                                const tmp = stringifySimple(String(i), value[i], stack);
+                                res += void 0 !== tmp ? tmp : 'null';
+                                if (value.length - 1 > maximumBreadth) {
+                                    const removedKeys = value.length - maximumBreadth - 1;
+                                    res += `,"... ${getItemCount(removedKeys)} not stringified"`;
+                                }
+                                stack.pop();
+                                return `[${res}]`;
+                            }
+                            let keys = Object.keys(value);
+                            const keyLength = keys.length;
+                            if (0 === keyLength) return '{}';
+                            if (maximumDepth < stack.length + 1) return '"[Object]"';
+                            let separator = '';
+                            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+                            if (hasLength && isTypedArrayWithEntries(value)) {
+                                res += stringifyTypedArray(value, ',', maximumBreadth);
+                                keys = keys.slice(value.length);
+                                maximumPropertiesToStringify -= value.length;
+                                separator = ',';
+                            }
+                            if (deterministic) keys = sort(keys, comparator);
+                            stack.push(value);
+                            for(let i = 0; i < maximumPropertiesToStringify; i++){
+                                const key = keys[i];
+                                const tmp = stringifySimple(key, value[key], stack);
+                                if (void 0 !== tmp) {
+                                    res += `${separator}${strEscape(key)}:${tmp}`;
+                                    separator = ',';
+                                }
+                            }
+                            if (keyLength > maximumBreadth) {
+                                const removedKeys = keyLength - maximumBreadth;
+                                res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
+                            }
+                            stack.pop();
+                            return `{${res}}`;
+                        }
+                    case 'number':
+                        return isFinite(value) ? String(value) : fail ? fail(value) : 'null';
+                    case 'boolean':
+                        return true === value ? 'true' : 'false';
+                    case 'undefined':
+                        return;
+                    case 'bigint':
+                        if (bigint) return String(value);
+                    default:
+                        return fail ? fail(value) : void 0;
+                }
+            }
+            function stringify(value, replacer, space) {
+                if (arguments.length > 1) {
+                    let spacer = '';
+                    if ('number' == typeof space) spacer = ' '.repeat(Math.min(space, 10));
+                    else if ('string' == typeof space) spacer = space.slice(0, 10);
+                    if (null != replacer) {
+                        if ('function' == typeof replacer) return stringifyFnReplacer('', {
+                            '': value
+                        }, [], replacer, spacer, '');
+                        if (Array.isArray(replacer)) return stringifyArrayReplacer('', value, [], getUniqueReplacerSet(replacer), spacer, '');
+                    }
+                    if (0 !== spacer.length) return stringifyIndent('', value, [], spacer, '');
+                }
+                return stringifySimple('', value, []);
+            }
+            return stringify;
+        }
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { version } = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/package.json");
+        const { EventEmitter } = __webpack_require__("events");
+        const { Worker } = __webpack_require__("worker_threads");
+        const { join } = __webpack_require__("path");
+        const { pathToFileURL } = __webpack_require__("url");
+        const { wait } = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/wait.js");
+        const { WRITE_INDEX, READ_INDEX } = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/indexes.js");
+        const buffer = __webpack_require__("buffer");
+        const assert = __webpack_require__("assert");
+        const kImpl = Symbol('kImpl');
+        const MAX_STRING = buffer.constants.MAX_STRING_LENGTH;
+        class FakeWeakRef {
+            constructor(value){
+                this._value = value;
+            }
+            deref() {
+                return this._value;
+            }
+        }
+        class FakeFinalizationRegistry {
+            register() {}
+            unregister() {}
+        }
+        const FinalizationRegistry1 = process.env.NODE_V8_COVERAGE ? FakeFinalizationRegistry : global.FinalizationRegistry || FakeFinalizationRegistry;
+        const WeakRef1 = process.env.NODE_V8_COVERAGE ? FakeWeakRef : global.WeakRef || FakeWeakRef;
+        const registry = new FinalizationRegistry1((worker)=>{
+            if (worker.exited) return;
+            worker.terminate();
+        });
+        function createWorker(stream, opts) {
+            const { filename, workerData } = opts;
+            const bundlerOverrides = '__bundlerPathsOverrides' in globalThis ? globalThis.__bundlerPathsOverrides : {};
+            const toExecute = bundlerOverrides['thread-stream-worker'] || join(__dirname, 'lib', 'worker.js');
+            const worker = new Worker(toExecute, {
+                ...opts.workerOpts,
+                trackUnmanagedFds: false,
+                workerData: {
+                    filename: 0 === filename.indexOf('file://') ? filename : pathToFileURL(filename).href,
+                    dataBuf: stream[kImpl].dataBuf,
+                    stateBuf: stream[kImpl].stateBuf,
+                    workerData: {
+                        $context: {
+                            threadStreamVersion: version
+                        },
+                        ...workerData
+                    }
+                }
+            });
+            worker.stream = new FakeWeakRef(stream);
+            worker.on('message', onWorkerMessage);
+            worker.on('exit', onWorkerExit);
+            registry.register(stream, worker);
+            return worker;
+        }
+        function drain(stream) {
+            assert(!stream[kImpl].sync);
+            if (stream[kImpl].needDrain) {
+                stream[kImpl].needDrain = false;
+                stream.emit('drain');
+            }
+        }
+        function nextFlush(stream) {
+            const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+            let leftover = stream[kImpl].data.length - writeIndex;
+            if (leftover > 0) {
+                if (0 === stream[kImpl].buf.length) {
+                    stream[kImpl].flushing = false;
+                    if (stream[kImpl].ending) end(stream);
+                    else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
+                    return;
+                }
+                let toWrite = stream[kImpl].buf.slice(0, leftover);
+                let toWriteBytes = Buffer.byteLength(toWrite);
+                if (toWriteBytes <= leftover) {
+                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+                    write(stream, toWrite, nextFlush.bind(null, stream));
+                } else stream.flush(()=>{
+                    if (stream.destroyed) return;
+                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+                    while(toWriteBytes > stream[kImpl].data.length){
+                        leftover /= 2;
+                        toWrite = stream[kImpl].buf.slice(0, leftover);
+                        toWriteBytes = Buffer.byteLength(toWrite);
+                    }
+                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+                    write(stream, toWrite, nextFlush.bind(null, stream));
+                });
+            } else if (0 === leftover) {
+                if (0 === writeIndex && 0 === stream[kImpl].buf.length) return;
+                stream.flush(()=>{
+                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+                    nextFlush(stream);
+                });
+            } else destroy(stream, new Error('overwritten'));
+        }
+        function onWorkerMessage(msg) {
+            const stream = this.stream.deref();
+            if (void 0 === stream) {
+                this.exited = true;
+                this.terminate();
+                return;
+            }
+            switch(msg.code){
+                case 'READY':
+                    this.stream = new WeakRef1(stream);
+                    stream.flush(()=>{
+                        stream[kImpl].ready = true;
+                        stream.emit('ready');
+                    });
+                    break;
+                case 'ERROR':
+                    destroy(stream, msg.err);
+                    break;
+                case 'EVENT':
+                    if (Array.isArray(msg.args)) stream.emit(msg.name, ...msg.args);
+                    else stream.emit(msg.name, msg.args);
+                    break;
+                case 'WARNING':
+                    process.emitWarning(msg.err);
+                    break;
+                default:
+                    destroy(stream, new Error('this should not happen: ' + msg.code));
+            }
+        }
+        function onWorkerExit(code) {
+            const stream = this.stream.deref();
+            if (void 0 === stream) return;
+            registry.unregister(stream);
+            stream.worker.exited = true;
+            stream.worker.off('exit', onWorkerExit);
+            destroy(stream, 0 !== code ? new Error('the worker thread exited') : null);
+        }
+        class ThreadStream extends EventEmitter {
+            constructor(opts = {}){
+                super();
+                if (opts.bufferSize < 4) throw new Error('bufferSize must at least fit a 4-byte utf-8 char');
+                this[kImpl] = {};
+                this[kImpl].stateBuf = new SharedArrayBuffer(128);
+                this[kImpl].state = new Int32Array(this[kImpl].stateBuf);
+                this[kImpl].dataBuf = new SharedArrayBuffer(opts.bufferSize || 4194304);
+                this[kImpl].data = Buffer.from(this[kImpl].dataBuf);
+                this[kImpl].sync = opts.sync || false;
+                this[kImpl].ending = false;
+                this[kImpl].ended = false;
+                this[kImpl].needDrain = false;
+                this[kImpl].destroyed = false;
+                this[kImpl].flushing = false;
+                this[kImpl].ready = false;
+                this[kImpl].finished = false;
+                this[kImpl].errored = null;
+                this[kImpl].closed = false;
+                this[kImpl].buf = '';
+                this.worker = createWorker(this, opts);
+                this.on('message', (message, transferList)=>{
+                    this.worker.postMessage(message, transferList);
+                });
+            }
+            write(data) {
+                if (this[kImpl].destroyed) {
+                    error(this, new Error('the worker has exited'));
+                    return false;
+                }
+                if (this[kImpl].ending) {
+                    error(this, new Error('the worker is ending'));
+                    return false;
+                }
+                if (this[kImpl].flushing && this[kImpl].buf.length + data.length >= MAX_STRING) try {
+                    writeSync(this);
+                    this[kImpl].flushing = true;
+                } catch (err) {
+                    destroy(this, err);
+                    return false;
+                }
+                this[kImpl].buf += data;
+                if (this[kImpl].sync) try {
+                    writeSync(this);
+                    return true;
+                } catch (err) {
+                    destroy(this, err);
+                    return false;
+                }
+                if (!this[kImpl].flushing) {
+                    this[kImpl].flushing = true;
+                    setImmediate(nextFlush, this);
+                }
+                this[kImpl].needDrain = this[kImpl].data.length - this[kImpl].buf.length - Atomics.load(this[kImpl].state, WRITE_INDEX) <= 0;
+                return !this[kImpl].needDrain;
+            }
+            end() {
+                if (this[kImpl].destroyed) return;
+                this[kImpl].ending = true;
+                end(this);
+            }
+            flush(cb) {
+                if (this[kImpl].destroyed) {
+                    if ('function' == typeof cb) process.nextTick(cb, new Error('the worker has exited'));
+                    return;
+                }
+                const writeIndex = Atomics.load(this[kImpl].state, WRITE_INDEX);
+                wait(this[kImpl].state, READ_INDEX, writeIndex, 1 / 0, (err, res)=>{
+                    if (err) {
+                        destroy(this, err);
+                        process.nextTick(cb, err);
+                        return;
+                    }
+                    if ('not-equal' === res) return void this.flush(cb);
+                    process.nextTick(cb);
+                });
+            }
+            flushSync() {
+                if (this[kImpl].destroyed) return;
+                writeSync(this);
+                flushSync(this);
+            }
+            unref() {
+                this.worker.unref();
+            }
+            ref() {
+                this.worker.ref();
+            }
+            get ready() {
+                return this[kImpl].ready;
+            }
+            get destroyed() {
+                return this[kImpl].destroyed;
+            }
+            get closed() {
+                return this[kImpl].closed;
+            }
+            get writable() {
+                return !this[kImpl].destroyed && !this[kImpl].ending;
+            }
+            get writableEnded() {
+                return this[kImpl].ending;
+            }
+            get writableFinished() {
+                return this[kImpl].finished;
+            }
+            get writableNeedDrain() {
+                return this[kImpl].needDrain;
+            }
+            get writableObjectMode() {
+                return false;
+            }
+            get writableErrored() {
+                return this[kImpl].errored;
+            }
+        }
+        function error(stream, err) {
+            setImmediate(()=>{
+                stream.emit('error', err);
+            });
+        }
+        function destroy(stream, err) {
+            if (stream[kImpl].destroyed) return;
+            stream[kImpl].destroyed = true;
+            if (err) {
+                stream[kImpl].errored = err;
+                error(stream, err);
+            }
+            if (stream.worker.exited) setImmediate(()=>{
+                stream[kImpl].closed = true;
+                stream.emit('close');
+            });
+            else stream.worker.terminate().catch(()=>{}).then(()=>{
+                stream[kImpl].closed = true;
+                stream.emit('close');
+            });
+        }
+        function write(stream, data, cb) {
+            const current = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+            const length = Buffer.byteLength(data);
+            stream[kImpl].data.write(data, current);
+            Atomics.store(stream[kImpl].state, WRITE_INDEX, current + length);
+            Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+            cb();
+            return true;
+        }
+        function end(stream) {
+            if (stream[kImpl].ended || !stream[kImpl].ending || stream[kImpl].flushing) return;
+            stream[kImpl].ended = true;
+            try {
+                stream.flushSync();
+                let readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+                Atomics.store(stream[kImpl].state, WRITE_INDEX, -1);
+                Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+                let spins = 0;
+                while(-1 !== readIndex){
+                    Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1000);
+                    readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+                    if (-2 === readIndex) return void destroy(stream, new Error('end() failed'));
+                    if (10 === ++spins) return void destroy(stream, new Error('end() took too long (10s)'));
+                }
+                process.nextTick(()=>{
+                    stream[kImpl].finished = true;
+                    stream.emit('finish');
+                });
+            } catch (err) {
+                destroy(stream, err);
+            }
+        }
+        function writeSync(stream) {
+            const cb = ()=>{
+                if (stream[kImpl].ending) end(stream);
+                else if (stream[kImpl].needDrain) process.nextTick(drain, stream);
+            };
+            stream[kImpl].flushing = false;
+            while(0 !== stream[kImpl].buf.length){
+                const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+                let leftover = stream[kImpl].data.length - writeIndex;
+                if (0 === leftover) {
+                    flushSync(stream);
+                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+                    continue;
+                }
+                if (leftover < 0) throw new Error('overwritten');
+                let toWrite = stream[kImpl].buf.slice(0, leftover);
+                let toWriteBytes = Buffer.byteLength(toWrite);
+                if (toWriteBytes <= leftover) {
+                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+                    write(stream, toWrite, cb);
+                } else {
+                    flushSync(stream);
+                    Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+                    Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+                    while(toWriteBytes > stream[kImpl].buf.length){
+                        leftover /= 2;
+                        toWrite = stream[kImpl].buf.slice(0, leftover);
+                        toWriteBytes = Buffer.byteLength(toWrite);
+                    }
+                    stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+                    write(stream, toWrite, cb);
+                }
+            }
+        }
+        function flushSync(stream) {
+            if (stream[kImpl].flushing) throw new Error('unable to flush while flushing');
+            const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+            let spins = 0;
+            while(true){
+                const readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+                if (-2 === readIndex) throw Error('_flushSync failed');
+                if (readIndex !== writeIndex) Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1000);
+                else break;
+                if (10 === ++spins) throw new Error('_flushSync took too long (10s)');
+            }
+        }
+        module1.exports = ThreadStream;
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/indexes.js": function(module1) {
+        "use strict";
+        const WRITE_INDEX = 4;
+        const READ_INDEX = 8;
+        module1.exports = {
+            WRITE_INDEX,
+            READ_INDEX
+        };
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/lib/wait.js": function(module1) {
+        "use strict";
+        const MAX_TIMEOUT = 1000;
+        function wait(state, index, expected, timeout, done) {
+            const max = Date.now() + timeout;
+            let current = Atomics.load(state, index);
+            if (current === expected) return void done(null, 'ok');
+            let prior = current;
+            const check = (backoff)=>{
+                if (Date.now() > max) done(null, 'timed-out');
+                else setTimeout(()=>{
+                    prior = current;
+                    current = Atomics.load(state, index);
+                    if (current === prior) check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : 2 * backoff);
+                    else current === expected ? done(null, 'ok') : done(null, 'not-equal');
+                }, backoff);
+            };
+            check(1);
+        }
+        function waitDiff(state, index, expected, timeout, done) {
+            const max = Date.now() + timeout;
+            let current = Atomics.load(state, index);
+            if (current !== expected) return void done(null, 'ok');
+            const check = (backoff)=>{
+                if (Date.now() > max) done(null, 'timed-out');
+                else setTimeout(()=>{
+                    current = Atomics.load(state, index);
+                    if (current !== expected) done(null, 'ok');
+                    else check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : 2 * backoff);
+                }, backoff);
+            };
+            check(1);
+        }
+        module1.exports = {
+            wait,
+            waitDiff
+        };
+    },
+    assert: function(module1) {
+        "use strict";
+        module1.exports = require("assert");
+    },
+    buffer: function(module1) {
+        "use strict";
+        module1.exports = require("buffer");
+    },
+    events: function(module1) {
+        "use strict";
+        module1.exports = require("events");
+    },
+    fs: function(module1) {
+        "use strict";
+        module1.exports = require("fs");
+    },
+    module: function(module1) {
+        "use strict";
+        module1.exports = require("module");
+    },
+    "node:diagnostics_channel": function(module1) {
+        "use strict";
+        module1.exports = require("node:diagnostics_channel");
+    },
+    "node:events": function(module1) {
+        "use strict";
+        module1.exports = require("node:events");
+    },
+    "node:os": function(module1) {
+        "use strict";
+        module1.exports = require("node:os");
+    },
+    "node:path": function(module1) {
+        "use strict";
+        module1.exports = require("node:path");
+    },
+    path: function(module1) {
+        "use strict";
+        module1.exports = require("path");
+    },
+    url: function(module1) {
+        "use strict";
+        module1.exports = require("url");
+    },
+    util: function(module1) {
+        "use strict";
+        module1.exports = require("util");
+    },
+    worker_threads: function(module1) {
+        "use strict";
+        module1.exports = require("worker_threads");
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/file.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const pino = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/pino.js");
+        const { once } = __webpack_require__("node:events");
+        module1.exports = async function(opts = {}) {
+            const destOpts = Object.assign({}, opts, {
+                dest: opts.destination || 1,
+                sync: false
+            });
+            delete destOpts.destination;
+            const destination = pino.destination(destOpts);
+            await once(destination, 'ready');
+            return destination;
+        };
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const errSerializer = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err.js");
+        const errWithCauseSerializer = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-with-cause.js");
+        const reqSerializers = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/req.js");
+        const resSerializers = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/res.js");
+        module1.exports = {
+            err: errSerializer,
+            errWithCause: errWithCauseSerializer,
+            mapHttpRequest: reqSerializers.mapHttpRequest,
+            mapHttpResponse: resSerializers.mapHttpResponse,
+            req: reqSerializers.reqSerializer,
+            res: resSerializers.resSerializer,
+            wrapErrorSerializer: function(customSerializer) {
+                if (customSerializer === errSerializer) return customSerializer;
+                return function(err) {
+                    return customSerializer(errSerializer(err));
+                };
+            },
+            wrapRequestSerializer: function(customSerializer) {
+                if (customSerializer === reqSerializers.reqSerializer) return customSerializer;
+                return function(req) {
+                    return customSerializer(reqSerializers.reqSerializer(req));
+                };
+            },
+            wrapResponseSerializer: function(customSerializer) {
+                if (customSerializer === resSerializers.resSerializer) return customSerializer;
+                return function(res) {
+                    return customSerializer(resSerializers.resSerializer(res));
+                };
+            }
+        };
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-helpers.js": function(module1) {
+        "use strict";
+        const isErrorLike = (err)=>err && 'string' == typeof err.message;
+        const getErrorCause = (err)=>{
+            if (!err) return;
+            const cause = err.cause;
+            if ('function' != typeof cause) return isErrorLike(cause) ? cause : void 0;
+            {
+                const causeResult = err.cause();
+                return isErrorLike(causeResult) ? causeResult : void 0;
+            }
+        };
+        const _stackWithCauses = (err, seen)=>{
+            if (!isErrorLike(err)) return '';
+            const stack = err.stack || '';
+            if (seen.has(err)) return stack + '\ncauses have become circular...';
+            const cause = getErrorCause(err);
+            if (!cause) return stack;
+            seen.add(err);
+            return stack + '\ncaused by: ' + _stackWithCauses(cause, seen);
+        };
+        const stackWithCauses = (err)=>_stackWithCauses(err, new Set());
+        const _messageWithCauses = (err, seen, skip)=>{
+            if (!isErrorLike(err)) return '';
+            const message = skip ? '' : err.message || '';
+            if (seen.has(err)) return message + ': ...';
+            const cause = getErrorCause(err);
+            if (!cause) return message;
+            {
+                seen.add(err);
+                const skipIfVErrorStyleCause = 'function' == typeof err.cause;
+                return message + (skipIfVErrorStyleCause ? '' : ': ') + _messageWithCauses(cause, seen, skipIfVErrorStyleCause);
+            }
+        };
+        const messageWithCauses = (err)=>_messageWithCauses(err, new Set());
+        module1.exports = {
+            isErrorLike,
+            getErrorCause,
+            stackWithCauses,
+            messageWithCauses
+        };
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-proto.js": function(module1) {
+        "use strict";
+        const seen = Symbol('circular-ref-tag');
+        const rawSymbol = Symbol('pino-raw-err-ref');
+        const pinoErrProto = Object.create({}, {
+            type: {
+                enumerable: true,
+                writable: true,
+                value: void 0
+            },
+            message: {
+                enumerable: true,
+                writable: true,
+                value: void 0
+            },
+            stack: {
+                enumerable: true,
+                writable: true,
+                value: void 0
+            },
+            aggregateErrors: {
+                enumerable: true,
+                writable: true,
+                value: void 0
+            },
+            raw: {
+                enumerable: false,
+                get: function() {
+                    return this[rawSymbol];
+                },
+                set: function(val) {
+                    this[rawSymbol] = val;
+                }
+            }
+        });
+        Object.defineProperty(pinoErrProto, rawSymbol, {
+            writable: true,
+            value: {}
+        });
+        module1.exports = {
+            pinoErrProto,
+            pinoErrorSymbols: {
+                seen,
+                rawSymbol
+            }
+        };
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-with-cause.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = errWithCauseSerializer;
+        const { isErrorLike } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-helpers.js");
+        const { pinoErrProto, pinoErrorSymbols } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-proto.js");
+        const { seen } = pinoErrorSymbols;
+        const { toString } = Object.prototype;
+        function errWithCauseSerializer(err) {
+            if (!isErrorLike(err)) return err;
+            err[seen] = void 0;
+            const _err = Object.create(pinoErrProto);
+            _err.type = '[object Function]' === toString.call(err.constructor) ? err.constructor.name : err.name;
+            _err.message = err.message;
+            _err.stack = err.stack;
+            if (Array.isArray(err.errors)) _err.aggregateErrors = err.errors.map((err)=>errWithCauseSerializer(err));
+            if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) _err.cause = errWithCauseSerializer(err.cause);
+            for(const key in err)if (void 0 === _err[key]) {
+                const val = err[key];
+                if (isErrorLike(val)) {
+                    if (!Object.prototype.hasOwnProperty.call(val, seen)) _err[key] = errWithCauseSerializer(val);
+                } else _err[key] = val;
+            }
+            delete err[seen];
+            _err.raw = err;
+            return _err;
+        }
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        module1.exports = errSerializer;
+        const { messageWithCauses, stackWithCauses, isErrorLike } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-helpers.js");
+        const { pinoErrProto, pinoErrorSymbols } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/err-proto.js");
+        const { seen } = pinoErrorSymbols;
+        const { toString } = Object.prototype;
+        function errSerializer(err) {
+            if (!isErrorLike(err)) return err;
+            err[seen] = void 0;
+            const _err = Object.create(pinoErrProto);
+            _err.type = '[object Function]' === toString.call(err.constructor) ? err.constructor.name : err.name;
+            _err.message = messageWithCauses(err);
+            _err.stack = stackWithCauses(err);
+            if (Array.isArray(err.errors)) _err.aggregateErrors = err.errors.map((err)=>errSerializer(err));
+            for(const key in err)if (void 0 === _err[key]) {
+                const val = err[key];
+                if (isErrorLike(val)) {
+                    if ('cause' !== key && !Object.prototype.hasOwnProperty.call(val, seen)) _err[key] = errSerializer(val);
+                } else _err[key] = val;
+            }
+            delete err[seen];
+            _err.raw = err;
+            return _err;
+        }
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/req.js": function(module1) {
+        "use strict";
+        module1.exports = {
+            mapHttpRequest,
+            reqSerializer
+        };
+        const rawSymbol = Symbol('pino-raw-req-ref');
+        const pinoReqProto = Object.create({}, {
+            id: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            method: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            url: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            query: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            params: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            headers: {
+                enumerable: true,
+                writable: true,
+                value: {}
+            },
+            remoteAddress: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            remotePort: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            raw: {
+                enumerable: false,
+                get: function() {
+                    return this[rawSymbol];
+                },
+                set: function(val) {
+                    this[rawSymbol] = val;
+                }
+            }
+        });
+        Object.defineProperty(pinoReqProto, rawSymbol, {
+            writable: true,
+            value: {}
+        });
+        function reqSerializer(req) {
+            const connection = req.info || req.socket;
+            const _req = Object.create(pinoReqProto);
+            _req.id = 'function' == typeof req.id ? req.id() : req.id || (req.info ? req.info.id : void 0);
+            _req.method = req.method;
+            if (req.originalUrl) _req.url = req.originalUrl;
+            else {
+                const path = req.path;
+                _req.url = 'string' == typeof path ? path : req.url ? req.url.path || req.url : void 0;
+            }
+            if (req.query) _req.query = req.query;
+            if (req.params) _req.params = req.params;
+            _req.headers = req.headers;
+            _req.remoteAddress = connection && connection.remoteAddress;
+            _req.remotePort = connection && connection.remotePort;
+            _req.raw = req.raw || req;
+            return _req;
+        }
+        function mapHttpRequest(req) {
+            return {
+                req: reqSerializer(req)
+            };
+        }
+    },
+    "../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/lib/res.js": function(module1) {
+        "use strict";
+        module1.exports = {
+            mapHttpResponse,
+            resSerializer
+        };
+        const rawSymbol = Symbol('pino-raw-res-ref');
+        const pinoResProto = Object.create({}, {
+            statusCode: {
+                enumerable: true,
+                writable: true,
+                value: 0
+            },
+            headers: {
+                enumerable: true,
+                writable: true,
+                value: ''
+            },
+            raw: {
+                enumerable: false,
+                get: function() {
+                    return this[rawSymbol];
+                },
+                set: function(val) {
+                    this[rawSymbol] = val;
+                }
+            }
+        });
+        Object.defineProperty(pinoResProto, rawSymbol, {
+            writable: true,
+            value: {}
+        });
+        function resSerializer(res) {
+            const _res = Object.create(pinoResProto);
+            _res.statusCode = res.headersSent ? res.statusCode : null;
+            _res.headers = res.getHeaders ? res.getHeaders() : res._headers;
+            _res.raw = res;
+            return _res;
+        }
+        function mapHttpResponse(res) {
+            return {
+                res: resSerializer(res)
+            };
+        }
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/caller.js": function(module1) {
+        "use strict";
+        function noOpPrepareStackTrace(_, stack) {
+            return stack;
+        }
+        module1.exports = function() {
+            const originalPrepare = Error.prepareStackTrace;
+            Error.prepareStackTrace = noOpPrepareStackTrace;
+            const stack = new Error().stack;
+            Error.prepareStackTrace = originalPrepare;
+            if (!Array.isArray(stack)) return;
+            const entries = stack.slice(2);
+            const fileNames = [];
+            for (const entry of entries)if (entry) fileNames.push(entry.getFileName());
+            return fileNames;
+        };
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/constants.js": function(module1) {
+        const DEFAULT_LEVELS = {
+            trace: 10,
+            debug: 20,
+            info: 30,
+            warn: 40,
+            error: 50,
+            fatal: 60
+        };
+        const SORTING_ORDER = {
+            ASC: 'ASC',
+            DESC: 'DESC'
+        };
+        module1.exports = {
+            DEFAULT_LEVELS,
+            SORTING_ORDER
+        };
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/levels.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { lsCacheSym, levelValSym, useOnlyCustomLevelsSym, streamSym, formattersSym, hooksSym, levelCompSym } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/symbols.js");
+        const { noop, genLog } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/tools.js");
+        const { DEFAULT_LEVELS, SORTING_ORDER } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/constants.js");
+        const levelMethods = {
+            fatal: (hook)=>{
+                const logFatal = genLog(DEFAULT_LEVELS.fatal, hook);
+                return function(...args) {
+                    const stream = this[streamSym];
+                    logFatal.call(this, ...args);
+                    if ('function' == typeof stream.flushSync) try {
+                        stream.flushSync();
+                    } catch (e) {}
+                };
+            },
+            error: (hook)=>genLog(DEFAULT_LEVELS.error, hook),
+            warn: (hook)=>genLog(DEFAULT_LEVELS.warn, hook),
+            info: (hook)=>genLog(DEFAULT_LEVELS.info, hook),
+            debug: (hook)=>genLog(DEFAULT_LEVELS.debug, hook),
+            trace: (hook)=>genLog(DEFAULT_LEVELS.trace, hook)
+        };
+        const nums = Object.keys(DEFAULT_LEVELS).reduce((o, k)=>{
+            o[DEFAULT_LEVELS[k]] = k;
+            return o;
+        }, {});
+        const initialLsCache = Object.keys(nums).reduce((o, k)=>{
+            o[k] = '{"level":' + Number(k);
+            return o;
+        }, {});
+        function genLsCache(instance) {
+            const formatter = instance[formattersSym].level;
+            const { labels } = instance.levels;
+            const cache = {};
+            for(const label in labels){
+                const level = formatter(labels[label], Number(label));
+                cache[label] = JSON.stringify(level).slice(0, -1);
+            }
+            instance[lsCacheSym] = cache;
+            return instance;
+        }
+        function isStandardLevel(level, useOnlyCustomLevels) {
+            if (useOnlyCustomLevels) return false;
+            switch(level){
+                case 'fatal':
+                case 'error':
+                case 'warn':
+                case 'info':
+                case 'debug':
+                case 'trace':
+                    return true;
+                default:
+                    return false;
+            }
+        }
+        function setLevel(level) {
+            const { labels, values } = this.levels;
+            if ('number' == typeof level) {
+                if (void 0 === labels[level]) throw Error('unknown level value' + level);
+                level = labels[level];
+            }
+            if (void 0 === values[level]) throw Error('unknown level ' + level);
+            const preLevelVal = this[levelValSym];
+            const levelVal = this[levelValSym] = values[level];
+            const useOnlyCustomLevelsVal = this[useOnlyCustomLevelsSym];
+            const levelComparison = this[levelCompSym];
+            const hook = this[hooksSym].logMethod;
+            for(const key in values){
+                if (false === levelComparison(values[key], levelVal)) {
+                    this[key] = noop;
+                    continue;
+                }
+                this[key] = isStandardLevel(key, useOnlyCustomLevelsVal) ? levelMethods[key](hook) : genLog(values[key], hook);
+            }
+            this.emit('level-change', level, levelVal, labels[preLevelVal], preLevelVal, this);
+        }
+        function getLevel(level) {
+            const { levels, levelVal } = this;
+            return levels && levels.labels ? levels.labels[levelVal] : '';
+        }
+        function isLevelEnabled(logLevel) {
+            const { values } = this.levels;
+            const logLevelVal = values[logLevel];
+            return void 0 !== logLevelVal && this[levelCompSym](logLevelVal, this[levelValSym]);
+        }
+        function compareLevel(direction, current, expected) {
+            if (direction === SORTING_ORDER.DESC) return current <= expected;
+            return current >= expected;
+        }
+        function genLevelComparison(levelComparison) {
+            if ('string' == typeof levelComparison) return compareLevel.bind(null, levelComparison);
+            return levelComparison;
+        }
+        function mappings(customLevels = null, useOnlyCustomLevels = false) {
+            const customNums = customLevels ? Object.keys(customLevels).reduce((o, k)=>{
+                o[customLevels[k]] = k;
+                return o;
+            }, {}) : null;
+            const labels = Object.assign(Object.create(Object.prototype, {
+                Infinity: {
+                    value: 'silent'
+                }
+            }), useOnlyCustomLevels ? null : nums, customNums);
+            const values = Object.assign(Object.create(Object.prototype, {
+                silent: {
+                    value: 1 / 0
+                }
+            }), useOnlyCustomLevels ? null : DEFAULT_LEVELS, customLevels);
+            return {
+                labels,
+                values
+            };
+        }
+        function assertDefaultLevelFound(defaultLevel, customLevels, useOnlyCustomLevels) {
+            if ('number' == typeof defaultLevel) {
+                const values = [].concat(Object.keys(customLevels || {}).map((key)=>customLevels[key]), useOnlyCustomLevels ? [] : Object.keys(nums).map((level)=>+level), 1 / 0);
+                if (!values.includes(defaultLevel)) throw Error(`default level:${defaultLevel} must be included in custom levels`);
+                return;
+            }
+            const labels = Object.assign(Object.create(Object.prototype, {
+                silent: {
+                    value: 1 / 0
+                }
+            }), useOnlyCustomLevels ? null : DEFAULT_LEVELS, customLevels);
+            if (!(defaultLevel in labels)) throw Error(`default level:${defaultLevel} must be included in custom levels`);
+        }
+        function assertNoLevelCollisions(levels, customLevels) {
+            const { labels, values } = levels;
+            for(const k in customLevels){
+                if (k in values) throw Error('levels cannot be overridden');
+                if (customLevels[k] in labels) throw Error('pre-existing level values cannot be used for new levels');
+            }
+        }
+        function assertLevelComparison(levelComparison) {
+            if ('function' == typeof levelComparison) return;
+            if ('string' == typeof levelComparison && Object.values(SORTING_ORDER).includes(levelComparison)) return;
+            throw new Error('Levels comparison should be one of "ASC", "DESC" or "function" type');
+        }
+        module1.exports = {
+            initialLsCache,
+            genLsCache,
+            levelMethods,
+            getLevel,
+            setLevel,
+            isLevelEnabled,
+            mappings,
+            assertNoLevelCollisions,
+            assertDefaultLevelFound,
+            genLevelComparison,
+            assertLevelComparison
+        };
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/meta.js": function(module1) {
+        "use strict";
+        module1.exports = {
+            version: '10.1.0'
+        };
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/multistream.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const metadata = Symbol.for('pino.metadata');
+        const { DEFAULT_LEVELS } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/constants.js");
+        const DEFAULT_INFO_LEVEL = DEFAULT_LEVELS.info;
+        function multistream(streamsArray, opts) {
+            streamsArray = streamsArray || [];
+            opts = opts || {
+                dedupe: false
+            };
+            const streamLevels = Object.create(DEFAULT_LEVELS);
+            streamLevels.silent = 1 / 0;
+            if (opts.levels && 'object' == typeof opts.levels) Object.keys(opts.levels).forEach((i)=>{
+                streamLevels[i] = opts.levels[i];
+            });
+            const res = {
+                write,
+                add,
+                remove,
+                emit,
+                flushSync,
+                end,
+                minLevel: 0,
+                lastId: 0,
+                streams: [],
+                clone,
+                [metadata]: true,
+                streamLevels
+            };
+            if (Array.isArray(streamsArray)) streamsArray.forEach(add, res);
+            else add.call(res, streamsArray);
+            streamsArray = null;
+            return res;
+            function write(data) {
+                let dest;
+                const level = this.lastLevel;
+                const { streams } = this;
+                let recordedLevel = 0;
+                let stream;
+                for(let i = initLoopVar(streams.length, opts.dedupe); checkLoopVar(i, streams.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe)){
+                    dest = streams[i];
+                    if (dest.level <= level) {
+                        if (0 !== recordedLevel && recordedLevel !== dest.level) break;
+                        stream = dest.stream;
+                        if (stream[metadata]) {
+                            const { lastTime, lastMsg, lastObj, lastLogger } = this;
+                            stream.lastLevel = level;
+                            stream.lastTime = lastTime;
+                            stream.lastMsg = lastMsg;
+                            stream.lastObj = lastObj;
+                            stream.lastLogger = lastLogger;
+                        }
+                        stream.write(data);
+                        if (opts.dedupe) recordedLevel = dest.level;
+                    } else if (!opts.dedupe) break;
+                }
+            }
+            function emit(...args) {
+                for (const { stream } of this.streams)if ('function' == typeof stream.emit) stream.emit(...args);
+            }
+            function flushSync() {
+                for (const { stream } of this.streams)if ('function' == typeof stream.flushSync) stream.flushSync();
+            }
+            function add(dest) {
+                if (!dest) return res;
+                const isStream = 'function' == typeof dest.write || dest.stream;
+                const stream_ = dest.write ? dest : dest.stream;
+                if (!isStream) throw Error('stream object needs to implement either StreamEntry or DestinationStream interface');
+                const { streams, streamLevels } = this;
+                let level;
+                level = 'number' == typeof dest.levelVal ? dest.levelVal : 'string' == typeof dest.level ? streamLevels[dest.level] : 'number' == typeof dest.level ? dest.level : DEFAULT_INFO_LEVEL;
+                const dest_ = {
+                    stream: stream_,
+                    level,
+                    levelVal: void 0,
+                    id: ++res.lastId
+                };
+                streams.unshift(dest_);
+                streams.sort(compareByLevel);
+                this.minLevel = streams[0].level;
+                return res;
+            }
+            function remove(id) {
+                const { streams } = this;
+                const index = streams.findIndex((s)=>s.id === id);
+                if (index >= 0) {
+                    streams.splice(index, 1);
+                    streams.sort(compareByLevel);
+                    this.minLevel = streams.length > 0 ? streams[0].level : -1;
+                }
+                return res;
+            }
+            function end() {
+                for (const { stream } of this.streams){
+                    if ('function' == typeof stream.flushSync) stream.flushSync();
+                    stream.end();
+                }
+            }
+            function clone(level) {
+                const streams = new Array(this.streams.length);
+                for(let i = 0; i < streams.length; i++)streams[i] = {
+                    level,
+                    stream: this.streams[i].stream
+                };
+                return {
+                    write,
+                    add,
+                    remove,
+                    minLevel: level,
+                    streams,
+                    clone,
+                    emit,
+                    flushSync,
+                    [metadata]: true
+                };
+            }
+        }
+        function compareByLevel(a, b) {
+            return a.level - b.level;
+        }
+        function initLoopVar(length, dedupe) {
+            return dedupe ? length - 1 : 0;
+        }
+        function adjustLoopVar(i, dedupe) {
+            return dedupe ? i - 1 : i + 1;
+        }
+        function checkLoopVar(i, length, dedupe) {
+            return dedupe ? i >= 0 : i < length;
+        }
+        module1.exports = multistream;
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/proto.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { EventEmitter } = __webpack_require__("node:events");
+        const { lsCacheSym, levelValSym, setLevelSym, getLevelSym, chindingsSym, mixinSym, asJsonSym, writeSym, mixinMergeStrategySym, timeSym, timeSliceIndexSym, streamSym, serializersSym, formattersSym, errorKeySym, messageKeySym, useOnlyCustomLevelsSym, needsMetadataGsym, redactFmtSym, stringifySym, formatOptsSym, stringifiersSym, msgPrefixSym, hooksSym } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/symbols.js");
+        const { getLevel, setLevel, isLevelEnabled, mappings, initialLsCache, genLsCache, assertNoLevelCollisions } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/levels.js");
+        const { asChindings, asJson, buildFormatters, stringify, noop } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/tools.js");
+        const { version } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/meta.js");
+        const redaction = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/redaction.js");
+        const constructor = class {
+        };
+        const prototype = {
+            constructor,
+            child,
+            bindings,
+            setBindings,
+            flush,
+            isLevelEnabled,
+            version,
+            get level () {
+                return this[getLevelSym]();
+            },
+            set level (lvl){
+                this[setLevelSym](lvl);
+            },
+            get levelVal () {
+                return this[levelValSym];
+            },
+            set levelVal (n){
+                throw Error('levelVal is read-only');
+            },
+            get msgPrefix () {
+                return this[msgPrefixSym];
+            },
+            get [Symbol.toStringTag] () {
+                return 'Pino';
+            },
+            [lsCacheSym]: initialLsCache,
+            [writeSym]: write,
+            [asJsonSym]: asJson,
+            [getLevelSym]: getLevel,
+            [setLevelSym]: setLevel
+        };
+        Object.setPrototypeOf(prototype, EventEmitter.prototype);
+        module1.exports = function() {
+            return Object.create(prototype);
+        };
+        const resetChildingsFormatter = (bindings)=>bindings;
+        function child(bindings, options) {
+            if (!bindings) throw Error('missing bindings for child Pino');
+            const serializers = this[serializersSym];
+            const formatters = this[formattersSym];
+            const instance = Object.create(this);
+            if (null == options) {
+                if (instance[formattersSym].bindings !== resetChildingsFormatter) instance[formattersSym] = buildFormatters(formatters.level, resetChildingsFormatter, formatters.log);
+                instance[chindingsSym] = asChindings(instance, bindings);
+                if (this.onChild !== noop) this.onChild(instance);
+                return instance;
+            }
+            if (true === options.hasOwnProperty('serializers')) {
+                instance[serializersSym] = Object.create(null);
+                for(const k in serializers)instance[serializersSym][k] = serializers[k];
+                const parentSymbols = Object.getOwnPropertySymbols(serializers);
+                for(var i = 0; i < parentSymbols.length; i++){
+                    const ks = parentSymbols[i];
+                    instance[serializersSym][ks] = serializers[ks];
+                }
+                for(const bk in options.serializers)instance[serializersSym][bk] = options.serializers[bk];
+                const bindingsSymbols = Object.getOwnPropertySymbols(options.serializers);
+                for(var bi = 0; bi < bindingsSymbols.length; bi++){
+                    const bks = bindingsSymbols[bi];
+                    instance[serializersSym][bks] = options.serializers[bks];
+                }
+            } else instance[serializersSym] = serializers;
+            if (options.hasOwnProperty('formatters')) {
+                const { level, bindings: chindings, log } = options.formatters;
+                instance[formattersSym] = buildFormatters(level || formatters.level, chindings || resetChildingsFormatter, log || formatters.log);
+            } else instance[formattersSym] = buildFormatters(formatters.level, resetChildingsFormatter, formatters.log);
+            if (true === options.hasOwnProperty('customLevels')) {
+                assertNoLevelCollisions(this.levels, options.customLevels);
+                instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym]);
+                genLsCache(instance);
+            }
+            if ('object' == typeof options.redact && null !== options.redact || Array.isArray(options.redact)) {
+                instance.redact = options.redact;
+                const stringifiers = redaction(instance.redact, stringify);
+                const formatOpts = {
+                    stringify: stringifiers[redactFmtSym]
+                };
+                instance[stringifySym] = stringify;
+                instance[stringifiersSym] = stringifiers;
+                instance[formatOptsSym] = formatOpts;
+            }
+            if ('string' == typeof options.msgPrefix) instance[msgPrefixSym] = (this[msgPrefixSym] || '') + options.msgPrefix;
+            instance[chindingsSym] = asChindings(instance, bindings);
+            if (void 0 !== options.level && options.level !== this.level || options.hasOwnProperty('customLevels')) {
+                const childLevel = options.level || this.level;
+                instance[setLevelSym](childLevel);
+            }
+            this.onChild(instance);
+            return instance;
+        }
+        function bindings() {
+            const chindings = this[chindingsSym];
+            const chindingsJson = `{${chindings.substr(1)}}`;
+            const bindingsFromJson = JSON.parse(chindingsJson);
+            delete bindingsFromJson.pid;
+            delete bindingsFromJson.hostname;
+            return bindingsFromJson;
+        }
+        function setBindings(newBindings) {
+            const chindings = asChindings(this, newBindings);
+            this[chindingsSym] = chindings;
+        }
+        function defaultMixinMergeStrategy(mergeObject, mixinObject) {
+            return Object.assign(mixinObject, mergeObject);
+        }
+        function write(_obj, msg, num) {
+            const t = this[timeSym]();
+            const mixin = this[mixinSym];
+            const errorKey = this[errorKeySym];
+            const messageKey = this[messageKeySym];
+            const mixinMergeStrategy = this[mixinMergeStrategySym] || defaultMixinMergeStrategy;
+            let obj;
+            const streamWriteHook = this[hooksSym].streamWrite;
+            if (null == _obj) obj = {};
+            else if (_obj instanceof Error) {
+                obj = {
+                    [errorKey]: _obj
+                };
+                if (void 0 === msg) msg = _obj.message;
+            } else {
+                obj = _obj;
+                if (void 0 === msg && void 0 === _obj[messageKey] && _obj[errorKey]) msg = _obj[errorKey].message;
+            }
+            if (mixin) obj = mixinMergeStrategy(obj, mixin(obj, num, this));
+            const s = this[asJsonSym](obj, msg, num, t);
+            const stream = this[streamSym];
+            if (true === stream[needsMetadataGsym]) {
+                stream.lastLevel = num;
+                stream.lastObj = obj;
+                stream.lastMsg = msg;
+                stream.lastTime = t.slice(this[timeSliceIndexSym]);
+                stream.lastLogger = this;
+            }
+            stream.write(streamWriteHook ? streamWriteHook(s) : s);
+        }
+        function flush(cb) {
+            if (null != cb && 'function' != typeof cb) throw Error('callback must be a function');
+            const stream = this[streamSym];
+            if ('function' == typeof stream.flush) stream.flush(cb || noop);
+            else if (cb) cb();
+        }
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/redaction.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const Redact = __webpack_require__("../../node_modules/.pnpm/@pinojs+redact@0.4.0/node_modules/@pinojs/redact/index.js");
+        const { redactFmtSym, wildcardFirstSym } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/symbols.js");
+        const rx = /[^.[\]]+|\[([^[\]]*?)\]/g;
+        const CENSOR = '[Redacted]';
+        const strict = false;
+        function redaction(opts, serialize) {
+            const { paths, censor, remove } = handle(opts);
+            const shape = paths.reduce((o, str)=>{
+                rx.lastIndex = 0;
+                const first = rx.exec(str);
+                const next = rx.exec(str);
+                let ns = void 0 !== first[1] ? first[1].replace(/^(?:"|'|`)(.*)(?:"|'|`)$/, '$1') : first[0];
+                if ('*' === ns) ns = wildcardFirstSym;
+                if (null === next) {
+                    o[ns] = null;
+                    return o;
+                }
+                if (null === o[ns]) return o;
+                const { index } = next;
+                const nextPath = `${str.substr(index, str.length - 1)}`;
+                o[ns] = o[ns] || [];
+                if (ns !== wildcardFirstSym && 0 === o[ns].length) o[ns].push(...o[wildcardFirstSym] || []);
+                if (ns === wildcardFirstSym) Object.keys(o).forEach(function(k) {
+                    if (o[k]) o[k].push(nextPath);
+                });
+                o[ns].push(nextPath);
+                return o;
+            }, {});
+            const result = {
+                [redactFmtSym]: Redact({
+                    paths,
+                    censor,
+                    serialize,
+                    strict,
+                    remove
+                })
+            };
+            const topCensor = (...args)=>'function' == typeof censor ? serialize(censor(...args)) : serialize(censor);
+            return [
+                ...Object.keys(shape),
+                ...Object.getOwnPropertySymbols(shape)
+            ].reduce((o, k)=>{
+                if (null === shape[k]) o[k] = (value)=>topCensor(value, [
+                        k
+                    ]);
+                else {
+                    const wrappedCensor = 'function' == typeof censor ? (value, path)=>censor(value, [
+                            k,
+                            ...path
+                        ]) : censor;
+                    o[k] = Redact({
+                        paths: shape[k],
+                        censor: wrappedCensor,
+                        serialize,
+                        strict,
+                        remove
+                    });
+                }
+                return o;
+            }, result);
+        }
+        function handle(opts) {
+            if (Array.isArray(opts)) {
+                opts = {
+                    paths: opts,
+                    censor: CENSOR
+                };
+                return opts;
+            }
+            let { paths, censor = CENSOR, remove } = opts;
+            if (false === Array.isArray(paths)) throw Error('pino – redact must contain an array of strings');
+            if (true === remove) censor = void 0;
+            return {
+                paths,
+                censor,
+                remove
+            };
+        }
+        module1.exports = redaction;
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/symbols.js": function(module1) {
+        "use strict";
+        const setLevelSym = Symbol('pino.setLevel');
+        const getLevelSym = Symbol('pino.getLevel');
+        const levelValSym = Symbol('pino.levelVal');
+        const levelCompSym = Symbol('pino.levelComp');
+        const useLevelLabelsSym = Symbol('pino.useLevelLabels');
+        const useOnlyCustomLevelsSym = Symbol('pino.useOnlyCustomLevels');
+        const mixinSym = Symbol('pino.mixin');
+        const lsCacheSym = Symbol('pino.lsCache');
+        const chindingsSym = Symbol('pino.chindings');
+        const asJsonSym = Symbol('pino.asJson');
+        const writeSym = Symbol('pino.write');
+        const redactFmtSym = Symbol('pino.redactFmt');
+        const timeSym = Symbol('pino.time');
+        const timeSliceIndexSym = Symbol('pino.timeSliceIndex');
+        const streamSym = Symbol('pino.stream');
+        const stringifySym = Symbol('pino.stringify');
+        const stringifySafeSym = Symbol('pino.stringifySafe');
+        const stringifiersSym = Symbol('pino.stringifiers');
+        const endSym = Symbol('pino.end');
+        const formatOptsSym = Symbol('pino.formatOpts');
+        const messageKeySym = Symbol('pino.messageKey');
+        const errorKeySym = Symbol('pino.errorKey');
+        const nestedKeySym = Symbol('pino.nestedKey');
+        const nestedKeyStrSym = Symbol('pino.nestedKeyStr');
+        const mixinMergeStrategySym = Symbol('pino.mixinMergeStrategy');
+        const msgPrefixSym = Symbol('pino.msgPrefix');
+        const wildcardFirstSym = Symbol('pino.wildcardFirst');
+        const serializersSym = Symbol.for('pino.serializers');
+        const formattersSym = Symbol.for('pino.formatters');
+        const hooksSym = Symbol.for('pino.hooks');
+        const needsMetadataGsym = Symbol.for('pino.metadata');
+        module1.exports = {
+            setLevelSym,
+            getLevelSym,
+            levelValSym,
+            levelCompSym,
+            useLevelLabelsSym,
+            mixinSym,
+            lsCacheSym,
+            chindingsSym,
+            asJsonSym,
+            writeSym,
+            serializersSym,
+            redactFmtSym,
+            timeSym,
+            timeSliceIndexSym,
+            streamSym,
+            stringifySym,
+            stringifySafeSym,
+            stringifiersSym,
+            endSym,
+            formatOptsSym,
+            messageKeySym,
+            errorKeySym,
+            nestedKeySym,
+            wildcardFirstSym,
+            needsMetadataGsym,
+            useOnlyCustomLevelsSym,
+            formattersSym,
+            hooksSym,
+            nestedKeyStrSym,
+            mixinMergeStrategySym,
+            msgPrefixSym
+        };
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/time.js": function(module1) {
+        "use strict";
+        const nullTime = ()=>'';
+        const epochTime = ()=>`,"time":${Date.now()}`;
+        const unixTime = ()=>`,"time":${Math.round(Date.now() / 1000.0)}`;
+        const isoTime = ()=>`,"time":"${new Date(Date.now()).toISOString()}"`;
+        const NS_PER_MS = 1000000n;
+        const NS_PER_SEC = 1000000000n;
+        const startWallTimeNs = BigInt(Date.now()) * NS_PER_MS;
+        const startHrTime = process.hrtime.bigint();
+        const isoTimeNano = ()=>{
+            const elapsedNs = process.hrtime.bigint() - startHrTime;
+            const currentTimeNs = startWallTimeNs + elapsedNs;
+            const secondsSinceEpoch = currentTimeNs / NS_PER_SEC;
+            const nanosWithinSecond = currentTimeNs % NS_PER_SEC;
+            const msSinceEpoch = Number(1000n * secondsSinceEpoch + nanosWithinSecond / 1000000n);
+            const date = new Date(msSinceEpoch);
+            const year = date.getUTCFullYear();
+            const month = (date.getUTCMonth() + 1).toString().padStart(2, '0');
+            const day = date.getUTCDate().toString().padStart(2, '0');
+            const hours = date.getUTCHours().toString().padStart(2, '0');
+            const minutes = date.getUTCMinutes().toString().padStart(2, '0');
+            const seconds = date.getUTCSeconds().toString().padStart(2, '0');
+            return `,"time":"${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${nanosWithinSecond.toString().padStart(9, '0')}Z"`;
+        };
+        module1.exports = {
+            nullTime,
+            epochTime,
+            unixTime,
+            isoTime,
+            isoTimeNano
+        };
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/tools.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const diagChan = __webpack_require__("node:diagnostics_channel");
+        const format = __webpack_require__("../../node_modules/.pnpm/quick-format-unescaped@4.0.4/node_modules/quick-format-unescaped/index.js");
+        const { mapHttpRequest, mapHttpResponse } = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/index.js");
+        const SonicBoom = __webpack_require__("../../node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js");
+        const onExit = __webpack_require__("../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js");
+        const { lsCacheSym, chindingsSym, writeSym, serializersSym, formatOptsSym, endSym, stringifiersSym, stringifySym, stringifySafeSym, wildcardFirstSym, nestedKeySym, formattersSym, messageKeySym, errorKeySym, nestedKeyStrSym, msgPrefixSym } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/symbols.js");
+        const { isMainThread } = __webpack_require__("worker_threads");
+        const transport = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/transport.js");
+        const asJsonChan = diagChan.tracingChannel('pino_asJson');
+        function noop() {}
+        function genLog(level, hook) {
+            if (!hook) return LOG;
+            return function(...args) {
+                hook.call(this, args, LOG, level);
+            };
+            function LOG(o, ...n1) {
+                if ('object' == typeof o) {
+                    let msg = o;
+                    if (null !== o) {
+                        if (o.method && o.headers && o.socket) o = mapHttpRequest(o);
+                        else if ('function' == typeof o.setHeader) o = mapHttpResponse(o);
+                    }
+                    let formatParams;
+                    if (null === msg && 0 === n1.length) formatParams = [
+                        null
+                    ];
+                    else {
+                        msg = n1.shift();
+                        formatParams = n1;
+                    }
+                    if ('string' == typeof this[msgPrefixSym] && null != msg) msg = this[msgPrefixSym] + msg;
+                    this[writeSym](o, format(msg, formatParams, this[formatOptsSym]), level);
+                } else {
+                    let msg = void 0 === o ? n1.shift() : o;
+                    if ('string' == typeof this[msgPrefixSym] && null != msg) msg = this[msgPrefixSym] + msg;
+                    this[writeSym](null, format(msg, n1, this[formatOptsSym]), level);
+                }
+            }
+        }
+        function asString(str) {
+            let result = '';
+            let last = 0;
+            let found = false;
+            let point = 255;
+            const l = str.length;
+            if (l > 100) return JSON.stringify(str);
+            for(var i = 0; i < l && point >= 32; i++){
+                point = str.charCodeAt(i);
+                if (34 === point || 92 === point) {
+                    result += str.slice(last, i) + '\\';
+                    last = i;
+                    found = true;
+                }
+            }
+            if (found) result += str.slice(last);
+            else result = str;
+            return point < 32 ? JSON.stringify(str) : '"' + result + '"';
+        }
+        function asJson(obj, msg, num, time) {
+            if (false === asJsonChan.hasSubscribers) return _asJson.call(this, obj, msg, num, time);
+            const store = {
+                instance: this,
+                arguments
+            };
+            return asJsonChan.traceSync(_asJson, store, this, obj, msg, num, time);
+        }
+        function _asJson(obj, msg, num, time) {
+            const stringify = this[stringifySym];
+            const stringifySafe = this[stringifySafeSym];
+            const stringifiers = this[stringifiersSym];
+            const end = this[endSym];
+            const chindings = this[chindingsSym];
+            const serializers = this[serializersSym];
+            const formatters = this[formattersSym];
+            const messageKey = this[messageKeySym];
+            const errorKey = this[errorKeySym];
+            let data = this[lsCacheSym][num] + time;
+            data += chindings;
+            let value;
+            if (formatters.log) obj = formatters.log(obj);
+            const wildcardStringifier = stringifiers[wildcardFirstSym];
+            let propStr = '';
+            for(const key in obj){
+                value = obj[key];
+                if (Object.prototype.hasOwnProperty.call(obj, key) && void 0 !== value) {
+                    if (serializers[key]) value = serializers[key](value);
+                    else if (key === errorKey && serializers.err) value = serializers.err(value);
+                    const stringifier = stringifiers[key] || wildcardStringifier;
+                    switch(typeof value){
+                        case 'undefined':
+                        case 'function':
+                            continue;
+                        case 'number':
+                            if (false === Number.isFinite(value)) value = null;
+                        case 'boolean':
+                            if (stringifier) value = stringifier(value);
+                            break;
+                        case 'string':
+                            value = (stringifier || asString)(value);
+                            break;
+                        default:
+                            value = (stringifier || stringify)(value, stringifySafe);
+                    }
+                    if (void 0 === value) continue;
+                    const strKey = asString(key);
+                    propStr += ',' + strKey + ':' + value;
+                }
+            }
+            let msgStr = '';
+            if (void 0 !== msg) {
+                value = serializers[messageKey] ? serializers[messageKey](msg) : msg;
+                const stringifier = stringifiers[messageKey] || wildcardStringifier;
+                switch(typeof value){
+                    case 'function':
+                        break;
+                    case 'number':
+                        if (false === Number.isFinite(value)) value = null;
+                    case 'boolean':
+                        if (stringifier) value = stringifier(value);
+                        msgStr = ',"' + messageKey + '":' + value;
+                        break;
+                    case 'string':
+                        value = (stringifier || asString)(value);
+                        msgStr = ',"' + messageKey + '":' + value;
+                        break;
+                    default:
+                        value = (stringifier || stringify)(value, stringifySafe);
+                        msgStr = ',"' + messageKey + '":' + value;
+                }
+            }
+            if (this[nestedKeySym] && propStr) return data + this[nestedKeyStrSym] + propStr.slice(1) + '}' + msgStr + end;
+            return data + propStr + msgStr + end;
+        }
+        function asChindings(instance, bindings) {
+            let value;
+            let data = instance[chindingsSym];
+            const stringify = instance[stringifySym];
+            const stringifySafe = instance[stringifySafeSym];
+            const stringifiers = instance[stringifiersSym];
+            const wildcardStringifier = stringifiers[wildcardFirstSym];
+            const serializers = instance[serializersSym];
+            const formatter = instance[formattersSym].bindings;
+            bindings = formatter(bindings);
+            for(const key in bindings){
+                value = bindings[key];
+                const valid = (key.length < 5 || 'level' !== key && 'serializers' !== key && 'formatters' !== key && 'customLevels' !== key) && bindings.hasOwnProperty(key) && void 0 !== value;
+                if (true === valid) {
+                    value = serializers[key] ? serializers[key](value) : value;
+                    value = (stringifiers[key] || wildcardStringifier || stringify)(value, stringifySafe);
+                    if (void 0 === value) continue;
+                    data += ',"' + key + '":' + value;
+                }
+            }
+            return data;
+        }
+        function hasBeenTampered(stream) {
+            return stream.write !== stream.constructor.prototype.write;
+        }
+        function buildSafeSonicBoom(opts) {
+            const stream = new SonicBoom(opts);
+            stream.on('error', filterBrokenPipe);
+            if (!opts.sync && isMainThread) {
+                onExit.register(stream, autoEnd);
+                stream.on('close', function() {
+                    onExit.unregister(stream);
+                });
+            }
+            return stream;
+            function filterBrokenPipe(err) {
+                if ('EPIPE' === err.code) {
+                    stream.write = noop;
+                    stream.end = noop;
+                    stream.flushSync = noop;
+                    stream.destroy = noop;
+                    return;
+                }
+                stream.removeListener('error', filterBrokenPipe);
+                stream.emit('error', err);
+            }
+        }
+        function autoEnd(stream, eventName) {
+            if (stream.destroyed) return;
+            if ('beforeExit' === eventName) {
+                stream.flush();
+                stream.on('drain', function() {
+                    stream.end();
+                });
+            } else stream.flushSync();
+        }
+        function createArgsNormalizer(defaultOptions) {
+            return function(instance, caller, opts = {}, stream) {
+                if ('string' == typeof opts) {
+                    stream = buildSafeSonicBoom({
+                        dest: opts
+                    });
+                    opts = {};
+                } else if ('string' == typeof stream) {
+                    if (opts && opts.transport) throw Error('only one of option.transport or stream can be specified');
+                    stream = buildSafeSonicBoom({
+                        dest: stream
+                    });
+                } else if (opts instanceof SonicBoom || opts.writable || opts._writableState) {
+                    stream = opts;
+                    opts = {};
+                } else if (opts.transport) {
+                    if (opts.transport instanceof SonicBoom || opts.transport.writable || opts.transport._writableState) throw Error('option.transport do not allow stream, please pass to option directly. e.g. pino(transport)');
+                    if (opts.transport.targets && opts.transport.targets.length && opts.formatters && 'function' == typeof opts.formatters.level) throw Error('option.transport.targets do not allow custom level formatters');
+                    let customLevels;
+                    if (opts.customLevels) customLevels = opts.useOnlyCustomLevels ? opts.customLevels : Object.assign({}, opts.levels, opts.customLevels);
+                    stream = transport({
+                        caller,
+                        ...opts.transport,
+                        levels: customLevels
+                    });
+                }
+                opts = Object.assign({}, defaultOptions, opts);
+                opts.serializers = Object.assign({}, defaultOptions.serializers, opts.serializers);
+                opts.formatters = Object.assign({}, defaultOptions.formatters, opts.formatters);
+                if (opts.prettyPrint) throw new Error('prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)');
+                const { enabled, onChild } = opts;
+                if (false === enabled) opts.level = 'silent';
+                if (!onChild) opts.onChild = noop;
+                if (!stream) stream = hasBeenTampered(process.stdout) ? process.stdout : buildSafeSonicBoom({
+                    fd: process.stdout.fd || 1
+                });
+                return {
+                    opts,
+                    stream
+                };
+            };
+        }
+        function stringify(obj, stringifySafeFn) {
+            try {
+                return JSON.stringify(obj);
+            } catch (_) {
+                try {
+                    const stringify = stringifySafeFn || this[stringifySafeSym];
+                    return stringify(obj);
+                } catch (_) {
+                    return '"[unable to serialize, circular reference is too complex to analyze]"';
+                }
+            }
+        }
+        function buildFormatters(level, bindings, log) {
+            return {
+                level,
+                bindings,
+                log
+            };
+        }
+        function normalizeDestFileDescriptor(destination) {
+            const fd = Number(destination);
+            if ('string' == typeof destination && Number.isFinite(fd)) return fd;
+            if (void 0 === destination) return 1;
+            return destination;
+        }
+        module1.exports = {
+            noop,
+            buildSafeSonicBoom,
+            asChindings,
+            asJson,
+            genLog,
+            createArgsNormalizer,
+            stringify,
+            buildFormatters,
+            normalizeDestFileDescriptor
+        };
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/transport.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const { createRequire } = __webpack_require__("module");
+        const getCallers = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/caller.js");
+        const { join, isAbsolute, sep } = __webpack_require__("node:path");
+        const sleep = __webpack_require__("../../node_modules/.pnpm/atomic-sleep@1.0.0/node_modules/atomic-sleep/index.js");
+        const onExit = __webpack_require__("../../node_modules/.pnpm/on-exit-leak-free@2.1.2/node_modules/on-exit-leak-free/index.js");
+        const ThreadStream = __webpack_require__("../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/index.js");
+        function setupOnExit(stream) {
+            onExit.register(stream, autoEnd);
+            onExit.registerBeforeExit(stream, flush);
+            stream.on('close', function() {
+                onExit.unregister(stream);
+            });
+        }
+        function buildStream(filename, workerData, workerOpts, sync) {
+            const stream = new ThreadStream({
+                filename,
+                workerData,
+                workerOpts,
+                sync
+            });
+            stream.on('ready', onReady);
+            stream.on('close', function() {
+                process.removeListener('exit', onExit);
+            });
+            process.on('exit', onExit);
+            function onReady() {
+                process.removeListener('exit', onExit);
+                stream.unref();
+                if (false !== workerOpts.autoEnd) setupOnExit(stream);
+            }
+            function onExit() {
+                if (stream.closed) return;
+                stream.flushSync();
+                sleep(100);
+                stream.end();
+            }
+            return stream;
+        }
+        function autoEnd(stream) {
+            stream.ref();
+            stream.flushSync();
+            stream.end();
+            stream.once('close', function() {
+                stream.unref();
+            });
+        }
+        function flush(stream) {
+            stream.flushSync();
+        }
+        function transport(fullOptions) {
+            const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions;
+            const options = {
+                ...fullOptions.options
+            };
+            const callers = 'string' == typeof caller ? [
+                caller
+            ] : caller;
+            const bundlerOverrides = '__bundlerPathsOverrides' in globalThis ? globalThis.__bundlerPathsOverrides : {};
+            let target = fullOptions.target;
+            if (target && targets) throw new Error('only one of target or targets can be specified');
+            if (targets) {
+                target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js');
+                options.targets = targets.filter((dest)=>dest.target).map((dest)=>({
+                        ...dest,
+                        target: fixTarget(dest.target)
+                    }));
+                options.pipelines = targets.filter((dest)=>dest.pipeline).map((dest)=>dest.pipeline.map((t)=>({
+                            ...t,
+                            level: dest.level,
+                            target: fixTarget(t.target)
+                        })));
+            } else if (pipeline) {
+                target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js');
+                options.pipelines = [
+                    pipeline.map((dest)=>({
+                            ...dest,
+                            target: fixTarget(dest.target)
+                        }))
+                ];
+            }
+            if (levels) options.levels = levels;
+            if (dedupe) options.dedupe = dedupe;
+            options.pinoWillSendConfig = true;
+            return buildStream(fixTarget(target), options, worker, sync);
+            function fixTarget(origin) {
+                origin = bundlerOverrides[origin] || origin;
+                if (isAbsolute(origin) || 0 === origin.indexOf('file://')) return origin;
+                if ('pino/file' === origin) return join(__dirname, '..', 'file.js');
+                let fixTarget;
+                for (const filePath of callers)try {
+                    const context = 'node:repl' === filePath ? process.cwd() + sep : filePath;
+                    fixTarget = createRequire(context).resolve(origin);
+                    break;
+                } catch (err) {
+                    continue;
+                }
+                if (!fixTarget) throw new Error(`unable to determine transport target for "${origin}"`);
+                return fixTarget;
+            }
+        }
+        module1.exports = transport;
+    },
+    "../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/pino.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const os = __webpack_require__("node:os");
+        const stdSerializers = __webpack_require__("../../node_modules/.pnpm/pino-std-serializers@7.0.0/node_modules/pino-std-serializers/index.js");
+        const caller = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/caller.js");
+        const redaction = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/redaction.js");
+        const time = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/time.js");
+        const proto = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/proto.js");
+        const symbols = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/symbols.js");
+        const { configure } = __webpack_require__("../../node_modules/.pnpm/safe-stable-stringify@2.5.0/node_modules/safe-stable-stringify/index.js");
+        const { assertDefaultLevelFound, mappings, genLsCache, genLevelComparison, assertLevelComparison } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/levels.js");
+        const { DEFAULT_LEVELS, SORTING_ORDER } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/constants.js");
+        const { createArgsNormalizer, asChindings, buildSafeSonicBoom, buildFormatters, stringify, normalizeDestFileDescriptor, noop } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/tools.js");
+        const { version } = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/meta.js");
+        const { chindingsSym, redactFmtSym, serializersSym, timeSym, timeSliceIndexSym, streamSym, stringifySym, stringifySafeSym, stringifiersSym, setLevelSym, endSym, formatOptsSym, messageKeySym, errorKeySym, nestedKeySym, mixinSym, levelCompSym, useOnlyCustomLevelsSym, formattersSym, hooksSym, nestedKeyStrSym, mixinMergeStrategySym, msgPrefixSym } = symbols;
+        const { epochTime, nullTime } = time;
+        const { pid } = process;
+        const hostname = os.hostname();
+        const defaultErrorSerializer = stdSerializers.err;
+        const defaultOptions = {
+            level: 'info',
+            levelComparison: SORTING_ORDER.ASC,
+            levels: DEFAULT_LEVELS,
+            messageKey: 'msg',
+            errorKey: 'err',
+            nestedKey: null,
+            enabled: true,
+            base: {
+                pid,
+                hostname
+            },
+            serializers: Object.assign(Object.create(null), {
+                err: defaultErrorSerializer
+            }),
+            formatters: Object.assign(Object.create(null), {
+                bindings (bindings) {
+                    return bindings;
+                },
+                level (label, number) {
+                    return {
+                        level: number
+                    };
+                }
+            }),
+            hooks: {
+                logMethod: void 0,
+                streamWrite: void 0
+            },
+            timestamp: epochTime,
+            name: void 0,
+            redact: null,
+            customLevels: null,
+            useOnlyCustomLevels: false,
+            depthLimit: 5,
+            edgeLimit: 100
+        };
+        const normalize = createArgsNormalizer(defaultOptions);
+        const serializers = Object.assign(Object.create(null), stdSerializers);
+        function pino(...args) {
+            const instance = {};
+            const { opts, stream } = normalize(instance, caller(), ...args);
+            if (opts.level && 'string' == typeof opts.level && void 0 !== DEFAULT_LEVELS[opts.level.toLowerCase()]) opts.level = opts.level.toLowerCase();
+            const { redact, crlf, serializers, timestamp, messageKey, errorKey, nestedKey, base, name, level, customLevels, levelComparison, mixin, mixinMergeStrategy, useOnlyCustomLevels, formatters, hooks, depthLimit, edgeLimit, onChild, msgPrefix } = opts;
+            const stringifySafe = configure({
+                maximumDepth: depthLimit,
+                maximumBreadth: edgeLimit
+            });
+            const allFormatters = buildFormatters(formatters.level, formatters.bindings, formatters.log);
+            const stringifyFn = stringify.bind({
+                [stringifySafeSym]: stringifySafe
+            });
+            const stringifiers = redact ? redaction(redact, stringifyFn) : {};
+            const formatOpts = redact ? {
+                stringify: stringifiers[redactFmtSym]
+            } : {
+                stringify: stringifyFn
+            };
+            const end = '}' + (crlf ? '\r\n' : '\n');
+            const coreChindings = asChindings.bind(null, {
+                [chindingsSym]: '',
+                [serializersSym]: serializers,
+                [stringifiersSym]: stringifiers,
+                [stringifySym]: stringify,
+                [stringifySafeSym]: stringifySafe,
+                [formattersSym]: allFormatters
+            });
+            let chindings = '';
+            if (null !== base) chindings = void 0 === name ? coreChindings(base) : coreChindings(Object.assign({}, base, {
+                name
+            }));
+            const time = timestamp instanceof Function ? timestamp : timestamp ? epochTime : nullTime;
+            const timeSliceIndex = time().indexOf(':') + 1;
+            if (useOnlyCustomLevels && !customLevels) throw Error('customLevels is required if useOnlyCustomLevels is set true');
+            if (mixin && 'function' != typeof mixin) throw Error(`Unknown mixin type "${typeof mixin}" - expected "function"`);
+            if (msgPrefix && 'string' != typeof msgPrefix) throw Error(`Unknown msgPrefix type "${typeof msgPrefix}" - expected "string"`);
+            assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels);
+            const levels = mappings(customLevels, useOnlyCustomLevels);
+            if ('function' == typeof stream.emit) stream.emit('message', {
+                code: 'PINO_CONFIG',
+                config: {
+                    levels,
+                    messageKey,
+                    errorKey
+                }
+            });
+            assertLevelComparison(levelComparison);
+            const levelCompFunc = genLevelComparison(levelComparison);
+            Object.assign(instance, {
+                levels,
+                [levelCompSym]: levelCompFunc,
+                [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
+                [streamSym]: stream,
+                [timeSym]: time,
+                [timeSliceIndexSym]: timeSliceIndex,
+                [stringifySym]: stringify,
+                [stringifySafeSym]: stringifySafe,
+                [stringifiersSym]: stringifiers,
+                [endSym]: end,
+                [formatOptsSym]: formatOpts,
+                [messageKeySym]: messageKey,
+                [errorKeySym]: errorKey,
+                [nestedKeySym]: nestedKey,
+                [nestedKeyStrSym]: nestedKey ? `,${JSON.stringify(nestedKey)}:{` : '',
+                [serializersSym]: serializers,
+                [mixinSym]: mixin,
+                [mixinMergeStrategySym]: mixinMergeStrategy,
+                [chindingsSym]: chindings,
+                [formattersSym]: allFormatters,
+                [hooksSym]: hooks,
+                silent: noop,
+                onChild,
+                [msgPrefixSym]: msgPrefix
+            });
+            Object.setPrototypeOf(instance, proto());
+            genLsCache(instance);
+            instance[setLevelSym](level);
+            return instance;
+        }
+        module1.exports = pino;
+        module1.exports.destination = (dest = process.stdout.fd)=>{
+            if ('object' != typeof dest) return buildSafeSonicBoom({
+                dest: normalizeDestFileDescriptor(dest),
+                minLength: 0
+            });
+            dest.dest = normalizeDestFileDescriptor(dest.dest || process.stdout.fd);
+            return buildSafeSonicBoom(dest);
+        };
+        module1.exports.transport = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/transport.js");
+        module1.exports.multistream = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/lib/multistream.js");
+        module1.exports.levels = mappings();
+        module1.exports.stdSerializers = serializers;
+        module1.exports.stdTimeFunctions = Object.assign({}, time);
+        module1.exports.symbols = symbols;
+        module1.exports.version = version;
+        module1.exports["default"] = pino;
+        module1.exports.pino = pino;
+    },
+    "../../node_modules/.pnpm/sonic-boom@4.2.0/node_modules/sonic-boom/index.js": function(module1, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        const fs = __webpack_require__("fs");
+        const EventEmitter = __webpack_require__("events");
+        const inherits = __webpack_require__("util").inherits;
+        const path = __webpack_require__("path");
+        const sleep = __webpack_require__("../../node_modules/.pnpm/atomic-sleep@1.0.0/node_modules/atomic-sleep/index.js");
+        const assert = __webpack_require__("assert");
+        const BUSY_WRITE_TIMEOUT = 100;
+        const kEmptyBuffer = Buffer.allocUnsafe(0);
+        const MAX_WRITE = 16384;
+        const kContentModeBuffer = 'buffer';
+        const kContentModeUtf8 = 'utf8';
+        const [major, minor] = (process.versions.node || '0.0').split('.').map(Number);
+        const kCopyBuffer = major >= 22 && minor >= 7;
+        function openFile(file, sonic) {
+            sonic._opening = true;
+            sonic._writing = true;
+            sonic._asyncDrainScheduled = false;
+            function fileOpened(err, fd) {
+                if (err) {
+                    sonic._reopening = false;
+                    sonic._writing = false;
+                    sonic._opening = false;
+                    if (sonic.sync) process.nextTick(()=>{
+                        if (sonic.listenerCount('error') > 0) sonic.emit('error', err);
+                    });
+                    else sonic.emit('error', err);
+                    return;
+                }
+                const reopening = sonic._reopening;
+                sonic.fd = fd;
+                sonic.file = file;
+                sonic._reopening = false;
+                sonic._opening = false;
+                sonic._writing = false;
+                if (sonic.sync) process.nextTick(()=>sonic.emit('ready'));
+                else sonic.emit('ready');
+                if (sonic.destroyed) return;
+                if (!sonic._writing && sonic._len > sonic.minLength || sonic._flushPending) sonic._actualWrite();
+                else if (reopening) process.nextTick(()=>sonic.emit('drain'));
+            }
+            const flags = sonic.append ? 'a' : 'w';
+            const mode = sonic.mode;
+            if (sonic.sync) try {
+                if (sonic.mkdir) fs.mkdirSync(path.dirname(file), {
+                    recursive: true
+                });
+                const fd = fs.openSync(file, flags, mode);
+                fileOpened(null, fd);
+            } catch (err) {
+                fileOpened(err);
+                throw err;
+            }
+            else if (sonic.mkdir) fs.mkdir(path.dirname(file), {
+                recursive: true
+            }, (err)=>{
+                if (err) return fileOpened(err);
+                fs.open(file, flags, mode, fileOpened);
+            });
+            else fs.open(file, flags, mode, fileOpened);
+        }
+        function SonicBoom(opts) {
+            if (!(this instanceof SonicBoom)) return new SonicBoom(opts);
+            let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+            fd = fd || dest;
+            this._len = 0;
+            this.fd = -1;
+            this._bufs = [];
+            this._lens = [];
+            this._writing = false;
+            this._ending = false;
+            this._reopening = false;
+            this._asyncDrainScheduled = false;
+            this._flushPending = false;
+            this._hwm = Math.max(minLength || 0, 16387);
+            this.file = null;
+            this.destroyed = false;
+            this.minLength = minLength || 0;
+            this.maxLength = maxLength || 0;
+            this.maxWrite = maxWrite || MAX_WRITE;
+            this._periodicFlush = periodicFlush || 0;
+            this._periodicFlushTimer = void 0;
+            this.sync = sync || false;
+            this.writable = true;
+            this._fsync = fsync || false;
+            this.append = append || false;
+            this.mode = mode;
+            this.retryEAGAIN = retryEAGAIN || (()=>true);
+            this.mkdir = mkdir || false;
+            let fsWriteSync;
+            let fsWrite;
+            if (contentMode === kContentModeBuffer) {
+                this._writingBuf = kEmptyBuffer;
+                this.write = writeBuffer;
+                this.flush = flushBuffer;
+                this.flushSync = flushBufferSync;
+                this._actualWrite = actualWriteBuffer;
+                fsWriteSync = ()=>fs.writeSync(this.fd, this._writingBuf);
+                fsWrite = ()=>fs.write(this.fd, this._writingBuf, this.release);
+            } else if (void 0 === contentMode || contentMode === kContentModeUtf8) {
+                this._writingBuf = '';
+                this.write = write;
+                this.flush = flush;
+                this.flushSync = flushSync;
+                this._actualWrite = actualWrite;
+                fsWriteSync = ()=>fs.writeSync(this.fd, this._writingBuf, 'utf8');
+                fsWrite = ()=>fs.write(this.fd, this._writingBuf, 'utf8', this.release);
+            } else throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
+            if ('number' == typeof fd) {
+                this.fd = fd;
+                process.nextTick(()=>this.emit('ready'));
+            } else if ('string' == typeof fd) openFile(fd, this);
+            else throw new Error("SonicBoom supports only file descriptors and files");
+            if (this.minLength >= this.maxWrite) throw new Error(`minLength should be smaller than maxWrite (${this.maxWrite})`);
+            this.release = (err, n1)=>{
+                if (err) {
+                    if (('EAGAIN' === err.code || 'EBUSY' === err.code) && this.retryEAGAIN(err, this._writingBuf.length, this._len - this._writingBuf.length)) if (this.sync) try {
+                        sleep(BUSY_WRITE_TIMEOUT);
+                        this.release(void 0, 0);
+                    } catch (err) {
+                        this.release(err);
+                    }
+                    else setTimeout(fsWrite, BUSY_WRITE_TIMEOUT);
+                    else {
+                        this._writing = false;
+                        this.emit('error', err);
+                    }
+                    return;
+                }
+                this.emit('write', n1);
+                const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n1);
+                this._len = releasedBufObj.len;
+                this._writingBuf = releasedBufObj.writingBuf;
+                if (this._writingBuf.length) {
+                    if (!this.sync) return void fsWrite();
+                    try {
+                        do {
+                            const n1 = fsWriteSync();
+                            const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n1);
+                            this._len = releasedBufObj.len;
+                            this._writingBuf = releasedBufObj.writingBuf;
+                        }while (this._writingBuf.length);
+                    } catch (err) {
+                        this.release(err);
+                        return;
+                    }
+                }
+                if (this._fsync) fs.fsyncSync(this.fd);
+                const len = this._len;
+                if (this._reopening) {
+                    this._writing = false;
+                    this._reopening = false;
+                    this.reopen();
+                } else if (len > this.minLength) this._actualWrite();
+                else if (this._ending) if (len > 0) this._actualWrite();
+                else {
+                    this._writing = false;
+                    actualClose(this);
+                }
+                else {
+                    this._writing = false;
+                    if (this.sync) {
+                        if (!this._asyncDrainScheduled) {
+                            this._asyncDrainScheduled = true;
+                            process.nextTick(emitDrain, this);
+                        }
+                    } else this.emit('drain');
+                }
+            };
+            this.on('newListener', function(name) {
+                if ('drain' === name) this._asyncDrainScheduled = false;
+            });
+            if (0 !== this._periodicFlush) {
+                this._periodicFlushTimer = setInterval(()=>this.flush(null), this._periodicFlush);
+                this._periodicFlushTimer.unref();
+            }
+        }
+        function releaseWritingBuf(writingBuf, len, n1) {
+            if ('string' == typeof writingBuf && Buffer.byteLength(writingBuf) !== n1) n1 = Buffer.from(writingBuf).subarray(0, n1).toString().length;
+            len = Math.max(len - n1, 0);
+            writingBuf = writingBuf.slice(n1);
+            return {
+                writingBuf,
+                len
+            };
+        }
+        function emitDrain(sonic) {
+            const hasListeners = sonic.listenerCount('drain') > 0;
+            if (!hasListeners) return;
+            sonic._asyncDrainScheduled = false;
+            sonic.emit('drain');
+        }
+        inherits(SonicBoom, EventEmitter);
+        function mergeBuf(bufs, len) {
+            if (0 === bufs.length) return kEmptyBuffer;
+            if (1 === bufs.length) return bufs[0];
+            return Buffer.concat(bufs, len);
+        }
+        function write(data) {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            const len = this._len + data.length;
+            const bufs = this._bufs;
+            if (this.maxLength && len > this.maxLength) {
+                this.emit('drop', data);
+                return this._len < this._hwm;
+            }
+            if (0 === bufs.length || bufs[bufs.length - 1].length + data.length > this.maxWrite) bufs.push('' + data);
+            else bufs[bufs.length - 1] += data;
+            this._len = len;
+            if (!this._writing && this._len >= this.minLength) this._actualWrite();
+            return this._len < this._hwm;
+        }
+        function writeBuffer(data) {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            const len = this._len + data.length;
+            const bufs = this._bufs;
+            const lens = this._lens;
+            if (this.maxLength && len > this.maxLength) {
+                this.emit('drop', data);
+                return this._len < this._hwm;
+            }
+            if (0 === bufs.length || lens[lens.length - 1] + data.length > this.maxWrite) {
+                bufs.push([
+                    data
+                ]);
+                lens.push(data.length);
+            } else {
+                bufs[bufs.length - 1].push(data);
+                lens[lens.length - 1] += data.length;
+            }
+            this._len = len;
+            if (!this._writing && this._len >= this.minLength) this._actualWrite();
+            return this._len < this._hwm;
+        }
+        function callFlushCallbackOnDrain(cb) {
+            this._flushPending = true;
+            const onDrain = ()=>{
+                if (this._fsync) {
+                    this._flushPending = false;
+                    cb();
+                } else try {
+                    fs.fsync(this.fd, (err)=>{
+                        this._flushPending = false;
+                        cb(err);
+                    });
+                } catch (err) {
+                    cb(err);
+                }
+                this.off('error', onError);
+            };
+            const onError = (err)=>{
+                this._flushPending = false;
+                cb(err);
+                this.off('drain', onDrain);
+            };
+            this.once('drain', onDrain);
+            this.once('error', onError);
+        }
+        function flush(cb) {
+            if (null != cb && 'function' != typeof cb) throw new Error('flush cb must be a function');
+            if (this.destroyed) {
+                const error = new Error('SonicBoom destroyed');
+                if (cb) return void cb(error);
+                throw error;
+            }
+            if (this.minLength <= 0) return void cb?.();
+            if (cb) callFlushCallbackOnDrain.call(this, cb);
+            if (this._writing) return;
+            if (0 === this._bufs.length) this._bufs.push('');
+            this._actualWrite();
+        }
+        function flushBuffer(cb) {
+            if (null != cb && 'function' != typeof cb) throw new Error('flush cb must be a function');
+            if (this.destroyed) {
+                const error = new Error('SonicBoom destroyed');
+                if (cb) return void cb(error);
+                throw error;
+            }
+            if (this.minLength <= 0) return void cb?.();
+            if (cb) callFlushCallbackOnDrain.call(this, cb);
+            if (this._writing) return;
+            if (0 === this._bufs.length) {
+                this._bufs.push([]);
+                this._lens.push(0);
+            }
+            this._actualWrite();
+        }
+        SonicBoom.prototype.reopen = function(file) {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            if (this._opening) return void this.once('ready', ()=>{
+                this.reopen(file);
+            });
+            if (this._ending) return;
+            if (!this.file) throw new Error("Unable to reopen a file descriptor, you must pass a file to SonicBoom");
+            if (file) this.file = file;
+            this._reopening = true;
+            if (this._writing) return;
+            const fd = this.fd;
+            this.once('ready', ()=>{
+                if (fd !== this.fd) fs.close(fd, (err)=>{
+                    if (err) return this.emit('error', err);
+                });
+            });
+            openFile(this.file, this);
+        };
+        SonicBoom.prototype.end = function() {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            if (this._opening) return void this.once('ready', ()=>{
+                this.end();
+            });
+            if (this._ending) return;
+            this._ending = true;
+            if (this._writing) return;
+            if (this._len > 0 && this.fd >= 0) this._actualWrite();
+            else actualClose(this);
+        };
+        function flushSync() {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            if (this.fd < 0) throw new Error('sonic boom is not ready yet');
+            if (!this._writing && this._writingBuf.length > 0) {
+                this._bufs.unshift(this._writingBuf);
+                this._writingBuf = '';
+            }
+            let buf = '';
+            while(this._bufs.length || buf){
+                if (buf.length <= 0) buf = this._bufs[0];
+                try {
+                    const n1 = fs.writeSync(this.fd, buf, 'utf8');
+                    const releasedBufObj = releaseWritingBuf(buf, this._len, n1);
+                    buf = releasedBufObj.writingBuf;
+                    this._len = releasedBufObj.len;
+                    if (buf.length <= 0) this._bufs.shift();
+                } catch (err) {
+                    const shouldRetry = 'EAGAIN' === err.code || 'EBUSY' === err.code;
+                    if (shouldRetry && !this.retryEAGAIN(err, buf.length, this._len - buf.length)) throw err;
+                    sleep(BUSY_WRITE_TIMEOUT);
+                }
+            }
+            try {
+                fs.fsyncSync(this.fd);
+            } catch  {}
+        }
+        function flushBufferSync() {
+            if (this.destroyed) throw new Error('SonicBoom destroyed');
+            if (this.fd < 0) throw new Error('sonic boom is not ready yet');
+            if (!this._writing && this._writingBuf.length > 0) {
+                this._bufs.unshift([
+                    this._writingBuf
+                ]);
+                this._writingBuf = kEmptyBuffer;
+            }
+            let buf = kEmptyBuffer;
+            while(this._bufs.length || buf.length){
+                if (buf.length <= 0) buf = mergeBuf(this._bufs[0], this._lens[0]);
+                try {
+                    const n1 = fs.writeSync(this.fd, buf);
+                    buf = buf.subarray(n1);
+                    this._len = Math.max(this._len - n1, 0);
+                    if (buf.length <= 0) {
+                        this._bufs.shift();
+                        this._lens.shift();
+                    }
+                } catch (err) {
+                    const shouldRetry = 'EAGAIN' === err.code || 'EBUSY' === err.code;
+                    if (shouldRetry && !this.retryEAGAIN(err, buf.length, this._len - buf.length)) throw err;
+                    sleep(BUSY_WRITE_TIMEOUT);
+                }
+            }
+        }
+        SonicBoom.prototype.destroy = function() {
+            if (this.destroyed) return;
+            actualClose(this);
+        };
+        function actualWrite() {
+            const release = this.release;
+            this._writing = true;
+            this._writingBuf = this._writingBuf || this._bufs.shift() || '';
+            if (this.sync) try {
+                const written = fs.writeSync(this.fd, this._writingBuf, 'utf8');
+                release(null, written);
+            } catch (err) {
+                release(err);
+            }
+            else fs.write(this.fd, this._writingBuf, 'utf8', release);
+        }
+        function actualWriteBuffer() {
+            const release = this.release;
+            this._writing = true;
+            this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift());
+            if (this.sync) try {
+                const written = fs.writeSync(this.fd, this._writingBuf);
+                release(null, written);
+            } catch (err) {
+                release(err);
+            }
+            else {
+                if (kCopyBuffer) this._writingBuf = Buffer.from(this._writingBuf);
+                fs.write(this.fd, this._writingBuf, release);
+            }
+        }
+        function actualClose(sonic) {
+            if (-1 === sonic.fd) return void sonic.once('ready', actualClose.bind(null, sonic));
+            if (void 0 !== sonic._periodicFlushTimer) clearInterval(sonic._periodicFlushTimer);
+            sonic.destroyed = true;
+            sonic._bufs = [];
+            sonic._lens = [];
+            assert('number' == typeof sonic.fd, `sonic.fd must be a number, got ${typeof sonic.fd}`);
+            try {
+                fs.fsync(sonic.fd, closeWrapped);
+            } catch  {}
+            function closeWrapped() {
+                if (1 !== sonic.fd && 2 !== sonic.fd) fs.close(sonic.fd, done);
+                else done();
+            }
+            function done(err) {
+                if (err) return void sonic.emit('error', err);
+                if (sonic._ending && !sonic._writing) sonic.emit('finish');
+                sonic.emit('close');
+            }
+        }
+        SonicBoom.SonicBoom = SonicBoom;
+        SonicBoom.default = SonicBoom;
+        module1.exports = SonicBoom;
+    },
+    "../../node_modules/.pnpm/thread-stream@3.1.0/node_modules/thread-stream/package.json": function(module1) {
+        "use strict";
+        module1.exports = JSON.parse('{"name":"thread-stream","version":"3.1.0","description":"A streaming way to send data to a Node.js Worker Thread","main":"index.js","types":"index.d.ts","dependencies":{"real-require":"^0.2.0"},"devDependencies":{"@types/node":"^20.1.0","@types/tap":"^15.0.0","@yao-pkg/pkg":"^5.11.5","desm":"^1.3.0","fastbench":"^1.0.1","husky":"^9.0.6","pino-elasticsearch":"^8.0.0","sonic-boom":"^4.0.1","standard":"^17.0.0","tap":"^16.2.0","ts-node":"^10.8.0","typescript":"^5.3.2","why-is-node-running":"^2.2.2"},"scripts":{"build":"tsc --noEmit","test":"standard && npm run build && npm run transpile && tap \\"test/**/*.test.*js\\" && tap --ts test/*.test.*ts","test:ci":"standard && npm run transpile && npm run test:ci:js && npm run test:ci:ts","test:ci:js":"tap --no-check-coverage --timeout=120 --coverage-report=lcovonly \\"test/**/*.test.*js\\"","test:ci:ts":"tap --ts --no-check-coverage --coverage-report=lcovonly \\"test/**/*.test.*ts\\"","test:yarn":"npm run transpile && tap \\"test/**/*.test.js\\" --no-check-coverage","transpile":"sh ./test/ts/transpile.sh","prepare":"husky install"},"standard":{"ignore":["test/ts/**/*","test/syntax-error.mjs"]},"repository":{"type":"git","url":"git+https://github.com/mcollina/thread-stream.git"},"keywords":["worker","thread","threads","stream"],"author":"Matteo Collina <hello@matteocollina.com>","license":"MIT","bugs":{"url":"https://github.com/mcollina/thread-stream/issues"},"homepage":"https://github.com/mcollina/thread-stream#readme"}');
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module1 = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module1, module1.exports, __webpack_require__);
+    return module1.exports;
+}
+var __webpack_exports__ = __webpack_require__("../../node_modules/.pnpm/pino@10.1.0/node_modules/pino/file.js");
+module.exports = __webpack_exports__;