npm - @navios/core - Versions diffs - 0.1.11 → 0.1.12 - Mend

@navios/core 0.1.11 → 0.1.12

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

package/dist/index.js +61 -3187
package/dist/index.mjs +52 -17
package/package.json +2 -2
package/src/navios.application.mts +5 -12
package/dist/chunk-Z2AVZ4BT.mjs +0 -65
package/dist/multipart-23QO76VV.mjs +0 -3120

package/dist/index.js CHANGED Viewed

@@ -11,3184 +11,65 @@ var __typeError = (msg) => {
 };
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __decoratorStart = (base) => [, , , __create((base == null ? void 0 : base[__knownSymbol("metadata")]) ?? null)];
-var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
-var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
-var __decoratorContext = (kind, name2, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name: name2, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
-var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
-var __runInitializers = (array, flags, self, value) => {
-  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
-  return value;
-};
-var __decorateElement = (array, flags, name2, decorators, target, extra) => {
-  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
-  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
-  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
-  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name2]() {
-    return __privateGet(this, extra);
-  }, set [name2](x) {
-    return __privateSet(this, extra, x);
-  } }, name2));
-  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name2) : __name(target, name2);
-  for (var i = decorators.length - 1; i >= 0; i--) {
-    ctx = __decoratorContext(k, name2, done = {}, array[3], extraInitializers);
-    if (k) {
-      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name2 in x };
-      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name2];
-      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name2] = y;
-    }
-    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
-    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
-    else if (typeof it !== "object" || it === null) __typeError("Object expected");
-    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
-  }
-  return k || __decoratorMetadata(array, target), desc && __defProp(target, name2, desc), p ? k ^ 4 ? extra : desc : target;
-};
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js
-var require_sbmh = __commonJS({
-  "node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports2, module2) {
-    "use strict";
-    var { EventEmitter: EventEmitter2 } = require("events");
-    var { inherits } = require("util");
-    function SBMH(needle) {
-      if (typeof needle === "string") {
-        needle = Buffer.from(needle);
-      }
-      if (!Buffer.isBuffer(needle)) {
-        throw new TypeError("The needle has to be a String or a Buffer.");
-      }
-      const needleLength = needle.length;
-      const needleLastCharIndex = needleLength - 1;
-      if (needleLength === 0) {
-        throw new Error("The needle cannot be an empty String/Buffer.");
-      }
-      if (needleLength > 256) {
-        throw new Error("The needle cannot have a length bigger than 256.");
-      }
-      this.maxMatches = Infinity;
-      this.matches = 0;
-      this._occ = new Uint8Array(256).fill(needleLength);
-      this._lookbehind_size = 0;
-      this._needle = needle;
-      this._bufpos = 0;
-      this._lookbehind = Buffer.alloc(needleLastCharIndex);
-      for (var i = 0; i < needleLastCharIndex; ++i) {
-        this._occ[needle[i]] = needleLastCharIndex - i;
-      }
-    }
-    inherits(SBMH, EventEmitter2);
-    SBMH.prototype.reset = function() {
-      this._lookbehind_size = 0;
-      this.matches = 0;
-      this._bufpos = 0;
-    };
-    SBMH.prototype.push = function(chunk, pos) {
-      if (!Buffer.isBuffer(chunk)) {
-        chunk = Buffer.from(chunk, "binary");
-      }
-      const chlen = chunk.length;
-      this._bufpos = pos || 0;
-      let r;
-      while (r !== chlen && this.matches < this.maxMatches) {
-        r = this._sbmh_feed(chunk);
-      }
-      return r;
-    };
-    SBMH.prototype._sbmh_feed = function(data) {
-      const len = data.length;
-      const needle = this._needle;
-      const needleLength = needle.length;
-      const needleLastCharIndex = needleLength - 1;
-      const needleLastChar = needle[needleLastCharIndex];
-      let pos = -this._lookbehind_size;
-      let ch;
-      if (pos < 0) {
-        while (pos < 0 && pos <= len - needleLength) {
-          ch = data[pos + needleLastCharIndex];
-          if (ch === needleLastChar && this._sbmh_memcmp(data, pos, needleLastCharIndex)) {
-            this._lookbehind_size = 0;
-            ++this.matches;
-            this.emit("info", true);
-            return this._bufpos = pos + needleLength;
-          }
-          pos += this._occ[ch];
-        }
-        while (pos < 0 && !this._sbmh_memcmp(data, pos, len - pos)) {
-          ++pos;
-        }
-        if (pos >= 0) {
-          this.emit("info", false, this._lookbehind, 0, this._lookbehind_size);
-          this._lookbehind_size = 0;
-        } else {
-          const bytesToCutOff = this._lookbehind_size + pos;
-          if (bytesToCutOff > 0) {
-            this.emit("info", false, this._lookbehind, 0, bytesToCutOff);
-          }
-          this._lookbehind_size -= bytesToCutOff;
-          this._lookbehind.copy(this._lookbehind, 0, bytesToCutOff, this._lookbehind_size);
-          data.copy(this._lookbehind, this._lookbehind_size);
-          this._lookbehind_size += len;
-          this._bufpos = len;
-          return len;
-        }
-      }
-      pos = data.indexOf(needle, pos + this._bufpos);
-      if (pos !== -1) {
-        ++this.matches;
-        if (pos === 0) {
-          this.emit("info", true);
-        } else {
-          this.emit("info", true, data, this._bufpos, pos);
-        }
-        return this._bufpos = pos + needleLength;
-      }
-      pos = len - needleLastCharIndex;
-      if (pos < 0) {
-        pos = 0;
-      }
-      while (pos !== len && (data[pos] !== needle[0] || Buffer.compare(
-        data.subarray(pos + 1, len),
-        needle.subarray(1, len - pos)
-      ) !== 0)) {
-        ++pos;
-      }
-      if (pos !== len) {
-        data.copy(this._lookbehind, 0, pos, len);
-        this._lookbehind_size = len - pos;
-      }
-      if (pos !== 0) {
-        this.emit("info", false, data, this._bufpos, pos);
-      }
-      this._bufpos = len;
-      return len;
-    };
-    SBMH.prototype._sbmh_lookup_char = function(data, pos) {
-      return pos < 0 ? this._lookbehind[this._lookbehind_size + pos] : data[pos];
-    };
-    SBMH.prototype._sbmh_memcmp = function(data, pos, len) {
-      for (var i = 0; i < len; ++i) {
-        if (this._sbmh_lookup_char(data, pos + i) !== this._needle[i]) {
-          return false;
-        }
-      }
-      return true;
-    };
-    module2.exports = SBMH;
-  }
-});
-// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js
-var require_PartStream = __commonJS({
-  "node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports2, module2) {
-    "use strict";
-    var inherits = require("util").inherits;
-    var ReadableStream = require("stream").Readable;
-    function PartStream(opts) {
-      ReadableStream.call(this, opts);
-    }
-    inherits(PartStream, ReadableStream);
-    PartStream.prototype._read = function(n) {
-    };
-    module2.exports = PartStream;
-  }
-});
-// node_modules/@fastify/busboy/lib/utils/getLimit.js
-var require_getLimit = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports2, module2) {
-    "use strict";
-    module2.exports = function getLimit(limits, name2, defaultLimit) {
-      if (!limits || limits[name2] === void 0 || limits[name2] === null) {
-        return defaultLimit;
-      }
-      if (typeof limits[name2] !== "number" || isNaN(limits[name2])) {
-        throw new TypeError("Limit " + name2 + " is not a valid number");
-      }
-      return limits[name2];
-    };
-  }
-});
-// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js
-var require_HeaderParser = __commonJS({
-  "node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports2, module2) {
-    "use strict";
-    var EventEmitter2 = require("events").EventEmitter;
-    var inherits = require("util").inherits;
-    var getLimit = require_getLimit();
-    var StreamSearch = require_sbmh();
-    var B_DCRLF = Buffer.from("\r\n\r\n");
-    var RE_CRLF = /\r\n/g;
-    var RE_HDR = /^([^:]+):[ \t]?([\x00-\xFF]+)?$/;
-    function HeaderParser(cfg) {
-      EventEmitter2.call(this);
-      cfg = cfg || {};
-      const self = this;
-      this.nread = 0;
-      this.maxed = false;
-      this.npairs = 0;
-      this.maxHeaderPairs = getLimit(cfg, "maxHeaderPairs", 2e3);
-      this.maxHeaderSize = getLimit(cfg, "maxHeaderSize", 80 * 1024);
-      this.buffer = "";
-      this.header = {};
-      this.finished = false;
-      this.ss = new StreamSearch(B_DCRLF);
-      this.ss.on("info", function(isMatch, data, start, end) {
-        if (data && !self.maxed) {
-          if (self.nread + end - start >= self.maxHeaderSize) {
-            end = self.maxHeaderSize - self.nread + start;
-            self.nread = self.maxHeaderSize;
-            self.maxed = true;
-          } else {
-            self.nread += end - start;
-          }
-          self.buffer += data.toString("binary", start, end);
-        }
-        if (isMatch) {
-          self._finish();
-        }
-      });
-    }
-    inherits(HeaderParser, EventEmitter2);
-    HeaderParser.prototype.push = function(data) {
-      const r = this.ss.push(data);
-      if (this.finished) {
-        return r;
-      }
-    };
-    HeaderParser.prototype.reset = function() {
-      this.finished = false;
-      this.buffer = "";
-      this.header = {};
-      this.ss.reset();
-    };
-    HeaderParser.prototype._finish = function() {
-      if (this.buffer) {
-        this._parseHeader();
-      }
-      this.ss.matches = this.ss.maxMatches;
-      const header = this.header;
-      this.header = {};
-      this.buffer = "";
-      this.finished = true;
-      this.nread = this.npairs = 0;
-      this.maxed = false;
-      this.emit("header", header);
-    };
-    HeaderParser.prototype._parseHeader = function() {
-      if (this.npairs === this.maxHeaderPairs) {
-        return;
-      }
-      const lines = this.buffer.split(RE_CRLF);
-      const len = lines.length;
-      let m, h;
-      for (var i = 0; i < len; ++i) {
-        if (lines[i].length === 0) {
-          continue;
-        }
-        if (lines[i][0] === "	" || lines[i][0] === " ") {
-          if (h) {
-            this.header[h][this.header[h].length - 1] += lines[i];
-            continue;
-          }
-        }
-        const posColon = lines[i].indexOf(":");
-        if (posColon === -1 || posColon === 0) {
-          return;
-        }
-        m = RE_HDR.exec(lines[i]);
-        h = m[1].toLowerCase();
-        this.header[h] = this.header[h] || [];
-        this.header[h].push(m[2] || "");
-        if (++this.npairs === this.maxHeaderPairs) {
-          break;
-        }
-      }
-    };
-    module2.exports = HeaderParser;
-  }
-});
-// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js
-var require_Dicer = __commonJS({
-  "node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports2, module2) {
-    "use strict";
-    var WritableStream = require("stream").Writable;
-    var inherits = require("util").inherits;
-    var StreamSearch = require_sbmh();
-    var PartStream = require_PartStream();
-    var HeaderParser = require_HeaderParser();
-    var DASH = 45;
-    var B_ONEDASH = Buffer.from("-");
-    var B_CRLF = Buffer.from("\r\n");
-    var EMPTY_FN = function() {
-    };
-    function Dicer(cfg) {
-      if (!(this instanceof Dicer)) {
-        return new Dicer(cfg);
-      }
-      WritableStream.call(this, cfg);
-      if (!cfg || !cfg.headerFirst && typeof cfg.boundary !== "string") {
-        throw new TypeError("Boundary required");
-      }
-      if (typeof cfg.boundary === "string") {
-        this.setBoundary(cfg.boundary);
-      } else {
-        this._bparser = void 0;
-      }
-      this._headerFirst = cfg.headerFirst;
-      this._dashes = 0;
-      this._parts = 0;
-      this._finished = false;
-      this._realFinish = false;
-      this._isPreamble = true;
-      this._justMatched = false;
-      this._firstWrite = true;
-      this._inHeader = true;
-      this._part = void 0;
-      this._cb = void 0;
-      this._ignoreData = false;
-      this._partOpts = { highWaterMark: cfg.partHwm };
-      this._pause = false;
-      const self = this;
-      this._hparser = new HeaderParser(cfg);
-      this._hparser.on("header", function(header) {
-        self._inHeader = false;
-        self._part.emit("header", header);
-      });
-    }
-    inherits(Dicer, WritableStream);
-    Dicer.prototype.emit = function(ev) {
-      if (ev === "finish" && !this._realFinish) {
-        if (!this._finished) {
-          const self = this;
-          process.nextTick(function() {
-            self.emit("error", new Error("Unexpected end of multipart data"));
-            if (self._part && !self._ignoreData) {
-              const type = self._isPreamble ? "Preamble" : "Part";
-              self._part.emit("error", new Error(type + " terminated early due to unexpected end of multipart data"));
-              self._part.push(null);
-              process.nextTick(function() {
-                self._realFinish = true;
-                self.emit("finish");
-                self._realFinish = false;
-              });
-              return;
-            }
-            self._realFinish = true;
-            self.emit("finish");
-            self._realFinish = false;
-          });
-        }
-      } else {
-        WritableStream.prototype.emit.apply(this, arguments);
-      }
-    };
-    Dicer.prototype._write = function(data, encoding, cb) {
-      if (!this._hparser && !this._bparser) {
-        return cb();
-      }
-      if (this._headerFirst && this._isPreamble) {
-        if (!this._part) {
-          this._part = new PartStream(this._partOpts);
-          if (this.listenerCount("preamble") !== 0) {
-            this.emit("preamble", this._part);
-          } else {
-            this._ignore();
-          }
-        }
-        const r = this._hparser.push(data);
-        if (!this._inHeader && r !== void 0 && r < data.length) {
-          data = data.slice(r);
-        } else {
-          return cb();
-        }
-      }
-      if (this._firstWrite) {
-        this._bparser.push(B_CRLF);
-        this._firstWrite = false;
-      }
-      this._bparser.push(data);
-      if (this._pause) {
-        this._cb = cb;
-      } else {
-        cb();
-      }
-    };
-    Dicer.prototype.reset = function() {
-      this._part = void 0;
-      this._bparser = void 0;
-      this._hparser = void 0;
-    };
-    Dicer.prototype.setBoundary = function(boundary) {
-      const self = this;
-      this._bparser = new StreamSearch("\r\n--" + boundary);
-      this._bparser.on("info", function(isMatch, data, start, end) {
-        self._oninfo(isMatch, data, start, end);
-      });
-    };
-    Dicer.prototype._ignore = function() {
-      if (this._part && !this._ignoreData) {
-        this._ignoreData = true;
-        this._part.on("error", EMPTY_FN);
-        this._part.resume();
-      }
-    };
-    Dicer.prototype._oninfo = function(isMatch, data, start, end) {
-      let buf;
-      const self = this;
-      let i = 0;
-      let r;
-      let shouldWriteMore = true;
-      if (!this._part && this._justMatched && data) {
-        while (this._dashes < 2 && start + i < end) {
-          if (data[start + i] === DASH) {
-            ++i;
-            ++this._dashes;
-          } else {
-            if (this._dashes) {
-              buf = B_ONEDASH;
-            }
-            this._dashes = 0;
-            break;
-          }
-        }
-        if (this._dashes === 2) {
-          if (start + i < end && this.listenerCount("trailer") !== 0) {
-            this.emit("trailer", data.slice(start + i, end));
-          }
-          this.reset();
-          this._finished = true;
-          if (self._parts === 0) {
-            self._realFinish = true;
-            self.emit("finish");
-            self._realFinish = false;
-          }
-        }
-        if (this._dashes) {
-          return;
-        }
-      }
-      if (this._justMatched) {
-        this._justMatched = false;
-      }
-      if (!this._part) {
-        this._part = new PartStream(this._partOpts);
-        this._part._read = function(n) {
-          self._unpause();
-        };
-        if (this._isPreamble && this.listenerCount("preamble") !== 0) {
-          this.emit("preamble", this._part);
-        } else if (this._isPreamble !== true && this.listenerCount("part") !== 0) {
-          this.emit("part", this._part);
-        } else {
-          this._ignore();
-        }
-        if (!this._isPreamble) {
-          this._inHeader = true;
-        }
-      }
-      if (data && start < end && !this._ignoreData) {
-        if (this._isPreamble || !this._inHeader) {
-          if (buf) {
-            shouldWriteMore = this._part.push(buf);
-          }
-          shouldWriteMore = this._part.push(data.slice(start, end));
-          if (!shouldWriteMore) {
-            this._pause = true;
-          }
-        } else if (!this._isPreamble && this._inHeader) {
-          if (buf) {
-            this._hparser.push(buf);
-          }
-          r = this._hparser.push(data.slice(start, end));
-          if (!this._inHeader && r !== void 0 && r < end) {
-            this._oninfo(false, data, start + r, end);
-          }
-        }
-      }
-      if (isMatch) {
-        this._hparser.reset();
-        if (this._isPreamble) {
-          this._isPreamble = false;
-        } else {
-          if (start !== end) {
-            ++this._parts;
-            this._part.on("end", function() {
-              if (--self._parts === 0) {
-                if (self._finished) {
-                  self._realFinish = true;
-                  self.emit("finish");
-                  self._realFinish = false;
-                } else {
-                  self._unpause();
-                }
-              }
-            });
-          }
-        }
-        this._part.push(null);
-        this._part = void 0;
-        this._ignoreData = false;
-        this._justMatched = true;
-        this._dashes = 0;
-      }
-    };
-    Dicer.prototype._unpause = function() {
-      if (!this._pause) {
-        return;
-      }
-      this._pause = false;
-      if (this._cb) {
-        const cb = this._cb;
-        this._cb = void 0;
-        cb();
-      }
-    };
-    module2.exports = Dicer;
-  }
-});
-// node_modules/@fastify/busboy/lib/utils/decodeText.js
-var require_decodeText = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports2, module2) {
-    "use strict";
-    var utf8Decoder = new TextDecoder("utf-8");
-    var textDecoders = /* @__PURE__ */ new Map([
-      ["utf-8", utf8Decoder],
-      ["utf8", utf8Decoder]
-    ]);
-    function getDecoder(charset) {
-      let lc;
-      while (true) {
-        switch (charset) {
-          case "utf-8":
-          case "utf8":
-            return decoders.utf8;
-          case "latin1":
-          case "ascii":
-          // TODO: Make these a separate, strict decoder?
-          case "us-ascii":
-          case "iso-8859-1":
-          case "iso8859-1":
-          case "iso88591":
-          case "iso_8859-1":
-          case "windows-1252":
-          case "iso_8859-1:1987":
-          case "cp1252":
-          case "x-cp1252":
-            return decoders.latin1;
-          case "utf16le":
-          case "utf-16le":
-          case "ucs2":
-          case "ucs-2":
-            return decoders.utf16le;
-          case "base64":
-            return decoders.base64;
-          default:
-            if (lc === void 0) {
-              lc = true;
-              charset = charset.toLowerCase();
-              continue;
-            }
-            return decoders.other.bind(charset);
-        }
-      }
-    }
-    var decoders = {
-      utf8: (data, sourceEncoding) => {
-        if (data.length === 0) {
-          return "";
-        }
-        if (typeof data === "string") {
-          data = Buffer.from(data, sourceEncoding);
-        }
-        return data.utf8Slice(0, data.length);
-      },
-      latin1: (data, sourceEncoding) => {
-        if (data.length === 0) {
-          return "";
-        }
-        if (typeof data === "string") {
-          return data;
-        }
-        return data.latin1Slice(0, data.length);
-      },
-      utf16le: (data, sourceEncoding) => {
-        if (data.length === 0) {
-          return "";
-        }
-        if (typeof data === "string") {
-          data = Buffer.from(data, sourceEncoding);
-        }
-        return data.ucs2Slice(0, data.length);
-      },
-      base64: (data, sourceEncoding) => {
-        if (data.length === 0) {
-          return "";
-        }
-        if (typeof data === "string") {
-          data = Buffer.from(data, sourceEncoding);
-        }
-        return data.base64Slice(0, data.length);
-      },
-      other: (data, sourceEncoding) => {
-        if (data.length === 0) {
-          return "";
-        }
-        if (typeof data === "string") {
-          data = Buffer.from(data, sourceEncoding);
-        }
-        if (textDecoders.has(exports2.toString())) {
-          try {
-            return textDecoders.get(exports2).decode(data);
-          } catch {
-          }
-        }
-        return typeof data === "string" ? data : data.toString();
-      }
-    };
-    function decodeText(text, sourceEncoding, destEncoding) {
-      if (text) {
-        return getDecoder(destEncoding)(text, sourceEncoding);
-      }
-      return text;
-    }
-    module2.exports = decodeText;
-  }
-});
-// node_modules/@fastify/busboy/lib/utils/parseParams.js
-var require_parseParams = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports2, module2) {
-    "use strict";
-    var decodeText = require_decodeText();
-    var RE_ENCODED = /%[a-fA-F0-9][a-fA-F0-9]/g;
-    var EncodedLookup = {
-      "%00": "\0",
-      "%01": "",
-      "%02": "",
-      "%03": "",
-      "%04": "",
-      "%05": "",
-      "%06": "",
-      "%07": "\x07",
-      "%08": "\b",
-      "%09": "	",
-      "%0a": "\n",
-      "%0A": "\n",
-      "%0b": "\v",
-      "%0B": "\v",
-      "%0c": "\f",
-      "%0C": "\f",
-      "%0d": "\r",
-      "%0D": "\r",
-      "%0e": "",
-      "%0E": "",
-      "%0f": "",
-      "%0F": "",
-      "%10": "",
-      "%11": "",
-      "%12": "",
-      "%13": "",
-      "%14": "",
-      "%15": "",
-      "%16": "",
-      "%17": "",
-      "%18": "",
-      "%19": "",
-      "%1a": "",
-      "%1A": "",
-      "%1b": "\x1B",
-      "%1B": "\x1B",
-      "%1c": "",
-      "%1C": "",
-      "%1d": "",
-      "%1D": "",
-      "%1e": "",
-      "%1E": "",
-      "%1f": "",
-      "%1F": "",
-      "%20": " ",
-      "%21": "!",
-      "%22": '"',
-      "%23": "#",
-      "%24": "$",
-      "%25": "%",
-      "%26": "&",
-      "%27": "'",
-      "%28": "(",
-      "%29": ")",
-      "%2a": "*",
-      "%2A": "*",
-      "%2b": "+",
-      "%2B": "+",
-      "%2c": ",",
-      "%2C": ",",
-      "%2d": "-",
-      "%2D": "-",
-      "%2e": ".",
-      "%2E": ".",
-      "%2f": "/",
-      "%2F": "/",
-      "%30": "0",
-      "%31": "1",
-      "%32": "2",
-      "%33": "3",
-      "%34": "4",
-      "%35": "5",
-      "%36": "6",
-      "%37": "7",
-      "%38": "8",
-      "%39": "9",
-      "%3a": ":",
-      "%3A": ":",
-      "%3b": ";",
-      "%3B": ";",
-      "%3c": "<",
-      "%3C": "<",
-      "%3d": "=",
-      "%3D": "=",
-      "%3e": ">",
-      "%3E": ">",
-      "%3f": "?",
-      "%3F": "?",
-      "%40": "@",
-      "%41": "A",
-      "%42": "B",
-      "%43": "C",
-      "%44": "D",
-      "%45": "E",
-      "%46": "F",
-      "%47": "G",
-      "%48": "H",
-      "%49": "I",
-      "%4a": "J",
-      "%4A": "J",
-      "%4b": "K",
-      "%4B": "K",
-      "%4c": "L",
-      "%4C": "L",
-      "%4d": "M",
-      "%4D": "M",
-      "%4e": "N",
-      "%4E": "N",
-      "%4f": "O",
-      "%4F": "O",
-      "%50": "P",
-      "%51": "Q",
-      "%52": "R",
-      "%53": "S",
-      "%54": "T",
-      "%55": "U",
-      "%56": "V",
-      "%57": "W",
-      "%58": "X",
-      "%59": "Y",
-      "%5a": "Z",
-      "%5A": "Z",
-      "%5b": "[",
-      "%5B": "[",
-      "%5c": "\\",
-      "%5C": "\\",
-      "%5d": "]",
-      "%5D": "]",
-      "%5e": "^",
-      "%5E": "^",
-      "%5f": "_",
-      "%5F": "_",
-      "%60": "`",
-      "%61": "a",
-      "%62": "b",
-      "%63": "c",
-      "%64": "d",
-      "%65": "e",
-      "%66": "f",
-      "%67": "g",
-      "%68": "h",
-      "%69": "i",
-      "%6a": "j",
-      "%6A": "j",
-      "%6b": "k",
-      "%6B": "k",
-      "%6c": "l",
-      "%6C": "l",
-      "%6d": "m",
-      "%6D": "m",
-      "%6e": "n",
-      "%6E": "n",
-      "%6f": "o",
-      "%6F": "o",
-      "%70": "p",
-      "%71": "q",
-      "%72": "r",
-      "%73": "s",
-      "%74": "t",
-      "%75": "u",
-      "%76": "v",
-      "%77": "w",
-      "%78": "x",
-      "%79": "y",
-      "%7a": "z",
-      "%7A": "z",
-      "%7b": "{",
-      "%7B": "{",
-      "%7c": "|",
-      "%7C": "|",
-      "%7d": "}",
-      "%7D": "}",
-      "%7e": "~",
-      "%7E": "~",
-      "%7f": "\x7F",
-      "%7F": "\x7F",
-      "%80": "\x80",
-      "%81": "\x81",
-      "%82": "\x82",
-      "%83": "\x83",
-      "%84": "\x84",
-      "%85": "\x85",
-      "%86": "\x86",
-      "%87": "\x87",
-      "%88": "\x88",
-      "%89": "\x89",
-      "%8a": "\x8A",
-      "%8A": "\x8A",
-      "%8b": "\x8B",
-      "%8B": "\x8B",
-      "%8c": "\x8C",
-      "%8C": "\x8C",
-      "%8d": "\x8D",
-      "%8D": "\x8D",
-      "%8e": "\x8E",
-      "%8E": "\x8E",
-      "%8f": "\x8F",
-      "%8F": "\x8F",
-      "%90": "\x90",
-      "%91": "\x91",
-      "%92": "\x92",
-      "%93": "\x93",
-      "%94": "\x94",
-      "%95": "\x95",
-      "%96": "\x96",
-      "%97": "\x97",
-      "%98": "\x98",
-      "%99": "\x99",
-      "%9a": "\x9A",
-      "%9A": "\x9A",
-      "%9b": "\x9B",
-      "%9B": "\x9B",
-      "%9c": "\x9C",
-      "%9C": "\x9C",
-      "%9d": "\x9D",
-      "%9D": "\x9D",
-      "%9e": "\x9E",
-      "%9E": "\x9E",
-      "%9f": "\x9F",
-      "%9F": "\x9F",
-      "%a0": "\xA0",
-      "%A0": "\xA0",
-      "%a1": "\xA1",
-      "%A1": "\xA1",
-      "%a2": "\xA2",
-      "%A2": "\xA2",
-      "%a3": "\xA3",
-      "%A3": "\xA3",
-      "%a4": "\xA4",
-      "%A4": "\xA4",
-      "%a5": "\xA5",
-      "%A5": "\xA5",
-      "%a6": "\xA6",
-      "%A6": "\xA6",
-      "%a7": "\xA7",
-      "%A7": "\xA7",
-      "%a8": "\xA8",
-      "%A8": "\xA8",
-      "%a9": "\xA9",
-      "%A9": "\xA9",
-      "%aa": "\xAA",
-      "%Aa": "\xAA",
-      "%aA": "\xAA",
-      "%AA": "\xAA",
-      "%ab": "\xAB",
-      "%Ab": "\xAB",
-      "%aB": "\xAB",
-      "%AB": "\xAB",
-      "%ac": "\xAC",
-      "%Ac": "\xAC",
-      "%aC": "\xAC",
-      "%AC": "\xAC",
-      "%ad": "\xAD",
-      "%Ad": "\xAD",
-      "%aD": "\xAD",
-      "%AD": "\xAD",
-      "%ae": "\xAE",
-      "%Ae": "\xAE",
-      "%aE": "\xAE",
-      "%AE": "\xAE",
-      "%af": "\xAF",
-      "%Af": "\xAF",
-      "%aF": "\xAF",
-      "%AF": "\xAF",
-      "%b0": "\xB0",
-      "%B0": "\xB0",
-      "%b1": "\xB1",
-      "%B1": "\xB1",
-      "%b2": "\xB2",
-      "%B2": "\xB2",
-      "%b3": "\xB3",
-      "%B3": "\xB3",
-      "%b4": "\xB4",
-      "%B4": "\xB4",
-      "%b5": "\xB5",
-      "%B5": "\xB5",
-      "%b6": "\xB6",
-      "%B6": "\xB6",
-      "%b7": "\xB7",
-      "%B7": "\xB7",
-      "%b8": "\xB8",
-      "%B8": "\xB8",
-      "%b9": "\xB9",
-      "%B9": "\xB9",
-      "%ba": "\xBA",
-      "%Ba": "\xBA",
-      "%bA": "\xBA",
-      "%BA": "\xBA",
-      "%bb": "\xBB",
-      "%Bb": "\xBB",
-      "%bB": "\xBB",
-      "%BB": "\xBB",
-      "%bc": "\xBC",
-      "%Bc": "\xBC",
-      "%bC": "\xBC",
-      "%BC": "\xBC",
-      "%bd": "\xBD",
-      "%Bd": "\xBD",
-      "%bD": "\xBD",
-      "%BD": "\xBD",
-      "%be": "\xBE",
-      "%Be": "\xBE",
-      "%bE": "\xBE",
-      "%BE": "\xBE",
-      "%bf": "\xBF",
-      "%Bf": "\xBF",
-      "%bF": "\xBF",
-      "%BF": "\xBF",
-      "%c0": "\xC0",
-      "%C0": "\xC0",
-      "%c1": "\xC1",
-      "%C1": "\xC1",
-      "%c2": "\xC2",
-      "%C2": "\xC2",
-      "%c3": "\xC3",
-      "%C3": "\xC3",
-      "%c4": "\xC4",
-      "%C4": "\xC4",
-      "%c5": "\xC5",
-      "%C5": "\xC5",
-      "%c6": "\xC6",
-      "%C6": "\xC6",
-      "%c7": "\xC7",
-      "%C7": "\xC7",
-      "%c8": "\xC8",
-      "%C8": "\xC8",
-      "%c9": "\xC9",
-      "%C9": "\xC9",
-      "%ca": "\xCA",
-      "%Ca": "\xCA",
-      "%cA": "\xCA",
-      "%CA": "\xCA",
-      "%cb": "\xCB",
-      "%Cb": "\xCB",
-      "%cB": "\xCB",
-      "%CB": "\xCB",
-      "%cc": "\xCC",
-      "%Cc": "\xCC",
-      "%cC": "\xCC",
-      "%CC": "\xCC",
-      "%cd": "\xCD",
-      "%Cd": "\xCD",
-      "%cD": "\xCD",
-      "%CD": "\xCD",
-      "%ce": "\xCE",
-      "%Ce": "\xCE",
-      "%cE": "\xCE",
-      "%CE": "\xCE",
-      "%cf": "\xCF",
-      "%Cf": "\xCF",
-      "%cF": "\xCF",
-      "%CF": "\xCF",
-      "%d0": "\xD0",
-      "%D0": "\xD0",
-      "%d1": "\xD1",
-      "%D1": "\xD1",
-      "%d2": "\xD2",
-      "%D2": "\xD2",
-      "%d3": "\xD3",
-      "%D3": "\xD3",
-      "%d4": "\xD4",
-      "%D4": "\xD4",
-      "%d5": "\xD5",
-      "%D5": "\xD5",
-      "%d6": "\xD6",
-      "%D6": "\xD6",
-      "%d7": "\xD7",
-      "%D7": "\xD7",
-      "%d8": "\xD8",
-      "%D8": "\xD8",
-      "%d9": "\xD9",
-      "%D9": "\xD9",
-      "%da": "\xDA",
-      "%Da": "\xDA",
-      "%dA": "\xDA",
-      "%DA": "\xDA",
-      "%db": "\xDB",
-      "%Db": "\xDB",
-      "%dB": "\xDB",
-      "%DB": "\xDB",
-      "%dc": "\xDC",
-      "%Dc": "\xDC",
-      "%dC": "\xDC",
-      "%DC": "\xDC",
-      "%dd": "\xDD",
-      "%Dd": "\xDD",
-      "%dD": "\xDD",
-      "%DD": "\xDD",
-      "%de": "\xDE",
-      "%De": "\xDE",
-      "%dE": "\xDE",
-      "%DE": "\xDE",
-      "%df": "\xDF",
-      "%Df": "\xDF",
-      "%dF": "\xDF",
-      "%DF": "\xDF",
-      "%e0": "\xE0",
-      "%E0": "\xE0",
-      "%e1": "\xE1",
-      "%E1": "\xE1",
-      "%e2": "\xE2",
-      "%E2": "\xE2",
-      "%e3": "\xE3",
-      "%E3": "\xE3",
-      "%e4": "\xE4",
-      "%E4": "\xE4",
-      "%e5": "\xE5",
-      "%E5": "\xE5",
-      "%e6": "\xE6",
-      "%E6": "\xE6",
-      "%e7": "\xE7",
-      "%E7": "\xE7",
-      "%e8": "\xE8",
-      "%E8": "\xE8",
-      "%e9": "\xE9",
-      "%E9": "\xE9",
-      "%ea": "\xEA",
-      "%Ea": "\xEA",
-      "%eA": "\xEA",
-      "%EA": "\xEA",
-      "%eb": "\xEB",
-      "%Eb": "\xEB",
-      "%eB": "\xEB",
-      "%EB": "\xEB",
-      "%ec": "\xEC",
-      "%Ec": "\xEC",
-      "%eC": "\xEC",
-      "%EC": "\xEC",
-      "%ed": "\xED",
-      "%Ed": "\xED",
-      "%eD": "\xED",
-      "%ED": "\xED",
-      "%ee": "\xEE",
-      "%Ee": "\xEE",
-      "%eE": "\xEE",
-      "%EE": "\xEE",
-      "%ef": "\xEF",
-      "%Ef": "\xEF",
-      "%eF": "\xEF",
-      "%EF": "\xEF",
-      "%f0": "\xF0",
-      "%F0": "\xF0",
-      "%f1": "\xF1",
-      "%F1": "\xF1",
-      "%f2": "\xF2",
-      "%F2": "\xF2",
-      "%f3": "\xF3",
-      "%F3": "\xF3",
-      "%f4": "\xF4",
-      "%F4": "\xF4",
-      "%f5": "\xF5",
-      "%F5": "\xF5",
-      "%f6": "\xF6",
-      "%F6": "\xF6",
-      "%f7": "\xF7",
-      "%F7": "\xF7",
-      "%f8": "\xF8",
-      "%F8": "\xF8",
-      "%f9": "\xF9",
-      "%F9": "\xF9",
-      "%fa": "\xFA",
-      "%Fa": "\xFA",
-      "%fA": "\xFA",
-      "%FA": "\xFA",
-      "%fb": "\xFB",
-      "%Fb": "\xFB",
-      "%fB": "\xFB",
-      "%FB": "\xFB",
-      "%fc": "\xFC",
-      "%Fc": "\xFC",
-      "%fC": "\xFC",
-      "%FC": "\xFC",
-      "%fd": "\xFD",
-      "%Fd": "\xFD",
-      "%fD": "\xFD",
-      "%FD": "\xFD",
-      "%fe": "\xFE",
-      "%Fe": "\xFE",
-      "%fE": "\xFE",
-      "%FE": "\xFE",
-      "%ff": "\xFF",
-      "%Ff": "\xFF",
-      "%fF": "\xFF",
-      "%FF": "\xFF"
-    };
-    function encodedReplacer(match) {
-      return EncodedLookup[match];
-    }
-    var STATE_KEY = 0;
-    var STATE_VALUE = 1;
-    var STATE_CHARSET = 2;
-    var STATE_LANG = 3;
-    function parseParams(str) {
-      const res = [];
-      let state = STATE_KEY;
-      let charset = "";
-      let inquote = false;
-      let escaping = false;
-      let p = 0;
-      let tmp = "";
-      const len = str.length;
-      for (var i = 0; i < len; ++i) {
-        const char = str[i];
-        if (char === "\\" && inquote) {
-          if (escaping) {
-            escaping = false;
-          } else {
-            escaping = true;
-            continue;
-          }
-        } else if (char === '"') {
-          if (!escaping) {
-            if (inquote) {
-              inquote = false;
-              state = STATE_KEY;
-            } else {
-              inquote = true;
-            }
-            continue;
-          } else {
-            escaping = false;
-          }
-        } else {
-          if (escaping && inquote) {
-            tmp += "\\";
-          }
-          escaping = false;
-          if ((state === STATE_CHARSET || state === STATE_LANG) && char === "'") {
-            if (state === STATE_CHARSET) {
-              state = STATE_LANG;
-              charset = tmp.substring(1);
-            } else {
-              state = STATE_VALUE;
-            }
-            tmp = "";
-            continue;
-          } else if (state === STATE_KEY && (char === "*" || char === "=") && res.length) {
-            state = char === "*" ? STATE_CHARSET : STATE_VALUE;
-            res[p] = [tmp, void 0];
-            tmp = "";
-            continue;
-          } else if (!inquote && char === ";") {
-            state = STATE_KEY;
-            if (charset) {
-              if (tmp.length) {
-                tmp = decodeText(
-                  tmp.replace(RE_ENCODED, encodedReplacer),
-                  "binary",
-                  charset
-                );
-              }
-              charset = "";
-            } else if (tmp.length) {
-              tmp = decodeText(tmp, "binary", "utf8");
-            }
-            if (res[p] === void 0) {
-              res[p] = tmp;
-            } else {
-              res[p][1] = tmp;
-            }
-            tmp = "";
-            ++p;
-            continue;
-          } else if (!inquote && (char === " " || char === "	")) {
-            continue;
-          }
-        }
-        tmp += char;
-      }
-      if (charset && tmp.length) {
-        tmp = decodeText(
-          tmp.replace(RE_ENCODED, encodedReplacer),
-          "binary",
-          charset
-        );
-      } else if (tmp) {
-        tmp = decodeText(tmp, "binary", "utf8");
-      }
-      if (res[p] === void 0) {
-        if (tmp) {
-          res[p] = tmp;
-        }
-      } else {
-        res[p][1] = tmp;
-      }
-      return res;
-    }
-    module2.exports = parseParams;
-  }
-});
-// node_modules/@fastify/busboy/lib/utils/basename.js
-var require_basename = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/basename.js"(exports2, module2) {
-    "use strict";
-    module2.exports = function basename(path) {
-      if (typeof path !== "string") {
-        return "";
-      }
-      for (var i = path.length - 1; i >= 0; --i) {
-        switch (path.charCodeAt(i)) {
-          case 47:
-          // '/'
-          case 92:
-            path = path.slice(i + 1);
-            return path === ".." || path === "." ? "" : path;
-        }
-      }
-      return path === ".." || path === "." ? "" : path;
-    };
-  }
-});
-// node_modules/@fastify/busboy/lib/types/multipart.js
-var require_multipart = __commonJS({
-  "node_modules/@fastify/busboy/lib/types/multipart.js"(exports2, module2) {
-    "use strict";
-    var { Readable } = require("stream");
-    var { inherits } = require("util");
-    var Dicer = require_Dicer();
-    var parseParams = require_parseParams();
-    var decodeText = require_decodeText();
-    var basename = require_basename();
-    var getLimit = require_getLimit();
-    var RE_BOUNDARY = /^boundary$/i;
-    var RE_FIELD = /^form-data$/i;
-    var RE_CHARSET = /^charset$/i;
-    var RE_FILENAME = /^filename$/i;
-    var RE_NAME = /^name$/i;
-    Multipart2.detect = /^multipart\/form-data/i;
-    function Multipart2(boy, cfg) {
-      let i;
-      let len;
-      const self = this;
-      let boundary;
-      const limits = cfg.limits;
-      const isPartAFile = cfg.isPartAFile || ((fieldName, contentType, fileName) => contentType === "application/octet-stream" || fileName !== void 0);
-      const parsedConType = cfg.parsedConType || [];
-      const defCharset = cfg.defCharset || "utf8";
-      const preservePath = cfg.preservePath;
-      const fileOpts = { highWaterMark: cfg.fileHwm };
-      for (i = 0, len = parsedConType.length; i < len; ++i) {
-        if (Array.isArray(parsedConType[i]) && RE_BOUNDARY.test(parsedConType[i][0])) {
-          boundary = parsedConType[i][1];
-          break;
-        }
-      }
-      function checkFinished() {
-        if (nends === 0 && finished && !boy._done) {
-          finished = false;
-          self.end();
-        }
-      }
-      if (typeof boundary !== "string") {
-        throw new Error("Multipart: Boundary not found");
-      }
-      const fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
-      const fileSizeLimit = getLimit(limits, "fileSize", Infinity);
-      const filesLimit = getLimit(limits, "files", Infinity);
-      const fieldsLimit = getLimit(limits, "fields", Infinity);
-      const partsLimit = getLimit(limits, "parts", Infinity);
-      const headerPairsLimit = getLimit(limits, "headerPairs", 2e3);
-      const headerSizeLimit = getLimit(limits, "headerSize", 80 * 1024);
-      let nfiles = 0;
-      let nfields = 0;
-      let nends = 0;
-      let curFile;
-      let curField;
-      let finished = false;
-      this._needDrain = false;
-      this._pause = false;
-      this._cb = void 0;
-      this._nparts = 0;
-      this._boy = boy;
-      const parserCfg = {
-        boundary,
-        maxHeaderPairs: headerPairsLimit,
-        maxHeaderSize: headerSizeLimit,
-        partHwm: fileOpts.highWaterMark,
-        highWaterMark: cfg.highWaterMark
-      };
-      this.parser = new Dicer(parserCfg);
-      this.parser.on("drain", function() {
-        self._needDrain = false;
-        if (self._cb && !self._pause) {
-          const cb = self._cb;
-          self._cb = void 0;
-          cb();
-        }
-      }).on("part", function onPart(part) {
-        if (++self._nparts > partsLimit) {
-          self.parser.removeListener("part", onPart);
-          self.parser.on("part", skipPart);
-          boy.hitPartsLimit = true;
-          boy.emit("partsLimit");
-          return skipPart(part);
-        }
-        if (curField) {
-          const field = curField;
-          field.emit("end");
-          field.removeAllListeners("end");
-        }
-        part.on("header", function(header) {
-          let contype;
-          let fieldname;
-          let parsed;
-          let charset;
-          let encoding;
-          let filename;
-          let nsize = 0;
-          if (header["content-type"]) {
-            parsed = parseParams(header["content-type"][0]);
-            if (parsed[0]) {
-              contype = parsed[0].toLowerCase();
-              for (i = 0, len = parsed.length; i < len; ++i) {
-                if (RE_CHARSET.test(parsed[i][0])) {
-                  charset = parsed[i][1].toLowerCase();
-                  break;
-                }
-              }
-            }
-          }
-          if (contype === void 0) {
-            contype = "text/plain";
-          }
-          if (charset === void 0) {
-            charset = defCharset;
-          }
-          if (header["content-disposition"]) {
-            parsed = parseParams(header["content-disposition"][0]);
-            if (!RE_FIELD.test(parsed[0])) {
-              return skipPart(part);
-            }
-            for (i = 0, len = parsed.length; i < len; ++i) {
-              if (RE_NAME.test(parsed[i][0])) {
-                fieldname = parsed[i][1];
-              } else if (RE_FILENAME.test(parsed[i][0])) {
-                filename = parsed[i][1];
-                if (!preservePath) {
-                  filename = basename(filename);
-                }
-              }
-            }
-          } else {
-            return skipPart(part);
-          }
-          if (header["content-transfer-encoding"]) {
-            encoding = header["content-transfer-encoding"][0].toLowerCase();
-          } else {
-            encoding = "7bit";
-          }
-          let onData, onEnd;
-          if (isPartAFile(fieldname, contype, filename)) {
-            if (nfiles === filesLimit) {
-              if (!boy.hitFilesLimit) {
-                boy.hitFilesLimit = true;
-                boy.emit("filesLimit");
-              }
-              return skipPart(part);
-            }
-            ++nfiles;
-            if (boy.listenerCount("file") === 0) {
-              self.parser._ignore();
-              return;
-            }
-            ++nends;
-            const file = new FileStream(fileOpts);
-            curFile = file;
-            file.on("end", function() {
-              --nends;
-              self._pause = false;
-              checkFinished();
-              if (self._cb && !self._needDrain) {
-                const cb = self._cb;
-                self._cb = void 0;
-                cb();
-              }
-            });
-            file._read = function(n) {
-              if (!self._pause) {
-                return;
-              }
-              self._pause = false;
-              if (self._cb && !self._needDrain) {
-                const cb = self._cb;
-                self._cb = void 0;
-                cb();
-              }
-            };
-            boy.emit("file", fieldname, file, filename, encoding, contype);
-            onData = function(data) {
-              if ((nsize += data.length) > fileSizeLimit) {
-                const extralen = fileSizeLimit - nsize + data.length;
-                if (extralen > 0) {
-                  file.push(data.slice(0, extralen));
-                }
-                file.truncated = true;
-                file.bytesRead = fileSizeLimit;
-                part.removeAllListeners("data");
-                file.emit("limit");
-                return;
-              } else if (!file.push(data)) {
-                self._pause = true;
-              }
-              file.bytesRead = nsize;
-            };
-            onEnd = function() {
-              curFile = void 0;
-              file.push(null);
-            };
-          } else {
-            if (nfields === fieldsLimit) {
-              if (!boy.hitFieldsLimit) {
-                boy.hitFieldsLimit = true;
-                boy.emit("fieldsLimit");
-              }
-              return skipPart(part);
-            }
-            ++nfields;
-            ++nends;
-            let buffer = "";
-            let truncated = false;
-            curField = part;
-            onData = function(data) {
-              if ((nsize += data.length) > fieldSizeLimit) {
-                const extralen = fieldSizeLimit - (nsize - data.length);
-                buffer += data.toString("binary", 0, extralen);
-                truncated = true;
-                part.removeAllListeners("data");
-              } else {
-                buffer += data.toString("binary");
-              }
-            };
-            onEnd = function() {
-              curField = void 0;
-              if (buffer.length) {
-                buffer = decodeText(buffer, "binary", charset);
-              }
-              boy.emit("field", fieldname, buffer, false, truncated, encoding, contype);
-              --nends;
-              checkFinished();
-            };
-          }
-          part._readableState.sync = false;
-          part.on("data", onData);
-          part.on("end", onEnd);
-        }).on("error", function(err) {
-          if (curFile) {
-            curFile.emit("error", err);
-          }
-        });
-      }).on("error", function(err) {
-        boy.emit("error", err);
-      }).on("finish", function() {
-        finished = true;
-        checkFinished();
-      });
-    }
-    Multipart2.prototype.write = function(chunk, cb) {
-      const r = this.parser.write(chunk);
-      if (r && !this._pause) {
-        cb();
-      } else {
-        this._needDrain = !r;
-        this._cb = cb;
-      }
-    };
-    Multipart2.prototype.end = function() {
-      const self = this;
-      if (self.parser.writable) {
-        self.parser.end();
-      } else if (!self._boy._done) {
-        process.nextTick(function() {
-          self._boy._done = true;
-          self._boy.emit("finish");
-        });
-      }
-    };
-    function skipPart(part) {
-      part.resume();
-    }
-    function FileStream(opts) {
-      Readable.call(this, opts);
-      this.bytesRead = 0;
-      this.truncated = false;
-    }
-    inherits(FileStream, Readable);
-    FileStream.prototype._read = function(n) {
-    };
-    module2.exports = Multipart2;
-  }
-});
-// node_modules/@fastify/busboy/lib/utils/Decoder.js
-var require_Decoder = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports2, module2) {
-    "use strict";
-    var RE_PLUS = /\+/g;
-    var HEX = [
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      1,
-      1,
-      1,
-      1,
-      1,
-      1,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0,
-      0
-    ];
-    function Decoder() {
-      this.buffer = void 0;
-    }
-    Decoder.prototype.write = function(str) {
-      str = str.replace(RE_PLUS, " ");
-      let res = "";
-      let i = 0;
-      let p = 0;
-      const len = str.length;
-      for (; i < len; ++i) {
-        if (this.buffer !== void 0) {
-          if (!HEX[str.charCodeAt(i)]) {
-            res += "%" + this.buffer;
-            this.buffer = void 0;
-            --i;
-          } else {
-            this.buffer += str[i];
-            ++p;
-            if (this.buffer.length === 2) {
-              res += String.fromCharCode(parseInt(this.buffer, 16));
-              this.buffer = void 0;
-            }
-          }
-        } else if (str[i] === "%") {
-          if (i > p) {
-            res += str.substring(p, i);
-            p = i;
-          }
-          this.buffer = "";
-          ++p;
-        }
-      }
-      if (p < len && this.buffer === void 0) {
-        res += str.substring(p);
-      }
-      return res;
-    };
-    Decoder.prototype.reset = function() {
-      this.buffer = void 0;
-    };
-    module2.exports = Decoder;
-  }
-});
-// node_modules/@fastify/busboy/lib/types/urlencoded.js
-var require_urlencoded = __commonJS({
-  "node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports2, module2) {
-    "use strict";
-    var Decoder = require_Decoder();
-    var decodeText = require_decodeText();
-    var getLimit = require_getLimit();
-    var RE_CHARSET = /^charset$/i;
-    UrlEncoded.detect = /^application\/x-www-form-urlencoded/i;
-    function UrlEncoded(boy, cfg) {
-      const limits = cfg.limits;
-      const parsedConType = cfg.parsedConType;
-      this.boy = boy;
-      this.fieldSizeLimit = getLimit(limits, "fieldSize", 1 * 1024 * 1024);
-      this.fieldNameSizeLimit = getLimit(limits, "fieldNameSize", 100);
-      this.fieldsLimit = getLimit(limits, "fields", Infinity);
-      let charset;
-      for (var i = 0, len = parsedConType.length; i < len; ++i) {
-        if (Array.isArray(parsedConType[i]) && RE_CHARSET.test(parsedConType[i][0])) {
-          charset = parsedConType[i][1].toLowerCase();
-          break;
-        }
-      }
-      if (charset === void 0) {
-        charset = cfg.defCharset || "utf8";
-      }
-      this.decoder = new Decoder();
-      this.charset = charset;
-      this._fields = 0;
-      this._state = "key";
-      this._checkingBytes = true;
-      this._bytesKey = 0;
-      this._bytesVal = 0;
-      this._key = "";
-      this._val = "";
-      this._keyTrunc = false;
-      this._valTrunc = false;
-      this._hitLimit = false;
-    }
-    UrlEncoded.prototype.write = function(data, cb) {
-      if (this._fields === this.fieldsLimit) {
-        if (!this.boy.hitFieldsLimit) {
-          this.boy.hitFieldsLimit = true;
-          this.boy.emit("fieldsLimit");
-        }
-        return cb();
-      }
-      let idxeq;
-      let idxamp;
-      let i;
-      let p = 0;
-      const len = data.length;
-      while (p < len) {
-        if (this._state === "key") {
-          idxeq = idxamp = void 0;
-          for (i = p; i < len; ++i) {
-            if (!this._checkingBytes) {
-              ++p;
-            }
-            if (data[i] === 61) {
-              idxeq = i;
-              break;
-            } else if (data[i] === 38) {
-              idxamp = i;
-              break;
-            }
-            if (this._checkingBytes && this._bytesKey === this.fieldNameSizeLimit) {
-              this._hitLimit = true;
-              break;
-            } else if (this._checkingBytes) {
-              ++this._bytesKey;
-            }
-          }
-          if (idxeq !== void 0) {
-            if (idxeq > p) {
-              this._key += this.decoder.write(data.toString("binary", p, idxeq));
-            }
-            this._state = "val";
-            this._hitLimit = false;
-            this._checkingBytes = true;
-            this._val = "";
-            this._bytesVal = 0;
-            this._valTrunc = false;
-            this.decoder.reset();
-            p = idxeq + 1;
-          } else if (idxamp !== void 0) {
-            ++this._fields;
-            let key;
-            const keyTrunc = this._keyTrunc;
-            if (idxamp > p) {
-              key = this._key += this.decoder.write(data.toString("binary", p, idxamp));
-            } else {
-              key = this._key;
-            }
-            this._hitLimit = false;
-            this._checkingBytes = true;
-            this._key = "";
-            this._bytesKey = 0;
-            this._keyTrunc = false;
-            this.decoder.reset();
-            if (key.length) {
-              this.boy.emit(
-                "field",
-                decodeText(key, "binary", this.charset),
-                "",
-                keyTrunc,
-                false
-              );
-            }
-            p = idxamp + 1;
-            if (this._fields === this.fieldsLimit) {
-              return cb();
-            }
-          } else if (this._hitLimit) {
-            if (i > p) {
-              this._key += this.decoder.write(data.toString("binary", p, i));
-            }
-            p = i;
-            if ((this._bytesKey = this._key.length) === this.fieldNameSizeLimit) {
-              this._checkingBytes = false;
-              this._keyTrunc = true;
-            }
-          } else {
-            if (p < len) {
-              this._key += this.decoder.write(data.toString("binary", p));
-            }
-            p = len;
-          }
-        } else {
-          idxamp = void 0;
-          for (i = p; i < len; ++i) {
-            if (!this._checkingBytes) {
-              ++p;
-            }
-            if (data[i] === 38) {
-              idxamp = i;
-              break;
-            }
-            if (this._checkingBytes && this._bytesVal === this.fieldSizeLimit) {
-              this._hitLimit = true;
-              break;
-            } else if (this._checkingBytes) {
-              ++this._bytesVal;
-            }
-          }
-          if (idxamp !== void 0) {
-            ++this._fields;
-            if (idxamp > p) {
-              this._val += this.decoder.write(data.toString("binary", p, idxamp));
-            }
-            this.boy.emit(
-              "field",
-              decodeText(this._key, "binary", this.charset),
-              decodeText(this._val, "binary", this.charset),
-              this._keyTrunc,
-              this._valTrunc
-            );
-            this._state = "key";
-            this._hitLimit = false;
-            this._checkingBytes = true;
-            this._key = "";
-            this._bytesKey = 0;
-            this._keyTrunc = false;
-            this.decoder.reset();
-            p = idxamp + 1;
-            if (this._fields === this.fieldsLimit) {
-              return cb();
-            }
-          } else if (this._hitLimit) {
-            if (i > p) {
-              this._val += this.decoder.write(data.toString("binary", p, i));
-            }
-            p = i;
-            if (this._val === "" && this.fieldSizeLimit === 0 || (this._bytesVal = this._val.length) === this.fieldSizeLimit) {
-              this._checkingBytes = false;
-              this._valTrunc = true;
-            }
-          } else {
-            if (p < len) {
-              this._val += this.decoder.write(data.toString("binary", p));
-            }
-            p = len;
-          }
-        }
-      }
-      cb();
-    };
-    UrlEncoded.prototype.end = function() {
-      if (this.boy._done) {
-        return;
-      }
-      if (this._state === "key" && this._key.length > 0) {
-        this.boy.emit(
-          "field",
-          decodeText(this._key, "binary", this.charset),
-          "",
-          this._keyTrunc,
-          false
-        );
-      } else if (this._state === "val") {
-        this.boy.emit(
-          "field",
-          decodeText(this._key, "binary", this.charset),
-          decodeText(this._val, "binary", this.charset),
-          this._keyTrunc,
-          this._valTrunc
-        );
-      }
-      this.boy._done = true;
-      this.boy.emit("finish");
-    };
-    module2.exports = UrlEncoded;
-  }
-});
-// node_modules/@fastify/busboy/lib/main.js
-var require_main = __commonJS({
-  "node_modules/@fastify/busboy/lib/main.js"(exports2, module2) {
-    "use strict";
-    var WritableStream = require("stream").Writable;
-    var { inherits } = require("util");
-    var Dicer = require_Dicer();
-    var MultipartParser = require_multipart();
-    var UrlencodedParser = require_urlencoded();
-    var parseParams = require_parseParams();
-    function Busboy(opts) {
-      if (!(this instanceof Busboy)) {
-        return new Busboy(opts);
-      }
-      if (typeof opts !== "object") {
-        throw new TypeError("Busboy expected an options-Object.");
-      }
-      if (typeof opts.headers !== "object") {
-        throw new TypeError("Busboy expected an options-Object with headers-attribute.");
-      }
-      if (typeof opts.headers["content-type"] !== "string") {
-        throw new TypeError("Missing Content-Type-header.");
-      }
-      const {
-        headers,
-        ...streamOptions
-      } = opts;
-      this.opts = {
-        autoDestroy: false,
-        ...streamOptions
-      };
-      WritableStream.call(this, this.opts);
-      this._done = false;
-      this._parser = this.getParserByHeaders(headers);
-      this._finished = false;
-    }
-    inherits(Busboy, WritableStream);
-    Busboy.prototype.emit = function(ev) {
-      var _a;
-      if (ev === "finish") {
-        if (!this._done) {
-          (_a = this._parser) == null ? void 0 : _a.end();
-          return;
-        } else if (this._finished) {
-          return;
-        }
-        this._finished = true;
-      }
-      WritableStream.prototype.emit.apply(this, arguments);
-    };
-    Busboy.prototype.getParserByHeaders = function(headers) {
-      const parsed = parseParams(headers["content-type"]);
-      const cfg = {
-        defCharset: this.opts.defCharset,
-        fileHwm: this.opts.fileHwm,
-        headers,
-        highWaterMark: this.opts.highWaterMark,
-        isPartAFile: this.opts.isPartAFile,
-        limits: this.opts.limits,
-        parsedConType: parsed,
-        preservePath: this.opts.preservePath
-      };
-      if (MultipartParser.detect.test(parsed[0])) {
-        return new MultipartParser(this, cfg);
-      }
-      if (UrlencodedParser.detect.test(parsed[0])) {
-        return new UrlencodedParser(this, cfg);
-      }
-      throw new Error("Unsupported Content-Type.");
-    };
-    Busboy.prototype._write = function(chunk, encoding, cb) {
-      this._parser.write(chunk, cb);
-    };
-    module2.exports = Busboy;
-    module2.exports.default = Busboy;
-    module2.exports.Busboy = Busboy;
-    module2.exports.Dicer = Dicer;
-  }
-});
-// node_modules/fastify-plugin/lib/getPluginName.js
-var require_getPluginName = __commonJS({
-  "node_modules/fastify-plugin/lib/getPluginName.js"(exports2, module2) {
-    "use strict";
-    var fpStackTracePattern = /at\s{1}(?:.*\.)?plugin\s{1}.*\n\s*(.*)/;
-    var fileNamePattern = /(\w*(\.\w*)*)\..*/;
-    module2.exports = function getPluginName(fn) {
-      if (fn.name.length > 0) return fn.name;
-      const stackTraceLimit = Error.stackTraceLimit;
-      Error.stackTraceLimit = 10;
-      try {
-        throw new Error("anonymous function");
-      } catch (e) {
-        Error.stackTraceLimit = stackTraceLimit;
-        return extractPluginName(e.stack);
-      }
-    };
-    function extractPluginName(stack) {
-      const m = stack.match(fpStackTracePattern);
-      return m ? m[1].split(/[/\\]/).slice(-1)[0].match(fileNamePattern)[1] : "anonymous";
-    }
-    module2.exports.extractPluginName = extractPluginName;
-  }
-});
-// node_modules/fastify-plugin/lib/toCamelCase.js
-var require_toCamelCase = __commonJS({
-  "node_modules/fastify-plugin/lib/toCamelCase.js"(exports2, module2) {
-    "use strict";
-    module2.exports = function toCamelCase(name2) {
-      if (name2[0] === "@") {
-        name2 = name2.slice(1).replace("/", "-");
-      }
-      return name2.replace(/-(.)/g, function(match, g1) {
-        return g1.toUpperCase();
-      });
-    };
-  }
-});
-// node_modules/fastify-plugin/plugin.js
-var require_plugin = __commonJS({
-  "node_modules/fastify-plugin/plugin.js"(exports2, module2) {
-    "use strict";
-    var getPluginName = require_getPluginName();
-    var toCamelCase = require_toCamelCase();
-    var count = 0;
-    function plugin(fn, options = {}) {
-      let autoName = false;
-      if (fn.default !== void 0) {
-        fn = fn.default;
-      }
-      if (typeof fn !== "function") {
-        throw new TypeError(
-          `fastify-plugin expects a function, instead got a '${typeof fn}'`
-        );
-      }
-      if (typeof options === "string") {
-        options = {
-          fastify: options
-        };
-      }
-      if (typeof options !== "object" || Array.isArray(options) || options === null) {
-        throw new TypeError("The options object should be an object");
-      }
-      if (options.fastify !== void 0 && typeof options.fastify !== "string") {
-        throw new TypeError(`fastify-plugin expects a version string, instead got '${typeof options.fastify}'`);
-      }
-      if (!options.name) {
-        autoName = true;
-        options.name = getPluginName(fn) + "-auto-" + count++;
-      }
-      fn[Symbol.for("skip-override")] = options.encapsulate !== true;
-      fn[Symbol.for("fastify.display-name")] = options.name;
-      fn[Symbol.for("plugin-meta")] = options;
-      if (!fn.default) {
-        fn.default = fn;
-      }
-      const camelCase = toCamelCase(options.name);
-      if (!autoName && !fn[camelCase]) {
-        fn[camelCase] = fn;
-      }
-      return fn;
-    }
-    module2.exports = plugin;
-    module2.exports.default = plugin;
-    module2.exports.fastifyPlugin = plugin;
-  }
-});
-// node_modules/@fastify/multipart/lib/generateId.js
-var require_generateId = __commonJS({
-  "node_modules/@fastify/multipart/lib/generateId.js"(exports2, module2) {
-    "use strict";
-    var HEX = [
-      "00",
-      "01",
-      "02",
-      "03",
-      "04",
-      "05",
-      "06",
-      "07",
-      "08",
-      "09",
-      "0a",
-      "0b",
-      "0c",
-      "0d",
-      "0e",
-      "0f",
-      "10",
-      "11",
-      "12",
-      "13",
-      "14",
-      "15",
-      "16",
-      "17",
-      "18",
-      "19",
-      "1a",
-      "1b",
-      "1c",
-      "1d",
-      "1e",
-      "1f",
-      "20",
-      "21",
-      "22",
-      "23",
-      "24",
-      "25",
-      "26",
-      "27",
-      "28",
-      "29",
-      "2a",
-      "2b",
-      "2c",
-      "2d",
-      "2e",
-      "2f",
-      "30",
-      "31",
-      "32",
-      "33",
-      "34",
-      "35",
-      "36",
-      "37",
-      "38",
-      "39",
-      "3a",
-      "3b",
-      "3c",
-      "3d",
-      "3e",
-      "3f",
-      "40",
-      "41",
-      "42",
-      "43",
-      "44",
-      "45",
-      "46",
-      "47",
-      "48",
-      "49",
-      "4a",
-      "4b",
-      "4c",
-      "4d",
-      "4e",
-      "4f",
-      "50",
-      "51",
-      "52",
-      "53",
-      "54",
-      "55",
-      "56",
-      "57",
-      "58",
-      "59",
-      "5a",
-      "5b",
-      "5c",
-      "5d",
-      "5e",
-      "5f",
-      "60",
-      "61",
-      "62",
-      "63",
-      "64",
-      "65",
-      "66",
-      "67",
-      "68",
-      "69",
-      "6a",
-      "6b",
-      "6c",
-      "6d",
-      "6e",
-      "6f",
-      "70",
-      "71",
-      "72",
-      "73",
-      "74",
-      "75",
-      "76",
-      "77",
-      "78",
-      "79",
-      "7a",
-      "7b",
-      "7c",
-      "7d",
-      "7e",
-      "7f",
-      "80",
-      "81",
-      "82",
-      "83",
-      "84",
-      "85",
-      "86",
-      "87",
-      "88",
-      "89",
-      "8a",
-      "8b",
-      "8c",
-      "8d",
-      "8e",
-      "8f",
-      "90",
-      "91",
-      "92",
-      "93",
-      "94",
-      "95",
-      "96",
-      "97",
-      "98",
-      "99",
-      "9a",
-      "9b",
-      "9c",
-      "9d",
-      "9e",
-      "9f",
-      "a0",
-      "a1",
-      "a2",
-      "a3",
-      "a4",
-      "a5",
-      "a6",
-      "a7",
-      "a8",
-      "a9",
-      "aa",
-      "ab",
-      "ac",
-      "ad",
-      "ae",
-      "af",
-      "b0",
-      "b1",
-      "b2",
-      "b3",
-      "b4",
-      "b5",
-      "b6",
-      "b7",
-      "b8",
-      "b9",
-      "ba",
-      "bb",
-      "bc",
-      "bd",
-      "be",
-      "bf",
-      "c0",
-      "c1",
-      "c2",
-      "c3",
-      "c4",
-      "c5",
-      "c6",
-      "c7",
-      "c8",
-      "c9",
-      "ca",
-      "cb",
-      "cc",
-      "cd",
-      "ce",
-      "cf",
-      "d0",
-      "d1",
-      "d2",
-      "d3",
-      "d4",
-      "d5",
-      "d6",
-      "d7",
-      "d8",
-      "d9",
-      "da",
-      "db",
-      "dc",
-      "dd",
-      "de",
-      "df",
-      "e0",
-      "e1",
-      "e2",
-      "e3",
-      "e4",
-      "e5",
-      "e6",
-      "e7",
-      "e8",
-      "e9",
-      "ea",
-      "eb",
-      "ec",
-      "ed",
-      "ee",
-      "ef",
-      "f0",
-      "f1",
-      "f2",
-      "f3",
-      "f4",
-      "f5",
-      "f6",
-      "f7",
-      "f8",
-      "f9",
-      "fa",
-      "fb",
-      "fc",
-      "fd",
-      "fe",
-      "ff"
-    ];
-    var random = Math.random;
-    function seed() {
-      return HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0] + HEX[255 * random() | 0];
-    }
-    module2.exports.generateId = function generateIdFn() {
-      let num = 0;
-      let str = seed();
-      return function generateId() {
-        return num === 255 ? (str = seed()) + HEX[num = 0] : str + HEX[++num];
-      };
-    }();
-  }
-});
-// node_modules/@fastify/error/index.js
-var require_error = __commonJS({
-  "node_modules/@fastify/error/index.js"(exports2, module2) {
-    "use strict";
-    var { format } = require("util");
-    function toString() {
-      return `${this.name} [${this.code}]: ${this.message}`;
-    }
-    function createError(code, message, statusCode = 500, Base = Error, captureStackTrace = createError.captureStackTrace) {
-      if (!code) throw new Error("Fastify error code must not be empty");
-      if (!message) throw new Error("Fastify error message must not be empty");
-      code = code.toUpperCase();
-      !statusCode && (statusCode = void 0);
-      function FastifyError(...args) {
-        if (!new.target) {
-          return new FastifyError(...args);
-        }
-        this.code = code;
-        this.name = "FastifyError";
-        this.statusCode = statusCode;
-        const lastElement = args.length - 1;
-        if (lastElement !== -1 && args[lastElement] && typeof args[lastElement] === "object" && "cause" in args[lastElement]) {
-          this.cause = args.pop().cause;
-        }
-        this.message = format(message, ...args);
-        Error.stackTraceLimit && captureStackTrace && Error.captureStackTrace(this, FastifyError);
-      }
-      FastifyError.prototype = Object.create(Base.prototype, {
-        constructor: {
-          value: FastifyError,
-          enumerable: false,
-          writable: true,
-          configurable: true
-        }
-      });
-      FastifyError.prototype[Symbol.toStringTag] = "Error";
-      FastifyError.prototype.toString = toString;
-      return FastifyError;
-    }
-    createError.captureStackTrace = true;
-    module2.exports = createError;
-    module2.exports.default = createError;
-    module2.exports.createError = createError;
-  }
-});
-// node_modules/@fastify/multipart/lib/stream-consumer.js
-var require_stream_consumer = __commonJS({
-  "node_modules/@fastify/multipart/lib/stream-consumer.js"(exports2, module2) {
-    "use strict";
-    module2.exports = function streamToNull(stream) {
-      return new Promise((resolve, reject) => {
-        stream.on("data", () => {
-        });
-        stream.on("close", () => {
-          resolve();
-        });
-        stream.on("end", () => {
-          resolve();
-        });
-        stream.on("error", (error) => {
-          reject(error);
-        });
-      });
-    };
-  }
-});
-// node_modules/@fastify/deepmerge/index.js
-var require_deepmerge = __commonJS({
-  "node_modules/@fastify/deepmerge/index.js"(exports2, module2) {
-    "use strict";
-    var JSON_PROTO = Object.getPrototypeOf({});
-    function deepmergeConstructor(options) {
-      function isNotPrototypeKey(value) {
-        return value !== "constructor" && value !== "prototype" && value !== "__proto__";
-      }
-      function cloneArray(value) {
-        let i = 0;
-        const il = value.length;
-        const result = new Array(il);
-        for (i; i < il; ++i) {
-          result[i] = clone(value[i]);
-        }
-        return result;
-      }
-      function cloneObject(target) {
-        const result = {};
-        if (cloneProtoObject && Object.getPrototypeOf(target) !== JSON_PROTO) {
-          return cloneProtoObject(target);
-        }
-        const targetKeys = getKeys(target);
-        let i, il, key;
-        for (i = 0, il = targetKeys.length; i < il; ++i) {
-          isNotPrototypeKey(key = targetKeys[i]) && (result[key] = clone(target[key]));
-        }
-        return result;
-      }
-      function concatArrays(target, source) {
-        const tl = target.length;
-        const sl = source.length;
-        let i = 0;
-        const result = new Array(tl + sl);
-        for (i; i < tl; ++i) {
-          result[i] = clone(target[i]);
-        }
-        for (i = 0; i < sl; ++i) {
-          result[i + tl] = clone(source[i]);
-        }
-        return result;
-      }
-      const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
-      function getSymbolsAndKeys(value) {
-        const result = Object.keys(value);
-        const keys = Object.getOwnPropertySymbols(value);
-        for (let i = 0, il = keys.length; i < il; ++i) {
-          propertyIsEnumerable.call(value, keys[i]) && result.push(keys[i]);
-        }
-        return result;
-      }
-      const getKeys = (options == null ? void 0 : options.symbols) ? getSymbolsAndKeys : Object.keys;
-      const cloneProtoObject = typeof (options == null ? void 0 : options.cloneProtoObject) === "function" ? options.cloneProtoObject : void 0;
-      function isMergeableObject(value) {
-        return typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Date);
-      }
-      function isPrimitive(value) {
-        return typeof value !== "object" || value === null;
-      }
-      const isPrimitiveOrBuiltIn = typeof Buffer !== "undefined" ? (value) => typeof value !== "object" || value === null || value instanceof RegExp || value instanceof Date || value instanceof Buffer : (value) => typeof value !== "object" || value === null || value instanceof RegExp || value instanceof Date;
-      const mergeArray = options && typeof options.mergeArray === "function" ? options.mergeArray({ clone, deepmerge: _deepmerge, getKeys, isMergeableObject }) : concatArrays;
-      function clone(entry) {
-        return isMergeableObject(entry) ? Array.isArray(entry) ? cloneArray(entry) : cloneObject(entry) : entry;
-      }
-      function mergeObject(target, source) {
-        const result = {};
-        const targetKeys = getKeys(target);
-        const sourceKeys = getKeys(source);
-        let i, il, key;
-        for (i = 0, il = targetKeys.length; i < il; ++i) {
-          isNotPrototypeKey(key = targetKeys[i]) && sourceKeys.indexOf(key) === -1 && (result[key] = clone(target[key]));
-        }
-        for (i = 0, il = sourceKeys.length; i < il; ++i) {
-          if (!isNotPrototypeKey(key = sourceKeys[i])) {
-            continue;
-          }
-          if (key in target) {
-            if (targetKeys.indexOf(key) !== -1) {
-              if (cloneProtoObject && isMergeableObject(source[key]) && Object.getPrototypeOf(source[key]) !== JSON_PROTO) {
-                result[key] = cloneProtoObject(source[key]);
-              } else {
-                result[key] = _deepmerge(target[key], source[key]);
-              }
-            }
-          } else {
-            result[key] = clone(source[key]);
-          }
-        }
-        return result;
-      }
-      function _deepmerge(target, source) {
-        const sourceIsArray = Array.isArray(source);
-        const targetIsArray = Array.isArray(target);
-        if (isPrimitive(source)) {
-          return source;
-        } else if (isPrimitiveOrBuiltIn(target)) {
-          return clone(source);
-        } else if (sourceIsArray && targetIsArray) {
-          return mergeArray(target, source);
-        } else if (sourceIsArray !== targetIsArray) {
-          return clone(source);
-        } else {
-          return mergeObject(target, source);
-        }
-      }
-      function _deepmergeAll() {
-        switch (arguments.length) {
-          case 0:
-            return {};
-          case 1:
-            return clone(arguments[0]);
-          case 2:
-            return _deepmerge(arguments[0], arguments[1]);
-        }
-        let result;
-        for (let i = 0, il = arguments.length; i < il; ++i) {
-          result = _deepmerge(result, arguments[i]);
-        }
-        return result;
-      }
-      return (options == null ? void 0 : options.all) ? _deepmergeAll : _deepmerge;
-    }
-    module2.exports = deepmergeConstructor;
-    module2.exports.default = deepmergeConstructor;
-    module2.exports.deepmerge = deepmergeConstructor;
-  }
-});
-// node_modules/secure-json-parse/index.js
-var require_secure_json_parse = __commonJS({
-  "node_modules/secure-json-parse/index.js"(exports2, module2) {
-    "use strict";
-    var hasBuffer = typeof Buffer !== "undefined";
-    var suspectProtoRx = /"(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])"\s*:/;
-    var suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
-    function _parse(text, reviver, options) {
-      if (options == null) {
-        if (reviver !== null && typeof reviver === "object") {
-          options = reviver;
-          reviver = void 0;
-        }
-      }
-      if (hasBuffer && Buffer.isBuffer(text)) {
-        text = text.toString();
-      }
-      if (text && text.charCodeAt(0) === 65279) {
-        text = text.slice(1);
-      }
-      const obj = JSON.parse(text, reviver);
-      if (obj === null || typeof obj !== "object") {
-        return obj;
-      }
-      const protoAction = options && options.protoAction || "error";
-      const constructorAction = options && options.constructorAction || "error";
-      if (protoAction === "ignore" && constructorAction === "ignore") {
-        return obj;
-      }
-      if (protoAction !== "ignore" && constructorAction !== "ignore") {
-        if (suspectProtoRx.test(text) === false && suspectConstructorRx.test(text) === false) {
-          return obj;
-        }
-      } else if (protoAction !== "ignore" && constructorAction === "ignore") {
-        if (suspectProtoRx.test(text) === false) {
-          return obj;
-        }
-      } else {
-        if (suspectConstructorRx.test(text) === false) {
-          return obj;
-        }
-      }
-      return filter(obj, { protoAction, constructorAction, safe: options && options.safe });
-    }
-    function filter(obj, { protoAction = "error", constructorAction = "error", safe } = {}) {
-      let next = [obj];
-      while (next.length) {
-        const nodes = next;
-        next = [];
-        for (const node of nodes) {
-          if (protoAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "__proto__")) {
-            if (safe === true) {
-              return null;
-            } else if (protoAction === "error") {
-              throw new SyntaxError("Object contains forbidden prototype property");
-            }
-            delete node.__proto__;
-          }
-          if (constructorAction !== "ignore" && Object.prototype.hasOwnProperty.call(node, "constructor") && Object.prototype.hasOwnProperty.call(node.constructor, "prototype")) {
-            if (safe === true) {
-              return null;
-            } else if (constructorAction === "error") {
-              throw new SyntaxError("Object contains forbidden prototype property");
-            }
-            delete node.constructor;
-          }
-          for (const key in node) {
-            const value = node[key];
-            if (value && typeof value === "object") {
-              next.push(value);
-            }
-          }
-        }
-      }
-      return obj;
-    }
-    function parse(text, reviver, options) {
-      const { stackTraceLimit } = Error;
-      Error.stackTraceLimit = 0;
-      try {
-        return _parse(text, reviver, options);
-      } finally {
-        Error.stackTraceLimit = stackTraceLimit;
-      }
-    }
-    function safeParse(text, reviver) {
-      const { stackTraceLimit } = Error;
-      Error.stackTraceLimit = 0;
-      try {
-        return _parse(text, reviver, { safe: true });
-      } catch (_e) {
-        return null;
-      } finally {
-        Error.stackTraceLimit = stackTraceLimit;
-      }
-    }
-    module2.exports = parse;
-    module2.exports.default = parse;
-    module2.exports.parse = parse;
-    module2.exports.safeParse = safeParse;
-    module2.exports.scan = filter;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-});
-// node_modules/@fastify/multipart/index.js
-var require_multipart2 = __commonJS({
-  "node_modules/@fastify/multipart/index.js"(exports2, module2) {
-    "use strict";
-    var Busboy = require_main();
-    var os = require("os");
-    var fp = require_plugin();
-    var { createWriteStream } = require("fs");
-    var { unlink } = require("fs/promises");
-    var path = require("path");
-    var { generateId } = require_generateId();
-    var createError = require_error();
-    var streamToNull = require_stream_consumer();
-    var deepmergeAll = require_deepmerge()({ all: true });
-    var { PassThrough, Readable } = require("stream");
-    var { pipeline: pump } = require("stream/promises");
-    var secureJSON = require_secure_json_parse();
-    var kMultipart = Symbol("multipart");
-    var kMultipartHandler = Symbol("multipartHandler");
-    var PartsLimitError = createError("FST_PARTS_LIMIT", "reach parts limit", 413);
-    var FilesLimitError = createError("FST_FILES_LIMIT", "reach files limit", 413);
-    var FieldsLimitError = createError("FST_FIELDS_LIMIT", "reach fields limit", 413);
-    var RequestFileTooLargeError = createError("FST_REQ_FILE_TOO_LARGE", "request file too large", 413);
-    var PrototypeViolationError = createError("FST_PROTO_VIOLATION", "prototype property is not allowed as field name", 400);
-    var InvalidMultipartContentTypeError = createError("FST_INVALID_MULTIPART_CONTENT_TYPE", "the request is not multipart", 406);
-    var InvalidJSONFieldError = createError("FST_INVALID_JSON_FIELD_ERROR", "a request field is not a valid JSON as declared by its Content-Type", 406);
-    var FileBufferNotFoundError = createError("FST_FILE_BUFFER_NOT_FOUND", "the file buffer was not found", 500);
-    var NoFormData = createError("FST_NO_FORM_DATA", "FormData is not available", 500);
-    function setMultipart(req, _payload, done) {
-      req[kMultipart] = true;
-      done();
-    }
-    function busboy(options) {
-      try {
-        return new Busboy(options);
-      } catch (error) {
-        const errorEmitter = new PassThrough();
-        process.nextTick(function() {
-          errorEmitter.emit("error", error);
-        });
-        return errorEmitter;
-      }
-    }
-    function fastifyMultipart(fastify2, options, done) {
-      var _a, _b;
-      options.limits = {
-        ...options.limits,
-        parts: ((_a = options.limits) == null ? void 0 : _a.parts) || 1e3,
-        fileSize: ((_b = options.limits) == null ? void 0 : _b.fileSize) || fastify2.initialConfig.bodyLimit
-      };
-      const attachFieldsToBody = options.attachFieldsToBody;
-      if (attachFieldsToBody === true || attachFieldsToBody === "keyValues") {
-        if (typeof options.sharedSchemaId === "string" && attachFieldsToBody === true) {
-          fastify2.addSchema({
-            $id: options.sharedSchemaId,
-            type: "object",
-            properties: {
-              fieldname: { type: "string" },
-              encoding: { type: "string" },
-              filename: { type: "string" },
-              mimetype: { type: "string" }
-            }
-          });
-        }
-        fastify2.addHook("preValidation", async function(req) {
-          if (!req.isMultipart()) {
-            return;
-          }
-          for await (const part of req.parts()) {
-            req.body = part.fields;
-            if (part.file) {
-              if (options.onFile) {
-                await options.onFile.call(req, part);
-              } else {
-                await part.toBuffer();
-              }
-            }
-          }
-          if (attachFieldsToBody === "keyValues") {
-            const body = {};
-            if (req.body) {
-              const reqBodyKeys = Object.keys(req.body);
-              for (let i = 0; i < reqBodyKeys.length; ++i) {
-                const key = reqBodyKeys[i];
-                const field = req.body[key];
-                if (field.value !== void 0) {
-                  body[key] = field.value;
-                } else if (field._buf) {
-                  body[key] = field._buf;
-                } else if (Array.isArray(field)) {
-                  const items = [];
-                  for (let i2 = 0; i2 < field.length; ++i2) {
-                    const item = field[i2];
-                    if (item.value !== void 0) {
-                      items.push(item.value);
-                    } else if (item._buf) {
-                      items.push(item._buf);
-                    }
-                  }
-                  if (items.length) {
-                    body[key] = items;
-                  }
-                }
-              }
-            }
-            req.body = body;
-          }
-        });
-        if (globalThis.FormData && !fastify2.hasRequestDecorator("formData")) {
-          fastify2.decorateRequest("formData", async function() {
-            const formData = new FormData();
-            for (const key in this.body) {
-              const value = this.body[key];
-              if (Array.isArray(value)) {
-                for (const item of value) {
-                  await append(key, item);
-                }
-              } else {
-                await append(key, value);
-              }
-            }
-            async function append(key, entry) {
-              if (entry.type === "file" || attachFieldsToBody === "keyValues" && Buffer.isBuffer(entry)) {
-                formData.append(key, new Blob([await entry.toBuffer()], {
-                  type: entry.mimetype
-                }), entry.filename);
-              } else {
-                formData.append(key, entry.value);
-              }
-            }
-            return formData;
-          });
-        }
-      }
-      if (!fastify2.hasRequestDecorator("formData")) {
-        fastify2.decorateRequest("formData", async function() {
-          throw new NoFormData();
-        });
-      }
-      const defaultThrowFileSizeLimit = typeof options.throwFileSizeLimit === "boolean" ? options.throwFileSizeLimit : true;
-      fastify2.decorate("multipartErrors", {
-        PartsLimitError,
-        FilesLimitError,
-        FieldsLimitError,
-        PrototypeViolationError,
-        InvalidMultipartContentTypeError,
-        RequestFileTooLargeError,
-        FileBufferNotFoundError
-      });
-      fastify2.addContentTypeParser("multipart/form-data", setMultipart);
-      fastify2.decorateRequest(kMultipart, false);
-      fastify2.decorateRequest(kMultipartHandler, handleMultipart);
-      fastify2.decorateRequest("parts", getMultipartIterator);
-      fastify2.decorateRequest("isMultipart", isMultipart);
-      fastify2.decorateRequest("tmpUploads", null);
-      fastify2.decorateRequest("savedRequestFiles", null);
-      fastify2.decorateRequest("file", getMultipartFile);
-      fastify2.decorateRequest("files", getMultipartFiles);
-      fastify2.decorateRequest("saveRequestFiles", saveRequestFiles);
-      fastify2.decorateRequest("cleanRequestFiles", cleanRequestFiles);
-      fastify2.addHook("onResponse", async (request) => {
-        await request.cleanRequestFiles();
-      });
-      function isMultipart() {
-        return this[kMultipart];
-      }
-      function handleMultipart(opts = {}) {
-        if (!this.isMultipart()) {
-          throw new InvalidMultipartContentTypeError();
-        }
-        this.log.debug("starting multipart parsing");
-        let values = [];
-        let pendingHandler = null;
-        const ch = (val) => {
-          if (pendingHandler) {
-            pendingHandler(val);
-            pendingHandler = null;
-          } else {
-            values.push(val);
-          }
-        };
-        const handle = (handler) => {
-          if (values.length > 0) {
-            const value = values[0];
-            values = values.slice(1);
-            handler(value);
-          } else {
-            pendingHandler = handler;
-          }
-        };
-        const parts = () => {
-          return new Promise((resolve, reject) => {
-            handle((val) => {
-              if (val instanceof Error) {
-                if (val.message === "Unexpected end of multipart data") {
-                  resolve(null);
-                } else {
-                  reject(val);
-                }
-              } else {
-                resolve(val);
-              }
-            });
-          });
-        };
-        const body = {};
-        let lastError = null;
-        let currentFile = null;
-        const request = this.raw;
-        const busboyOptions = deepmergeAll(
-          { headers: request.headers },
-          options,
-          opts
-        );
-        this.log.trace({ busboyOptions }, "Providing options to busboy");
-        const bb = busboy(busboyOptions);
-        request.on("close", cleanup);
-        request.on("error", cleanup);
-        bb.on("field", onField).on("file", onFile).on("end", cleanup).on("finish", cleanup).on("close", cleanup).on("error", cleanup);
-        bb.on("partsLimit", function() {
-          const err = new PartsLimitError();
-          onError(err);
-          process.nextTick(() => cleanup(err));
-        });
-        bb.on("filesLimit", function() {
-          const err = new FilesLimitError();
-          onError(err);
-          process.nextTick(() => cleanup(err));
-        });
-        bb.on("fieldsLimit", function() {
-          const err = new FieldsLimitError();
-          onError(err);
-          process.nextTick(() => cleanup(err));
-        });
-        request.pipe(bb);
-        function onField(name2, fieldValue, fieldnameTruncated, valueTruncated, encoding, contentType) {
-          if (name2 in Object.prototype) {
-            onError(new PrototypeViolationError());
-            return;
-          }
-          if (contentType.startsWith("application/json")) {
-            if (valueTruncated) {
-              onError(new InvalidJSONFieldError());
-              return;
-            }
-            try {
-              fieldValue = secureJSON.parse(fieldValue);
-              contentType = "application/json";
-            } catch {
-              onError(new InvalidJSONFieldError());
-              return;
-            }
-          }
-          const value = {
-            type: "field",
-            fieldname: name2,
-            mimetype: contentType,
-            encoding,
-            value: fieldValue,
-            fieldnameTruncated,
-            valueTruncated,
-            fields: body
-          };
-          if (body[name2] === void 0) {
-            body[name2] = value;
-          } else if (Array.isArray(body[name2])) {
-            body[name2].push(value);
-          } else {
-            body[name2] = [body[name2], value];
-          }
-          ch(value);
-        }
-        function onFile(name2, file, filename, encoding, mimetype) {
-          if (name2 in Object.prototype) {
-            streamToNull(file).catch(() => {
-            });
-            onError(new PrototypeViolationError());
-            return;
-          }
-          const throwFileSizeLimit = typeof opts.throwFileSizeLimit === "boolean" ? opts.throwFileSizeLimit : defaultThrowFileSizeLimit;
-          const value = {
-            type: "file",
-            fieldname: name2,
-            filename,
-            encoding,
-            mimetype,
-            file,
-            fields: body,
-            _buf: null,
-            async toBuffer() {
-              if (this._buf) {
-                return this._buf;
-              }
-              const fileChunks = [];
-              let err;
-              for await (const chunk of this.file) {
-                fileChunks.push(chunk);
-                if (throwFileSizeLimit && this.file.truncated) {
-                  err = new RequestFileTooLargeError();
-                  err.part = this;
-                  onError(err);
-                  fileChunks.length = 0;
-                }
-              }
-              if (err) {
-                throw err;
-              }
-              this._buf = Buffer.concat(fileChunks);
-              return this._buf;
-            }
-          };
-          if (throwFileSizeLimit) {
-            file.on("limit", function() {
-              const err = new RequestFileTooLargeError();
-              err.part = value;
-              onError(err);
-            });
-          }
-          if (body[name2] === void 0) {
-            body[name2] = value;
-          } else if (Array.isArray(body[name2])) {
-            body[name2].push(value);
-          } else {
-            body[name2] = [body[name2], value];
-          }
-          currentFile = file;
-          ch(value);
-        }
-        function onError(err) {
-          lastError = err;
-          currentFile = null;
-        }
-        function cleanup(err) {
-          request.unpipe(bb);
-          if ((err || request.aborted) && currentFile) {
-            currentFile.destroy();
-            currentFile = null;
-          }
-          ch(err || lastError || null);
-        }
-        return parts;
-      }
-      async function saveRequestFiles(options2) {
-        if (this.savedRequestFiles) {
-          return this.savedRequestFiles;
-        }
-        let files;
-        if (attachFieldsToBody === true) {
-          if (!this.body) {
-            return [];
-          }
-          files = filesFromFields.call(this, this.body);
-        } else {
-          files = await this.files(options2);
-        }
-        this.savedRequestFiles = [];
-        const tmpdir = (options2 == null ? void 0 : options2.tmpdir) || os.tmpdir();
-        this.tmpUploads = [];
-        let i = 0;
-        for await (const file of files) {
-          const filepath = path.join(tmpdir, generateId() + path.extname(file.filename || "file" + i++));
-          const target = createWriteStream(filepath);
-          try {
-            this.tmpUploads.push(filepath);
-            await pump(file.file, target);
-            this.savedRequestFiles.push({ ...file, filepath });
-          } catch (err) {
-            this.log.error({ err }, "save request file");
-            throw err;
-          }
-        }
-        return this.savedRequestFiles;
-      }
-      function* filesFromFields(container) {
-        try {
-          const fields = Array.isArray(container) ? container : Object.values(container);
-          for (let i = 0; i < fields.length; ++i) {
-            const field = fields[i];
-            if (Array.isArray(field)) {
-              for (const subField of filesFromFields.call(this, field)) {
-                yield subField;
-              }
-            }
-            if (!field.file) {
-              continue;
-            }
-            if (!field._buf) {
-              throw new FileBufferNotFoundError();
-            }
-            field.file = Readable.from(field._buf);
-            yield field;
-          }
-        } catch (err) {
-          this.log.error({ err }, "save request file failed");
-          throw err;
-        }
-      }
-      async function cleanRequestFiles() {
-        if (!this.tmpUploads) {
-          return;
-        }
-        for (let i = 0; i < this.tmpUploads.length; ++i) {
-          const filepath = this.tmpUploads[i];
-          try {
-            await unlink(filepath);
-          } catch (error) {
-            this.log.error(error, "Could not delete file");
-          }
-        }
-      }
-      async function getMultipartFile(options2) {
-        const parts = this[kMultipartHandler](options2);
-        let part;
-        while ((part = await parts()) != null) {
-          if (part.file) {
-            return part;
-          }
-        }
-      }
-      async function* getMultipartFiles(options2) {
-        const parts = this[kMultipartHandler](options2);
-        let part;
-        while ((part = await parts()) != null) {
-          if (part.file) {
-            yield part;
-          }
-        }
-      }
-      async function* getMultipartIterator(options2) {
-        const parts = this[kMultipartHandler](options2);
-        let part;
-        while ((part = await parts()) != null) {
-          yield part;
-        }
-      }
-      done();
-    }
-    function ajvFilePlugin(ajv) {
-      return ajv.addKeyword({
-        keyword: "isFile",
-        compile: (_schema, parent) => {
-          parent.type = "string";
-          parent.format = "binary";
-          delete parent.isFile;
-          return (field) => !!field.file;
-        },
-        error: {
-          message: "should be a file"
-        }
-      });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decoratorStart = (base) => [, , , __create((base == null ? void 0 : base[__knownSymbol("metadata")]) ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name2, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name: name2, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name2, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name2]() {
+    return __privateGet(this, extra);
+  }, set [name2](x) {
+    return __privateSet(this, extra, x);
+  } }, name2));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name2) : __name(target, name2);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name2, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name2 in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name2];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name2] = y;
     }
