@cloudinary/environment-config-mcp 0.6.1 → 0.6.2

package/bin/mcp-server.js

@@ -5402,9 +5402,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.5.5",
-    sdkVersion: "0.6.1",
-    genVersion: "2.918.4",
-    userAgent: "speakeasy-sdk/mcp-typescript 0.6.1 2.918.4 0.5.5 @cloudinary/environment-config-mcp"
+    sdkVersion: "0.6.2",
+    genVersion: "2.943.0",
+    userAgent: "speakeasy-sdk/mcp-typescript 0.6.2 2.943.0 0.5.5 @cloudinary/environment-config-mcp"
   };
 });
 
@@ -9252,7 +9252,7 @@ var require_utf32 = __commonJS((exports) => {
   }
   Utf32Encoder.prototype.write = function(str) {
     var src = Buffer2.from(str, "ucs2");
-    var dst = Buffer2.alloc(src.length * 2);
+    var dst = Buffer2.alloc(src.length * 2 + 4);
     var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;
     var offset = 0;
     for (var i = 0;i < src.length; i += 2) {
@@ -9319,9 +9319,9 @@ var require_utf32 = __commonJS((exports) => {
       }
       if (overflow.length === 4) {
         if (isLE) {
-          codepoint = overflow[i] | overflow[i + 1] << 8 | overflow[i + 2] << 16 | overflow[i + 3] << 24;
+          codepoint = overflow[0] | overflow[1] << 8 | overflow[2] << 16 | overflow[3] << 24;
         } else {
-          codepoint = overflow[i + 3] | overflow[i + 2] << 8 | overflow[i + 1] << 16 | overflow[i] << 24;
+          codepoint = overflow[3] | overflow[2] << 8 | overflow[1] << 16 | overflow[0] << 24;
         }
         overflow.length = 0;
         offset = _writeCodepoint(dst, offset, codepoint, badChar);
@@ -9356,7 +9356,11 @@ var require_utf32 = __commonJS((exports) => {
     return offset;
   }
   Utf32Decoder.prototype.end = function() {
+    if (this.overflow.length === 0) {
+      return;
+    }
     this.overflow.length = 0;
+    return String.fromCharCode(this.badChar);
   };
   exports.utf32 = Utf32AutoCodec;
   exports.ucs4 = "utf32";
@@ -9973,6 +9977,8 @@ var require_sbcs_data = __commonJS((exports, module) => {
     elot928: "iso88597",
     hebrew: "iso88598",
     hebrew8: "iso88598",
+    iso88598i: "iso88598",
+    iso88598e: "iso88598",
     turkish: "iso88599",
     turkish8: "iso88599",
     thai: "iso885911",
@@ -12470,55 +12476,54 @@ var require_lib = __commonJS((exports, module) => {
   var Buffer2 = require_safer().Buffer;
   var bomHandling = require_bom_handling();
   var mergeModules = require_merge_exports();
-  var iconv = exports;
-  iconv.encodings = null;
-  iconv.defaultCharUnicode = "�";
-  iconv.defaultCharSingleByte = "?";
-  iconv.encode = function encode(str, encoding, options) {
+  exports.encodings = null;
+  exports.defaultCharUnicode = "�";
+  exports.defaultCharSingleByte = "?";
+  exports.encode = function encode(str, encoding, options) {
     str = "" + (str || "");
-    var encoder = iconv.getEncoder(encoding, options);
+    var encoder = exports.getEncoder(encoding, options);
     var res = encoder.write(str);
     var trail = encoder.end();
     return trail && trail.length > 0 ? Buffer2.concat([res, trail]) : res;
   };
-  iconv.decode = function decode(buf, encoding, options) {
+  exports.decode = function decode(buf, encoding, options) {
     if (typeof buf === "string") {
-      if (!iconv.skipDecodeWarning) {
+      if (!exports.skipDecodeWarning) {
         console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
-        iconv.skipDecodeWarning = true;
+        exports.skipDecodeWarning = true;
       }
       buf = Buffer2.from("" + (buf || ""), "binary");
     }
-    var decoder = iconv.getDecoder(encoding, options);
+    var decoder = exports.getDecoder(encoding, options);
     var res = decoder.write(buf);
     var trail = decoder.end();
     return trail ? res + trail : res;
   };
-  iconv.encodingExists = function encodingExists(enc) {
+  exports.encodingExists = function encodingExists(enc) {
     try {
-      iconv.getCodec(enc);
+      exports.getCodec(enc);
       return true;
     } catch (e) {
       return false;
     }
   };
-  iconv.toEncoding = iconv.encode;
-  iconv.fromEncoding = iconv.decode;
-  iconv._codecDataCache = { __proto__: null };
-  iconv.getCodec = function getCodec(encoding) {
-    if (!iconv.encodings) {
+  exports.toEncoding = exports.encode;
+  exports.fromEncoding = exports.decode;
+  exports._codecDataCache = { __proto__: null };
+  exports.getCodec = function getCodec(encoding) {
+    if (!exports.encodings) {
       var raw = require_encodings();
-      iconv.encodings = { __proto__: null };
-      mergeModules(iconv.encodings, raw);
+      exports.encodings = { __proto__: null };
+      mergeModules(exports.encodings, raw);
     }
-    var enc = iconv._canonicalizeEncoding(encoding);
+    var enc = exports._canonicalizeEncoding(encoding);
     var codecOptions = {};
     while (true) {
-      var codec = iconv._codecDataCache[enc];
+      var codec = exports._codecDataCache[enc];
       if (codec) {
         return codec;
       }
-      var codecDef = iconv.encodings[enc];
+      var codecDef = exports.encodings[enc];
       switch (typeof codecDef) {
         case "string":
           enc = codecDef;
@@ -12536,56 +12541,56 @@ var require_lib = __commonJS((exports, module) => {
           if (!codecOptions.encodingName) {
             codecOptions.encodingName = enc;
           }
-          codec = new codecDef(codecOptions, iconv);
-          iconv._codecDataCache[codecOptions.encodingName] = codec;
+          codec = new codecDef(codecOptions, exports);
+          exports._codecDataCache[codecOptions.encodingName] = codec;
           return codec;
         default:
           throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
       }
     }
   };
-  iconv._canonicalizeEncoding = function(encoding) {
+  exports._canonicalizeEncoding = function(encoding) {
     return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
   };
-  iconv.getEncoder = function getEncoder(encoding, options) {
-    var codec = iconv.getCodec(encoding);
+  exports.getEncoder = function getEncoder(encoding, options) {
+    var codec = exports.getCodec(encoding);
     var encoder = new codec.encoder(options, codec);
     if (codec.bomAware && options && options.addBOM) {
       encoder = new bomHandling.PrependBOM(encoder, options);
     }
     return encoder;
   };
-  iconv.getDecoder = function getDecoder(encoding, options) {
-    var codec = iconv.getCodec(encoding);
+  exports.getDecoder = function getDecoder(encoding, options) {
+    var codec = exports.getCodec(encoding);
     var decoder = new codec.decoder(options, codec);
     if (codec.bomAware && !(options && options.stripBOM === false)) {
       decoder = new bomHandling.StripBOM(decoder, options);
     }
     return decoder;
   };
-  iconv.enableStreamingAPI = function enableStreamingAPI(streamModule2) {
-    if (iconv.supportsStreams) {
+  exports.enableStreamingAPI = function enableStreamingAPI(streamModule2) {
+    if (exports.supportsStreams) {
       return;
     }
     var streams = require_streams()(streamModule2);
-    iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;
-    iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;
-    iconv.encodeStream = function encodeStream(encoding, options) {
-      return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options);
+    exports.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;
+    exports.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;
+    exports.encodeStream = function encodeStream(encoding, options) {
+      return new exports.IconvLiteEncoderStream(exports.getEncoder(encoding, options), options);
     };
-    iconv.decodeStream = function decodeStream(encoding, options) {
-      return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options);
+    exports.decodeStream = function decodeStream(encoding, options) {
+      return new exports.IconvLiteDecoderStream(exports.getDecoder(encoding, options), options);
     };
-    iconv.supportsStreams = true;
+    exports.supportsStreams = true;
   };
   var streamModule;
   try {
     streamModule = __require("stream");
   } catch (e) {}
   if (streamModule && streamModule.Transform) {
-    iconv.enableStreamingAPI(streamModule);
+    exports.enableStreamingAPI(streamModule);
   } else {
-    iconv.encodeStream = iconv.decodeStream = function() {
+    exports.encodeStream = exports.decodeStream = function() {
       throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.");
     };
   }
@@ -13001,109 +13006,144 @@ var require_on_finished = __commonJS((exports, module) => {
   }
 });
 
-// node_modules/content-type/index.js
-var require_content_type = __commonJS((exports) => {
+// node_modules/type-is/node_modules/content-type/dist/index.js
+var require_dist = __commonJS((exports) => {
   /*!
    * content-type
    * Copyright(c) 2015 Douglas Christopher Wilson
    * MIT Licensed
    */
-  var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
-  var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
-  var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-  var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
-  var QUOTE_REGEXP = /([\\"])/g;
-  var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+  Object.defineProperty(exports, "__esModule", { value: true });
   exports.format = format;
   exports.parse = parse5;
+  var TEXT_REGEXP = /^[\u0009\u0020-\u007e\u0080-\u00ff]*$/;
+  var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+  var QUOTE_REGEXP = /[\\"]/g;
+  var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+  var NullObject = /* @__PURE__ */ (() => {
+    const C2 = function() {};
+    C2.prototype = Object.create(null);
+    return C2;
+  })();
   function format(obj) {
-    if (!obj || typeof obj !== "object") {
-      throw new TypeError("argument obj is required");
-    }
-    var parameters = obj.parameters;
-    var type = obj.type;
+    const { type, parameters } = obj;
     if (!type || !TYPE_REGEXP.test(type)) {
-      throw new TypeError("invalid type");
+      throw new TypeError(`Invalid type: ${type}`);
     }
-    var string4 = type;
-    if (parameters && typeof parameters === "object") {
-      var param;
-      var params = Object.keys(parameters).sort();
-      for (var i = 0;i < params.length; i++) {
-        param = params[i];
+    let result = type;
+    if (parameters) {
+      for (const param of Object.keys(parameters)) {
         if (!TOKEN_REGEXP.test(param)) {
-          throw new TypeError("invalid parameter name");
+          throw new TypeError(`Invalid parameter name: ${param}`);
         }
-        string4 += "; " + param + "=" + qstring(parameters[param]);
+        result += `; ${param}=${qstring(parameters[param])}`;
       }
     }
-    return string4;
+    return result;
   }
-  function parse5(string4) {
-    if (!string4) {
-      throw new TypeError("argument string is required");
-    }
-    var header = typeof string4 === "object" ? getcontenttype(string4) : string4;
-    if (typeof header !== "string") {
-      throw new TypeError("argument string is required to be a string");
-    }
-    var index = header.indexOf(";");
-    var type = index !== -1 ? header.slice(0, index).trim() : header.trim();
-    if (!TYPE_REGEXP.test(type)) {
-      throw new TypeError("invalid media type");
-    }
-    var obj = new ContentType(type.toLowerCase());
-    if (index !== -1) {
-      var key;
-      var match;
-      var value;
-      PARAM_REGEXP.lastIndex = index;
-      while (match = PARAM_REGEXP.exec(header)) {
-        if (match.index !== index) {
-          throw new TypeError("invalid parameter format");
-        }
-        index += match[0].length;
-        key = match[1].toLowerCase();
-        value = match[2];
-        if (value.charCodeAt(0) === 34) {
-          value = value.slice(1, -1);
-          if (value.indexOf("\\") !== -1) {
-            value = value.replace(QESC_REGEXP, "$1");
+  function parse5(header, options) {
+    const stopChar = options?.comma === true ? COMMA : 65536;
+    const len = header.length;
+    let index = skipOWS(header, options?.start ?? 0, len);
+    const valueStart = index;
+    index = skipValue(header, index, len, stopChar);
+    const valueEnd = trailingOWS(header, valueStart, index);
+    const type = header.slice(valueStart, valueEnd).toLowerCase();
+    if (options?.parameters === false) {
+      return { type, index, parameters: new NullObject };
+    }
+    return parseParameters(header, type, index, len, stopChar);
+  }
+  var SP = 32;
+  var HTAB = 9;
+  var SEMI = 59;
+  var EQ = 61;
+  var DQUOTE = 34;
+  var BSLASH = 92;
+  var COMMA = 44;
+  function parseParameters(header, type, index, len, stopChar) {
+    const parameters = new NullObject;
+    parameter:
+      while (index < len) {
+        if (header.charCodeAt(index) === stopChar)
+          break;
+        index = skipOWS(header, index + 1, len);
+        const keyStart = index;
+        while (index < len) {
+          const code = header.charCodeAt(index);
+          if (code === stopChar)
+            break parameter;
+          if (code === SEMI)
+            continue parameter;
+          if (code === EQ) {
+            const keyEnd = trailingOWS(header, keyStart, index);
+            const key = header.slice(keyStart, keyEnd).toLowerCase();
+            index = skipOWS(header, index + 1, len);
+            if (index < len && header.charCodeAt(index) === DQUOTE) {
+              index++;
+              let value = "";
+              while (index < len) {
+                const code2 = header.charCodeAt(index++);
+                if (code2 === DQUOTE) {
+                  index = skipValue(header, index, len, stopChar);
+                  if (parameters[key] === undefined)
+                    parameters[key] = value;
+                  break;
+                }
+                if (code2 === BSLASH && index < len) {
+                  value += header[index++];
+                  continue;
+                }
+                value += String.fromCharCode(code2);
+              }
+              continue parameter;
+            }
+            const valueStart = index;
+            index = skipValue(header, index, len, stopChar);
+            if (parameters[key] === undefined) {
+              const valueEnd = trailingOWS(header, valueStart, index);
+              parameters[key] = header.slice(valueStart, valueEnd);
+            }
+            continue parameter;
           }
+          index++;
         }
-        obj.parameters[key] = value;
       }
-      if (index !== header.length) {
-        throw new TypeError("invalid parameter format");
-      }
-    }
-    return obj;
+    return { type, index, parameters };
   }
-  function getcontenttype(obj) {
-    var header;
-    if (typeof obj.getHeader === "function") {
-      header = obj.getHeader("content-type");
-    } else if (typeof obj.headers === "object") {
-      header = obj.headers && obj.headers["content-type"];
-    }
-    if (typeof header !== "string") {
-      throw new TypeError("content-type header is missing from object");
+  function skipValue(str, index, len, stopChar) {
+    while (index < len) {
+      const code = str.charCodeAt(index);
+      if (code === SEMI || code === stopChar)
+        break;
+      index++;
     }
-    return header;
+    return index;
   }
-  function qstring(val) {
-    var str = String(val);
-    if (TOKEN_REGEXP.test(str)) {
-      return str;
+  function skipOWS(header, index, len) {
+    while (index < len) {
+      const char = header.charCodeAt(index);
+      if (char !== SP && char !== HTAB)
+        break;
+      index++;
     }
-    if (str.length > 0 && !TEXT_REGEXP.test(str)) {
-      throw new TypeError("invalid parameter value");
+    return index;
+  }
+  function trailingOWS(header, start, end) {
+    while (end > start) {
+      const char = header.charCodeAt(end - 1);
+      if (char !== SP && char !== HTAB)
+        break;
+      end--;
     }
-    return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
+    return end;
   }
-  function ContentType(type) {
-    this.parameters = Object.create(null);
-    this.type = type;
+  function qstring(str) {
+    if (TOKEN_REGEXP.test(str))
+      return str;
+    if (TEXT_REGEXP.test(str))
+      return `"${str.replace(QUOTE_REGEXP, "\\$&")}"`;
+    throw new TypeError(`Invalid parameter value: ${str}`);
   }
 });
 
@@ -22686,7 +22726,7 @@ var require_type_is = __commonJS((exports, module) => {
    * Copyright(c) 2014-2015 Douglas Christopher Wilson
    * MIT Licensed
    */
-  var contentType = require_content_type();
+  var contentType = require_dist();
   var mime = require_mime_types();
   var typer = require_media_typer();
   module.exports = typeofrequest;
@@ -22695,9 +22735,12 @@ var require_type_is = __commonJS((exports, module) => {
   module.exports.normalize = normalize;
   module.exports.match = mimeMatch;
   function typeis(value, types_) {
+    if (value && typeof value === "object") {
+      value = value.headers["content-type"];
+    }
     var i;
     var types = types_;
-    var val = tryNormalizeType(value);
+    var val = normalizeType(value);
     if (!val) {
       return false;
     }
@@ -22764,22 +22807,158 @@ var require_type_is = __commonJS((exports, module) => {
     return true;
   }
   function normalizeType(value) {
-    var type = contentType.parse(value).type;
+    if (!value)
+      return null;
+    var type = contentType.parse(value, { parameters: false }).type;
     return typer.test(type) ? type : null;
   }
-  function tryNormalizeType(value) {
-    try {
-      return value ? normalizeType(value) : null;
-    } catch (err) {
-      return null;
+});
+
+// node_modules/body-parser/node_modules/content-type/dist/index.js
+var require_dist2 = __commonJS((exports) => {
+  /*!
+   * content-type
+   * Copyright(c) 2015 Douglas Christopher Wilson
+   * MIT Licensed
+   */
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.format = format;
+  exports.parse = parse5;
+  var TEXT_REGEXP = /^[\u0009\u0020-\u007e\u0080-\u00ff]*$/;
+  var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+  var QUOTE_REGEXP = /[\\"]/g;
+  var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+  var NullObject = /* @__PURE__ */ (() => {
+    const C2 = function() {};
+    C2.prototype = Object.create(null);
+    return C2;
+  })();
+  function format(obj) {
+    const { type, parameters } = obj;
+    if (!type || !TYPE_REGEXP.test(type)) {
+      throw new TypeError(`Invalid type: ${type}`);
+    }
+    let result = type;
+    if (parameters) {
+      for (const param of Object.keys(parameters)) {
+        if (!TOKEN_REGEXP.test(param)) {
+          throw new TypeError(`Invalid parameter name: ${param}`);
+        }
+        result += `; ${param}=${qstring(parameters[param])}`;
+      }
     }
+    return result;
+  }
+  function parse5(header, options) {
+    const stopChar = options?.comma === true ? COMMA : 65536;
+    const len = header.length;
+    let index = skipOWS(header, options?.start ?? 0, len);
+    const valueStart = index;
+    index = skipValue(header, index, len, stopChar);
+    const valueEnd = trailingOWS(header, valueStart, index);
+    const type = header.slice(valueStart, valueEnd).toLowerCase();
+    if (options?.parameters === false) {
+      return { type, index, parameters: new NullObject };
+    }
+    return parseParameters(header, type, index, len, stopChar);
+  }
+  var SP = 32;
+  var HTAB = 9;
+  var SEMI = 59;
+  var EQ = 61;
+  var DQUOTE = 34;
+  var BSLASH = 92;
+  var COMMA = 44;
+  function parseParameters(header, type, index, len, stopChar) {
+    const parameters = new NullObject;
+    parameter:
+      while (index < len) {
+        if (header.charCodeAt(index) === stopChar)
+          break;
+        index = skipOWS(header, index + 1, len);
+        const keyStart = index;
+        while (index < len) {
+          const code = header.charCodeAt(index);
+          if (code === stopChar)
+            break parameter;
+          if (code === SEMI)
+            continue parameter;
+          if (code === EQ) {
+            const keyEnd = trailingOWS(header, keyStart, index);
+            const key = header.slice(keyStart, keyEnd).toLowerCase();
+            index = skipOWS(header, index + 1, len);
+            if (index < len && header.charCodeAt(index) === DQUOTE) {
+              index++;
+              let value = "";
+              while (index < len) {
+                const code2 = header.charCodeAt(index++);
+                if (code2 === DQUOTE) {
+                  index = skipValue(header, index, len, stopChar);
+                  if (parameters[key] === undefined)
+                    parameters[key] = value;
+                  break;
+                }
+                if (code2 === BSLASH && index < len) {
+                  value += header[index++];
+                  continue;
+                }
+                value += String.fromCharCode(code2);
+              }
+              continue parameter;
+            }
+            const valueStart = index;
+            index = skipValue(header, index, len, stopChar);
+            if (parameters[key] === undefined) {
+              const valueEnd = trailingOWS(header, valueStart, index);
+              parameters[key] = header.slice(valueStart, valueEnd);
+            }
+            continue parameter;
+          }
+          index++;
+        }
+      }
+    return { type, index, parameters };
+  }
+  function skipValue(str, index, len, stopChar) {
+    while (index < len) {
+      const code = str.charCodeAt(index);
+      if (code === SEMI || code === stopChar)
+        break;
+      index++;
+    }
+    return index;
+  }
+  function skipOWS(header, index, len) {
+    while (index < len) {
+      const char = header.charCodeAt(index);
+      if (char !== SP && char !== HTAB)
+        break;
+      index++;
+    }
+    return index;
+  }
+  function trailingOWS(header, start, end) {
+    while (end > start) {
+      const char = header.charCodeAt(end - 1);
+      if (char !== SP && char !== HTAB)
+        break;
+      end--;
+    }
+    return end;
+  }
+  function qstring(str) {
+    if (TOKEN_REGEXP.test(str))
+      return str;
+    if (TEXT_REGEXP.test(str))
+      return `"${str.replace(QUOTE_REGEXP, "\\$&")}"`;
+    throw new TypeError(`Invalid parameter value: ${str}`);
   }
 });
 
 // node_modules/body-parser/lib/utils.js
 var require_utils = __commonJS((exports, module) => {
   var bytes = require_bytes();
-  var contentType = require_content_type();
+  var contentType = require_dist2();
   var typeis = require_type_is();
   module.exports = {
     getCharset,
@@ -22787,11 +22966,10 @@ var require_utils = __commonJS((exports, module) => {
     passthrough
   };
   function getCharset(req) {
-    try {
-      return (contentType.parse(req).parameters.charset || "").toLowerCase();
-    } catch {
+    const header = req.headers["content-type"];
+    if (!header)
       return;
-    }
+    return contentType.parse(header).parameters.charset?.toLowerCase();
   }
   function typeChecker(type) {
     return function checkType(req) {
@@ -22802,15 +22980,18 @@ var require_utils = __commonJS((exports, module) => {
     if (!defaultType) {
       throw new TypeError("defaultType must be provided");
     }
-    var inflate = options?.inflate !== false;
-    var limit = typeof options?.limit !== "number" ? bytes.parse(options?.limit || "100kb") : options?.limit;
-    var type = options?.type || defaultType;
-    var verify = options?.verify || false;
-    var defaultCharset = options?.defaultCharset || "utf-8";
+    const inflate = options?.inflate !== false;
+    const limit = typeof options?.limit === "undefined" || options?.limit === null ? 102400 : bytes.parse(options.limit);
+    const type = options?.type || defaultType;
+    const verify = options?.verify || false;
+    const defaultCharset = options?.defaultCharset || "utf-8";
+    if (limit === null) {
+      throw new TypeError(`option limit "${String(options.limit)}" is invalid`);
+    }
     if (verify !== false && typeof verify !== "function") {
       throw new TypeError("option verify must be function");
     }
-    var shouldParse = typeof type !== "function" ? typeChecker(type) : type;
+    const shouldParse = typeof type !== "function" ? typeChecker(type) : type;
     return {
       inflate,
       limit,
@@ -22859,7 +23040,7 @@ var require_read = __commonJS((exports, module) => {
       next();
       return;
     }
-    var encoding = null;
+    let encoding = null;
     if (options?.skipCharset !== true) {
       encoding = getCharset(req) || options.defaultCharset;
       if (!!options?.isValidCharset && !options.isValidCharset(encoding)) {
@@ -22871,10 +23052,10 @@ var require_read = __commonJS((exports, module) => {
         return;
       }
     }
-    var length;
-    var opts = options;
-    var stream;
-    var verify = opts.verify;
+    let length;
+    const opts = options;
+    let stream;
+    const verify = opts.verify;
     try {
       stream = contentstream(req, debug, opts.inflate);
       length = stream.length;
@@ -22893,7 +23074,7 @@ var require_read = __commonJS((exports, module) => {
     debug("read body");
     getBody(stream, opts, function(error2, body) {
       if (error2) {
-        var _error;
+        let _error;
         if (error2.type === "encoding.unsupported") {
           _error = createError(415, 'unsupported charset "' + encoding.toUpperCase() + '"', {
             charset: encoding.toLowerCase(),
@@ -22923,7 +23104,7 @@ var require_read = __commonJS((exports, module) => {
           return;
         }
       }
-      var str = body;
+      let str = body;
       try {
         debug("parse body");
         str = typeof body !== "string" && encoding !== null ? iconv.decode(body, encoding) : body;
@@ -22939,8 +23120,8 @@ var require_read = __commonJS((exports, module) => {
     });
   }
   function contentstream(req, debug, inflate) {
-    var encoding = (req.headers["content-encoding"] || "identity").toLowerCase();
-    var length = req.headers["content-length"];
+    const encoding = (req.headers["content-encoding"] || "identity").toLowerCase();
+    const length = req.headers["content-length"];
     debug('content-encoding "%s"', encoding);
     if (inflate === false && encoding !== "identity") {
       throw createError(415, "content encoding unsupported", {
@@ -22952,7 +23133,7 @@ var require_read = __commonJS((exports, module) => {
       req.length = length;
       return req;
     }
-    var stream = createDecompressionStream(encoding, debug);
+    const stream = createDecompressionStream(encoding, debug);
     req.pipe(stream);
     return stream;
   }
@@ -23001,18 +23182,42 @@ var require_json = __commonJS((exports, module) => {
   var JSON_SYNTAX_REGEXP = /#+/g;
   function json(options) {
     const normalizedOptions = normalizeOptions(options, "application/json");
-    var reviver = options?.reviver;
-    var strict = options?.strict !== false;
-    function parse5(body) {
-      if (body.length === 0) {
-        return {};
-      }
-      if (strict) {
-        var first = firstchar(body);
+    const parse5 = createJsonParser(options);
+    const readOptions = {
+      ...normalizedOptions,
+      isValidCharset: (charset) => charset.slice(0, 4) === "utf-"
+    };
+    return function jsonParser(req, res, next) {
+      read(req, res, next, parse5, debug, readOptions);
+    };
+  }
+  function createJsonParser(options) {
+    const reviver = options?.reviver;
+    const strict = options?.strict !== false;
+    if (strict) {
+      return function parse(body) {
+        if (body.length === 0) {
+          return {};
+        }
+        const first = firstchar(body);
         if (first !== "{" && first !== "[") {
           debug("strict violation");
           throw createStrictSyntaxError(body, first);
         }
+        try {
+          debug("parse json");
+          return JSON.parse(body, reviver);
+        } catch (e) {
+          throw normalizeJsonSyntaxError(e, {
+            message: e.message,
+            stack: e.stack
+          });
+        }
+      };
+    }
+    return function parse(body) {
+      if (body.length === 0) {
+        return {};
       }
       try {
         debug("parse json");
@@ -23023,23 +23228,13 @@ var require_json = __commonJS((exports, module) => {
           stack: e.stack
         });
       }
-    }
-    const readOptions = {
-      ...normalizedOptions,
-      isValidCharset: (charset) => charset.slice(0, 4) === "utf-"
-    };
-    return function jsonParser(req, res, next) {
-      read(req, res, next, parse5, debug, readOptions);
     };
   }
   function createStrictSyntaxError(str, char) {
-    var index = str.indexOf(char);
-    var partial2 = "";
+    const index = str.indexOf(char);
+    let partial2 = "";
     if (index !== -1) {
-      partial2 = str.substring(0, index) + JSON_SYNTAX_CHAR;
-      for (var i = index + 1;i < str.length; i++) {
-        partial2 += JSON_SYNTAX_CHAR;
-      }
+      partial2 = str.substring(0, index) + JSON_SYNTAX_CHAR.repeat(str.length - index);
     }
     try {
       JSON.parse(partial2);
@@ -23054,13 +23249,13 @@ var require_json = __commonJS((exports, module) => {
     }
   }
   function firstchar(str) {
-    var match = FIRST_CHAR_REGEXP.exec(str);
+    const match = FIRST_CHAR_REGEXP.exec(str);
     return match ? match[1] : undefined;
   }
   function normalizeJsonSyntaxError(error2, obj) {
-    var keys = Object.getOwnPropertyNames(error2);
-    for (var i = 0;i < keys.length; i++) {
-      var key = keys[i];
+    const keys = Object.getOwnPropertyNames(error2);
+    for (let i = 0;i < keys.length; i++) {
+      const key = keys[i];
       if (key !== "stack" && key !== "message") {
         delete error2[key];
       }
@@ -23705,9 +23900,8 @@ var require_side_channel_list = __commonJS((exports, module) => {
         }
       },
       delete: function(key) {
-        var root = $o && $o.next;
         var deletedNode = listDelete($o, key);
-        if (deletedNode && root && root === deletedNode) {
+        if (deletedNode && $o && !$o.next) {
           $o = undefined;
         }
         return !!deletedNode;
@@ -24553,7 +24747,8 @@ var require_side_channel = __commonJS((exports, module) => {
     var channel = {
       assert: function(key) {
         if (!channel.has(key)) {
-          throw new $TypeError("Side channel does not contain " + inspect(key));
+          var keyDesc = key && Object(key) === key ? "the given object key" : inspect(key);
+          throw new $TypeError("Side channel does not contain " + keyDesc);
         }
       },
       delete: function(key) {
@@ -24602,12 +24797,28 @@ var require_formats = __commonJS((exports, module) => {
 // node_modules/qs/lib/utils.js
 var require_utils2 = __commonJS((exports, module) => {
   var formats = require_formats();
+  var getSideChannel = require_side_channel();
+  var defineProperty = require_es_define_property();
   var has = Object.prototype.hasOwnProperty;
   var isArray = Array.isArray;
+  var overflowChannel = getSideChannel();
+  var markOverflow = function markOverflow(obj, maxIndex) {
+    overflowChannel.set(obj, maxIndex);
+    return obj;
+  };
+  var isOverflow = function isOverflow(obj) {
+    return overflowChannel.has(obj);
+  };
+  var getMaxIndex = function getMaxIndex(obj) {
+    return overflowChannel.get(obj);
+  };
+  var setMaxIndex = function setMaxIndex(obj, maxIndex) {
+    overflowChannel.set(obj, maxIndex);
+  };
   var hexTable = function() {
     var array2 = [];
     for (var i = 0;i < 256; ++i) {
-      array2.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase());
+      array2[array2.length] = "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase();
     }
     return array2;
   }();
@@ -24619,7 +24830,7 @@ var require_utils2 = __commonJS((exports, module) => {
         var compacted = [];
         for (var j2 = 0;j2 < obj.length; ++j2) {
           if (typeof obj[j2] !== "undefined") {
-            compacted.push(obj[j2]);
+            compacted[compacted.length] = obj[j2];
           }
         }
         item.obj[item.prop] = compacted;
@@ -24635,15 +24846,40 @@ var require_utils2 = __commonJS((exports, module) => {
     }
     return obj;
   };
+  var setProperty = function setProperty(obj, key, value) {
+    if (key === "__proto__" && defineProperty) {
+      defineProperty(obj, key, {
+        configurable: true,
+        enumerable: true,
+        value,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+  };
   var merge2 = function merge(target, source, options) {
     if (!source) {
       return target;
     }
     if (typeof source !== "object" && typeof source !== "function") {
       if (isArray(target)) {
-        target.push(source);
+        var nextIndex = target.length;
+        if (options && typeof options.arrayLimit === "number" && nextIndex >= options.arrayLimit) {
+          if (options.throwOnLimitExceeded) {
+            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+          }
+          return markOverflow(arrayToObject(target.concat(source), options), nextIndex);
+        }
+        target[nextIndex] = source;
       } else if (target && typeof target === "object") {
-        if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
+        if (isOverflow(target)) {
+          var newIndex = getMaxIndex(target) + 1;
+          target[newIndex] = source;
+          setMaxIndex(target, newIndex);
+        } else if (options && options.strictMerge) {
+          return [target, source];
+        } else if (options && (options.plainObjects || options.allowPrototypes) || !has.call(Object.prototype, source)) {
           target[source] = true;
         }
       } else {
@@ -24652,7 +24888,23 @@ var require_utils2 = __commonJS((exports, module) => {
       return target;
     }
     if (!target || typeof target !== "object") {
-      return [target].concat(source);
+      if (isOverflow(source)) {
+        var sourceKeys = Object.keys(source);
+        var result = options && options.plainObjects ? { __proto__: null, 0: target } : { 0: target };
+        for (var m = 0;m < sourceKeys.length; m++) {
+          var oldKey = parseInt(sourceKeys[m], 10);
+          result[oldKey + 1] = source[sourceKeys[m]];
+        }
+        return markOverflow(result, getMaxIndex(source) + 1);
+      }
+      var combined = [target].concat(source);
+      if (options && typeof options.arrayLimit === "number" && combined.length > options.arrayLimit) {
+        if (options.throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        }
+        return markOverflow(arrayToObject(combined, options), combined.length - 1);
+      }
+      return combined;
     }
     var mergeTarget = target;
     if (isArray(target) && !isArray(source)) {
@@ -24665,27 +24917,42 @@ var require_utils2 = __commonJS((exports, module) => {
           if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
             target[i] = merge(targetItem, item, options);
           } else {
-            target.push(item);
+            target[target.length] = item;
           }
         } else {
           target[i] = item;
         }
       });
+      if (options && typeof options.arrayLimit === "number" && target.length > options.arrayLimit) {
+        if (options.throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        }
+        return markOverflow(arrayToObject(target, options), target.length - 1);
+      }
       return target;
     }
     return Object.keys(source).reduce(function(acc, key) {
       var value = source[key];
       if (has.call(acc, key)) {
-        acc[key] = merge(acc[key], value, options);
+        setProperty(acc, key, merge(acc[key], value, options));
       } else {
-        acc[key] = value;
+        setProperty(acc, key, value);
+      }
+      if (isOverflow(source) && !isOverflow(acc)) {
+        markOverflow(acc, getMaxIndex(source));
+      }
+      if (isOverflow(acc)) {
+        var keyNum = parseInt(key, 10);
+        if (String(keyNum) === key && keyNum >= 0 && keyNum > getMaxIndex(acc)) {
+          setMaxIndex(acc, keyNum);
+        }
       }
       return acc;
     }, mergeTarget);
   };
   var assign = function assignSingleSource(target, source) {
     return Object.keys(source).reduce(function(acc, key) {
-      acc[key] = source[key];
+      setProperty(acc, key, source[key]);
       return acc;
     }, target);
   };
@@ -24719,6 +24986,13 @@ var require_utils2 = __commonJS((exports, module) => {
     var out = "";
     for (var j2 = 0;j2 < string4.length; j2 += limit) {
       var segment = string4.length >= limit ? string4.slice(j2, j2 + limit) : string4;
+      if (j2 + limit < string4.length) {
+        var last = segment.charCodeAt(segment.length - 1);
+        if (last >= 55296 && last <= 56319) {
+          segment = segment.slice(0, -1);
+          j2 -= 1;
+        }
+      }
       var arr = [];
       for (var i = 0;i < segment.length; ++i) {
         var c = segment.charCodeAt(i);
@@ -24748,7 +25022,7 @@ var require_utils2 = __commonJS((exports, module) => {
   };
   var compact = function compact(value) {
     var queue = [{ obj: { o: value }, prop: "o" }];
-    var refs = [];
+    var refs = getSideChannel();
     for (var i = 0;i < queue.length; ++i) {
       var item = queue[i];
       var obj = item.obj[item.prop];
@@ -24756,9 +25030,9 @@ var require_utils2 = __commonJS((exports, module) => {
       for (var j2 = 0;j2 < keys.length; ++j2) {
         var key = keys[j2];
         var val = obj[key];
-        if (typeof val === "object" && val !== null && refs.indexOf(val) === -1) {
-          queue.push({ obj, prop: key });
-          refs.push(val);
+        if (typeof val === "object" && val !== null && !refs.has(val)) {
+          queue[queue.length] = { obj, prop: key };
+          refs.set(val, true);
         }
       }
     }
@@ -24772,16 +25046,36 @@ var require_utils2 = __commonJS((exports, module) => {
     if (!obj || typeof obj !== "object") {
       return false;
     }
-    return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+    return !!(obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj));
   };
-  var combine = function combine(a, b) {
-    return [].concat(a, b);
+  var combine = function combine(a, b, arrayLimit, plainObjects, throwOnLimitExceeded) {
+    if (isOverflow(a)) {
+      if (throwOnLimitExceeded) {
+        throw new RangeError("Array limit exceeded. Only " + arrayLimit + " element" + (arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+      }
+      var bValues = isArray(b) ? b : [b];
+      var newIndex = getMaxIndex(a);
+      for (var i = 0;i < bValues.length; ++i) {
+        newIndex += 1;
+        a[newIndex] = bValues[i];
+      }
+      setMaxIndex(a, newIndex);
+      return a;
+    }
+    var result = [].concat(a, b);
+    if (result.length > arrayLimit) {
+      if (throwOnLimitExceeded) {
+        throw new RangeError("Array limit exceeded. Only " + arrayLimit + " element" + (arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+      }
+      return markOverflow(arrayToObject(result, { plainObjects }), result.length - 1);
+    }
+    return result;
   };
   var maybeMap = function maybeMap(val, fn) {
     if (isArray(val)) {
       var mapped = [];
       for (var i = 0;i < val.length; i += 1) {
-        mapped.push(fn(val[i]));
+        mapped[mapped.length] = fn(val[i]);
       }
       return mapped;
     }
@@ -24795,7 +25089,9 @@ var require_utils2 = __commonJS((exports, module) => {
     decode: decode2,
     encode: encode2,
     isBuffer,
+    isOverflow,
     isRegExp,
+    markOverflow,
     maybeMap,
     merge: merge2
   };
@@ -24835,6 +25131,7 @@ var require_stringify = __commonJS((exports, module) => {
     charsetSentinel: false,
     commaRoundTrip: false,
     delimiter: "&",
+    depth: Infinity,
     encode: true,
     encodeDotInKeys: false,
     encoder: utils.encode,
@@ -24853,8 +25150,11 @@ var require_stringify = __commonJS((exports, module) => {
     return typeof v2 === "string" || typeof v2 === "number" || typeof v2 === "boolean" || typeof v2 === "symbol" || typeof v2 === "bigint";
   };
   var sentinel = {};
-  var stringify = function stringify(object2, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel) {
+  var stringify = function stringify(object2, prefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, sideChannel, depth, currentDepth) {
     var obj = object2;
+    if (currentDepth > depth) {
+      throw new RangeError("Input depth exceeded depth option of " + depth);
+    }
     var tmpSc = sideChannel;
     var step = 0;
     var findFlag = false;
@@ -24872,9 +25172,8 @@ var require_stringify = __commonJS((exports, module) => {
         step = 0;
       }
     }
-    if (typeof filter === "function") {
-      obj = filter(prefix, obj);
-    } else if (obj instanceof Date) {
+    obj = typeof filter === "function" ? filter(prefix, obj) : obj;
+    if (obj instanceof Date) {
       obj = serializeDate(obj);
     } else if (generateArrayPrefix === "comma" && isArray(obj)) {
       obj = utils.maybeMap(obj, function(value2) {
@@ -24886,7 +25185,7 @@ var require_stringify = __commonJS((exports, module) => {
     }
     if (obj === null) {
       if (strictNullHandling) {
-        return encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix;
+        return formatter(encoder && !encodeValuesOnly ? encoder(prefix, defaults.encoder, charset, "key", format) : prefix);
       }
       obj = "";
     }
@@ -24904,7 +25203,9 @@ var require_stringify = __commonJS((exports, module) => {
     var objKeys;
     if (generateArrayPrefix === "comma" && isArray(obj)) {
       if (encodeValuesOnly && encoder) {
-        obj = utils.maybeMap(obj, encoder);
+        obj = utils.maybeMap(obj, function(v2) {
+          return v2 == null ? v2 : encoder(v2);
+        });
       }
       objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : undefined }];
     } else if (isArray(filter)) {
@@ -24915,7 +25216,7 @@ var require_stringify = __commonJS((exports, module) => {
     }
     var encodedPrefix = encodeDotInKeys ? String(prefix).replace(/\./g, "%2E") : String(prefix);
     var adjustedPrefix = commaRoundTrip && isArray(obj) && obj.length === 1 ? encodedPrefix + "[]" : encodedPrefix;
-    if (allowEmptyArrays && isArray(obj) && obj.length === 0) {
+    if (allowEmptyArrays && isArray(obj) && obj.length === 0 && Object.keys(obj).length === 0) {
       return adjustedPrefix + "[]";
     }
     for (var j2 = 0;j2 < objKeys.length; ++j2) {
@@ -24929,7 +25230,7 @@ var require_stringify = __commonJS((exports, module) => {
       sideChannel.set(object2, step);
       var valueSideChannel = getSideChannel();
       valueSideChannel.set(sentinel, sideChannel);
-      pushToArray(values, stringify(value, keyPrefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, valueSideChannel));
+      pushToArray(values, stringify(value, keyPrefix, generateArrayPrefix, commaRoundTrip, allowEmptyArrays, strictNullHandling, skipNulls, encodeDotInKeys, generateArrayPrefix === "comma" && encodeValuesOnly && isArray(obj) ? null : encoder, filter, sort, allowDots, serializeDate, format, formatter, encodeValuesOnly, charset, valueSideChannel, depth, currentDepth + 1));
     }
     return values;
   };
@@ -24983,6 +25284,7 @@ var require_stringify = __commonJS((exports, module) => {
       charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults.charsetSentinel,
       commaRoundTrip: !!opts.commaRoundTrip,
       delimiter: typeof opts.delimiter === "undefined" ? defaults.delimiter : opts.delimiter,
+      depth: typeof opts.depth === "number" ? opts.depth : defaults.depth,
       encode: typeof opts.encode === "boolean" ? opts.encode : defaults.encode,
       encodeDotInKeys: typeof opts.encodeDotInKeys === "boolean" ? opts.encodeDotInKeys : defaults.encodeDotInKeys,
       encoder: typeof opts.encoder === "function" ? opts.encoder : defaults.encoder,
@@ -25023,19 +25325,23 @@ var require_stringify = __commonJS((exports, module) => {
     var sideChannel = getSideChannel();
     for (var i = 0;i < objKeys.length; ++i) {
       var key = objKeys[i];
+      if (typeof key === "undefined" || key === null) {
+        continue;
+      }
       var value = obj[key];
       if (options.skipNulls && value === null) {
         continue;
       }
-      pushToArray(keys, stringify(value, key, generateArrayPrefix, commaRoundTrip, options.allowEmptyArrays, options.strictNullHandling, options.skipNulls, options.encodeDotInKeys, options.encode ? options.encoder : null, options.filter, options.sort, options.allowDots, options.serializeDate, options.format, options.formatter, options.encodeValuesOnly, options.charset, sideChannel));
+      var encodedKey = options.encodeDotInKeys ? String(key).replace(/\./g, "%2E") : String(key);
+      pushToArray(keys, stringify(value, encodedKey, generateArrayPrefix, commaRoundTrip, options.allowEmptyArrays, options.strictNullHandling, options.skipNulls, options.encodeDotInKeys, options.encode ? options.encoder : null, options.filter, options.sort, options.allowDots, options.serializeDate, options.format, options.formatter, options.encodeValuesOnly, options.charset, sideChannel, options.depth, 0));
     }
     var joined = keys.join(options.delimiter);
     var prefix = options.addQueryPrefix === true ? "?" : "";
     if (options.charsetSentinel) {
       if (options.charset === "iso-8859-1") {
-        prefix += "utf8=%26%2310003%3B&";
+        prefix += "utf8=%26%2310003%3B" + options.delimiter;
       } else {
-        prefix += "utf8=%E2%9C%93&";
+        prefix += "utf8=%E2%9C%93" + options.delimiter;
       }
     }
     return joined.length > 0 ? prefix + joined : "";
@@ -25067,6 +25373,7 @@ var require_parse = __commonJS((exports, module) => {
     parseArrays: true,
     plainObjects: false,
     strictDepth: false,
+    strictMerge: true,
     strictNullHandling: false,
     throwOnLimitExceeded: false
   };
@@ -25077,6 +25384,17 @@ var require_parse = __commonJS((exports, module) => {
   };
   var parseArrayValue = function(val, options, currentArrayLength) {
     if (val && typeof val === "string" && options.comma && val.indexOf(",") > -1) {
+      if (options.throwOnLimitExceeded) {
+        var commaCount = 0;
+        var commaIndex = val.indexOf(",");
+        while (commaIndex > -1) {
+          commaCount += 1;
+          if (commaCount >= options.arrayLimit) {
+            throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+          }
+          commaIndex = val.indexOf(",", commaIndex + 1);
+        }
+      }
       return val.split(",");
     }
     if (options.throwOnLimitExceeded && currentArrayLength >= options.arrayLimit) {
@@ -25091,8 +25409,8 @@ var require_parse = __commonJS((exports, module) => {
     var cleanStr = options.ignoreQueryPrefix ? str.replace(/^\?/, "") : str;
     cleanStr = cleanStr.replace(/%5B/gi, "[").replace(/%5D/gi, "]");
     var limit = options.parameterLimit === Infinity ? undefined : options.parameterLimit;
-    var parts = cleanStr.split(options.delimiter, options.throwOnLimitExceeded ? limit + 1 : limit);
-    if (options.throwOnLimitExceeded && parts.length > limit) {
+    var parts = cleanStr.split(options.delimiter, options.throwOnLimitExceeded && typeof limit !== "undefined" ? limit + 1 : limit);
+    if (options.throwOnLimitExceeded && typeof limit !== "undefined" && parts.length > limit) {
       throw new RangeError("Parameter limit exceeded. Only " + limit + " parameter" + (limit === 1 ? "" : "s") + " allowed.");
     }
     var skipIndex = -1;
@@ -25125,9 +25443,11 @@ var require_parse = __commonJS((exports, module) => {
         val = options.strictNullHandling ? null : "";
       } else {
         key = options.decoder(part.slice(0, pos), defaults.decoder, charset, "key");
-        val = utils.maybeMap(parseArrayValue(part.slice(pos + 1), options, isArray(obj[key]) ? obj[key].length : 0), function(encodedVal) {
-          return options.decoder(encodedVal, defaults.decoder, charset, "value");
-        });
+        if (key !== null) {
+          val = utils.maybeMap(parseArrayValue(part.slice(pos + 1), options, isArray(obj[key]) ? obj[key].length : 0), function(encodedVal) {
+            return options.decoder(encodedVal, defaults.decoder, charset, "value");
+          });
+        }
       }
       if (val && options.interpretNumericEntities && charset === "iso-8859-1") {
         val = interpretNumericEntities(String(val));
@@ -25135,11 +25455,16 @@ var require_parse = __commonJS((exports, module) => {
       if (part.indexOf("[]=") > -1) {
         val = isArray(val) ? [val] : val;
       }
-      var existing = has.call(obj, key);
-      if (existing && options.duplicates === "combine") {
-        obj[key] = utils.combine(obj[key], val);
-      } else if (!existing || options.duplicates === "last") {
-        obj[key] = val;
+      if (options.comma && isArray(val) && val.length > options.arrayLimit) {
+        val = utils.combine([], val, options.arrayLimit, options.plainObjects, options.throwOnLimitExceeded);
+      }
+      if (key !== null) {
+        var existing = has.call(obj, key);
+        if (existing && (options.duplicates === "combine" || part.indexOf("[]=") > -1)) {
+          obj[key] = utils.combine(obj[key], val, options.arrayLimit, options.plainObjects, options.throwOnLimitExceeded);
+        } else if (!existing || options.duplicates === "last") {
+          obj[key] = val;
+        }
       }
     }
     return obj;
@@ -25155,17 +25480,27 @@ var require_parse = __commonJS((exports, module) => {
       var obj;
       var root = chain[i];
       if (root === "[]" && options.parseArrays) {
-        obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : utils.combine([], leaf);
+        if (utils.isOverflow(leaf)) {
+          obj = leaf;
+        } else {
+          obj = options.allowEmptyArrays && (leaf === "" || options.strictNullHandling && leaf === null) ? [] : utils.combine([], leaf, options.arrayLimit, options.plainObjects, options.throwOnLimitExceeded);
+        }
       } else {
         obj = options.plainObjects ? { __proto__: null } : {};
         var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
         var decodedRoot = options.decodeDotInKeys ? cleanRoot.replace(/%2E/g, ".") : cleanRoot;
         var index = parseInt(decodedRoot, 10);
+        var isValidArrayIndex = !isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && options.parseArrays;
         if (!options.parseArrays && decodedRoot === "") {
           obj = { 0: leaf };
-        } else if (!isNaN(index) && root !== decodedRoot && String(index) === decodedRoot && index >= 0 && (options.parseArrays && index <= options.arrayLimit)) {
+        } else if (isValidArrayIndex && index < options.arrayLimit) {
           obj = [];
           obj[index] = leaf;
+        } else if (isValidArrayIndex && options.throwOnLimitExceeded) {
+          throw new RangeError("Array limit exceeded. Only " + options.arrayLimit + " element" + (options.arrayLimit === 1 ? "" : "s") + " allowed in an array.");
+        } else if (isValidArrayIndex) {
+          obj[index] = leaf;
+          utils.markOverflow(obj, index);
         } else if (decodedRoot !== "__proto__") {
           obj[decodedRoot] = leaf;
         }
@@ -25174,39 +25509,74 @@ var require_parse = __commonJS((exports, module) => {
     }
     return leaf;
   };
-  var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
-    if (!givenKey) {
-      return;
+  var splitKeyIntoSegments = function splitKeyIntoSegments(originalKey, options) {
+    var key = options.allowDots ? originalKey.replace(/\.([^.[]+)/g, "[$1]") : originalKey;
+    if (options.depth <= 0) {
+      if (!options.plainObjects && has.call(Object.prototype, key)) {
+        if (!options.allowPrototypes) {
+          return;
+        }
+      }
+      return [key];
     }
-    var key = options.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
-    var brackets = /(\[[^[\]]*])/;
-    var child = /(\[[^[\]]*])/g;
-    var segment = options.depth > 0 && brackets.exec(key);
-    var parent = segment ? key.slice(0, segment.index) : key;
-    var keys = [];
+    var segments = [];
+    var first = key.indexOf("[");
+    var parent = first >= 0 ? key.slice(0, first) : key;
     if (parent) {
       if (!options.plainObjects && has.call(Object.prototype, parent)) {
         if (!options.allowPrototypes) {
           return;
         }
       }
-      keys.push(parent);
+      segments[segments.length] = parent;
     }
-    var i = 0;
-    while (options.depth > 0 && (segment = child.exec(key)) !== null && i < options.depth) {
-      i += 1;
-      if (!options.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
-        if (!options.allowPrototypes) {
-          return;
+    var n = key.length;
+    var open = first;
+    var collected = 0;
+    while (open >= 0 && collected < options.depth) {
+      var level = 1;
+      var i = open + 1;
+      var close = -1;
+      while (i < n && close < 0) {
+        var cu = key.charCodeAt(i);
+        if (cu === 91) {
+          level += 1;
+        } else if (cu === 93) {
+          level -= 1;
+          if (level === 0) {
+            close = i;
+          }
         }
+        i += 1;
+      }
+      if (close < 0) {
+        segments[segments.length] = "[" + key.slice(open) + "]";
+        return segments;
+      }
+      var seg = key.slice(open, close + 1);
+      var content = seg.slice(1, -1);
+      if (!options.plainObjects && has.call(Object.prototype, content) && !options.allowPrototypes) {
+        return;
       }
-      keys.push(segment[1]);
+      segments[segments.length] = seg;
+      collected += 1;
+      open = key.indexOf("[", close + 1);
     }
-    if (segment) {
+    if (open >= 0) {
       if (options.strictDepth === true) {
         throw new RangeError("Input depth exceeded depth option of " + options.depth + " and strictDepth is true");
       }
-      keys.push("[" + key.slice(segment.index) + "]");
+      segments[segments.length] = "[" + key.slice(open) + "]";
+    }
+    return segments;
+  };
+  var parseKeys = function parseQueryStringKeys(givenKey, val, options, valuesParsed) {
+    if (!givenKey) {
+      return;
+    }
+    var keys = splitKeyIntoSegments(givenKey, options);
+    if (!keys) {
+      return;
     }
     return parseObject(keys, val, options, valuesParsed);
   };
@@ -25255,6 +25625,7 @@ var require_parse = __commonJS((exports, module) => {
       parseArrays: opts.parseArrays !== false,
       plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults.plainObjects,
       strictDepth: typeof opts.strictDepth === "boolean" ? !!opts.strictDepth : defaults.strictDepth,
+      strictMerge: typeof opts.strictMerge === "boolean" ? !!opts.strictMerge : defaults.strictMerge,
       strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults.strictNullHandling,
       throwOnLimitExceeded: typeof opts.throwOnLimitExceeded === "boolean" ? opts.throwOnLimitExceeded : false
     };
@@ -25310,10 +25681,7 @@ var require_urlencoded = __commonJS((exports, module) => {
     if (normalizedOptions.defaultCharset !== "utf-8" && normalizedOptions.defaultCharset !== "iso-8859-1") {
       throw new TypeError("option defaultCharset must be either utf-8 or iso-8859-1");
     }
-    var queryparse = createQueryParser(options);
-    function parse5(body, encoding) {
-      return body.length ? queryparse(body, encoding) : {};
-    }
+    const parse5 = createQueryParser(options);
     const readOptions = {
       ...normalizedOptions,
       isValidCharset: (charset) => charset === "utf-8" || charset === "iso-8859-1"
@@ -25323,11 +25691,11 @@ var require_urlencoded = __commonJS((exports, module) => {
     };
   }
   function createQueryParser(options) {
-    var extended = Boolean(options?.extended);
-    var parameterLimit = options?.parameterLimit !== undefined ? options?.parameterLimit : 1000;
-    var charsetSentinel = options?.charsetSentinel;
-    var interpretNumericEntities = options?.interpretNumericEntities;
-    var depth = extended ? options?.depth !== undefined ? options?.depth : 32 : 0;
+    const extended = Boolean(options?.extended);
+    let parameterLimit = options?.parameterLimit !== undefined ? options?.parameterLimit : 1000;
+    const charsetSentinel = options?.charsetSentinel;
+    const interpretNumericEntities = options?.interpretNumericEntities;
+    const depth = extended ? options?.depth !== undefined ? options?.depth : 32 : 0;
     if (isNaN(parameterLimit) || parameterLimit < 1) {
       throw new TypeError("option parameterLimit must be a positive number");
     }
@@ -25337,15 +25705,17 @@ var require_urlencoded = __commonJS((exports, module) => {
     if (isFinite(parameterLimit)) {
       parameterLimit = parameterLimit | 0;
     }
-    return function queryparse(body, encoding) {
-      var paramCount = parameterCount(body, parameterLimit);
+    return function parse(body, encoding) {
+      if (!body.length)
+        return {};
+      const paramCount = parameterCount(body, parameterLimit);
       if (paramCount === undefined) {
         debug("too many parameters");
         throw createError(413, "too many parameters", {
           type: "parameters.too.many"
         });
       }
-      var arrayLimit = extended ? Math.max(100, paramCount) : 0;
+      const arrayLimit = extended ? Math.max(100, paramCount) : paramCount;
       debug("parse " + (extended ? "extended " : "") + "urlencoding");
       try {
         return qs.parse(body, {
@@ -25390,26 +25760,10 @@ var require_body_parser = __commonJS((exports, module) => {
    * MIT Licensed
    */
   exports = module.exports = bodyParser;
-  Object.defineProperty(exports, "json", {
-    configurable: true,
-    enumerable: true,
-    get: () => require_json()
-  });
-  Object.defineProperty(exports, "raw", {
-    configurable: true,
-    enumerable: true,
-    get: () => require_raw()
-  });
-  Object.defineProperty(exports, "text", {
-    configurable: true,
-    enumerable: true,
-    get: () => require_text()
-  });
-  Object.defineProperty(exports, "urlencoded", {
-    configurable: true,
-    enumerable: true,
-    get: () => require_urlencoded()
-  });
+  exports.json = require_json();
+  exports.raw = require_raw();
+  exports.text = require_text();
+  exports.urlencoded = require_urlencoded();
   function bodyParser() {
     throw new Error("The bodyParser() generic has been split into individual middleware to use instead.");
   }
@@ -25822,6 +26176,112 @@ var require_view = __commonJS((exports, module) => {
   }
 });
 
+// node_modules/content-type/index.js
+var require_content_type = __commonJS((exports) => {
+  /*!
+   * content-type
+   * Copyright(c) 2015 Douglas Christopher Wilson
+   * MIT Licensed
+   */
+  var PARAM_REGEXP = /; *([!#$%&'*+.^_`|~0-9A-Za-z-]+) *= *("(?:[\u000b\u0020\u0021\u0023-\u005b\u005d-\u007e\u0080-\u00ff]|\\[\u000b\u0020-\u00ff])*"|[!#$%&'*+.^_`|~0-9A-Za-z-]+) */g;
+  var TEXT_REGEXP = /^[\u000b\u0020-\u007e\u0080-\u00ff]+$/;
+  var TOKEN_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+  var QESC_REGEXP = /\\([\u000b\u0020-\u00ff])/g;
+  var QUOTE_REGEXP = /([\\"])/g;
+  var TYPE_REGEXP = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+  exports.format = format;
+  exports.parse = parse5;
+  function format(obj) {
+    if (!obj || typeof obj !== "object") {
+      throw new TypeError("argument obj is required");
+    }
+    var parameters = obj.parameters;
+    var type = obj.type;
+    if (!type || !TYPE_REGEXP.test(type)) {
+      throw new TypeError("invalid type");
+    }
+    var string4 = type;
+    if (parameters && typeof parameters === "object") {
+      var param;
+      var params = Object.keys(parameters).sort();
+      for (var i = 0;i < params.length; i++) {
+        param = params[i];
+        if (!TOKEN_REGEXP.test(param)) {
+          throw new TypeError("invalid parameter name");
+        }
+        string4 += "; " + param + "=" + qstring(parameters[param]);
+      }
+    }
+    return string4;
+  }
+  function parse5(string4) {
+    if (!string4) {
+      throw new TypeError("argument string is required");
+    }
+    var header = typeof string4 === "object" ? getcontenttype(string4) : string4;
+    if (typeof header !== "string") {
+      throw new TypeError("argument string is required to be a string");
+    }
+    var index = header.indexOf(";");
+    var type = index !== -1 ? header.slice(0, index).trim() : header.trim();
+    if (!TYPE_REGEXP.test(type)) {
+      throw new TypeError("invalid media type");
+    }
+    var obj = new ContentType(type.toLowerCase());
+    if (index !== -1) {
+      var key;
+      var match;
+      var value;
+      PARAM_REGEXP.lastIndex = index;
+      while (match = PARAM_REGEXP.exec(header)) {
+        if (match.index !== index) {
+          throw new TypeError("invalid parameter format");
+        }
+        index += match[0].length;
+        key = match[1].toLowerCase();
+        value = match[2];
+        if (value.charCodeAt(0) === 34) {
+          value = value.slice(1, -1);
+          if (value.indexOf("\\") !== -1) {
+            value = value.replace(QESC_REGEXP, "$1");
+          }
+        }
+        obj.parameters[key] = value;
+      }
+      if (index !== header.length) {
+        throw new TypeError("invalid parameter format");
+      }
+    }
+    return obj;
+  }
+  function getcontenttype(obj) {
+    var header;
+    if (typeof obj.getHeader === "function") {
+      header = obj.getHeader("content-type");
+    } else if (typeof obj.headers === "object") {
+      header = obj.headers && obj.headers["content-type"];
+    }
+    if (typeof header !== "string") {
+      throw new TypeError("content-type header is missing from object");
+    }
+    return header;
+  }
+  function qstring(val) {
+    var str = String(val);
+    if (TOKEN_REGEXP.test(str)) {
+      return str;
+    }
+    if (str.length > 0 && !TEXT_REGEXP.test(str)) {
+      throw new TypeError("invalid parameter value");
+    }
+    return '"' + str.replace(QUOTE_REGEXP, "\\$1") + '"';
+  }
+  function ContentType(type) {
+    this.parameters = Object.create(null);
+    this.type = type;
+  }
+});
+
 // node_modules/etag/index.js
 var require_etag = __commonJS((exports, module) => {
   /*!
@@ -26913,7 +27373,7 @@ var require_is_promise = __commonJS((exports, module) => {
 });
 
 // node_modules/path-to-regexp/dist/index.js
-var require_dist = __commonJS((exports) => {
+var require_dist3 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.PathError = exports.TokenData = undefined;
   exports.parse = parse5;
@@ -27273,7 +27733,7 @@ var require_layer = __commonJS((exports, module) => {
    * MIT Licensed
    */
   var isPromise2 = require_is_promise();
-  var pathRegexp = require_dist();
+  var pathRegexp = require_dist3();
   var debug = require_src()("router:layer");
   var deprecate = require_depd()("router");
   var TRAILING_SLASH_REGEXP = /\/+$/;
@@ -40048,10 +40508,12 @@ var require_data = __commonJS((exports, module) => {
 var require_utils4 = __commonJS((exports, module) => {
   var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
   var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+  var isPort = RegExp.prototype.test.bind(/^\d*$/u);
   var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
   var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
-  var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
-  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/?]$/iu);
+  var isPathCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/]$/u);
+  var isQueryFragmentCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:@/?]$/u);
+  var isUserinfoCharacter = RegExp.prototype.test.bind(/^[A-Za-z0-9\-._~!$&'()*+,;=:]$/u);
   function stringArrayToHexStripped(input) {
     let acc = "";
     let code = 0;
@@ -40076,91 +40538,127 @@ var require_utils4 = __commonJS((exports, module) => {
     }
     return acc;
   }
+  var isHextet = RegExp.prototype.test.bind(/^[\dA-Fa-f]{1,4}$/);
+  var isIPvFuture = RegExp.prototype.test.bind(/^[vV][\dA-Fa-f]+\.[A-Za-z\d\-._~!$&'()*+,;=:]+$/);
+  var isZoneCharacter = RegExp.prototype.test.bind(/^[A-Za-z\d\-._~]$/);
   var nonSimpleDomain = RegExp.prototype.test.bind(/[^!"$&'()*+,\-.;=_`a-z{}~]/u);
-  function consumeIsZone(buffer) {
-    buffer.length = 0;
-    return true;
+  var nonSimpleDomainChars = RegExp.prototype.test.bind(/[^\d!"$&'()*+,\-.;=_`a-z{}~]/u);
+  var numericLastLabel = RegExp.prototype.test.bind(/(?:^|\.)\d+$/u);
+  function nonSimpleMailtoDomain(domain) {
+    return nonSimpleDomainChars(domain) || numericLastLabel(domain);
   }
-  function consumeHextets(buffer, address, output) {
-    if (buffer.length) {
-      const hex = stringArrayToHexStripped(buffer);
-      if (hex !== "") {
-        address.push(hex);
-      } else {
-        output.error = true;
-        return false;
+  function isZoneIdentifier(zone) {
+    if (zone.length === 0)
+      return false;
+    for (let i = 0;i < zone.length; i++) {
+      if (isZoneCharacter(zone[i]))
+        continue;
+      if (zone[i] === "%" && i + 2 < zone.length && isHexPair(zone.slice(i + 1, i + 3))) {
+        i += 2;
+        continue;
       }
-      buffer.length = 0;
+      return false;
     }
     return true;
   }
-  function getIPV6(input) {
-    let tokenCount = 0;
-    const output = { error: false, address: "", zone: "" };
-    const address = [];
-    const buffer = [];
-    let endipv6Encountered = false;
-    let endIpv6 = false;
-    let consume = consumeHextets;
-    for (let i = 0;i < input.length; i++) {
-      const cursor = input[i];
-      if (cursor === "[" || cursor === "]") {
-        continue;
-      }
-      if (cursor === ":") {
-        if (endipv6Encountered === true) {
-          endIpv6 = true;
-        }
-        if (!consume(buffer, address, output)) {
-          break;
+  function compressIPv6ZeroRun(hextets) {
+    let bestStart = -1;
+    let bestLength = 0;
+    let runStart = -1;
+    let runLength = 0;
+    for (let i = 0;i < hextets.length; i++) {
+      if (hextets[i] === "0") {
+        if (runStart === -1)
+          runStart = i;
+        runLength++;
+        if (runLength > bestLength) {
+          bestLength = runLength;
+          bestStart = runStart;
         }
-        if (++tokenCount > 7) {
-          output.error = true;
-          break;
-        }
-        if (i > 0 && input[i - 1] === ":") {
-          endipv6Encountered = true;
-        }
-        address.push(":");
-        continue;
-      } else if (cursor === "%") {
-        if (!consume(buffer, address, output)) {
-          break;
-        }
-        consume = consumeIsZone;
       } else {
-        buffer.push(cursor);
-        continue;
+        runStart = -1;
+        runLength = 0;
       }
     }
-    if (buffer.length) {
-      if (consume === consumeIsZone) {
-        output.zone = buffer.join("");
-      } else if (endIpv6) {
-        address.push(buffer.join(""));
-      } else {
-        address.push(stringArrayToHexStripped(buffer));
+    if (bestLength < 2)
+      return hextets.join(":");
+    const head = hextets.slice(0, bestStart).join(":");
+    const tail = hextets.slice(bestStart + bestLength).join(":");
+    return head + "::" + tail;
+  }
+  function normalizeIPv6Address(input) {
+    const compression = input.indexOf("::");
+    if (compression !== -1 && input.indexOf("::", compression + 1) !== -1)
+      return;
+    const left = compression === -1 ? input.split(":") : input.slice(0, compression).split(":");
+    const right = compression === -1 ? [] : input.slice(compression + 2).split(":");
+    if (compression !== -1) {
+      if (left.length === 1 && left[0] === "")
+        left.length = 0;
+      if (right.length === 1 && right[0] === "")
+        right.length = 0;
+    }
+    const parts = left.concat(right);
+    let hextetCount = 0;
+    for (let i = 0;i < parts.length; i++) {
+      const part = parts[i];
+      if (part === "")
+        return;
+      if (part.indexOf(".") !== -1) {
+        if (i !== parts.length - 1 || compression !== -1 && right.length === 0 || !isIPv4(part))
+          return;
+        hextetCount += 2;
+        continue;
       }
+      if (!isHextet(part))
+        return;
+      parts[i] = parseInt(part, 16).toString(16);
+      hextetCount++;
     }
-    output.address = address.join("");
-    return output;
+    if (compression === -1) {
+      if (hextetCount !== 8)
+        return;
+      return compressIPv6ZeroRun(parts);
+    }
+    if (hextetCount >= 8)
+      return;
+    const expanded = parts.slice(0, left.length);
+    for (let i = hextetCount;i < 8; i++)
+      expanded.push("0");
+    for (let i = left.length;i < parts.length; i++)
+      expanded.push(parts[i]);
+    return compressIPv6ZeroRun(expanded);
   }
   function normalizeIPv6(host) {
-    if (findToken(host, ":") < 2) {
-      return { host, isIPV6: false };
-    }
-    const ipv62 = getIPV6(host);
-    if (!ipv62.error) {
-      let newHost = ipv62.address;
-      let escapedHost = ipv62.address;
-      if (ipv62.zone) {
-        newHost += "%" + ipv62.zone;
-        escapedHost += "%25" + ipv62.zone;
-      }
-      return { host: newHost, isIPV6: true, escapedHost };
-    } else {
-      return { host, isIPV6: false };
-    }
+    const bracketed = host[0] === "[" && host[host.length - 1] === "]";
+    const hasBracket = host[0] === "[" || host[host.length - 1] === "]";
+    if (hasBracket && !bracketed)
+      return { host, isIPV6: false, error: true };
+    let input = bracketed ? host.slice(1, -1) : host;
+    if (bracketed && isIPvFuture(input)) {
+      input = input.toLowerCase();
+      return { host: `[${input}]`, escapedHost: input, isIPV6: false, isIPVFuture: true };
+    }
+    if (findToken(input, ":") < 2) {
+      return { host, isIPV6: false, error: bracketed };
+    }
+    let zoneIdentifier = "";
+    const zoneSeparator = input.indexOf("%");
+    if (zoneSeparator !== -1) {
+      const separatorLength = input.slice(zoneSeparator, zoneSeparator + 3).toLowerCase() === "%25" ? 3 : 1;
+      zoneIdentifier = input.slice(zoneSeparator + separatorLength);
+      if (!isZoneIdentifier(zoneIdentifier))
+        return { host, isIPV6: false, error: true };
+      input = input.slice(0, zoneSeparator);
+    }
+    const address = normalizeIPv6Address(input);
+    if (address === undefined)
+      return { host, isIPV6: false, error: true };
+    return {
+      host: address + (zoneIdentifier ? "%" + zoneIdentifier : ""),
+      escapedHost: address + (zoneIdentifier ? "%25" + zoneIdentifier : ""),
+      isIPV6: true
+    };
   }
   function findToken(str, token) {
     let ind = 0;
@@ -40337,6 +40835,45 @@ var require_utils4 = __commonJS((exports, module) => {
     }
     return output;
   }
+  function serializePathEncoding(input, pathNoScheme = false) {
+    let output = "";
+    let firstSegment = pathNoScheme && input[0] !== "/";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (ch === "/") {
+        firstSegment = false;
+      }
+      if (isPathCharacter(ch) && (ch !== ":" || !firstSegment)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
   function normalizeQueryFragmentEncoding(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
@@ -40378,6 +40915,50 @@ var require_utils4 = __commonJS((exports, module) => {
     }
     return output;
   }
+  function encodeComponent(input, isAllowed) {
+    let output = "";
+    for (let i = 0;i < input.length; i++) {
+      const ch = input[i];
+      if (ch === "%" && i + 2 < input.length) {
+        const hex = input.slice(i + 1, i + 3);
+        if (isHexPair(hex)) {
+          output += "%" + hex.toUpperCase();
+          i += 2;
+          continue;
+        }
+      }
+      if (isAllowed(ch)) {
+        output += ch;
+      } else {
+        const code = input.charCodeAt(i);
+        if (code < 128) {
+          output += BYTE_HEX[code];
+        } else if (code < 55296 || code > 57343) {
+          output += percentEncodeNonAscii(code);
+        } else if (code <= 56319 && i + 1 < input.length) {
+          const low = input.charCodeAt(i + 1);
+          if (low >= 56320 && low <= 57343) {
+            output += percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+            i++;
+          } else {
+            output += percentEncodeNonAscii(65533);
+          }
+        } else {
+          output += percentEncodeNonAscii(65533);
+        }
+      }
+    }
+    return output;
+  }
+  function encodeUserinfo(input) {
+    return encodeComponent(input, isUserinfoCharacter);
+  }
+  function encodeQuery(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
+  function encodeFragment(input) {
+    return encodeComponent(input, isQueryFragmentCharacter);
+  }
   function escapePreservingEscapes(input) {
     let output = "";
     for (let i = 0;i < input.length; i++) {
@@ -40409,37 +40990,73 @@ var require_utils4 = __commonJS((exports, module) => {
     }
     return output;
   }
+  function recomposeZonedIPv6Host(component) {
+    const zone = component.ipv6Zone;
+    if (zone === undefined)
+      return;
+    const host = component.host;
+    const separator = host.indexOf("%");
+    if (separator === -1)
+      return;
+    const address = host.slice(0, separator);
+    const escaped = address + "%25" + zone;
+    const derived = normalizeIPv6("[" + escaped + "]");
+    if (derived.isIPV6 === true && derived.host === host) {
+      return "[" + escaped + "]";
+    }
+    return;
+  }
   function recomposeAuthority(component) {
     const uriTokens = [];
     if (component.userinfo !== undefined) {
-      uriTokens.push(component.userinfo);
+      uriTokens.push(encodeUserinfo(component.userinfo));
       uriTokens.push("@");
     }
     if (component.host !== undefined) {
-      let host = unescape(component.host);
+      let host = component.host;
       if (!isIPv4(host)) {
-        const ipV6res = normalizeIPv6(host);
-        if (ipV6res.isIPV6 === true) {
-          host = `[${ipV6res.escapedHost}]`;
+        const zonedHost = recomposeZonedIPv6Host(component);
+        if (zonedHost !== undefined) {
+          host = zonedHost;
         } else {
-          host = reescapeHostDelimiters(host, false);
+          let ipV6res = normalizeIPv6(host);
+          if (ipV6res.isIPV6 !== true && ipV6res.isIPVFuture !== true) {
+            host = normalizePercentEncoding(host, true);
+            ipV6res = normalizeIPv6(host);
+          }
+          if (ipV6res.isIPV6 === true || ipV6res.isIPVFuture === true) {
+            host = `[${ipV6res.escapedHost}]`;
+          } else {
+            host = reescapeHostDelimiters(host, false);
+          }
         }
       }
       uriTokens.push(host);
     }
     if (typeof component.port === "number" || typeof component.port === "string") {
+      const port = String(component.port);
+      if (!isPort(port)) {
+        throw new TypeError("URI port is malformed.");
+      }
       uriTokens.push(":");
-      uriTokens.push(String(component.port));
+      uriTokens.push(port);
     }
     return uriTokens.length ? uriTokens.join("") : undefined;
   }
   module.exports = {
+    BYTE_HEX,
+    percentEncodeNonAscii,
     nonSimpleDomain,
+    nonSimpleMailtoDomain,
     recomposeAuthority,
     reescapeHostDelimiters,
     normalizePercentEncoding,
     normalizePathEncoding,
+    serializePathEncoding,
     normalizeQueryFragmentEncoding,
+    encodeUserinfo,
+    encodeQuery,
+    encodeFragment,
     escapePreservingEscapes,
     removeDotSegments,
     isIPv4,
@@ -40451,15 +41068,16 @@ var require_utils4 = __commonJS((exports, module) => {
 
 // node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS((exports, module) => {
-  var { isUUID } = require_utils4();
-  var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
+  var { isUUID, BYTE_HEX, percentEncodeNonAscii, nonSimpleMailtoDomain } = require_utils4();
+  var URN_REG = /^([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-./:;=@]|%[\da-f]{2})+)$/iu;
   var supportedSchemeNames = [
     "http",
     "https",
     "ws",
     "wss",
     "urn",
-    "urn:uuid"
+    "urn:uuid",
+    "mailto"
   ];
   function isValidSchemeName(name) {
     return supportedSchemeNames.indexOf(name) !== -1;
@@ -40507,9 +41125,10 @@ var require_schemes = __commonJS((exports, module) => {
       wsComponent.secure = undefined;
     }
     if (wsComponent.resourceName) {
-      const [path, query] = wsComponent.resourceName.split("?");
+      const queryIndex = wsComponent.resourceName.indexOf("?");
+      const path = queryIndex === -1 ? wsComponent.resourceName : wsComponent.resourceName.slice(0, queryIndex);
       wsComponent.path = path && path !== "/" ? path : undefined;
-      wsComponent.query = query;
+      wsComponent.query = queryIndex === -1 ? undefined : wsComponent.resourceName.slice(queryIndex + 1);
       wsComponent.resourceName = undefined;
     }
     wsComponent.fragment = undefined;
@@ -40521,7 +41140,7 @@ var require_schemes = __commonJS((exports, module) => {
       return urnComponent;
     }
     const matches = urnComponent.path.match(URN_REG);
-    if (matches) {
+    if (matches && matches[0] === urnComponent.path) {
       const scheme = options.scheme || urnComponent.scheme || "urn";
       urnComponent.nid = matches[1].toLowerCase();
       urnComponent.nss = matches[2];
@@ -40603,13 +41222,262 @@ var require_schemes = __commonJS((exports, module) => {
     serialize: urnuuidSerialize,
     skipNormalize: true
   };
+  var LOCAL_PART_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+=";
+  var HFNAME_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+,;:@";
+  var DTEXT_ALLOWED = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~!$'()*+;:";
+  function allowSet(chars, allowNonAscii = false) {
+    const table = new Uint8Array(128);
+    for (let i = 0;i < chars.length; i++) {
+      table[chars.charCodeAt(i)] = 1;
+    }
+    const escaped = chars.replace(/[\\\]^-]/gu, "\\$&");
+    const cls = allowNonAscii ? `[${escaped}]|[^\\0-\\x7F\\uD800-\\uDFFF]` : `[${escaped}]`;
+    return { all: new RegExp(`^(?:${cls})*$`, "u"), table, allowNonAscii };
+  }
+  var LOCAL_PART = allowSet(LOCAL_PART_ALLOWED);
+  var HFNAME = allowSet(HFNAME_ALLOWED);
+  var DTEXT = allowSet(DTEXT_ALLOWED);
+  var DTEXT_IRI = allowSet(DTEXT_ALLOWED, true);
+  var HEX_PAIR = /^[\da-f]{2}$/iu;
+  var MAILTO_DOMAIN_LITERAL = /^\[[\x21-\x5A\x5E-\x7E]*\]$/u;
+  var MAILTO_DOMAIN_ERROR = "URI mailto has an invalid recipient domain.";
+  var MAILTO_AUTHORITY_ERROR = "URI mailto must not have an authority component.";
+  var HAS_SURROGATE = /[\uD800-\uDFFF]/u;
+  function decodeHex(str) {
+    if (typeof str !== "string" || str.indexOf("%") === -1) {
+      return str;
+    }
+    try {
+      return decodeURIComponent(str);
+    } catch {
+      return str;
+    }
+  }
+  function replaceLoneSurrogates(input) {
+    let result = "";
+    for (let i = 0;i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      if (code >= 55296 && code <= 56319 && i + 1 < input.length) {
+        const low = input.charCodeAt(i + 1);
+        if (low >= 56320 && low <= 57343) {
+          result += input[i] + input[i + 1];
+          i++;
+          continue;
+        }
+      }
+      result += code >= 55296 && code <= 57343 ? "�" : input[i];
+    }
+    return result;
+  }
+  function encodeWithAllow(input, set2) {
+    if (set2.all.test(input)) {
+      return input;
+    }
+    const table = set2.table;
+    let result = "";
+    for (let i = 0;i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      if (code < 128) {
+        if (table[code] === 1) {
+          result += input[i];
+        } else if (code === 37 && i + 2 < input.length && HEX_PAIR.test(input.slice(i + 1, i + 3))) {
+          result += "%" + input.slice(i + 1, i + 3).toUpperCase();
+          i += 2;
+        } else {
+          result += BYTE_HEX[code];
+        }
+        continue;
+      }
+      if (code < 55296 || code > 57343) {
+        result += set2.allowNonAscii ? input[i] : percentEncodeNonAscii(code);
+        continue;
+      }
+      if (code <= 56319 && i + 1 < input.length) {
+        const low = input.charCodeAt(i + 1);
+        if (low >= 56320 && low <= 57343) {
+          result += set2.allowNonAscii ? input[i] + input[i + 1] : percentEncodeNonAscii(65536 + (code - 55296 << 10) + (low - 56320));
+          i++;
+          continue;
+        }
+      }
+      result += set2.allowNonAscii ? "�" : percentEncodeNonAscii(65533);
+    }
+    return result;
+  }
+  function mailtoNormalizeDomain(domain, options, component) {
+    const normalizedDomain = String(domain).toLowerCase();
+    if (MAILTO_DOMAIN_LITERAL.test(normalizedDomain)) {
+      return normalizedDomain;
+    }
+    if (normalizedDomain !== "" && !nonSimpleMailtoDomain(normalizedDomain)) {
+      return normalizedDomain;
+    }
+    try {
+      const parsedDomain = new URL("http://" + normalizedDomain);
+      if (parsedDomain.username || parsedDomain.password || parsedDomain.port || parsedDomain.pathname !== "/" || parsedDomain.search || parsedDomain.hash || !parsedDomain.hostname) {
+        throw new Error(MAILTO_DOMAIN_ERROR);
+      }
+      return options && options.unicodeSupport ? normalizedDomain : parsedDomain.hostname;
+    } catch {
+      if (component) {
+        component.error = component.error || MAILTO_DOMAIN_ERROR;
+      }
+      return normalizedDomain;
+    }
+  }
+  function mailtoEncodeDomain(domain, options) {
+    const set2 = options && options.unicodeSupport ? DTEXT_IRI : DTEXT;
+    if (domain.length > 1 && domain[0] === "[" && domain[domain.length - 1] === "]") {
+      return "[" + encodeWithAllow(domain.slice(1, -1), set2) + "]";
+    }
+    return encodeWithAllow(domain, set2);
+  }
+  function mailtoParse(component, options) {
+    const mailtoComponent = component;
+    let rawPath = mailtoComponent.path;
+    let rawQuery = mailtoComponent.query;
+    if (rawPath && HAS_SURROGATE.test(rawPath))
+      rawPath = replaceLoneSurrogates(rawPath);
+    if (rawQuery && HAS_SURROGATE.test(rawQuery))
+      rawQuery = replaceLoneSurrogates(rawQuery);
+    const to = rawPath ? rawPath.indexOf(",") === -1 ? [rawPath] : rawPath.split(",") : [];
+    mailtoComponent.path = undefined;
+    if (rawQuery) {
+      let headers = null;
+      let start = 0;
+      while (start <= rawQuery.length) {
+        let end = rawQuery.indexOf("&", start);
+        if (end === -1)
+          end = rawQuery.length;
+        const token = rawQuery.slice(start, end);
+        start = end + 1;
+        const eqIdx = token.indexOf("=");
+        if (eqIdx !== token.lastIndexOf("=")) {
+          mailtoComponent.error = mailtoComponent.error || "URI mailto has malformed header fields.";
+          continue;
+        }
+        const name = decodeHex(eqIdx === -1 ? token : token.slice(0, eqIdx));
+        const normalizedName = name.toLowerCase();
+        const value = eqIdx === -1 ? "" : token.slice(eqIdx + 1);
+        if (normalizedName === "to") {
+          const addrs = value.split(",");
+          for (let j2 = 0;j2 < addrs.length; j2++)
+            to.push(addrs[j2]);
+          continue;
+        }
+        if (normalizedName === "subject") {
+          mailtoComponent.subject = decodeHex(value);
+          continue;
+        }
+        if (normalizedName === "body") {
+          mailtoComponent.body = decodeHex(value);
+          continue;
+        }
+        if (headers === null)
+          headers = Object.create(null);
+        headers[name] = decodeHex(value);
+      }
+      if (headers !== null)
+        mailtoComponent.headers = headers;
+    }
+    mailtoComponent.query = undefined;
+    if (to.length > 0 && (mailtoComponent.userinfo !== undefined || mailtoComponent.host !== undefined || mailtoComponent.port !== undefined)) {
+      mailtoComponent.userinfo = undefined;
+      mailtoComponent.host = undefined;
+      mailtoComponent.port = undefined;
+      mailtoComponent.error = mailtoComponent.error || MAILTO_AUTHORITY_ERROR;
+    }
+    for (let i = 0;i < to.length; i++) {
+      const rawAddr = to[i];
+      const atIdx = rawAddr.lastIndexOf("@");
+      if (atIdx < 0) {
+        mailtoComponent.error = mailtoComponent.error || MAILTO_DOMAIN_ERROR;
+        to[i] = decodeHex(rawAddr);
+        continue;
+      }
+      const local = decodeHex(rawAddr.slice(0, atIdx));
+      const domain = mailtoNormalizeDomain(decodeHex(rawAddr.slice(atIdx + 1)), options, mailtoComponent);
+      to[i] = local + "@" + domain;
+    }
+    if (to.length)
+      mailtoComponent.to = to;
+    return mailtoComponent;
+  }
+  function mailtoEncodeHeaderName(name) {
+    return encodeWithAllow(name.replace(/%/gu, "%25"), HFNAME);
+  }
+  function mailtoSerialize(component, options) {
+    const mailtoComponent = component;
+    const to = Array.isArray(mailtoComponent.to) ? mailtoComponent.to.slice() : [];
+    const sourceHeaders = mailtoComponent.headers && typeof mailtoComponent.headers === "object" ? Object.assign(Object.create(null), mailtoComponent.headers) : Object.create(null);
+    const headers = Object.create(null);
+    for (const name in sourceHeaders) {
+      const normalizedName = name.toLowerCase();
+      if (normalizedName === "to") {
+        const addrs = String(sourceHeaders[name]).split(",");
+        for (let i = 0;i < addrs.length; i++)
+          to.push(addrs[i]);
+      } else if (normalizedName === "subject" || normalizedName === "body") {
+        headers[normalizedName] = sourceHeaders[name];
+      } else {
+        headers[name] = sourceHeaders[name];
+      }
+    }
+    if (mailtoComponent.subject !== undefined)
+      headers.subject = mailtoComponent.subject;
+    if (mailtoComponent.body !== undefined)
+      headers.body = mailtoComponent.body;
+    mailtoComponent.headers = headers;
+    if (to.length) {
+      mailtoComponent.userinfo = undefined;
+      mailtoComponent.host = undefined;
+      mailtoComponent.port = undefined;
+      for (let i = 0;i < to.length; i++) {
+        const addr = String(to[i]);
+        const atIdx = addr.lastIndexOf("@");
+        const rawLocal = atIdx >= 0 ? addr.slice(0, atIdx) : addr;
+        const rawDomain = atIdx >= 0 ? addr.slice(atIdx + 1) : "";
+        const local = encodeWithAllow(rawLocal, LOCAL_PART);
+        const decodedDomain = decodeHex(rawDomain);
+        const normalizedDomain = mailtoNormalizeDomain(decodedDomain, options);
+        to[i] = local + "@" + mailtoEncodeDomain(normalizedDomain, options);
+      }
+      mailtoComponent.path = to.join(",");
+      options.skipEscape = true;
+    } else {
+      mailtoComponent.path = undefined;
+    }
+    let query = "";
+    let count = 0;
+    for (const name in headers) {
+      if (count++ !== 0)
+        query += "&";
+      query += mailtoEncodeHeaderName(name) + "=" + encodeWithAllow(String(headers[name]), HFNAME);
+    }
+    if (count !== 0) {
+      mailtoComponent.query = query;
+    } else {
+      mailtoComponent.headers = undefined;
+    }
+    return mailtoComponent;
+  }
+  var mailto = {
+    scheme: "mailto",
+    parse: mailtoParse,
+    serialize: mailtoSerialize,
+    domainHost: false,
+    unicodeSupport: true,
+    skipNormalize: true,
+    absolutePath: true
+  };
   var SCHEMES = {
     http,
     https,
     ws,
     wss,
     urn,
-    "urn:uuid": urnuuid
+    "urn:uuid": urnuuid,
+    mailto
   };
   Object.setPrototypeOf(SCHEMES, null);
   function getSchemeHandler(scheme) {
@@ -40625,8 +41493,17 @@ var require_schemes = __commonJS((exports, module) => {
 
 // node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS((exports, module) => {
-  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, normalizeQueryFragmentEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils4();
+  var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, serializePathEncoding, normalizeQueryFragmentEncoding, encodeQuery, encodeFragment, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils4();
   var { SCHEMES, getSchemeHandler } = require_schemes();
+  var VALID_SCHEME = /^[A-Za-z][A-Za-z0-9+.-]*$/u;
+  var MALFORMED_SCHEME_ERROR = "URI scheme is malformed.";
+  function decodeValidScheme(scheme) {
+    const decodedScheme = unescape(String(scheme));
+    if (!VALID_SCHEME.test(decodedScheme)) {
+      throw new TypeError(MALFORMED_SCHEME_ERROR);
+    }
+    return decodedScheme;
+  }
   function normalize(uri, options) {
     if (typeof uri === "string") {
       uri = normalizeString(uri, options);
@@ -40637,10 +41514,43 @@ var require_fast_uri = __commonJS((exports, module) => {
   }
   function resolve(baseURI, relativeURI, options) {
     const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
-    const resolved = resolveComponent(parse6(baseURI, schemelessOptions), parse6(relativeURI, schemelessOptions), schemelessOptions, true);
+    const {
+      parsed: baseParsed,
+      malformedAuthorityOrPort: baseMalformed,
+      malformedPercentEncoding: baseMalformedPercentEncoding,
+      malformedSchemeSpecific: baseMalformedSchemeSpecific,
+      malformedHost: baseMalformedHost,
+      malformedScheme: baseMalformedScheme
+    } = parseWithStatus(baseURI, schemelessOptions);
+    const {
+      parsed: relativeParsed,
+      malformedAuthorityOrPort: relativeMalformed,
+      malformedPercentEncoding: relativeMalformedPercentEncoding,
+      malformedSchemeSpecific: relativeMalformedSchemeSpecific,
+      malformedHost: relativeMalformedHost,
+      malformedScheme: relativeMalformedScheme
+    } = parseWithStatus(relativeURI, schemelessOptions);
+    if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
+      throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
+    }
+    const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+    const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
+    const resolvedHost = resolved.host;
+    const resolvedHostIsIP = resolvedHost !== undefined && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
+    canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+    const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !/\P{ASCII}/u.test(resolvedHost);
+    if (resolved.error && !encodedASCIIHost) {
+      throw new Error(resolved.error);
+    }
     schemelessOptions.skipEscape = true;
     return serialize(resolved, schemelessOptions);
   }
+  function copyHost(target, source) {
+    target.host = source.host;
+    if (source.ipv6Zone !== undefined) {
+      target.ipv6Zone = source.ipv6Zone;
+    }
+  }
   function resolveComponent(base, relative, options, skipNormalization) {
     const target = {};
     if (!skipNormalization) {
@@ -40651,14 +41561,14 @@ var require_fast_uri = __commonJS((exports, module) => {
     if (!options.tolerant && relative.scheme) {
       target.scheme = relative.scheme;
       target.userinfo = relative.userinfo;
-      target.host = relative.host;
+      copyHost(target, relative);
       target.port = relative.port;
       target.path = removeDotSegments(relative.path || "");
       target.query = relative.query;
     } else {
       if (relative.userinfo !== undefined || relative.host !== undefined || relative.port !== undefined) {
         target.userinfo = relative.userinfo;
-        target.host = relative.host;
+        copyHost(target, relative);
         target.port = relative.port;
         target.path = removeDotSegments(relative.path || "");
         target.query = relative.query;
@@ -40686,7 +41596,7 @@ var require_fast_uri = __commonJS((exports, module) => {
           target.query = relative.query;
         }
         target.userinfo = base.userinfo;
-        target.host = base.host;
+        copyHost(target, base);
         target.port = base.port;
       }
       target.scheme = base.scheme;
@@ -40697,11 +41607,12 @@ var require_fast_uri = __commonJS((exports, module) => {
   function equal(uriA, uriB, options) {
     const normalizedA = normalizeComparableURI(uriA, options);
     const normalizedB = normalizeComparableURI(uriB, options);
-    return normalizedA !== undefined && normalizedB !== undefined && normalizedA.toLowerCase() === normalizedB.toLowerCase();
+    return normalizedA !== undefined && normalizedB !== undefined && normalizedA === normalizedB;
   }
   function serialize(cmpts, opts) {
     const component = {
       host: cmpts.host,
+      ipv6Zone: cmpts.ipv6Zone,
       scheme: cmpts.scheme,
       userinfo: cmpts.userinfo,
       port: cmpts.port,
@@ -40714,24 +41625,31 @@ var require_fast_uri = __commonJS((exports, module) => {
       reference: cmpts.reference,
       resourceName: cmpts.resourceName,
       secure: cmpts.secure,
+      to: cmpts.to,
+      subject: cmpts.subject,
+      body: cmpts.body,
+      headers: cmpts.headers,
       error: ""
     };
     const options = Object.assign({}, opts);
     const uriTokens = [];
+    if (component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
+    }
     const schemeHandler = getSchemeHandler(options.scheme || component.scheme);
     if (schemeHandler && schemeHandler.serialize)
       schemeHandler.serialize(component, options);
+    const hasAuthority = component.userinfo !== undefined || component.host !== undefined || component.port !== undefined;
+    const pathNoScheme = !options.skipEscape && component.scheme === undefined && !hasAuthority;
     if (component.path !== undefined) {
       if (!options.skipEscape) {
-        component.path = escapePreservingEscapes(component.path);
-        if (component.scheme !== undefined) {
-          component.path = component.path.split("%3A").join(":");
-        }
+        component.path = serializePathEncoding(component.path, pathNoScheme);
       } else {
         component.path = normalizePercentEncoding(component.path);
       }
     }
     if (options.reference !== "suffix" && component.scheme) {
+      component.scheme = decodeValidScheme(component.scheme);
       uriTokens.push(component.scheme, ":");
     }
     const authority = recomposeAuthority(component);
@@ -40749,21 +41667,25 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (!options.absolutePath && (!schemeHandler || !schemeHandler.absolutePath)) {
         s = removeDotSegments(s);
       }
+      if (pathNoScheme) {
+        s = serializePathEncoding(s, true);
+      }
       if (authority === undefined && s[0] === "/" && s[1] === "/") {
         s = "/%2F" + s.slice(2);
       }
       uriTokens.push(s);
     }
     if (component.query !== undefined) {
-      uriTokens.push("?", component.query);
+      uriTokens.push("?", encodeQuery(component.query));
     }
     if (component.fragment !== undefined) {
-      uriTokens.push("#", component.fragment);
+      uriTokens.push("#", encodeFragment(component.fragment));
     }
     return uriTokens.join("");
   }
   var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
   var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
+  var AUTHORITY_INTRODUCER_REGION = /^(?:[^#/:?]+:)?([/\\\t\n\r]*)/;
   function getParseError(parsed, matches) {
     if (matches[2] !== undefined && parsed.path && parsed.path[0] !== "/") {
       return 'URI path must start with "/" when authority is present.';
@@ -40773,6 +41695,37 @@ var require_fast_uri = __commonJS((exports, module) => {
     }
     return;
   }
+  function hasMalformedPercentEncoding(component) {
+    if (component === undefined)
+      return false;
+    let percent = component.indexOf("%");
+    while (percent !== -1) {
+      if (percent + 2 >= component.length || !/^[\da-f]{2}$/iu.test(component.slice(percent + 1, percent + 3))) {
+        return true;
+      }
+      percent = component.indexOf("%", percent + 3);
+    }
+    return false;
+  }
+  function isIPLiteral(host) {
+    return host[0] === "[" && host[host.length - 1] === "]";
+  }
+  function hasMalformedComponentPercentEncoding(matches) {
+    const host = matches[4];
+    return hasMalformedPercentEncoding(matches[3]) || host !== undefined && !isIPLiteral(host) && hasMalformedPercentEncoding(host) || hasMalformedPercentEncoding(matches[6]) || hasMalformedPercentEncoding(matches[7]) || hasMalformedPercentEncoding(matches[8]);
+  }
+  function canonicalizeHost(parsed, options, schemeHandler, isIP) {
+    const bracketedIPLiteral = parsed.host && parsed.host[0] === "[" && parsed.host[parsed.host.length - 1] === "]";
+    if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport) && parsed.host && !isIPLiteral(parsed.host) && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && !bracketedIPLiteral && nonSimpleDomain(parsed.host)) {
+      try {
+        parsed.host = new URL("http://" + parsed.host).hostname;
+      } catch (e) {
+        parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
+        return true;
+      }
+    }
+    return false;
+  }
   function parseWithStatus(uri, opts) {
     const options = Object.assign({}, opts);
     const parsed = {
@@ -40785,6 +41738,11 @@ var require_fast_uri = __commonJS((exports, module) => {
       fragment: undefined
     };
     let malformedAuthorityOrPort = false;
+    let malformedPercentEncoding = false;
+    let malformedSchemeSpecific = false;
+    let malformedHost = false;
+    let malformedIPLiteral = false;
+    let malformedScheme = false;
     let isIP = false;
     if (options.reference === "suffix") {
       if (options.scheme) {
@@ -40798,15 +41756,42 @@ var require_fast_uri = __commonJS((exports, module) => {
       parsed.error = "URI authority must not contain a literal backslash.";
       malformedAuthorityOrPort = true;
     }
+    const introducerMatch = uri.match(AUTHORITY_INTRODUCER_REGION);
+    if (introducerMatch !== null) {
+      const region = introducerMatch[1];
+      const normalizedRegion = region.replace(/[\t\n\r]/g, "");
+      if (normalizedRegion.length >= 2) {
+        if (normalizedRegion.slice(0, 2) !== "//") {
+          parsed.error = parsed.error || "URI authority must not contain a literal backslash.";
+          malformedAuthorityOrPort = true;
+        } else if (region.length !== normalizedRegion.length) {
+          parsed.error = parsed.error || "URI authority introducer must not contain whitespace.";
+          malformedAuthorityOrPort = true;
+        }
+      }
+    }
     const matches = uri.match(URI_PARSE);
     if (matches) {
-      parsed.scheme = matches[1] === undefined ? undefined : matches[1].toLowerCase();
+      parsed.scheme = matches[1];
       parsed.userinfo = matches[3];
       parsed.host = matches[4];
       parsed.port = parseInt(matches[5], 10);
       parsed.path = matches[6] || "";
       parsed.query = matches[7];
       parsed.fragment = matches[8];
+      if (parsed.scheme !== undefined) {
+        const decodedScheme = unescape(parsed.scheme);
+        if (VALID_SCHEME.test(decodedScheme)) {
+          parsed.scheme = decodedScheme.toLowerCase();
+        } else {
+          parsed.error = parsed.error || MALFORMED_SCHEME_ERROR;
+          malformedScheme = true;
+        }
+      }
+      malformedPercentEncoding = hasMalformedComponentPercentEncoding(matches);
+      if (malformedPercentEncoding) {
+        parsed.error = parsed.error || "URI contains malformed percent-encoding.";
+      }
       if (isNaN(parsed.port)) {
         parsed.port = matches[5];
       }
@@ -40818,9 +41803,19 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (parsed.host) {
         const ipv4result = isIPv4(parsed.host);
         if (ipv4result === false) {
+          const bracketedIPLiteral = isIPLiteral(parsed.host);
+          const hasIPLiteralBracket = parsed.host.indexOf("[") !== -1 || parsed.host.indexOf("]") !== -1;
           const ipv6result = normalizeIPv6(parsed.host);
-          parsed.host = ipv6result.host.toLowerCase();
-          isIP = ipv6result.isIPV6;
+          isIP = ipv6result.isIPV6 || ipv6result.isIPVFuture === true;
+          malformedIPLiteral = hasIPLiteralBracket && (!bracketedIPLiteral || ipv6result.error === true);
+          parsed.host = isIP ? ipv6result.host : ipv6result.host.toLowerCase();
+          if (isIP && ipv6result.isIPV6 === true && parsed.host.indexOf("%") !== -1) {
+            parsed.ipv6Zone = parsed.host.slice(parsed.host.indexOf("%") + 1);
+          }
+          if (malformedIPLiteral) {
+            parsed.error = parsed.error || "URI host is malformed.";
+            malformedAuthorityOrPort = true;
+          }
         } else {
           isIP = true;
         }
@@ -40838,24 +41833,17 @@ var require_fast_uri = __commonJS((exports, module) => {
         parsed.error = parsed.error || "URI is not a " + options.reference + " reference.";
       }
       const schemeHandler = getSchemeHandler(options.scheme || parsed.scheme);
-      if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
-        if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
-          try {
-            parsed.host = new URL("http://" + parsed.host).hostname;
-          } catch (e) {
-            parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
-          }
+      if (!malformedIPLiteral) {
+        malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
+      }
+      if (uri.indexOf("%") !== -1 && parsed.host !== undefined && !malformedIPLiteral) {
+        let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+        if (!isIP) {
+          host = normalizePercentEncoding(host.toLowerCase());
         }
+        parsed.host = reescapeHostDelimiters(host, isIP);
       }
       if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-        if (uri.indexOf("%") !== -1) {
-          if (parsed.scheme !== undefined) {
-            parsed.scheme = unescape(parsed.scheme);
-          }
-          if (parsed.host !== undefined) {
-            parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
-          }
-        }
         if (parsed.path) {
           parsed.path = normalizePathEncoding(parsed.path);
         }
@@ -40868,11 +41856,14 @@ var require_fast_uri = __commonJS((exports, module) => {
       }
       if (schemeHandler && schemeHandler.parse) {
         schemeHandler.parse(parsed, options);
+        if (schemeHandler === SCHEMES.urn && parsed.nid === undefined) {
+          malformedSchemeSpecific = true;
+        }
       }
     } else {
       parsed.error = parsed.error || "URI can not be parsed.";
     }
-    return { parsed, malformedAuthorityOrPort };
+    return { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme };
   }
   function parse6(uri, opts) {
     return parseWithStatus(uri, opts).parsed;
@@ -40881,20 +41872,28 @@ var require_fast_uri = __commonJS((exports, module) => {
     return normalizeStringWithStatus(uri, opts).normalized;
   }
   function normalizeStringWithStatus(uri, opts) {
-    const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+    const { parsed, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = parseWithStatus(uri, opts);
     return {
-      normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
-      malformedAuthorityOrPort
+      normalized: malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? uri : serialize(parsed, opts),
+      malformedAuthorityOrPort,
+      malformedPercentEncoding,
+      malformedSchemeSpecific,
+      malformedHost,
+      malformedScheme
     };
   }
   function normalizeComparableURI(uri, opts) {
-    if (typeof uri === "string") {
-      const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
-      return malformedAuthorityOrPort ? undefined : normalized;
+    if (typeof uri !== "string" && typeof uri !== "object") {
+      return;
     }
-    if (typeof uri === "object") {
-      return serialize(uri, opts);
+    let value;
+    try {
+      value = typeof uri === "string" ? uri : serialize(uri, opts);
+    } catch {
+      return;
     }
+    const { normalized, malformedAuthorityOrPort, malformedPercentEncoding, malformedSchemeSpecific, malformedHost, malformedScheme } = normalizeStringWithStatus(value, opts);
+    return malformedAuthorityOrPort || malformedPercentEncoding || malformedSchemeSpecific || malformedHost || malformedScheme ? undefined : normalized;
   }
   var fastUri = {
     SCHEMES,
@@ -49109,7 +50108,7 @@ var require_limit = __commonJS((exports) => {
 });
 
 // node_modules/ajv-formats/dist/index.js
-var require_dist2 = __commonJS((exports, module) => {
+var require_dist4 = __commonJS((exports, module) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   var formats_1 = require_formats2();
   var limit_1 = require_limit();
@@ -49187,7 +50186,7 @@ class AjvJsonSchemaValidator {
 var import_ajv, import_ajv_formats;
 var init_ajv_provider = __esm(() => {
   import_ajv = __toESM(require_ajv(), 1);
-  import_ajv_formats = __toESM(require_dist2(), 1);
+  import_ajv_formats = __toESM(require_dist4(), 1);
 });
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
@@ -51732,6 +52731,29 @@ function createRegisterResourceTemplate(logger, server, getSDK, allowedScopes) {
 }
 var init_resources = () => {};
 
+// src/mcp-server/server-info.ts
+var ICON_BASE = "https://cloudinary-res.cloudinary.com/image/upload/docsite/brand-assets", serverInfo, instructions = `Cloudinary Environment Config: manage the settings that shape how assets are uploaded, transformed and delivered in a Cloudinary product environment.
+
+- Upload presets bundle upload options (folder, tags, eager and incoming transformations, notification_url) under a name that uploads and the Upload Widget refer to. Check list-upload-presets first: creating a preset with an existing name overwrites it.
+- Named transformations are reusable transformation strings applied in delivery URLs as t_<name>. Changing one requires unsafe_update and affects only newly generated derived assets. Chain f_auto outside it, e.g. t_square/f_auto.
+- Upload mappings link a folder to a remote URL prefix for auto-upload. To apply a preset to a mapping, give the preset the same name as the mapped folder.
+- Triggers send webhook notifications for one event type to one URL. update-trigger, delete-trigger and test-trigger need the id from list-triggers or create-trigger. A preset's notification_url overrides global triggers for uploads that use it.
+- Streaming profiles define adaptive bitrate renditions. Updating one replaces its whole representations list; deleting a modified built-in profile reverts it.
+- Works with the Asset Management server: its upload-asset takes upload_preset.
+- Docs: https://cloudinary.com/documentation/llms.txt indexes all Cloudinary docs; append .md to a documentation URL for Markdown.`;
+var init_server_info = __esm(() => {
+  serverInfo = {
+    title: "Cloudinary Environment Config",
+    description: "Manage Cloudinary upload presets, named transformations, upload mappings, triggers, and streaming profiles.",
+    websiteUrl: "https://cloudinary.com/documentation/cloudinary_llm_mcp",
+    icons: [32, 96, 192].map((size) => ({
+      src: `${ICON_BASE}/cloudinary_favicon_${size}x${size}.png`,
+      mimeType: "image/png",
+      sizes: [`${size}x${size}`]
+    }))
+  };
+});
+
 // src/mcp-server/tools.ts
 function buildAnnotationFilter(annotations) {
   const filter = {};
@@ -56461,8 +57483,9 @@ var init_uploadPresetsUpdateUploadPreset2 = __esm(() => {
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "CloudinaryEnvConfig",
-    version: "0.6.1"
-  });
+    version: "0.6.2",
+    ...serverInfo
+  }, { instructions });
   const getClient = deps.getSDK || (() => new CloudinaryEnvConfigCore({
     security: deps.security,
     cloud_name: deps.cloud_name,
@@ -56516,6 +57539,7 @@ var init_server2 = __esm(() => {
   init_mcp();
   init_core3();
   init_resources();
+  init_server_info();
   init_tools();
   init_streamingProfilesCreateStreamingProfile2();
   init_streamingProfilesDeleteStreamingProfile2();
@@ -57597,7 +58621,7 @@ http_headers = { "api-key" = "YOUR_API_KEY", "api-secret" = "YOUR_API_SECRET", "
         <h1>Instructions</h1>
         <p>One-click installation for Claude Desktop users</p>
         <div class="instruction-item">
-          <a href="https://github.com/cloudinary/environment-config-mcp/releases/download/v0.6.1/mcp-server.mcpb" download="mcp-server.mcpb" class="action-button header-action" style="display: inline-flex; margin-bottom: 16px;">
+          <a href="https://github.com/cloudinary/environment-config-mcp/releases/download/v0.6.2/mcp-server.mcpb" download="mcp-server.mcpb" class="action-button header-action" style="display: inline-flex; margin-bottom: 16px;">
             \uD83D\uDCE5 Download MCP Bundle
           </a>
         </div>
@@ -59522,7 +60546,7 @@ var routes = ln({
 var app = _e(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.6.1"
+    currentVersion: "0.6.2"
   }
 });
 Yt(app, process4.argv.slice(2), buildContext(process4));
@@ -59530,5 +60554,5 @@ export {
   app
 };
 
-//# debugId=DC7D6D5E210736C564756E2164756E21
+//# debugId=0E4893BC713B871164756E2164756E21
 //# sourceMappingURL=mcp-server.js.map