appos 0.1.6-0 → 0.1.8-0

package/build/main.js

@@ -304892,6 +304892,2278 @@ var require_pino = __commonJS((exports, module) => {
   module.exports.pino = pino;
 });
 
+// node_modules/colorette/index.cjs
+var require_colorette = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var tty2 = __require("tty");
+  function _interopNamespace(e3) {
+    if (e3 && e3.__esModule)
+      return e3;
+    var n2 = Object.create(null);
+    if (e3) {
+      Object.keys(e3).forEach(function(k5) {
+        if (k5 !== "default") {
+          var d5 = Object.getOwnPropertyDescriptor(e3, k5);
+          Object.defineProperty(n2, k5, d5.get ? d5 : {
+            enumerable: true,
+            get: function() {
+              return e3[k5];
+            }
+          });
+        }
+      });
+    }
+    n2["default"] = e3;
+    return Object.freeze(n2);
+  }
+  var tty__namespace = /* @__PURE__ */ _interopNamespace(tty2);
+  var {
+    env: env5 = {},
+    argv = [],
+    platform = ""
+  } = typeof process === "undefined" ? {} : process;
+  var isDisabled = "NO_COLOR" in env5 || argv.includes("--no-color");
+  var isForced = "FORCE_COLOR" in env5 || argv.includes("--color");
+  var isWindows = platform === "win32";
+  var isDumbTerminal = env5.TERM === "dumb";
+  var isCompatibleTerminal = tty__namespace && tty__namespace.isatty && tty__namespace.isatty(1) && env5.TERM && !isDumbTerminal;
+  var isCI2 = "CI" in env5 && (("GITHUB_ACTIONS" in env5) || ("GITLAB_CI" in env5) || ("CIRCLECI" in env5));
+  var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI2);
+  var replaceClose = (index3, string8, close, replace, head = string8.substring(0, index3) + replace, tail = string8.substring(index3 + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+  var clearBleed = (index3, string8, open, close, replace) => index3 < 0 ? open + string8 + close : open + replaceClose(index3, string8, close, replace) + close;
+  var filterEmpty = (open, close, replace = open, at3 = open.length + 1) => (string8) => string8 || !(string8 === "" || string8 === undefined) ? clearBleed(("" + string8).indexOf(close, at3), string8, open, close, replace) : "";
+  var init3 = (open, close, replace) => filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, replace);
+  var colors9 = {
+    reset: init3(0, 0),
+    bold: init3(1, 22, "\x1B[22m\x1B[1m"),
+    dim: init3(2, 22, "\x1B[22m\x1B[2m"),
+    italic: init3(3, 23),
+    underline: init3(4, 24),
+    inverse: init3(7, 27),
+    hidden: init3(8, 28),
+    strikethrough: init3(9, 29),
+    black: init3(30, 39),
+    red: init3(31, 39),
+    green: init3(32, 39),
+    yellow: init3(33, 39),
+    blue: init3(34, 39),
+    magenta: init3(35, 39),
+    cyan: init3(36, 39),
+    white: init3(37, 39),
+    gray: init3(90, 39),
+    bgBlack: init3(40, 49),
+    bgRed: init3(41, 49),
+    bgGreen: init3(42, 49),
+    bgYellow: init3(43, 49),
+    bgBlue: init3(44, 49),
+    bgMagenta: init3(45, 49),
+    bgCyan: init3(46, 49),
+    bgWhite: init3(47, 49),
+    blackBright: init3(90, 39),
+    redBright: init3(91, 39),
+    greenBright: init3(92, 39),
+    yellowBright: init3(93, 39),
+    blueBright: init3(94, 39),
+    magentaBright: init3(95, 39),
+    cyanBright: init3(96, 39),
+    whiteBright: init3(97, 39),
+    bgBlackBright: init3(100, 49),
+    bgRedBright: init3(101, 49),
+    bgGreenBright: init3(102, 49),
+    bgYellowBright: init3(103, 49),
+    bgBlueBright: init3(104, 49),
+    bgMagentaBright: init3(105, 49),
+    bgCyanBright: init3(106, 49),
+    bgWhiteBright: init3(107, 49)
+  };
+  var createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors9 : Object.keys(colors9).reduce((colors10, key2) => ({ ...colors10, [key2]: String }), {});
+  var {
+    reset: reset3,
+    bold,
+    dim,
+    italic,
+    underline,
+    inverse,
+    hidden,
+    strikethrough: strikethrough2,
+    black,
+    red,
+    green,
+    yellow,
+    blue,
+    magenta,
+    cyan,
+    white,
+    gray,
+    bgBlack,
+    bgRed,
+    bgGreen,
+    bgYellow,
+    bgBlue,
+    bgMagenta,
+    bgCyan,
+    bgWhite,
+    blackBright,
+    redBright,
+    greenBright,
+    yellowBright,
+    blueBright,
+    magentaBright,
+    cyanBright,
+    whiteBright,
+    bgBlackBright,
+    bgRedBright,
+    bgGreenBright,
+    bgYellowBright,
+    bgBlueBright,
+    bgMagentaBright,
+    bgCyanBright,
+    bgWhiteBright
+  } = createColors();
+  exports.bgBlack = bgBlack;
+  exports.bgBlackBright = bgBlackBright;
+  exports.bgBlue = bgBlue;
+  exports.bgBlueBright = bgBlueBright;
+  exports.bgCyan = bgCyan;
+  exports.bgCyanBright = bgCyanBright;
+  exports.bgGreen = bgGreen;
+  exports.bgGreenBright = bgGreenBright;
+  exports.bgMagenta = bgMagenta;
+  exports.bgMagentaBright = bgMagentaBright;
+  exports.bgRed = bgRed;
+  exports.bgRedBright = bgRedBright;
+  exports.bgWhite = bgWhite;
+  exports.bgWhiteBright = bgWhiteBright;
+  exports.bgYellow = bgYellow;
+  exports.bgYellowBright = bgYellowBright;
+  exports.black = black;
+  exports.blackBright = blackBright;
+  exports.blue = blue;
+  exports.blueBright = blueBright;
+  exports.bold = bold;
+  exports.createColors = createColors;
+  exports.cyan = cyan;
+  exports.cyanBright = cyanBright;
+  exports.dim = dim;
+  exports.gray = gray;
+  exports.green = green;
+  exports.greenBright = greenBright;
+  exports.hidden = hidden;
+  exports.inverse = inverse;
+  exports.isColorSupported = isColorSupported;
+  exports.italic = italic;
+  exports.magenta = magenta;
+  exports.magentaBright = magentaBright;
+  exports.red = red;
+  exports.redBright = redBright;
+  exports.reset = reset3;
+  exports.strikethrough = strikethrough2;
+  exports.underline = underline;
+  exports.white = white;
+  exports.whiteBright = whiteBright;
+  exports.yellow = yellow;
+  exports.yellowBright = yellowBright;
+});
+
+// node_modules/end-of-stream/index.js
+var require_end_of_stream = __commonJS((exports, module) => {
+  var once2 = require_once();
+  var noop10 = function() {};
+  var qnt = global.Bare ? queueMicrotask : process.nextTick.bind(process);
+  var isRequest = function(stream3) {
+    return stream3.setHeader && typeof stream3.abort === "function";
+  };
+  var isChildProcess = function(stream3) {
+    return stream3.stdio && Array.isArray(stream3.stdio) && stream3.stdio.length === 3;
+  };
+  var eos = function(stream3, opts, callback2) {
+    if (typeof opts === "function")
+      return eos(stream3, null, opts);
+    if (!opts)
+      opts = {};
+    callback2 = once2(callback2 || noop10);
+    var ws3 = stream3._writableState;
+    var rs2 = stream3._readableState;
+    var readable = opts.readable || opts.readable !== false && stream3.readable;
+    var writable = opts.writable || opts.writable !== false && stream3.writable;
+    var cancelled = false;
+    var onlegacyfinish = function() {
+      if (!stream3.writable)
+        onfinish();
+    };
+    var onfinish = function() {
+      writable = false;
+      if (!readable)
+        callback2.call(stream3);
+    };
+    var onend = function() {
+      readable = false;
+      if (!writable)
+        callback2.call(stream3);
+    };
+    var onexit = function(exitCode) {
+      callback2.call(stream3, exitCode ? new Error("exited with error code: " + exitCode) : null);
+    };
+    var onerror = function(err) {
+      callback2.call(stream3, err);
+    };
+    var onclose = function() {
+      qnt(onclosenexttick);
+    };
+    var onclosenexttick = function() {
+      if (cancelled)
+        return;
+      if (readable && !(rs2 && (rs2.ended && !rs2.destroyed)))
+        return callback2.call(stream3, new Error("premature close"));
+      if (writable && !(ws3 && (ws3.ended && !ws3.destroyed)))
+        return callback2.call(stream3, new Error("premature close"));
+    };
+    var onrequest = function() {
+      stream3.req.on("finish", onfinish);
+    };
+    if (isRequest(stream3)) {
+      stream3.on("complete", onfinish);
+      stream3.on("abort", onclose);
+      if (stream3.req)
+        onrequest();
+      else
+        stream3.on("request", onrequest);
+    } else if (writable && !ws3) {
+      stream3.on("end", onlegacyfinish);
+      stream3.on("close", onlegacyfinish);
+    }
+    if (isChildProcess(stream3))
+      stream3.on("exit", onexit);
+    stream3.on("end", onend);
+    stream3.on("finish", onfinish);
+    if (opts.error !== false)
+      stream3.on("error", onerror);
+    stream3.on("close", onclose);
+    return function() {
+      cancelled = true;
+      stream3.removeListener("complete", onfinish);
+      stream3.removeListener("abort", onclose);
+      stream3.removeListener("request", onrequest);
+      if (stream3.req)
+        stream3.req.removeListener("finish", onfinish);
+      stream3.removeListener("end", onlegacyfinish);
+      stream3.removeListener("close", onlegacyfinish);
+      stream3.removeListener("finish", onfinish);
+      stream3.removeListener("exit", onexit);
+      stream3.removeListener("end", onend);
+      stream3.removeListener("error", onerror);
+      stream3.removeListener("close", onclose);
+    };
+  };
+  module.exports = eos;
+});
+
+// node_modules/pump/index.js
+var require_pump = __commonJS((exports, module) => {
+  var once2 = require_once();
+  var eos = require_end_of_stream();
+  var fs5;
+  try {
+    fs5 = __require("fs");
+  } catch (e3) {}
+  var noop10 = function() {};
+  var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
+  var isFn = function(fn4) {
+    return typeof fn4 === "function";
+  };
+  var isFS = function(stream3) {
+    if (!ancient)
+      return false;
+    if (!fs5)
+      return false;
+    return (stream3 instanceof (fs5.ReadStream || noop10) || stream3 instanceof (fs5.WriteStream || noop10)) && isFn(stream3.close);
+  };
+  var isRequest = function(stream3) {
+    return stream3.setHeader && isFn(stream3.abort);
+  };
+  var destroyer = function(stream3, reading, writing, callback2) {
+    callback2 = once2(callback2);
+    var closed = false;
+    stream3.on("close", function() {
+      closed = true;
+    });
+    eos(stream3, { readable: reading, writable: writing }, function(err) {
+      if (err)
+        return callback2(err);
+      closed = true;
+      callback2();
+    });
+    var destroyed = false;
+    return function(err) {
+      if (closed)
+        return;
+      if (destroyed)
+        return;
+      destroyed = true;
+      if (isFS(stream3))
+        return stream3.close(noop10);
+      if (isRequest(stream3))
+        return stream3.abort();
+      if (isFn(stream3.destroy))
+        return stream3.destroy();
+      callback2(err || new Error("stream was destroyed"));
+    };
+  };
+  var call = function(fn4) {
+    fn4();
+  };
+  var pipe3 = function(from, to3) {
+    return from.pipe(to3);
+  };
+  var pump = function() {
+    var streams = Array.prototype.slice.call(arguments);
+    var callback2 = isFn(streams[streams.length - 1] || noop10) && streams.pop() || noop10;
+    if (Array.isArray(streams[0]))
+      streams = streams[0];
+    if (streams.length < 2)
+      throw new Error("pump requires two streams per minimum");
+    var error48;
+    var destroys = streams.map(function(stream3, i2) {
+      var reading = i2 < streams.length - 1;
+      var writing = i2 > 0;
+      return destroyer(stream3, reading, writing, function(err) {
+        if (!error48)
+          error48 = err;
+        if (err)
+          destroys.forEach(call);
+        if (reading)
+          return;
+        destroys.forEach(call);
+        callback2(error48);
+      });
+    });
+    return streams.reduce(pipe3);
+  };
+  module.exports = pump;
+});
+
+// node_modules/pino-abstract-transport/index.js
+var require_pino_abstract_transport = __commonJS((exports, module) => {
+  var metadata = Symbol.for("pino.metadata");
+  var split2 = require_split2();
+  var { Duplex } = __require("stream");
+  var { parentPort, workerData } = __require("worker_threads");
+  function createDeferred2() {
+    let resolve2;
+    let reject;
+    const promise2 = new Promise((_resolve, _reject) => {
+      resolve2 = _resolve;
+      reject = _reject;
+    });
+    promise2.resolve = resolve2;
+    promise2.reject = reject;
+    return promise2;
+  }
+  module.exports = function build(fn4, opts = {}) {
+    const waitForConfig = opts.expectPinoConfig === true && workerData?.workerData?.pinoWillSendConfig === true;
+    const parseLines = opts.parse === "lines";
+    const parseLine = typeof opts.parseLine === "function" ? opts.parseLine : JSON.parse;
+    const close = opts.close || defaultClose;
+    const stream3 = split2(function(line4) {
+      let value2;
+      try {
+        value2 = parseLine(line4);
+      } catch (error48) {
+        this.emit("unknown", line4, error48);
+        return;
+      }
+      if (value2 === null) {
+        this.emit("unknown", line4, "Null value ignored");
+        return;
+      }
+      if (typeof value2 !== "object") {
+        value2 = {
+          data: value2,
+          time: Date.now()
+        };
+      }
+      if (stream3[metadata]) {
+        stream3.lastTime = value2.time;
+        stream3.lastLevel = value2.level;
+        stream3.lastObj = value2;
+      }
+      if (parseLines) {
+        return line4;
+      }
+      return value2;
+    }, { autoDestroy: true });
+    stream3._destroy = function(err, cb) {
+      const promise2 = close(err, cb);
+      if (promise2 && typeof promise2.then === "function") {
+        promise2.then(cb, cb);
+      }
+    };
+    if (opts.expectPinoConfig === true && workerData?.workerData?.pinoWillSendConfig !== true) {
+      setImmediate(() => {
+        stream3.emit("error", new Error("This transport is not compatible with the current version of pino. Please upgrade pino to the latest version."));
+      });
+    }
+    if (opts.metadata !== false) {
+      stream3[metadata] = true;
+      stream3.lastTime = 0;
+      stream3.lastLevel = 0;
+      stream3.lastObj = null;
+    }
+    if (waitForConfig) {
+      let pinoConfig = {};
+      const configReceived = createDeferred2();
+      parentPort.on("message", function handleMessage(message2) {
+        if (message2.code === "PINO_CONFIG") {
+          pinoConfig = message2.config;
+          configReceived.resolve();
+          parentPort.off("message", handleMessage);
+        }
+      });
+      Object.defineProperties(stream3, {
+        levels: {
+          get() {
+            return pinoConfig.levels;
+          }
+        },
+        messageKey: {
+          get() {
+            return pinoConfig.messageKey;
+          }
+        },
+        errorKey: {
+          get() {
+            return pinoConfig.errorKey;
+          }
+        }
+      });
+      return configReceived.then(finish);
+    }
+    return finish();
+    function finish() {
+      let res = fn4(stream3);
+      if (res && typeof res.catch === "function") {
+        res.catch((err) => {
+          stream3.destroy(err);
+        });
+        res = null;
+      } else if (opts.enablePipelining && res) {
+        return Duplex.from({ writable: stream3, readable: res });
+      }
+      return stream3;
+    }
+  };
+  function defaultClose(err, cb) {
+    process.nextTick(cb, err);
+  }
+});
+
+// node_modules/pino-pretty/lib/constants.js
+var require_constants7 = __commonJS((exports, module) => {
+  module.exports = {
+    DATE_FORMAT: "yyyy-mm-dd HH:MM:ss.l o",
+    DATE_FORMAT_SIMPLE: "HH:MM:ss.l",
+    ERROR_LIKE_KEYS: ["err", "error"],
+    MESSAGE_KEY: "msg",
+    LEVEL_KEY: "level",
+    LEVEL_LABEL: "levelLabel",
+    TIMESTAMP_KEY: "time",
+    LEVELS: {
+      default: "USERLVL",
+      60: "FATAL",
+      50: "ERROR",
+      40: "WARN",
+      30: "INFO",
+      20: "DEBUG",
+      10: "TRACE"
+    },
+    LEVEL_NAMES: {
+      fatal: 60,
+      error: 50,
+      warn: 40,
+      info: 30,
+      debug: 20,
+      trace: 10
+    },
+    LOGGER_KEYS: [
+      "pid",
+      "hostname",
+      "name",
+      "level",
+      "time",
+      "timestamp",
+      "caller"
+    ]
+  };
+});
+
+// node_modules/pino-pretty/lib/utils/get-level-label-data.js
+var require_get_level_label_data = __commonJS((exports, module) => {
+  module.exports = getLevelLabelData;
+  var { LEVELS, LEVEL_NAMES } = require_constants7();
+  function getLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames) {
+    const levels2 = useOnlyCustomProps ? customLevels || LEVELS : Object.assign({}, LEVELS, customLevels);
+    const levelNames = useOnlyCustomProps ? customLevelNames || LEVEL_NAMES : Object.assign({}, LEVEL_NAMES, customLevelNames);
+    return function(level) {
+      let levelNum = "default";
+      if (Number.isInteger(+level)) {
+        levelNum = Object.prototype.hasOwnProperty.call(levels2, level) ? level : levelNum;
+      } else {
+        levelNum = Object.prototype.hasOwnProperty.call(levelNames, level.toLowerCase()) ? levelNames[level.toLowerCase()] : levelNum;
+      }
+      return [levels2[levelNum], levelNum];
+    };
+  }
+});
+
+// node_modules/pino-pretty/lib/colors.js
+var require_colors = __commonJS((exports, module) => {
+  var nocolor = (input) => input;
+  var plain = {
+    default: nocolor,
+    60: nocolor,
+    50: nocolor,
+    40: nocolor,
+    30: nocolor,
+    20: nocolor,
+    10: nocolor,
+    message: nocolor,
+    greyMessage: nocolor,
+    property: nocolor
+  };
+  var { createColors } = require_colorette();
+  var getLevelLabelData = require_get_level_label_data();
+  var availableColors = createColors({ useColor: true });
+  var { white, bgRed, red, yellow, green, blue, gray, cyan, magenta } = availableColors;
+  var colored = {
+    default: white,
+    60: bgRed,
+    50: red,
+    40: yellow,
+    30: green,
+    20: blue,
+    10: gray,
+    message: cyan,
+    greyMessage: gray,
+    property: magenta
+  };
+  function resolveCustomColoredColorizer(customColors) {
+    return customColors.reduce(function(agg, [level, color2]) {
+      agg[level] = typeof availableColors[color2] === "function" ? availableColors[color2] : white;
+      return agg;
+    }, { default: white, message: cyan, greyMessage: gray, property: magenta });
+  }
+  function colorizeLevel(useOnlyCustomProps) {
+    return function(level, colorizer, { customLevels, customLevelNames } = {}) {
+      const [levelStr, levelNum] = getLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames)(level);
+      return Object.prototype.hasOwnProperty.call(colorizer, levelNum) ? colorizer[levelNum](levelStr) : colorizer.default(levelStr);
+    };
+  }
+  function plainColorizer(useOnlyCustomProps) {
+    const newPlainColorizer = colorizeLevel(useOnlyCustomProps);
+    const customColoredColorizer = function(level, opts) {
+      return newPlainColorizer(level, plain, opts);
+    };
+    customColoredColorizer.message = plain.message;
+    customColoredColorizer.greyMessage = plain.greyMessage;
+    customColoredColorizer.property = plain.property;
+    customColoredColorizer.colors = createColors({ useColor: false });
+    return customColoredColorizer;
+  }
+  function coloredColorizer(useOnlyCustomProps) {
+    const newColoredColorizer = colorizeLevel(useOnlyCustomProps);
+    const customColoredColorizer = function(level, opts) {
+      return newColoredColorizer(level, colored, opts);
+    };
+    customColoredColorizer.message = colored.message;
+    customColoredColorizer.property = colored.property;
+    customColoredColorizer.greyMessage = colored.greyMessage;
+    customColoredColorizer.colors = availableColors;
+    return customColoredColorizer;
+  }
+  function customColoredColorizerFactory(customColors, useOnlyCustomProps) {
+    const onlyCustomColored = resolveCustomColoredColorizer(customColors);
+    const customColored = useOnlyCustomProps ? onlyCustomColored : Object.assign({}, colored, onlyCustomColored);
+    const colorizeLevelCustom = colorizeLevel(useOnlyCustomProps);
+    const customColoredColorizer = function(level, opts) {
+      return colorizeLevelCustom(level, customColored, opts);
+    };
+    customColoredColorizer.colors = availableColors;
+    customColoredColorizer.message = customColoredColorizer.message || customColored.message;
+    customColoredColorizer.property = customColoredColorizer.property || customColored.property;
+    customColoredColorizer.greyMessage = customColoredColorizer.greyMessage || customColored.greyMessage;
+    return customColoredColorizer;
+  }
+  module.exports = function getColorizer(useColors = false, customColors, useOnlyCustomProps) {
+    if (useColors && customColors !== undefined) {
+      return customColoredColorizerFactory(customColors, useOnlyCustomProps);
+    } else if (useColors) {
+      return coloredColorizer(useOnlyCustomProps);
+    }
+    return plainColorizer(useOnlyCustomProps);
+  };
+});
+
+// node_modules/pino-pretty/lib/utils/noop.js
+var require_noop = __commonJS((exports, module) => {
+  module.exports = function noop() {};
+});
+
+// node_modules/pino-pretty/lib/utils/build-safe-sonic-boom.js
+var require_build_safe_sonic_boom = __commonJS((exports, module) => {
+  module.exports = buildSafeSonicBoom;
+  var { isMainThread } = __require("node:worker_threads");
+  var SonicBoom = require_sonic_boom();
+  var noop10 = require_noop();
+  function buildSafeSonicBoom(opts) {
+    const stream3 = new SonicBoom(opts);
+    stream3.on("error", filterBrokenPipe);
+    if (!opts.sync && isMainThread) {
+      setupOnExit(stream3);
+    }
+    return stream3;
+    function filterBrokenPipe(err) {
+      if (err.code === "EPIPE") {
+        stream3.write = noop10;
+        stream3.end = noop10;
+        stream3.flushSync = noop10;
+        stream3.destroy = noop10;
+        return;
+      }
+      stream3.removeListener("error", filterBrokenPipe);
+    }
+  }
+  function setupOnExit(stream3) {
+    if (global.WeakRef && global.WeakMap && global.FinalizationRegistry) {
+      const onExit = require_on_exit_leak_free();
+      onExit.register(stream3, autoEnd);
+      stream3.on("close", function() {
+        onExit.unregister(stream3);
+      });
+    }
+  }
+  function autoEnd(stream3, eventName) {
+    if (stream3.destroyed) {
+      return;
+    }
+    if (eventName === "beforeExit") {
+      stream3.flush();
+      stream3.on("drain", function() {
+        stream3.end();
+      });
+    } else {
+      stream3.flushSync();
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/is-valid-date.js
+var require_is_valid_date = __commonJS((exports, module) => {
+  module.exports = isValidDate2;
+  function isValidDate2(date6) {
+    return date6 instanceof Date && !Number.isNaN(date6.getTime());
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/create-date.js
+var require_create_date = __commonJS((exports, module) => {
+  module.exports = createDate;
+  var isValidDate2 = require_is_valid_date();
+  function createDate(epoch) {
+    let date6 = new Date(epoch);
+    if (isValidDate2(date6)) {
+      return date6;
+    }
+    date6 = new Date(+epoch);
+    return date6;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/split-property-key.js
+var require_split_property_key = __commonJS((exports, module) => {
+  module.exports = splitPropertyKey;
+  function splitPropertyKey(key2) {
+    const result = [];
+    let backslash = false;
+    let segment = "";
+    for (let i2 = 0;i2 < key2.length; i2++) {
+      const c3 = key2.charAt(i2);
+      if (c3 === "\\") {
+        backslash = true;
+        continue;
+      }
+      if (backslash) {
+        backslash = false;
+        segment += c3;
+        continue;
+      }
+      if (c3 === ".") {
+        result.push(segment);
+        segment = "";
+        continue;
+      }
+      segment += c3;
+    }
+    if (segment.length) {
+      result.push(segment);
+    }
+    return result;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/get-property-value.js
+var require_get_property_value = __commonJS((exports, module) => {
+  module.exports = getPropertyValue;
+  var splitPropertyKey = require_split_property_key();
+  function getPropertyValue(obj, property) {
+    const props = Array.isArray(property) ? property : splitPropertyKey(property);
+    for (const prop of props) {
+      if (!Object.prototype.hasOwnProperty.call(obj, prop)) {
+        return;
+      }
+      obj = obj[prop];
+    }
+    return obj;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/delete-log-property.js
+var require_delete_log_property = __commonJS((exports, module) => {
+  module.exports = deleteLogProperty;
+  var getPropertyValue = require_get_property_value();
+  var splitPropertyKey = require_split_property_key();
+  function deleteLogProperty(log4, property) {
+    const props = splitPropertyKey(property);
+    const propToDelete = props.pop();
+    log4 = getPropertyValue(log4, props);
+    if (log4 !== null && typeof log4 === "object" && Object.prototype.hasOwnProperty.call(log4, propToDelete)) {
+      delete log4[propToDelete];
+    }
+  }
+});
+
+// node_modules/fast-copy/dist/cjs/index.cjs
+var require_cjs9 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  var toStringFunction = Function.prototype.toString;
+  var create2 = Object.create;
+  var toStringObject = Object.prototype.toString;
+  var LegacyCache = function() {
+    function LegacyCache2() {
+      this._keys = [];
+      this._values = [];
+    }
+    LegacyCache2.prototype.has = function(key2) {
+      return !!~this._keys.indexOf(key2);
+    };
+    LegacyCache2.prototype.get = function(key2) {
+      return this._values[this._keys.indexOf(key2)];
+    };
+    LegacyCache2.prototype.set = function(key2, value2) {
+      this._keys.push(key2);
+      this._values.push(value2);
+    };
+    return LegacyCache2;
+  }();
+  function createCacheLegacy() {
+    return new LegacyCache;
+  }
+  function createCacheModern() {
+    return new WeakMap;
+  }
+  var createCache = typeof WeakMap !== "undefined" ? createCacheModern : createCacheLegacy;
+  function getCleanClone(prototype) {
+    if (!prototype) {
+      return create2(null);
+    }
+    var Constructor = prototype.constructor;
+    if (Constructor === Object) {
+      return prototype === Object.prototype ? {} : create2(prototype);
+    }
+    if (Constructor && ~toStringFunction.call(Constructor).indexOf("[native code]")) {
+      try {
+        return new Constructor;
+      } catch (_a4) {}
+    }
+    return create2(prototype);
+  }
+  function getRegExpFlagsLegacy(regExp) {
+    var flags = "";
+    if (regExp.global) {
+      flags += "g";
+    }
+    if (regExp.ignoreCase) {
+      flags += "i";
+    }
+    if (regExp.multiline) {
+      flags += "m";
+    }
+    if (regExp.unicode) {
+      flags += "u";
+    }
+    if (regExp.sticky) {
+      flags += "y";
+    }
+    return flags;
+  }
+  function getRegExpFlagsModern(regExp) {
+    return regExp.flags;
+  }
+  var getRegExpFlags = /test/g.flags === "g" ? getRegExpFlagsModern : getRegExpFlagsLegacy;
+  function getTagLegacy(value2) {
+    var type2 = toStringObject.call(value2);
+    return type2.substring(8, type2.length - 1);
+  }
+  function getTagModern(value2) {
+    return value2[Symbol.toStringTag] || getTagLegacy(value2);
+  }
+  var getTag3 = typeof Symbol !== "undefined" ? getTagModern : getTagLegacy;
+  var defineProperty = Object.defineProperty;
+  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  var getOwnPropertyNames = Object.getOwnPropertyNames;
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var _a3 = Object.prototype;
+  var hasOwnProperty5 = _a3.hasOwnProperty;
+  var propertyIsEnumerable = _a3.propertyIsEnumerable;
+  var SUPPORTS_SYMBOL = typeof getOwnPropertySymbols === "function";
+  function getStrictPropertiesModern(object2) {
+    return getOwnPropertyNames(object2).concat(getOwnPropertySymbols(object2));
+  }
+  var getStrictProperties = SUPPORTS_SYMBOL ? getStrictPropertiesModern : getOwnPropertyNames;
+  function copyOwnPropertiesStrict(value2, clone3, state) {
+    var properties = getStrictProperties(value2);
+    for (var index4 = 0, length_1 = properties.length, property = undefined, descriptor = undefined;index4 < length_1; ++index4) {
+      property = properties[index4];
+      if (property === "callee" || property === "caller") {
+        continue;
+      }
+      descriptor = getOwnPropertyDescriptor(value2, property);
+      if (!descriptor) {
+        clone3[property] = state.copier(value2[property], state);
+        continue;
+      }
+      if (!descriptor.get && !descriptor.set) {
+        descriptor.value = state.copier(descriptor.value, state);
+      }
+      try {
+        defineProperty(clone3, property, descriptor);
+      } catch (error48) {
+        clone3[property] = descriptor.value;
+      }
+    }
+    return clone3;
+  }
+  function copyArrayLoose(array3, state) {
+    var clone3 = new state.Constructor;
+    state.cache.set(array3, clone3);
+    for (var index4 = 0, length_2 = array3.length;index4 < length_2; ++index4) {
+      clone3[index4] = state.copier(array3[index4], state);
+    }
+    return clone3;
+  }
+  function copyArrayStrict(array3, state) {
+    var clone3 = new state.Constructor;
+    state.cache.set(array3, clone3);
+    return copyOwnPropertiesStrict(array3, clone3, state);
+  }
+  function copyArrayBuffer(arrayBuffer, _state) {
+    return arrayBuffer.slice(0);
+  }
+  function copyBlob(blob, _state) {
+    return blob.slice(0, blob.size, blob.type);
+  }
+  function copyDataView(dataView, state) {
+    return new state.Constructor(copyArrayBuffer(dataView.buffer));
+  }
+  function copyDate(date6, state) {
+    return new state.Constructor(date6.getTime());
+  }
+  function copyMapLoose(map6, state) {
+    var clone3 = new state.Constructor;
+    state.cache.set(map6, clone3);
+    map6.forEach(function(value2, key2) {
+      clone3.set(key2, state.copier(value2, state));
+    });
+    return clone3;
+  }
+  function copyMapStrict(map6, state) {
+    return copyOwnPropertiesStrict(map6, copyMapLoose(map6, state), state);
+  }
+  function copyObjectLooseLegacy(object2, state) {
+    var clone3 = getCleanClone(state.prototype);
+    state.cache.set(object2, clone3);
+    for (var key2 in object2) {
+      if (hasOwnProperty5.call(object2, key2)) {
+        clone3[key2] = state.copier(object2[key2], state);
+      }
+    }
+    return clone3;
+  }
+  function copyObjectLooseModern(object2, state) {
+    var clone3 = getCleanClone(state.prototype);
+    state.cache.set(object2, clone3);
+    for (var key2 in object2) {
+      if (hasOwnProperty5.call(object2, key2)) {
+        clone3[key2] = state.copier(object2[key2], state);
+      }
+    }
+    var symbols = getOwnPropertySymbols(object2);
+    for (var index4 = 0, length_3 = symbols.length, symbol2 = undefined;index4 < length_3; ++index4) {
+      symbol2 = symbols[index4];
+      if (propertyIsEnumerable.call(object2, symbol2)) {
+        clone3[symbol2] = state.copier(object2[symbol2], state);
+      }
+    }
+    return clone3;
+  }
+  var copyObjectLoose = SUPPORTS_SYMBOL ? copyObjectLooseModern : copyObjectLooseLegacy;
+  function copyObjectStrict(object2, state) {
+    var clone3 = getCleanClone(state.prototype);
+    state.cache.set(object2, clone3);
+    return copyOwnPropertiesStrict(object2, clone3, state);
+  }
+  function copyPrimitiveWrapper(primitiveObject, state) {
+    return new state.Constructor(primitiveObject.valueOf());
+  }
+  function copyRegExp(regExp, state) {
+    var clone3 = new state.Constructor(regExp.source, getRegExpFlags(regExp));
+    clone3.lastIndex = regExp.lastIndex;
+    return clone3;
+  }
+  function copySelf(value2, _state) {
+    return value2;
+  }
+  function copySetLoose(set4, state) {
+    var clone3 = new state.Constructor;
+    state.cache.set(set4, clone3);
+    set4.forEach(function(value2) {
+      clone3.add(state.copier(value2, state));
+    });
+    return clone3;
+  }
+  function copySetStrict(set4, state) {
+    return copyOwnPropertiesStrict(set4, copySetLoose(set4, state), state);
+  }
+  var isArray3 = Array.isArray;
+  var assign4 = Object.assign;
+  var getPrototypeOf = Object.getPrototypeOf || function(obj) {
+    return obj.__proto__;
+  };
+  var DEFAULT_LOOSE_OPTIONS = {
+    array: copyArrayLoose,
+    arrayBuffer: copyArrayBuffer,
+    blob: copyBlob,
+    dataView: copyDataView,
+    date: copyDate,
+    error: copySelf,
+    map: copyMapLoose,
+    object: copyObjectLoose,
+    regExp: copyRegExp,
+    set: copySetLoose
+  };
+  var DEFAULT_STRICT_OPTIONS = assign4({}, DEFAULT_LOOSE_OPTIONS, {
+    array: copyArrayStrict,
+    map: copyMapStrict,
+    object: copyObjectStrict,
+    set: copySetStrict
+  });
+  function getTagSpecificCopiers(options) {
+    return {
+      Arguments: options.object,
+      Array: options.array,
+      ArrayBuffer: options.arrayBuffer,
+      Blob: options.blob,
+      Boolean: copyPrimitiveWrapper,
+      DataView: options.dataView,
+      Date: options.date,
+      Error: options.error,
+      Float32Array: options.arrayBuffer,
+      Float64Array: options.arrayBuffer,
+      Int8Array: options.arrayBuffer,
+      Int16Array: options.arrayBuffer,
+      Int32Array: options.arrayBuffer,
+      Map: options.map,
+      Number: copyPrimitiveWrapper,
+      Object: options.object,
+      Promise: copySelf,
+      RegExp: options.regExp,
+      Set: options.set,
+      String: copyPrimitiveWrapper,
+      WeakMap: copySelf,
+      WeakSet: copySelf,
+      Uint8Array: options.arrayBuffer,
+      Uint8ClampedArray: options.arrayBuffer,
+      Uint16Array: options.arrayBuffer,
+      Uint32Array: options.arrayBuffer,
+      Uint64Array: options.arrayBuffer
+    };
+  }
+  function createCopier(options) {
+    var normalizedOptions = assign4({}, DEFAULT_LOOSE_OPTIONS, options);
+    var tagSpecificCopiers = getTagSpecificCopiers(normalizedOptions);
+    var { Array: array3, Object: object2 } = tagSpecificCopiers;
+    function copier(value2, state) {
+      state.prototype = state.Constructor = undefined;
+      if (!value2 || typeof value2 !== "object") {
+        return value2;
+      }
+      if (state.cache.has(value2)) {
+        return state.cache.get(value2);
+      }
+      state.prototype = getPrototypeOf(value2);
+      state.Constructor = state.prototype && state.prototype.constructor;
+      if (!state.Constructor || state.Constructor === Object) {
+        return object2(value2, state);
+      }
+      if (isArray3(value2)) {
+        return array3(value2, state);
+      }
+      var tagSpecificCopier = tagSpecificCopiers[getTag3(value2)];
+      if (tagSpecificCopier) {
+        return tagSpecificCopier(value2, state);
+      }
+      return typeof value2.then === "function" ? value2 : object2(value2, state);
+    }
+    return function copy(value2) {
+      return copier(value2, {
+        Constructor: undefined,
+        cache: createCache(),
+        copier,
+        prototype: undefined
+      });
+    };
+  }
+  function createStrictCopier(options) {
+    return createCopier(assign4({}, DEFAULT_STRICT_OPTIONS, options));
+  }
+  var copyStrict = createStrictCopier({});
+  var index3 = createCopier({});
+  exports.copyStrict = copyStrict;
+  exports.createCopier = createCopier;
+  exports.createStrictCopier = createStrictCopier;
+  exports.default = index3;
+});
+
+// node_modules/pino-pretty/lib/utils/filter-log.js
+var require_filter_log = __commonJS((exports, module) => {
+  module.exports = filterLog;
+  var { createCopier } = require_cjs9();
+  var fastCopy = createCopier({});
+  var deleteLogProperty = require_delete_log_property();
+  function filterLog({ log: log4, context }) {
+    const { ignoreKeys, includeKeys } = context;
+    const logCopy = fastCopy(log4);
+    if (includeKeys) {
+      const logIncluded = {};
+      includeKeys.forEach((key2) => {
+        logIncluded[key2] = logCopy[key2];
+      });
+      return logIncluded;
+    }
+    ignoreKeys.forEach((ignoreKey) => {
+      deleteLogProperty(logCopy, ignoreKey);
+    });
+    return logCopy;
+  }
+});
+
+// node_modules/dateformat/lib/dateformat.js
+var require_dateformat = __commonJS((exports, module) => {
+  function _typeof4(obj) {
+    "@babel/helpers - typeof";
+    if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+      _typeof4 = function _typeof(obj2) {
+        return typeof obj2;
+      };
+    } else {
+      _typeof4 = function _typeof(obj2) {
+        return obj2 && typeof Symbol === "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+      };
+    }
+    return _typeof4(obj);
+  }
+  (function(global2) {
+    var _arguments = arguments;
+    var dateFormat = function() {
+      var token3 = /d{1,4}|D{3,4}|m{1,4}|yy(?:yy)?|([HhMsTt])\1?|W{1,2}|[LlopSZN]|"[^"]*"|'[^']*'/g;
+      var timezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g;
+      var timezoneClip = /[^-+\dA-Z]/g;
+      return function(date6, mask, utc, gmt) {
+        if (_arguments.length === 1 && kindOf(date6) === "string" && !/\d/.test(date6)) {
+          mask = date6;
+          date6 = undefined;
+        }
+        date6 = date6 || date6 === 0 ? date6 : new Date;
+        if (!(date6 instanceof Date)) {
+          date6 = new Date(date6);
+        }
+        if (isNaN(date6)) {
+          throw TypeError("Invalid date");
+        }
+        mask = String(dateFormat.masks[mask] || mask || dateFormat.masks["default"]);
+        var maskSlice = mask.slice(0, 4);
+        if (maskSlice === "UTC:" || maskSlice === "GMT:") {
+          mask = mask.slice(4);
+          utc = true;
+          if (maskSlice === "GMT:") {
+            gmt = true;
+          }
+        }
+        var _5 = function _() {
+          return utc ? "getUTC" : "get";
+        };
+        var _d = function d() {
+          return date6[_5() + "Date"]();
+        };
+        var D2 = function D() {
+          return date6[_5() + "Day"]();
+        };
+        var _m = function m() {
+          return date6[_5() + "Month"]();
+        };
+        var y5 = function y() {
+          return date6[_5() + "FullYear"]();
+        };
+        var _H = function H() {
+          return date6[_5() + "Hours"]();
+        };
+        var _M = function M() {
+          return date6[_5() + "Minutes"]();
+        };
+        var _s2 = function s() {
+          return date6[_5() + "Seconds"]();
+        };
+        var _L = function L() {
+          return date6[_5() + "Milliseconds"]();
+        };
+        var _o2 = function o() {
+          return utc ? 0 : date6.getTimezoneOffset();
+        };
+        var _W = function W() {
+          return getWeek(date6);
+        };
+        var _N = function N() {
+          return getDayOfWeek(date6);
+        };
+        var flags = { d: function d() {
+          return _d();
+        }, dd: function dd() {
+          return pad(_d());
+        }, ddd: function ddd() {
+          return dateFormat.i18n.dayNames[D2()];
+        }, DDD: function DDD() {
+          return getDayName({ y: y5(), m: _m(), d: _d(), _: _5(), dayName: dateFormat.i18n.dayNames[D2()], short: true });
+        }, dddd: function dddd() {
+          return dateFormat.i18n.dayNames[D2() + 7];
+        }, DDDD: function DDDD() {
+          return getDayName({ y: y5(), m: _m(), d: _d(), _: _5(), dayName: dateFormat.i18n.dayNames[D2() + 7] });
+        }, m: function m() {
+          return _m() + 1;
+        }, mm: function mm() {
+          return pad(_m() + 1);
+        }, mmm: function mmm() {
+          return dateFormat.i18n.monthNames[_m()];
+        }, mmmm: function mmmm() {
+          return dateFormat.i18n.monthNames[_m() + 12];
+        }, yy: function yy() {
+          return String(y5()).slice(2);
+        }, yyyy: function yyyy() {
+          return pad(y5(), 4);
+        }, h: function h() {
+          return _H() % 12 || 12;
+        }, hh: function hh() {
+          return pad(_H() % 12 || 12);
+        }, H: function H() {
+          return _H();
+        }, HH: function HH() {
+          return pad(_H());
+        }, M: function M() {
+          return _M();
+        }, MM: function MM() {
+          return pad(_M());
+        }, s: function s() {
+          return _s2();
+        }, ss: function ss() {
+          return pad(_s2());
+        }, l: function l() {
+          return pad(_L(), 3);
+        }, L: function L() {
+          return pad(Math.floor(_L() / 10));
+        }, t: function t() {
+          return _H() < 12 ? dateFormat.i18n.timeNames[0] : dateFormat.i18n.timeNames[1];
+        }, tt: function tt() {
+          return _H() < 12 ? dateFormat.i18n.timeNames[2] : dateFormat.i18n.timeNames[3];
+        }, T: function T() {
+          return _H() < 12 ? dateFormat.i18n.timeNames[4] : dateFormat.i18n.timeNames[5];
+        }, TT: function TT() {
+          return _H() < 12 ? dateFormat.i18n.timeNames[6] : dateFormat.i18n.timeNames[7];
+        }, Z: function Z() {
+          return gmt ? "GMT" : utc ? "UTC" : (String(date6).match(timezone) || [""]).pop().replace(timezoneClip, "").replace(/GMT\+0000/g, "UTC");
+        }, o: function o() {
+          return (_o2() > 0 ? "-" : "+") + pad(Math.floor(Math.abs(_o2()) / 60) * 100 + Math.abs(_o2()) % 60, 4);
+        }, p: function p() {
+          return (_o2() > 0 ? "-" : "+") + pad(Math.floor(Math.abs(_o2()) / 60), 2) + ":" + pad(Math.floor(Math.abs(_o2()) % 60), 2);
+        }, S: function S() {
+          return ["th", "st", "nd", "rd"][_d() % 10 > 3 ? 0 : (_d() % 100 - _d() % 10 != 10) * _d() % 10];
+        }, W: function W() {
+          return _W();
+        }, WW: function WW() {
+          return pad(_W());
+        }, N: function N() {
+          return _N();
+        } };
+        return mask.replace(token3, function(match) {
+          if (match in flags) {
+            return flags[match]();
+          }
+          return match.slice(1, match.length - 1);
+        });
+      };
+    }();
+    dateFormat.masks = { default: "ddd mmm dd yyyy HH:MM:ss", shortDate: "m/d/yy", paddedShortDate: "mm/dd/yyyy", mediumDate: "mmm d, yyyy", longDate: "mmmm d, yyyy", fullDate: "dddd, mmmm d, yyyy", shortTime: "h:MM TT", mediumTime: "h:MM:ss TT", longTime: "h:MM:ss TT Z", isoDate: "yyyy-mm-dd", isoTime: "HH:MM:ss", isoDateTime: "yyyy-mm-dd'T'HH:MM:sso", isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'", expiresHeaderFormat: "ddd, dd mmm yyyy HH:MM:ss Z" };
+    dateFormat.i18n = { dayNames: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], monthNames: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec", "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], timeNames: ["a", "p", "am", "pm", "A", "P", "AM", "PM"] };
+    var pad = function pad(val, len) {
+      val = String(val);
+      len = len || 2;
+      while (val.length < len) {
+        val = "0" + val;
+      }
+      return val;
+    };
+    var getDayName = function getDayName(_ref) {
+      var { y: y5, m: m3, d: d5, _: _5, dayName } = _ref, _ref$short = _ref["short"], _short = _ref$short === undefined ? false : _ref$short;
+      var today = new Date;
+      var yesterday = new Date;
+      yesterday.setDate(yesterday[_5 + "Date"]() - 1);
+      var tomorrow = new Date;
+      tomorrow.setDate(tomorrow[_5 + "Date"]() + 1);
+      var today_d = function today_d() {
+        return today[_5 + "Date"]();
+      };
+      var today_m = function today_m() {
+        return today[_5 + "Month"]();
+      };
+      var today_y = function today_y() {
+        return today[_5 + "FullYear"]();
+      };
+      var yesterday_d = function yesterday_d() {
+        return yesterday[_5 + "Date"]();
+      };
+      var yesterday_m = function yesterday_m() {
+        return yesterday[_5 + "Month"]();
+      };
+      var yesterday_y = function yesterday_y() {
+        return yesterday[_5 + "FullYear"]();
+      };
+      var tomorrow_d = function tomorrow_d() {
+        return tomorrow[_5 + "Date"]();
+      };
+      var tomorrow_m = function tomorrow_m() {
+        return tomorrow[_5 + "Month"]();
+      };
+      var tomorrow_y = function tomorrow_y() {
+        return tomorrow[_5 + "FullYear"]();
+      };
+      if (today_y() === y5 && today_m() === m3 && today_d() === d5) {
+        return _short ? "Tdy" : "Today";
+      } else if (yesterday_y() === y5 && yesterday_m() === m3 && yesterday_d() === d5) {
+        return _short ? "Ysd" : "Yesterday";
+      } else if (tomorrow_y() === y5 && tomorrow_m() === m3 && tomorrow_d() === d5) {
+        return _short ? "Tmw" : "Tomorrow";
+      }
+      return dayName;
+    };
+    var getWeek = function getWeek(date6) {
+      var targetThursday = new Date(date6.getFullYear(), date6.getMonth(), date6.getDate());
+      targetThursday.setDate(targetThursday.getDate() - (targetThursday.getDay() + 6) % 7 + 3);
+      var firstThursday = new Date(targetThursday.getFullYear(), 0, 4);
+      firstThursday.setDate(firstThursday.getDate() - (firstThursday.getDay() + 6) % 7 + 3);
+      var ds2 = targetThursday.getTimezoneOffset() - firstThursday.getTimezoneOffset();
+      targetThursday.setHours(targetThursday.getHours() - ds2);
+      var weekDiff = (targetThursday - firstThursday) / (86400000 * 7);
+      return 1 + Math.floor(weekDiff);
+    };
+    var getDayOfWeek = function getDayOfWeek(date6) {
+      var dow = date6.getDay();
+      if (dow === 0) {
+        dow = 7;
+      }
+      return dow;
+    };
+    var kindOf = function kindOf(val) {
+      if (val === null) {
+        return "null";
+      }
+      if (val === undefined) {
+        return "undefined";
+      }
+      if (_typeof4(val) !== "object") {
+        return _typeof4(val);
+      }
+      if (Array.isArray(val)) {
+        return "array";
+      }
+      return {}.toString.call(val).slice(8, -1).toLowerCase();
+    };
+    if (typeof define === "function" && define.amd) {
+      define(function() {
+        return dateFormat;
+      });
+    } else if ((typeof exports === "undefined" ? "undefined" : _typeof4(exports)) === "object") {
+      module.exports = dateFormat;
+    } else {
+      global2.dateFormat = dateFormat;
+    }
+  })(undefined);
+});
+
+// node_modules/pino-pretty/lib/utils/format-time.js
+var require_format_time = __commonJS((exports, module) => {
+  module.exports = formatTime;
+  var {
+    DATE_FORMAT,
+    DATE_FORMAT_SIMPLE
+  } = require_constants7();
+  var dateformat = require_dateformat();
+  var createDate = require_create_date();
+  var isValidDate2 = require_is_valid_date();
+  function formatTime(epoch, translateTime = false) {
+    if (translateTime === false) {
+      return epoch;
+    }
+    const instant = createDate(epoch);
+    if (!isValidDate2(instant)) {
+      return epoch;
+    }
+    if (translateTime === true) {
+      return dateformat(instant, DATE_FORMAT_SIMPLE);
+    }
+    const upperFormat = translateTime.toUpperCase();
+    if (upperFormat === "SYS:STANDARD") {
+      return dateformat(instant, DATE_FORMAT);
+    }
+    const prefix3 = upperFormat.substr(0, 4);
+    if (prefix3 === "SYS:" || prefix3 === "UTC:") {
+      if (prefix3 === "UTC:") {
+        return dateformat(instant, translateTime);
+      }
+      return dateformat(instant, translateTime.slice(4));
+    }
+    return dateformat(instant, `UTC:${translateTime}`);
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/handle-custom-levels-names-opts.js
+var require_handle_custom_levels_names_opts = __commonJS((exports, module) => {
+  module.exports = handleCustomLevelsNamesOpts;
+  function handleCustomLevelsNamesOpts(cLevels) {
+    if (!cLevels)
+      return {};
+    if (typeof cLevels === "string") {
+      return cLevels.split(",").reduce((agg, value2, idx) => {
+        const [levelName, levelNum = idx] = value2.split(":");
+        agg[levelName.toLowerCase()] = levelNum;
+        return agg;
+      }, {});
+    } else if (Object.prototype.toString.call(cLevels) === "[object Object]") {
+      return Object.keys(cLevels).reduce((agg, levelName) => {
+        agg[levelName.toLowerCase()] = cLevels[levelName];
+        return agg;
+      }, {});
+    } else {
+      return {};
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/handle-custom-levels-opts.js
+var require_handle_custom_levels_opts = __commonJS((exports, module) => {
+  module.exports = handleCustomLevelsOpts;
+  function handleCustomLevelsOpts(cLevels) {
+    if (!cLevels)
+      return {};
+    if (typeof cLevels === "string") {
+      return cLevels.split(",").reduce((agg, value2, idx) => {
+        const [levelName, levelNum = idx] = value2.split(":");
+        agg[levelNum] = levelName.toUpperCase();
+        return agg;
+      }, { default: "USERLVL" });
+    } else if (Object.prototype.toString.call(cLevels) === "[object Object]") {
+      return Object.keys(cLevels).reduce((agg, levelName) => {
+        agg[cLevels[levelName]] = levelName.toUpperCase();
+        return agg;
+      }, { default: "USERLVL" });
+    } else {
+      return {};
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/interpret-conditionals.js
+var require_interpret_conditionals = __commonJS((exports, module) => {
+  module.exports = interpretConditionals;
+  var getPropertyValue = require_get_property_value();
+  function interpretConditionals(messageFormat, log4) {
+    messageFormat = messageFormat.replace(/{if (.*?)}(.*?){end}/g, replacer);
+    messageFormat = messageFormat.replace(/{if (.*?)}/g, "");
+    messageFormat = messageFormat.replace(/{end}/g, "");
+    return messageFormat.replace(/\s+/g, " ").trim();
+    function replacer(_5, key2, value2) {
+      const propertyValue = getPropertyValue(log4, key2);
+      if (propertyValue && value2.includes(key2)) {
+        return value2.replace(new RegExp("{" + key2 + "}", "g"), propertyValue);
+      } else {
+        return "";
+      }
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/is-object.js
+var require_is_object = __commonJS((exports, module) => {
+  module.exports = isObject7;
+  function isObject7(input) {
+    return Object.prototype.toString.apply(input) === "[object Object]";
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/join-lines-with-indentation.js
+var require_join_lines_with_indentation = __commonJS((exports, module) => {
+  module.exports = joinLinesWithIndentation;
+  function joinLinesWithIndentation({ input, ident: ident2 = "    ", eol = `
+` }) {
+    const lines = input.split(/\r?\n/);
+    for (let i2 = 1;i2 < lines.length; i2 += 1) {
+      lines[i2] = ident2 + lines[i2];
+    }
+    return lines.join(eol);
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/parse-factory-options.js
+var require_parse_factory_options = __commonJS((exports, module) => {
+  module.exports = parseFactoryOptions;
+  var {
+    LEVEL_NAMES
+  } = require_constants7();
+  var colors9 = require_colors();
+  var handleCustomLevelsOpts = require_handle_custom_levels_opts();
+  var handleCustomLevelsNamesOpts = require_handle_custom_levels_names_opts();
+  var handleLevelLabelData = require_get_level_label_data();
+  function parseFactoryOptions(options) {
+    const EOL = options.crlf ? `\r
+` : `
+`;
+    const IDENT = "    ";
+    const {
+      customPrettifiers,
+      errorLikeObjectKeys,
+      hideObject,
+      levelFirst,
+      levelKey,
+      levelLabel,
+      messageFormat,
+      messageKey,
+      minimumLevel,
+      singleLine,
+      timestampKey,
+      translateTime
+    } = options;
+    const errorProps = options.errorProps.split(",");
+    const useOnlyCustomProps = typeof options.useOnlyCustomProps === "boolean" ? options.useOnlyCustomProps : options.useOnlyCustomProps === "true";
+    const customLevels = handleCustomLevelsOpts(options.customLevels);
+    const customLevelNames = handleCustomLevelsNamesOpts(options.customLevels);
+    const getLevelLabelData = handleLevelLabelData(useOnlyCustomProps, customLevels, customLevelNames);
+    let customColors;
+    if (options.customColors) {
+      if (typeof options.customColors === "string") {
+        customColors = options.customColors.split(",").reduce((agg, value2) => {
+          const [level, color2] = value2.split(":");
+          const condition = useOnlyCustomProps ? options.customLevels : customLevelNames[level] !== undefined;
+          const levelNum = condition ? customLevelNames[level] : LEVEL_NAMES[level];
+          const colorIdx = levelNum !== undefined ? levelNum : level;
+          agg.push([colorIdx, color2]);
+          return agg;
+        }, []);
+      } else if (typeof options.customColors === "object") {
+        customColors = Object.keys(options.customColors).reduce((agg, value2) => {
+          const [level, color2] = [value2, options.customColors[value2]];
+          const condition = useOnlyCustomProps ? options.customLevels : customLevelNames[level] !== undefined;
+          const levelNum = condition ? customLevelNames[level] : LEVEL_NAMES[level];
+          const colorIdx = levelNum !== undefined ? levelNum : level;
+          agg.push([colorIdx, color2]);
+          return agg;
+        }, []);
+      } else {
+        throw new Error("options.customColors must be of type string or object.");
+      }
+    }
+    const customProperties = { customLevels, customLevelNames };
+    if (useOnlyCustomProps === true && !options.customLevels) {
+      customProperties.customLevels = undefined;
+      customProperties.customLevelNames = undefined;
+    }
+    const includeKeys = options.include !== undefined ? new Set(options.include.split(",")) : undefined;
+    const ignoreKeys = !includeKeys && options.ignore ? new Set(options.ignore.split(",")) : undefined;
+    const colorizer = colors9(options.colorize, customColors, useOnlyCustomProps);
+    const objectColorizer = options.colorizeObjects ? colorizer : colors9(false, [], false);
+    return {
+      EOL,
+      IDENT,
+      colorizer,
+      customColors,
+      customLevelNames,
+      customLevels,
+      customPrettifiers,
+      customProperties,
+      errorLikeObjectKeys,
+      errorProps,
+      getLevelLabelData,
+      hideObject,
+      ignoreKeys,
+      includeKeys,
+      levelFirst,
+      levelKey,
+      levelLabel,
+      messageFormat,
+      messageKey,
+      minimumLevel,
+      objectColorizer,
+      singleLine,
+      timestampKey,
+      translateTime,
+      useOnlyCustomProps
+    };
+  }
+});
+
+// node_modules/fast-safe-stringify/index.js
+var require_fast_safe_stringify = __commonJS((exports, module) => {
+  module.exports = stringify7;
+  stringify7.default = stringify7;
+  stringify7.stable = deterministicStringify;
+  stringify7.stableStringify = deterministicStringify;
+  var LIMIT_REPLACE_NODE = "[...]";
+  var CIRCULAR_REPLACE_NODE = "[Circular]";
+  var arr2 = [];
+  var replacerStack = [];
+  function defaultOptions3() {
+    return {
+      depthLimit: Number.MAX_SAFE_INTEGER,
+      edgesLimit: Number.MAX_SAFE_INTEGER
+    };
+  }
+  function stringify7(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+      options = defaultOptions3();
+    }
+    decirc(obj, "", 0, [], undefined, 0, options);
+    var res;
+    try {
+      if (replacerStack.length === 0) {
+        res = JSON.stringify(obj, replacer, spacer);
+      } else {
+        res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+      }
+    } catch (_5) {
+      return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    } finally {
+      while (arr2.length !== 0) {
+        var part = arr2.pop();
+        if (part.length === 4) {
+          Object.defineProperty(part[0], part[1], part[3]);
+        } else {
+          part[0][part[1]] = part[2];
+        }
+      }
+    }
+    return res;
+  }
+  function setReplace(replace, val, k5, parent) {
+    var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k5);
+    if (propertyDescriptor.get !== undefined) {
+      if (propertyDescriptor.configurable) {
+        Object.defineProperty(parent, k5, { value: replace });
+        arr2.push([parent, k5, val, propertyDescriptor]);
+      } else {
+        replacerStack.push([val, k5, replace]);
+      }
+    } else {
+      parent[k5] = replace;
+      arr2.push([parent, k5, val]);
+    }
+  }
+  function decirc(val, k5, edgeIndex, stack2, parent, depth, options) {
+    depth += 1;
+    var i2;
+    if (typeof val === "object" && val !== null) {
+      for (i2 = 0;i2 < stack2.length; i2++) {
+        if (stack2[i2] === val) {
+          setReplace(CIRCULAR_REPLACE_NODE, val, k5, parent);
+          return;
+        }
+      }
+      if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
+        setReplace(LIMIT_REPLACE_NODE, val, k5, parent);
+        return;
+      }
+      if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
+        setReplace(LIMIT_REPLACE_NODE, val, k5, parent);
+        return;
+      }
+      stack2.push(val);
+      if (Array.isArray(val)) {
+        for (i2 = 0;i2 < val.length; i2++) {
+          decirc(val[i2], i2, i2, stack2, val, depth, options);
+        }
+      } else {
+        var keys2 = Object.keys(val);
+        for (i2 = 0;i2 < keys2.length; i2++) {
+          var key2 = keys2[i2];
+          decirc(val[key2], key2, i2, stack2, val, depth, options);
+        }
+      }
+      stack2.pop();
+    }
+  }
+  function compareFunction(a, b5) {
+    if (a < b5) {
+      return -1;
+    }
+    if (a > b5) {
+      return 1;
+    }
+    return 0;
+  }
+  function deterministicStringify(obj, replacer, spacer, options) {
+    if (typeof options === "undefined") {
+      options = defaultOptions3();
+    }
+    var tmp = deterministicDecirc(obj, "", 0, [], undefined, 0, options) || obj;
+    var res;
+    try {
+      if (replacerStack.length === 0) {
+        res = JSON.stringify(tmp, replacer, spacer);
+      } else {
+        res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
+      }
+    } catch (_5) {
+      return JSON.stringify("[unable to serialize, circular reference is too complex to analyze]");
+    } finally {
+      while (arr2.length !== 0) {
+        var part = arr2.pop();
+        if (part.length === 4) {
+          Object.defineProperty(part[0], part[1], part[3]);
+        } else {
+          part[0][part[1]] = part[2];
+        }
+      }
+    }
+    return res;
+  }
+  function deterministicDecirc(val, k5, edgeIndex, stack2, parent, depth, options) {
+    depth += 1;
+    var i2;
+    if (typeof val === "object" && val !== null) {
+      for (i2 = 0;i2 < stack2.length; i2++) {
+        if (stack2[i2] === val) {
+          setReplace(CIRCULAR_REPLACE_NODE, val, k5, parent);
+          return;
+        }
+      }
+      try {
+        if (typeof val.toJSON === "function") {
+          return;
+        }
+      } catch (_5) {
+        return;
+      }
+      if (typeof options.depthLimit !== "undefined" && depth > options.depthLimit) {
+        setReplace(LIMIT_REPLACE_NODE, val, k5, parent);
+        return;
+      }
+      if (typeof options.edgesLimit !== "undefined" && edgeIndex + 1 > options.edgesLimit) {
+        setReplace(LIMIT_REPLACE_NODE, val, k5, parent);
+        return;
+      }
+      stack2.push(val);
+      if (Array.isArray(val)) {
+        for (i2 = 0;i2 < val.length; i2++) {
+          deterministicDecirc(val[i2], i2, i2, stack2, val, depth, options);
+        }
+      } else {
+        var tmp = {};
+        var keys2 = Object.keys(val).sort(compareFunction);
+        for (i2 = 0;i2 < keys2.length; i2++) {
+          var key2 = keys2[i2];
+          deterministicDecirc(val[key2], key2, i2, stack2, val, depth, options);
+          tmp[key2] = val[key2];
+        }
+        if (typeof parent !== "undefined") {
+          arr2.push([parent, k5, val]);
+          parent[k5] = tmp;
+        } else {
+          return tmp;
+        }
+      }
+      stack2.pop();
+    }
+  }
+  function replaceGetterValues(replacer) {
+    replacer = typeof replacer !== "undefined" ? replacer : function(k5, v4) {
+      return v4;
+    };
+    return function(key2, val) {
+      if (replacerStack.length > 0) {
+        for (var i2 = 0;i2 < replacerStack.length; i2++) {
+          var part = replacerStack[i2];
+          if (part[1] === key2 && part[0] === val) {
+            val = part[2];
+            replacerStack.splice(i2, 1);
+            break;
+          }
+        }
+      }
+      return replacer.call(this, key2, val);
+    };
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-error.js
+var require_prettify_error = __commonJS((exports, module) => {
+  module.exports = prettifyError2;
+  var joinLinesWithIndentation = require_join_lines_with_indentation();
+  function prettifyError2({ keyName, lines, eol, ident: ident2 }) {
+    let result = "";
+    const joinedLines = joinLinesWithIndentation({ input: lines, ident: ident2, eol });
+    const splitLines = `${ident2}${keyName}: ${joinedLines}${eol}`.split(eol);
+    for (let j4 = 0;j4 < splitLines.length; j4 += 1) {
+      if (j4 !== 0)
+        result += eol;
+      const line4 = splitLines[j4];
+      if (/^\s*"stack"/.test(line4)) {
+        const matches = /^(\s*"stack":)\s*(".*"),?$/.exec(line4);
+        if (matches && matches.length === 3) {
+          const indentSize = /^\s*/.exec(line4)[0].length + 4;
+          const indentation = " ".repeat(indentSize);
+          const stackMessage = matches[2];
+          result += matches[1] + eol + indentation + JSON.parse(stackMessage).replace(/\n/g, eol + indentation);
+        } else {
+          result += line4;
+        }
+      } else {
+        result += line4;
+      }
+    }
+    return result;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-object.js
+var require_prettify_object = __commonJS((exports, module) => {
+  module.exports = prettifyObject;
+  var {
+    LOGGER_KEYS
+  } = require_constants7();
+  var stringifySafe = require_fast_safe_stringify();
+  var joinLinesWithIndentation = require_join_lines_with_indentation();
+  var prettifyError2 = require_prettify_error();
+  function prettifyObject({
+    log: log4,
+    excludeLoggerKeys = true,
+    skipKeys = [],
+    context
+  }) {
+    const {
+      EOL: eol,
+      IDENT: ident2,
+      customPrettifiers,
+      errorLikeObjectKeys: errorLikeKeys,
+      objectColorizer,
+      singleLine,
+      colorizer
+    } = context;
+    const keysToIgnore = [].concat(skipKeys);
+    if (excludeLoggerKeys === true)
+      Array.prototype.push.apply(keysToIgnore, LOGGER_KEYS);
+    let result = "";
+    const { plain, errors: errors3 } = Object.entries(log4).reduce(({ plain: plain2, errors: errors4 }, [k5, v4]) => {
+      if (keysToIgnore.includes(k5) === false) {
+        const pretty2 = typeof customPrettifiers[k5] === "function" ? customPrettifiers[k5](v4, k5, log4, { colors: colorizer.colors }) : v4;
+        if (errorLikeKeys.includes(k5)) {
+          errors4[k5] = pretty2;
+        } else {
+          plain2[k5] = pretty2;
+        }
+      }
+      return { plain: plain2, errors: errors4 };
+    }, { plain: {}, errors: {} });
+    if (singleLine) {
+      if (Object.keys(plain).length > 0) {
+        result += objectColorizer.greyMessage(stringifySafe(plain));
+      }
+      result += eol;
+      result = result.replace(/\\\\/gi, "\\");
+    } else {
+      Object.entries(plain).forEach(([keyName, keyValue]) => {
+        let lines = typeof customPrettifiers[keyName] === "function" ? keyValue : stringifySafe(keyValue, null, 2);
+        if (lines === undefined)
+          return;
+        lines = lines.replace(/\\\\/gi, "\\");
+        const joinedLines = joinLinesWithIndentation({ input: lines, ident: ident2, eol });
+        result += `${ident2}${objectColorizer.property(keyName)}:${joinedLines.startsWith(eol) ? "" : " "}${joinedLines}${eol}`;
+      });
+    }
+    Object.entries(errors3).forEach(([keyName, keyValue]) => {
+      const lines = typeof customPrettifiers[keyName] === "function" ? keyValue : stringifySafe(keyValue, null, 2);
+      if (lines === undefined)
+        return;
+      result += prettifyError2({ keyName, lines, eol, ident: ident2 });
+    });
+    return result;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-error-log.js
+var require_prettify_error_log = __commonJS((exports, module) => {
+  module.exports = prettifyErrorLog;
+  var {
+    LOGGER_KEYS
+  } = require_constants7();
+  var isObject7 = require_is_object();
+  var joinLinesWithIndentation = require_join_lines_with_indentation();
+  var prettifyObject = require_prettify_object();
+  function prettifyErrorLog({ log: log4, context }) {
+    const {
+      EOL: eol,
+      IDENT: ident2,
+      errorProps: errorProperties,
+      messageKey
+    } = context;
+    const stack2 = log4.stack;
+    const joinedLines = joinLinesWithIndentation({ input: stack2, ident: ident2, eol });
+    let result = `${ident2}${joinedLines}${eol}`;
+    if (errorProperties.length > 0) {
+      const excludeProperties = LOGGER_KEYS.concat(messageKey, "type", "stack");
+      let propertiesToPrint;
+      if (errorProperties[0] === "*") {
+        propertiesToPrint = Object.keys(log4).filter((k5) => excludeProperties.includes(k5) === false);
+      } else {
+        propertiesToPrint = errorProperties.filter((k5) => excludeProperties.includes(k5) === false);
+      }
+      for (let i2 = 0;i2 < propertiesToPrint.length; i2 += 1) {
+        const key2 = propertiesToPrint[i2];
+        if (key2 in log4 === false)
+          continue;
+        if (isObject7(log4[key2])) {
+          const prettifiedObject = prettifyObject({
+            log: log4[key2],
+            excludeLoggerKeys: false,
+            context: {
+              ...context,
+              IDENT: ident2 + ident2
+            }
+          });
+          result = `${result}${ident2}${key2}: {${eol}${prettifiedObject}${ident2}}${eol}`;
+          continue;
+        }
+        result = `${result}${ident2}${key2}: ${log4[key2]}${eol}`;
+      }
+    }
+    return result;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-level.js
+var require_prettify_level = __commonJS((exports, module) => {
+  module.exports = prettifyLevel;
+  var getPropertyValue = require_get_property_value();
+  function prettifyLevel({ log: log4, context }) {
+    const {
+      colorizer,
+      customLevels,
+      customLevelNames,
+      levelKey,
+      getLevelLabelData
+    } = context;
+    const prettifier = context.customPrettifiers?.level;
+    const output = getPropertyValue(log4, levelKey);
+    if (output === undefined)
+      return;
+    const labelColorized = colorizer(output, { customLevels, customLevelNames });
+    if (prettifier) {
+      const [label] = getLevelLabelData(output);
+      return prettifier(output, levelKey, log4, { label, labelColorized, colors: colorizer.colors });
+    }
+    return labelColorized;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-message.js
+var require_prettify_message = __commonJS((exports, module) => {
+  module.exports = prettifyMessage;
+  var {
+    LEVELS
+  } = require_constants7();
+  var getPropertyValue = require_get_property_value();
+  var interpretConditionals = require_interpret_conditionals();
+  function prettifyMessage({ log: log4, context }) {
+    const {
+      colorizer,
+      customLevels,
+      levelKey,
+      levelLabel,
+      messageFormat,
+      messageKey,
+      useOnlyCustomProps
+    } = context;
+    if (messageFormat && typeof messageFormat === "string") {
+      const parsedMessageFormat = interpretConditionals(messageFormat, log4);
+      const message2 = String(parsedMessageFormat).replace(/{([^{}]+)}/g, function(match, p1) {
+        let level;
+        if (p1 === levelLabel && (level = getPropertyValue(log4, levelKey)) !== undefined) {
+          const condition = useOnlyCustomProps ? customLevels === undefined : customLevels[level] === undefined;
+          return condition ? LEVELS[level] : customLevels[level];
+        }
+        return getPropertyValue(log4, p1) || "";
+      });
+      return colorizer.message(message2);
+    }
+    if (messageFormat && typeof messageFormat === "function") {
+      const msg = messageFormat(log4, messageKey, levelLabel, { colors: colorizer.colors });
+      return colorizer.message(msg);
+    }
+    if (messageKey in log4 === false)
+      return;
+    if (typeof log4[messageKey] !== "string" && typeof log4[messageKey] !== "number" && typeof log4[messageKey] !== "boolean")
+      return;
+    return colorizer.message(log4[messageKey]);
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-metadata.js
+var require_prettify_metadata = __commonJS((exports, module) => {
+  module.exports = prettifyMetadata;
+  function prettifyMetadata({ log: log4, context }) {
+    const { customPrettifiers: prettifiers, colorizer } = context;
+    let line4 = "";
+    if (log4.name || log4.pid || log4.hostname) {
+      line4 += "(";
+      if (log4.name) {
+        line4 += prettifiers.name ? prettifiers.name(log4.name, "name", log4, { colors: colorizer.colors }) : log4.name;
+      }
+      if (log4.pid) {
+        const prettyPid = prettifiers.pid ? prettifiers.pid(log4.pid, "pid", log4, { colors: colorizer.colors }) : log4.pid;
+        if (log4.name && log4.pid) {
+          line4 += "/" + prettyPid;
+        } else {
+          line4 += prettyPid;
+        }
+      }
+      if (log4.hostname) {
+        const prettyHostname = prettifiers.hostname ? prettifiers.hostname(log4.hostname, "hostname", log4, { colors: colorizer.colors }) : log4.hostname;
+        line4 += `${line4 === "(" ? "on" : " on"} ${prettyHostname}`;
+      }
+      line4 += ")";
+    }
+    if (log4.caller) {
+      const prettyCaller = prettifiers.caller ? prettifiers.caller(log4.caller, "caller", log4, { colors: colorizer.colors }) : log4.caller;
+      line4 += `${line4 === "" ? "" : " "}<${prettyCaller}>`;
+    }
+    if (line4 === "") {
+      return;
+    } else {
+      return line4;
+    }
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/prettify-time.js
+var require_prettify_time = __commonJS((exports, module) => {
+  module.exports = prettifyTime;
+  var formatTime = require_format_time();
+  function prettifyTime({ log: log4, context }) {
+    const {
+      timestampKey,
+      translateTime: translateFormat
+    } = context;
+    const prettifier = context.customPrettifiers?.time;
+    let time4 = null;
+    if (timestampKey in log4) {
+      time4 = log4[timestampKey];
+    } else if ("timestamp" in log4) {
+      time4 = log4.timestamp;
+    }
+    if (time4 === null)
+      return;
+    const output = translateFormat ? formatTime(time4, translateFormat) : time4;
+    return prettifier ? prettifier(output) : `[${output}]`;
+  }
+});
+
+// node_modules/pino-pretty/lib/utils/index.js
+var require_utils16 = __commonJS((exports, module) => {
+  module.exports = {
+    buildSafeSonicBoom: require_build_safe_sonic_boom(),
+    createDate: require_create_date(),
+    deleteLogProperty: require_delete_log_property(),
+    filterLog: require_filter_log(),
+    formatTime: require_format_time(),
+    getPropertyValue: require_get_property_value(),
+    handleCustomLevelsNamesOpts: require_handle_custom_levels_names_opts(),
+    handleCustomLevelsOpts: require_handle_custom_levels_opts(),
+    interpretConditionals: require_interpret_conditionals(),
+    isObject: require_is_object(),
+    isValidDate: require_is_valid_date(),
+    joinLinesWithIndentation: require_join_lines_with_indentation(),
+    noop: require_noop(),
+    parseFactoryOptions: require_parse_factory_options(),
+    prettifyErrorLog: require_prettify_error_log(),
+    prettifyError: require_prettify_error(),
+    prettifyLevel: require_prettify_level(),
+    prettifyMessage: require_prettify_message(),
+    prettifyMetadata: require_prettify_metadata(),
+    prettifyObject: require_prettify_object(),
+    prettifyTime: require_prettify_time(),
+    splitPropertyKey: require_split_property_key(),
+    getLevelLabelData: require_get_level_label_data()
+  };
+});
+
+// node_modules/pino-pretty/lib/pretty.js
+var require_pretty = __commonJS((exports, module) => {
+  module.exports = pretty2;
+  var sjs = require_secure_json_parse();
+  var isObject7 = require_is_object();
+  var prettifyErrorLog = require_prettify_error_log();
+  var prettifyLevel = require_prettify_level();
+  var prettifyMessage = require_prettify_message();
+  var prettifyMetadata = require_prettify_metadata();
+  var prettifyObject = require_prettify_object();
+  var prettifyTime = require_prettify_time();
+  var filterLog = require_filter_log();
+  var {
+    LEVELS,
+    LEVEL_KEY,
+    LEVEL_NAMES
+  } = require_constants7();
+  var jsonParser = (input) => {
+    try {
+      return { value: sjs.parse(input, { protoAction: "remove" }) };
+    } catch (err) {
+      return { err };
+    }
+  };
+  function pretty2(inputData) {
+    let log4;
+    if (!isObject7(inputData)) {
+      const parsed = jsonParser(inputData);
+      if (parsed.err || !isObject7(parsed.value)) {
+        return inputData + this.EOL;
+      }
+      log4 = parsed.value;
+    } else {
+      log4 = inputData;
+    }
+    if (this.minimumLevel) {
+      let condition;
+      if (this.useOnlyCustomProps) {
+        condition = this.customLevels;
+      } else {
+        condition = this.customLevelNames[this.minimumLevel] !== undefined;
+      }
+      let minimum;
+      if (condition) {
+        minimum = this.customLevelNames[this.minimumLevel];
+      } else {
+        minimum = LEVEL_NAMES[this.minimumLevel];
+      }
+      if (!minimum) {
+        minimum = typeof this.minimumLevel === "string" ? LEVEL_NAMES[this.minimumLevel] : LEVEL_NAMES[LEVELS[this.minimumLevel].toLowerCase()];
+      }
+      const level = log4[this.levelKey === undefined ? LEVEL_KEY : this.levelKey];
+      if (level < minimum)
+        return;
+    }
+    const prettifiedMessage = prettifyMessage({ log: log4, context: this.context });
+    if (this.ignoreKeys || this.includeKeys) {
+      log4 = filterLog({ log: log4, context: this.context });
+    }
+    const prettifiedLevel = prettifyLevel({
+      log: log4,
+      context: {
+        ...this.context,
+        ...this.context.customProperties
+      }
+    });
+    const prettifiedMetadata = prettifyMetadata({ log: log4, context: this.context });
+    const prettifiedTime = prettifyTime({ log: log4, context: this.context });
+    let line4 = "";
+    if (this.levelFirst && prettifiedLevel) {
+      line4 = `${prettifiedLevel}`;
+    }
+    if (prettifiedTime && line4 === "") {
+      line4 = `${prettifiedTime}`;
+    } else if (prettifiedTime) {
+      line4 = `${line4} ${prettifiedTime}`;
+    }
+    if (!this.levelFirst && prettifiedLevel) {
+      if (line4.length > 0) {
+        line4 = `${line4} ${prettifiedLevel}`;
+      } else {
+        line4 = prettifiedLevel;
+      }
+    }
+    if (prettifiedMetadata) {
+      if (line4.length > 0) {
+        line4 = `${line4} ${prettifiedMetadata}:`;
+      } else {
+        line4 = prettifiedMetadata;
+      }
+    }
+    if (line4.endsWith(":") === false && line4 !== "") {
+      line4 += ":";
+    }
+    if (prettifiedMessage !== undefined) {
+      if (line4.length > 0) {
+        line4 = `${line4} ${prettifiedMessage}`;
+      } else {
+        line4 = prettifiedMessage;
+      }
+    }
+    if (line4.length > 0 && !this.singleLine) {
+      line4 += this.EOL;
+    }
+    if (log4.type === "Error" && typeof log4.stack === "string") {
+      const prettifiedErrorLog = prettifyErrorLog({ log: log4, context: this.context });
+      if (this.singleLine)
+        line4 += this.EOL;
+      line4 += prettifiedErrorLog;
+    } else if (this.hideObject === false) {
+      const skipKeys = [
+        this.messageKey,
+        this.levelKey,
+        this.timestampKey
+      ].map((key2) => key2.replaceAll(/\\/g, "")).filter((key2) => {
+        return typeof log4[key2] === "string" || typeof log4[key2] === "number" || typeof log4[key2] === "boolean";
+      });
+      const prettifiedObject = prettifyObject({
+        log: log4,
+        skipKeys,
+        context: this.context
+      });
+      if (this.singleLine && !/^\s$/.test(prettifiedObject)) {
+        line4 += " ";
+      }
+      line4 += prettifiedObject;
+    }
+    return line4;
+  }
+});
+
+// node_modules/pino-pretty/index.js
+var require_pino_pretty = __commonJS((exports, module) => {
+  var { isColorSupported } = require_colorette();
+  var pump = require_pump();
+  var { Transform } = __require("node:stream");
+  var abstractTransport = require_pino_abstract_transport();
+  var colors9 = require_colors();
+  var {
+    ERROR_LIKE_KEYS,
+    LEVEL_KEY,
+    LEVEL_LABEL,
+    MESSAGE_KEY,
+    TIMESTAMP_KEY
+  } = require_constants7();
+  var {
+    buildSafeSonicBoom,
+    parseFactoryOptions
+  } = require_utils16();
+  var pretty2 = require_pretty();
+  var defaultOptions3 = {
+    colorize: isColorSupported,
+    colorizeObjects: true,
+    crlf: false,
+    customColors: null,
+    customLevels: null,
+    customPrettifiers: {},
+    errorLikeObjectKeys: ERROR_LIKE_KEYS,
+    errorProps: "",
+    hideObject: false,
+    ignore: "hostname",
+    include: undefined,
+    levelFirst: false,
+    levelKey: LEVEL_KEY,
+    levelLabel: LEVEL_LABEL,
+    messageFormat: null,
+    messageKey: MESSAGE_KEY,
+    minimumLevel: undefined,
+    outputStream: process.stdout,
+    singleLine: false,
+    timestampKey: TIMESTAMP_KEY,
+    translateTime: true,
+    useOnlyCustomProps: true
+  };
+  function prettyFactory(options) {
+    const context = parseFactoryOptions(Object.assign({}, defaultOptions3, options));
+    return pretty2.bind({ ...context, context });
+  }
+  function build(opts = {}) {
+    let pretty3 = prettyFactory(opts);
+    let destination;
+    return abstractTransport(function(source2) {
+      source2.on("message", function pinoConfigListener(message2) {
+        if (!message2 || message2.code !== "PINO_CONFIG")
+          return;
+        Object.assign(opts, {
+          messageKey: message2.config.messageKey,
+          errorLikeObjectKeys: Array.from(new Set([...opts.errorLikeObjectKeys || ERROR_LIKE_KEYS, message2.config.errorKey])),
+          customLevels: message2.config.levels.values
+        });
+        pretty3 = prettyFactory(opts);
+        source2.off("message", pinoConfigListener);
+      });
+      const stream3 = new Transform({
+        objectMode: true,
+        autoDestroy: true,
+        transform(chunk, enc2, cb) {
+          const line4 = pretty3(chunk);
+          cb(null, line4);
+        }
+      });
+      if (typeof opts.destination === "object" && typeof opts.destination.write === "function") {
+        destination = opts.destination;
+      } else {
+        destination = buildSafeSonicBoom({
+          dest: opts.destination || 1,
+          append: opts.append,
+          mkdir: opts.mkdir,
+          sync: opts.sync
+        });
+      }
+      source2.on("unknown", function(line4) {
+        destination.write(line4 + `
+`);
+      });
+      pump(source2, stream3, destination);
+      return stream3;
+    }, {
+      parse: "lines",
+      close(err, cb) {
+        destination.on("close", () => {
+          cb(err);
+        });
+      }
+    });
+  }
+  module.exports = build;
+  module.exports.build = build;
+  module.exports.PinoPretty = build;
+  module.exports.prettyFactory = prettyFactory;
+  module.exports.colorizerFactory = colors9;
+  module.exports.isColorSupported = isColorSupported;
+  module.exports.default = build;
+});
+
 // node_modules/nodemailer/lib/fetch/cookies.js
 var require_cookies = __commonJS((exports, module) => {
   var urllib = __require("url");
@@ -315104,7 +317376,7 @@ var require_lib14 = __commonJS((exports, module) => {
 });
 
 // node_modules/node-fetch/node_modules/whatwg-url/lib/utils.js
-var require_utils16 = __commonJS((exports, module) => {
+var require_utils17 = __commonJS((exports, module) => {
   exports.mixin = function mixin(target, source2) {
     const keys2 = Object.getOwnPropertyNames(source2);
     for (let i2 = 0;i2 < keys2.length; ++i2) {
@@ -316508,7 +318780,7 @@ var require_URL_impl = __commonJS((exports) => {
 // node_modules/node-fetch/node_modules/whatwg-url/lib/URL.js
 var require_URL = __commonJS((exports, module) => {
   var conversions = require_lib14();
-  var utils2 = require_utils16();
+  var utils2 = require_utils17();
   var Impl = require_URL_impl();
   var impl = utils2.implSymbol;
   function URL2(url2) {
@@ -378506,8 +380778,15 @@ async function defineI18n(opts) {
 
 // app/.server/primitives/logger.ts
 var import_pino = __toESM(require_pino(), 1);
+var import_pino_pretty = __toESM(require_pino_pretty(), 1);
 async function defineLogger(opts) {
-  const transports = [];
+  const transports = [
+    ...process.env.NODE_ENV !== "production" ? [
+      {
+        target: "pino-pretty"
+      }
+    ] : []
+  ];
   const commonOpts = {
     level: opts.level || "info",
     redact: opts.redact || [],