-    module2.exports = fp(fastifyMultipart, {
-      fastify: "5.x",
-      name: "@fastify/multipart"
-    });
-    module2.exports.default = fastifyMultipart;
-    module2.exports.fastifyMultipart = fastifyMultipart;
-    module2.exports.ajvFilePlugin = ajvFilePlugin;
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
   }
-});
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name2, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 // packages/core/src/index.mts
 var src_exports = {};
@@ -5814,6 +2695,7 @@ var AttributeFactory = class {
 // packages/core/src/navios.application.mts
 var import_cors = __toESM(require("@fastify/cors"), 1);
+var import_multipart = __toESM(require("@fastify/multipart"), 1);
 var import_fastify = require("fastify");
 var import_fastify_type_provider_zod = require("fastify-type-provider-zod");
 var _NaviosApplication_decorators, _init8;
@@ -5914,18 +2796,10 @@ var _NaviosApplication = class _NaviosApplication {
   }
   async configureMultipart(server, options) {
     if (options) {
-      try {
-        const multipartModule = await Promise.resolve().then(() => __toESM(require_multipart2(), 1));
-        await server.register(
-          multipartModule.default,
-          typeof options === "object" ? options : {}
-        );
-      } catch (error) {
-        this.logger.error(
-          `@fastify/multipart is not installed. Please install it.`
-        );
-        throw error;
-      }
+      await server.register(
+        import_multipart.default,
+        typeof options === "object" ? options : {}
+      );
     }
   }
   async initModules() {