@basemaps/lambda-tiler 6.16.0 → 6.16.1

package/dist/index.js

@@ -58,9 +58,9 @@ var __privateWrapper = (obj, member, setter, getter) => {
   };
 };
 
-// ../../node_modules/pino-std-serializers/lib/err.js
+// ../../node_modules/@linzjs/lambda/node_modules/pino-std-serializers/lib/err.js
 var require_err = __commonJS({
-  "../../node_modules/pino-std-serializers/lib/err.js"(exports, module2) {
+  "../../node_modules/@linzjs/lambda/node_modules/pino-std-serializers/lib/err.js"(exports, module2) {
     "use strict";
     module2.exports = errSerializer;
     var { toString } = Object.prototype;
@@ -124,9 +124,9 @@ var require_err = __commonJS({
   }
 });
 
-// ../../node_modules/pino-std-serializers/lib/req.js
+// ../../node_modules/@linzjs/lambda/node_modules/pino-std-serializers/lib/req.js
 var require_req = __commonJS({
-  "../../node_modules/pino-std-serializers/lib/req.js"(exports, module2) {
+  "../../node_modules/@linzjs/lambda/node_modules/pino-std-serializers/lib/req.js"(exports, module2) {
     "use strict";
     module2.exports = {
       mapHttpRequest,
@@ -202,9 +202,9 @@ var require_req = __commonJS({
   }
 });
 
-// ../../node_modules/pino-std-serializers/lib/res.js
+// ../../node_modules/@linzjs/lambda/node_modules/pino-std-serializers/lib/res.js
 var require_res = __commonJS({
-  "../../node_modules/pino-std-serializers/lib/res.js"(exports, module2) {
+  "../../node_modules/@linzjs/lambda/node_modules/pino-std-serializers/lib/res.js"(exports, module2) {
     "use strict";
     module2.exports = {
       mapHttpResponse,
@@ -251,9 +251,9 @@ var require_res = __commonJS({
   }
 });
 
-// ../../node_modules/pino-std-serializers/index.js
+// ../../node_modules/@linzjs/lambda/node_modules/pino-std-serializers/index.js
 var require_pino_std_serializers = __commonJS({
-  "../../node_modules/pino-std-serializers/index.js"(exports, module2) {
+  "../../node_modules/@linzjs/lambda/node_modules/pino-std-serializers/index.js"(exports, module2) {
     "use strict";
     var errSerializer = require_err();
     var reqSerializers = require_req();
@@ -891,9 +891,9 @@ var require_flatstr = __commonJS({
   }
 });
 
-// ../../node_modules/atomic-sleep/index.js
+// ../../node_modules/@linzjs/lambda/node_modules/atomic-sleep/index.js
 var require_atomic_sleep = __commonJS({
-  "../../node_modules/atomic-sleep/index.js"(exports, module2) {
+  "../../node_modules/@linzjs/lambda/node_modules/atomic-sleep/index.js"(exports, module2) {
     "use strict";
     if (typeof SharedArrayBuffer !== "undefined" && typeof Atomics !== "undefined") {
       let sleep = function(ms) {
@@ -926,9 +926,9 @@ var require_atomic_sleep = __commonJS({
   }
 });
 
-// ../../node_modules/sonic-boom/index.js
+// ../../node_modules/@linzjs/lambda/node_modules/sonic-boom/index.js
 var require_sonic_boom = __commonJS({
-  "../../node_modules/sonic-boom/index.js"(exports, module2) {
+  "../../node_modules/@linzjs/lambda/node_modules/sonic-boom/index.js"(exports, module2) {
     "use strict";
     var fs4 = require("fs");
     var EventEmitter = require("events");
@@ -1399,9 +1399,9 @@ var require_quick_format_unescaped = __commonJS({
   }
 });
 
-// ../../node_modules/@linzjs/lambda/node_modules/fast-safe-stringify/index.js
+// ../../node_modules/fast-safe-stringify/index.js
 var require_fast_safe_stringify = __commonJS({
-  "../../node_modules/@linzjs/lambda/node_modules/fast-safe-stringify/index.js"(exports, module2) {
+  "../../node_modules/fast-safe-stringify/index.js"(exports, module2) {
     module2.exports = stringify;
     stringify.default = stringify;
     stringify.stable = deterministicStringify;
@@ -3260,6 +3260,273 @@ var require_src = __commonJS({
   }
 });
 
+// ../../node_modules/pino-std-serializers/lib/err.js
+var require_err2 = __commonJS({
+  "../../node_modules/pino-std-serializers/lib/err.js"(exports, module2) {
+    "use strict";
+    module2.exports = errSerializer;
+    var { toString } = Object.prototype;
+    var seen = Symbol("circular-ref-tag");
+    var rawSymbol = Symbol("pino-raw-err-ref");
+    var pinoErrProto = Object.create({}, {
+      type: {
+        enumerable: true,
+        writable: true,
+        value: void 0
+      },
+      message: {
+        enumerable: true,
+        writable: true,
+        value: void 0
+      },
+      stack: {
+        enumerable: true,
+        writable: true,
+        value: void 0
+      },
+      raw: {
+        enumerable: false,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoErrProto, rawSymbol, {
+      writable: true,
+      value: {}
+    });
+    function errSerializer(err) {
+      if (!(err instanceof Error)) {
+        return err;
+      }
+      err[seen] = void 0;
+      const _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;
+      for (const key in err) {
+        if (_err[key] === void 0) {
+          const val = err[key];
+          if (val instanceof Error) {
+            if (!val.hasOwnProperty(seen)) {
+              _err[key] = errSerializer(val);
+            }
+          } else {
+            _err[key] = val;
+          }
+        }
+      }
+      delete err[seen];
+      _err.raw = err;
+      return _err;
+    }
+  }
+});
+
+// ../../node_modules/pino-std-serializers/lib/req.js
+var require_req2 = __commonJS({
+  "../../node_modules/pino-std-serializers/lib/req.js"(exports, module2) {
+    "use strict";
+    module2.exports = {
+      mapHttpRequest,
+      reqSerializer
+    };
+    var rawSymbol = Symbol("pino-raw-req-ref");
+    var pinoReqProto = Object.create({}, {
+      id: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      method: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      url: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      query: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      params: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      headers: {
+        enumerable: true,
+        writable: true,
+        value: {}
+      },
+      remoteAddress: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      remotePort: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      raw: {
+        enumerable: false,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoReqProto, rawSymbol, {
+      writable: true,
+      value: {}
+    });
+    function reqSerializer(req) {
+      const connection = req.info || req.socket;
+      const _req = Object.create(pinoReqProto);
+      _req.id = typeof req.id === "function" ? req.id() : req.id || (req.info ? req.info.id : void 0);
+      _req.method = req.method;
+      if (req.originalUrl) {
+        _req.url = req.originalUrl;
+        _req.query = req.query;
+        _req.params = req.params;
+      } else {
+        _req.url = req.path || (req.url ? req.url.path || req.url : void 0);
+      }
+      _req.headers = req.headers;
+      _req.remoteAddress = connection && connection.remoteAddress;
+      _req.remotePort = connection && connection.remotePort;
+      _req.raw = req.raw || req;
+      return _req;
+    }
+    function mapHttpRequest(req) {
+      return {
+        req: reqSerializer(req)
+      };
+    }
+  }
+});
+
+// ../../node_modules/pino-std-serializers/lib/res.js
+var require_res2 = __commonJS({
+  "../../node_modules/pino-std-serializers/lib/res.js"(exports, module2) {
+    "use strict";
+    module2.exports = {
+      mapHttpResponse,
+      resSerializer
+    };
+    var rawSymbol = Symbol("pino-raw-res-ref");
+    var pinoResProto = Object.create({}, {
+      statusCode: {
+        enumerable: true,
+        writable: true,
+        value: 0
+      },
+      headers: {
+        enumerable: true,
+        writable: true,
+        value: ""
+      },
+      raw: {
+        enumerable: false,
+        get: function() {
+          return this[rawSymbol];
+        },
+        set: function(val) {
+          this[rawSymbol] = val;
+        }
+      }
+    });
+    Object.defineProperty(pinoResProto, rawSymbol, {
+      writable: true,
+      value: {}
+    });
+    function resSerializer(res) {
+      const _res = Object.create(pinoResProto);
+      _res.statusCode = res.statusCode;
+      _res.headers = res.getHeaders ? res.getHeaders() : res._headers;
+      _res.raw = res;
+      return _res;
+    }
+    function mapHttpResponse(res) {
+      return {
+        res: resSerializer(res)
+      };
+    }
+  }
+});
+
+// ../../node_modules/pino-std-serializers/index.js
+var require_pino_std_serializers2 = __commonJS({
+  "../../node_modules/pino-std-serializers/index.js"(exports, module2) {
+    "use strict";
+    var errSerializer = require_err2();
+    var reqSerializers = require_req2();
+    var resSerializers = require_res2();
+    module2.exports = {
+      err: errSerializer,
+      mapHttpRequest: reqSerializers.mapHttpRequest,
+      mapHttpResponse: resSerializers.mapHttpResponse,
+      req: reqSerializers.reqSerializer,
+      res: resSerializers.resSerializer,
+      wrapErrorSerializer: function wrapErrorSerializer(customSerializer) {
+        if (customSerializer === errSerializer)
+          return customSerializer;
+        return function wrapErrSerializer(err) {
+          return customSerializer(errSerializer(err));
+        };
+      },
+      wrapRequestSerializer: function wrapRequestSerializer(customSerializer) {
+        if (customSerializer === reqSerializers.reqSerializer)
+          return customSerializer;
+        return function wrappedReqSerializer(req) {
+          return customSerializer(reqSerializers.reqSerializer(req));
+        };
+      },
+      wrapResponseSerializer: function wrapResponseSerializer(customSerializer) {
+        if (customSerializer === resSerializers.resSerializer)
+          return customSerializer;
+        return function wrappedResSerializer(res) {
+          return customSerializer(resSerializers.resSerializer(res));
+        };
+      }
+    };
+  }
+});
+
+// ../../node_modules/get-caller-file/index.js
+var require_get_caller_file = __commonJS({
+  "../../node_modules/get-caller-file/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = function getCallerFile(position) {
+      if (position === void 0) {
+        position = 2;
+      }
+      if (position >= Error.stackTraceLimit) {
+        throw new TypeError("getCallerFile(position) requires position be less then Error.stackTraceLimit but position was: `" + position + "` and Error.stackTraceLimit was: `" + Error.stackTraceLimit + "`");
+      }
+      var oldPrepareStackTrace = Error.prepareStackTrace;
+      Error.prepareStackTrace = function(_, stack2) {
+        return stack2;
+      };
+      var stack = new Error().stack;
+      Error.prepareStackTrace = oldPrepareStackTrace;
+      if (stack !== null && typeof stack === "object") {
+        return stack[position] ? stack[position].getFileName() : void 0;
+      }
+    };
+  }
+});
+
 // ../../node_modules/pino/lib/symbols.js
 var require_symbols2 = __commonJS({
   "../../node_modules/pino/lib/symbols.js"(exports, module2) {
@@ -3280,11 +3547,13 @@ var require_symbols2 = __commonJS({
     var timeSliceIndexSym = Symbol("pino.timeSliceIndex");
     var streamSym = Symbol("pino.stream");
     var stringifySym = Symbol("pino.stringify");
+    var stringifySafeSym = Symbol("pino.stringifySafe");
     var stringifiersSym = Symbol("pino.stringifiers");
     var endSym = Symbol("pino.end");
     var formatOptsSym = Symbol("pino.formatOpts");
     var messageKeySym = Symbol("pino.messageKey");
     var nestedKeySym = Symbol("pino.nestedKey");
+    var nestedKeyStrSym = Symbol("pino.nestedKeyStr");
     var wildcardFirstSym = Symbol("pino.wildcardFirst");
     var serializersSym = Symbol.for("pino.serializers");
     var formattersSym = Symbol.for("pino.formatters");
@@ -3307,6 +3576,7 @@ var require_symbols2 = __commonJS({
       timeSliceIndexSym,
       streamSym,
       stringifySym,
+      stringifySafeSym,
       stringifiersSym,
       endSym,
       formatOptsSym,
@@ -3316,7 +3586,8 @@ var require_symbols2 = __commonJS({
       needsMetadataGsym,
       useOnlyCustomLevelsSym,
       formattersSym,
-      hooksSym
+      hooksSym,
+      nestedKeyStrSym
     };
   }
 });
@@ -3421,159 +3692,1002 @@ var require_time2 = __commonJS({
   }
 });
 
-// ../../node_modules/fast-safe-stringify/index.js
-var require_fast_safe_stringify2 = __commonJS({
-  "../../node_modules/fast-safe-stringify/index.js"(exports, module2) {
-    module2.exports = stringify;
-    stringify.default = stringify;
-    stringify.stable = deterministicStringify;
-    stringify.stableStringify = deterministicStringify;
-    var arr = [];
-    var replacerStack = [];
-    function stringify(obj, replacer, spacer) {
-      decirc(obj, "", [], void 0);
-      var res;
-      if (replacerStack.length === 0) {
-        res = JSON.stringify(obj, replacer, spacer);
+// ../../node_modules/atomic-sleep/index.js
+var require_atomic_sleep2 = __commonJS({
+  "../../node_modules/atomic-sleep/index.js"(exports, module2) {
+    "use strict";
+    if (typeof SharedArrayBuffer !== "undefined" && typeof Atomics !== "undefined") {
+      let sleep = function(ms) {
+        const valid = ms > 0 && ms < Infinity;
+        if (valid === false) {
+          if (typeof ms !== "number" && typeof ms !== "bigint") {
+            throw TypeError("sleep: ms must be a number");
+          }
+          throw RangeError("sleep: ms must be a number that is greater than 0 but less than Infinity");
+        }
+        Atomics.wait(nil, 0, 0, Number(ms));
+      };
+      const nil = new Int32Array(new SharedArrayBuffer(4));
+      module2.exports = sleep;
+    } else {
+      let sleep = function(ms) {
+        const valid = ms > 0 && ms < Infinity;
+        if (valid === false) {
+          if (typeof ms !== "number" && typeof ms !== "bigint") {
+            throw TypeError("sleep: ms must be a number");
+          }
+          throw RangeError("sleep: ms must be a number that is greater than 0 but less than Infinity");
+        }
+        const target = Date.now() + Number(ms);
+        while (target > Date.now()) {
+        }
+      };
+      module2.exports = sleep;
+    }
+  }
+});
+
+// ../../node_modules/sonic-boom/index.js
+var require_sonic_boom2 = __commonJS({
+  "../../node_modules/sonic-boom/index.js"(exports, module2) {
+    "use strict";
+    var fs4 = require("fs");
+    var EventEmitter = require("events");
+    var inherits = require("util").inherits;
+    var path3 = require("path");
+    var sleep = require_atomic_sleep2();
+    var BUSY_WRITE_TIMEOUT = 100;
+    var MAX_WRITE = 16 * 1024 * 1024;
+    function openFile(file, sonic) {
+      sonic._opening = true;
+      sonic._writing = true;
+      sonic._asyncDrainScheduled = false;
+      function fileOpened(err, fd) {
+        if (err) {
+          sonic._reopening = false;
+          sonic._writing = false;
+          sonic._opening = false;
+          if (sonic.sync) {
+            process.nextTick(() => {
+              if (sonic.listenerCount("error") > 0) {
+                sonic.emit("error", err);
+              }
+            });
+          } else {
+            sonic.emit("error", err);
+          }
+          return;
+        }
+        sonic.fd = fd;
+        sonic.file = file;
+        sonic._reopening = false;
+        sonic._opening = false;
+        sonic._writing = false;
+        if (sonic.sync) {
+          process.nextTick(() => sonic.emit("ready"));
+        } else {
+          sonic.emit("ready");
+        }
+        if (sonic._reopening) {
+          return;
+        }
+        if (!sonic._writing && sonic._len > sonic.minLength && !sonic.destroyed) {
+          actualWrite(sonic);
+        }
+      }
+      const mode = sonic.append ? "a" : "w";
+      if (sonic.sync) {
+        try {
+          if (sonic.mkdir)
+            fs4.mkdirSync(path3.dirname(file), { recursive: true });
+          const fd = fs4.openSync(file, mode);
+          fileOpened(null, fd);
+        } catch (err) {
+          fileOpened(err);
+          throw err;
+        }
+      } else if (sonic.mkdir) {
+        fs4.mkdir(path3.dirname(file), { recursive: true }, (err) => {
+          if (err)
+            return fileOpened(err);
+          fs4.open(file, mode, fileOpened);
+        });
+      } else {
+        fs4.open(file, mode, fileOpened);
+      }
+    }
+    function SonicBoom(opts) {
+      if (!(this instanceof SonicBoom)) {
+        return new SonicBoom(opts);
+      }
+      let { fd, dest, minLength, maxLength, sync, append = true, mkdir, retryEAGAIN } = opts || {};
+      fd = fd || dest;
+      this._bufs = [];
+      this._len = 0;
+      this.fd = -1;
+      this._writing = false;
+      this._writingBuf = "";
+      this._ending = false;
+      this._reopening = false;
+      this._asyncDrainScheduled = false;
+      this._hwm = Math.max(minLength || 0, 16387);
+      this.file = null;
+      this.destroyed = false;
+      this.minLength = minLength || 0;
+      this.maxLength = maxLength || 0;
+      this.sync = sync || false;
+      this.append = append || false;
+      this.retryEAGAIN = retryEAGAIN || (() => true);
+      this.mkdir = mkdir || false;
+      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 >= MAX_WRITE) {
+        throw new Error(`minLength should be smaller than MAX_WRITE (${MAX_WRITE})`);
+      }
+      this.release = (err, n) => {
+        if (err) {
+          if (err.code === "EAGAIN" && 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(() => {
+                fs4.write(this.fd, this._writingBuf, "utf8", this.release);
+              }, BUSY_WRITE_TIMEOUT);
+            }
+          } else {
+            this._writing = false;
+            this.emit("error", err);
+          }
+          return;
+        }
+        this._len -= n;
+        this._writingBuf = this._writingBuf.slice(n);
+        if (this._writingBuf.length) {
+          if (!this.sync) {
+            fs4.write(this.fd, this._writingBuf, "utf8", this.release);
+            return;
+          }
+          try {
+            do {
+              const n2 = fs4.writeSync(this.fd, this._writingBuf, "utf8");
+              this._len -= n2;
+              this._writingBuf = this._writingBuf.slice(n2);
+            } while (this._writingBuf);
+          } catch (err2) {
+            this.release(err2);
+            return;
+          }
+        }
+        const len = this._len;
+        if (this._reopening) {
+          this._writing = false;
+          this._reopening = false;
+          this.reopen();
+        } else if (len > this.minLength) {
+          actualWrite(this);
+        } else if (this._ending) {
+          if (len > 0) {
+            actualWrite(this);
+          } else {
+            this._writing = false;
+            actualClose(this);
+          }
+        } else {
+          this._writing = false;
+          if (this.sync) {
+            if (!this._asyncDrainScheduled) {
+              this._asyncDrainScheduled = true;
+              process.nextTick(emitDrain, this);
+            }
+          } else {
+            this.emit("drain");
+          }
+        }
+      };
+      this.on("newListener", function(name) {
+        if (name === "drain") {
+          this._asyncDrainScheduled = false;
+        }
+      });
+    }
+    function emitDrain(sonic) {
+      const hasListeners = sonic.listenerCount("drain") > 0;
+      if (!hasListeners)
+        return;
+      sonic._asyncDrainScheduled = false;
+      sonic.emit("drain");
+    }
+    inherits(SonicBoom, EventEmitter);
+    SonicBoom.prototype.write = function(data) {
+      if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+      }
+      const len = this._len + data.length;
+      const bufs = this._bufs;
+      if (this.maxLength && len > this.maxLength) {
+        this.emit("drop", data);
+        return this._len < this._hwm;
+      }
+      if (!this._writing && len > MAX_WRITE) {
+        bufs.push(data);
+      } else if (bufs.length === 0) {
+        bufs[0] = "" + data;
+      } else {
+        bufs[bufs.length - 1] += data;
+      }
+      this._len = len;
+      if (!this._writing && this._len >= this.minLength) {
+        actualWrite(this);
+      }
+      return this._len < this._hwm;
+    };
+    SonicBoom.prototype.flush = function() {
+      if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+      }
+      if (this._writing || this.minLength <= 0) {
+        return;
+      }
+      if (this._bufs.length === 0) {
+        this._bufs.push("");
+      }
+      actualWrite(this);
+    };
+    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");
+      }
+      this._reopening = true;
+      if (this._writing) {
+        return;
+      }
+      const fd = this.fd;
+      this.once("ready", () => {
+        if (fd !== this.fd) {
+          fs4.close(fd, (err) => {
+            if (err) {
+              return this.emit("error", err);
+            }
+          });
+        }
+      });
+      openFile(file || this.file, this);
+    };
+    SonicBoom.prototype.end = function() {
+      if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+      }
+      if (this._opening) {
+        this.once("ready", () => {
+          this.end();
+        });
+        return;
+      }
+      if (this._ending) {
+        return;
+      }
+      this._ending = true;
+      if (this._writing) {
+        return;
+      }
+      if (this._len > 0 && this.fd >= 0) {
+        actualWrite(this);
+      } else {
+        actualClose(this);
+      }
+    };
+    SonicBoom.prototype.flushSync = function() {
+      if (this.destroyed) {
+        throw new Error("SonicBoom destroyed");
+      }
+      if (this.fd < 0) {
+        throw new Error("sonic boom is not ready yet");
+      }
+      if (!this._writing && this._writingBuf.length > 0) {
+        this._bufs.unshift(this._writingBuf);
+        this._writingBuf = "";
+      }
+      while (this._bufs.length) {
+        const buf = this._bufs[0];
+        try {
+          this._len -= fs4.writeSync(this.fd, buf, "utf8");
+          this._bufs.shift();
+        } catch (err) {
+          if (err.code !== "EAGAIN" || !this.retryEAGAIN(err, buf.length, this._len - buf.length)) {
+            throw err;
+          }
+          sleep(BUSY_WRITE_TIMEOUT);
+        }
+      }
+    };
+    SonicBoom.prototype.destroy = function() {
+      if (this.destroyed) {
+        return;
+      }
+      actualClose(this);
+    };
+    function actualWrite(sonic) {
+      const release = sonic.release;
+      sonic._writing = true;
+      sonic._writingBuf = sonic._writingBuf || sonic._bufs.shift();
+      if (sonic.sync) {
+        try {
+          const written = fs4.writeSync(sonic.fd, sonic._writingBuf, "utf8");
+          release(null, written);
+        } catch (err) {
+          release(err);
+        }
+      } else {
+        fs4.write(sonic.fd, sonic._writingBuf, "utf8", release);
+      }
+    }
+    function actualClose(sonic) {
+      if (sonic.fd === -1) {
+        sonic.once("ready", actualClose.bind(null, sonic));
+        return;
+      }
+      fs4.close(sonic.fd, (err) => {
+        if (err) {
+          sonic.emit("error", err);
+          return;
+        }
+        if (sonic._ending && !sonic._writing) {
+          sonic.emit("finish");
+        }
+        sonic.emit("close");
+      });
+      sonic.destroyed = true;
+      sonic._bufs = [];
+    }
+    SonicBoom.SonicBoom = SonicBoom;
+    SonicBoom.default = SonicBoom;
+    module2.exports = SonicBoom;
+  }
+});
+
+// ../../node_modules/pino/lib/deprecations.js
+var require_deprecations2 = __commonJS({
+  "../../node_modules/pino/lib/deprecations.js"(exports, module2) {
+    "use strict";
+    var warning = require_fastify_warning()();
+    module2.exports = warning;
+    var warnName = "PinoWarning";
+    warning.create(warnName, "PINODEP008", "prettyPrint is deprecated, look at https://github.com/pinojs/pino-pretty for alternatives.");
+    warning.create(warnName, "PINODEP009", "The use of pino.final is discouraged in Node.js v14+ and not required. It will be removed in the next major version");
+  }
+});
+
+// ../../node_modules/on-exit-leak-free/index.js
+var require_on_exit_leak_free = __commonJS({
+  "../../node_modules/on-exit-leak-free/index.js"(exports, module2) {
+    "use strict";
+    function genWrap(wraps, ref, fn, event) {
+      function wrap() {
+        const obj = ref.deref();
+        if (obj !== void 0) {
+          fn(obj, event);
+        }
+      }
+      wraps[event] = wrap;
+      process.once(event, wrap);
+    }
+    var registry = new FinalizationRegistry(clear);
+    var map = new WeakMap();
+    function clear(wraps) {
+      process.removeListener("exit", wraps.exit);
+      process.removeListener("beforeExit", wraps.beforeExit);
+    }
+    function register(obj, fn) {
+      if (obj === void 0) {
+        throw new Error("the object can't be undefined");
+      }
+      const ref = new WeakRef(obj);
+      const wraps = {};
+      map.set(obj, wraps);
+      registry.register(obj, wraps);
+      genWrap(wraps, ref, fn, "exit");
+      genWrap(wraps, ref, fn, "beforeExit");
+    }
+    function unregister(obj) {
+      const wraps = map.get(obj);
+      map.delete(obj);
+      if (wraps) {
+        clear(wraps);
+      }
+      registry.unregister(obj);
+    }
+    module2.exports = {
+      register,
+      unregister
+    };
+  }
+});
+
+// ../../node_modules/thread-stream/lib/wait.js
+var require_wait = __commonJS({
+  "../../node_modules/thread-stream/lib/wait.js"(exports, module2) {
+    "use strict";
+    var MAX_TIMEOUT = 1e3;
+    function wait(state, index, expected, timeout, done) {
+      const max = Date.now() + timeout;
+      let current = Atomics.load(state, index);
+      if (current === expected) {
+        done(null, "ok");
+        return;
+      }
+      let prior = current;
+      const check = (backoff) => {
+        if (Date.now() > max) {
+          done(null, "timed-out");
+        } else {
+          setTimeout(() => {
+            prior = current;
+            current = Atomics.load(state, index);
+            if (current === prior) {
+              check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : backoff * 2);
+            } else {
+              if (current === expected)
+                done(null, "ok");
+              else
+                done(null, "not-equal");
+            }
+          }, backoff);
+        }
+      };
+      check(1);
+    }
+    function waitDiff(state, index, expected, timeout, done) {
+      const max = Date.now() + timeout;
+      let current = Atomics.load(state, index);
+      if (current !== expected) {
+        done(null, "ok");
+        return;
+      }
+      const check = (backoff) => {
+        if (Date.now() > max) {
+          done(null, "timed-out");
+        } else {
+          setTimeout(() => {
+            current = Atomics.load(state, index);
+            if (current !== expected) {
+              done(null, "ok");
+            } else {
+              check(backoff >= MAX_TIMEOUT ? MAX_TIMEOUT : backoff * 2);
+            }
+          }, backoff);
+        }
+      };
+      check(1);
+    }
+    module2.exports = { wait, waitDiff };
+  }
+});
+
+// ../../node_modules/thread-stream/lib/indexes.js
+var require_indexes = __commonJS({
+  "../../node_modules/thread-stream/lib/indexes.js"(exports, module2) {
+    "use strict";
+    var WRITE_INDEX = 4;
+    var READ_INDEX = 8;
+    module2.exports = {
+      WRITE_INDEX,
+      READ_INDEX
+    };
+  }
+});
+
+// ../../node_modules/thread-stream/index.js
+var require_thread_stream = __commonJS({
+  "../../node_modules/thread-stream/index.js"(exports, module2) {
+    "use strict";
+    var { EventEmitter } = require("events");
+    var { Worker } = require("worker_threads");
+    var { join: join2 } = require("path");
+    var { pathToFileURL } = require("url");
+    var { wait } = require_wait();
+    var {
+      WRITE_INDEX,
+      READ_INDEX
+    } = require_indexes();
+    var buffer = require("buffer");
+    var assert = require("assert");
+    var kImpl = Symbol("kImpl");
+    var MAX_STRING = buffer.constants.MAX_STRING_LENGTH;
+    var FakeWeakRef = class {
+      constructor(value) {
+        this._value = value;
+      }
+      deref() {
+        return this._value;
+      }
+    };
+    var FinalizationRegistry2 = global.FinalizationRegistry || class FakeFinalizationRegistry {
+      register() {
+      }
+      unregister() {
+      }
+    };
+    var WeakRef2 = global.WeakRef || FakeWeakRef;
+    var registry = new FinalizationRegistry2((worker) => {
+      if (worker.exited) {
+        return;
+      }
+      worker.terminate();
+    });
+    function createWorker(stream, opts) {
+      const { filename, workerData } = opts;
+      const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join2(__dirname, "lib", "worker.js");
+      const worker = new Worker(toExecute, {
+        ...opts.workerOpts,
+        workerData: {
+          filename: filename.indexOf("file://") === 0 ? filename : pathToFileURL(filename).href,
+          dataBuf: stream[kImpl].dataBuf,
+          stateBuf: stream[kImpl].stateBuf,
+          workerData
+        }
+      });
+      worker.stream = new FakeWeakRef(stream);
+      worker.on("message", onWorkerMessage);
+      worker.on("exit", onWorkerExit);
+      registry.register(stream, worker);
+      return worker;
+    }
+    function drain(stream) {
+      assert(!stream[kImpl].sync);
+      if (stream[kImpl].needDrain) {
+        stream[kImpl].needDrain = false;
+        stream.emit("drain");
+      }
+    }
+    function nextFlush(stream) {
+      const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+      let leftover = stream[kImpl].data.length - writeIndex;
+      if (leftover > 0) {
+        if (stream[kImpl].buf.length === 0) {
+          stream[kImpl].flushing = false;
+          if (stream[kImpl].ending) {
+            end(stream);
+          } else if (stream[kImpl].needDrain) {
+            process.nextTick(drain, stream);
+          }
+          return;
+        }
+        let toWrite = stream[kImpl].buf.slice(0, leftover);
+        let toWriteBytes = Buffer.byteLength(toWrite);
+        if (toWriteBytes <= leftover) {
+          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+          write(stream, toWrite, nextFlush.bind(null, stream));
+        } else {
+          stream.flush(() => {
+            Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+            Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+            while (toWriteBytes > stream[kImpl].buf.length) {
+              leftover = leftover / 2;
+              toWrite = stream[kImpl].buf.slice(0, leftover);
+              toWriteBytes = Buffer.byteLength(toWrite);
+            }
+            stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+            write(stream, toWrite, nextFlush.bind(null, stream));
+          });
+        }
+      } else if (leftover === 0) {
+        if (writeIndex === 0 && stream[kImpl].buf.length === 0) {
+          return;
+        }
+        stream.flush(() => {
+          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+          nextFlush(stream);
+        });
+      } else {
+        throw new Error("overwritten");
+      }
+    }
+    function onWorkerMessage(msg) {
+      const stream = this.stream.deref();
+      if (stream === void 0) {
+        this.exited = true;
+        this.terminate();
+        return;
+      }
+      switch (msg.code) {
+        case "READY":
+          this.stream = new WeakRef2(stream);
+          stream.flush(() => {
+            stream[kImpl].ready = true;
+            stream.emit("ready");
+          });
+          break;
+        case "ERROR":
+          destroy(stream, msg.err);
+          break;
+        default:
+          throw new Error("this should not happen: " + msg.code);
+      }
+    }
+    function onWorkerExit(code) {
+      const stream = this.stream.deref();
+      if (stream === void 0) {
+        return;
+      }
+      registry.unregister(stream);
+      stream.worker.exited = true;
+      stream.worker.off("exit", onWorkerExit);
+      destroy(stream, code !== 0 ? new Error("The worker thread exited") : null);
+    }
+    var ThreadStream = class extends EventEmitter {
+      constructor(opts = {}) {
+        super();
+        if (opts.bufferSize < 4) {
+          throw new Error("bufferSize must at least fit a 4-byte utf-8 char");
+        }
+        this[kImpl] = {};
+        this[kImpl].stateBuf = new SharedArrayBuffer(128);
+        this[kImpl].state = new Int32Array(this[kImpl].stateBuf);
+        this[kImpl].dataBuf = new SharedArrayBuffer(opts.bufferSize || 4 * 1024 * 1024);
+        this[kImpl].data = Buffer.from(this[kImpl].dataBuf);
+        this[kImpl].sync = opts.sync || false;
+        this[kImpl].ending = false;
+        this[kImpl].ended = false;
+        this[kImpl].needDrain = false;
+        this[kImpl].destroyed = false;
+        this[kImpl].flushing = false;
+        this[kImpl].ready = false;
+        this[kImpl].finished = false;
+        this[kImpl].errored = null;
+        this[kImpl].closed = false;
+        this[kImpl].buf = "";
+        this.worker = createWorker(this, opts);
+      }
+      write(data) {
+        if (this[kImpl].destroyed) {
+          throw new Error("the worker has exited");
+        }
+        if (this[kImpl].ending) {
+          throw new Error("the worker is ending");
+        }
+        if (this[kImpl].flushing && this[kImpl].buf.length + data.length >= MAX_STRING) {
+          try {
+            writeSync(this);
+            this[kImpl].flushing = true;
+          } catch (err) {
+            destroy(this, err);
+            return false;
+          }
+        }
+        this[kImpl].buf += data;
+        if (this[kImpl].sync) {
+          try {
+            writeSync(this);
+            return true;
+          } catch (err) {
+            destroy(this, err);
+            return false;
+          }
+        }
+        if (!this[kImpl].flushing) {
+          this[kImpl].flushing = true;
+          setImmediate(nextFlush, this);
+        }
+        this[kImpl].needDrain = this[kImpl].data.length - this[kImpl].buf.length - Atomics.load(this[kImpl].state, WRITE_INDEX) <= 0;
+        return !this[kImpl].needDrain;
+      }
+      end() {
+        if (this[kImpl].destroyed) {
+          throw new Error("the worker has exited");
+        }
+        this[kImpl].ending = true;
+        end(this);
+      }
+      flush(cb) {
+        if (this[kImpl].destroyed) {
+          throw new Error("the worker has exited");
+        }
+        const writeIndex = Atomics.load(this[kImpl].state, WRITE_INDEX);
+        wait(this[kImpl].state, READ_INDEX, writeIndex, Infinity, (err, res) => {
+          if (err) {
+            destroy(this, err);
+            process.nextTick(cb, err);
+            return;
+          }
+          if (res === "not-equal") {
+            this.flush(cb);
+            return;
+          }
+          process.nextTick(cb);
+        });
+      }
+      flushSync() {
+        if (this[kImpl].destroyed) {
+          throw new Error("the worker has exited");
+        }
+        writeSync(this);
+        flushSync(this);
+      }
+      unref() {
+        this.worker.unref();
+      }
+      ref() {
+        this.worker.ref();
+      }
+      get ready() {
+        return this[kImpl].ready;
+      }
+      get destroyed() {
+        return this[kImpl].destroyed;
+      }
+      get closed() {
+        return this[kImpl].closed;
+      }
+      get writable() {
+        return !this[kImpl].destroyed && !this[kImpl].ending;
+      }
+      get writableEnded() {
+        return this[kImpl].ending;
+      }
+      get writableFinished() {
+        return this[kImpl].finished;
+      }
+      get writableNeedDrain() {
+        return this[kImpl].needDrain;
+      }
+      get writableObjectMode() {
+        return false;
+      }
+      get writableErrored() {
+        return this[kImpl].errored;
+      }
+    };
+    function destroy(stream, err) {
+      if (stream[kImpl].destroyed) {
+        return;
+      }
+      stream[kImpl].destroyed = true;
+      if (err) {
+        stream[kImpl].errored = err;
+        stream.emit("error", err);
+      }
+      if (!stream.worker.exited) {
+        stream.worker.terminate().catch(() => {
+        }).then(() => {
+          stream[kImpl].closed = true;
+          stream.emit("close");
+        });
       } else {
-        res = JSON.stringify(obj, replaceGetterValues(replacer), spacer);
+        setImmediate(() => {
+          stream[kImpl].closed = true;
+          stream.emit("close");
+        });
       }
-      while (arr.length !== 0) {
-        var part = arr.pop();
-        if (part.length === 4) {
-          Object.defineProperty(part[0], part[1], part[3]);
-        } else {
-          part[0][part[1]] = part[2];
-        }
+    }
+    function write(stream, data, cb) {
+      const current = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+      const length = Buffer.byteLength(data);
+      stream[kImpl].data.write(data, current);
+      Atomics.store(stream[kImpl].state, WRITE_INDEX, current + length);
+      Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+      cb();
+      return true;
+    }
+    function end(stream) {
+      if (stream[kImpl].ended || !stream[kImpl].ending || stream[kImpl].flushing) {
+        return;
+      }
+      stream[kImpl].ended = true;
+      try {
+        stream.flushSync();
+        let readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+        Atomics.store(stream[kImpl].state, WRITE_INDEX, -1);
+        Atomics.notify(stream[kImpl].state, WRITE_INDEX);
+        let spins = 0;
+        while (readIndex !== -1) {
+          Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1e3);
+          readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+          if (readIndex === -2) {
+            throw new Error("end() failed");
+          }
+          if (++spins === 10) {
+            throw new Error("end() took too long (10s)");
+          }
+        }
+        process.nextTick(() => {
+          stream[kImpl].finished = true;
+          stream.emit("finish");
+        });
+      } catch (err) {
+        destroy(stream, err);
       }
-      return res;
     }
-    function decirc(val, k, stack, parent) {
-      var i;
-      if (typeof val === "object" && val !== null) {
-        for (i = 0; i < stack.length; i++) {
-          if (stack[i] === val) {
-            var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
-            if (propertyDescriptor.get !== void 0) {
-              if (propertyDescriptor.configurable) {
-                Object.defineProperty(parent, k, { value: "[Circular]" });
-                arr.push([parent, k, val, propertyDescriptor]);
-              } else {
-                replacerStack.push([val, k]);
-              }
-            } else {
-              parent[k] = "[Circular]";
-              arr.push([parent, k, val]);
-            }
-            return;
-          }
+    function writeSync(stream) {
+      const cb = () => {
+        if (stream[kImpl].ending) {
+          end(stream);
+        } else if (stream[kImpl].needDrain) {
+          process.nextTick(drain, stream);
         }
-        stack.push(val);
-        if (Array.isArray(val)) {
-          for (i = 0; i < val.length; i++) {
-            decirc(val[i], i, stack, val);
-          }
+      };
+      stream[kImpl].flushing = false;
+      while (stream[kImpl].buf.length !== 0) {
+        const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+        let leftover = stream[kImpl].data.length - writeIndex;
+        if (leftover === 0) {
+          flushSync(stream);
+          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+          continue;
+        } else if (leftover < 0) {
+          throw new Error("overwritten");
+        }
+        let toWrite = stream[kImpl].buf.slice(0, leftover);
+        let toWriteBytes = Buffer.byteLength(toWrite);
+        if (toWriteBytes <= leftover) {
+          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+          write(stream, toWrite, cb);
         } else {
-          var keys = Object.keys(val);
-          for (i = 0; i < keys.length; i++) {
-            var key = keys[i];
-            decirc(val[key], key, stack, val);
+          flushSync(stream);
+          Atomics.store(stream[kImpl].state, READ_INDEX, 0);
+          Atomics.store(stream[kImpl].state, WRITE_INDEX, 0);
+          while (toWriteBytes > stream[kImpl].buf.length) {
+            leftover = leftover / 2;
+            toWrite = stream[kImpl].buf.slice(0, leftover);
+            toWriteBytes = Buffer.byteLength(toWrite);
           }
+          stream[kImpl].buf = stream[kImpl].buf.slice(leftover);
+          write(stream, toWrite, cb);
         }
-        stack.pop();
       }
     }
-    function compareFunction(a, b) {
-      if (a < b) {
-        return -1;
+    function flushSync(stream) {
+      if (stream[kImpl].flushing) {
+        throw new Error("unable to flush while flushing");
       }
-      if (a > b) {
-        return 1;
+      const writeIndex = Atomics.load(stream[kImpl].state, WRITE_INDEX);
+      let spins = 0;
+      while (true) {
+        const readIndex = Atomics.load(stream[kImpl].state, READ_INDEX);
+        if (readIndex === -2) {
+          throw new Error("_flushSync failed");
+        }
+        if (readIndex !== writeIndex) {
+          Atomics.wait(stream[kImpl].state, READ_INDEX, readIndex, 1e3);
+        } else {
+          break;
+        }
+        if (++spins === 10) {
+          throw new Error("_flushSync took too long (10s)");
+        }
       }
-      return 0;
     }
-    function deterministicStringify(obj, replacer, spacer) {
-      var tmp = deterministicDecirc(obj, "", [], void 0) || obj;
-      var res;
-      if (replacerStack.length === 0) {
-        res = JSON.stringify(tmp, replacer, spacer);
+    module2.exports = ThreadStream;
+  }
+});
+
+// ../../node_modules/pino/lib/transport.js
+var require_transport = __commonJS({
+  "../../node_modules/pino/lib/transport.js"(exports, module2) {
+    "use strict";
+    var { createRequire } = require("module");
+    var getCaller = require_get_caller_file();
+    var { join: join2, isAbsolute } = require("path");
+    var onExit;
+    if (global.WeakRef && global.WeakMap && global.FinalizationRegistry) {
+      onExit = require_on_exit_leak_free();
+    }
+    var ThreadStream = require_thread_stream();
+    function setupOnExit(stream) {
+      if (onExit) {
+        onExit.register(stream, autoEnd);
+        stream.on("close", function() {
+          onExit.unregister(stream);
+        });
       } else {
-        res = JSON.stringify(tmp, replaceGetterValues(replacer), spacer);
-      }
-      while (arr.length !== 0) {
-        var part = arr.pop();
-        if (part.length === 4) {
-          Object.defineProperty(part[0], part[1], part[3]);
-        } else {
-          part[0][part[1]] = part[2];
-        }
+        const fn = autoEnd.bind(null, stream);
+        process.once("beforeExit", fn);
+        process.once("exit", fn);
+        stream.on("close", function() {
+          process.removeListener("beforeExit", fn);
+          process.removeListener("exit", fn);
+        });
       }
-      return res;
     }
-    function deterministicDecirc(val, k, stack, parent) {
-      var i;
-      if (typeof val === "object" && val !== null) {
-        for (i = 0; i < stack.length; i++) {
-          if (stack[i] === val) {
-            var propertyDescriptor = Object.getOwnPropertyDescriptor(parent, k);
-            if (propertyDescriptor.get !== void 0) {
-              if (propertyDescriptor.configurable) {
-                Object.defineProperty(parent, k, { value: "[Circular]" });
-                arr.push([parent, k, val, propertyDescriptor]);
-              } else {
-                replacerStack.push([val, k]);
-              }
-            } else {
-              parent[k] = "[Circular]";
-              arr.push([parent, k, val]);
-            }
-            return;
-          }
+    function buildStream(filename, workerData, workerOpts) {
+      const stream = new ThreadStream({
+        filename,
+        workerData,
+        workerOpts
+      });
+      stream.on("ready", onReady);
+      stream.on("close", function() {
+        process.removeListener("exit", onExit2);
+      });
+      process.on("exit", onExit2);
+      function onReady() {
+        process.removeListener("exit", onExit2);
+        stream.unref();
+        if (workerOpts.autoEnd !== false) {
+          setupOnExit(stream);
         }
-        if (typeof val.toJSON === "function") {
+      }
+      function onExit2() {
+        if (stream.closed) {
           return;
         }
-        stack.push(val);
-        if (Array.isArray(val)) {
-          for (i = 0; i < val.length; i++) {
-            deterministicDecirc(val[i], i, stack, val);
-          }
-        } else {
-          var tmp = {};
-          var keys = Object.keys(val).sort(compareFunction);
-          for (i = 0; i < keys.length; i++) {
-            var key = keys[i];
-            deterministicDecirc(val[key], key, stack, val);
-            tmp[key] = val[key];
-          }
-          if (parent !== void 0) {
-            arr.push([parent, k, val]);
-            parent[k] = tmp;
-          } else {
-            return tmp;
-          }
-        }
-        stack.pop();
+        stream.flushSync();
       }
+      return stream;
     }
-    function replaceGetterValues(replacer) {
-      replacer = replacer !== void 0 ? replacer : function(k, v) {
-        return v;
-      };
-      return function(key, val) {
-        if (replacerStack.length > 0) {
-          for (var i = 0; i < replacerStack.length; i++) {
-            var part = replacerStack[i];
-            if (part[1] === key && part[0] === val) {
-              val = "[Circular]";
-              replacerStack.splice(i, 1);
-              break;
-            }
-          }
+    function autoEnd(stream) {
+      stream.ref();
+      stream.flushSync();
+      stream.end();
+      stream.once("close", function() {
+        stream.unref();
+      });
+    }
+    function transport(fullOptions) {
+      const { pipeline: pipeline2, targets, options = {}, worker = {}, caller = getCaller() } = fullOptions;
+      const callerRequire = createRequire(caller);
+      const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
+      let target = fullOptions.target;
+      if (target && targets) {
+        throw new Error("only one of target or targets can be specified");
+      }
+      if (targets) {
+        target = bundlerOverrides["pino-worker"] || join2(__dirname, "worker.js");
+        options.targets = targets.map((dest) => {
+          return {
+            ...dest,
+            target: fixTarget(dest.target)
+          };
+        });
+      } else if (fullOptions.pipeline) {
+        target = bundlerOverrides["pino-pipeline-worker"] || join2(__dirname, "worker-pipeline.js");
+        options.targets = pipeline2.map((dest) => {
+          return {
+            ...dest,
+            target: fixTarget(dest.target)
+          };
+        });
+      }
+      return buildStream(fixTarget(target), options, worker);
+      function fixTarget(origin) {
+        origin = bundlerOverrides[origin] || origin;
+        if (isAbsolute(origin) || origin.indexOf("file://") === 0) {
+          return origin;
         }
-        return replacer.call(this, key, val);
-      };
+        switch (origin) {
+          case "pino/file":
+            return join2(__dirname, "..", "file.js");
+          default:
+            return callerRequire.resolve(origin);
+        }
+      }
     }
+    module2.exports = transport;
   }
 });
 
@@ -3582,9 +4696,9 @@ var require_tools2 = __commonJS({
   "../../node_modules/pino/lib/tools.js"(exports, module2) {
     "use strict";
     var format = require_quick_format_unescaped();
-    var { mapHttpRequest, mapHttpResponse } = require_pino_std_serializers();
-    var SonicBoom = require_sonic_boom();
-    var stringifySafe = require_fast_safe_stringify2();
+    var { mapHttpRequest, mapHttpResponse } = require_pino_std_serializers2();
+    var SonicBoom = require_sonic_boom2();
+    var warning = require_deprecations2();
     var {
       lsCacheSym,
       chindingsSym,
@@ -3595,14 +4709,18 @@ var require_tools2 = __commonJS({
       endSym,
       stringifiersSym,
       stringifySym,
+      stringifySafeSym,
       wildcardFirstSym,
       needsMetadataGsym,
       redactFmtSym,
       streamSym,
       nestedKeySym,
       formattersSym,
-      messageKeySym
+      messageKeySym,
+      nestedKeyStrSym
     } = require_symbols2();
+    var { isMainThread } = require("worker_threads");
+    var transport = require_transport();
     function noop() {
     }
     function genLog(level, hook) {
@@ -3621,8 +4739,6 @@ var require_tools2 = __commonJS({
               o = mapHttpResponse(o);
             }
           }
-          if (this[nestedKeySym])
-            o = { [this[nestedKeySym]]: o };
           let formatParams;
           if (msg === null && n.length === 0) {
             formatParams = [null];
@@ -3662,6 +4778,7 @@ var require_tools2 = __commonJS({
     }
     function asJson(obj, msg, num, time) {
       const stringify2 = this[stringifySym];
+      const stringifySafe = this[stringifySafeSym];
       const stringifiers = this[stringifiersSym];
       const end = this[endSym];
       const chindings = this[chindingsSym];
@@ -3675,10 +4792,8 @@ var require_tools2 = __commonJS({
       if (formatters.log) {
         obj = formatters.log(obj);
       }
-      if (msg !== void 0) {
-        obj[messageKey] = msg;
-      }
       const wildcardStringifier = stringifiers[wildcardFirstSym];
+      let propStr = "";
       for (const key in obj) {
         value = obj[key];
         if ((notHasOwnProperty || obj.hasOwnProperty(key)) && value !== void 0) {
@@ -3700,19 +4815,49 @@ var require_tools2 = __commonJS({
               value = (stringifier || asString)(value);
               break;
             default:
-              value = (stringifier || stringify2)(value);
+              value = (stringifier || stringify2)(value, stringifySafe);
           }
           if (value === void 0)
             continue;
-          data += ',"' + key + '":' + value;
+          propStr += ',"' + key + '":' + value;
         }
       }
-      return data + end;
+      let msgStr = "";
+      if (msg !== void 0) {
+        value = serializers[messageKey] ? serializers[messageKey](msg) : msg;
+        const stringifier = stringifiers[messageKey] || wildcardStringifier;
+        switch (typeof value) {
+          case "function":
+            break;
+          case "number":
+            if (Number.isFinite(value) === false) {
+              value = null;
+            }
+          case "boolean":
+            if (stringifier)
+              value = stringifier(value);
+            msgStr = ',"' + messageKey + '":' + value;
+            break;
+          case "string":
+            value = (stringifier || asString)(value);
+            msgStr = ',"' + messageKey + '":' + value;
+            break;
+          default:
+            value = (stringifier || stringify2)(value, stringifySafe);
+            msgStr = ',"' + messageKey + '":' + value;
+        }
+      }
+      if (this[nestedKeySym] && propStr) {
+        return data + this[nestedKeyStrSym] + propStr.slice(1) + "}" + msgStr + end;
+      } else {
+        return data + propStr + msgStr + end;
+      }
     }
     function asChindings(instance, bindings) {
       let value;
       let data = instance[chindingsSym];
       const stringify2 = instance[stringifySym];
+      const stringifySafe = instance[stringifySafeSym];
       const stringifiers = instance[stringifiersSym];
       const wildcardStringifier = stringifiers[wildcardFirstSym];
       const serializers = instance[serializersSym];
@@ -3723,7 +4868,7 @@ var require_tools2 = __commonJS({
         const valid = key !== "level" && key !== "serializers" && key !== "formatters" && key !== "customLevels" && bindings.hasOwnProperty(key) && value !== void 0;
         if (valid === true) {
           value = serializers[key] ? serializers[key](value) : value;
-          value = (stringifiers[key] || wildcardStringifier || stringify2)(value);
+          value = (stringifiers[key] || wildcardStringifier || stringify2)(value, stringifySafe);
           if (value === void 0)
             continue;
           data += ',"' + key + '":' + value;
@@ -3737,7 +4882,7 @@ var require_tools2 = __commonJS({
         return prettifierMetaWrapper(prettifier(opts), dest, opts);
       }
       try {
-        const prettyFactory = require("pino-pretty");
+        const prettyFactory = require("pino-pretty").prettyFactory;
         prettyFactory.asMetaWrapper = prettifierMetaWrapper;
         return prettifierMetaWrapper(prettyFactory(opts), dest, opts);
       } catch (e) {
@@ -3787,7 +4932,8 @@ var require_tools2 = __commonJS({
           const lastLogger = this.lastLogger;
           const chindings = this.chindings();
           let time = this.lastTime;
-          if (time.match(/^\d+/)) {
+          if (typeof time === "number") {
+          } else if (time.match(/^\d+/)) {
             time = parseInt(time);
           } else {
             time = time.slice(1, -1);
@@ -3834,6 +4980,9 @@ var require_tools2 = __commonJS({
     function buildSafeSonicBoom(opts) {
       const stream = new SonicBoom(opts);
       stream.on("error", filterBrokenPipe);
+      if (!opts.sync && isMainThread) {
+        setupOnExit(stream);
+      }
       return stream;
       function filterBrokenPipe(err) {
         if (err.code === "EPIPE") {
@@ -3847,21 +4996,46 @@ var require_tools2 = __commonJS({
         stream.emit("error", err);
       }
     }
+    function setupOnExit(stream) {
+      if (global.WeakRef && global.WeakMap && global.FinalizationRegistry) {
+        const onExit = require_on_exit_leak_free();
+        onExit.register(stream, autoEnd);
+        stream.on("close", function() {
+          onExit.unregister(stream);
+        });
+      }
+    }
+    function autoEnd(stream, eventName) {
+      if (stream.destroyed) {
+        return;
+      }
+      if (eventName === "beforeExit") {
+        stream.flush();
+        stream.on("drain", function() {
+          stream.end();
+        });
+      } else {
+        stream.flushSync();
+      }
+    }
     function createArgsNormalizer(defaultOptions) {
-      return function normalizeArgs(instance, opts = {}, stream) {
+      return function normalizeArgs(instance, caller, opts = {}, stream) {
         if (typeof opts === "string") {
           stream = buildSafeSonicBoom({ dest: opts, sync: true });
           opts = {};
         } else if (typeof stream === "string") {
+          if (opts && opts.transport) {
+            throw Error("only one of option.transport or stream can be specified");
+          }
           stream = buildSafeSonicBoom({ dest: stream, sync: true });
         } else if (opts instanceof SonicBoom || opts.writable || opts._writableState) {
           stream = opts;
-          opts = null;
+          opts = {};
+        } else if (opts.transport) {
+          stream = transport({ caller, ...opts.transport });
         }
         opts = Object.assign({}, defaultOptions, opts);
-        if ("extreme" in opts) {
-          throw Error("The extreme option has been removed, use pino.destination({ sync: false }) instead");
-        }
+        opts.serializers = Object.assign({}, defaultOptions.serializers, opts.serializers);
         if ("onTerminated" in opts) {
           throw Error("The onTerminated option has been removed, use pino.final instead");
         }
@@ -3878,6 +5052,7 @@ var require_tools2 = __commonJS({
           stream = buildSafeSonicBoom({ fd: stream.fd, sync: true });
         }
         if (prettyPrint) {
+          warning.emit("PINODEP008");
           const prettyOpts = Object.assign({ messageKey }, prettyPrint);
           stream = getPrettyStream(prettyOpts, prettifier, stream, instance);
         }
@@ -3885,6 +5060,9 @@ var require_tools2 = __commonJS({
       };
     }
     function final(logger, handler2) {
+      const major = Number(process.versions.node.split(".")[0]);
+      if (major >= 14)
+        warning.emit("PINODEP009");
       if (typeof logger === "undefined" || typeof logger.child !== "function") {
         throw Error("expected a pino logger instance");
       }
@@ -3908,6 +5086,10 @@ var require_tools2 = __commonJS({
         }
       });
       if (!hasHandler) {
+        try {
+          stream.flushSync();
+        } catch {
+        }
         return finalLogger;
       }
       return (err = null, ...args) => {
@@ -3918,11 +5100,16 @@ var require_tools2 = __commonJS({
         return handler2(err, finalLogger, ...args);
       };
     }
-    function stringify(obj) {
+    function stringify(obj, stringifySafeFn) {
       try {
         return JSON.stringify(obj);
       } catch (_) {
-        return stringifySafe(obj);
+        try {
+          const stringify2 = stringifySafeFn || this[stringifySafeSym];
+          return stringify2(obj);
+        } catch (_2) {
+          return '"[unable to serialize, circular reference is too complex to analyze]"';
+        }
       }
     }
     function buildFormatters(level, bindings, log) {
@@ -3941,6 +5128,13 @@ var require_tools2 = __commonJS({
         dest.lastLogger = that.lastLogger;
       }
     }
+    function normalizeDestFileDescriptor(destination) {
+      const fd = Number(destination);
+      if (typeof destination === "string" && Number.isFinite(fd)) {
+        return fd;
+      }
+      return destination;
+    }
     module2.exports = {
       noop,
       buildSafeSonicBoom,
@@ -3951,7 +5145,8 @@ var require_tools2 = __commonJS({
       createArgsNormalizer,
       final,
       stringify,
-      buildFormatters
+      buildFormatters,
+      normalizeDestFileDescriptor
     };
   }
 });
@@ -3960,7 +5155,6 @@ var require_tools2 = __commonJS({
 var require_levels2 = __commonJS({
   "../../node_modules/pino/lib/levels.js"(exports, module2) {
     "use strict";
-    var flatstr = require_flatstr();
     var {
       lsCacheSym,
       levelValSym,
@@ -4003,7 +5197,7 @@ var require_levels2 = __commonJS({
       return o;
     }, {});
     var initialLsCache = Object.keys(nums).reduce((o, k) => {
-      o[k] = flatstr('{"level":' + Number(k));
+      o[k] = '{"level":' + Number(k);
       return o;
     }, {});
     function genLsCache(instance) {
@@ -4105,6 +5299,7 @@ var require_levels2 = __commonJS({
       setLevel,
       isLevelEnabled,
       mappings,
+      levels,
       assertNoLevelCollisions,
       assertDefaultLevelFound
     };
@@ -4116,12 +5311,16 @@ var require_package2 = __commonJS({
   "../../node_modules/pino/package.json"(exports, module2) {
     module2.exports = {
       name: "pino",
-      version: "6.11.3",
+      version: "7.5.0",
       description: "super fast, all natural json logger",
       main: "pino.js",
+      type: "commonjs",
+      types: "pino.d.ts",
       browser: "./browser.js",
       files: [
         "pino.js",
+        "file.js",
+        "pino.d.ts",
         "bin.js",
         "browser.js",
         "pretty.js",
@@ -4135,8 +5334,11 @@ var require_package2 = __commonJS({
         docs: "docsify serve",
         "browser-test": "airtap --local 8080 test/browser*test.js",
         lint: "eslint .",
-        test: "npm run lint && tap --100 test/*test.js test/*/*test.js",
-        "test-ci": "npm run lint && tap test/*test.js test/*/*test.js --coverage-report=lcovonly",
+        test: "npm run lint && tap test/*test.js test/*/*test.js && jest test/jest && npm run test-types",
+        "test-ci": "npm run lint && tap --no-check-coverage test/*test.js test/*/*test.js --coverage-report=lcovonly && npm run test-types",
+        "test-ci-pnpm": "pnpm run lint && tap --no-coverage --no-check-coverage test/*test.js test/*/*test.js && pnpm run test-types",
+        "test-ci-yarn-pnp": "yarn run lint && tap --no-check-coverage test/*test.js test/*/*test.js --coverage-report=lcovonly",
+        "test-types": "tsc && tsd && ts-node test/types/pino.ts",
         "cov-ui": "tap --coverage-report=html test/*test.js test/*/*test.js",
         bench: "node benchmarks/utils/runbench all",
         "bench-basic": "node benchmarks/utils/runbench basic",
@@ -4176,42 +5378,55 @@ var require_package2 = __commonJS({
       },
       homepage: "http://getpino.io",
       devDependencies: {
+        "@types/node": "^16.11.0",
         airtap: "4.0.3",
         benchmark: "^2.1.4",
         bole: "^4.0.0",
         bunyan: "^1.8.14",
         "docsify-cli": "^4.4.1",
         eslint: "^7.17.0",
-        "eslint-config-standard": "^16.0.2",
+        "eslint-config-standard": "^16.0.3",
         "eslint-plugin-import": "^2.22.1",
         "eslint-plugin-node": "^11.1.0",
-        "eslint-plugin-promise": "^4.2.1",
+        "eslint-plugin-promise": "^5.1.0",
         execa: "^5.0.0",
         fastbench: "^1.0.1",
         "flush-write-stream": "^2.0.0",
         "import-fresh": "^3.2.1",
+        jest: "^27.3.1",
         log: "^6.0.0",
         loglevel: "^1.6.7",
-        "pino-pretty": "^4.1.0",
+        "pino-pretty": "^v7.1.0",
         "pre-commit": "^1.2.2",
         proxyquire: "^2.1.3",
         pump: "^3.0.0",
         semver: "^7.0.0",
-        split2: "^3.1.1",
+        split2: "^4.0.0",
         steed: "^1.1.3",
         "strip-ansi": "^6.0.0",
         tap: "^15.0.1",
         tape: "^5.0.0",
         through2: "^4.0.0",
+        "ts-node": "^10.3.0",
+        tsd: "^0.19.0",
+        typescript: "^4.4.4",
         winston: "^3.3.3"
       },
       dependencies: {
         "fast-redact": "^3.0.0",
-        "fast-safe-stringify": "^2.0.7",
-        flatstr: "^1.0.12",
-        "pino-std-serializers": "^3.1.0",
+        "fastify-warning": "^0.2.0",
+        "get-caller-file": "^2.0.5",
+        "on-exit-leak-free": "^0.2.0",
+        "pino-abstract-transport": "v0.5.0",
+        "pino-std-serializers": "^4.0.0",
         "quick-format-unescaped": "^4.0.3",
-        "sonic-boom": "^1.0.2"
+        "real-require": "^0.1.0",
+        "safe-stable-stringify": "^2.1.0",
+        "sonic-boom": "^2.2.1",
+        "thread-stream": "^0.13.0"
+      },
+      tsd: {
+        directory: "test/types"
       }
     };
   }
@@ -4231,8 +5446,6 @@ var require_proto2 = __commonJS({
   "../../node_modules/pino/lib/proto.js"(exports, module2) {
     "use strict";
     var { EventEmitter } = require("events");
-    var SonicBoom = require_sonic_boom();
-    var flatstr = require_flatstr();
     var {
       lsCacheSym,
       levelValSym,
@@ -4249,7 +5462,11 @@ var require_proto2 = __commonJS({
       serializersSym,
       formattersSym,
       useOnlyCustomLevelsSym,
-      needsMetadataGsym
+      needsMetadataGsym,
+      redactFmtSym,
+      stringifySym,
+      formatOptsSym,
+      stringifiersSym
     } = require_symbols2();
     var {
       getLevel,
@@ -4263,11 +5480,13 @@ var require_proto2 = __commonJS({
     var {
       asChindings,
       asJson,
-      buildFormatters
+      buildFormatters,
+      stringify
     } = require_tools2();
     var {
       version: version2
     } = require_meta2();
+    var redaction = require_redaction2();
     var constructor = class Pino {
     };
     var prototype = {
@@ -4301,14 +5520,15 @@ var require_proto2 = __commonJS({
       return Object.create(prototype);
     };
     var resetChildingsFormatter = (bindings2) => bindings2;
-    function child(bindings2) {
+    function child(bindings2, options) {
       if (!bindings2) {
         throw Error("missing bindings for child Pino");
       }
+      options = options || {};
       const serializers = this[serializersSym];
       const formatters = this[formattersSym];
       const instance = Object.create(this);
-      if (bindings2.hasOwnProperty("serializers") === true) {
+      if (options.hasOwnProperty("serializers") === true) {
         instance[serializersSym] = Object.create(null);
         for (const k in serializers) {
           instance[serializersSym][k] = serializers[k];
@@ -4318,29 +5538,37 @@ var require_proto2 = __commonJS({
           const ks = parentSymbols[i];
           instance[serializersSym][ks] = serializers[ks];
         }
-        for (const bk in bindings2.serializers) {
-          instance[serializersSym][bk] = bindings2.serializers[bk];
+        for (const bk in options.serializers) {
+          instance[serializersSym][bk] = options.serializers[bk];
         }
-        const bindingsSymbols = Object.getOwnPropertySymbols(bindings2.serializers);
+        const bindingsSymbols = Object.getOwnPropertySymbols(options.serializers);
         for (var bi = 0; bi < bindingsSymbols.length; bi++) {
           const bks = bindingsSymbols[bi];
-          instance[serializersSym][bks] = bindings2.serializers[bks];
+          instance[serializersSym][bks] = options.serializers[bks];
         }
       } else
         instance[serializersSym] = serializers;
-      if (bindings2.hasOwnProperty("formatters")) {
-        const { level, bindings: chindings, log } = bindings2.formatters;
+      if (options.hasOwnProperty("formatters")) {
+        const { level, bindings: chindings, log } = options.formatters;
         instance[formattersSym] = buildFormatters(level || formatters.level, chindings || resetChildingsFormatter, log || formatters.log);
       } else {
         instance[formattersSym] = buildFormatters(formatters.level, resetChildingsFormatter, formatters.log);
       }
-      if (bindings2.hasOwnProperty("customLevels") === true) {
-        assertNoLevelCollisions(this.levels, bindings2.customLevels);
-        instance.levels = mappings(bindings2.customLevels, instance[useOnlyCustomLevelsSym]);
+      if (options.hasOwnProperty("customLevels") === true) {
+        assertNoLevelCollisions(this.levels, options.customLevels);
+        instance.levels = mappings(options.customLevels, instance[useOnlyCustomLevelsSym]);
         genLsCache(instance);
       }
+      if (typeof options.redact === "object" && options.redact !== null || Array.isArray(options.redact)) {
+        instance.redact = options.redact;
+        const stringifiers = redaction(instance.redact, stringify);
+        const formatOpts = { stringify: stringifiers[redactFmtSym] };
+        instance[stringifySym] = stringify;
+        instance[stringifiersSym] = stringifiers;
+        instance[formatOptsSym] = formatOpts;
+      }
       instance[chindingsSym] = asChindings(instance, bindings2);
-      const childLevel = bindings2.level || this.level;
+      const childLevel = options.level || this.level;
       instance[setLevelSym](childLevel);
       return instance;
     }
@@ -4360,20 +5588,18 @@ var require_proto2 = __commonJS({
     function write(_obj, msg, num) {
       const t = this[timeSym]();
       const mixin = this[mixinSym];
-      const objError = _obj instanceof Error;
       let obj;
-      if (_obj === void 0 || _obj === null) {
-        obj = mixin ? mixin({}) : {};
-      } else {
-        obj = Object.assign(mixin ? mixin(_obj) : {}, _obj);
-        if (!msg && objError) {
+      if (_obj === void 0 || _obj === null) {
+        obj = mixin ? mixin({}) : {};
+      } else if (_obj instanceof Error) {
+        obj = Object.assign(mixin ? mixin({}) : {}, { err: _obj });
+        if (msg === void 0) {
           msg = _obj.message;
         }
-        if (objError) {
-          obj.stack = _obj.stack;
-          if (!obj.type) {
-            obj.type = "Error";
-          }
+      } else {
+        obj = Object.assign(mixin ? mixin({}) : {}, _obj);
+        if (msg === void 0 && _obj.err) {
+          msg = _obj.err.message;
         }
       }
       const s = this[asJsonSym](obj, msg, num, t);
@@ -4385,16 +5611,788 @@ var require_proto2 = __commonJS({
         stream.lastTime = t.slice(this[timeSliceIndexSym]);
         stream.lastLogger = this;
       }
-      if (stream instanceof SonicBoom)
-        stream.write(s);
-      else
-        stream.write(flatstr(s));
+      stream.write(s);
+    }
+    function noop() {
     }
     function flush() {
       const stream = this[streamSym];
       if ("flush" in stream)
-        stream.flush();
+        stream.flush(noop);
+    }
+  }
+});
+
+// ../../node_modules/safe-stable-stringify/index.js
+var require_safe_stable_stringify = __commonJS({
+  "../../node_modules/safe-stable-stringify/index.js"(exports, module2) {
+    "use strict";
+    var stringify = configure2();
+    stringify.configure = configure2;
+    stringify.stringify = stringify;
+    stringify.default = stringify;
+    exports.stringify = stringify;
+    exports.configure = configure2;
+    module2.exports = stringify;
+    var strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/;
+    var strEscapeSequencesReplacer = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?<![\ud800-\udbff])[\udc00-\udfff]/g;
+    var meta = [
+      "\\u0000",
+      "\\u0001",
+      "\\u0002",
+      "\\u0003",
+      "\\u0004",
+      "\\u0005",
+      "\\u0006",
+      "\\u0007",
+      "\\b",
+      "\\t",
+      "\\n",
+      "\\u000b",
+      "\\f",
+      "\\r",
+      "\\u000e",
+      "\\u000f",
+      "\\u0010",
+      "\\u0011",
+      "\\u0012",
+      "\\u0013",
+      "\\u0014",
+      "\\u0015",
+      "\\u0016",
+      "\\u0017",
+      "\\u0018",
+      "\\u0019",
+      "\\u001a",
+      "\\u001b",
+      "\\u001c",
+      "\\u001d",
+      "\\u001e",
+      "\\u001f",
+      "",
+      "",
+      '\\"',
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "",
+      "\\\\"
+    ];
+    function escapeFn(str) {
+      const charCode = str.charCodeAt(0);
+      return meta.length > charCode ? meta[charCode] : `\\u${charCode.toString(16)}`;
+    }
+    function strEscape(str) {
+      if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) {
+        return str;
+      }
+      if (str.length > 100) {
+        return str.replace(strEscapeSequencesReplacer, escapeFn);
+      }
+      let result = "";
+      let last = 0;
+      for (let i = 0; i < str.length; i++) {
+        const point = str.charCodeAt(i);
+        if (point === 34 || point === 92 || point < 32) {
+          result += `${str.slice(last, i)}${meta[point]}`;
+          last = i + 1;
+        } else if (point >= 55296 && point <= 57343) {
+          if (point <= 56319 && i + 1 < str.length) {
+            const point2 = str.charCodeAt(i + 1);
+            if (point2 >= 56320 && point2 <= 57343) {
+              i++;
+              continue;
+            }
+          }
+          result += `${str.slice(last, i)}${`\\u${point.toString(16)}`}`;
+          last = i + 1;
+        }
+      }
+      result += str.slice(last);
+      return result;
+    }
+    function insertSort(array) {
+      if (array.length > 200) {
+        return array.sort();
+      }
+      for (let i = 1; i < array.length; i++) {
+        const currentValue = array[i];
+        let position = i;
+        while (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 Uint8Array())), Symbol.toStringTag).get;
+    function isTypedArrayWithEntries(value) {
+      return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
+    }
+    function stringifyTypedArray(array, separator, maximumBreadth) {
+      if (array.length < maximumBreadth) {
+        maximumBreadth = array.length;
+      }
+      const whitespace = separator === "," ? "" : " ";
+      let res = `"0":${whitespace}${array[0]}`;
+      for (let i = 1; i < maximumBreadth; i++) {
+        res += `${separator}"${i}":${whitespace}${array[i]}`;
+      }
+      return res;
+    }
+    function getCircularValueOption(options) {
+      if (options && Object.prototype.hasOwnProperty.call(options, "circularValue")) {
+        var 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 getBooleanOption(options, key) {
+      if (options && Object.prototype.hasOwnProperty.call(options, key)) {
+        var value = options[key];
+        if (typeof value !== "boolean") {
+          throw new TypeError(`The "${key}" argument must be of type boolean`);
+        }
+      }
+      return value === void 0 ? true : value;
+    }
+    function getPositiveIntegerOption(options, key) {
+      if (options && Object.prototype.hasOwnProperty.call(options, key)) {
+        var value = options[key];
+        if (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 ? Infinity : value;
+    }
+    function getItemCount(number) {
+      if (number === 1) {
+        return "1 item";
+      }
+      return `${number} items`;
+    }
+    function getUniqueReplacerSet(replacerArray) {
+      const replacerSet = new Set();
+      for (const value of replacerArray) {
+        if (typeof value === "string") {
+          replacerSet.add(value);
+        } else if (typeof value === "number") {
+          replacerSet.add(String(value));
+        }
+      }
+      return replacerSet;
+    }
+    function configure2(options) {
+      const circularValue = getCircularValueOption(options);
+      const bigint = getBooleanOption(options, "bigint");
+      const deterministic = getBooleanOption(options, "deterministic");
+      const maximumDepth = getPositiveIntegerOption(options, "maximumDepth");
+      const maximumBreadth = getPositiveIntegerOption(options, "maximumBreadth");
+      function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
+        let value = parent[key];
+        if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
+          value = value.toJSON(key);
+        }
+        value = replacer.call(parent, key, value);
+        switch (typeof value) {
+          case "string":
+            return `"${strEscape(value)}"`;
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            let res = "";
+            let join2 = ",";
+            const originalIndentation = indentation;
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              if (spacer !== "") {
+                indentation += spacer;
+                res += `
+${indentation}`;
+                join2 = `,
+${indentation}`;
+              }
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyFnReplacer(i, value, stack, replacer, spacer, indentation);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += join2;
+              }
+              const tmp = stringifyFnReplacer(i, value, stack, replacer, spacer, indentation);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              if (spacer !== "") {
+                res += `
+${originalIndentation}`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            let whitespace = "";
+            let separator = "";
+            if (spacer !== "") {
+              indentation += spacer;
+              join2 = `,
+${indentation}`;
+              whitespace = " ";
+            }
+            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (isTypedArrayWithEntries(value)) {
+              res += stringifyTypedArray(value, join2, maximumBreadth);
+              keys = keys.slice(value.length);
+              maximumPropertiesToStringify -= value.length;
+              separator = join2;
+            }
+            if (deterministic) {
+              keys = insertSort(keys);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}"${strEscape(key2)}":${whitespace}${tmp}`;
+                separator = join2;
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
+              separator = join2;
+            }
+            if (spacer !== "" && separator.length > 1) {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "bigint":
+            return bigint ? String(value) : void 0;
+        }
+      }
+      function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
+        if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
+          value = value.toJSON(key);
+        }
+        switch (typeof value) {
+          case "string":
+            return `"${strEscape(value)}"`;
+          case "object": {
+            if (value === null) {
+              return "null";
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            const originalIndentation = indentation;
+            let res = "";
+            let join2 = ",";
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              if (spacer !== "") {
+                indentation += spacer;
+                res += `
+${indentation}`;
+                join2 = `,
+${indentation}`;
+              }
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyArrayReplacer(i, value[i], stack, replacer, spacer, indentation);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += join2;
+              }
+              const tmp = stringifyArrayReplacer(i, value[i], stack, replacer, spacer, indentation);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              if (spacer !== "") {
+                res += `
+${originalIndentation}`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            if (replacer.size === 0) {
+              return "{}";
+            }
+            stack.push(value);
+            let whitespace = "";
+            if (spacer !== "") {
+              indentation += spacer;
+              join2 = `,
+${indentation}`;
+              whitespace = " ";
+            }
+            let separator = "";
+            for (const key2 of replacer) {
+              const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}"${strEscape(key2)}":${whitespace}${tmp}`;
+                separator = join2;
+              }
+            }
+            if (spacer !== "" && separator.length > 1) {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "bigint":
+            return bigint ? String(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") {
+              value = value.toJSON(key);
+              if (typeof value !== "object") {
+                return stringifyIndent(key, value, stack, spacer, indentation);
+              }
+              if (value === null) {
+                return "null";
+              }
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            const 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}`;
+              const join3 = `,
+${indentation}`;
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifyIndent(i, value[i], stack, spacer, indentation);
+                res2 += tmp2 !== void 0 ? tmp2 : "null";
+                res2 += join3;
+              }
+              const tmp = stringifyIndent(i, value[i], stack, spacer, indentation);
+              res2 += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res2 += `${join3}"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              res2 += `
+${originalIndentation}`;
+              stack.pop();
+              return `[${res2}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            indentation += spacer;
+            const join2 = `,
+${indentation}`;
+            let res = "";
+            let separator = "";
+            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (isTypedArrayWithEntries(value)) {
+              res += stringifyTypedArray(value, join2, maximumBreadth);
+              keys = keys.slice(value.length);
+              maximumPropertiesToStringify -= value.length;
+              separator = join2;
+            }
+            if (deterministic) {
+              keys = insertSort(keys);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
+              if (tmp !== void 0) {
+                res += `${separator}"${strEscape(key2)}": ${tmp}`;
+                separator = join2;
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
+              separator = join2;
+            }
+            if (separator !== "") {
+              res = `
+${indentation}${res}
+${originalIndentation}`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "bigint":
+            return bigint ? String(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") {
+              value = value.toJSON(key);
+              if (typeof value !== "object") {
+                return stringifySimple(key, value, stack);
+              }
+              if (value === null) {
+                return "null";
+              }
+            }
+            if (stack.indexOf(value) !== -1) {
+              return circularValue;
+            }
+            let res = "";
+            if (Array.isArray(value)) {
+              if (value.length === 0) {
+                return "[]";
+              }
+              if (maximumDepth < stack.length + 1) {
+                return '"[Array]"';
+              }
+              stack.push(value);
+              const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+              let i = 0;
+              for (; i < maximumValuesToStringify - 1; i++) {
+                const tmp2 = stringifySimple(i, value[i], stack);
+                res += tmp2 !== void 0 ? tmp2 : "null";
+                res += ",";
+              }
+              const tmp = stringifySimple(i, value[i], stack);
+              res += tmp !== void 0 ? tmp : "null";
+              if (value.length - 1 > maximumBreadth) {
+                const removedKeys = value.length - maximumBreadth - 1;
+                res += `,"... ${getItemCount(removedKeys)} not stringified"`;
+              }
+              stack.pop();
+              return `[${res}]`;
+            }
+            let keys = Object.keys(value);
+            const keyLength = keys.length;
+            if (keyLength === 0) {
+              return "{}";
+            }
+            if (maximumDepth < stack.length + 1) {
+              return '"[Object]"';
+            }
+            let separator = "";
+            let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+            if (isTypedArrayWithEntries(value)) {
+              res += stringifyTypedArray(value, ",", maximumBreadth);
+              keys = keys.slice(value.length);
+              maximumPropertiesToStringify -= value.length;
+              separator = ",";
+            }
+            if (deterministic) {
+              keys = insertSort(keys);
+            }
+            stack.push(value);
+            for (let i = 0; i < maximumPropertiesToStringify; i++) {
+              const key2 = keys[i];
+              const tmp = stringifySimple(key2, value[key2], stack);
+              if (tmp !== void 0) {
+                res += `${separator}"${strEscape(key2)}":${tmp}`;
+                separator = ",";
+              }
+            }
+            if (keyLength > maximumBreadth) {
+              const removedKeys = keyLength - maximumBreadth;
+              res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
+            }
+            stack.pop();
+            return `{${res}}`;
+          }
+          case "number":
+            return isFinite(value) ? String(value) : "null";
+          case "boolean":
+            return value === true ? "true" : "false";
+          case "bigint":
+            return bigint ? String(value) : void 0;
+        }
+      }
+      function stringify2(value, replacer, space) {
+        if (arguments.length > 1) {
+          let spacer = "";
+          if (typeof space === "number") {
+            spacer = " ".repeat(Math.min(space, 10));
+          } else if (typeof space === "string") {
+            spacer = space.slice(0, 10);
+          }
+          if (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/pino/lib/multistream.js
+var require_multistream = __commonJS({
+  "../../node_modules/pino/lib/multistream.js"(exports, module2) {
+    "use strict";
+    var metadata = Symbol.for("pino.metadata");
+    var { levels } = require_levels2();
+    var defaultLevels = Object.create(levels);
+    defaultLevels.silent = Infinity;
+    function multistream(streamsArray, opts) {
+      let counter = 0;
+      streamsArray = streamsArray || [];
+      opts = opts || { dedupe: false };
+      let levels2 = defaultLevels;
+      if (opts.levels && typeof opts.levels === "object") {
+        levels2 = opts.levels;
+      }
+      const res = {
+        write,
+        add,
+        flushSync,
+        end,
+        minLevel: 0,
+        streams: [],
+        clone,
+        [metadata]: true
+      };
+      if (Array.isArray(streamsArray)) {
+        streamsArray.forEach(add, res);
+      } else {
+        add.call(res, streamsArray);
+      }
+      streamsArray = null;
+      return res;
+      function write(data) {
+        let dest;
+        const level = this.lastLevel;
+        const { streams } = this;
+        let stream;
+        for (let i = 0; i < streams.length; i++) {
+          dest = streams[i];
+          if (dest.level <= level) {
+            stream = dest.stream;
+            if (stream[metadata]) {
+              const { lastTime, lastMsg, lastObj, lastLogger } = this;
+              stream.lastLevel = level;
+              stream.lastTime = lastTime;
+              stream.lastMsg = lastMsg;
+              stream.lastObj = lastObj;
+              stream.lastLogger = lastLogger;
+            }
+            if (!opts.dedupe || dest.level === level) {
+              stream.write(data);
+            }
+          } else {
+            break;
+          }
+        }
+      }
+      function flushSync() {
+        for (const { stream } of this.streams) {
+          if (typeof stream.flushSync === "function") {
+            stream.flushSync();
+          }
+        }
+      }
+      function add(dest) {
+        const { streams } = this;
+        if (typeof dest.write === "function") {
+          return add.call(this, { stream: dest });
+        } else if (typeof dest.levelVal === "number") {
+          return add.call(this, Object.assign({}, dest, { level: dest.levelVal, levelVal: void 0 }));
+        } else if (typeof dest.level === "string") {
+          return add.call(this, Object.assign({}, dest, { level: levels2[dest.level] }));
+        } else if (typeof dest.level !== "number") {
+          dest = Object.assign({}, dest, { level: 30 });
+        } else {
+          dest = Object.assign({}, dest);
+        }
+        dest.id = counter++;
+        streams.unshift(dest);
+        streams.sort(compareByLevel);
+        this.minLevel = streams[0].level;
+        return res;
+      }
+      function end() {
+        for (const { stream } of this.streams) {
+          if (typeof stream.flushSync === "function") {
+            stream.flushSync();
+          }
+          stream.end();
+        }
+      }
+      function clone(level) {
+        const streams = new Array(this.streams.length);
+        for (let i = 0; i < streams.length; i++) {
+          streams[i] = {
+            level,
+            stream: this.streams[i].stream
+          };
+        }
+        return {
+          write,
+          add,
+          minLevel: level,
+          streams,
+          clone,
+          flushSync,
+          [metadata]: true
+        };
+      }
     }
+    function compareByLevel(a, b) {
+      return a.level - b.level;
+    }
+    module2.exports = multistream;
   }
 });
 
@@ -4403,19 +6401,22 @@ var require_pino2 = __commonJS({
   "../../node_modules/pino/pino.js"(exports, module2) {
     "use strict";
     var os = require("os");
-    var stdSerializers = require_pino_std_serializers();
+    var stdSerializers = require_pino_std_serializers2();
+    var caller = require_get_caller_file();
     var redaction = require_redaction2();
     var time = require_time2();
     var proto = require_proto2();
     var symbols = require_symbols2();
+    var { configure: configure2 } = require_safe_stable_stringify();
     var { assertDefaultLevelFound, mappings, genLsCache } = require_levels2();
     var {
       createArgsNormalizer,
       asChindings,
       final,
-      stringify,
       buildSafeSonicBoom,
       buildFormatters,
+      stringify,
+      normalizeDestFileDescriptor,
       noop
     } = require_tools2();
     var { version: version2 } = require_meta2();
@@ -4427,6 +6428,7 @@ var require_pino2 = __commonJS({
       timeSliceIndexSym,
       streamSym,
       stringifySym,
+      stringifySafeSym,
       stringifiersSym,
       setLevelSym,
       endSym,
@@ -4436,7 +6438,8 @@ var require_pino2 = __commonJS({
       mixinSym,
       useOnlyCustomLevelsSym,
       formattersSym,
-      hooksSym
+      hooksSym,
+      nestedKeyStrSym
     } = symbols;
     var { epochTime, nullTime } = time;
     var { pid } = process;
@@ -4467,14 +6470,15 @@ var require_pino2 = __commonJS({
       name: void 0,
       redact: null,
       customLevels: null,
-      levelKey: void 0,
-      useOnlyCustomLevels: false
+      useOnlyCustomLevels: false,
+      depthLimit: 5,
+      edgeLimit: 100
     };
     var normalize = createArgsNormalizer(defaultOptions);
     var serializers = Object.assign(Object.create(null), stdSerializers);
     function pino3(...args) {
       const instance = {};
-      const { opts, stream } = normalize(instance, ...args);
+      const { opts, stream } = normalize(instance, caller(), ...args);
       const {
         redact,
         crlf,
@@ -4486,30 +6490,18 @@ var require_pino2 = __commonJS({
         name,
         level,
         customLevels,
-        useLevelLabels,
-        changeLevelName,
-        levelKey,
         mixin,
         useOnlyCustomLevels,
         formatters,
-        hooks
+        hooks,
+        depthLimit,
+        edgeLimit
       } = opts;
+      const stringifySafe = configure2({
+        maximumDepth: depthLimit,
+        maximumBreadth: edgeLimit
+      });
       const allFormatters = buildFormatters(formatters.level, formatters.bindings, formatters.log);
-      if (useLevelLabels && !(changeLevelName || levelKey)) {
-        process.emitWarning("useLevelLabels is deprecated, use the formatters.level option instead", "Warning", "PINODEP001");
-        allFormatters.level = labelsFormatter;
-      } else if ((changeLevelName || levelKey) && !useLevelLabels) {
-        process.emitWarning("changeLevelName and levelKey are deprecated, use the formatters.level option instead", "Warning", "PINODEP002");
-        allFormatters.level = levelNameFormatter(changeLevelName || levelKey);
-      } else if ((changeLevelName || levelKey) && useLevelLabels) {
-        process.emitWarning("useLevelLabels is deprecated, use the formatters.level option instead", "Warning", "PINODEP001");
-        process.emitWarning("changeLevelName and levelKey are deprecated, use the formatters.level option instead", "Warning", "PINODEP002");
-        allFormatters.level = levelNameLabelFormatter(changeLevelName || levelKey);
-      }
-      if (serializers2[Symbol.for("pino.*")]) {
-        process.emitWarning("The pino.* serializer is deprecated, use the formatters.log options instead", "Warning", "PINODEP003");
-        allFormatters.log = serializers2[Symbol.for("pino.*")];
-      }
       if (!allFormatters.bindings) {
         allFormatters.bindings = defaultOptions.formatters.bindings;
       }
@@ -4517,13 +6509,17 @@ var require_pino2 = __commonJS({
         allFormatters.level = defaultOptions.formatters.level;
       }
       const stringifiers = redact ? redaction(redact, stringify) : {};
-      const formatOpts = redact ? { stringify: stringifiers[redactFmtSym] } : { stringify };
+      const stringifyFn = stringify.bind({
+        [stringifySafeSym]: stringifySafe
+      });
+      const formatOpts = redact ? { stringify: stringifiers[redactFmtSym] } : { stringify: stringifyFn };
       const end = "}" + (crlf ? "\r\n" : "\n");
       const coreChindings = asChindings.bind(null, {
         [chindingsSym]: "",
         [serializersSym]: serializers2,
         [stringifiersSym]: stringifiers,
         [stringifySym]: stringify,
+        [stringifySafeSym]: stringifySafe,
         [formattersSym]: allFormatters
       });
       let chindings = "";
@@ -4549,11 +6545,13 @@ var require_pino2 = __commonJS({
         [timeSym]: time2,
         [timeSliceIndexSym]: timeSliceIndex,
         [stringifySym]: stringify,
+        [stringifySafeSym]: stringifySafe,
         [stringifiersSym]: stringifiers,
         [endSym]: end,
         [formatOptsSym]: formatOpts,
         [messageKeySym]: messageKey,
         [nestedKeySym]: nestedKey,
+        [nestedKeyStrSym]: nestedKey ? `,${JSON.stringify(nestedKey)}:{` : "",
         [serializersSym]: serializers2,
         [mixinSym]: mixin,
         [chindingsSym]: chindings,
@@ -4566,32 +6564,17 @@ var require_pino2 = __commonJS({
       instance[setLevelSym](level);
       return instance;
     }
-    function labelsFormatter(label, number) {
-      return { level: label };
-    }
-    function levelNameFormatter(name) {
-      return function(label, number) {
-        return { [name]: number };
-      };
-    }
-    function levelNameLabelFormatter(name) {
-      return function(label, number) {
-        return { [name]: label };
-      };
-    }
     module2.exports = pino3;
-    module2.exports.extreme = (dest = process.stdout.fd) => {
-      process.emitWarning("The pino.extreme() option is deprecated and will be removed in v7. Use pino.destination({ sync: false }) instead.", { code: "extreme_deprecation" });
-      return buildSafeSonicBoom({ dest, minLength: 4096, sync: false });
-    };
     module2.exports.destination = (dest = process.stdout.fd) => {
       if (typeof dest === "object") {
-        dest.dest = dest.dest || process.stdout.fd;
+        dest.dest = normalizeDestFileDescriptor(dest.dest || process.stdout.fd);
         return buildSafeSonicBoom(dest);
       } else {
-        return buildSafeSonicBoom({ dest, minLength: 0, sync: true });
+        return buildSafeSonicBoom({ dest: normalizeDestFileDescriptor(dest), minLength: 0, sync: true });
       }
     };
+    module2.exports.transport = require_transport();
+    module2.exports.multistream = require_multistream();
     module2.exports.final = final;
     module2.exports.levels = mappings();
     module2.exports.stdSerializers = serializers;
@@ -22291,8 +24274,8 @@ var LambdaHttpResponse = class {
 };
 
 // ../../node_modules/@linzjs/lambda/build/src/function.js
-var version = "v6.16.0";
-var hash = "75bda15568c94ebe89af4c179c0e80226bfabd3f";
+var version = "v6.16.1";
+var hash = "5859ec22302eac1126b887d6399656272b3611cb";
 var versionInfo = { version, hash };
 async function runFunction(req, fn) {
   try {
@@ -25255,7 +27238,7 @@ async function Ping() {
 async function Version() {
   const response = new LambdaHttpResponse(200, "ok");
   response.header(HttpHeader.CacheControl, "no-store");
-  response.json({ version: "v6.16.0", hash: "75bda15568c94ebe89af4c179c0e80226bfabd3f" });
+  response.json({ version: "v6.16.1", hash: "5859ec22302eac1126b887d6399656272b3611cb" });
   return response;
 }
 
@@ -26425,6 +28408,7 @@ var import_sharp = __toModule(require("sharp"));
 function notEmpty(value) {
   return value != null;
 }
+var EmptyImage = new Map();
 var TileMakerSharp = class {
   constructor(tileSize) {
     this.tileSize = tileSize;
@@ -26440,8 +28424,18 @@ var TileMakerSharp = class {
     }
     return false;
   }
-  async getImageBuffer(layers, format, background) {
-    const pipeline2 = this.createImage(background).composite(layers);
+  getEmptyImage(format, background) {
+    const imgKey = [format, background.r, background.g, background.b, background.alpha].join("-");
+    let existing = EmptyImage.get(imgKey);
+    if (existing)
+      return existing;
+    existing = this.toImage(format, this.createImage(background));
+    if (EmptyImage.size > 128)
+      EmptyImage.clear();
+    EmptyImage.set(imgKey, existing);
+    return existing;
+  }
+  toImage(format, pipeline2) {
     switch (format) {
       case ImageFormat.JPEG:
         return pipeline2.jpeg().toBuffer();
@@ -26455,14 +28449,47 @@ var TileMakerSharp = class {
         throw new Error(`Invalid image format "${format}"`);
     }
   }
+  async getImageBuffer(layers, format, background) {
+    if (layers.length === 0)
+      return this.getEmptyImage(format, background);
+    return this.toImage(format, this.createImage(background).composite(layers));
+  }
+  isDirectImage(ctx) {
+    var _a;
+    if (ctx.layers.length !== 1)
+      return false;
+    const firstLayer = ctx.layers[0];
+    if (firstLayer.x !== 0 || firstLayer.y !== 0)
+      return false;
+    if (firstLayer.crop != null || firstLayer.extract != null || firstLayer.resize != null)
+      return false;
+    const img = firstLayer.tiff.getImage(firstLayer.source.imageId);
+    const tileSize = img.tileSize;
+    if (tileSize.height !== this.tileSize || tileSize.width !== this.tileSize)
+      return false;
+    if (!((_a = img.compression) === null || _a === void 0 ? void 0 : _a.includes(ctx.format)))
+      return false;
+    if (ctx.background.alpha !== 0)
+      return false;
+    return true;
+  }
   async compose(ctx) {
     const metrics = new Metrics();
     metrics.start("compose:overlay");
+    if (this.isDirectImage(ctx)) {
+      const firstLayer = ctx.layers[0];
+      const buf = await firstLayer.tiff.getTile(firstLayer.source.x, firstLayer.source.y, firstLayer.source.imageId);
+      metrics.end("compose:overlay");
+      if (buf == null)
+        return { buffer: await this.getEmptyImage(ctx.format, ctx.background), metrics, layers: 0 };
+      metrics.start("compose:direct");
+      metrics.end("compose:direct");
+      return { buffer: Buffer.from(buf.bytes), metrics, layers: 1 };
+    }
     const todo = [];
     for (const comp of ctx.layers) {
-      if (this.isTooLarge(comp)) {
+      if (this.isTooLarge(comp))
         continue;
-      }
       todo.push(this.composeTile(comp, ctx.resizeKernel));
     }
     const overlays = await Promise.all(todo).then((items) => items.filter(notEmpty));