@navios/core 0.1.10 → 0.1.12

package/dist/multipart-23QO76VV.mjs

@@ -1,3120 +0,0 @@
-import {
-  __commonJS,
-  __require
-} from "./chunk-Z2AVZ4BT.mjs";
-
-// node_modules/@fastify/busboy/deps/streamsearch/sbmh.js
-var require_sbmh = __commonJS({
-  "node_modules/@fastify/busboy/deps/streamsearch/sbmh.js"(exports, module) {
-    "use strict";
-    var { EventEmitter } = __require("node:events");
-    var { inherits } = __require("node: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, EventEmitter);
-    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;
-    };
-    module.exports = SBMH;
-  }
-});
-
-// node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js
-var require_PartStream = __commonJS({
-  "node_modules/@fastify/busboy/deps/dicer/lib/PartStream.js"(exports, module) {
-    "use strict";
-    var inherits = __require("node:util").inherits;
-    var ReadableStream = __require("node:stream").Readable;
-    function PartStream(opts) {
-      ReadableStream.call(this, opts);
-    }
-    inherits(PartStream, ReadableStream);
-    PartStream.prototype._read = function(n) {
-    };
-    module.exports = PartStream;
-  }
-});
-
-// node_modules/@fastify/busboy/lib/utils/getLimit.js
-var require_getLimit = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/getLimit.js"(exports, module) {
-    "use strict";
-    module.exports = function getLimit(limits, name, defaultLimit) {
-      if (!limits || limits[name] === void 0 || limits[name] === null) {
-        return defaultLimit;
-      }
-      if (typeof limits[name] !== "number" || isNaN(limits[name])) {
-        throw new TypeError("Limit " + name + " is not a valid number");
-      }
-      return limits[name];
-    };
-  }
-});
-
-// node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js
-var require_HeaderParser = __commonJS({
-  "node_modules/@fastify/busboy/deps/dicer/lib/HeaderParser.js"(exports, module) {
-    "use strict";
-    var EventEmitter = __require("node:events").EventEmitter;
-    var inherits = __require("node: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) {
-      EventEmitter.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, EventEmitter);
-    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;
-        }
-      }
-    };
-    module.exports = HeaderParser;
-  }
-});
-
-// node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js
-var require_Dicer = __commonJS({
-  "node_modules/@fastify/busboy/deps/dicer/lib/Dicer.js"(exports, module) {
-    "use strict";
-    var WritableStream = __require("node:stream").Writable;
-    var inherits = __require("node: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();
-      }
-    };
-    module.exports = Dicer;
-  }
-});
-
-// node_modules/@fastify/busboy/lib/utils/decodeText.js
-var require_decodeText = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/decodeText.js"(exports, module) {
-    "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(exports.toString())) {
-          try {
-            return textDecoders.get(exports).decode(data);
-          } catch {
-          }
-        }
-        return typeof data === "string" ? data : data.toString();
-      }
-    };
-    function decodeText(text, sourceEncoding, destEncoding) {
-      if (text) {
-        return getDecoder(destEncoding)(text, sourceEncoding);
-      }
-      return text;
-    }
-    module.exports = decodeText;
-  }
-});
-
-// node_modules/@fastify/busboy/lib/utils/parseParams.js
-var require_parseParams = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/parseParams.js"(exports, module) {
-    "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;
-    }
-    module.exports = parseParams;
-  }
-});
-
-// node_modules/@fastify/busboy/lib/utils/basename.js
-var require_basename = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/basename.js"(exports, module) {
-    "use strict";
-    module.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"(exports, module) {
-    "use strict";
-    var { Readable } = __require("node:stream");
-    var { inherits } = __require("node: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;
-    Multipart.detect = /^multipart\/form-data/i;
-    function Multipart(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();
-      });
-    }
-    Multipart.prototype.write = function(chunk, cb) {
-      const r = this.parser.write(chunk);
-      if (r && !this._pause) {
-        cb();
-      } else {
-        this._needDrain = !r;
-        this._cb = cb;
-      }
-    };
-    Multipart.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) {
-    };
-    module.exports = Multipart;
-  }
-});
-
-// node_modules/@fastify/busboy/lib/utils/Decoder.js
-var require_Decoder = __commonJS({
-  "node_modules/@fastify/busboy/lib/utils/Decoder.js"(exports, module) {
-    "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;
-    };
-    module.exports = Decoder;
-  }
-});
-
-// node_modules/@fastify/busboy/lib/types/urlencoded.js
-var require_urlencoded = __commonJS({
-  "node_modules/@fastify/busboy/lib/types/urlencoded.js"(exports, module) {
-    "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");
-    };
-    module.exports = UrlEncoded;
-  }
-});
-
-// node_modules/@fastify/busboy/lib/main.js
-var require_main = __commonJS({
-  "node_modules/@fastify/busboy/lib/main.js"(exports, module) {
-    "use strict";
-    var WritableStream = __require("node:stream").Writable;
-    var { inherits } = __require("node: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);
-    };
-    module.exports = Busboy;
-    module.exports.default = Busboy;
-    module.exports.Busboy = Busboy;
-    module.exports.Dicer = Dicer;
-  }
-});
-
-// node_modules/fastify-plugin/lib/getPluginName.js
-var require_getPluginName = __commonJS({
-  "node_modules/fastify-plugin/lib/getPluginName.js"(exports, module) {
-    "use strict";
-    var fpStackTracePattern = /at\s{1}(?:.*\.)?plugin\s{1}.*\n\s*(.*)/;
-    var fileNamePattern = /(\w*(\.\w*)*)\..*/;
-    module.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";
-    }
-    module.exports.extractPluginName = extractPluginName;
-  }
-});
-
-// node_modules/fastify-plugin/lib/toCamelCase.js
-var require_toCamelCase = __commonJS({
-  "node_modules/fastify-plugin/lib/toCamelCase.js"(exports, module) {
-    "use strict";
-    module.exports = function toCamelCase(name) {
-      if (name[0] === "@") {
-        name = name.slice(1).replace("/", "-");
-      }
-      return name.replace(/-(.)/g, function(match, g1) {
-        return g1.toUpperCase();
-      });
-    };
-  }
-});
-
-// node_modules/fastify-plugin/plugin.js
-var require_plugin = __commonJS({
-  "node_modules/fastify-plugin/plugin.js"(exports, module) {
-    "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;
-    }
-    module.exports = plugin;
-    module.exports.default = plugin;
-    module.exports.fastifyPlugin = plugin;
-  }
-});
-
-// node_modules/@fastify/multipart/lib/generateId.js
-var require_generateId = __commonJS({
-  "node_modules/@fastify/multipart/lib/generateId.js"(exports, module) {
-    "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];
-    }
-    module.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"(exports, module) {
-    "use strict";
-    var { format } = __require("node: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;
-    module.exports = createError;
-    module.exports.default = createError;
-    module.exports.createError = createError;
-  }
-});
-
-// node_modules/@fastify/multipart/lib/stream-consumer.js
-var require_stream_consumer = __commonJS({
-  "node_modules/@fastify/multipart/lib/stream-consumer.js"(exports, module) {
-    "use strict";
-    module.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"(exports, module) {
-    "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;
-    }
-    module.exports = deepmergeConstructor;
-    module.exports.default = deepmergeConstructor;
-    module.exports.deepmerge = deepmergeConstructor;
-  }
-});
-
-// node_modules/secure-json-parse/index.js
-var require_secure_json_parse = __commonJS({
-  "node_modules/secure-json-parse/index.js"(exports, module) {
-    "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;
-      }
-    }
-    module.exports = parse;
-    module.exports.default = parse;
-    module.exports.parse = parse;
-    module.exports.safeParse = safeParse;
-    module.exports.scan = filter;
-  }
-});
-
-// node_modules/@fastify/multipart/index.js
-var require_multipart2 = __commonJS({
-  "node_modules/@fastify/multipart/index.js"(exports, module) {
-    var Busboy = require_main();
-    var os = __require("node:os");
-    var fp = require_plugin();
-    var { createWriteStream } = __require("node:fs");
-    var { unlink } = __require("node:fs/promises");
-    var path = __require("node:path");
-    var { generateId } = require_generateId();
-    var createError = require_error();
-    var streamToNull = require_stream_consumer();
-    var deepmergeAll = require_deepmerge()({ all: true });
-    var { PassThrough, Readable } = __require("node:stream");
-    var { pipeline: pump } = __require("node: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(fastify, 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) || fastify.initialConfig.bodyLimit
-      };
-      const attachFieldsToBody = options.attachFieldsToBody;
-      if (attachFieldsToBody === true || attachFieldsToBody === "keyValues") {
-        if (typeof options.sharedSchemaId === "string" && attachFieldsToBody === true) {
-          fastify.addSchema({
-            $id: options.sharedSchemaId,
-            type: "object",
-            properties: {
-              fieldname: { type: "string" },
-              encoding: { type: "string" },
-              filename: { type: "string" },
-              mimetype: { type: "string" }
-            }
-          });
-        }
-        fastify.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 && !fastify.hasRequestDecorator("formData")) {
-          fastify.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 (!fastify.hasRequestDecorator("formData")) {
-        fastify.decorateRequest("formData", async function() {
-          throw new NoFormData();
-        });
-      }
-      const defaultThrowFileSizeLimit = typeof options.throwFileSizeLimit === "boolean" ? options.throwFileSizeLimit : true;
-      fastify.decorate("multipartErrors", {
-        PartsLimitError,
-        FilesLimitError,
-        FieldsLimitError,
-        PrototypeViolationError,
-        InvalidMultipartContentTypeError,
-        RequestFileTooLargeError,
-        FileBufferNotFoundError
-      });
-      fastify.addContentTypeParser("multipart/form-data", setMultipart);
-      fastify.decorateRequest(kMultipart, false);
-      fastify.decorateRequest(kMultipartHandler, handleMultipart);
-      fastify.decorateRequest("parts", getMultipartIterator);
-      fastify.decorateRequest("isMultipart", isMultipart);
-      fastify.decorateRequest("tmpUploads", null);
-      fastify.decorateRequest("savedRequestFiles", null);
-      fastify.decorateRequest("file", getMultipartFile);
-      fastify.decorateRequest("files", getMultipartFiles);
-      fastify.decorateRequest("saveRequestFiles", saveRequestFiles);
-      fastify.decorateRequest("cleanRequestFiles", cleanRequestFiles);
-      fastify.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(name, fieldValue, fieldnameTruncated, valueTruncated, encoding, contentType) {
-          if (name 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: name,
-            mimetype: contentType,
-            encoding,
-            value: fieldValue,
-            fieldnameTruncated,
-            valueTruncated,
-            fields: body
-          };
-          if (body[name] === void 0) {
-            body[name] = value;
-          } else if (Array.isArray(body[name])) {
-            body[name].push(value);
-          } else {
-            body[name] = [body[name], value];
-          }
-          ch(value);
-        }
-        function onFile(name, file, filename, encoding, mimetype) {
-          if (name in Object.prototype) {
-            streamToNull(file).catch(() => {
-            });
-            onError(new PrototypeViolationError());
-            return;
-          }
-          const throwFileSizeLimit = typeof opts.throwFileSizeLimit === "boolean" ? opts.throwFileSizeLimit : defaultThrowFileSizeLimit;
-          const value = {
-            type: "file",
-            fieldname: name,
-            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[name] === void 0) {
-            body[name] = value;
-          } else if (Array.isArray(body[name])) {
-            body[name].push(value);
-          } else {
-            body[name] = [body[name], 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"
-        }
-      });
-    }
-    module.exports = fp(fastifyMultipart, {
-      fastify: "5.x",
-      name: "@fastify/multipart"
-    });
-    module.exports.default = fastifyMultipart;
-    module.exports.fastifyMultipart = fastifyMultipart;
-    module.exports.ajvFilePlugin = ajvFilePlugin;
-  }
-});
-export default require_multipart2();