@agentdocumentformat/cli 0.7.2

package/dist/chunks/chunk-7N2R2VCG.mjs

@@ -0,0 +1,1434 @@
+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 {
+  __commonJS,
+  __require
+} from "./chunk-M2RX3S2T.mjs";
+
+// node_modules/pino-std-serializers/lib/err-helpers.js
+var require_err_helpers = __commonJS({
+  "node_modules/pino-std-serializers/lib/err-helpers.js"(exports, module) {
+    "use strict";
+    var isErrorLike = (err) => err && typeof err.message == "string", getErrorCause = (err) => {
+      if (!err) return;
+      let cause = err.cause;
+      if (typeof cause == "function") {
+        let causeResult = err.cause();
+        return isErrorLike(causeResult) ? causeResult : void 0;
+      } else
+        return isErrorLike(cause) ? cause : void 0;
+    }, _stackWithCauses = (err, seen) => {
+      if (!isErrorLike(err)) return "";
+      let stack = err.stack || "";
+      if (seen.has(err))
+        return stack + `
+causes have become circular...`;
+      let cause = getErrorCause(err);
+      return cause ? (seen.add(err), stack + `
+caused by: ` + _stackWithCauses(cause, seen)) : stack;
+    }, stackWithCauses = (err) => _stackWithCauses(err, /* @__PURE__ */ new Set()), _messageWithCauses = (err, seen, skip) => {
+      if (!isErrorLike(err)) return "";
+      let message = skip ? "" : err.message || "";
+      if (seen.has(err))
+        return message + ": ...";
+      let cause = getErrorCause(err);
+      if (cause) {
+        seen.add(err);
+        let skipIfVErrorStyleCause = typeof err.cause == "function";
+        return message + (skipIfVErrorStyleCause ? "" : ": ") + _messageWithCauses(cause, seen, skipIfVErrorStyleCause);
+      } else
+        return message;
+    }, messageWithCauses = (err) => _messageWithCauses(err, /* @__PURE__ */ new Set());
+    module.exports = {
+      isErrorLike,
+      getErrorCause,
+      stackWithCauses,
+      messageWithCauses
+    };
+  }
+});
+
+// node_modules/pino-std-serializers/lib/err-proto.js
+var require_err_proto = __commonJS({
+  "node_modules/pino-std-serializers/lib/err-proto.js"(exports, module) {
+    "use strict";
+    var seen = /* @__PURE__ */ Symbol("circular-ref-tag"), rawSymbol = /* @__PURE__ */ Symbol("pino-raw-err-ref"), pinoErrProto = Object.create({}, {
+      type: {
+        enumerable: !0,
+        writable: !0,
+        value: void 0
+      },
+      message: {
+        enumerable: !0,
+        writable: !0,
+        value: void 0
+      },
+      stack: {
+        enumerable: !0,
+        writable: !0,
+        value: void 0
+      },
+      aggregateErrors: {
+        enumerable: !0,
+        writable: !0,
+        value: void 0
+      },
+      raw: {
+        enumerable: !1,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoErrProto, rawSymbol, {
+      writable: !0,
+      value: {}
+    });
+    module.exports = {
+      pinoErrProto,
+      pinoErrorSymbols: {
+        seen,
+        rawSymbol
+      }
+    };
+  }
+});
+
+// node_modules/pino-std-serializers/lib/err.js
+var require_err = __commonJS({
+  "node_modules/pino-std-serializers/lib/err.js"(exports, module) {
+    "use strict";
+    module.exports = errSerializer;
+    var { messageWithCauses, stackWithCauses, isErrorLike } = require_err_helpers(), { pinoErrProto, pinoErrorSymbols } = require_err_proto(), { seen } = pinoErrorSymbols, { toString } = Object.prototype;
+    function errSerializer(err) {
+      if (!isErrorLike(err))
+        return err;
+      err[seen] = void 0;
+      let _err = Object.create(pinoErrProto);
+      _err.type = toString.call(err.constructor) === "[object Function]" ? err.constructor.name : err.name, _err.message = messageWithCauses(err), _err.stack = stackWithCauses(err), Array.isArray(err.errors) && (_err.aggregateErrors = err.errors.map((err2) => errSerializer(err2)));
+      for (let key in err)
+        if (_err[key] === void 0) {
+          let val = err[key];
+          isErrorLike(val) ? key !== "cause" && !Object.prototype.hasOwnProperty.call(val, seen) && (_err[key] = errSerializer(val)) : _err[key] = val;
+        }
+      return delete err[seen], _err.raw = err, _err;
+    }
+  }
+});
+
+// node_modules/pino-std-serializers/lib/err-with-cause.js
+var require_err_with_cause = __commonJS({
+  "node_modules/pino-std-serializers/lib/err-with-cause.js"(exports, module) {
+    "use strict";
+    module.exports = errWithCauseSerializer;
+    var { isErrorLike } = require_err_helpers(), { pinoErrProto, pinoErrorSymbols } = require_err_proto(), { seen } = pinoErrorSymbols, { toString } = Object.prototype;
+    function errWithCauseSerializer(err) {
+      if (!isErrorLike(err))
+        return err;
+      err[seen] = void 0;
+      let _err = Object.create(pinoErrProto);
+      _err.type = toString.call(err.constructor) === "[object Function]" ? err.constructor.name : err.name, _err.message = err.message, _err.stack = err.stack, Array.isArray(err.errors) && (_err.aggregateErrors = err.errors.map((err2) => errWithCauseSerializer(err2))), isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen) && (_err.cause = errWithCauseSerializer(err.cause));
+      for (let key in err)
+        if (_err[key] === void 0) {
+          let val = err[key];
+          isErrorLike(val) ? Object.prototype.hasOwnProperty.call(val, seen) || (_err[key] = errWithCauseSerializer(val)) : _err[key] = val;
+        }
+      return delete err[seen], _err.raw = err, _err;
+    }
+  }
+});
+
+// node_modules/pino-std-serializers/lib/req.js
+var require_req = __commonJS({
+  "node_modules/pino-std-serializers/lib/req.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      mapHttpRequest,
+      reqSerializer
+    };
+    var rawSymbol = /* @__PURE__ */ Symbol("pino-raw-req-ref"), pinoReqProto = Object.create({}, {
+      id: {
+        enumerable: !0,
+        writable: !0,
+        value: ""
+      },
+      method: {
+        enumerable: !0,
+        writable: !0,
+        value: ""
+      },
+      url: {
+        enumerable: !0,
+        writable: !0,
+        value: ""
+      },
+      query: {
+        enumerable: !0,
+        writable: !0,
+        value: ""
+      },
+      params: {
+        enumerable: !0,
+        writable: !0,
+        value: ""
+      },
+      headers: {
+        enumerable: !0,
+        writable: !0,
+        value: {}
+      },
+      remoteAddress: {
+        enumerable: !0,
+        writable: !0,
+        value: ""
+      },
+      remotePort: {
+        enumerable: !0,
+        writable: !0,
+        value: ""
+      },
+      raw: {
+        enumerable: !1,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoReqProto, rawSymbol, {
+      writable: !0,
+      value: {}
+    });
+    function reqSerializer(req) {
+      let connection = req.info || req.socket, _req = Object.create(pinoReqProto);
+      if (_req.id = typeof req.id == "function" ? req.id() : req.id || (req.info ? req.info.id : void 0), _req.method = req.method, req.originalUrl)
+        _req.url = req.originalUrl;
+      else {
+        let path = req.path;
+        _req.url = typeof path == "string" ? path : req.url ? req.url.path || req.url : void 0;
+      }
+      return req.query && (_req.query = req.query), 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, _req;
+    }
+    function mapHttpRequest(req) {
+      return {
+        req: reqSerializer(req)
+      };
+    }
+  }
+});
+
+// node_modules/pino-std-serializers/lib/res.js
+var require_res = __commonJS({
+  "node_modules/pino-std-serializers/lib/res.js"(exports, module) {
+    "use strict";
+    module.exports = {
+      mapHttpResponse,
+      resSerializer
+    };
+    var rawSymbol = /* @__PURE__ */ Symbol("pino-raw-res-ref"), pinoResProto = Object.create({}, {
+      statusCode: {
+        enumerable: !0,
+        writable: !0,
+        value: 0
+      },
+      headers: {
+        enumerable: !0,
+        writable: !0,
+        value: ""
+      },
+      raw: {
+        enumerable: !1,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoResProto, rawSymbol, {
+      writable: !0,
+      value: {}
+    });
+    function resSerializer(res) {
+      let _res = Object.create(pinoResProto);
+      return _res.statusCode = res.headersSent ? res.statusCode : null, _res.headers = res.getHeaders ? res.getHeaders() : res._headers, _res.raw = res, _res;
+    }
+    function mapHttpResponse(res) {
+      return {
+        res: resSerializer(res)
+      };
+    }
+  }
+});
+
+// node_modules/pino-std-serializers/index.js
+var require_pino_std_serializers = __commonJS({
+  "node_modules/pino-std-serializers/index.js"(exports, module) {
+    "use strict";
+    var errSerializer = require_err(), errWithCauseSerializer = require_err_with_cause(), reqSerializers = require_req(), resSerializers = require_res();
+    module.exports = {
+      err: errSerializer,
+      errWithCause: errWithCauseSerializer,
+      mapHttpRequest: reqSerializers.mapHttpRequest,
+      mapHttpResponse: resSerializers.mapHttpResponse,
+      req: reqSerializers.reqSerializer,
+      res: resSerializers.resSerializer,
+      wrapErrorSerializer: function(customSerializer) {
+        return customSerializer === errSerializer ? customSerializer : function(err) {
+          return customSerializer(errSerializer(err));
+        };
+      },
+      wrapRequestSerializer: function(customSerializer) {
+        return customSerializer === reqSerializers.reqSerializer ? customSerializer : function(req) {
+          return customSerializer(reqSerializers.reqSerializer(req));
+        };
+      },
+      wrapResponseSerializer: function(customSerializer) {
+        return customSerializer === resSerializers.resSerializer ? customSerializer : function(res) {
+          return customSerializer(resSerializers.resSerializer(res));
+        };
+      }
+    };
+  }
+});
+
+// node_modules/safe-stable-stringify/index.js
+var require_safe_stable_stringify = __commonJS({
+  "node_modules/safe-stable-stringify/index.js"(exports, module) {
+    "use strict";
+    var { hasOwnProperty } = Object.prototype, stringify = configure();
+    stringify.configure = configure;
+    stringify.stringify = stringify;
+    stringify.default = stringify;
+    exports.stringify = stringify;
+    exports.configure = configure;
+    module.exports = stringify;
+    var strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+    function strEscape(str) {
+      return str.length < 5e3 && !strEscapeSequencesRegExp.test(str) ? `"${str}"` : JSON.stringify(str);
+    }
+    function sort(array, comparator) {
+      if (array.length > 200 || comparator)
+        return array.sort(comparator);
+      for (let i = 1; i < array.length; i++) {
+        let currentValue = array[i], position = i;
+        for (; position !== 0 && array[position - 1] > currentValue; )
+          array[position] = array[position - 1], position--;
+        array[position] = currentValue;
+      }
+      return array;
+    }
+    var typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(
+      Object.getPrototypeOf(
+        Object.getPrototypeOf(
+          new Int8Array()
+        )
+      ),
+      Symbol.toStringTag
+    ).get;
+    function isTypedArrayWithEntries(value) {
+      return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
+    }
+    function stringifyTypedArray(array, separator, maximumBreadth) {
+      array.length < maximumBreadth && (maximumBreadth = array.length);
+      let whitespace = separator === "," ? "" : " ", 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")) {
+        let circularValue = options.circularValue;
+        if (typeof circularValue == "string")
+          return `"${circularValue}"`;
+        if (circularValue == null)
+          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, typeof value != "boolean" && typeof value != "function"))
+        throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
+      return value === void 0 ? !0 : value;
+    }
+    function getBooleanOption(options, key) {
+      let value;
+      if (hasOwnProperty.call(options, key) && (value = options[key], typeof value != "boolean"))
+        throw new TypeError(`The "${key}" argument must be of type boolean`);
+      return value === void 0 ? !0 : value;
+    }
+    function getPositiveIntegerOption(options, key) {
+      let value;
+      if (hasOwnProperty.call(options, key)) {
+        if (value = options[key], typeof value != "number")
+          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 value === void 0 ? 1 / 0 : value;
+    }
+    function getItemCount(number) {
+      return number === 1 ? "1 item" : `${number} items`;
+    }
+    function getUniqueReplacerSet(replacerArray) {
+      let replacerSet = /* @__PURE__ */ new Set();
+      for (let value of replacerArray)
+        (typeof value == "string" || typeof value == "number") && replacerSet.add(String(value));
+      return replacerSet;
+    }
+    function getStrictOption(options) {
+      if (hasOwnProperty.call(options, "strict")) {
+        let value = options.strict;
+        if (typeof value != "boolean")
+          throw new TypeError('The "strict" argument must be of type boolean');
+        if (value)
+          return (value2) => {
+            let message = `Object can not safely be stringified. Received type ${typeof value2}`;
+            throw typeof value2 != "function" && (message += ` (${value2.toString()})`), new Error(message);
+          };
+      }
+    }
+    function configure(options) {
+      options = { ...options };
+      let fail = getStrictOption(options);
+      fail && (options.bigint === void 0 && (options.bigint = !1), "circularValue" in options || (options.circularValue = Error));
+      let circularValue = getCircularValueOption(options), bigint = getBooleanOption(options, "bigint"), deterministic = getDeterministicOption(options), comparator = typeof deterministic == "function" ? deterministic : void 0, maximumDepth = getPositiveIntegerOption(options, "maximumDepth"), maximumBreadth = getPositiveIntegerOption(options, "maximumBreadth");
+      function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
+        let value = parent[key];
+        switch (typeof value == "object" && value !== null && typeof value.toJSON == "function" && (value = value.toJSON(key)), value = replacer.call(parent, key, value), typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null)
+              return "null";
+            if (stack.indexOf(value) !== -1)
+              return circularValue;
+            let res = "", join = ",", originalIndentation = indentation;
+            if (Array.isArray(value)) {
+              if (value.length === 0)
+                return "[]";
+              if (maximumDepth < stack.length + 1)
+                return '"[Array]"';
+              stack.push(value), spacer !== "" && (indentation += spacer, res += `
+${indentation}`, join = `,
+${indentation}`);
+              let maximumValuesToStringify = Math.min(value.length, maximumBreadth), i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                let tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+                res += tmp2 !== void 0 ? tmp2 : "null", res += join;
+              }
+              let tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+              if (res += tmp !== void 0 ? tmp : "null", value.length - 1 > maximumBreadth) {
+                let removedKeys = value.length - maximumBreadth - 1;
+                res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              return spacer !== "" && (res += `
+${originalIndentation}`), stack.pop(), `[${res}]`;
+            }
+            let keys = Object.keys(value), keyLength = keys.length;
+            if (keyLength === 0)
+              return "{}";
+            if (maximumDepth < stack.length + 1)
+              return '"[Object]"';
+            let whitespace = "", separator = "";
+            spacer !== "" && (indentation += spacer, join = `,
+${indentation}`, whitespace = " ");
+            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            deterministic && !isTypedArrayWithEntries(value) && (keys = sort(keys, comparator)), stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              let key2 = keys[i], tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
+              tmp !== void 0 && (res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`, separator = join);
+            }
+            if (keyLength > maximumBreadth) {
+              let removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`, separator = join;
+            }
+            return spacer !== "" && separator.length > 1 && (res = `
+${indentation}${res}
+${originalIndentation}`), stack.pop(), `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === !0 ? "true" : "false";
+          case "undefined":
+            return;
+          case "bigint":
+            if (bigint)
+              return String(value);
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
+        switch (typeof value == "object" && value !== null && typeof value.toJSON == "function" && (value = value.toJSON(key)), typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null)
+              return "null";
+            if (stack.indexOf(value) !== -1)
+              return circularValue;
+            let originalIndentation = indentation, res = "", join = ",";
+            if (Array.isArray(value)) {
+              if (value.length === 0)
+                return "[]";
+              if (maximumDepth < stack.length + 1)
+                return '"[Array]"';
+              stack.push(value), spacer !== "" && (indentation += spacer, res += `
+${indentation}`, join = `,
+${indentation}`);
+              let maximumValuesToStringify = Math.min(value.length, maximumBreadth), i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                let tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+                res += tmp2 !== void 0 ? tmp2 : "null", res += join;
+              }
+              let tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+              if (res += tmp !== void 0 ? tmp : "null", value.length - 1 > maximumBreadth) {
+                let removedKeys = value.length - maximumBreadth - 1;
+                res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              return spacer !== "" && (res += `
+${originalIndentation}`), stack.pop(), `[${res}]`;
+            }
+            stack.push(value);
+            let whitespace = "";
+            spacer !== "" && (indentation += spacer, join = `,
+${indentation}`, whitespace = " ");
+            let separator = "";
+            for (let key2 of replacer) {
+              let tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
+              tmp !== void 0 && (res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`, separator = join);
+            }
+            return spacer !== "" && separator.length > 1 && (res = `
+${indentation}${res}
+${originalIndentation}`), stack.pop(), `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === !0 ? "true" : "false";
+          case "undefined":
+            return;
+          case "bigint":
+            if (bigint)
+              return String(value);
+          // fallthrough
+          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 (value === null)
+              return "null";
+            if (typeof value.toJSON == "function") {
+              if (value = value.toJSON(key), typeof value != "object")
+                return stringifyIndent(key, value, stack, spacer, indentation);
+              if (value === null)
+                return "null";
+            }
+            if (stack.indexOf(value) !== -1)
+              return circularValue;
+            let originalIndentation = indentation;
+            if (Array.isArray(value)) {
+              if (value.length === 0)
+                return "[]";
+              if (maximumDepth < stack.length + 1)
+                return '"[Array]"';
+              stack.push(value), indentation += spacer;
+              let res2 = `
+${indentation}`, join2 = `,
+${indentation}`, maximumValuesToStringify = Math.min(value.length, maximumBreadth), i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                let tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+                res2 += tmp2 !== void 0 ? tmp2 : "null", res2 += join2;
+              }
+              let tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+              if (res2 += tmp !== void 0 ? tmp : "null", value.length - 1 > maximumBreadth) {
+                let removedKeys = value.length - maximumBreadth - 1;
+                res2 += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              return res2 += `
+${originalIndentation}`, stack.pop(), `[${res2}]`;
+            }
+            let keys = Object.keys(value), keyLength = keys.length;
+            if (keyLength === 0)
+              return "{}";
+            if (maximumDepth < stack.length + 1)
+              return '"[Object]"';
+            indentation += spacer;
+            let join = `,
+${indentation}`, res = "", separator = "", maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            isTypedArrayWithEntries(value) && (res += stringifyTypedArray(value, join, maximumBreadth), keys = keys.slice(value.length), maximumPropertiesToStringify -= value.length, separator = join), deterministic && (keys = sort(keys, comparator)), stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              let key2 = keys[i], tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
+              tmp !== void 0 && (res += `${separator}${strEscape(key2)}: ${tmp}`, separator = join);
+            }
+            if (keyLength > maximumBreadth) {
+              let removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`, separator = join;
+            }
+            return separator !== "" && (res = `
+${indentation}${res}
+${originalIndentation}`), stack.pop(), `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === !0 ? "true" : "false";
+          case "undefined":
+            return;
+          case "bigint":
+            if (bigint)
+              return String(value);
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringifySimple(key, value, stack) {
+        switch (typeof value) {
+          case "string":
+            return strEscape(value);
+          case "object": {
+            if (value === null)
+              return "null";
+            if (typeof value.toJSON == "function") {
+              if (value = value.toJSON(key), typeof value != "object")
+                return stringifySimple(key, value, stack);
+              if (value === null)
+                return "null";
+            }
+            if (stack.indexOf(value) !== -1)
+              return circularValue;
+            let res = "", hasLength = value.length !== void 0;
+            if (hasLength && Array.isArray(value)) {
+              if (value.length === 0)
+                return "[]";
+              if (maximumDepth < stack.length + 1)
+                return '"[Array]"';
+              stack.push(value);
+              let maximumValuesToStringify = Math.min(value.length, maximumBreadth), i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                let tmp2 = stringifySimple(String(i), value[i], stack);
+                res += tmp2 !== void 0 ? tmp2 : "null", res += ",";
+              }
+              let tmp = stringifySimple(String(i), value[i], stack);
+              if (res += tmp !== void 0 ? tmp : "null", value.length - 1 > maximumBreadth) {
+                let removedKeys = value.length - maximumBreadth - 1;
+                res += `,"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              return stack.pop(), `[${res}]`;
+            }
+            let keys = Object.keys(value), keyLength = keys.length;
+            if (keyLength === 0)
+              return "{}";
+            if (maximumDepth < stack.length + 1)
+              return '"[Object]"';
+            let separator = "", maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            hasLength && isTypedArrayWithEntries(value) && (res += stringifyTypedArray(value, ",", maximumBreadth), keys = keys.slice(value.length), maximumPropertiesToStringify -= value.length, separator = ","), deterministic && (keys = sort(keys, comparator)), stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              let key2 = keys[i], tmp = stringifySimple(key2, value[key2], stack);
+              tmp !== void 0 && (res += `${separator}${strEscape(key2)}:${tmp}`, separator = ",");
+            }
+            if (keyLength > maximumBreadth) {
+              let removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
+            }
+            return stack.pop(), `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+          case "boolean":
+            return value === !0 ? "true" : "false";
+          case "undefined":
+            return;
+          case "bigint":
+            if (bigint)
+              return String(value);
+          // fallthrough
+          default:
+            return fail ? fail(value) : void 0;
+        }
+      }
+      function stringify2(value, replacer, space) {
+        if (arguments.length > 1) {
+          let spacer = "";
+          if (typeof space == "number" ? spacer = " ".repeat(Math.min(space, 10)) : typeof space == "string" && (spacer = space.slice(0, 10)), replacer != null) {
+            if (typeof replacer == "function")
+              return stringifyFnReplacer("", { "": value }, [], replacer, spacer, "");
+            if (Array.isArray(replacer))
+              return stringifyArrayReplacer("", value, [], getUniqueReplacerSet(replacer), spacer, "");
+          }
+          if (spacer.length !== 0)
+            return stringifyIndent("", value, [], spacer, "");
+        }
+        return stringifySimple("", value, []);
+      }
+      return stringify2;
+    }
+  }
+});
+
+// node_modules/@pinojs/redact/index.js
+var require_redact = __commonJS({
+  "node_modules/@pinojs/redact/index.js"(exports, module) {
+    "use strict";
+    function deepClone(obj) {
+      if (obj === null || typeof obj != "object")
+        return obj;
+      if (obj instanceof Date)
+        return new Date(obj.getTime());
+      if (obj instanceof Array) {
+        let cloned = [];
+        for (let i = 0; i < obj.length; i++)
+          cloned[i] = deepClone(obj[i]);
+        return cloned;
+      }
+      if (typeof obj == "object") {
+        let cloned = Object.create(Object.getPrototypeOf(obj));
+        for (let key in obj)
+          Object.prototype.hasOwnProperty.call(obj, key) && (cloned[key] = deepClone(obj[key]));
+        return cloned;
+      }
+      return obj;
+    }
+    function parsePath(path) {
+      let parts = [], current = "", inBrackets = !1, inQuotes = !1, quoteChar = "";
+      for (let i = 0; i < path.length; i++) {
+        let char = path[i];
+        !inBrackets && char === "." ? current && (parts.push(current), current = "") : char === "[" ? (current && (parts.push(current), current = ""), inBrackets = !0) : char === "]" && inBrackets ? (parts.push(current), current = "", inBrackets = !1, inQuotes = !1) : (char === '"' || char === "'") && inBrackets ? inQuotes ? char === quoteChar ? (inQuotes = !1, quoteChar = "") : current += char : (inQuotes = !0, quoteChar = char) : current += char;
+      }
+      return current && parts.push(current), parts;
+    }
+    function setValue(obj, parts, value) {
+      let current = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        let key = parts[i];
+        if (typeof current != "object" || current === null || !(key in current) || typeof current[key] != "object" || current[key] === null)
+          return !1;
+        current = current[key];
+      }
+      let lastKey = parts[parts.length - 1];
+      if (lastKey === "*") {
+        if (Array.isArray(current))
+          for (let i = 0; i < current.length; i++)
+            current[i] = value;
+        else if (typeof current == "object" && current !== null)
+          for (let key in current)
+            Object.prototype.hasOwnProperty.call(current, key) && (current[key] = value);
+      } else
+        typeof current == "object" && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey) && (current[lastKey] = value);
+      return !0;
+    }
+    function removeKey(obj, parts) {
+      let current = obj;
+      for (let i = 0; i < parts.length - 1; i++) {
+        let key = parts[i];
+        if (typeof current != "object" || current === null || !(key in current) || typeof current[key] != "object" || current[key] === null)
+          return !1;
+        current = current[key];
+      }
+      let 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 (typeof current == "object" && current !== null)
+          for (let key in current)
+            Object.prototype.hasOwnProperty.call(current, key) && delete current[key];
+      } else
+        typeof current == "object" && current !== null && lastKey in current && Object.prototype.hasOwnProperty.call(current, lastKey) && delete current[lastKey];
+      return !0;
+    }
+    var PATH_NOT_FOUND = /* @__PURE__ */ Symbol("PATH_NOT_FOUND");
+    function getValueIfExists(obj, parts) {
+      let current = obj;
+      for (let part of parts) {
+        if (current == null || typeof current != "object" || current === null || !(part in current))
+          return PATH_NOT_FOUND;
+        current = current[part];
+      }
+      return current;
+    }
+    function getValue(obj, parts) {
+      let current = obj;
+      for (let part of parts) {
+        if (current == null || typeof current != "object" || current === null)
+          return;
+        current = current[part];
+      }
+      return current;
+    }
+    function redactPaths(obj, paths, censor, remove = !1) {
+      for (let path of paths) {
+        let parts = parsePath(path);
+        if (parts.includes("*"))
+          redactWildcardPath(obj, parts, censor, path, remove);
+        else if (remove)
+          removeKey(obj, parts);
+        else {
+          let value = getValueIfExists(obj, parts);
+          if (value === PATH_NOT_FOUND)
+            continue;
+          let actualCensor = typeof censor == "function" ? censor(value, parts) : censor;
+          setValue(obj, parts, actualCensor);
+        }
+      }
+    }
+    function redactWildcardPath(obj, parts, censor, originalPath, remove = !1) {
+      let wildcardIndex = parts.indexOf("*");
+      if (wildcardIndex === parts.length - 1) {
+        let parentParts = parts.slice(0, -1), current = obj;
+        for (let part of parentParts) {
+          if (current == null || typeof current != "object" || current === null) 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++) {
+              let indexPath = [...parentParts, i.toString()], actualCensor = typeof censor == "function" ? censor(current[i], indexPath) : censor;
+              current[i] = actualCensor;
+            }
+        else if (typeof current == "object" && current !== null)
+          if (remove) {
+            let keysToDelete = [];
+            for (let key in current)
+              Object.prototype.hasOwnProperty.call(current, key) && keysToDelete.push(key);
+            for (let key of keysToDelete)
+              delete current[key];
+          } else
+            for (let key in current) {
+              let keyPath = [...parentParts, key], actualCensor = typeof censor == "function" ? censor(current[key], keyPath) : censor;
+              current[key] = actualCensor;
+            }
+      } else
+        redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove);
+    }
+    function redactIntermediateWildcard(obj, parts, censor, wildcardIndex, originalPath, remove = !1) {
+      let beforeWildcard = parts.slice(0, wildcardIndex), afterWildcard = parts.slice(wildcardIndex + 1), 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 (typeof current == "object" && current !== null)
+            for (let key in current)
+              pathArray[pathLength] = key, traverse(current[key], pathLength + 1);
+        } else if (pathLength < beforeWildcard.length) {
+          let nextKey = beforeWildcard[pathLength];
+          current && typeof current == "object" && current !== null && nextKey in current && (pathArray[pathLength] = nextKey, traverse(current[nextKey], pathLength + 1));
+        } else if (afterWildcard.includes("*"))
+          redactWildcardPath(current, afterWildcard, typeof censor == "function" ? (value, path) => {
+            let fullPath = [...pathArray.slice(0, pathLength), ...path];
+            return censor(value, fullPath);
+          } : censor, originalPath, remove);
+        else if (remove)
+          removeKey(current, afterWildcard);
+        else {
+          let actualCensor = typeof censor == "function" ? censor(getValue(current, afterWildcard), [...pathArray.slice(0, pathLength), ...afterWildcard]) : censor;
+          setValue(current, afterWildcard, actualCensor);
+        }
+      }
+      if (beforeWildcard.length === 0)
+        traverse(obj, 0);
+      else {
+        let current = obj;
+        for (let i = 0; i < beforeWildcard.length; i++) {
+          let part = beforeWildcard[i];
+          if (current == null || typeof current != "object" || current === null) return;
+          current = current[part], pathArray[i] = part;
+        }
+        current != null && traverse(current, beforeWildcard.length);
+      }
+    }
+    function buildPathStructure(pathsToClone) {
+      if (pathsToClone.length === 0)
+        return null;
+      let pathStructure = /* @__PURE__ */ new Map();
+      for (let path of pathsToClone) {
+        let parts = parsePath(path), current = pathStructure;
+        for (let i = 0; i < parts.length; i++) {
+          let part = parts[i];
+          current.has(part) || current.set(part, /* @__PURE__ */ new Map()), current = current.get(part);
+        }
+      }
+      return pathStructure;
+    }
+    function selectiveClone(obj, pathStructure) {
+      if (!pathStructure)
+        return obj;
+      function cloneSelectively(source, pathMap, depth = 0) {
+        if (!pathMap || pathMap.size === 0 || source === null || typeof source != "object")
+          return source;
+        if (source instanceof Date)
+          return new Date(source.getTime());
+        if (Array.isArray(source)) {
+          let cloned2 = [];
+          for (let i = 0; i < source.length; i++) {
+            let indexStr = i.toString();
+            pathMap.has(indexStr) || pathMap.has("*") ? cloned2[i] = cloneSelectively(source[i], pathMap.get(indexStr) || pathMap.get("*")) : cloned2[i] = source[i];
+          }
+          return cloned2;
+        }
+        let cloned = Object.create(Object.getPrototypeOf(source));
+        for (let key in source)
+          Object.prototype.hasOwnProperty.call(source, key) && (pathMap.has(key) || pathMap.has("*") ? cloned[key] = cloneSelectively(source[key], pathMap.get(key) || pathMap.get("*")) : cloned[key] = source[key]);
+        return cloned;
+      }
+      return cloneSelectively(obj, pathStructure);
+    }
+    function validatePath(path) {
+      if (typeof path != "string")
+        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, inQuotes = !1, quoteChar = "";
+      for (let i = 0; i < path.length; i++) {
+        let char = path[i];
+        if ((char === '"' || char === "'") && bracketCount > 0)
+          inQuotes ? char === quoteChar && (inQuotes = !1, quoteChar = "") : (inQuotes = !0, quoteChar = char);
+        else if (char === "[" && !inQuotes)
+          bracketCount++;
+        else if (char === "]" && !inQuotes && (bracketCount--, bracketCount < 0))
+          throw new Error(`Invalid redaction path (${path})`);
+      }
+      if (bracketCount !== 0)
+        throw new Error(`Invalid redaction path (${path})`);
+    }
+    function validatePaths(paths) {
+      if (!Array.isArray(paths))
+        throw new TypeError("paths must be an array");
+      for (let path of paths)
+        validatePath(path);
+    }
+    function slowRedact(options = {}) {
+      let {
+        paths = [],
+        censor = "[REDACTED]",
+        serialize = JSON.stringify,
+        strict = !0,
+        remove = !1
+      } = options;
+      validatePaths(paths);
+      let pathStructure = buildPathStructure(paths);
+      return function(obj) {
+        if (strict && (obj === null || typeof obj != "object") && (obj == null || typeof obj != "object"))
+          return serialize ? serialize(obj) : obj;
+        let cloned = selectiveClone(obj, pathStructure), original = obj, actualCensor = censor;
+        return typeof censor == "function" && (actualCensor = censor), redactPaths(cloned, paths, actualCensor, remove), serialize === !1 ? (cloned.restore = function() {
+          return deepClone(original);
+        }, cloned) : typeof serialize == "function" ? serialize(cloned) : JSON.stringify(cloned);
+      };
+    }
+    module.exports = slowRedact;
+  }
+});
+
+// node_modules/quick-format-unescaped/index.js
+var require_quick_format_unescaped = __commonJS({
+  "node_modules/quick-format-unescaped/index.js"(exports, module) {
+    "use strict";
+    function tryStringify(o) {
+      try {
+        return JSON.stringify(o);
+      } catch {
+        return '"[Circular]"';
+      }
+    }
+    module.exports = format;
+    function format(f, args, opts) {
+      var ss = opts && opts.stringify || tryStringify, offset = 1;
+      if (typeof f == "object" && f !== null) {
+        var len = args.length + offset;
+        if (len === 1) 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 (typeof f != "string")
+        return f;
+      var argLen = args.length;
+      if (argLen === 0) return f;
+      for (var str = "", a = 1 - offset, lastPos = -1, flen = f && f.length || 0, i = 0; i < flen; ) {
+        if (f.charCodeAt(i) === 37 && i + 1 < flen) {
+          switch (lastPos = lastPos > -1 ? lastPos : 0, f.charCodeAt(i + 1)) {
+            case 100:
+            // 'd'
+            case 102:
+              if (a >= argLen || args[a] == null) break;
+              lastPos < i && (str += f.slice(lastPos, i)), str += Number(args[a]), lastPos = i + 2, i++;
+              break;
+            case 105:
+              if (a >= argLen || args[a] == null) break;
+              lastPos < i && (str += f.slice(lastPos, i)), str += Math.floor(Number(args[a])), lastPos = i + 2, i++;
+              break;
+            case 79:
+            // 'O'
+            case 111:
+            // 'o'
+            case 106:
+              if (a >= argLen || args[a] === void 0) break;
+              lastPos < i && (str += f.slice(lastPos, i));
+              var type = typeof args[a];
+              if (type === "string") {
+                str += "'" + args[a] + "'", lastPos = i + 2, i++;
+                break;
+              }
+              if (type === "function") {
+                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;
+              lastPos < i && (str += f.slice(lastPos, i)), str += String(args[a]), lastPos = i + 2, i++;
+              break;
+            case 37:
+              lastPos < i && (str += f.slice(lastPos, i)), str += "%", lastPos = i + 2, i++, a--;
+              break;
+          }
+          ++a;
+        }
+        ++i;
+      }
+      return lastPos === -1 ? f : (lastPos < flen && (str += f.slice(lastPos)), str);
+    }
+  }
+});
+
+// node_modules/atomic-sleep/index.js
+var require_atomic_sleep = __commonJS({
+  "node_modules/atomic-sleep/index.js"(exports, module) {
+    "use strict";
+    if (typeof SharedArrayBuffer < "u" && typeof Atomics < "u") {
+      let sleep = function(ms) {
+        if ((ms > 0 && ms < 1 / 0) === !1)
+          throw typeof ms != "number" && typeof ms != "bigint" ? TypeError("sleep: ms must be a number") : RangeError("sleep: ms must be a number that is greater than 0 but less than Infinity");
+        Atomics.wait(nil, 0, 0, Number(ms));
+      }, nil = new Int32Array(new SharedArrayBuffer(4));
+      module.exports = sleep;
+    } else {
+      let sleep = function(ms) {
+        if ((ms > 0 && ms < 1 / 0) === !1)
+          throw typeof ms != "number" && typeof ms != "bigint" ? TypeError("sleep: ms must be a number") : RangeError("sleep: ms must be a number that is greater than 0 but less than Infinity");
+        let target = Date.now() + Number(ms);
+        for (; target > Date.now(); )
+          ;
+      };
+      module.exports = sleep;
+    }
+  }
+});
+
+// node_modules/sonic-boom/index.js
+var require_sonic_boom = __commonJS({
+  "node_modules/sonic-boom/index.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs"), EventEmitter = __require("events"), inherits = __require("util").inherits, path = __require("path"), sleep = require_atomic_sleep(), assert = __require("assert"), BUSY_WRITE_TIMEOUT = 100, kEmptyBuffer = Buffer.allocUnsafe(0), MAX_WRITE = 16 * 1024, kContentModeBuffer = "buffer", kContentModeUtf8 = "utf8", [major, minor] = (process.versions.node || "0.0").split(".").map(Number), kCopyBuffer = major >= 22 && minor >= 7;
+    function openFile(file, sonic) {
+      sonic._opening = !0, sonic._writing = !0, sonic._asyncDrainScheduled = !1;
+      function fileOpened(err, fd) {
+        if (err) {
+          sonic._reopening = !1, sonic._writing = !1, sonic._opening = !1, sonic.sync ? process.nextTick(() => {
+            sonic.listenerCount("error") > 0 && sonic.emit("error", err);
+          }) : sonic.emit("error", err);
+          return;
+        }
+        let reopening = sonic._reopening;
+        sonic.fd = fd, sonic.file = file, sonic._reopening = !1, sonic._opening = !1, sonic._writing = !1, sonic.sync ? process.nextTick(() => sonic.emit("ready")) : sonic.emit("ready"), !sonic.destroyed && (!sonic._writing && sonic._len > sonic.minLength || sonic._flushPending ? sonic._actualWrite() : reopening && process.nextTick(() => sonic.emit("drain")));
+      }
+      let flags = sonic.append ? "a" : "w", mode = sonic.mode;
+      if (sonic.sync)
+        try {
+          sonic.mkdir && fs.mkdirSync(path.dirname(file), { recursive: !0 });
+          let fd = fs.openSync(file, flags, mode);
+          fileOpened(null, fd);
+        } catch (err) {
+          throw fileOpened(err), err;
+        }
+      else sonic.mkdir ? fs.mkdir(path.dirname(file), { recursive: !0 }, (err) => {
+        if (err) return fileOpened(err);
+        fs.open(file, flags, mode, fileOpened);
+      }) : 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 = !0, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+      fd = fd || dest, this._len = 0, this.fd = -1, this._bufs = [], this._lens = [], this._writing = !1, this._ending = !1, this._reopening = !1, this._asyncDrainScheduled = !1, this._flushPending = !1, this._hwm = Math.max(minLength || 0, 16387), this.file = null, this.destroyed = !1, this.minLength = minLength || 0, this.maxLength = maxLength || 0, this.maxWrite = maxWrite || MAX_WRITE, this._periodicFlush = periodicFlush || 0, this._periodicFlushTimer = void 0, this.sync = sync || !1, this.writable = !0, this._fsync = fsync || !1, this.append = append || !1, this.mode = mode, this.retryEAGAIN = retryEAGAIN || (() => !0), this.mkdir = mkdir || !1;
+      let fsWriteSync, 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 (contentMode === void 0 || contentMode === kContentModeUtf8)
+        this._writingBuf = "", this.write = write, this.flush = flush, this.flushSync = flushSync, this._actualWrite = actualWrite, fsWriteSync = () => Buffer.isBuffer(this._writingBuf) ? fs.writeSync(this.fd, this._writingBuf) : fs.writeSync(this.fd, this._writingBuf, "utf8"), fsWrite = () => Buffer.isBuffer(this._writingBuf) ? fs.write(this.fd, this._writingBuf, this.release) : fs.write(this.fd, this._writingBuf, "utf8", this.release);
+      else
+        throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`);
+      if (typeof fd == "number")
+        this.fd = fd, process.nextTick(() => this.emit("ready"));
+      else if (typeof fd == "string")
+        openFile(fd, this);
+      else
+        throw new Error("SonicBoom supports only file descriptors and files");
+      if (this.minLength >= this.maxWrite)
+        throw new Error(`minLength should be smaller than maxWrite (${this.maxWrite})`);
+      this.release = (err, n) => {
+        if (err) {
+          if ((err.code === "EAGAIN" || err.code === "EBUSY") && 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 (err2) {
+                this.release(err2);
+              }
+            else
+              setTimeout(fsWrite, BUSY_WRITE_TIMEOUT);
+          else
+            this._writing = !1, this.emit("error", err);
+          return;
+        }
+        this.emit("write", n);
+        let releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n);
+        if (this._len = releasedBufObj.len, this._writingBuf = releasedBufObj.writingBuf, this._writingBuf.length) {
+          if (!this.sync) {
+            fsWrite();
+            return;
+          }
+          try {
+            do {
+              let n2 = fsWriteSync(), releasedBufObj2 = releaseWritingBuf(this._writingBuf, this._len, n2);
+              this._len = releasedBufObj2.len, this._writingBuf = releasedBufObj2.writingBuf;
+            } while (this._writingBuf.length);
+          } catch (err2) {
+            this.release(err2);
+            return;
+          }
+        }
+        this._fsync && fs.fsyncSync(this.fd);
+        let len = this._len;
+        this._reopening ? (this._writing = !1, this._reopening = !1, this.reopen()) : len > this.minLength ? this._actualWrite() : this._ending ? len > 0 ? this._actualWrite() : (this._writing = !1, actualClose(this)) : (this._writing = !1, this.sync ? this._asyncDrainScheduled || (this._asyncDrainScheduled = !0, process.nextTick(emitDrain, this)) : this.emit("drain"));
+      }, this.on("newListener", function(name) {
+        name === "drain" && (this._asyncDrainScheduled = !1);
+      }), this._periodicFlush !== 0 && (this._periodicFlushTimer = setInterval(() => this.flush(null), this._periodicFlush), this._periodicFlushTimer.unref());
+    }
+    function releaseWritingBuf(writingBuf, len, n) {
+      return typeof writingBuf == "string" && (writingBuf = Buffer.from(writingBuf)), len = Math.max(len - n, 0), writingBuf = writingBuf.subarray(n), { writingBuf, len };
+    }
+    function emitDrain(sonic) {
+      sonic.listenerCount("drain") > 0 && (sonic._asyncDrainScheduled = !1, sonic.emit("drain"));
+    }
+    inherits(SonicBoom, EventEmitter);
+    function mergeBuf(bufs, len) {
+      return bufs.length === 0 ? kEmptyBuffer : bufs.length === 1 ? bufs[0] : Buffer.concat(bufs, len);
+    }
+    function write(data) {
+      if (this.destroyed)
+        throw new Error("SonicBoom destroyed");
+      data = "" + data;
+      let dataLen = Buffer.byteLength(data), len = this._len + dataLen, bufs = this._bufs;
+      return this.maxLength && len > this.maxLength ? (this.emit("drop", data), this._len < this._hwm) : (bufs.length === 0 || Buffer.byteLength(bufs[bufs.length - 1]) + dataLen > this.maxWrite ? bufs.push(data) : bufs[bufs.length - 1] += data, this._len = len, !this._writing && this._len >= this.minLength && this._actualWrite(), this._len < this._hwm);
+    }
+    function writeBuffer(data) {
+      if (this.destroyed)
+        throw new Error("SonicBoom destroyed");
+      let len = this._len + data.length, bufs = this._bufs, lens = this._lens;
+      return this.maxLength && len > this.maxLength ? (this.emit("drop", data), this._len < this._hwm) : (bufs.length === 0 || lens[lens.length - 1] + data.length > this.maxWrite ? (bufs.push([data]), lens.push(data.length)) : (bufs[bufs.length - 1].push(data), lens[lens.length - 1] += data.length), this._len = len, !this._writing && this._len >= this.minLength && this._actualWrite(), this._len < this._hwm);
+    }
+    function callFlushCallbackOnDrain(cb) {
+      this._flushPending = !0;
+      let onDrain = () => {
+        if (this._fsync)
+          this._flushPending = !1, cb();
+        else
+          try {
+            fs.fsync(this.fd, (err) => {
+              this._flushPending = !1, cb(err);
+            });
+          } catch (err) {
+            cb(err);
+          }
+        this.off("error", onError);
+      }, onError = (err) => {
+        this._flushPending = !1, cb(err), this.off("drain", onDrain);
+      };
+      this.once("drain", onDrain), this.once("error", onError);
+    }
+    function flush(cb) {
+      if (cb != null && typeof cb != "function")
+        throw new Error("flush cb must be a function");
+      if (this.destroyed) {
+        let error = new Error("SonicBoom destroyed");
+        if (cb) {
+          cb(error);
+          return;
+        }
+        throw error;
+      }
+      if (this.minLength <= 0) {
+        cb?.();
+        return;
+      }
+      cb && callFlushCallbackOnDrain.call(this, cb), !this._writing && (this._bufs.length === 0 && this._bufs.push(""), this._actualWrite());
+    }
+    function flushBuffer(cb) {
+      if (cb != null && typeof cb != "function")
+        throw new Error("flush cb must be a function");
+      if (this.destroyed) {
+        let error = new Error("SonicBoom destroyed");
+        if (cb) {
+          cb(error);
+          return;
+        }
+        throw error;
+      }
+      if (this.minLength <= 0) {
+        cb?.();
+        return;
+      }
+      cb && callFlushCallbackOnDrain.call(this, cb), !this._writing && (this._bufs.length === 0 && (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) {
+        this.once("ready", () => {
+          this.reopen(file);
+        });
+        return;
+      }
+      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 = !0, this._writing)
+        return;
+      let fd = this.fd;
+      this.once("ready", () => {
+        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) {
+        this.once("ready", () => {
+          this.end();
+        });
+        return;
+      }
+      this._ending || (this._ending = !0, !this._writing && (this._len > 0 && this.fd >= 0 ? this._actualWrite() : 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");
+      !this._writing && this._writingBuf.length > 0 && (this._bufs.unshift(this._writingBuf), this._writingBuf = "");
+      let buf = "";
+      for (; this._bufs.length || buf.length; ) {
+        buf.length <= 0 && (buf = this._bufs[0]);
+        try {
+          let n = Buffer.isBuffer(buf) ? fs.writeSync(this.fd, buf) : fs.writeSync(this.fd, buf, "utf8"), releasedBufObj = releaseWritingBuf(buf, this._len, n);
+          buf = releasedBufObj.writingBuf, this._len = releasedBufObj.len, buf.length <= 0 && this._bufs.shift();
+        } catch (err) {
+          if ((err.code === "EAGAIN" || err.code === "EBUSY") && !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");
+      !this._writing && this._writingBuf.length > 0 && (this._bufs.unshift([this._writingBuf]), this._writingBuf = kEmptyBuffer);
+      let buf = kEmptyBuffer;
+      for (; this._bufs.length || buf.length; ) {
+        buf.length <= 0 && (buf = mergeBuf(this._bufs[0], this._lens[0]));
+        try {
+          let n = fs.writeSync(this.fd, buf);
+          buf = buf.subarray(n), this._len = Math.max(this._len - n, 0), buf.length <= 0 && (this._bufs.shift(), this._lens.shift());
+        } catch (err) {
+          if ((err.code === "EAGAIN" || err.code === "EBUSY") && !this.retryEAGAIN(err, buf.length, this._len - buf.length))
+            throw err;
+          sleep(BUSY_WRITE_TIMEOUT);
+        }
+      }
+    }
+    SonicBoom.prototype.destroy = function() {
+      this.destroyed || actualClose(this);
+    };
+    function actualWrite() {
+      let release = this.release;
+      if (this._writing = !0, this._writingBuf = this._writingBuf.length ? this._writingBuf : this._bufs.shift() || "", this.sync)
+        try {
+          let written = Buffer.isBuffer(this._writingBuf) ? fs.writeSync(this.fd, this._writingBuf) : fs.writeSync(this.fd, this._writingBuf, "utf8");
+          release(null, written);
+        } catch (err) {
+          release(err);
+        }
+      else
+        fs.write(this.fd, this._writingBuf, release);
+    }
+    function actualWriteBuffer() {
+      let release = this.release;
+      if (this._writing = !0, this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift()), this.sync)
+        try {
+          let written = fs.writeSync(this.fd, this._writingBuf);
+          release(null, written);
+        } catch (err) {
+          release(err);
+        }
+      else
+        kCopyBuffer && (this._writingBuf = Buffer.from(this._writingBuf)), fs.write(this.fd, this._writingBuf, release);
+    }
+    function actualClose(sonic) {
+      if (sonic.fd === -1) {
+        sonic.once("ready", actualClose.bind(null, sonic));
+        return;
+      }
+      sonic._periodicFlushTimer !== void 0 && clearInterval(sonic._periodicFlushTimer), sonic.destroyed = !0, sonic._bufs = [], sonic._lens = [], assert(typeof sonic.fd == "number", `sonic.fd must be a number, got ${typeof sonic.fd}`);
+      try {
+        fs.fsync(sonic.fd, closeWrapped);
+      } catch {
+      }
+      function closeWrapped() {
+        sonic.fd !== 1 && sonic.fd !== 2 ? fs.close(sonic.fd, done) : done();
+      }
+      function done(err) {
+        if (err) {
+          sonic.emit("error", err);
+          return;
+        }
+        sonic._ending && !sonic._writing && sonic.emit("finish"), sonic.emit("close");
+      }
+    }
+    SonicBoom.SonicBoom = SonicBoom;
+    SonicBoom.default = SonicBoom;
+    module.exports = SonicBoom;
+  }
+});
+
+// node_modules/on-exit-leak-free/index.js
+var require_on_exit_leak_free = __commonJS({
+  "node_modules/on-exit-leak-free/index.js"(exports, module) {
+    "use strict";
+    var refs = {
+      exit: [],
+      beforeExit: []
+    }, functions = {
+      exit: onExit,
+      beforeExit: onBeforeExit
+    }, registry;
+    function ensureRegistry() {
+      registry === void 0 && (registry = new FinalizationRegistry(clear));
+    }
+    function install(event) {
+      refs[event].length > 0 || process.on(event, functions[event]);
+    }
+    function uninstall(event) {
+      refs[event].length > 0 || (process.removeListener(event, functions[event]), refs.exit.length === 0 && refs.beforeExit.length === 0 && (registry = void 0));
+    }
+    function onExit() {
+      callRefs("exit");
+    }
+    function onBeforeExit() {
+      callRefs("beforeExit");
+    }
+    function callRefs(event) {
+      for (let ref of refs[event]) {
+        let obj = ref.deref(), fn = ref.fn;
+        obj !== void 0 && fn(obj, event);
+      }
+      refs[event] = [];
+    }
+    function clear(ref) {
+      for (let event of ["exit", "beforeExit"]) {
+        let index = refs[event].indexOf(ref);
+        refs[event].splice(index, index + 1), uninstall(event);
+      }
+    }
+    function _register(event, obj, fn) {
+      if (obj === void 0)
+        throw new Error("the object can't be undefined");
+      install(event);
+      let 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 (registry !== void 0) {
+        registry.unregister(obj);
+        for (let event of ["exit", "beforeExit"])
+          refs[event] = refs[event].filter((ref) => {
+            let _obj = ref.deref();
+            return _obj && _obj !== obj;
+          }), uninstall(event);
+      }
+    }
+    module.exports = {
+      register,
+      registerBeforeExit,
+      unregister
+    };
+  }
+});
+
+export {
+  require_pino_std_serializers,
+  require_redact,
+  require_quick_format_unescaped,
+  require_atomic_sleep,
+  require_sonic_boom,
+  require_on_exit_leak_free,
+  require_safe_stable_stringify
+};