@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-SLJ5L7PY.mjs

@@ -0,0 +1,1473 @@
+import { createRequire as __adfCreateRequire } from 'node:module';
+import { fileURLToPath as __adfFileURLToPath } from 'node:url';
+import { dirname as __adfDirname } from 'node:path';
+const require = __adfCreateRequire(import.meta.url);
+const __filename = __adfFileURLToPath(import.meta.url);
+const __dirname = __adfDirname(__filename);
+import {
+  require_atomic_sleep,
+  require_on_exit_leak_free,
+  require_pino_std_serializers,
+  require_quick_format_unescaped,
+  require_redact,
+  require_safe_stable_stringify,
+  require_sonic_boom
+} from "./chunk-7N2R2VCG.mjs";
+import {
+  __commonJS,
+  __require
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/pino/lib/caller.js
+var require_caller = __commonJS({
+  "node_modules/pino/lib/caller.js"(exports, module) {
+    "use strict";
+    function noOpPrepareStackTrace(_, stack) {
+      return stack;
+    }
+    module.exports = function() {
+      let originalPrepare = Error.prepareStackTrace;
+      Error.prepareStackTrace = noOpPrepareStackTrace;
+      let stack = new Error().stack;
+      if (Error.prepareStackTrace = originalPrepare, !Array.isArray(stack))
+        return;
+      let entries = stack.slice(2), fileNames = [];
+      for (let entry of entries)
+        entry && fileNames.push(entry.getFileName());
+      return fileNames;
+    };
+  }
+});
+
+// node_modules/pino/lib/symbols.js
+var require_symbols = __commonJS({
+  "node_modules/pino/lib/symbols.js"(exports, module) {
+    "use strict";
+    var setLevelSym = /* @__PURE__ */ Symbol("pino.setLevel"), getLevelSym = /* @__PURE__ */ Symbol("pino.getLevel"), levelValSym = /* @__PURE__ */ Symbol("pino.levelVal"), levelCompSym = /* @__PURE__ */ Symbol("pino.levelComp"), useLevelLabelsSym = /* @__PURE__ */ Symbol("pino.useLevelLabels"), useOnlyCustomLevelsSym = /* @__PURE__ */ Symbol("pino.useOnlyCustomLevels"), mixinSym = /* @__PURE__ */ Symbol("pino.mixin"), lsCacheSym = /* @__PURE__ */ Symbol("pino.lsCache"), chindingsSym = /* @__PURE__ */ Symbol("pino.chindings"), asJsonSym = /* @__PURE__ */ Symbol("pino.asJson"), writeSym = /* @__PURE__ */ Symbol("pino.write"), redactFmtSym = /* @__PURE__ */ Symbol("pino.redactFmt"), timeSym = /* @__PURE__ */ Symbol("pino.time"), timeSliceIndexSym = /* @__PURE__ */ Symbol("pino.timeSliceIndex"), streamSym = /* @__PURE__ */ Symbol("pino.stream"), stringifySym = /* @__PURE__ */ Symbol("pino.stringify"), stringifySafeSym = /* @__PURE__ */ Symbol("pino.stringifySafe"), stringifiersSym = /* @__PURE__ */ Symbol("pino.stringifiers"), endSym = /* @__PURE__ */ Symbol("pino.end"), formatOptsSym = /* @__PURE__ */ Symbol("pino.formatOpts"), messageKeySym = /* @__PURE__ */ Symbol("pino.messageKey"), errorKeySym = /* @__PURE__ */ Symbol("pino.errorKey"), nestedKeySym = /* @__PURE__ */ Symbol("pino.nestedKey"), nestedKeyStrSym = /* @__PURE__ */ Symbol("pino.nestedKeyStr"), mixinMergeStrategySym = /* @__PURE__ */ Symbol("pino.mixinMergeStrategy"), msgPrefixSym = /* @__PURE__ */ Symbol("pino.msgPrefix"), wildcardFirstSym = /* @__PURE__ */ Symbol("pino.wildcardFirst"), serializersSym = /* @__PURE__ */ Symbol.for("pino.serializers"), formattersSym = /* @__PURE__ */ Symbol.for("pino.formatters"), hooksSym = /* @__PURE__ */ Symbol.for("pino.hooks"), needsMetadataGsym = /* @__PURE__ */ Symbol.for("pino.metadata");
+    module.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/pino/lib/redaction.js
+var require_redaction = __commonJS({
+  "node_modules/pino/lib/redaction.js"(exports, module) {
+    "use strict";
+    var Redact = require_redact(), { redactFmtSym, wildcardFirstSym } = require_symbols(), rx = /[^.[\]]+|\[([^[\]]*?)\]/g, CENSOR = "[Redacted]", strict = !1;
+    function redaction(opts, serialize) {
+      let { paths, censor, remove } = handle(opts), shape = paths.reduce((o, str) => {
+        rx.lastIndex = 0;
+        let first = rx.exec(str), next = rx.exec(str), ns = first[1] !== void 0 ? first[1].replace(/^(?:"|'|`)(.*)(?:"|'|`)$/, "$1") : first[0];
+        if (ns === "*" && (ns = wildcardFirstSym), next === null)
+          return o[ns] = null, o;
+        if (o[ns] === null)
+          return o;
+        let { index } = next, nextPath = `${str.substr(index, str.length - 1)}`;
+        return o[ns] = o[ns] || [], ns !== wildcardFirstSym && o[ns].length === 0 && o[ns].push(...o[wildcardFirstSym] || []), ns === wildcardFirstSym && Object.keys(o).forEach(function(k) {
+          o[k] && o[k].push(nextPath);
+        }), o[ns].push(nextPath), o;
+      }, {}), result = {
+        [redactFmtSym]: Redact({ paths, censor, serialize, strict, remove })
+      }, topCensor = (...args) => serialize(typeof censor == "function" ? censor(...args) : censor);
+      return [...Object.keys(shape), ...Object.getOwnPropertySymbols(shape)].reduce((o, k) => {
+        if (shape[k] === null)
+          o[k] = (value) => topCensor(value, [k]);
+        else {
+          let wrappedCensor = typeof censor == "function" ? (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))
+        return opts = { paths: opts, censor: CENSOR }, opts;
+      let { paths, censor = CENSOR, remove } = opts;
+      if (Array.isArray(paths) === !1)
+        throw Error("pino \u2013 redact must contain an array of strings");
+      return remove === !0 && (censor = void 0), { paths, censor, remove };
+    }
+    module.exports = redaction;
+  }
+});
+
+// node_modules/pino/lib/time.js
+var require_time = __commonJS({
+  "node_modules/pino/lib/time.js"(exports, module) {
+    "use strict";
+    var nullTime = () => "", epochTime = () => `,"time":${Date.now()}`, unixTime = () => `,"time":${Math.round(Date.now() / 1e3)}`, isoTime = () => `,"time":"${new Date(Date.now()).toISOString()}"`, NS_PER_MS = 1000000n, NS_PER_SEC = 1000000000n, startWallTimeNs = BigInt(Date.now()) * NS_PER_MS, startHrTime = process.hrtime.bigint(), isoTimeNano = () => {
+      let elapsedNs = process.hrtime.bigint() - startHrTime, currentTimeNs = startWallTimeNs + elapsedNs, secondsSinceEpoch = currentTimeNs / NS_PER_SEC, nanosWithinSecond = currentTimeNs % NS_PER_SEC, msSinceEpoch = Number(secondsSinceEpoch * 1000n + nanosWithinSecond / 1000000n), date = new Date(msSinceEpoch), year = date.getUTCFullYear(), month = (date.getUTCMonth() + 1).toString().padStart(2, "0"), day = date.getUTCDate().toString().padStart(2, "0"), hours = date.getUTCHours().toString().padStart(2, "0"), minutes = date.getUTCMinutes().toString().padStart(2, "0"), seconds = date.getUTCSeconds().toString().padStart(2, "0");
+      return `,"time":"${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${nanosWithinSecond.toString().padStart(9, "0")}Z"`;
+    };
+    module.exports = { nullTime, epochTime, unixTime, isoTime, isoTimeNano };
+  }
+});
+
+// node_modules/thread-stream/package.json
+var require_package = __commonJS({
+  "node_modules/thread-stream/package.json"(exports, module) {
+    module.exports = {
+      name: "thread-stream",
+      version: "4.0.0",
+      description: "A streaming way to send data to a Node.js Worker Thread",
+      main: "index.js",
+      types: "index.d.ts",
+      engines: {
+        node: ">=20"
+      },
+      dependencies: {
+        "real-require": "^0.2.0"
+      },
+      devDependencies: {
+        "@types/node": "^22.0.0",
+        "@yao-pkg/pkg": "^6.0.0",
+        borp: "^0.21.0",
+        desm: "^1.3.0",
+        eslint: "^9.39.1",
+        fastbench: "^1.0.1",
+        husky: "^9.0.6",
+        neostandard: "^0.12.2",
+        "pino-elasticsearch": "^8.0.0",
+        "sonic-boom": "^4.0.1",
+        "ts-node": "^10.8.0",
+        typescript: "~5.7.3"
+      },
+      scripts: {
+        build: "tsc --noEmit",
+        lint: "eslint",
+        test: "npm run lint && npm run build && npm run transpile && borp --pattern 'test/*.test.{js,mjs}'",
+        "test:ci": "npm run lint && npm run transpile && borp --pattern 'test/*.test.{js,mjs}'",
+        "test:yarn": "npm run transpile && borp --pattern 'test/*.test.js'",
+        transpile: "sh ./test/ts/transpile.sh",
+        prepare: "husky install"
+      },
+      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"
+    };
+  }
+});
+
+// node_modules/thread-stream/lib/wait.js
+var require_wait = __commonJS({
+  "node_modules/thread-stream/lib/wait.js"(exports, module) {
+    "use strict";
+    function wait(state, index, expected, timeout, done) {
+      let max = timeout === 1 / 0 ? 1 / 0 : Date.now() + timeout, check = () => {
+        let current = Atomics.load(state, index);
+        if (current === expected) {
+          done(null, "ok");
+          return;
+        }
+        if (max !== 1 / 0 && Date.now() > max) {
+          done(null, "timed-out");
+          return;
+        }
+        let remaining = max === 1 / 0 ? 1e4 : Math.min(1e4, Math.max(1, max - Date.now())), result = Atomics.waitAsync(state, index, current, remaining);
+        result.async ? result.value.then(check) : setImmediate(check);
+      };
+      check();
+    }
+    function waitDiff(state, index, expected, timeout, done) {
+      let max = timeout === 1 / 0 ? 1 / 0 : Date.now() + timeout, check = () => {
+        if (Atomics.load(state, index) !== expected) {
+          done(null, "ok");
+          return;
+        }
+        if (max !== 1 / 0 && Date.now() > max) {
+          done(null, "timed-out");
+          return;
+        }
+        let remaining = max === 1 / 0 ? 1e4 : Math.min(1e4, Math.max(1, max - Date.now())), result = Atomics.waitAsync(state, index, expected, remaining);
+        result.async ? result.value.then(check) : setImmediate(check);
+      };
+      check();
+    }
+    module.exports = { wait, waitDiff };
+  }
+});
+
+// node_modules/thread-stream/lib/indexes.js
+var require_indexes = __commonJS({
+  "node_modules/thread-stream/lib/indexes.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      WRITE_INDEX: 4,
+      READ_INDEX: 8
+    };
+  }
+});
+
+// node_modules/thread-stream/index.js
+var require_thread_stream = __commonJS({
+  "node_modules/thread-stream/index.js"(exports, module) {
+    "use strict";
+    var { version } = require_package(), { EventEmitter } = __require("events"), { Worker } = __require("worker_threads"), { join } = __require("path"), { pathToFileURL } = __require("url"), { wait } = require_wait(), {
+      WRITE_INDEX,
+      READ_INDEX
+    } = require_indexes(), buffer = __require("buffer"), assert = __require("assert"), kImpl = /* @__PURE__ */ Symbol("kImpl"), MAX_STRING = buffer.constants.MAX_STRING_LENGTH, FakeWeakRef = class {
+      constructor(value) {
+        this._value = value;
+      }
+      deref() {
+        return this._value;
+      }
+    }, FakeFinalizationRegistry = class {
+      register() {
+      }
+      unregister() {
+      }
+    }, FinalizationRegistry = process.env.NODE_V8_COVERAGE ? FakeFinalizationRegistry : global.FinalizationRegistry || FakeFinalizationRegistry, WeakRef = process.env.NODE_V8_COVERAGE ? FakeWeakRef : global.WeakRef || FakeWeakRef, registry = new FinalizationRegistry((worker) => {
+      worker.exited || worker.terminate();
+    });
+    function createWorker(stream, opts) {
+      let { filename, workerData } = opts, toExecute = ("__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {})["thread-stream-worker"] || join(__dirname, "lib", "worker.js"), worker = new Worker(toExecute, {
+        ...opts.workerOpts,
+        trackUnmanagedFds: !1,
+        workerData: {
+          filename: filename.indexOf("file://") === 0 ? filename : pathToFileURL(filename).href,
+          dataBuf: stream[kImpl].dataBuf,
+          stateBuf: stream[kImpl].stateBuf,
+          workerData: {
+            $context: {
+              threadStreamVersion: version
+            },
+            ...workerData
+          }
+        }
+      });
+      return worker.stream = new FakeWeakRef(stream), worker.on("message", onWorkerMessage), worker.on("exit", onWorkerExit), registry.register(stream, worker), worker;
+    }
+    function drain(stream) {
+      assert(!stream[kImpl].sync), stream[kImpl].needDrain && (stream[kImpl].needDrain = !1, stream.emit("drain"));
+    }
+    function nextFlush(stream) {
+      let writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX), leftover = stream[kImpl].data.length - writeIndex;
+      if (leftover > 0) {
+        if (stream[kImpl].buf.length === 0) {
+          stream[kImpl].flushing = !1, stream[kImpl].ending ? end(stream) : stream[kImpl].needDrain && process.nextTick(drain, stream);
+          return;
+        }
+        let toWrite = stream[kImpl].buf.slice(0, leftover), toWriteBytes = Buffer.byteLength(toWrite);
+        toWriteBytes <= leftover ? (stream[kImpl].buf = stream[kImpl].buf.slice(leftover), write(stream, toWrite, nextFlush.bind(null, stream))) : stream.flush(() => {
+          if (!stream.destroyed) {
+            for (Atomics.store(stream[kImpl].state, READ_INDEX, 0), Atomics.store(stream[kImpl].state, WRITE_INDEX, 0), Atomics.notify(stream[kImpl].state, READ_INDEX); toWriteBytes > stream[kImpl].data.length; )
+              leftover = 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 (leftover === 0) {
+        if (writeIndex === 0 && stream[kImpl].buf.length === 0)
+          return;
+        stream.flush(() => {
+          Atomics.store(stream[kImpl].state, READ_INDEX, 0), Atomics.store(stream[kImpl].state, WRITE_INDEX, 0), Atomics.notify(stream[kImpl].state, READ_INDEX), nextFlush(stream);
+        });
+      } else
+        destroy(stream, new Error("overwritten"));
+    }
+    function onWorkerMessage(msg) {
+      let stream = this.stream.deref();
+      if (stream === void 0) {
+        this.exited = !0, this.terminate();
+        return;
+      }
+      switch (msg.code) {
+        case "READY":
+          this.stream = new WeakRef(stream), stream.flush(() => {
+            stream[kImpl].ready = !0, stream.emit("ready");
+          });
+          break;
+        case "ERROR":
+          destroy(stream, msg.err);
+          break;
+        case "EVENT":
+          Array.isArray(msg.args) ? stream.emit(msg.name, ...msg.args) : 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) {
+      let stream = this.stream.deref();
+      stream !== void 0 && (registry.unregister(stream), stream.worker.exited = !0, stream.worker.off("exit", onWorkerExit), destroy(stream, code !== 0 ? new Error("the worker thread exited") : null));
+    }
+    var ThreadStream = class extends EventEmitter {
+      constructor(opts = {}) {
+        if (super(), 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 || 4 * 1024 * 1024), this[kImpl].data = Buffer.from(this[kImpl].dataBuf), this[kImpl].sync = opts.sync || !1, this[kImpl].ending = !1, this[kImpl].ended = !1, this[kImpl].needDrain = !1, this[kImpl].destroyed = !1, this[kImpl].flushing = !1, this[kImpl].ready = !1, this[kImpl].finished = !1, this[kImpl].errored = null, this[kImpl].closed = !1, this[kImpl].buf = "", this.worker = createWorker(this, opts), this.on("message", (message, transferList) => {
+          this.worker.postMessage(message, transferList);
+        });
+      }
+      write(data) {
+        if (this[kImpl].destroyed)
+          return error(this, new Error("the worker has exited")), !1;
+        if (this[kImpl].ending)
+          return error(this, new Error("the worker is ending")), !1;
+        if (this[kImpl].flushing && this[kImpl].buf.length + data.length >= MAX_STRING)
+          try {
+            writeSync(this), this[kImpl].flushing = !0;
+          } catch (err) {
+            return destroy(this, err), !1;
+          }
+        if (this[kImpl].buf += data, this[kImpl].sync)
+          try {
+            return writeSync(this), !0;
+          } catch (err) {
+            return destroy(this, err), !1;
+          }
+        return this[kImpl].flushing || (this[kImpl].flushing = !0, setImmediate(nextFlush, this)), this[kImpl].needDrain = this[kImpl].data.length - this[kImpl].buf.length - Atomics.load(this[kImpl].state, WRITE_INDEX) <= 0, !this[kImpl].needDrain;
+      }
+      end() {
+        this[kImpl].destroyed || (this[kImpl].ending = !0, end(this));
+      }
+      flush(cb) {
+        if (this[kImpl].destroyed) {
+          typeof cb == "function" && process.nextTick(cb, new Error("the worker has exited"));
+          return;
+        }
+        let 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 (res === "not-equal") {
+            this.flush(cb);
+            return;
+          }
+          process.nextTick(cb);
+        });
+      }
+      flushSync() {
+        this[kImpl].destroyed || (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 !1;
+      }
+      get writableErrored() {
+        return this[kImpl].errored;
+      }
+    };
+    function error(stream, err) {
+      setImmediate(() => {
+        stream.emit("error", err);
+      });
+    }
+    function destroy(stream, err) {
+      stream[kImpl].destroyed || (stream[kImpl].destroyed = !0, err && (stream[kImpl].errored = err, error(stream, err)), stream.worker.exited ? setImmediate(() => {
+        stream[kImpl].closed = !0, stream.emit("close");
+      }) : stream.worker.terminate().catch(() => {
+      }).then(() => {
+        stream[kImpl].closed = !0, stream.emit("close");
+      }));
+    }
+    function write(stream, data, cb) {
+      let current = Atomics.load(stream[kImpl].state, WRITE_INDEX), length = Buffer.byteLength(data);
+      return stream[kImpl].data.write(data, current), Atomics.store(stream[kImpl].state, WRITE_INDEX, current + length), Atomics.notify(stream[kImpl].state, WRITE_INDEX), cb(), !0;
+    }
+    function end(stream) {
+      if (!(stream[kImpl].ended || !stream[kImpl].ending || stream[kImpl].flushing)) {
+        stream[kImpl].ended = !0;
+        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;
+          for (; readIndex !== -1; ) {
+            if (Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1e3), readIndex = Atomics.load(stream[kImpl].state, READ_INDEX), readIndex === -2) {
+              destroy(stream, new Error("end() failed"));
+              return;
+            }
+            if (++spins === 10) {
+              destroy(stream, new Error("end() took too long (10s)"));
+              return;
+            }
+          }
+          process.nextTick(() => {
+            stream[kImpl].finished = !0, stream.emit("finish");
+          });
+        } catch (err) {
+          destroy(stream, err);
+        }
+      }
+    }
+    function writeSync(stream) {
+      let cb = () => {
+        stream[kImpl].ending ? end(stream) : stream[kImpl].needDrain && process.nextTick(drain, stream);
+      };
+      for (stream[kImpl].flushing = !1; stream[kImpl].buf.length !== 0; ) {
+        let writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX), leftover = stream[kImpl].data.length - writeIndex;
+        if (leftover === 0) {
+          flushSync(stream), Atomics.store(stream[kImpl].state, READ_INDEX, 0), Atomics.store(stream[kImpl].state, WRITE_INDEX, 0), Atomics.notify(stream[kImpl].state, READ_INDEX);
+          continue;
+        } else if (leftover < 0)
+          throw new Error("overwritten");
+        let toWrite = stream[kImpl].buf.slice(0, leftover), toWriteBytes = Buffer.byteLength(toWrite);
+        if (toWriteBytes <= leftover)
+          stream[kImpl].buf = stream[kImpl].buf.slice(leftover), write(stream, toWrite, cb);
+        else {
+          for (flushSync(stream), Atomics.store(stream[kImpl].state, READ_INDEX, 0), Atomics.store(stream[kImpl].state, WRITE_INDEX, 0), Atomics.notify(stream[kImpl].state, READ_INDEX); toWriteBytes > stream[kImpl].buf.length; )
+            leftover = 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");
+      let writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX), spins = 0;
+      for (; ; ) {
+        let readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+        if (readIndex === -2)
+          throw Error("_flushSync failed");
+        if (readIndex !== writeIndex)
+          Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1e3);
+        else
+          break;
+        if (++spins === 10)
+          throw new Error("_flushSync took too long (10s)");
+      }
+    }
+    module.exports = ThreadStream;
+  }
+});
+
+// node_modules/pino/lib/transport.js
+var require_transport = __commonJS({
+  "node_modules/pino/lib/transport.js"(exports, module) {
+    "use strict";
+    var { createRequire } = __require("module"), { existsSync } = __require("node:fs"), getCallers = require_caller(), { join, isAbsolute, sep } = __require("node:path"), { fileURLToPath } = __require("node:url"), sleep = require_atomic_sleep(), onExit = require_on_exit_leak_free(), ThreadStream = require_thread_stream();
+    function setupOnExit(stream) {
+      onExit.register(stream, autoEnd), onExit.registerBeforeExit(stream, flush), stream.on("close", function() {
+        onExit.unregister(stream);
+      });
+    }
+    function hasPreloadFlags() {
+      let execArgv = process.execArgv;
+      for (let i = 0; i < execArgv.length; i++) {
+        let arg = execArgv[i];
+        if (arg === "--import" || arg === "--require" || arg === "-r" || arg.startsWith("--import=") || arg.startsWith("--require=") || arg.startsWith("-r="))
+          return !0;
+      }
+      return !1;
+    }
+    function sanitizeNodeOptions(nodeOptions) {
+      let tokens = nodeOptions.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g);
+      if (!tokens)
+        return nodeOptions;
+      let sanitized = [], changed = !1;
+      for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i];
+        if (token === "--require" || token === "-r" || token === "--import") {
+          let next = tokens[i + 1];
+          if (next && shouldDropPreload(next)) {
+            changed = !0, i++;
+            continue;
+          }
+          sanitized.push(token), next && (sanitized.push(next), i++);
+          continue;
+        }
+        if (token.startsWith("--require=") || token.startsWith("-r=") || token.startsWith("--import=")) {
+          let value = token.slice(token.indexOf("=") + 1);
+          if (shouldDropPreload(value)) {
+            changed = !0;
+            continue;
+          }
+        }
+        sanitized.push(token);
+      }
+      return changed ? sanitized.join(" ") : nodeOptions;
+    }
+    function shouldDropPreload(value) {
+      let unquoted = stripQuotes(value);
+      if (!unquoted)
+        return !1;
+      let path = unquoted;
+      if (path.startsWith("file://"))
+        try {
+          path = fileURLToPath(path);
+        } catch {
+          return !1;
+        }
+      return isAbsolute(path) && !existsSync(path);
+    }
+    function stripQuotes(value) {
+      let first = value[0], last = value[value.length - 1];
+      return first === '"' && last === '"' || first === "'" && last === "'" ? value.slice(1, -1) : value;
+    }
+    function buildStream(filename, workerData, workerOpts, sync, name) {
+      if (!workerOpts.execArgv && hasPreloadFlags() && __require.main === void 0 && (workerOpts = {
+        ...workerOpts,
+        execArgv: []
+      }), !workerOpts.env && process.env.NODE_OPTIONS) {
+        let nodeOptions = sanitizeNodeOptions(process.env.NODE_OPTIONS);
+        nodeOptions !== process.env.NODE_OPTIONS && (workerOpts = {
+          ...workerOpts,
+          env: {
+            ...process.env,
+            NODE_OPTIONS: nodeOptions
+          }
+        });
+      }
+      workerOpts = { ...workerOpts, name };
+      let stream = new ThreadStream({
+        filename,
+        workerData,
+        workerOpts,
+        sync
+      });
+      stream.on("ready", onReady), stream.on("close", function() {
+        process.removeListener("exit", onExit2);
+      }), process.on("exit", onExit2);
+      function onReady() {
+        process.removeListener("exit", onExit2), stream.unref(), workerOpts.autoEnd !== !1 && setupOnExit(stream);
+      }
+      function onExit2() {
+        stream.closed || (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) {
+      let { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = !1 } = fullOptions, options = {
+        ...fullOptions.options
+      }, callers = typeof caller == "string" ? [caller] : caller, bundlerOverrides = typeof globalThis == "object" && Object.prototype.hasOwnProperty.call(globalThis, "__bundlerPathsOverrides") && globalThis.__bundlerPathsOverrides && typeof globalThis.__bundlerPathsOverrides == "object" ? globalThis.__bundlerPathsOverrides : /* @__PURE__ */ Object.create(null), target = fullOptions.target;
+      if (target && targets)
+        throw new Error("only one of target or targets can be specified");
+      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,
+        // duplicate the pipeline `level` property defined in the upper level
+        target: fixTarget(t.target)
+      })))) : pipeline && (target = bundlerOverrides["pino-worker"] || join(__dirname, "worker.js"), options.pipelines = [pipeline.map((dest) => ({
+        ...dest,
+        target: fixTarget(dest.target)
+      }))]), levels && (options.levels = levels), dedupe && (options.dedupe = dedupe), options.pinoWillSendConfig = !0;
+      let name = targets || pipeline ? "pino.transport" : target;
+      return buildStream(fixTarget(target), options, worker, sync, name);
+      function fixTarget(origin) {
+        if (origin = bundlerOverrides[origin] || origin, isAbsolute(origin) || origin.indexOf("file://") === 0)
+          return origin;
+        if (origin === "pino/file")
+          return join(__dirname, "..", "file.js");
+        let fixTarget2;
+        for (let filePath of callers)
+          try {
+            let context = filePath === "node:repl" ? process.cwd() + sep : filePath;
+            fixTarget2 = createRequire(context).resolve(origin);
+            break;
+          } catch {
+            continue;
+          }
+        if (!fixTarget2)
+          throw new Error(`unable to determine transport target for "${origin}"`);
+        return fixTarget2;
+      }
+    }
+    module.exports = transport;
+  }
+});
+
+// node_modules/pino/lib/tools.js
+var require_tools = __commonJS({
+  "node_modules/pino/lib/tools.js"(exports, module) {
+    "use strict";
+    var diagChan = __require("node:diagnostics_channel"), format = require_quick_format_unescaped(), { mapHttpRequest, mapHttpResponse } = require_pino_std_serializers(), SonicBoom = require_sonic_boom(), onExit = require_on_exit_leak_free(), {
+      lsCacheSym,
+      chindingsSym,
+      writeSym,
+      serializersSym,
+      formatOptsSym,
+      endSym,
+      stringifiersSym,
+      stringifySym,
+      stringifySafeSym,
+      wildcardFirstSym,
+      nestedKeySym,
+      formattersSym,
+      messageKeySym,
+      errorKeySym,
+      nestedKeyStrSym,
+      msgPrefixSym
+    } = require_symbols(), { isMainThread } = __require("worker_threads"), transport = require_transport(), [nodeMajor] = process.versions.node.split(".").map((v) => Number(v)), asJsonChan = diagChan.tracingChannel("pino_asJson"), asString = nodeMajor >= 25 ? (str) => JSON.stringify(str) : _asString;
+    function noop() {
+    }
+    function genLog(level, hook) {
+      if (!hook) return LOG;
+      return function(...args) {
+        hook.call(this, args, LOG, level);
+      };
+      function LOG(o, ...n) {
+        if (typeof o == "object") {
+          let msg = o;
+          o !== null && (o.method && o.headers && o.socket ? o = mapHttpRequest(o) : typeof o.setHeader == "function" && (o = mapHttpResponse(o)));
+          let formatParams;
+          msg === null && n.length === 0 ? formatParams = [null] : (msg = n.shift(), formatParams = n), typeof this[msgPrefixSym] == "string" && msg !== void 0 && msg !== null && (msg = this[msgPrefixSym] + msg), this[writeSym](o, format(msg, formatParams, this[formatOptsSym]), level);
+        } else {
+          let msg = o === void 0 ? n.shift() : o;
+          typeof this[msgPrefixSym] == "string" && msg !== void 0 && msg !== null && (msg = this[msgPrefixSym] + msg), this[writeSym](null, format(msg, n, this[formatOptsSym]), level);
+        }
+      }
+    }
+    function _asString(str) {
+      let result = "", last = 0, found = !1, point = 255, l = str.length;
+      if (l > 100)
+        return JSON.stringify(str);
+      for (var i = 0; i < l && point >= 32; i++)
+        point = str.charCodeAt(i), (point === 34 || point === 92) && (result += str.slice(last, i) + "\\", last = i, found = !0);
+      return found ? result += str.slice(last) : result = str, point < 32 ? JSON.stringify(str) : '"' + result + '"';
+    }
+    function asJson(obj, msg, num, time) {
+      if (asJsonChan.hasSubscribers === !1)
+        return _asJson.call(this, obj, msg, num, time);
+      let store = { instance: this, arguments };
+      return asJsonChan.traceSync(_asJson, store, this, obj, msg, num, time);
+    }
+    function _asJson(obj, msg, num, time) {
+      let stringify2 = this[stringifySym], stringifySafe = this[stringifySafeSym], stringifiers = this[stringifiersSym], end = this[endSym], chindings = this[chindingsSym], serializers = this[serializersSym], formatters = this[formattersSym], messageKey = this[messageKeySym], errorKey = this[errorKeySym], data = this[lsCacheSym][num] + time;
+      data = data + chindings;
+      let value;
+      formatters.log && (obj = formatters.log(obj));
+      let wildcardStringifier = stringifiers[wildcardFirstSym], propStr = "";
+      for (let key in obj)
+        if (value = obj[key], Object.prototype.hasOwnProperty.call(obj, key) && value !== void 0) {
+          serializers[key] ? value = serializers[key](value) : key === errorKey && serializers.err && (value = serializers.err(value));
+          let stringifier = stringifiers[key] || wildcardStringifier;
+          switch (typeof value) {
+            case "undefined":
+            case "function":
+              continue;
+            case "number":
+              Number.isFinite(value) === !1 && (value = null);
+            // this case explicitly falls through to the next one
+            case "boolean":
+              stringifier && (value = stringifier(value));
+              break;
+            case "string":
+              value = (stringifier || asString)(value);
+              break;
+            default:
+              value = (stringifier || stringify2)(value, stringifySafe);
+          }
+          if (value === void 0) continue;
+          let strKey = asString(key);
+          propStr += "," + strKey + ":" + value;
+        }
+      let msgStr = "";
+      if (msg !== void 0) {
+        value = serializers[messageKey] ? serializers[messageKey](msg) : msg;
+        let stringifier = stringifiers[messageKey] || wildcardStringifier;
+        switch (typeof value) {
+          case "function":
+            break;
+          case "number":
+            Number.isFinite(value) === !1 && (value = null);
+          // this case explicitly falls through to the next one
+          case "boolean":
+            stringifier && (value = stringifier(value)), msgStr = ',"' + messageKey + '":' + value;
+            break;
+          case "string":
+            value = (stringifier || asString)(value), msgStr = ',"' + messageKey + '":' + value;
+            break;
+          default:
+            value = (stringifier || stringify2)(value, stringifySafe), msgStr = ',"' + messageKey + '":' + value;
+        }
+      }
+      return this[nestedKeySym] && propStr ? data + this[nestedKeyStrSym] + propStr.slice(1) + "}" + msgStr + end : data + propStr + msgStr + end;
+    }
+    function asChindings(instance, bindings) {
+      let value, data = instance[chindingsSym], stringify2 = instance[stringifySym], stringifySafe = instance[stringifySafeSym], stringifiers = instance[stringifiersSym], wildcardStringifier = stringifiers[wildcardFirstSym], serializers = instance[serializersSym], formatter = instance[formattersSym].bindings;
+      bindings = formatter(bindings);
+      for (let key in bindings)
+        if (value = bindings[key], ((key.length < 5 || key !== "level" && key !== "serializers" && key !== "formatters" && key !== "customLevels") && bindings.hasOwnProperty(key) && value !== void 0) === !0) {
+          if (value = serializers[key] ? serializers[key](value) : value, value = (stringifiers[key] || wildcardStringifier || stringify2)(value, stringifySafe), value === void 0) continue;
+          data += ',"' + key + '":' + value;
+        }
+      return data;
+    }
+    function hasBeenTampered(stream) {
+      return stream.write !== stream.constructor.prototype.write;
+    }
+    function buildSafeSonicBoom(opts) {
+      let stream = new SonicBoom(opts);
+      return stream.on("error", filterBrokenPipe), !opts.sync && isMainThread && (onExit.register(stream, autoEnd), stream.on("close", function() {
+        onExit.unregister(stream);
+      })), stream;
+      function filterBrokenPipe(err) {
+        if (err.code === "EPIPE") {
+          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) {
+      stream.destroyed || (eventName === "beforeExit" ? (stream.flush(), stream.on("drain", function() {
+        stream.end();
+      })) : stream.flushSync());
+    }
+    function createArgsNormalizer(defaultOptions) {
+      return function(instance, caller, opts = {}, stream) {
+        if (typeof opts == "string")
+          stream = buildSafeSonicBoom({ dest: opts }), opts = {};
+        else if (typeof stream == "string") {
+          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 && typeof opts.formatters.level == "function")
+            throw Error("option.transport.targets do not allow custom level formatters");
+          let customLevels;
+          opts.customLevels && (customLevels = opts.useOnlyCustomLevels ? opts.customLevels : Object.assign({}, opts.levels, opts.customLevels)), stream = transport({ caller, ...opts.transport, levels: customLevels });
+        }
+        if (opts = Object.assign({}, defaultOptions, opts), opts.serializers = Object.assign({}, defaultOptions.serializers, opts.serializers), opts.formatters = Object.assign({}, defaultOptions.formatters, opts.formatters), opts.prettyPrint)
+          throw new Error("prettyPrint option is no longer supported, see the pino-pretty package (https://github.com/pinojs/pino-pretty)");
+        let { enabled, onChild } = opts;
+        return enabled === !1 && (opts.level = "silent"), onChild || (opts.onChild = noop), stream || (hasBeenTampered(process.stdout) ? stream = process.stdout : stream = buildSafeSonicBoom({ fd: process.stdout.fd || 1 })), { opts, stream };
+      };
+    }
+    function stringify(obj, stringifySafeFn) {
+      try {
+        return JSON.stringify(obj);
+      } catch {
+        try {
+          return (stringifySafeFn || this[stringifySafeSym])(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) {
+      let fd = Number(destination);
+      return typeof destination == "string" && Number.isFinite(fd) ? fd : destination === void 0 ? 1 : destination;
+    }
+    module.exports = {
+      noop,
+      buildSafeSonicBoom,
+      asChindings,
+      asJson,
+      genLog,
+      createArgsNormalizer,
+      stringify,
+      buildFormatters,
+      normalizeDestFileDescriptor
+    };
+  }
+});
+
+// node_modules/pino/lib/constants.js
+var require_constants = __commonJS({
+  "node_modules/pino/lib/constants.js"(exports, module) {
+    "use strict";
+    var DEFAULT_LEVELS = {
+      trace: 10,
+      debug: 20,
+      info: 30,
+      warn: 40,
+      error: 50,
+      fatal: 60
+    }, SORTING_ORDER = {
+      ASC: "ASC",
+      DESC: "DESC"
+    };
+    module.exports = {
+      DEFAULT_LEVELS,
+      SORTING_ORDER
+    };
+  }
+});
+
+// node_modules/pino/lib/levels.js
+var require_levels = __commonJS({
+  "node_modules/pino/lib/levels.js"(exports, module) {
+    "use strict";
+    var {
+      lsCacheSym,
+      levelValSym,
+      useOnlyCustomLevelsSym,
+      streamSym,
+      formattersSym,
+      hooksSym,
+      levelCompSym
+    } = require_symbols(), { noop, genLog } = require_tools(), { DEFAULT_LEVELS, SORTING_ORDER } = require_constants(), levelMethods = {
+      fatal: (hook) => {
+        let logFatal = genLog(DEFAULT_LEVELS.fatal, hook);
+        return function(...args) {
+          let stream = this[streamSym];
+          if (logFatal.call(this, ...args), typeof stream.flushSync == "function")
+            try {
+              stream.flushSync();
+            } catch {
+            }
+        };
+      },
+      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)
+    }, nums = Object.keys(DEFAULT_LEVELS).reduce((o, k) => (o[DEFAULT_LEVELS[k]] = k, o), {}), initialLsCache = Object.keys(nums).reduce((o, k) => (o[k] = '{"level":' + Number(k), o), {});
+    function genLsCache(instance) {
+      let formatter = instance[formattersSym].level, { labels } = instance.levels, cache = {};
+      for (let label in labels) {
+        let level = formatter(labels[label], Number(label));
+        cache[label] = JSON.stringify(level).slice(0, -1);
+      }
+      return instance[lsCacheSym] = cache, instance;
+    }
+    function isStandardLevel(level, useOnlyCustomLevels) {
+      if (useOnlyCustomLevels)
+        return !1;
+      switch (level) {
+        case "fatal":
+        case "error":
+        case "warn":
+        case "info":
+        case "debug":
+        case "trace":
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function setLevel(level) {
+      let { labels, values } = this.levels;
+      if (typeof level == "number") {
+        if (labels[level] === void 0) throw Error("unknown level value" + level);
+        level = labels[level];
+      }
+      if (values[level] === void 0) throw Error("unknown level " + level);
+      let preLevelVal = this[levelValSym], levelVal = this[levelValSym] = values[level], useOnlyCustomLevelsVal = this[useOnlyCustomLevelsSym], levelComparison = this[levelCompSym], hook = this[hooksSym].logMethod;
+      for (let key in values) {
+        if (levelComparison(values[key], levelVal) === !1) {
+          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) {
+      let { levels, levelVal } = this;
+      return levels && levels.labels ? levels.labels[levelVal] : "";
+    }
+    function isLevelEnabled(logLevel) {
+      let { values } = this.levels, logLevelVal = values[logLevel];
+      return logLevelVal !== void 0 && this[levelCompSym](logLevelVal, this[levelValSym]);
+    }
+    function compareLevel(direction, current, expected) {
+      return direction === SORTING_ORDER.DESC ? current <= expected : current >= expected;
+    }
+    function genLevelComparison(levelComparison) {
+      return typeof levelComparison == "string" ? compareLevel.bind(null, levelComparison) : levelComparison;
+    }
+    function mappings(customLevels = null, useOnlyCustomLevels = !1) {
+      let customNums = customLevels ? Object.keys(customLevels).reduce((o, k) => (o[customLevels[k]] = k, o), {}) : null, labels = Object.assign(
+        Object.create(Object.prototype, { Infinity: { value: "silent" } }),
+        useOnlyCustomLevels ? null : nums,
+        customNums
+      ), 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 (typeof defaultLevel == "number") {
+        if (![].concat(
+          Object.keys(customLevels || {}).map((key) => customLevels[key]),
+          useOnlyCustomLevels ? [] : Object.keys(nums).map((level) => +level),
+          1 / 0
+        ).includes(defaultLevel))
+          throw Error(`default level:${defaultLevel} must be included in custom levels`);
+        return;
+      }
+      let 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) {
+      let { labels, values } = levels;
+      for (let 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 (typeof levelComparison != "function" && !(typeof levelComparison == "string" && Object.values(SORTING_ORDER).includes(levelComparison)))
+        throw new Error('Levels comparison should be one of "ASC", "DESC" or "function" type');
+    }
+    module.exports = {
+      initialLsCache,
+      genLsCache,
+      levelMethods,
+      getLevel,
+      setLevel,
+      isLevelEnabled,
+      mappings,
+      assertNoLevelCollisions,
+      assertDefaultLevelFound,
+      genLevelComparison,
+      assertLevelComparison
+    };
+  }
+});
+
+// node_modules/pino/lib/meta.js
+var require_meta = __commonJS({
+  "node_modules/pino/lib/meta.js"(exports, module) {
+    "use strict";
+    module.exports = { version: "10.3.1" };
+  }
+});
+
+// node_modules/pino/lib/proto.js
+var require_proto = __commonJS({
+  "node_modules/pino/lib/proto.js"(exports, module) {
+    "use strict";
+    var { EventEmitter } = __require("node:events"), {
+      lsCacheSym,
+      levelValSym,
+      setLevelSym,
+      getLevelSym,
+      chindingsSym,
+      mixinSym,
+      asJsonSym,
+      writeSym,
+      mixinMergeStrategySym,
+      timeSym,
+      timeSliceIndexSym,
+      streamSym,
+      serializersSym,
+      formattersSym,
+      errorKeySym,
+      messageKeySym,
+      useOnlyCustomLevelsSym,
+      needsMetadataGsym,
+      redactFmtSym,
+      stringifySym,
+      formatOptsSym,
+      stringifiersSym,
+      msgPrefixSym,
+      hooksSym
+    } = require_symbols(), {
+      getLevel,
+      setLevel,
+      isLevelEnabled,
+      mappings,
+      initialLsCache,
+      genLsCache,
+      assertNoLevelCollisions
+    } = require_levels(), {
+      asChindings,
+      asJson,
+      buildFormatters,
+      stringify,
+      noop
+    } = require_tools(), {
+      version
+    } = require_meta(), redaction = require_redaction(), constructor = class {
+    }, 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);
+    module.exports = function() {
+      return Object.create(prototype);
+    };
+    var resetChildingsFormatter = (bindings2) => bindings2;
+    function child(bindings2, options) {
+      if (!bindings2)
+        throw Error("missing bindings for child Pino");
+      let serializers = this[serializersSym], formatters = this[formattersSym], instance = Object.create(this);
+      if (options == null)
+        return instance[formattersSym].bindings !== resetChildingsFormatter && (instance[formattersSym] = buildFormatters(
+          formatters.level,
+          resetChildingsFormatter,
+          formatters.log
+        )), instance[chindingsSym] = asChindings(instance, bindings2), this.onChild !== noop && this.onChild(instance), instance;
+      if (options.hasOwnProperty("serializers") === !0) {
+        instance[serializersSym] = /* @__PURE__ */ Object.create(null);
+        for (let k in serializers)
+          instance[serializersSym][k] = serializers[k];
+        let parentSymbols = Object.getOwnPropertySymbols(serializers);
+        for (var i = 0; i < parentSymbols.length; i++) {
+          let ks = parentSymbols[i];
+          instance[serializersSym][ks] = serializers[ks];
+        }
+        for (let bk in options.serializers)
+          instance[serializersSym][bk] = options.serializers[bk];
+        let bindingsSymbols = Object.getOwnPropertySymbols(options.serializers);
+        for (var bi = 0; bi < bindingsSymbols.length; bi++) {
+          let bks = bindingsSymbols[bi];
+          instance[serializersSym][bks] = options.serializers[bks];
+        }
+      } else instance[serializersSym] = serializers;
+      if (options.hasOwnProperty("formatters")) {
+        let { 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 (options.hasOwnProperty("customLevels") === !0 && (assertNoLevelCollisions(this.levels, options.customLevels), instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym]), genLsCache(instance)), typeof options.redact == "object" && options.redact !== null || Array.isArray(options.redact)) {
+        instance.redact = options.redact;
+        let stringifiers = redaction(instance.redact, stringify), formatOpts = { stringify: stringifiers[redactFmtSym] };
+        instance[stringifySym] = stringify, instance[stringifiersSym] = stringifiers, instance[formatOptsSym] = formatOpts;
+      }
+      if (typeof options.msgPrefix == "string" && (instance[msgPrefixSym] = (this[msgPrefixSym] || "") + options.msgPrefix), instance[chindingsSym] = asChindings(instance, bindings2), options.level !== void 0 && options.level !== this.level || options.hasOwnProperty("customLevels")) {
+        let childLevel = options.level || this.level;
+        instance[setLevelSym](childLevel);
+      }
+      return this.onChild(instance), instance;
+    }
+    function bindings() {
+      let chindingsJson = `{${this[chindingsSym].substr(1)}}`, bindingsFromJson = JSON.parse(chindingsJson);
+      return delete bindingsFromJson.pid, delete bindingsFromJson.hostname, bindingsFromJson;
+    }
+    function setBindings(newBindings) {
+      let chindings = asChindings(this, newBindings);
+      this[chindingsSym] = chindings;
+    }
+    function defaultMixinMergeStrategy(mergeObject, mixinObject) {
+      return Object.assign(mixinObject, mergeObject);
+    }
+    function write(_obj, msg, num) {
+      let t = this[timeSym](), mixin = this[mixinSym], errorKey = this[errorKeySym], messageKey = this[messageKeySym], mixinMergeStrategy = this[mixinMergeStrategySym] || defaultMixinMergeStrategy, obj, streamWriteHook = this[hooksSym].streamWrite;
+      _obj == null ? obj = {} : _obj instanceof Error ? (obj = { [errorKey]: _obj }, msg === void 0 && (msg = _obj.message)) : (obj = _obj, msg === void 0 && _obj[messageKey] === void 0 && _obj[errorKey] && (msg = _obj[errorKey].message)), mixin && (obj = mixinMergeStrategy(obj, mixin(obj, num, this)));
+      let s = this[asJsonSym](obj, msg, num, t), stream = this[streamSym];
+      stream[needsMetadataGsym] === !0 && (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 (cb != null && typeof cb != "function")
+        throw Error("callback must be a function");
+      let stream = this[streamSym];
+      typeof stream.flush == "function" ? stream.flush(cb || noop) : cb && cb();
+    }
+  }
+});
+
+// node_modules/pino/lib/multistream.js
+var require_multistream = __commonJS({
+  "node_modules/pino/lib/multistream.js"(exports, module) {
+    "use strict";
+    var metadata = /* @__PURE__ */ Symbol.for("pino.metadata"), { DEFAULT_LEVELS } = require_constants(), DEFAULT_INFO_LEVEL = DEFAULT_LEVELS.info;
+    function multistream(streamsArray, opts) {
+      streamsArray = streamsArray || [], opts = opts || { dedupe: !1 };
+      let streamLevels = Object.create(DEFAULT_LEVELS);
+      streamLevels.silent = 1 / 0, opts.levels && typeof opts.levels == "object" && Object.keys(opts.levels).forEach((i) => {
+        streamLevels[i] = opts.levels[i];
+      });
+      let res = {
+        write,
+        add,
+        remove,
+        emit,
+        flushSync,
+        end,
+        minLevel: 0,
+        lastId: 0,
+        streams: [],
+        clone,
+        [metadata]: !0,
+        streamLevels
+      };
+      return Array.isArray(streamsArray) ? streamsArray.forEach(add, res) : add.call(res, streamsArray), streamsArray = null, res;
+      function write(data) {
+        let dest, level = this.lastLevel, { streams } = this, recordedLevel = 0, stream;
+        for (let i = initLoopVar(streams.length, opts.dedupe); checkLoopVar(i, streams.length, opts.dedupe); i = adjustLoopVar(i, opts.dedupe))
+          if (dest = streams[i], dest.level <= level) {
+            if (recordedLevel !== 0 && recordedLevel !== dest.level)
+              break;
+            if (stream = dest.stream, stream[metadata]) {
+              let { lastTime, lastMsg, lastObj, lastLogger } = this;
+              stream.lastLevel = level, stream.lastTime = lastTime, stream.lastMsg = lastMsg, stream.lastObj = lastObj, stream.lastLogger = lastLogger;
+            }
+            stream.write(data), opts.dedupe && (recordedLevel = dest.level);
+          } else if (!opts.dedupe)
+            break;
+      }
+      function emit(...args) {
+        for (let { stream } of this.streams)
+          typeof stream.emit == "function" && stream.emit(...args);
+      }
+      function flushSync() {
+        for (let { stream } of this.streams)
+          typeof stream.flushSync == "function" && stream.flushSync();
+      }
+      function add(dest) {
+        if (!dest)
+          return res;
+        let isStream = typeof dest.write == "function" || dest.stream, stream_ = dest.write ? dest : dest.stream;
+        if (!isStream)
+          throw Error("stream object needs to implement either StreamEntry or DestinationStream interface");
+        let { streams, streamLevels: streamLevels2 } = this, level;
+        typeof dest.levelVal == "number" ? level = dest.levelVal : typeof dest.level == "string" ? level = streamLevels2[dest.level] : typeof dest.level == "number" ? level = dest.level : level = DEFAULT_INFO_LEVEL;
+        let dest_ = {
+          stream: stream_,
+          level,
+          levelVal: void 0,
+          id: ++res.lastId
+        };
+        return streams.unshift(dest_), streams.sort(compareByLevel), this.minLevel = streams[0].level, res;
+      }
+      function remove(id) {
+        let { streams } = this, index = streams.findIndex((s) => s.id === id);
+        return index >= 0 && (streams.splice(index, 1), streams.sort(compareByLevel), this.minLevel = streams.length > 0 ? streams[0].level : -1), res;
+      }
+      function end() {
+        for (let { stream } of this.streams)
+          typeof stream.flushSync == "function" && stream.flushSync(), stream.end();
+      }
+      function clone(level) {
+        let 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]: !0
+        };
+      }
+    }
+    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;
+    }
+    module.exports = multistream;
+  }
+});
+
+// node_modules/pino/pino.js
+var require_pino = __commonJS({
+  "node_modules/pino/pino.js"(exports, module) {
+    "use strict";
+    var os = __require("node:os"), stdSerializers = require_pino_std_serializers(), caller = require_caller(), redaction = require_redaction(), time = require_time(), proto = require_proto(), symbols = require_symbols(), { configure } = require_safe_stable_stringify(), { assertDefaultLevelFound, mappings, genLsCache, genLevelComparison, assertLevelComparison } = require_levels(), { DEFAULT_LEVELS, SORTING_ORDER } = require_constants(), {
+      createArgsNormalizer,
+      asChindings,
+      buildSafeSonicBoom,
+      buildFormatters,
+      stringify,
+      normalizeDestFileDescriptor,
+      noop
+    } = require_tools(), { version } = require_meta(), {
+      chindingsSym,
+      redactFmtSym,
+      serializersSym,
+      timeSym,
+      timeSliceIndexSym,
+      streamSym,
+      stringifySym,
+      stringifySafeSym,
+      stringifiersSym,
+      setLevelSym,
+      endSym,
+      formatOptsSym,
+      messageKeySym,
+      errorKeySym,
+      nestedKeySym,
+      mixinSym,
+      levelCompSym,
+      useOnlyCustomLevelsSym,
+      formattersSym,
+      hooksSym,
+      nestedKeyStrSym,
+      mixinMergeStrategySym,
+      msgPrefixSym
+    } = symbols, { epochTime, nullTime } = time, { pid } = process, hostname = os.hostname(), defaultErrorSerializer = stdSerializers.err, defaultOptions = {
+      level: "info",
+      levelComparison: SORTING_ORDER.ASC,
+      levels: DEFAULT_LEVELS,
+      messageKey: "msg",
+      errorKey: "err",
+      nestedKey: null,
+      enabled: !0,
+      base: { pid, hostname },
+      serializers: Object.assign(/* @__PURE__ */ Object.create(null), {
+        err: defaultErrorSerializer
+      }),
+      formatters: Object.assign(/* @__PURE__ */ 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: !1,
+      depthLimit: 5,
+      edgeLimit: 100
+    }, normalize = createArgsNormalizer(defaultOptions), serializers = Object.assign(/* @__PURE__ */ Object.create(null), stdSerializers);
+    function pino(...args) {
+      let instance = {}, { opts, stream } = normalize(instance, caller(), ...args);
+      opts.level && typeof opts.level == "string" && DEFAULT_LEVELS[opts.level.toLowerCase()] !== void 0 && (opts.level = opts.level.toLowerCase());
+      let {
+        redact,
+        crlf,
+        serializers: serializers2,
+        timestamp,
+        messageKey,
+        errorKey,
+        nestedKey,
+        base,
+        name,
+        level,
+        customLevels,
+        levelComparison,
+        mixin,
+        mixinMergeStrategy,
+        useOnlyCustomLevels,
+        formatters,
+        hooks,
+        depthLimit,
+        edgeLimit,
+        onChild,
+        msgPrefix
+      } = opts, stringifySafe = configure({
+        maximumDepth: depthLimit,
+        maximumBreadth: edgeLimit
+      }), allFormatters = buildFormatters(
+        formatters.level,
+        formatters.bindings,
+        formatters.log
+      ), stringifyFn = stringify.bind({
+        [stringifySafeSym]: stringifySafe
+      }), stringifiers = redact ? redaction(redact, stringifyFn) : {}, formatOpts = redact ? { stringify: stringifiers[redactFmtSym] } : { stringify: stringifyFn }, end = "}" + (crlf ? `\r
+` : `
+`), coreChindings = asChindings.bind(null, {
+        [chindingsSym]: "",
+        [serializersSym]: serializers2,
+        [stringifiersSym]: stringifiers,
+        [stringifySym]: stringify,
+        [stringifySafeSym]: stringifySafe,
+        [formattersSym]: allFormatters
+      }), chindings = "";
+      base !== null && (name === void 0 ? chindings = coreChindings(base) : chindings = coreChindings(Object.assign({}, base, { name })));
+      let time2 = timestamp instanceof Function ? timestamp : timestamp ? epochTime : nullTime, timeSliceIndex = time2().indexOf(":") + 1;
+      if (useOnlyCustomLevels && !customLevels) throw Error("customLevels is required if useOnlyCustomLevels is set true");
+      if (mixin && typeof mixin != "function") throw Error(`Unknown mixin type "${typeof mixin}" - expected "function"`);
+      if (msgPrefix && typeof msgPrefix != "string") throw Error(`Unknown msgPrefix type "${typeof msgPrefix}" - expected "string"`);
+      assertDefaultLevelFound(level, customLevels, useOnlyCustomLevels);
+      let levels = mappings(customLevels, useOnlyCustomLevels);
+      typeof stream.emit == "function" && stream.emit("message", { code: "PINO_CONFIG", config: { levels, messageKey, errorKey } }), assertLevelComparison(levelComparison);
+      let levelCompFunc = genLevelComparison(levelComparison);
+      return Object.assign(instance, {
+        levels,
+        [levelCompSym]: levelCompFunc,
+        [useOnlyCustomLevelsSym]: useOnlyCustomLevels,
+        [streamSym]: stream,
+        [timeSym]: time2,
+        [timeSliceIndexSym]: timeSliceIndex,
+        [stringifySym]: stringify,
+        [stringifySafeSym]: stringifySafe,
+        [stringifiersSym]: stringifiers,
+        [endSym]: end,
+        [formatOptsSym]: formatOpts,
+        [messageKeySym]: messageKey,
+        [errorKeySym]: errorKey,
+        [nestedKeySym]: nestedKey,
+        // protect against injection
+        [nestedKeyStrSym]: nestedKey ? `,${JSON.stringify(nestedKey)}:{` : "",
+        [serializersSym]: serializers2,
+        [mixinSym]: mixin,
+        [mixinMergeStrategySym]: mixinMergeStrategy,
+        [chindingsSym]: chindings,
+        [formattersSym]: allFormatters,
+        [hooksSym]: hooks,
+        silent: noop,
+        onChild,
+        [msgPrefixSym]: msgPrefix
+      }), Object.setPrototypeOf(instance, proto()), genLsCache(instance), instance[setLevelSym](level), instance;
+    }
+    module.exports = pino;
+    module.exports.destination = (dest = process.stdout.fd) => typeof dest == "object" ? (dest.dest = normalizeDestFileDescriptor(dest.dest || process.stdout.fd), buildSafeSonicBoom(dest)) : buildSafeSonicBoom({ dest: normalizeDestFileDescriptor(dest), minLength: 0 });
+    module.exports.transport = require_transport();
+    module.exports.multistream = require_multistream();
+    module.exports.levels = mappings();
+    module.exports.stdSerializers = serializers;
+    module.exports.stdTimeFunctions = Object.assign({}, time);
+    module.exports.symbols = symbols;
+    module.exports.version = version;
+    module.exports.default = pino;
+    module.exports.pino = pino;
+  }
+});
+
+export {
+  require_pino
+};