@kubb/core 0.37.19 → 0.37.21

package/dist/index.global.js

@@ -7,17 +7,10 @@ var kubb = (function (exports) {
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-  }) : x)(function(x) {
-    if (typeof require !== "undefined")
-      return require.apply(this, arguments);
-    throw new Error('Dynamic require of "' + x + '" is not supported');
-  });
   var __esm = (fn, res) => function __init() {
     return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
   };
-  var __commonJS = (cb, mod) => function __require2() {
+  var __commonJS = (cb, mod) => function __require() {
     return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
   };
   var __copyProps = (to, from, except, desc) => {
@@ -5289,10 +5282,10 @@ var kubb = (function (exports) {
     "../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/shim.js"(exports, module) {
       init_define_process();
       var getPolyfill = require_polyfill();
-      var define = require_define_properties();
+      var define2 = require_define_properties();
       module.exports = function shimObjectIs() {
         var polyfill = getPolyfill();
-        define(Object, { is: polyfill }, {
+        define2(Object, { is: polyfill }, {
           is: function testObjectIs() {
             return Object.is !== polyfill;
           }
@@ -5306,13 +5299,13 @@ var kubb = (function (exports) {
   var require_object_is = __commonJS({
     "../../node_modules/.pnpm/object-is@1.1.5/node_modules/object-is/index.js"(exports, module) {
       init_define_process();
-      var define = require_define_properties();
+      var define2 = require_define_properties();
       var callBind = require_call_bind();
       var implementation = require_implementation3();
       var getPolyfill = require_polyfill();
       var shim = require_shim();
       var polyfill = callBind(getPolyfill(), Object);
-      define(polyfill, {
+      define2(polyfill, {
         getPolyfill,
         implementation,
         shim
@@ -5349,11 +5342,11 @@ var kubb = (function (exports) {
   var require_shim2 = __commonJS({
     "../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/shim.js"(exports, module) {
       init_define_process();
-      var define = require_define_properties();
+      var define2 = require_define_properties();
       var getPolyfill = require_polyfill2();
       module.exports = function shimNumberIsNaN() {
         var polyfill = getPolyfill();
-        define(Number, { isNaN: polyfill }, {
+        define2(Number, { isNaN: polyfill }, {
           isNaN: function testIsNaN() {
             return Number.isNaN !== polyfill;
           }
@@ -5368,12 +5361,12 @@ var kubb = (function (exports) {
     "../../node_modules/.pnpm/is-nan@1.3.2/node_modules/is-nan/index.js"(exports, module) {
       init_define_process();
       var callBind = require_call_bind();
-      var define = require_define_properties();
+      var define2 = require_define_properties();
       var implementation = require_implementation4();
       var getPolyfill = require_polyfill2();
       var shim = require_shim2();
       var polyfill = callBind(getPolyfill(), Number);
-      define(polyfill, {
+      define2(polyfill, {
         getPolyfill,
         implementation,
         shim
@@ -10542,6 +10535,853 @@ var kubb = (function (exports) {
     }
   });
 
+  // ../../node_modules/.pnpm/punycode@1.3.2/node_modules/punycode/punycode.js
+  var require_punycode = __commonJS({
+    "../../node_modules/.pnpm/punycode@1.3.2/node_modules/punycode/punycode.js"(exports, module) {
+      init_define_process();
+      (function(root) {
+        var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+        var freeModule = typeof module == "object" && module && !module.nodeType && module;
+        var freeGlobal = typeof globalThis == "object" && globalThis;
+        if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
+          root = freeGlobal;
+        }
+        var punycode, maxInt = 2147483647, base = 36, tMin = 1, tMax = 26, skew = 38, damp = 700, initialBias = 72, initialN = 128, delimiter = "-", regexPunycode = /^xn--/, regexNonASCII = /[^\x20-\x7E]/, regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g, errors = {
+          "overflow": "Overflow: input needs wider integers to process",
+          "not-basic": "Illegal input >= 0x80 (not a basic code point)",
+          "invalid-input": "Invalid input"
+        }, baseMinusTMin = base - tMin, floor = Math.floor, stringFromCharCode = String.fromCharCode, key;
+        function error(type) {
+          throw RangeError(errors[type]);
+        }
+        function map(array, fn) {
+          var length = array.length;
+          var result = [];
+          while (length--) {
+            result[length] = fn(array[length]);
+          }
+          return result;
+        }
+        function mapDomain(string, fn) {
+          var parts = string.split("@");
+          var result = "";
+          if (parts.length > 1) {
+            result = parts[0] + "@";
+            string = parts[1];
+          }
+          string = string.replace(regexSeparators, ".");
+          var labels = string.split(".");
+          var encoded = map(labels, fn).join(".");
+          return result + encoded;
+        }
+        function ucs2decode(string) {
+          var output = [], counter = 0, length = string.length, value, extra;
+          while (counter < length) {
+            value = string.charCodeAt(counter++);
+            if (value >= 55296 && value <= 56319 && counter < length) {
+              extra = string.charCodeAt(counter++);
+              if ((extra & 64512) == 56320) {
+                output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
+              } else {
+                output.push(value);
+                counter--;
+              }
+            } else {
+              output.push(value);
+            }
+          }
+          return output;
+        }
+        function ucs2encode(array) {
+          return map(array, function(value) {
+            var output = "";
+            if (value > 65535) {
+              value -= 65536;
+              output += stringFromCharCode(value >>> 10 & 1023 | 55296);
+              value = 56320 | value & 1023;
+            }
+            output += stringFromCharCode(value);
+            return output;
+          }).join("");
+        }
+        function basicToDigit(codePoint) {
+          if (codePoint - 48 < 10) {
+            return codePoint - 22;
+          }
+          if (codePoint - 65 < 26) {
+            return codePoint - 65;
+          }
+          if (codePoint - 97 < 26) {
+            return codePoint - 97;
+          }
+          return base;
+        }
+        function digitToBasic(digit, flag) {
+          return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+        }
+        function adapt(delta, numPoints, firstTime) {
+          var k = 0;
+          delta = firstTime ? floor(delta / damp) : delta >> 1;
+          delta += floor(delta / numPoints);
+          for (; delta > baseMinusTMin * tMax >> 1; k += base) {
+            delta = floor(delta / baseMinusTMin);
+          }
+          return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+        }
+        function decode(input) {
+          var output = [], inputLength = input.length, out, i = 0, n = initialN, bias = initialBias, basic, j, index, oldi, w, k, digit, t, baseMinusT;
+          basic = input.lastIndexOf(delimiter);
+          if (basic < 0) {
+            basic = 0;
+          }
+          for (j = 0; j < basic; ++j) {
+            if (input.charCodeAt(j) >= 128) {
+              error("not-basic");
+            }
+            output.push(input.charCodeAt(j));
+          }
+          for (index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
+            for (oldi = i, w = 1, k = base; ; k += base) {
+              if (index >= inputLength) {
+                error("invalid-input");
+              }
+              digit = basicToDigit(input.charCodeAt(index++));
+              if (digit >= base || digit > floor((maxInt - i) / w)) {
+                error("overflow");
+              }
+              i += digit * w;
+              t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+              if (digit < t) {
+                break;
+              }
+              baseMinusT = base - t;
+              if (w > floor(maxInt / baseMinusT)) {
+                error("overflow");
+              }
+              w *= baseMinusT;
+            }
+            out = output.length + 1;
+            bias = adapt(i - oldi, out, oldi == 0);
+            if (floor(i / out) > maxInt - n) {
+              error("overflow");
+            }
+            n += floor(i / out);
+            i %= out;
+            output.splice(i++, 0, n);
+          }
+          return ucs2encode(output);
+        }
+        function encode(input) {
+          var n, delta, handledCPCount, basicLength, bias, j, m, q, k, t, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;
+          input = ucs2decode(input);
+          inputLength = input.length;
+          n = initialN;
+          delta = 0;
+          bias = initialBias;
+          for (j = 0; j < inputLength; ++j) {
+            currentValue = input[j];
+            if (currentValue < 128) {
+              output.push(stringFromCharCode(currentValue));
+            }
+          }
+          handledCPCount = basicLength = output.length;
+          if (basicLength) {
+            output.push(delimiter);
+          }
+          while (handledCPCount < inputLength) {
+            for (m = maxInt, j = 0; j < inputLength; ++j) {
+              currentValue = input[j];
+              if (currentValue >= n && currentValue < m) {
+                m = currentValue;
+              }
+            }
+            handledCPCountPlusOne = handledCPCount + 1;
+            if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+              error("overflow");
+            }
+            delta += (m - n) * handledCPCountPlusOne;
+            n = m;
+            for (j = 0; j < inputLength; ++j) {
+              currentValue = input[j];
+              if (currentValue < n && ++delta > maxInt) {
+                error("overflow");
+              }
+              if (currentValue == n) {
+                for (q = delta, k = base; ; k += base) {
+                  t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+                  if (q < t) {
+                    break;
+                  }
+                  qMinusT = q - t;
+                  baseMinusT = base - t;
+                  output.push(
+                    stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+                  );
+                  q = floor(qMinusT / baseMinusT);
+                }
+                output.push(stringFromCharCode(digitToBasic(q, 0)));
+                bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+                delta = 0;
+                ++handledCPCount;
+              }
+            }
+            ++delta;
+            ++n;
+          }
+          return output.join("");
+        }
+        function toUnicode(input) {
+          return mapDomain(input, function(string) {
+            return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
+          });
+        }
+        function toASCII(input) {
+          return mapDomain(input, function(string) {
+            return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
+          });
+        }
+        punycode = {
+          "version": "1.3.2",
+          "ucs2": {
+            "decode": ucs2decode,
+            "encode": ucs2encode
+          },
+          "decode": decode,
+          "encode": encode,
+          "toASCII": toASCII,
+          "toUnicode": toUnicode
+        };
+        if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
+          define("punycode", function() {
+            return punycode;
+          });
+        } else if (freeExports && freeModule) {
+          if (module.exports == freeExports) {
+            freeModule.exports = punycode;
+          } else {
+            for (key in punycode) {
+              punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);
+            }
+          }
+        } else {
+          root.punycode = punycode;
+        }
+      })(exports);
+    }
+  });
+
+  // ../../node_modules/.pnpm/url@0.11.0/node_modules/url/util.js
+  var require_util3 = __commonJS({
+    "../../node_modules/.pnpm/url@0.11.0/node_modules/url/util.js"(exports, module) {
+      init_define_process();
+      module.exports = {
+        isString: function(arg) {
+          return typeof arg === "string";
+        },
+        isObject: function(arg) {
+          return typeof arg === "object" && arg !== null;
+        },
+        isNull: function(arg) {
+          return arg === null;
+        },
+        isNullOrUndefined: function(arg) {
+          return arg == null;
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/.pnpm/querystring@0.2.0/node_modules/querystring/decode.js
+  var require_decode = __commonJS({
+    "../../node_modules/.pnpm/querystring@0.2.0/node_modules/querystring/decode.js"(exports, module) {
+      init_define_process();
+      function hasOwnProperty(obj, prop) {
+        return Object.prototype.hasOwnProperty.call(obj, prop);
+      }
+      module.exports = function(qs, sep, eq, options) {
+        sep = sep || "&";
+        eq = eq || "=";
+        var obj = {};
+        if (typeof qs !== "string" || qs.length === 0) {
+          return obj;
+        }
+        var regexp = /\+/g;
+        qs = qs.split(sep);
+        var maxKeys = 1e3;
+        if (options && typeof options.maxKeys === "number") {
+          maxKeys = options.maxKeys;
+        }
+        var len = qs.length;
+        if (maxKeys > 0 && len > maxKeys) {
+          len = maxKeys;
+        }
+        for (var i = 0; i < len; ++i) {
+          var x = qs[i].replace(regexp, "%20"), idx = x.indexOf(eq), kstr, vstr, k, v;
+          if (idx >= 0) {
+            kstr = x.substr(0, idx);
+            vstr = x.substr(idx + 1);
+          } else {
+            kstr = x;
+            vstr = "";
+          }
+          k = decodeURIComponent(kstr);
+          v = decodeURIComponent(vstr);
+          if (!hasOwnProperty(obj, k)) {
+            obj[k] = v;
+          } else if (Array.isArray(obj[k])) {
+            obj[k].push(v);
+          } else {
+            obj[k] = [obj[k], v];
+          }
+        }
+        return obj;
+      };
+    }
+  });
+
+  // ../../node_modules/.pnpm/querystring@0.2.0/node_modules/querystring/encode.js
+  var require_encode = __commonJS({
+    "../../node_modules/.pnpm/querystring@0.2.0/node_modules/querystring/encode.js"(exports, module) {
+      init_define_process();
+      var stringifyPrimitive = function(v) {
+        switch (typeof v) {
+          case "string":
+            return v;
+          case "boolean":
+            return v ? "true" : "false";
+          case "number":
+            return isFinite(v) ? v : "";
+          default:
+            return "";
+        }
+      };
+      module.exports = function(obj, sep, eq, name2) {
+        sep = sep || "&";
+        eq = eq || "=";
+        if (obj === null) {
+          obj = void 0;
+        }
+        if (typeof obj === "object") {
+          return Object.keys(obj).map(function(k) {
+            var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;
+            if (Array.isArray(obj[k])) {
+              return obj[k].map(function(v) {
+                return ks + encodeURIComponent(stringifyPrimitive(v));
+              }).join(sep);
+            } else {
+              return ks + encodeURIComponent(stringifyPrimitive(obj[k]));
+            }
+          }).join(sep);
+        }
+        if (!name2)
+          return "";
+        return encodeURIComponent(stringifyPrimitive(name2)) + eq + encodeURIComponent(stringifyPrimitive(obj));
+      };
+    }
+  });
+
+  // ../../node_modules/.pnpm/querystring@0.2.0/node_modules/querystring/index.js
+  var require_querystring = __commonJS({
+    "../../node_modules/.pnpm/querystring@0.2.0/node_modules/querystring/index.js"(exports) {
+      init_define_process();
+      exports.decode = exports.parse = require_decode();
+      exports.encode = exports.stringify = require_encode();
+    }
+  });
+
+  // ../../node_modules/.pnpm/url@0.11.0/node_modules/url/url.js
+  var require_url = __commonJS({
+    "../../node_modules/.pnpm/url@0.11.0/node_modules/url/url.js"(exports) {
+      init_define_process();
+      var punycode = require_punycode();
+      var util = require_util3();
+      exports.parse = urlParse;
+      exports.resolve = urlResolve;
+      exports.resolveObject = urlResolveObject;
+      exports.format = urlFormat;
+      exports.Url = Url;
+      function Url() {
+        this.protocol = null;
+        this.slashes = null;
+        this.auth = null;
+        this.host = null;
+        this.port = null;
+        this.hostname = null;
+        this.hash = null;
+        this.search = null;
+        this.query = null;
+        this.pathname = null;
+        this.path = null;
+        this.href = null;
+      }
+      var protocolPattern = /^([a-z0-9.+-]+:)/i;
+      var portPattern = /:[0-9]*$/;
+      var simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/;
+      var delims = ["<", ">", '"', "`", " ", "\r", "\n", "	"];
+      var unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims);
+      var autoEscape = ["'"].concat(unwise);
+      var nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape);
+      var hostEndingChars = ["/", "?", "#"];
+      var hostnameMaxLen = 255;
+      var hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/;
+      var hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/;
+      var unsafeProtocol = {
+        "javascript": true,
+        "javascript:": true
+      };
+      var hostlessProtocol = {
+        "javascript": true,
+        "javascript:": true
+      };
+      var slashedProtocol = {
+        "http": true,
+        "https": true,
+        "ftp": true,
+        "gopher": true,
+        "file": true,
+        "http:": true,
+        "https:": true,
+        "ftp:": true,
+        "gopher:": true,
+        "file:": true
+      };
+      var querystring = require_querystring();
+      function urlParse(url, parseQueryString, slashesDenoteHost) {
+        if (url && util.isObject(url) && url instanceof Url)
+          return url;
+        var u = new Url();
+        u.parse(url, parseQueryString, slashesDenoteHost);
+        return u;
+      }
+      Url.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {
+        if (!util.isString(url)) {
+          throw new TypeError("Parameter 'url' must be a string, not " + typeof url);
+        }
+        var queryIndex = url.indexOf("?"), splitter = queryIndex !== -1 && queryIndex < url.indexOf("#") ? "?" : "#", uSplit = url.split(splitter), slashRegex = /\\/g;
+        uSplit[0] = uSplit[0].replace(slashRegex, "/");
+        url = uSplit.join(splitter);
+        var rest = url;
+        rest = rest.trim();
+        if (!slashesDenoteHost && url.split("#").length === 1) {
+          var simplePath = simplePathPattern.exec(rest);
+          if (simplePath) {
+            this.path = rest;
+            this.href = rest;
+            this.pathname = simplePath[1];
+            if (simplePath[2]) {
+              this.search = simplePath[2];
+              if (parseQueryString) {
+                this.query = querystring.parse(this.search.substr(1));
+              } else {
+                this.query = this.search.substr(1);
+              }
+            } else if (parseQueryString) {
+              this.search = "";
+              this.query = {};
+            }
+            return this;
+          }
+        }
+        var proto = protocolPattern.exec(rest);
+        if (proto) {
+          proto = proto[0];
+          var lowerProto = proto.toLowerCase();
+          this.protocol = lowerProto;
+          rest = rest.substr(proto.length);
+        }
+        if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
+          var slashes = rest.substr(0, 2) === "//";
+          if (slashes && !(proto && hostlessProtocol[proto])) {
+            rest = rest.substr(2);
+            this.slashes = true;
+          }
+        }
+        if (!hostlessProtocol[proto] && (slashes || proto && !slashedProtocol[proto])) {
+          var hostEnd = -1;
+          for (var i = 0; i < hostEndingChars.length; i++) {
+            var hec = rest.indexOf(hostEndingChars[i]);
+            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+              hostEnd = hec;
+          }
+          var auth, atSign;
+          if (hostEnd === -1) {
+            atSign = rest.lastIndexOf("@");
+          } else {
+            atSign = rest.lastIndexOf("@", hostEnd);
+          }
+          if (atSign !== -1) {
+            auth = rest.slice(0, atSign);
+            rest = rest.slice(atSign + 1);
+            this.auth = decodeURIComponent(auth);
+          }
+          hostEnd = -1;
+          for (var i = 0; i < nonHostChars.length; i++) {
+            var hec = rest.indexOf(nonHostChars[i]);
+            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))
+              hostEnd = hec;
+          }
+          if (hostEnd === -1)
+            hostEnd = rest.length;
+          this.host = rest.slice(0, hostEnd);
+          rest = rest.slice(hostEnd);
+          this.parseHost();
+          this.hostname = this.hostname || "";
+          var ipv6Hostname = this.hostname[0] === "[" && this.hostname[this.hostname.length - 1] === "]";
+          if (!ipv6Hostname) {
+            var hostparts = this.hostname.split(/\./);
+            for (var i = 0, l = hostparts.length; i < l; i++) {
+              var part = hostparts[i];
+              if (!part)
+                continue;
+              if (!part.match(hostnamePartPattern)) {
+                var newpart = "";
+                for (var j = 0, k = part.length; j < k; j++) {
+                  if (part.charCodeAt(j) > 127) {
+                    newpart += "x";
+                  } else {
+                    newpart += part[j];
+                  }
+                }
+                if (!newpart.match(hostnamePartPattern)) {
+                  var validParts = hostparts.slice(0, i);
+                  var notHost = hostparts.slice(i + 1);
+                  var bit = part.match(hostnamePartStart);
+                  if (bit) {
+                    validParts.push(bit[1]);
+                    notHost.unshift(bit[2]);
+                  }
+                  if (notHost.length) {
+                    rest = "/" + notHost.join(".") + rest;
+                  }
+                  this.hostname = validParts.join(".");
+                  break;
+                }
+              }
+            }
+          }
+          if (this.hostname.length > hostnameMaxLen) {
+            this.hostname = "";
+          } else {
+            this.hostname = this.hostname.toLowerCase();
+          }
+          if (!ipv6Hostname) {
+            this.hostname = punycode.toASCII(this.hostname);
+          }
+          var p = this.port ? ":" + this.port : "";
+          var h = this.hostname || "";
+          this.host = h + p;
+          this.href += this.host;
+          if (ipv6Hostname) {
+            this.hostname = this.hostname.substr(1, this.hostname.length - 2);
+            if (rest[0] !== "/") {
+              rest = "/" + rest;
+            }
+          }
+        }
+        if (!unsafeProtocol[lowerProto]) {
+          for (var i = 0, l = autoEscape.length; i < l; i++) {
+            var ae = autoEscape[i];
+            if (rest.indexOf(ae) === -1)
+              continue;
+            var esc = encodeURIComponent(ae);
+            if (esc === ae) {
+              esc = escape(ae);
+            }
+            rest = rest.split(ae).join(esc);
+          }
+        }
+        var hash = rest.indexOf("#");
+        if (hash !== -1) {
+          this.hash = rest.substr(hash);
+          rest = rest.slice(0, hash);
+        }
+        var qm = rest.indexOf("?");
+        if (qm !== -1) {
+          this.search = rest.substr(qm);
+          this.query = rest.substr(qm + 1);
+          if (parseQueryString) {
+            this.query = querystring.parse(this.query);
+          }
+          rest = rest.slice(0, qm);
+        } else if (parseQueryString) {
+          this.search = "";
+          this.query = {};
+        }
+        if (rest)
+          this.pathname = rest;
+        if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
+          this.pathname = "/";
+        }
+        if (this.pathname || this.search) {
+          var p = this.pathname || "";
+          var s = this.search || "";
+          this.path = p + s;
+        }
+        this.href = this.format();
+        return this;
+      };
+      function urlFormat(obj) {
+        if (util.isString(obj))
+          obj = urlParse(obj);
+        if (!(obj instanceof Url))
+          return Url.prototype.format.call(obj);
+        return obj.format();
+      }
+      Url.prototype.format = function() {
+        var auth = this.auth || "";
+        if (auth) {
+          auth = encodeURIComponent(auth);
+          auth = auth.replace(/%3A/i, ":");
+          auth += "@";
+        }
+        var protocol = this.protocol || "", pathname = this.pathname || "", hash = this.hash || "", host = false, query = "";
+        if (this.host) {
+          host = auth + this.host;
+        } else if (this.hostname) {
+          host = auth + (this.hostname.indexOf(":") === -1 ? this.hostname : "[" + this.hostname + "]");
+          if (this.port) {
+            host += ":" + this.port;
+          }
+        }
+        if (this.query && util.isObject(this.query) && Object.keys(this.query).length) {
+          query = querystring.stringify(this.query);
+        }
+        var search = this.search || query && "?" + query || "";
+        if (protocol && protocol.substr(-1) !== ":")
+          protocol += ":";
+        if (this.slashes || (!protocol || slashedProtocol[protocol]) && host !== false) {
+          host = "//" + (host || "");
+          if (pathname && pathname.charAt(0) !== "/")
+            pathname = "/" + pathname;
+        } else if (!host) {
+          host = "";
+        }
+        if (hash && hash.charAt(0) !== "#")
+          hash = "#" + hash;
+        if (search && search.charAt(0) !== "?")
+          search = "?" + search;
+        pathname = pathname.replace(/[?#]/g, function(match) {
+          return encodeURIComponent(match);
+        });
+        search = search.replace("#", "%23");
+        return protocol + host + pathname + search + hash;
+      };
+      function urlResolve(source, relative) {
+        return urlParse(source, false, true).resolve(relative);
+      }
+      Url.prototype.resolve = function(relative) {
+        return this.resolveObject(urlParse(relative, false, true)).format();
+      };
+      function urlResolveObject(source, relative) {
+        if (!source)
+          return relative;
+        return urlParse(source, false, true).resolveObject(relative);
+      }
+      Url.prototype.resolveObject = function(relative) {
+        if (util.isString(relative)) {
+          var rel = new Url();
+          rel.parse(relative, false, true);
+          relative = rel;
+        }
+        var result = new Url();
+        var tkeys = Object.keys(this);
+        for (var tk = 0; tk < tkeys.length; tk++) {
+          var tkey = tkeys[tk];
+          result[tkey] = this[tkey];
+        }
+        result.hash = relative.hash;
+        if (relative.href === "") {
+          result.href = result.format();
+          return result;
+        }
+        if (relative.slashes && !relative.protocol) {
+          var rkeys = Object.keys(relative);
+          for (var rk = 0; rk < rkeys.length; rk++) {
+            var rkey = rkeys[rk];
+            if (rkey !== "protocol")
+              result[rkey] = relative[rkey];
+          }
+          if (slashedProtocol[result.protocol] && result.hostname && !result.pathname) {
+            result.path = result.pathname = "/";
+          }
+          result.href = result.format();
+          return result;
+        }
+        if (relative.protocol && relative.protocol !== result.protocol) {
+          if (!slashedProtocol[relative.protocol]) {
+            var keys2 = Object.keys(relative);
+            for (var v = 0; v < keys2.length; v++) {
+              var k = keys2[v];
+              result[k] = relative[k];
+            }
+            result.href = result.format();
+            return result;
+          }
+          result.protocol = relative.protocol;
+          if (!relative.host && !hostlessProtocol[relative.protocol]) {
+            var relPath = (relative.pathname || "").split("/");
+            while (relPath.length && !(relative.host = relPath.shift()))
+              ;
+            if (!relative.host)
+              relative.host = "";
+            if (!relative.hostname)
+              relative.hostname = "";
+            if (relPath[0] !== "")
+              relPath.unshift("");
+            if (relPath.length < 2)
+              relPath.unshift("");
+            result.pathname = relPath.join("/");
+          } else {
+            result.pathname = relative.pathname;
+          }
+          result.search = relative.search;
+          result.query = relative.query;
+          result.host = relative.host || "";
+          result.auth = relative.auth;
+          result.hostname = relative.hostname || relative.host;
+          result.port = relative.port;
+          if (result.pathname || result.search) {
+            var p = result.pathname || "";
+            var s = result.search || "";
+            result.path = p + s;
+          }
+          result.slashes = result.slashes || relative.slashes;
+          result.href = result.format();
+          return result;
+        }
+        var isSourceAbs = result.pathname && result.pathname.charAt(0) === "/", isRelAbs = relative.host || relative.pathname && relative.pathname.charAt(0) === "/", mustEndAbs = isRelAbs || isSourceAbs || result.host && relative.pathname, removeAllDots = mustEndAbs, srcPath = result.pathname && result.pathname.split("/") || [], relPath = relative.pathname && relative.pathname.split("/") || [], psychotic = result.protocol && !slashedProtocol[result.protocol];
+        if (psychotic) {
+          result.hostname = "";
+          result.port = null;
+          if (result.host) {
+            if (srcPath[0] === "")
+              srcPath[0] = result.host;
+            else
+              srcPath.unshift(result.host);
+          }
+          result.host = "";
+          if (relative.protocol) {
+            relative.hostname = null;
+            relative.port = null;
+            if (relative.host) {
+              if (relPath[0] === "")
+                relPath[0] = relative.host;
+              else
+                relPath.unshift(relative.host);
+            }
+            relative.host = null;
+          }
+          mustEndAbs = mustEndAbs && (relPath[0] === "" || srcPath[0] === "");
+        }
+        if (isRelAbs) {
+          result.host = relative.host || relative.host === "" ? relative.host : result.host;
+          result.hostname = relative.hostname || relative.hostname === "" ? relative.hostname : result.hostname;
+          result.search = relative.search;
+          result.query = relative.query;
+          srcPath = relPath;
+        } else if (relPath.length) {
+          if (!srcPath)
+            srcPath = [];
+          srcPath.pop();
+          srcPath = srcPath.concat(relPath);
+          result.search = relative.search;
+          result.query = relative.query;
+        } else if (!util.isNullOrUndefined(relative.search)) {
+          if (psychotic) {
+            result.hostname = result.host = srcPath.shift();
+            var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
+            if (authInHost) {
+              result.auth = authInHost.shift();
+              result.host = result.hostname = authInHost.shift();
+            }
+          }
+          result.search = relative.search;
+          result.query = relative.query;
+          if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+            result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
+          }
+          result.href = result.format();
+          return result;
+        }
+        if (!srcPath.length) {
+          result.pathname = null;
+          if (result.search) {
+            result.path = "/" + result.search;
+          } else {
+            result.path = null;
+          }
+          result.href = result.format();
+          return result;
+        }
+        var last = srcPath.slice(-1)[0];
+        var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last === "." || last === "..") || last === "";
+        var up = 0;
+        for (var i = srcPath.length; i >= 0; i--) {
+          last = srcPath[i];
+          if (last === ".") {
+            srcPath.splice(i, 1);
+          } else if (last === "..") {
+            srcPath.splice(i, 1);
+            up++;
+          } else if (up) {
+            srcPath.splice(i, 1);
+            up--;
+          }
+        }
+        if (!mustEndAbs && !removeAllDots) {
+          for (; up--; up) {
+            srcPath.unshift("..");
+          }
+        }
+        if (mustEndAbs && srcPath[0] !== "" && (!srcPath[0] || srcPath[0].charAt(0) !== "/")) {
+          srcPath.unshift("");
+        }
+        if (hasTrailingSlash && srcPath.join("/").substr(-1) !== "/") {
+          srcPath.push("");
+        }
+        var isAbsolute = srcPath[0] === "" || srcPath[0] && srcPath[0].charAt(0) === "/";
+        if (psychotic) {
+          result.hostname = result.host = isAbsolute ? "" : srcPath.length ? srcPath.shift() : "";
+          var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
+          if (authInHost) {
+            result.auth = authInHost.shift();
+            result.host = result.hostname = authInHost.shift();
+          }
+        }
+        mustEndAbs = mustEndAbs || result.host && srcPath.length;
+        if (mustEndAbs && !isAbsolute) {
+          srcPath.unshift("");
+        }
+        if (!srcPath.length) {
+          result.pathname = null;
+          result.path = null;
+        } else {
+          result.pathname = srcPath.join("/");
+        }
+        if (!util.isNull(result.pathname) || !util.isNull(result.search)) {
+          result.path = (result.pathname ? result.pathname : "") + (result.search ? result.search : "");
+        }
+        result.auth = relative.auth || result.auth;
+        result.slashes = result.slashes || relative.slashes;
+        result.href = result.format();
+        return result;
+      };
+      Url.prototype.parseHost = function() {
+        var host = this.host;
+        var port = portPattern.exec(host);
+        if (port) {
+          port = port[0];
+          if (port !== ":") {
+            this.port = port.substr(1);
+          }
+          host = host.substr(0, host.length - port.length);
+        }
+        if (host)
+          this.hostname = host;
+      };
+    }
+  });
+
   // ../../node_modules/.pnpm/fs-monkey@1.0.3/node_modules/fs-monkey/lib/correctPath.js
   var require_correctPath = __commonJS({
     "../../node_modules/.pnpm/fs-monkey@1.0.3/node_modules/fs-monkey/lib/correctPath.js"(exports) {
@@ -10907,7 +11747,7 @@ var kubb = (function (exports) {
       function pathToFilename(path) {
         if (typeof path !== "string" && !buffer_1.Buffer.isBuffer(path)) {
           try {
-            if (!(path instanceof __require("url").URL))
+            if (!(path instanceof require_url().URL))
               throw new TypeError(ERRSTR.PATH_STR);
           } catch (err) {
             throw new TypeError(ERRSTR.PATH_STR);
@@ -16312,6 +17152,7 @@ ${file.source}`
    * @author   Feross Aboukhadijeh <https://feross.org>
    * @license  MIT
    */
+  /*! https://mths.be/punycode v1.3.2 by @mathias */
   /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
   /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */