@scalar/api-reference 0.1.2 → 0.1.4

package/dist/{index-4b7dc641.js → index-ad012ba6.js}

@@ -107,11 +107,11 @@ var hasProto$1 = function hasProto() {
 };
 var ERROR_MESSAGE = "Function.prototype.bind called on incompatible ";
 var slice = Array.prototype.slice;
-var toStr$3 = Object.prototype.toString;
+var toStr$4 = Object.prototype.toString;
 var funcType = "[object Function]";
 var implementation$1 = function bind(that) {
   var target = this;
-  if (typeof target !== "function" || toStr$3.call(target) !== funcType) {
+  if (typeof target !== "function" || toStr$4.call(target) !== funcType) {
     throw new TypeError(ERROR_MESSAGE + target);
   }
   var args = slice.call(arguments, 1);
@@ -155,7 +155,7 @@ var src = bind$1.call(Function.call, Object.prototype.hasOwnProperty);
 var undefined$1;
 var $SyntaxError = SyntaxError;
 var $Function = Function;
-var $TypeError = TypeError;
+var $TypeError$1 = TypeError;
 var getEvalledConstructor = function(expressionSyntax) {
   try {
     return $Function('"use strict"; return (' + expressionSyntax + ").constructor;")();
@@ -171,7 +171,7 @@ if ($gOPD$1) {
   }
 }
 var throwTypeError = function() {
-  throw new $TypeError();
+  throw new $TypeError$1();
 };
 var ThrowTypeError = $gOPD$1 ? function() {
   try {
@@ -251,7 +251,7 @@ var INTRINSICS = {
   "%SyntaxError%": $SyntaxError,
   "%ThrowTypeError%": ThrowTypeError,
   "%TypedArray%": TypedArray,
-  "%TypeError%": $TypeError,
+  "%TypeError%": $TypeError$1,
   "%Uint8Array%": typeof Uint8Array === "undefined" ? undefined$1 : Uint8Array,
   "%Uint8ClampedArray%": typeof Uint8ClampedArray === "undefined" ? undefined$1 : Uint8ClampedArray,
   "%Uint16Array%": typeof Uint16Array === "undefined" ? undefined$1 : Uint16Array,
@@ -345,10 +345,10 @@ var LEGACY_ALIASES = {
   "%WeakSetPrototype%": ["WeakSet", "prototype"]
 };
 var bind2 = functionBind;
-var hasOwn$1 = src;
-var $concat = bind2.call(Function.call, Array.prototype.concat);
+var hasOwn$2 = src;
+var $concat$1 = bind2.call(Function.call, Array.prototype.concat);
 var $spliceApply = bind2.call(Function.apply, Array.prototype.splice);
-var $replace = bind2.call(Function.call, String.prototype.replace);
+var $replace$1 = bind2.call(Function.call, String.prototype.replace);
 var $strSlice = bind2.call(Function.call, String.prototype.slice);
 var $exec = bind2.call(Function.call, RegExp.prototype.exec);
 var rePropName = /[^%.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|%$))/g;
@@ -362,25 +362,25 @@ var stringToPath = function stringToPath2(string2) {
     throw new $SyntaxError("invalid intrinsic syntax, expected opening `%`");
   }
   var result = [];
-  $replace(string2, rePropName, function(match, number2, quote, subString) {
-    result[result.length] = quote ? $replace(subString, reEscapeChar, "$1") : number2 || match;
+  $replace$1(string2, rePropName, function(match, number2, quote2, subString) {
+    result[result.length] = quote2 ? $replace$1(subString, reEscapeChar, "$1") : number2 || match;
   });
   return result;
 };
 var getBaseIntrinsic = function getBaseIntrinsic2(name2, allowMissing) {
   var intrinsicName = name2;
   var alias;
-  if (hasOwn$1(LEGACY_ALIASES, intrinsicName)) {
+  if (hasOwn$2(LEGACY_ALIASES, intrinsicName)) {
     alias = LEGACY_ALIASES[intrinsicName];
     intrinsicName = "%" + alias[0] + "%";
   }
-  if (hasOwn$1(INTRINSICS, intrinsicName)) {
+  if (hasOwn$2(INTRINSICS, intrinsicName)) {
     var value = INTRINSICS[intrinsicName];
     if (value === needsEval) {
       value = doEval(intrinsicName);
     }
     if (typeof value === "undefined" && !allowMissing) {
-      throw new $TypeError("intrinsic " + name2 + " exists, but is not available. Please file an issue!");
+      throw new $TypeError$1("intrinsic " + name2 + " exists, but is not available. Please file an issue!");
     }
     return {
       alias,
@@ -392,10 +392,10 @@ var getBaseIntrinsic = function getBaseIntrinsic2(name2, allowMissing) {
 };
 var getIntrinsic = function GetIntrinsic(name2, allowMissing) {
   if (typeof name2 !== "string" || name2.length === 0) {
-    throw new $TypeError("intrinsic name must be a non-empty string");
+    throw new $TypeError$1("intrinsic name must be a non-empty string");
   }
   if (arguments.length > 1 && typeof allowMissing !== "boolean") {
-    throw new $TypeError('"allowMissing" argument must be a boolean');
+    throw new $TypeError$1('"allowMissing" argument must be a boolean');
   }
   if ($exec(/^%?[^%]*%?$/, name2) === null) {
     throw new $SyntaxError("`%` may not be present anywhere but at the beginning and end of the intrinsic name");
@@ -409,7 +409,7 @@ var getIntrinsic = function GetIntrinsic(name2, allowMissing) {
   var alias = intrinsic.alias;
   if (alias) {
     intrinsicBaseName = alias[0];
-    $spliceApply(parts, $concat([0, 1], alias));
+    $spliceApply(parts, $concat$1([0, 1], alias));
   }
   for (var i = 1, isOwn = true; i < parts.length; i += 1) {
     var part = parts[i];
@@ -423,12 +423,12 @@ var getIntrinsic = function GetIntrinsic(name2, allowMissing) {
     }
     intrinsicBaseName += "." + part;
     intrinsicRealName = "%" + intrinsicBaseName + "%";
-    if (hasOwn$1(INTRINSICS, intrinsicRealName)) {
+    if (hasOwn$2(INTRINSICS, intrinsicRealName)) {
       value = INTRINSICS[intrinsicRealName];
     } else if (value != null) {
       if (!(part in value)) {
         if (!allowMissing) {
-          throw new $TypeError("base intrinsic for " + name2 + " exists, but the property is not available.");
+          throw new $TypeError$1("base intrinsic for " + name2 + " exists, but the property is not available.");
         }
         return void 0;
       }
@@ -441,7 +441,7 @@ var getIntrinsic = function GetIntrinsic(name2, allowMissing) {
           value = value[part];
         }
       } else {
-        isOwn = hasOwn$1(value, part);
+        isOwn = hasOwn$2(value, part);
         value = value[part];
       }
       if (isOwn && !skipFurtherCaching) {
@@ -492,19 +492,19 @@ var callBind$2 = { exports: {} };
   }
 })(callBind$2);
 var callBindExports = callBind$2.exports;
-var GetIntrinsic$1 = getIntrinsic;
+var GetIntrinsic$2 = getIntrinsic;
 var callBind$1 = callBindExports;
-var $indexOf$1 = callBind$1(GetIntrinsic$1("String.prototype.indexOf"));
-var callBound$2 = function callBoundIntrinsic(name2, allowMissing) {
-  var intrinsic = GetIntrinsic$1(name2, !!allowMissing);
+var $indexOf$1 = callBind$1(GetIntrinsic$2("String.prototype.indexOf"));
+var callBound$3 = function callBoundIntrinsic(name2, allowMissing) {
+  var intrinsic = GetIntrinsic$2(name2, !!allowMissing);
   if (typeof intrinsic === "function" && $indexOf$1(name2, ".prototype.") > -1) {
     return callBind$1(intrinsic);
   }
   return intrinsic;
 };
 var hasToStringTag$3 = shams();
-var callBound$1 = callBound$2;
-var $toString$1 = callBound$1("Object.prototype.toString");
+var callBound$2 = callBound$3;
+var $toString$1 = callBound$2("Object.prototype.toString");
 var isStandardArguments = function isArguments(value) {
   if (hasToStringTag$3 && value && typeof value === "object" && Symbol.toStringTag in value) {
     return false;
@@ -522,7 +522,7 @@ var supportsStandardArguments = function() {
 }();
 isStandardArguments.isLegacyArguments = isLegacyArguments;
 var isArguments3 = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
-var toStr$2 = Object.prototype.toString;
+var toStr$3 = Object.prototype.toString;
 var fnToStr$1 = Function.prototype.toString;
 var isFnRegex = /^\s*(?:function)?\*/;
 var hasToStringTag$2 = shams();
@@ -545,7 +545,7 @@ var isGeneratorFunction = function isGeneratorFunction2(fn) {
     return true;
   }
   if (!hasToStringTag$2) {
-    var str2 = toStr$2.call(fn);
+    var str2 = toStr$3.call(fn);
     return str2 === "[object GeneratorFunction]";
   }
   if (!getProto) {
@@ -600,7 +600,7 @@ var tryFunctionObject = function tryFunctionToStr(value) {
     return false;
   }
 };
-var toStr$1 = Object.prototype.toString;
+var toStr$2 = Object.prototype.toString;
 var objectClass = "[object Object]";
 var fnClass = "[object Function]";
 var genClass = "[object GeneratorFunction]";
@@ -614,11 +614,11 @@ var isDDA = function isDocumentDotAll() {
 };
 if (typeof document === "object") {
   var all = document.all;
-  if (toStr$1.call(all) === toStr$1.call(document.all)) {
+  if (toStr$2.call(all) === toStr$2.call(document.all)) {
     isDDA = function isDocumentDotAll2(value) {
       if ((isIE68 || !value) && (typeof value === "undefined" || typeof value === "object")) {
         try {
-          var str2 = toStr$1.call(value);
+          var str2 = toStr$2.call(value);
           return (str2 === ddaClass || str2 === ddaClass2 || str2 === ddaClass3 || str2 === objectClass) && value("") == null;
         } catch (e2) {
         }
@@ -661,14 +661,14 @@ var isCallable$1 = reflectApply ? function isCallable(value) {
   if (isES6ClassFn(value)) {
     return false;
   }
-  var strClass = toStr$1.call(value);
+  var strClass = toStr$2.call(value);
   if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
     return false;
   }
   return tryFunctionObject(value);
 };
 var isCallable3 = isCallable$1;
-var toStr = Object.prototype.toString;
+var toStr$1 = Object.prototype.toString;
 var hasOwnProperty = Object.prototype.hasOwnProperty;
 var forEachArray = function forEachArray2(array, iterator, receiver) {
   for (var i = 0, len = array.length; i < len; i++) {
@@ -709,7 +709,7 @@ var forEach$3 = function forEach(list, iterator, thisArg) {
   if (arguments.length >= 3) {
     receiver = thisArg;
   }
-  if (toStr.call(list) === "[object Array]") {
+  if (toStr$1.call(list) === "[object Array]") {
     forEachArray(list, iterator, receiver);
   } else if (typeof list === "string") {
     forEachString(list, iterator, receiver);
@@ -741,8 +741,8 @@ var availableTypedArrays$1 = function availableTypedArrays() {
   }
   return out;
 };
-var GetIntrinsic2 = getIntrinsic;
-var $gOPD = GetIntrinsic2("%Object.getOwnPropertyDescriptor%", true);
+var GetIntrinsic$1 = getIntrinsic;
+var $gOPD = GetIntrinsic$1("%Object.getOwnPropertyDescriptor%", true);
 if ($gOPD) {
   try {
     $gOPD([], "length");
@@ -754,15 +754,15 @@ var gopd = $gOPD;
 var forEach$2 = forEach_1;
 var availableTypedArrays2 = availableTypedArrays$1;
 var callBind = callBindExports;
-var callBound = callBound$2;
+var callBound$1 = callBound$3;
 var gOPD = gopd;
-var $toString = callBound("Object.prototype.toString");
+var $toString = callBound$1("Object.prototype.toString");
 var hasToStringTag = shams();
 var g = typeof globalThis === "undefined" ? commonjsGlobal : globalThis;
 var typedArrays = availableTypedArrays2();
-var $slice = callBound("String.prototype.slice");
+var $slice$1 = callBound$1("String.prototype.slice");
 var getPrototypeOf = Object.getPrototypeOf;
-var $indexOf = callBound("Array.prototype.indexOf", true) || function indexOf(array, value) {
+var $indexOf = callBound$1("Array.prototype.indexOf", true) || function indexOf(array, value) {
   for (var i = 0; i < array.length; i += 1) {
     if (array[i] === value) {
       return i;
@@ -796,7 +796,7 @@ var tryTypedArrays = function tryAllTypedArrays(value) {
     if (!found) {
       try {
         if ("$" + getter(value) === typedArray) {
-          found = $slice(typedArray, 1);
+          found = $slice$1(typedArray, 1);
         }
       } catch (e2) {
       }
@@ -810,7 +810,7 @@ var trySlices = function tryAllSlices(value) {
     if (!found) {
       try {
         getter(value);
-        found = $slice(name2, 1);
+        found = $slice$1(name2, 1);
       } catch (e2) {
       }
     }
@@ -822,7 +822,7 @@ var whichTypedArray$1 = function whichTypedArray(value) {
     return false;
   }
   if (!hasToStringTag) {
-    var tag = $slice($toString(value), 8, -1);
+    var tag = $slice$1($toString(value), 8, -1);
     if ($indexOf(typedArrays, tag) > -1) {
       return tag;
     }
@@ -933,43 +933,43 @@ var isTypedArray = function isTypedArray2(value) {
     return ObjectToString(value) === "[object Map]";
   }
   isMapToString.working = typeof Map !== "undefined" && isMapToString(/* @__PURE__ */ new Map());
-  function isMap(value) {
+  function isMap2(value) {
     if (typeof Map === "undefined") {
       return false;
     }
     return isMapToString.working ? isMapToString(value) : value instanceof Map;
   }
-  exports.isMap = isMap;
+  exports.isMap = isMap2;
   function isSetToString(value) {
     return ObjectToString(value) === "[object Set]";
   }
   isSetToString.working = typeof Set !== "undefined" && isSetToString(/* @__PURE__ */ new Set());
-  function isSet(value) {
+  function isSet2(value) {
     if (typeof Set === "undefined") {
       return false;
     }
     return isSetToString.working ? isSetToString(value) : value instanceof Set;
   }
-  exports.isSet = isSet;
+  exports.isSet = isSet2;
   function isWeakMapToString(value) {
     return ObjectToString(value) === "[object WeakMap]";
   }
   isWeakMapToString.working = typeof WeakMap !== "undefined" && isWeakMapToString(/* @__PURE__ */ new WeakMap());
-  function isWeakMap(value) {
+  function isWeakMap2(value) {
     if (typeof WeakMap === "undefined") {
       return false;
     }
     return isWeakMapToString.working ? isWeakMapToString(value) : value instanceof WeakMap;
   }
-  exports.isWeakMap = isWeakMap;
+  exports.isWeakMap = isWeakMap2;
   function isWeakSetToString(value) {
     return ObjectToString(value) === "[object WeakSet]";
   }
   isWeakSetToString.working = typeof WeakSet !== "undefined" && isWeakSetToString(/* @__PURE__ */ new WeakSet());
-  function isWeakSet(value) {
+  function isWeakSet2(value) {
     return isWeakSetToString(value);
   }
-  exports.isWeakSet = isWeakSet;
+  exports.isWeakSet = isWeakSet2;
   function isArrayBufferToString(value) {
     return ObjectToString(value) === "[object ArrayBuffer]";
   }
@@ -1105,10 +1105,10 @@ var inherits_browserExports = inherits_browser.exports;
   };
   var formatRegExp = /%[sdj%]/g;
   exports.format = function(f2) {
-    if (!isString(f2)) {
+    if (!isString2(f2)) {
       var objects = [];
       for (var i = 0; i < arguments.length; i++) {
-        objects.push(inspect(arguments[i]));
+        objects.push(inspect2(arguments[i]));
       }
       return objects.join(" ");
     }
@@ -1139,7 +1139,7 @@ var inherits_browserExports = inherits_browser.exports;
       if (isNull2(x2) || !isObject2(x2)) {
         str2 += " " + x2;
       } else {
-        str2 += " " + inspect(x2);
+        str2 += " " + inspect2(x2);
       }
     }
     return str2;
@@ -1192,7 +1192,7 @@ var inherits_browserExports = inherits_browser.exports;
     }
     return debugs[set2];
   };
-  function inspect(obj, opts) {
+  function inspect2(obj, opts) {
     var ctx = {
       seen: [],
       stylize: stylizeNoColor
@@ -1218,8 +1218,8 @@ var inherits_browserExports = inherits_browser.exports;
       ctx.stylize = stylizeWithColor;
     return formatValue(ctx, obj, ctx.depth);
   }
-  exports.inspect = inspect;
-  inspect.colors = {
+  exports.inspect = inspect2;
+  inspect2.colors = {
     "bold": [1, 22],
     "italic": [3, 23],
     "underline": [4, 24],
@@ -1234,7 +1234,7 @@ var inherits_browserExports = inherits_browser.exports;
     "red": [31, 39],
     "yellow": [33, 39]
   };
-  inspect.styles = {
+  inspect2.styles = {
     "special": "cyan",
     "number": "yellow",
     "boolean": "yellow",
@@ -1246,9 +1246,9 @@ var inherits_browserExports = inherits_browser.exports;
     "regexp": "red"
   };
   function stylizeWithColor(str2, styleType) {
-    var style = inspect.styles[styleType];
+    var style = inspect2.styles[styleType];
     if (style) {
-      return "\x1B[" + inspect.colors[style][0] + "m" + str2 + "\x1B[" + inspect.colors[style][1] + "m";
+      return "\x1B[" + inspect2.colors[style][0] + "m" + str2 + "\x1B[" + inspect2.colors[style][1] + "m";
     } else {
       return str2;
     }
@@ -1268,7 +1268,7 @@ var inherits_browserExports = inherits_browser.exports;
     value.inspect !== exports.inspect && // Also filter out any prototype objects using the circular check.
     !(value.constructor && value.constructor.prototype === value)) {
       var ret = value.inspect(recurseTimes, ctx);
-      if (!isString(ret)) {
+      if (!isString2(ret)) {
         ret = formatValue(ctx, ret, recurseTimes);
       }
       return ret;
@@ -1282,7 +1282,7 @@ var inherits_browserExports = inherits_browser.exports;
     if (ctx.showHidden) {
       keys2 = Object.getOwnPropertyNames(value);
     }
-    if (isError(value) && (keys2.indexOf("message") >= 0 || keys2.indexOf("description") >= 0)) {
+    if (isError2(value) && (keys2.indexOf("message") >= 0 || keys2.indexOf("description") >= 0)) {
       return formatError2(value);
     }
     if (keys2.length === 0) {
@@ -1290,13 +1290,13 @@ var inherits_browserExports = inherits_browser.exports;
         var name2 = value.name ? ": " + value.name : "";
         return ctx.stylize("[Function" + name2 + "]", "special");
       }
-      if (isRegExp2(value)) {
+      if (isRegExp3(value)) {
         return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
       }
-      if (isDate(value)) {
+      if (isDate2(value)) {
         return ctx.stylize(Date.prototype.toString.call(value), "date");
       }
-      if (isError(value)) {
+      if (isError2(value)) {
         return formatError2(value);
       }
     }
@@ -1309,20 +1309,20 @@ var inherits_browserExports = inherits_browser.exports;
       var n2 = value.name ? ": " + value.name : "";
       base2 = " [Function" + n2 + "]";
     }
-    if (isRegExp2(value)) {
+    if (isRegExp3(value)) {
       base2 = " " + RegExp.prototype.toString.call(value);
     }
-    if (isDate(value)) {
+    if (isDate2(value)) {
       base2 = " " + Date.prototype.toUTCString.call(value);
     }
-    if (isError(value)) {
+    if (isError2(value)) {
       base2 = " " + formatError2(value);
     }
     if (keys2.length === 0 && (!array || value.length == 0)) {
       return braces[0] + base2 + braces[1];
     }
     if (recurseTimes < 0) {
-      if (isRegExp2(value)) {
+      if (isRegExp3(value)) {
         return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
       } else {
         return ctx.stylize("[Object]", "special");
@@ -1343,11 +1343,11 @@ var inherits_browserExports = inherits_browser.exports;
   function formatPrimitive(ctx, value) {
     if (isUndefined2(value))
       return ctx.stylize("undefined", "undefined");
-    if (isString(value)) {
+    if (isString2(value)) {
       var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
       return ctx.stylize(simple, "string");
     }
-    if (isNumber(value))
+    if (isNumber2(value))
       return ctx.stylize("" + value, "number");
     if (isBoolean2(value))
       return ctx.stylize("" + value, "boolean");
@@ -1469,41 +1469,41 @@ var inherits_browserExports = inherits_browser.exports;
     return arg == null;
   }
   exports.isNullOrUndefined = isNullOrUndefined;
-  function isNumber(arg) {
+  function isNumber2(arg) {
     return typeof arg === "number";
   }
-  exports.isNumber = isNumber;
-  function isString(arg) {
+  exports.isNumber = isNumber2;
+  function isString2(arg) {
     return typeof arg === "string";
   }
-  exports.isString = isString;
-  function isSymbol(arg) {
+  exports.isString = isString2;
+  function isSymbol2(arg) {
     return typeof arg === "symbol";
   }
-  exports.isSymbol = isSymbol;
+  exports.isSymbol = isSymbol2;
   function isUndefined2(arg) {
     return arg === void 0;
   }
   exports.isUndefined = isUndefined2;
-  function isRegExp2(re) {
-    return isObject2(re) && objectToString(re) === "[object RegExp]";
+  function isRegExp3(re) {
+    return isObject2(re) && objectToString2(re) === "[object RegExp]";
   }
-  exports.isRegExp = isRegExp2;
-  exports.types.isRegExp = isRegExp2;
+  exports.isRegExp = isRegExp3;
+  exports.types.isRegExp = isRegExp3;
   function isObject2(arg) {
     return typeof arg === "object" && arg !== null;
   }
   exports.isObject = isObject2;
-  function isDate(d2) {
-    return isObject2(d2) && objectToString(d2) === "[object Date]";
+  function isDate2(d2) {
+    return isObject2(d2) && objectToString2(d2) === "[object Date]";
   }
-  exports.isDate = isDate;
-  exports.types.isDate = isDate;
-  function isError(e2) {
-    return isObject2(e2) && (objectToString(e2) === "[object Error]" || e2 instanceof Error);
+  exports.isDate = isDate2;
+  exports.types.isDate = isDate2;
+  function isError2(e2) {
+    return isObject2(e2) && (objectToString2(e2) === "[object Error]" || e2 instanceof Error);
   }
-  exports.isError = isError;
-  exports.types.isNativeError = isError;
+  exports.isError = isError2;
+  exports.types.isNativeError = isError2;
   function isFunction2(arg) {
     return typeof arg === "function";
   }
@@ -1514,7 +1514,7 @@ var inherits_browserExports = inherits_browser.exports;
   }
   exports.isPrimitive = isPrimitive;
   exports.isBuffer = isBufferBrowser;
-  function objectToString(o2) {
+  function objectToString2(o2) {
     return Object.prototype.toString.call(o2);
   }
   function pad(n2) {
@@ -1658,15 +1658,2054 @@ var inherits_browserExports = inherits_browser.exports;
   }
   exports.callbackify = callbackify;
 })(util$6);
-var url$9 = { exports: {} };
+var url$a = { exports: {} };
+var url$9 = {};
+var punycode$1 = { exports: {} };
+/*! https://mths.be/punycode v1.4.1 by @mathias */
+punycode$1.exports;
+(function(module2, exports) {
+  (function(root) {
+    var freeExports = exports && !exports.nodeType && exports;
+    var freeModule = module2 && !module2.nodeType && module2;
+    var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal;
+    if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal) {
+      root = freeGlobal;
+    }
+    var punycode2, maxInt = 2147483647, base2 = 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, errors2 = {
+      "overflow": "Overflow: input needs wider integers to process",
+      "not-basic": "Illegal input >= 0x80 (not a basic code point)",
+      "invalid-input": "Invalid input"
+    }, baseMinusTMin = base2 - tMin, floor2 = Math.floor, stringFromCharCode = String.fromCharCode, key;
+    function error2(type2) {
+      throw new RangeError(errors2[type2]);
+    }
+    function map2(array, fn) {
+      var length2 = array.length;
+      var result = [];
+      while (length2--) {
+        result[length2] = fn(array[length2]);
+      }
+      return result;
+    }
+    function mapDomain(string2, fn) {
+      var parts = string2.split("@");
+      var result = "";
+      if (parts.length > 1) {
+        result = parts[0] + "@";
+        string2 = parts[1];
+      }
+      string2 = string2.replace(regexSeparators, ".");
+      var labels = string2.split(".");
+      var encoded = map2(labels, fn).join(".");
+      return result + encoded;
+    }
+    function ucs2decode(string2) {
+      var output = [], counter = 0, length2 = string2.length, value, extra;
+      while (counter < length2) {
+        value = string2.charCodeAt(counter++);
+        if (value >= 55296 && value <= 56319 && counter < length2) {
+          extra = string2.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 map2(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 base2;
+    }
+    function digitToBasic(digit, flag) {
+      return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+    }
+    function adapt(delta, numPoints, firstTime) {
+      var k = 0;
+      delta = firstTime ? floor2(delta / damp) : delta >> 1;
+      delta += floor2(delta / numPoints);
+      for (; delta > baseMinusTMin * tMax >> 1; k += base2) {
+        delta = floor2(delta / baseMinusTMin);
+      }
+      return floor2(k + (baseMinusTMin + 1) * delta / (delta + skew));
+    }
+    function decode2(input) {
+      var output = [], inputLength = input.length, out, i = 0, n2 = initialN, bias = initialBias, basic, j2, index, oldi, w2, k, digit, t2, baseMinusT;
+      basic = input.lastIndexOf(delimiter);
+      if (basic < 0) {
+        basic = 0;
+      }
+      for (j2 = 0; j2 < basic; ++j2) {
+        if (input.charCodeAt(j2) >= 128) {
+          error2("not-basic");
+        }
+        output.push(input.charCodeAt(j2));
+      }
+      for (index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
+        for (oldi = i, w2 = 1, k = base2; ; k += base2) {
+          if (index >= inputLength) {
+            error2("invalid-input");
+          }
+          digit = basicToDigit(input.charCodeAt(index++));
+          if (digit >= base2 || digit > floor2((maxInt - i) / w2)) {
+            error2("overflow");
+          }
+          i += digit * w2;
+          t2 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+          if (digit < t2) {
+            break;
+          }
+          baseMinusT = base2 - t2;
+          if (w2 > floor2(maxInt / baseMinusT)) {
+            error2("overflow");
+          }
+          w2 *= baseMinusT;
+        }
+        out = output.length + 1;
+        bias = adapt(i - oldi, out, oldi == 0);
+        if (floor2(i / out) > maxInt - n2) {
+          error2("overflow");
+        }
+        n2 += floor2(i / out);
+        i %= out;
+        output.splice(i++, 0, n2);
+      }
+      return ucs2encode(output);
+    }
+    function encode3(input) {
+      var n2, delta, handledCPCount, basicLength, bias, j2, m2, q, k, t2, currentValue, output = [], inputLength, handledCPCountPlusOne, baseMinusT, qMinusT;
+      input = ucs2decode(input);
+      inputLength = input.length;
+      n2 = initialN;
+      delta = 0;
+      bias = initialBias;
+      for (j2 = 0; j2 < inputLength; ++j2) {
+        currentValue = input[j2];
+        if (currentValue < 128) {
+          output.push(stringFromCharCode(currentValue));
+        }
+      }
+      handledCPCount = basicLength = output.length;
+      if (basicLength) {
+        output.push(delimiter);
+      }
+      while (handledCPCount < inputLength) {
+        for (m2 = maxInt, j2 = 0; j2 < inputLength; ++j2) {
+          currentValue = input[j2];
+          if (currentValue >= n2 && currentValue < m2) {
+            m2 = currentValue;
+          }
+        }
+        handledCPCountPlusOne = handledCPCount + 1;
+        if (m2 - n2 > floor2((maxInt - delta) / handledCPCountPlusOne)) {
+          error2("overflow");
+        }
+        delta += (m2 - n2) * handledCPCountPlusOne;
+        n2 = m2;
+        for (j2 = 0; j2 < inputLength; ++j2) {
+          currentValue = input[j2];
+          if (currentValue < n2 && ++delta > maxInt) {
+            error2("overflow");
+          }
+          if (currentValue == n2) {
+            for (q = delta, k = base2; ; k += base2) {
+              t2 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+              if (q < t2) {
+                break;
+              }
+              qMinusT = q - t2;
+              baseMinusT = base2 - t2;
+              output.push(
+                stringFromCharCode(digitToBasic(t2 + qMinusT % baseMinusT, 0))
+              );
+              q = floor2(qMinusT / baseMinusT);
+            }
+            output.push(stringFromCharCode(digitToBasic(q, 0)));
+            bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
+            delta = 0;
+            ++handledCPCount;
+          }
+        }
+        ++delta;
+        ++n2;
+      }
+      return output.join("");
+    }
+    function toUnicode(input) {
+      return mapDomain(input, function(string2) {
+        return regexPunycode.test(string2) ? decode2(string2.slice(4).toLowerCase()) : string2;
+      });
+    }
+    function toASCII(input) {
+      return mapDomain(input, function(string2) {
+        return regexNonASCII.test(string2) ? "xn--" + encode3(string2) : string2;
+      });
+    }
+    punycode2 = {
+      /**
+       * A string representing the current Punycode.js version number.
+       * @memberOf punycode
+       * @type String
+       */
+      "version": "1.4.1",
+      /**
+       * An object of methods to convert from JavaScript's internal character
+       * representation (UCS-2) to Unicode code points, and back.
+       * @see <https://mathiasbynens.be/notes/javascript-encoding>
+       * @memberOf punycode
+       * @type Object
+       */
+      "ucs2": {
+        "decode": ucs2decode,
+        "encode": ucs2encode
+      },
+      "decode": decode2,
+      "encode": encode3,
+      "toASCII": toASCII,
+      "toUnicode": toUnicode
+    };
+    if (freeExports && freeModule) {
+      if (module2.exports == freeExports) {
+        freeModule.exports = punycode2;
+      } else {
+        for (key in punycode2) {
+          punycode2.hasOwnProperty(key) && (freeExports[key] = punycode2[key]);
+        }
+      }
+    } else {
+      root.punycode = punycode2;
+    }
+  })(commonjsGlobal);
+})(punycode$1, punycode$1.exports);
+var punycodeExports = punycode$1.exports;
 const __viteBrowserExternal = {};
 const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   default: __viteBrowserExternal
 }, Symbol.toStringTag, { value: "Module" }));
 const require$$1$2 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
+var hasMap = typeof Map === "function" && Map.prototype;
+var mapSizeDescriptor = Object.getOwnPropertyDescriptor && hasMap ? Object.getOwnPropertyDescriptor(Map.prototype, "size") : null;
+var mapSize = hasMap && mapSizeDescriptor && typeof mapSizeDescriptor.get === "function" ? mapSizeDescriptor.get : null;
+var mapForEach = hasMap && Map.prototype.forEach;
+var hasSet = typeof Set === "function" && Set.prototype;
+var setSizeDescriptor = Object.getOwnPropertyDescriptor && hasSet ? Object.getOwnPropertyDescriptor(Set.prototype, "size") : null;
+var setSize = hasSet && setSizeDescriptor && typeof setSizeDescriptor.get === "function" ? setSizeDescriptor.get : null;
+var setForEach = hasSet && Set.prototype.forEach;
+var hasWeakMap = typeof WeakMap === "function" && WeakMap.prototype;
+var weakMapHas = hasWeakMap ? WeakMap.prototype.has : null;
+var hasWeakSet = typeof WeakSet === "function" && WeakSet.prototype;
+var weakSetHas = hasWeakSet ? WeakSet.prototype.has : null;
+var hasWeakRef = typeof WeakRef === "function" && WeakRef.prototype;
+var weakRefDeref = hasWeakRef ? WeakRef.prototype.deref : null;
+var booleanValueOf = Boolean.prototype.valueOf;
+var objectToString = Object.prototype.toString;
+var functionToString = Function.prototype.toString;
+var $match = String.prototype.match;
+var $slice = String.prototype.slice;
+var $replace = String.prototype.replace;
+var $toUpperCase = String.prototype.toUpperCase;
+var $toLowerCase = String.prototype.toLowerCase;
+var $test = RegExp.prototype.test;
+var $concat = Array.prototype.concat;
+var $join = Array.prototype.join;
+var $arrSlice = Array.prototype.slice;
+var $floor = Math.floor;
+var bigIntValueOf = typeof BigInt === "function" ? BigInt.prototype.valueOf : null;
+var gOPS = Object.getOwnPropertySymbols;
+var symToString = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? Symbol.prototype.toString : null;
+var hasShammedSymbols = typeof Symbol === "function" && typeof Symbol.iterator === "object";
+var toStringTag = typeof Symbol === "function" && Symbol.toStringTag && (typeof Symbol.toStringTag === hasShammedSymbols ? "object" : "symbol") ? Symbol.toStringTag : null;
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var gPO = (typeof Reflect === "function" ? Reflect.getPrototypeOf : Object.getPrototypeOf) || ([].__proto__ === Array.prototype ? function(O2) {
+  return O2.__proto__;
+} : null);
+function addNumericSeparator(num, str2) {
+  if (num === Infinity || num === -Infinity || num !== num || num && num > -1e3 && num < 1e3 || $test.call(/e/, str2)) {
+    return str2;
+  }
+  var sepRegex = /[0-9](?=(?:[0-9]{3})+(?![0-9]))/g;
+  if (typeof num === "number") {
+    var int2 = num < 0 ? -$floor(-num) : $floor(num);
+    if (int2 !== num) {
+      var intStr = String(int2);
+      var dec2 = $slice.call(str2, intStr.length + 1);
+      return $replace.call(intStr, sepRegex, "$&_") + "." + $replace.call($replace.call(dec2, /([0-9]{3})/g, "$&_"), /_$/, "");
+    }
+  }
+  return $replace.call(str2, sepRegex, "$&_");
+}
+var utilInspect = require$$1$2;
+var inspectCustom = utilInspect.custom;
+var inspectSymbol = isSymbol(inspectCustom) ? inspectCustom : null;
+var objectInspect = function inspect_(obj, options2, depth, seen) {
+  var opts = options2 || {};
+  if (has$3(opts, "quoteStyle") && (opts.quoteStyle !== "single" && opts.quoteStyle !== "double")) {
+    throw new TypeError('option "quoteStyle" must be "single" or "double"');
+  }
+  if (has$3(opts, "maxStringLength") && (typeof opts.maxStringLength === "number" ? opts.maxStringLength < 0 && opts.maxStringLength !== Infinity : opts.maxStringLength !== null)) {
+    throw new TypeError('option "maxStringLength", if provided, must be a positive integer, Infinity, or `null`');
+  }
+  var customInspect = has$3(opts, "customInspect") ? opts.customInspect : true;
+  if (typeof customInspect !== "boolean" && customInspect !== "symbol") {
+    throw new TypeError("option \"customInspect\", if provided, must be `true`, `false`, or `'symbol'`");
+  }
+  if (has$3(opts, "indent") && opts.indent !== null && opts.indent !== "	" && !(parseInt(opts.indent, 10) === opts.indent && opts.indent > 0)) {
+    throw new TypeError('option "indent" must be "\\t", an integer > 0, or `null`');
+  }
+  if (has$3(opts, "numericSeparator") && typeof opts.numericSeparator !== "boolean") {
+    throw new TypeError('option "numericSeparator", if provided, must be `true` or `false`');
+  }
+  var numericSeparator = opts.numericSeparator;
+  if (typeof obj === "undefined") {
+    return "undefined";
+  }
+  if (obj === null) {
+    return "null";
+  }
+  if (typeof obj === "boolean") {
+    return obj ? "true" : "false";
+  }
+  if (typeof obj === "string") {
+    return inspectString(obj, opts);
+  }
+  if (typeof obj === "number") {
+    if (obj === 0) {
+      return Infinity / obj > 0 ? "0" : "-0";
+    }
+    var str2 = String(obj);
+    return numericSeparator ? addNumericSeparator(obj, str2) : str2;
+  }
+  if (typeof obj === "bigint") {
+    var bigIntStr = String(obj) + "n";
+    return numericSeparator ? addNumericSeparator(obj, bigIntStr) : bigIntStr;
+  }
+  var maxDepth = typeof opts.depth === "undefined" ? 5 : opts.depth;
+  if (typeof depth === "undefined") {
+    depth = 0;
+  }
+  if (depth >= maxDepth && maxDepth > 0 && typeof obj === "object") {
+    return isArray$4(obj) ? "[Array]" : "[Object]";
+  }
+  var indent = getIndent(opts, depth);
+  if (typeof seen === "undefined") {
+    seen = [];
+  } else if (indexOf2(seen, obj) >= 0) {
+    return "[Circular]";
+  }
+  function inspect2(value, from2, noIndent) {
+    if (from2) {
+      seen = $arrSlice.call(seen);
+      seen.push(from2);
+    }
+    if (noIndent) {
+      var newOpts = {
+        depth: opts.depth
+      };
+      if (has$3(opts, "quoteStyle")) {
+        newOpts.quoteStyle = opts.quoteStyle;
+      }
+      return inspect_(value, newOpts, depth + 1, seen);
+    }
+    return inspect_(value, opts, depth + 1, seen);
+  }
+  if (typeof obj === "function" && !isRegExp$2(obj)) {
+    var name2 = nameOf(obj);
+    var keys2 = arrObjKeys(obj, inspect2);
+    return "[Function" + (name2 ? ": " + name2 : " (anonymous)") + "]" + (keys2.length > 0 ? " { " + $join.call(keys2, ", ") + " }" : "");
+  }
+  if (isSymbol(obj)) {
+    var symString = hasShammedSymbols ? $replace.call(String(obj), /^(Symbol\(.*\))_[^)]*$/, "$1") : symToString.call(obj);
+    return typeof obj === "object" && !hasShammedSymbols ? markBoxed(symString) : symString;
+  }
+  if (isElement(obj)) {
+    var s2 = "<" + $toLowerCase.call(String(obj.nodeName));
+    var attrs = obj.attributes || [];
+    for (var i = 0; i < attrs.length; i++) {
+      s2 += " " + attrs[i].name + "=" + wrapQuotes(quote(attrs[i].value), "double", opts);
+    }
+    s2 += ">";
+    if (obj.childNodes && obj.childNodes.length) {
+      s2 += "...";
+    }
+    s2 += "</" + $toLowerCase.call(String(obj.nodeName)) + ">";
+    return s2;
+  }
+  if (isArray$4(obj)) {
+    if (obj.length === 0) {
+      return "[]";
+    }
+    var xs = arrObjKeys(obj, inspect2);
+    if (indent && !singleLineValues(xs)) {
+      return "[" + indentedJoin(xs, indent) + "]";
+    }
+    return "[ " + $join.call(xs, ", ") + " ]";
+  }
+  if (isError(obj)) {
+    var parts = arrObjKeys(obj, inspect2);
+    if (!("cause" in Error.prototype) && "cause" in obj && !isEnumerable.call(obj, "cause")) {
+      return "{ [" + String(obj) + "] " + $join.call($concat.call("[cause]: " + inspect2(obj.cause), parts), ", ") + " }";
+    }
+    if (parts.length === 0) {
+      return "[" + String(obj) + "]";
+    }
+    return "{ [" + String(obj) + "] " + $join.call(parts, ", ") + " }";
+  }
+  if (typeof obj === "object" && customInspect) {
+    if (inspectSymbol && typeof obj[inspectSymbol] === "function" && utilInspect) {
+      return utilInspect(obj, { depth: maxDepth - depth });
+    } else if (customInspect !== "symbol" && typeof obj.inspect === "function") {
+      return obj.inspect();
+    }
+  }
+  if (isMap(obj)) {
+    var mapParts = [];
+    if (mapForEach) {
+      mapForEach.call(obj, function(value, key) {
+        mapParts.push(inspect2(key, obj, true) + " => " + inspect2(value, obj));
+      });
+    }
+    return collectionOf("Map", mapSize.call(obj), mapParts, indent);
+  }
+  if (isSet(obj)) {
+    var setParts = [];
+    if (setForEach) {
+      setForEach.call(obj, function(value) {
+        setParts.push(inspect2(value, obj));
+      });
+    }
+    return collectionOf("Set", setSize.call(obj), setParts, indent);
+  }
+  if (isWeakMap(obj)) {
+    return weakCollectionOf("WeakMap");
+  }
+  if (isWeakSet(obj)) {
+    return weakCollectionOf("WeakSet");
+  }
+  if (isWeakRef(obj)) {
+    return weakCollectionOf("WeakRef");
+  }
+  if (isNumber(obj)) {
+    return markBoxed(inspect2(Number(obj)));
+  }
+  if (isBigInt(obj)) {
+    return markBoxed(inspect2(bigIntValueOf.call(obj)));
+  }
+  if (isBoolean$2(obj)) {
+    return markBoxed(booleanValueOf.call(obj));
+  }
+  if (isString(obj)) {
+    return markBoxed(inspect2(String(obj)));
+  }
+  if (!isDate(obj) && !isRegExp$2(obj)) {
+    var ys = arrObjKeys(obj, inspect2);
+    var isPlainObject = gPO ? gPO(obj) === Object.prototype : obj instanceof Object || obj.constructor === Object;
+    var protoTag = obj instanceof Object ? "" : "null prototype";
+    var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
+    var constructorTag = isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
+    var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
+    if (ys.length === 0) {
+      return tag + "{}";
+    }
+    if (indent) {
+      return tag + "{" + indentedJoin(ys, indent) + "}";
+    }
+    return tag + "{ " + $join.call(ys, ", ") + " }";
+  }
+  return String(obj);
+};
+function wrapQuotes(s2, defaultStyle, opts) {
+  var quoteChar = (opts.quoteStyle || defaultStyle) === "double" ? '"' : "'";
+  return quoteChar + s2 + quoteChar;
+}
+function quote(s2) {
+  return $replace.call(String(s2), /"/g, "&quot;");
+}
+function isArray$4(obj) {
+  return toStr(obj) === "[object Array]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+}
+function isDate(obj) {
+  return toStr(obj) === "[object Date]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+}
+function isRegExp$2(obj) {
+  return toStr(obj) === "[object RegExp]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+}
+function isError(obj) {
+  return toStr(obj) === "[object Error]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+}
+function isString(obj) {
+  return toStr(obj) === "[object String]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+}
+function isNumber(obj) {
+  return toStr(obj) === "[object Number]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+}
+function isBoolean$2(obj) {
+  return toStr(obj) === "[object Boolean]" && (!toStringTag || !(typeof obj === "object" && toStringTag in obj));
+}
+function isSymbol(obj) {
+  if (hasShammedSymbols) {
+    return obj && typeof obj === "object" && obj instanceof Symbol;
+  }
+  if (typeof obj === "symbol") {
+    return true;
+  }
+  if (!obj || typeof obj !== "object" || !symToString) {
+    return false;
+  }
+  try {
+    symToString.call(obj);
+    return true;
+  } catch (e2) {
+  }
+  return false;
+}
+function isBigInt(obj) {
+  if (!obj || typeof obj !== "object" || !bigIntValueOf) {
+    return false;
+  }
+  try {
+    bigIntValueOf.call(obj);
+    return true;
+  } catch (e2) {
+  }
+  return false;
+}
+var hasOwn$1 = Object.prototype.hasOwnProperty || function(key) {
+  return key in this;
+};
+function has$3(obj, key) {
+  return hasOwn$1.call(obj, key);
+}
+function toStr(obj) {
+  return objectToString.call(obj);
+}
+function nameOf(f2) {
+  if (f2.name) {
+    return f2.name;
+  }
+  var m2 = $match.call(functionToString.call(f2), /^function\s*([\w$]+)/);
+  if (m2) {
+    return m2[1];
+  }
+  return null;
+}
+function indexOf2(xs, x2) {
+  if (xs.indexOf) {
+    return xs.indexOf(x2);
+  }
+  for (var i = 0, l2 = xs.length; i < l2; i++) {
+    if (xs[i] === x2) {
+      return i;
+    }
+  }
+  return -1;
+}
+function isMap(x2) {
+  if (!mapSize || !x2 || typeof x2 !== "object") {
+    return false;
+  }
+  try {
+    mapSize.call(x2);
+    try {
+      setSize.call(x2);
+    } catch (s2) {
+      return true;
+    }
+    return x2 instanceof Map;
+  } catch (e2) {
+  }
+  return false;
+}
+function isWeakMap(x2) {
+  if (!weakMapHas || !x2 || typeof x2 !== "object") {
+    return false;
+  }
+  try {
+    weakMapHas.call(x2, weakMapHas);
+    try {
+      weakSetHas.call(x2, weakSetHas);
+    } catch (s2) {
+      return true;
+    }
+    return x2 instanceof WeakMap;
+  } catch (e2) {
+  }
+  return false;
+}
+function isWeakRef(x2) {
+  if (!weakRefDeref || !x2 || typeof x2 !== "object") {
+    return false;
+  }
+  try {
+    weakRefDeref.call(x2);
+    return true;
+  } catch (e2) {
+  }
+  return false;
+}
+function isSet(x2) {
+  if (!setSize || !x2 || typeof x2 !== "object") {
+    return false;
+  }
+  try {
+    setSize.call(x2);
+    try {
+      mapSize.call(x2);
+    } catch (m2) {
+      return true;
+    }
+    return x2 instanceof Set;
+  } catch (e2) {
+  }
+  return false;
+}
+function isWeakSet(x2) {
+  if (!weakSetHas || !x2 || typeof x2 !== "object") {
+    return false;
+  }
+  try {
+    weakSetHas.call(x2, weakSetHas);
+    try {
+      weakMapHas.call(x2, weakMapHas);
+    } catch (s2) {
+      return true;
+    }
+    return x2 instanceof WeakSet;
+  } catch (e2) {
+  }
+  return false;
+}
+function isElement(x2) {
+  if (!x2 || typeof x2 !== "object") {
+    return false;
+  }
+  if (typeof HTMLElement !== "undefined" && x2 instanceof HTMLElement) {
+    return true;
+  }
+  return typeof x2.nodeName === "string" && typeof x2.getAttribute === "function";
+}
+function inspectString(str2, opts) {
+  if (str2.length > opts.maxStringLength) {
+    var remaining = str2.length - opts.maxStringLength;
+    var trailer = "... " + remaining + " more character" + (remaining > 1 ? "s" : "");
+    return inspectString($slice.call(str2, 0, opts.maxStringLength), opts) + trailer;
+  }
+  var s2 = $replace.call($replace.call(str2, /(['\\])/g, "\\$1"), /[\x00-\x1f]/g, lowbyte);
+  return wrapQuotes(s2, "single", opts);
+}
+function lowbyte(c2) {
+  var n2 = c2.charCodeAt(0);
+  var x2 = {
+    8: "b",
+    9: "t",
+    10: "n",
+    12: "f",
+    13: "r"
+  }[n2];
+  if (x2) {
+    return "\\" + x2;
+  }
+  return "\\x" + (n2 < 16 ? "0" : "") + $toUpperCase.call(n2.toString(16));
+}
+function markBoxed(str2) {
+  return "Object(" + str2 + ")";
+}
+function weakCollectionOf(type2) {
+  return type2 + " { ? }";
+}
+function collectionOf(type2, size, entries, indent) {
+  var joinedEntries = indent ? indentedJoin(entries, indent) : $join.call(entries, ", ");
+  return type2 + " (" + size + ") {" + joinedEntries + "}";
+}
+function singleLineValues(xs) {
+  for (var i = 0; i < xs.length; i++) {
+    if (indexOf2(xs[i], "\n") >= 0) {
+      return false;
+    }
+  }
+  return true;
+}
+function getIndent(opts, depth) {
+  var baseIndent;
+  if (opts.indent === "	") {
+    baseIndent = "	";
+  } else if (typeof opts.indent === "number" && opts.indent > 0) {
+    baseIndent = $join.call(Array(opts.indent + 1), " ");
+  } else {
+    return null;
+  }
+  return {
+    base: baseIndent,
+    prev: $join.call(Array(depth + 1), baseIndent)
+  };
+}
+function indentedJoin(xs, indent) {
+  if (xs.length === 0) {
+    return "";
+  }
+  var lineJoiner = "\n" + indent.prev + indent.base;
+  return lineJoiner + $join.call(xs, "," + lineJoiner) + "\n" + indent.prev;
+}
+function arrObjKeys(obj, inspect2) {
+  var isArr = isArray$4(obj);
+  var xs = [];
+  if (isArr) {
+    xs.length = obj.length;
+    for (var i = 0; i < obj.length; i++) {
+      xs[i] = has$3(obj, i) ? inspect2(obj[i], obj) : "";
+    }
+  }
+  var syms = typeof gOPS === "function" ? gOPS(obj) : [];
+  var symMap;
+  if (hasShammedSymbols) {
+    symMap = {};
+    for (var k = 0; k < syms.length; k++) {
+      symMap["$" + syms[k]] = syms[k];
+    }
+  }
+  for (var key in obj) {
+    if (!has$3(obj, key)) {
+      continue;
+    }
+    if (isArr && String(Number(key)) === key && key < obj.length) {
+      continue;
+    }
+    if (hasShammedSymbols && symMap["$" + key] instanceof Symbol) {
+      continue;
+    } else if ($test.call(/[^\w$]/, key)) {
+      xs.push(inspect2(key, obj) + ": " + inspect2(obj[key], obj));
+    } else {
+      xs.push(key + ": " + inspect2(obj[key], obj));
+    }
+  }
+  if (typeof gOPS === "function") {
+    for (var j2 = 0; j2 < syms.length; j2++) {
+      if (isEnumerable.call(obj, syms[j2])) {
+        xs.push("[" + inspect2(syms[j2]) + "]: " + inspect2(obj[syms[j2]], obj));
+      }
+    }
+  }
+  return xs;
+}
+var GetIntrinsic2 = getIntrinsic;
+var callBound = callBound$3;
+var inspect = objectInspect;
+var $TypeError = GetIntrinsic2("%TypeError%");
+var $WeakMap = GetIntrinsic2("%WeakMap%", true);
+var $Map = GetIntrinsic2("%Map%", true);
+var $weakMapGet = callBound("WeakMap.prototype.get", true);
+var $weakMapSet = callBound("WeakMap.prototype.set", true);
+var $weakMapHas = callBound("WeakMap.prototype.has", true);
+var $mapGet = callBound("Map.prototype.get", true);
+var $mapSet = callBound("Map.prototype.set", true);
+var $mapHas = callBound("Map.prototype.has", true);
+var listGetNode = function(list, key) {
+  for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
+    if (curr.key === key) {
+      prev.next = curr.next;
+      curr.next = list.next;
+      list.next = curr;
+      return curr;
+    }
+  }
+};
+var listGet = function(objects, key) {
+  var node = listGetNode(objects, key);
+  return node && node.value;
+};
+var listSet = function(objects, key, value) {
+  var node = listGetNode(objects, key);
+  if (node) {
+    node.value = value;
+  } else {
+    objects.next = {
+      // eslint-disable-line no-param-reassign
+      key,
+      next: objects.next,
+      value
+    };
+  }
+};
+var listHas = function(objects, key) {
+  return !!listGetNode(objects, key);
+};
+var sideChannel = function getSideChannel() {
+  var $wm;
+  var $m;
+  var $o;
+  var channel = {
+    assert: function(key) {
+      if (!channel.has(key)) {
+        throw new $TypeError("Side channel does not contain " + inspect(key));
+      }
+    },
+    get: function(key) {
+      if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+        if ($wm) {
+          return $weakMapGet($wm, key);
+        }
+      } else if ($Map) {
+        if ($m) {
+          return $mapGet($m, key);
+        }
+      } else {
+        if ($o) {
+          return listGet($o, key);
+        }
+      }
+    },
+    has: function(key) {
+      if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+        if ($wm) {
+          return $weakMapHas($wm, key);
+        }
+      } else if ($Map) {
+        if ($m) {
+          return $mapHas($m, key);
+        }
+      } else {
+        if ($o) {
+          return listHas($o, key);
+        }
+      }
+      return false;
+    },
+    set: function(key, value) {
+      if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+        if (!$wm) {
+          $wm = new $WeakMap();
+        }
+        $weakMapSet($wm, key, value);
+      } else if ($Map) {
+        if (!$m) {
+          $m = new $Map();
+        }
+        $mapSet($m, key, value);
+      } else {
+        if (!$o) {
+          $o = { key: {}, next: null };
+        }
+        listSet($o, key, value);
+      }
+    }
+  };
+  return channel;
+};
+var replace = String.prototype.replace;
+var percentTwenties = /%20/g;
+var Format = {
+  RFC1738: "RFC1738",
+  RFC3986: "RFC3986"
+};
+var formats$3 = {
+  "default": Format.RFC3986,
+  formatters: {
+    RFC1738: function(value) {
+      return replace.call(value, percentTwenties, "+");
+    },
+    RFC3986: function(value) {
+      return String(value);
+    }
+  },
+  RFC1738: Format.RFC1738,
+  RFC3986: Format.RFC3986
+};
+var formats$2 = formats$3;
+var has$2 = Object.prototype.hasOwnProperty;
+var isArray$3 = Array.isArray;
+var hexTable = function() {
+  var array = [];
+  for (var i = 0; i < 256; ++i) {
+    array.push("%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase());
+  }
+  return array;
+}();
+var compactQueue = function compactQueue2(queue) {
+  while (queue.length > 1) {
+    var item = queue.pop();
+    var obj = item.obj[item.prop];
+    if (isArray$3(obj)) {
+      var compacted = [];
+      for (var j2 = 0; j2 < obj.length; ++j2) {
+        if (typeof obj[j2] !== "undefined") {
+          compacted.push(obj[j2]);
+        }
+      }
+      item.obj[item.prop] = compacted;
+    }
+  }
+};
+var arrayToObject = function arrayToObject2(source, options2) {
+  var obj = options2 && options2.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+  for (var i = 0; i < source.length; ++i) {
+    if (typeof source[i] !== "undefined") {
+      obj[i] = source[i];
+    }
+  }
+  return obj;
+};
+var merge$3 = function merge(target, source, options2) {
+  if (!source) {
+    return target;
+  }
+  if (typeof source !== "object") {
+    if (isArray$3(target)) {
+      target.push(source);
+    } else if (target && typeof target === "object") {
+      if (options2 && (options2.plainObjects || options2.allowPrototypes) || !has$2.call(Object.prototype, source)) {
+        target[source] = true;
+      }
+    } else {
+      return [target, source];
+    }
+    return target;
+  }
+  if (!target || typeof target !== "object") {
+    return [target].concat(source);
+  }
+  var mergeTarget = target;
+  if (isArray$3(target) && !isArray$3(source)) {
+    mergeTarget = arrayToObject(target, options2);
+  }
+  if (isArray$3(target) && isArray$3(source)) {
+    source.forEach(function(item, i) {
+      if (has$2.call(target, i)) {
+        var targetItem = target[i];
+        if (targetItem && typeof targetItem === "object" && item && typeof item === "object") {
+          target[i] = merge(targetItem, item, options2);
+        } else {
+          target.push(item);
+        }
+      } else {
+        target[i] = item;
+      }
+    });
+    return target;
+  }
+  return Object.keys(source).reduce(function(acc, key) {
+    var value = source[key];
+    if (has$2.call(acc, key)) {
+      acc[key] = merge(acc[key], value, options2);
+    } else {
+      acc[key] = value;
+    }
+    return acc;
+  }, mergeTarget);
+};
+var assign$1 = function assignSingleSource(target, source) {
+  return Object.keys(source).reduce(function(acc, key) {
+    acc[key] = source[key];
+    return acc;
+  }, target);
+};
+var decode = function(str2, decoder, charset) {
+  var strWithoutPlus = str2.replace(/\+/g, " ");
+  if (charset === "iso-8859-1") {
+    return strWithoutPlus.replace(/%[0-9a-f]{2}/gi, unescape);
+  }
+  try {
+    return decodeURIComponent(strWithoutPlus);
+  } catch (e2) {
+    return strWithoutPlus;
+  }
+};
+var encode = function encode2(str2, defaultEncoder, charset, kind, format2) {
+  if (str2.length === 0) {
+    return str2;
+  }
+  var string2 = str2;
+  if (typeof str2 === "symbol") {
+    string2 = Symbol.prototype.toString.call(str2);
+  } else if (typeof str2 !== "string") {
+    string2 = String(str2);
+  }
+  if (charset === "iso-8859-1") {
+    return escape(string2).replace(/%u[0-9a-f]{4}/gi, function($0) {
+      return "%26%23" + parseInt($0.slice(2), 16) + "%3B";
+    });
+  }
+  var out = "";
+  for (var i = 0; i < string2.length; ++i) {
+    var c2 = string2.charCodeAt(i);
+    if (c2 === 45 || c2 === 46 || c2 === 95 || c2 === 126 || c2 >= 48 && c2 <= 57 || c2 >= 65 && c2 <= 90 || c2 >= 97 && c2 <= 122 || format2 === formats$2.RFC1738 && (c2 === 40 || c2 === 41)) {
+      out += string2.charAt(i);
+      continue;
+    }
+    if (c2 < 128) {
+      out = out + hexTable[c2];
+      continue;
+    }
+    if (c2 < 2048) {
+      out = out + (hexTable[192 | c2 >> 6] + hexTable[128 | c2 & 63]);
+      continue;
+    }
+    if (c2 < 55296 || c2 >= 57344) {
+      out = out + (hexTable[224 | c2 >> 12] + hexTable[128 | c2 >> 6 & 63] + hexTable[128 | c2 & 63]);
+      continue;
+    }
+    i += 1;
+    c2 = 65536 + ((c2 & 1023) << 10 | string2.charCodeAt(i) & 1023);
+    out += hexTable[240 | c2 >> 18] + hexTable[128 | c2 >> 12 & 63] + hexTable[128 | c2 >> 6 & 63] + hexTable[128 | c2 & 63];
+  }
+  return out;
+};
+var compact = function compact2(value) {
+  var queue = [{ obj: { o: value }, prop: "o" }];
+  var refs2 = [];
+  for (var i = 0; i < queue.length; ++i) {
+    var item = queue[i];
+    var obj = item.obj[item.prop];
+    var keys2 = Object.keys(obj);
+    for (var j2 = 0; j2 < keys2.length; ++j2) {
+      var key = keys2[j2];
+      var val = obj[key];
+      if (typeof val === "object" && val !== null && refs2.indexOf(val) === -1) {
+        queue.push({ obj, prop: key });
+        refs2.push(val);
+      }
+    }
+  }
+  compactQueue(queue);
+  return value;
+};
+var isRegExp$1 = function isRegExp(obj) {
+  return Object.prototype.toString.call(obj) === "[object RegExp]";
+};
+var isBuffer2 = function isBuffer3(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  return !!(obj.constructor && obj.constructor.isBuffer && obj.constructor.isBuffer(obj));
+};
+var combine = function combine2(a2, b2) {
+  return [].concat(a2, b2);
+};
+var maybeMap = function maybeMap2(val, fn) {
+  if (isArray$3(val)) {
+    var mapped = [];
+    for (var i = 0; i < val.length; i += 1) {
+      mapped.push(fn(val[i]));
+    }
+    return mapped;
+  }
+  return fn(val);
+};
+var utils$2 = {
+  arrayToObject,
+  assign: assign$1,
+  combine,
+  compact,
+  decode,
+  encode,
+  isBuffer: isBuffer2,
+  isRegExp: isRegExp$1,
+  maybeMap,
+  merge: merge$3
+};
+var getSideChannel2 = sideChannel;
+var utils$1 = utils$2;
+var formats$1 = formats$3;
+var has$1 = Object.prototype.hasOwnProperty;
+var arrayPrefixGenerators = {
+  brackets: function brackets(prefix) {
+    return prefix + "[]";
+  },
+  comma: "comma",
+  indices: function indices(prefix, key) {
+    return prefix + "[" + key + "]";
+  },
+  repeat: function repeat(prefix) {
+    return prefix;
+  }
+};
+var isArray$2 = Array.isArray;
+var push = Array.prototype.push;
+var pushToArray = function(arr, valueOrArray) {
+  push.apply(arr, isArray$2(valueOrArray) ? valueOrArray : [valueOrArray]);
+};
+var toISO = Date.prototype.toISOString;
+var defaultFormat = formats$1["default"];
+var defaults$4 = {
+  addQueryPrefix: false,
+  allowDots: false,
+  charset: "utf-8",
+  charsetSentinel: false,
+  delimiter: "&",
+  encode: true,
+  encoder: utils$1.encode,
+  encodeValuesOnly: false,
+  format: defaultFormat,
+  formatter: formats$1.formatters[defaultFormat],
+  // deprecated
+  indices: false,
+  serializeDate: function serializeDate(date) {
+    return toISO.call(date);
+  },
+  skipNulls: false,
+  strictNullHandling: false
+};
+var isNonNullishPrimitive = function isNonNullishPrimitive2(v2) {
+  return typeof v2 === "string" || typeof v2 === "number" || typeof v2 === "boolean" || typeof v2 === "symbol" || typeof v2 === "bigint";
+};
+var sentinel = {};
+var stringify$1 = function stringify(object, prefix, generateArrayPrefix, commaRoundTrip, strictNullHandling, skipNulls, encoder, filter, sort, allowDots, serializeDate2, format2, formatter, encodeValuesOnly, charset, sideChannel2) {
+  var obj = object;
+  var tmpSc = sideChannel2;
+  var step = 0;
+  var findFlag = false;
+  while ((tmpSc = tmpSc.get(sentinel)) !== void 0 && !findFlag) {
+    var pos = tmpSc.get(object);
+    step += 1;
+    if (typeof pos !== "undefined") {
+      if (pos === step) {
+        throw new RangeError("Cyclic object value");
+      } else {
+        findFlag = true;
+      }
+    }
+    if (typeof tmpSc.get(sentinel) === "undefined") {
+      step = 0;
+    }
+  }
+  if (typeof filter === "function") {
+    obj = filter(prefix, obj);
+  } else if (obj instanceof Date) {
+    obj = serializeDate2(obj);
+  } else if (generateArrayPrefix === "comma" && isArray$2(obj)) {
+    obj = utils$1.maybeMap(obj, function(value2) {
+      if (value2 instanceof Date) {
+        return serializeDate2(value2);
+      }
+      return value2;
+    });
+  }
+  if (obj === null) {
+    if (strictNullHandling) {
+      return encoder && !encodeValuesOnly ? encoder(prefix, defaults$4.encoder, charset, "key", format2) : prefix;
+    }
+    obj = "";
+  }
+  if (isNonNullishPrimitive(obj) || utils$1.isBuffer(obj)) {
+    if (encoder) {
+      var keyValue = encodeValuesOnly ? prefix : encoder(prefix, defaults$4.encoder, charset, "key", format2);
+      return [formatter(keyValue) + "=" + formatter(encoder(obj, defaults$4.encoder, charset, "value", format2))];
+    }
+    return [formatter(prefix) + "=" + formatter(String(obj))];
+  }
+  var values = [];
+  if (typeof obj === "undefined") {
+    return values;
+  }
+  var objKeys;
+  if (generateArrayPrefix === "comma" && isArray$2(obj)) {
+    if (encodeValuesOnly && encoder) {
+      obj = utils$1.maybeMap(obj, encoder);
+    }
+    objKeys = [{ value: obj.length > 0 ? obj.join(",") || null : void 0 }];
+  } else if (isArray$2(filter)) {
+    objKeys = filter;
+  } else {
+    var keys2 = Object.keys(obj);
+    objKeys = sort ? keys2.sort(sort) : keys2;
+  }
+  var adjustedPrefix = commaRoundTrip && isArray$2(obj) && obj.length === 1 ? prefix + "[]" : prefix;
+  for (var j2 = 0; j2 < objKeys.length; ++j2) {
+    var key = objKeys[j2];
+    var value = typeof key === "object" && typeof key.value !== "undefined" ? key.value : obj[key];
+    if (skipNulls && value === null) {
+      continue;
+    }
+    var keyPrefix = isArray$2(obj) ? typeof generateArrayPrefix === "function" ? generateArrayPrefix(adjustedPrefix, key) : adjustedPrefix : adjustedPrefix + (allowDots ? "." + key : "[" + key + "]");
+    sideChannel2.set(object, step);
+    var valueSideChannel = getSideChannel2();
+    valueSideChannel.set(sentinel, sideChannel2);
+    pushToArray(values, stringify(
+      value,
+      keyPrefix,
+      generateArrayPrefix,
+      commaRoundTrip,
+      strictNullHandling,
+      skipNulls,
+      generateArrayPrefix === "comma" && encodeValuesOnly && isArray$2(obj) ? null : encoder,
+      filter,
+      sort,
+      allowDots,
+      serializeDate2,
+      format2,
+      formatter,
+      encodeValuesOnly,
+      charset,
+      valueSideChannel
+    ));
+  }
+  return values;
+};
+var normalizeStringifyOptions = function normalizeStringifyOptions2(opts) {
+  if (!opts) {
+    return defaults$4;
+  }
+  if (opts.encoder !== null && typeof opts.encoder !== "undefined" && typeof opts.encoder !== "function") {
+    throw new TypeError("Encoder has to be a function.");
+  }
+  var charset = opts.charset || defaults$4.charset;
+  if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+    throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+  }
+  var format2 = formats$1["default"];
+  if (typeof opts.format !== "undefined") {
+    if (!has$1.call(formats$1.formatters, opts.format)) {
+      throw new TypeError("Unknown format option provided.");
+    }
+    format2 = opts.format;
+  }
+  var formatter = formats$1.formatters[format2];
+  var filter = defaults$4.filter;
+  if (typeof opts.filter === "function" || isArray$2(opts.filter)) {
+    filter = opts.filter;
+  }
+  return {
+    addQueryPrefix: typeof opts.addQueryPrefix === "boolean" ? opts.addQueryPrefix : defaults$4.addQueryPrefix,
+    allowDots: typeof opts.allowDots === "undefined" ? defaults$4.allowDots : !!opts.allowDots,
+    charset,
+    charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults$4.charsetSentinel,
+    delimiter: typeof opts.delimiter === "undefined" ? defaults$4.delimiter : opts.delimiter,
+    encode: typeof opts.encode === "boolean" ? opts.encode : defaults$4.encode,
+    encoder: typeof opts.encoder === "function" ? opts.encoder : defaults$4.encoder,
+    encodeValuesOnly: typeof opts.encodeValuesOnly === "boolean" ? opts.encodeValuesOnly : defaults$4.encodeValuesOnly,
+    filter,
+    format: format2,
+    formatter,
+    serializeDate: typeof opts.serializeDate === "function" ? opts.serializeDate : defaults$4.serializeDate,
+    skipNulls: typeof opts.skipNulls === "boolean" ? opts.skipNulls : defaults$4.skipNulls,
+    sort: typeof opts.sort === "function" ? opts.sort : null,
+    strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults$4.strictNullHandling
+  };
+};
+var stringify_1 = function(object, opts) {
+  var obj = object;
+  var options2 = normalizeStringifyOptions(opts);
+  var objKeys;
+  var filter;
+  if (typeof options2.filter === "function") {
+    filter = options2.filter;
+    obj = filter("", obj);
+  } else if (isArray$2(options2.filter)) {
+    filter = options2.filter;
+    objKeys = filter;
+  }
+  var keys2 = [];
+  if (typeof obj !== "object" || obj === null) {
+    return "";
+  }
+  var arrayFormat;
+  if (opts && opts.arrayFormat in arrayPrefixGenerators) {
+    arrayFormat = opts.arrayFormat;
+  } else if (opts && "indices" in opts) {
+    arrayFormat = opts.indices ? "indices" : "repeat";
+  } else {
+    arrayFormat = "indices";
+  }
+  var generateArrayPrefix = arrayPrefixGenerators[arrayFormat];
+  if (opts && "commaRoundTrip" in opts && typeof opts.commaRoundTrip !== "boolean") {
+    throw new TypeError("`commaRoundTrip` must be a boolean, or absent");
+  }
+  var commaRoundTrip = generateArrayPrefix === "comma" && opts && opts.commaRoundTrip;
+  if (!objKeys) {
+    objKeys = Object.keys(obj);
+  }
+  if (options2.sort) {
+    objKeys.sort(options2.sort);
+  }
+  var sideChannel2 = getSideChannel2();
+  for (var i = 0; i < objKeys.length; ++i) {
+    var key = objKeys[i];
+    if (options2.skipNulls && obj[key] === null) {
+      continue;
+    }
+    pushToArray(keys2, stringify$1(
+      obj[key],
+      key,
+      generateArrayPrefix,
+      commaRoundTrip,
+      options2.strictNullHandling,
+      options2.skipNulls,
+      options2.encode ? options2.encoder : null,
+      options2.filter,
+      options2.sort,
+      options2.allowDots,
+      options2.serializeDate,
+      options2.format,
+      options2.formatter,
+      options2.encodeValuesOnly,
+      options2.charset,
+      sideChannel2
+    ));
+  }
+  var joined = keys2.join(options2.delimiter);
+  var prefix = options2.addQueryPrefix === true ? "?" : "";
+  if (options2.charsetSentinel) {
+    if (options2.charset === "iso-8859-1") {
+      prefix += "utf8=%26%2310003%3B&";
+    } else {
+      prefix += "utf8=%E2%9C%93&";
+    }
+  }
+  return joined.length > 0 ? prefix + joined : "";
+};
+var utils = utils$2;
+var has = Object.prototype.hasOwnProperty;
+var isArray$1 = Array.isArray;
+var defaults$3 = {
+  allowDots: false,
+  allowPrototypes: false,
+  allowSparse: false,
+  arrayLimit: 20,
+  charset: "utf-8",
+  charsetSentinel: false,
+  comma: false,
+  decoder: utils.decode,
+  delimiter: "&",
+  depth: 5,
+  ignoreQueryPrefix: false,
+  interpretNumericEntities: false,
+  parameterLimit: 1e3,
+  parseArrays: true,
+  plainObjects: false,
+  strictNullHandling: false
+};
+var interpretNumericEntities = function(str2) {
+  return str2.replace(/&#(\d+);/g, function($0, numberStr) {
+    return String.fromCharCode(parseInt(numberStr, 10));
+  });
+};
+var parseArrayValue = function(val, options2) {
+  if (val && typeof val === "string" && options2.comma && val.indexOf(",") > -1) {
+    return val.split(",");
+  }
+  return val;
+};
+var isoSentinel = "utf8=%26%2310003%3B";
+var charsetSentinel = "utf8=%E2%9C%93";
+var parseValues = function parseQueryStringValues(str2, options2) {
+  var obj = { __proto__: null };
+  var cleanStr = options2.ignoreQueryPrefix ? str2.replace(/^\?/, "") : str2;
+  var limit = options2.parameterLimit === Infinity ? void 0 : options2.parameterLimit;
+  var parts = cleanStr.split(options2.delimiter, limit);
+  var skipIndex = -1;
+  var i;
+  var charset = options2.charset;
+  if (options2.charsetSentinel) {
+    for (i = 0; i < parts.length; ++i) {
+      if (parts[i].indexOf("utf8=") === 0) {
+        if (parts[i] === charsetSentinel) {
+          charset = "utf-8";
+        } else if (parts[i] === isoSentinel) {
+          charset = "iso-8859-1";
+        }
+        skipIndex = i;
+        i = parts.length;
+      }
+    }
+  }
+  for (i = 0; i < parts.length; ++i) {
+    if (i === skipIndex) {
+      continue;
+    }
+    var part = parts[i];
+    var bracketEqualsPos = part.indexOf("]=");
+    var pos = bracketEqualsPos === -1 ? part.indexOf("=") : bracketEqualsPos + 1;
+    var key, val;
+    if (pos === -1) {
+      key = options2.decoder(part, defaults$3.decoder, charset, "key");
+      val = options2.strictNullHandling ? null : "";
+    } else {
+      key = options2.decoder(part.slice(0, pos), defaults$3.decoder, charset, "key");
+      val = utils.maybeMap(
+        parseArrayValue(part.slice(pos + 1), options2),
+        function(encodedVal) {
+          return options2.decoder(encodedVal, defaults$3.decoder, charset, "value");
+        }
+      );
+    }
+    if (val && options2.interpretNumericEntities && charset === "iso-8859-1") {
+      val = interpretNumericEntities(val);
+    }
+    if (part.indexOf("[]=") > -1) {
+      val = isArray$1(val) ? [val] : val;
+    }
+    if (has.call(obj, key)) {
+      obj[key] = utils.combine(obj[key], val);
+    } else {
+      obj[key] = val;
+    }
+  }
+  return obj;
+};
+var parseObject = function(chain, val, options2, valuesParsed) {
+  var leaf = valuesParsed ? val : parseArrayValue(val, options2);
+  for (var i = chain.length - 1; i >= 0; --i) {
+    var obj;
+    var root = chain[i];
+    if (root === "[]" && options2.parseArrays) {
+      obj = [].concat(leaf);
+    } else {
+      obj = options2.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+      var cleanRoot = root.charAt(0) === "[" && root.charAt(root.length - 1) === "]" ? root.slice(1, -1) : root;
+      var index = parseInt(cleanRoot, 10);
+      if (!options2.parseArrays && cleanRoot === "") {
+        obj = { 0: leaf };
+      } else if (!isNaN(index) && root !== cleanRoot && String(index) === cleanRoot && index >= 0 && (options2.parseArrays && index <= options2.arrayLimit)) {
+        obj = [];
+        obj[index] = leaf;
+      } else if (cleanRoot !== "__proto__") {
+        obj[cleanRoot] = leaf;
+      }
+    }
+    leaf = obj;
+  }
+  return leaf;
+};
+var parseKeys = function parseQueryStringKeys(givenKey, val, options2, valuesParsed) {
+  if (!givenKey) {
+    return;
+  }
+  var key = options2.allowDots ? givenKey.replace(/\.([^.[]+)/g, "[$1]") : givenKey;
+  var brackets2 = /(\[[^[\]]*])/;
+  var child = /(\[[^[\]]*])/g;
+  var segment = options2.depth > 0 && brackets2.exec(key);
+  var parent = segment ? key.slice(0, segment.index) : key;
+  var keys2 = [];
+  if (parent) {
+    if (!options2.plainObjects && has.call(Object.prototype, parent)) {
+      if (!options2.allowPrototypes) {
+        return;
+      }
+    }
+    keys2.push(parent);
+  }
+  var i = 0;
+  while (options2.depth > 0 && (segment = child.exec(key)) !== null && i < options2.depth) {
+    i += 1;
+    if (!options2.plainObjects && has.call(Object.prototype, segment[1].slice(1, -1))) {
+      if (!options2.allowPrototypes) {
+        return;
+      }
+    }
+    keys2.push(segment[1]);
+  }
+  if (segment) {
+    keys2.push("[" + key.slice(segment.index) + "]");
+  }
+  return parseObject(keys2, val, options2, valuesParsed);
+};
+var normalizeParseOptions = function normalizeParseOptions2(opts) {
+  if (!opts) {
+    return defaults$3;
+  }
+  if (opts.decoder !== null && opts.decoder !== void 0 && typeof opts.decoder !== "function") {
+    throw new TypeError("Decoder has to be a function.");
+  }
+  if (typeof opts.charset !== "undefined" && opts.charset !== "utf-8" && opts.charset !== "iso-8859-1") {
+    throw new TypeError("The charset option must be either utf-8, iso-8859-1, or undefined");
+  }
+  var charset = typeof opts.charset === "undefined" ? defaults$3.charset : opts.charset;
+  return {
+    allowDots: typeof opts.allowDots === "undefined" ? defaults$3.allowDots : !!opts.allowDots,
+    allowPrototypes: typeof opts.allowPrototypes === "boolean" ? opts.allowPrototypes : defaults$3.allowPrototypes,
+    allowSparse: typeof opts.allowSparse === "boolean" ? opts.allowSparse : defaults$3.allowSparse,
+    arrayLimit: typeof opts.arrayLimit === "number" ? opts.arrayLimit : defaults$3.arrayLimit,
+    charset,
+    charsetSentinel: typeof opts.charsetSentinel === "boolean" ? opts.charsetSentinel : defaults$3.charsetSentinel,
+    comma: typeof opts.comma === "boolean" ? opts.comma : defaults$3.comma,
+    decoder: typeof opts.decoder === "function" ? opts.decoder : defaults$3.decoder,
+    delimiter: typeof opts.delimiter === "string" || utils.isRegExp(opts.delimiter) ? opts.delimiter : defaults$3.delimiter,
+    // eslint-disable-next-line no-implicit-coercion, no-extra-parens
+    depth: typeof opts.depth === "number" || opts.depth === false ? +opts.depth : defaults$3.depth,
+    ignoreQueryPrefix: opts.ignoreQueryPrefix === true,
+    interpretNumericEntities: typeof opts.interpretNumericEntities === "boolean" ? opts.interpretNumericEntities : defaults$3.interpretNumericEntities,
+    parameterLimit: typeof opts.parameterLimit === "number" ? opts.parameterLimit : defaults$3.parameterLimit,
+    parseArrays: opts.parseArrays !== false,
+    plainObjects: typeof opts.plainObjects === "boolean" ? opts.plainObjects : defaults$3.plainObjects,
+    strictNullHandling: typeof opts.strictNullHandling === "boolean" ? opts.strictNullHandling : defaults$3.strictNullHandling
+  };
+};
+var parse$3 = function(str2, opts) {
+  var options2 = normalizeParseOptions(opts);
+  if (str2 === "" || str2 === null || typeof str2 === "undefined") {
+    return options2.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+  }
+  var tempObj = typeof str2 === "string" ? parseValues(str2, options2) : str2;
+  var obj = options2.plainObjects ? /* @__PURE__ */ Object.create(null) : {};
+  var keys2 = Object.keys(tempObj);
+  for (var i = 0; i < keys2.length; ++i) {
+    var key = keys2[i];
+    var newObj = parseKeys(key, tempObj[key], options2, typeof str2 === "string");
+    obj = utils.merge(obj, newObj, options2);
+  }
+  if (options2.allowSparse === true) {
+    return obj;
+  }
+  return utils.compact(obj);
+};
+var stringify2 = stringify_1;
+var parse$2 = parse$3;
+var formats = formats$3;
+var lib$4 = {
+  formats,
+  parse: parse$2,
+  stringify: stringify2
+};
+var punycode = punycodeExports;
+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, portPattern = /:[0-9]*$/, simplePathPattern = /^(\/\/?(?!\/)[^?\s]*)(\?[^\s]*)?$/, delims = [
+  "<",
+  ">",
+  '"',
+  "`",
+  " ",
+  "\r",
+  "\n",
+  "	"
+], unwise = [
+  "{",
+  "}",
+  "|",
+  "\\",
+  "^",
+  "`"
+].concat(delims), autoEscape = ["'"].concat(unwise), nonHostChars = [
+  "%",
+  "/",
+  "?",
+  ";",
+  "#"
+].concat(autoEscape), hostEndingChars = [
+  "/",
+  "?",
+  "#"
+], hostnameMaxLen = 255, hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/, hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/, unsafeProtocol = {
+  javascript: true,
+  "javascript:": true
+}, hostlessProtocol = {
+  javascript: true,
+  "javascript:": true
+}, slashedProtocol = {
+  http: true,
+  https: true,
+  ftp: true,
+  gopher: true,
+  file: true,
+  "http:": true,
+  "https:": true,
+  "ftp:": true,
+  "gopher:": true,
+  "file:": true
+}, querystring = lib$4;
+function urlParse(url2, parseQueryString, slashesDenoteHost) {
+  if (url2 && typeof url2 === "object" && url2 instanceof Url) {
+    return url2;
+  }
+  var u2 = new Url();
+  u2.parse(url2, parseQueryString, slashesDenoteHost);
+  return u2;
+}
+Url.prototype.parse = function(url2, parseQueryString, slashesDenoteHost) {
+  if (typeof url2 !== "string") {
+    throw new TypeError("Parameter 'url' must be a string, not " + typeof url2);
+  }
+  var queryIndex = url2.indexOf("?"), splitter = queryIndex !== -1 && queryIndex < url2.indexOf("#") ? "?" : "#", uSplit = url2.split(splitter), slashRegex = /\\/g;
+  uSplit[0] = uSplit[0].replace(slashRegex, "/");
+  url2 = uSplit.join(splitter);
+  var rest = url2;
+  rest = rest.trim();
+  if (!slashesDenoteHost && url2.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, l2 = hostparts.length; i < l2; i++) {
+        var part = hostparts[i];
+        if (!part) {
+          continue;
+        }
+        if (!part.match(hostnamePartPattern)) {
+          var newpart = "";
+          for (var j2 = 0, k = part.length; j2 < k; j2++) {
+            if (part.charCodeAt(j2) > 127) {
+              newpart += "x";
+            } else {
+              newpart += part[j2];
+            }
+          }
+          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 p2 = this.port ? ":" + this.port : "";
+    var h2 = this.hostname || "";
+    this.host = h2 + p2;
+    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, l2 = autoEscape.length; i < l2; 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 p2 = this.pathname || "";
+    var s2 = this.search || "";
+    this.path = p2 + s2;
+  }
+  this.href = this.format();
+  return this;
+};
+function urlFormat(obj) {
+  if (typeof obj === "string") {
+    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 && typeof this.query === "object" && 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 (typeof relative === "string") {
+    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.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 v2 = 0; v2 < keys2.length; v2++) {
+        var k = keys2[v2];
+        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 p2 = result.pathname || "";
+      var s2 = result.search || "";
+      result.path = p2 + s2;
+    }
+    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 (relative.search != null) {
+    if (psychotic) {
+      result.host = srcPath.shift();
+      result.hostname = result.host;
+      var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
+      if (authInHost) {
+        result.auth = authInHost.shift();
+        result.hostname = authInHost.shift();
+        result.host = result.hostname;
+      }
+    }
+    result.search = relative.search;
+    result.query = relative.query;
+    if (result.pathname !== null || result.search !== null) {
+      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 last2 = srcPath.slice(-1)[0];
+  var hasTrailingSlash = (result.host || relative.host || srcPath.length > 1) && (last2 === "." || last2 === "..") || last2 === "";
+  var up = 0;
+  for (var i = srcPath.length; i >= 0; i--) {
+    last2 = srcPath[i];
+    if (last2 === ".") {
+      srcPath.splice(i, 1);
+    } else if (last2 === "..") {
+      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 = isAbsolute ? "" : srcPath.length ? srcPath.shift() : "";
+    result.host = result.hostname;
+    var authInHost = result.host && result.host.indexOf("@") > 0 ? result.host.split("@") : false;
+    if (authInHost) {
+      result.auth = authInHost.shift();
+      result.hostname = authInHost.shift();
+      result.host = result.hostname;
+    }
+  }
+  mustEndAbs = mustEndAbs || result.host && srcPath.length;
+  if (mustEndAbs && !isAbsolute) {
+    srcPath.unshift("");
+  }
+  if (srcPath.length > 0) {
+    result.pathname = srcPath.join("/");
+  } else {
+    result.pathname = null;
+    result.path = null;
+  }
+  if (result.pathname !== null || result.search !== null) {
+    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;
+  }
+};
+url$9.parse = urlParse;
+url$9.resolve = urlResolve;
+url$9.resolveObject = urlResolveObject;
+url$9.format = urlFormat;
+url$9.Url = Url;
 (function(module2, exports) {
-  let isWindows = /^win/.test(process.platform), forwardSlashPattern = /\//g, protocolPattern = /^(\w{2,}):\/\//i, url2 = module2.exports, jsonPointerSlash = /~1/g, jsonPointerTilde = /~0/g;
+  let isWindows = /^win/.test(process.platform), forwardSlashPattern = /\//g, protocolPattern2 = /^(\w{2,}):\/\//i, url2 = module2.exports, jsonPointerSlash = /~1/g, jsonPointerTilde = /~0/g;
   let urlEncodePatterns = [
     /\?/g,
     "%3F",
@@ -1685,8 +3724,8 @@ const require$$1$2 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal
     /\%40/g,
     "@"
   ];
-  exports.parse = require$$1$2.parse;
-  exports.resolve = require$$1$2.resolve;
+  exports.parse = url$9.parse;
+  exports.resolve = url$9.resolve;
   exports.cwd = function cwd() {
     if (process.browser) {
       return location.href;
@@ -1700,7 +3739,7 @@ const require$$1$2 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal
     }
   };
   exports.getProtocol = function getProtocol(path) {
-    let match = protocolPattern.exec(path);
+    let match = protocolPattern2.exec(path);
     if (match) {
       return match[1].toLowerCase();
     }
@@ -1787,8 +3826,8 @@ const require$$1$2 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal
       return decodeURIComponent(value).replace(jsonPointerSlash, "/").replace(jsonPointerTilde, "~");
     });
   };
-})(url$9, url$9.exports);
-var urlExports = url$9.exports;
+})(url$a, url$a.exports);
+var urlExports = url$a.exports;
 const util$5 = util$6;
 const url$8 = urlExports;
 util$7.format = util$5.format;
@@ -2177,10 +4216,10 @@ var code$2 = {};
   function interpolate(x2) {
     return typeof x2 == "number" || typeof x2 == "boolean" || x2 === null ? x2 : safeStringify(Array.isArray(x2) ? x2.join(",") : x2);
   }
-  function stringify(x2) {
+  function stringify3(x2) {
     return new _Code(safeStringify(x2));
   }
-  exports.stringify = stringify;
+  exports.stringify = stringify3;
   function safeStringify(x2) {
     return JSON.stringify(x2).replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
   }
@@ -3204,8 +5243,8 @@ var util$4 = {};
   })(Type2 = exports.Type || (exports.Type = {}));
   function getErrorPath(dataProp, dataPropType, jsPropertySyntax) {
     if (dataProp instanceof codegen_12.Name) {
-      const isNumber = dataPropType === Type2.Num;
-      return jsPropertySyntax ? isNumber ? (0, codegen_12._)`"[" + ${dataProp} + "]"` : (0, codegen_12._)`"['" + ${dataProp} + "']"` : isNumber ? (0, codegen_12._)`"/" + ${dataProp}` : (0, codegen_12._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
+      const isNumber2 = dataPropType === Type2.Num;
+      return jsPropertySyntax ? isNumber2 ? (0, codegen_12._)`"[" + ${dataProp} + "]"` : (0, codegen_12._)`"['" + ${dataProp} + "']"` : isNumber2 ? (0, codegen_12._)`"/" + ${dataProp}` : (0, codegen_12._)`"/" + ${dataProp}.replace(/~/g, "~0").replace(/\\//g, "~1")`;
     }
     return jsPropertySyntax ? (0, codegen_12.getProperty)(dataProp).toString() : "/" + escapeJsonPointer(dataProp);
   }
@@ -5020,7 +7059,7 @@ var uri_all = { exports: {} };
   (function(global2, factory) {
     factory(exports);
   })(commonjsGlobal, function(exports2) {
-    function merge2() {
+    function merge3() {
       for (var _len = arguments.length, sets = Array(_len), _key = 0; _key < _len; _key++) {
         sets[_key] = arguments[_key];
       }
@@ -5058,26 +7097,26 @@ var uri_all = { exports: {} };
       return obj;
     }
     function buildExps(isIRI) {
-      var ALPHA$$ = "[A-Za-z]", DIGIT$$ = "[0-9]", HEXDIG$$2 = merge2(DIGIT$$, "[A-Fa-f]"), PCT_ENCODED$2 = subexp(subexp("%[EFef]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%" + HEXDIG$$2 + HEXDIG$$2)), GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]", SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]", RESERVED$$ = merge2(GEN_DELIMS$$, SUB_DELIMS$$), UCSCHAR$$ = isIRI ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]", IPRIVATE$$ = isIRI ? "[\\uE000-\\uF8FF]" : "[]", UNRESERVED$$2 = merge2(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]", UCSCHAR$$);
-      subexp(ALPHA$$ + merge2(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*");
-      subexp(subexp(PCT_ENCODED$2 + "|" + merge2(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]")) + "*");
+      var ALPHA$$ = "[A-Za-z]", DIGIT$$ = "[0-9]", HEXDIG$$2 = merge3(DIGIT$$, "[A-Fa-f]"), PCT_ENCODED$2 = subexp(subexp("%[EFef]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$2 + "%" + HEXDIG$$2 + HEXDIG$$2) + "|" + subexp("%" + HEXDIG$$2 + HEXDIG$$2)), GEN_DELIMS$$ = "[\\:\\/\\?\\#\\[\\]\\@]", SUB_DELIMS$$ = "[\\!\\$\\&\\'\\(\\)\\*\\+\\,\\;\\=]", RESERVED$$ = merge3(GEN_DELIMS$$, SUB_DELIMS$$), UCSCHAR$$ = isIRI ? "[\\xA0-\\u200D\\u2010-\\u2029\\u202F-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFEF]" : "[]", IPRIVATE$$ = isIRI ? "[\\uE000-\\uF8FF]" : "[]", UNRESERVED$$2 = merge3(ALPHA$$, DIGIT$$, "[\\-\\.\\_\\~]", UCSCHAR$$);
+      subexp(ALPHA$$ + merge3(ALPHA$$, DIGIT$$, "[\\+\\-\\.]") + "*");
+      subexp(subexp(PCT_ENCODED$2 + "|" + merge3(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]")) + "*");
       var DEC_OCTET_RELAXED$ = subexp(subexp("25[0-5]") + "|" + subexp("2[0-4]" + DIGIT$$) + "|" + subexp("1" + DIGIT$$ + DIGIT$$) + "|" + subexp("0?[1-9]" + DIGIT$$) + "|0?0?" + DIGIT$$), IPV4ADDRESS$ = subexp(DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$ + "\\." + DEC_OCTET_RELAXED$), H16$ = subexp(HEXDIG$$2 + "{1,4}"), LS32$ = subexp(subexp(H16$ + "\\:" + H16$) + "|" + IPV4ADDRESS$), IPV6ADDRESS1$ = subexp(subexp(H16$ + "\\:") + "{6}" + LS32$), IPV6ADDRESS2$ = subexp("\\:\\:" + subexp(H16$ + "\\:") + "{5}" + LS32$), IPV6ADDRESS3$ = subexp(subexp(H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{4}" + LS32$), IPV6ADDRESS4$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,1}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{3}" + LS32$), IPV6ADDRESS5$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,2}" + H16$) + "?\\:\\:" + subexp(H16$ + "\\:") + "{2}" + LS32$), IPV6ADDRESS6$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,3}" + H16$) + "?\\:\\:" + H16$ + "\\:" + LS32$), IPV6ADDRESS7$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,4}" + H16$) + "?\\:\\:" + LS32$), IPV6ADDRESS8$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,5}" + H16$) + "?\\:\\:" + H16$), IPV6ADDRESS9$ = subexp(subexp(subexp(H16$ + "\\:") + "{0,6}" + H16$) + "?\\:\\:"), IPV6ADDRESS$ = subexp([IPV6ADDRESS1$, IPV6ADDRESS2$, IPV6ADDRESS3$, IPV6ADDRESS4$, IPV6ADDRESS5$, IPV6ADDRESS6$, IPV6ADDRESS7$, IPV6ADDRESS8$, IPV6ADDRESS9$].join("|")), ZONEID$ = subexp(subexp(UNRESERVED$$2 + "|" + PCT_ENCODED$2) + "+");
-      subexp("[vV]" + HEXDIG$$2 + "+\\." + merge2(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]") + "+");
-      subexp(subexp(PCT_ENCODED$2 + "|" + merge2(UNRESERVED$$2, SUB_DELIMS$$)) + "*");
-      var PCHAR$ = subexp(PCT_ENCODED$2 + "|" + merge2(UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@]"));
-      subexp(subexp(PCT_ENCODED$2 + "|" + merge2(UNRESERVED$$2, SUB_DELIMS$$, "[\\@]")) + "+");
-      subexp(subexp(PCHAR$ + "|" + merge2("[\\/\\?]", IPRIVATE$$)) + "*");
+      subexp("[vV]" + HEXDIG$$2 + "+\\." + merge3(UNRESERVED$$2, SUB_DELIMS$$, "[\\:]") + "+");
+      subexp(subexp(PCT_ENCODED$2 + "|" + merge3(UNRESERVED$$2, SUB_DELIMS$$)) + "*");
+      var PCHAR$ = subexp(PCT_ENCODED$2 + "|" + merge3(UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@]"));
+      subexp(subexp(PCT_ENCODED$2 + "|" + merge3(UNRESERVED$$2, SUB_DELIMS$$, "[\\@]")) + "+");
+      subexp(subexp(PCHAR$ + "|" + merge3("[\\/\\?]", IPRIVATE$$)) + "*");
       return {
-        NOT_SCHEME: new RegExp(merge2("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"),
-        NOT_USERINFO: new RegExp(merge2("[^\\%\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
-        NOT_HOST: new RegExp(merge2("[^\\%\\[\\]\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
-        NOT_PATH: new RegExp(merge2("[^\\%\\/\\:\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
-        NOT_PATH_NOSCHEME: new RegExp(merge2("[^\\%\\/\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
-        NOT_QUERY: new RegExp(merge2("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"),
-        NOT_FRAGMENT: new RegExp(merge2("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"),
-        ESCAPE: new RegExp(merge2("[^]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
+        NOT_SCHEME: new RegExp(merge3("[^]", ALPHA$$, DIGIT$$, "[\\+\\-\\.]"), "g"),
+        NOT_USERINFO: new RegExp(merge3("[^\\%\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
+        NOT_HOST: new RegExp(merge3("[^\\%\\[\\]\\:]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
+        NOT_PATH: new RegExp(merge3("[^\\%\\/\\:\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
+        NOT_PATH_NOSCHEME: new RegExp(merge3("[^\\%\\/\\@]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
+        NOT_QUERY: new RegExp(merge3("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]", IPRIVATE$$), "g"),
+        NOT_FRAGMENT: new RegExp(merge3("[^\\%]", UNRESERVED$$2, SUB_DELIMS$$, "[\\:\\@\\/\\?]"), "g"),
+        ESCAPE: new RegExp(merge3("[^]", UNRESERVED$$2, SUB_DELIMS$$), "g"),
         UNRESERVED: new RegExp(UNRESERVED$$2, "g"),
-        OTHER_CHARS: new RegExp(merge2("[^\\%]", UNRESERVED$$2, RESERVED$$), "g"),
+        OTHER_CHARS: new RegExp(merge3("[^\\%]", UNRESERVED$$2, RESERVED$$), "g"),
         PCT_ENCODED: new RegExp(PCT_ENCODED$2, "g"),
         IPV4ADDRESS: new RegExp("^(" + IPV4ADDRESS$ + ")$"),
         IPV6ADDRESS: new RegExp("^\\[?(" + IPV6ADDRESS$ + ")" + subexp(subexp("\\%25|\\%(?!" + HEXDIG$$2 + "{2})") + "(" + ZONEID$ + ")") + "?\\]?$")
@@ -5226,7 +7265,7 @@ var uri_all = { exports: {} };
       }
       return floor2(k + (baseMinusTMin + 1) * delta / (delta + skew));
     };
-    var decode = function decode2(input) {
+    var decode2 = function decode3(input) {
       var output = [];
       var inputLength = input.length;
       var i = 0;
@@ -5279,7 +7318,7 @@ var uri_all = { exports: {} };
       }
       return String.fromCodePoint.apply(String, output);
     };
-    var encode = function encode2(input) {
+    var encode3 = function encode4(input) {
       var output = [];
       input = ucs2decode(input);
       var inputLength = input.length;
@@ -5400,15 +7439,15 @@ var uri_all = { exports: {} };
     };
     var toUnicode = function toUnicode2(input) {
       return mapDomain(input, function(string2) {
-        return regexPunycode.test(string2) ? decode(string2.slice(4).toLowerCase()) : string2;
+        return regexPunycode.test(string2) ? decode2(string2.slice(4).toLowerCase()) : string2;
       });
     };
     var toASCII = function toASCII2(input) {
       return mapDomain(input, function(string2) {
-        return regexNonASCII.test(string2) ? "xn--" + encode(string2) : string2;
+        return regexNonASCII.test(string2) ? "xn--" + encode3(string2) : string2;
       });
     };
-    var punycode = {
+    var punycode2 = {
       /**
        * A string representing the current Punycode.js version number.
        * @memberOf punycode
@@ -5426,8 +7465,8 @@ var uri_all = { exports: {} };
         "decode": ucs2decode,
         "encode": ucs2encode
       },
-      "decode": decode,
-      "encode": encode,
+      "decode": decode2,
+      "encode": encode3,
       "toASCII": toASCII,
       "toUnicode": toUnicode
     };
@@ -5608,7 +7647,7 @@ var uri_all = { exports: {} };
         if (!options2.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
           if (components2.host && (options2.domainHost || schemeHandler && schemeHandler.domainHost)) {
             try {
-              components2.host = punycode.toASCII(components2.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());
+              components2.host = punycode2.toASCII(components2.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase());
             } catch (e2) {
               components2.error = components2.error || "Host's domain name can not be converted to ASCII via punycode: " + e2;
             }
@@ -5684,7 +7723,7 @@ var uri_all = { exports: {} };
           ;
         else if (options2.domainHost || schemeHandler && schemeHandler.domainHost) {
           try {
-            components2.host = !options2.iri ? punycode.toASCII(components2.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode.toUnicode(components2.host);
+            components2.host = !options2.iri ? punycode2.toASCII(components2.host.replace(protocol.PCT_ENCODED, pctDecChars).toLowerCase()) : punycode2.toUnicode(components2.host);
           } catch (e2) {
             components2.error = components2.error || "Host's domain name can not be converted to " + (!options2.iri ? "ASCII" : "Unicode") + " via punycode: " + e2;
           }
@@ -5881,12 +7920,12 @@ var uri_all = { exports: {} };
     var PCT_ENCODED$ = subexp(subexp("%[EFef]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%[89A-Fa-f]" + HEXDIG$$ + "%" + HEXDIG$$ + HEXDIG$$) + "|" + subexp("%" + HEXDIG$$ + HEXDIG$$));
     var ATEXT$$ = "[A-Za-z0-9\\!\\$\\%\\'\\*\\+\\-\\^\\_\\`\\{\\|\\}\\~]";
     var QTEXT$$ = "[\\!\\$\\%\\'\\(\\)\\*\\+\\,\\-\\.0-9\\<\\>A-Z\\x5E-\\x7E]";
-    var VCHAR$$ = merge2(QTEXT$$, '[\\"\\\\]');
+    var VCHAR$$ = merge3(QTEXT$$, '[\\"\\\\]');
     var SOME_DELIMS$$ = "[\\!\\$\\'\\(\\)\\*\\+\\,\\;\\:\\@]";
     var UNRESERVED = new RegExp(UNRESERVED$$, "g");
     var PCT_ENCODED = new RegExp(PCT_ENCODED$, "g");
-    var NOT_LOCAL_PART = new RegExp(merge2("[^]", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g");
-    var NOT_HFNAME = new RegExp(merge2("[^]", UNRESERVED$$, SOME_DELIMS$$), "g");
+    var NOT_LOCAL_PART = new RegExp(merge3("[^]", ATEXT$$, "[\\.]", '[\\"]', VCHAR$$), "g");
+    var NOT_HFNAME = new RegExp(merge3("[^]", UNRESERVED$$, SOME_DELIMS$$), "g");
     var NOT_HFVALUE = NOT_HFNAME;
     function decodeUnreserved(str2) {
       var decStr = pctDecChars(str2);
@@ -5932,7 +7971,7 @@ var uri_all = { exports: {} };
           addr[0] = unescapeComponent(addr[0]);
           if (!options2.unicodeSupport) {
             try {
-              addr[1] = punycode.toASCII(unescapeComponent(addr[1], options2).toLowerCase());
+              addr[1] = punycode2.toASCII(unescapeComponent(addr[1], options2).toLowerCase());
             } catch (e2) {
               mailtoComponents.error = mailtoComponents.error || "Email address's domain name can not be converted to ASCII via punycode: " + e2;
             }
@@ -5953,7 +7992,7 @@ var uri_all = { exports: {} };
             var localPart = toAddr.slice(0, atIdx).replace(PCT_ENCODED, decodeUnreserved).replace(PCT_ENCODED, toUpperCase).replace(NOT_LOCAL_PART, pctEncChar);
             var domain = toAddr.slice(atIdx + 1);
             try {
-              domain = !options2.iri ? punycode.toASCII(unescapeComponent(domain, options2).toLowerCase()) : punycode.toUnicode(domain);
+              domain = !options2.iri ? punycode2.toASCII(unescapeComponent(domain, options2).toLowerCase()) : punycode2.toUnicode(domain);
             } catch (e2) {
               components2.error = components2.error || "Email address's domain name can not be converted to " + (!options2.iri ? "ASCII" : "Unicode") + " via punycode: " + e2;
             }
@@ -7111,17 +9150,17 @@ const def$u = {
     function loopN(i, j2) {
       const item = gen.name("item");
       const wrongType = (0, dataType_1.checkDataTypes)(itemTypes, item, it.opts.strictNumbers, dataType_1.DataType.Wrong);
-      const indices = gen.const("indices", (0, codegen_1$i._)`{}`);
+      const indices2 = gen.const("indices", (0, codegen_1$i._)`{}`);
       gen.for((0, codegen_1$i._)`;${i}--;`, () => {
         gen.let(item, (0, codegen_1$i._)`${data}[${i}]`);
         gen.if(wrongType, (0, codegen_1$i._)`continue`);
         if (itemTypes.length > 1)
           gen.if((0, codegen_1$i._)`typeof ${item} == "string"`, (0, codegen_1$i._)`${item} += "_"`);
-        gen.if((0, codegen_1$i._)`typeof ${indices}[${item}] == "number"`, () => {
-          gen.assign(j2, (0, codegen_1$i._)`${indices}[${item}]`);
+        gen.if((0, codegen_1$i._)`typeof ${indices2}[${item}] == "number"`, () => {
+          gen.assign(j2, (0, codegen_1$i._)`${indices2}[${item}]`);
           cxt.error();
           gen.assign(valid, false).break();
-        }).code((0, codegen_1$i._)`${indices}[${item}] = ${i}`);
+        }).code((0, codegen_1$i._)`${indices2}[${item}] = ${i}`);
       });
     }
     function loopN2(i, j2) {
@@ -14710,10 +16749,10 @@ function YAMLException$6(reason, mark2) {
 }
 YAMLException$6.prototype = Object.create(Error.prototype);
 YAMLException$6.prototype.constructor = YAMLException$6;
-YAMLException$6.prototype.toString = function toString(compact) {
+YAMLException$6.prototype.toString = function toString(compact3) {
   var result = this.name + ": ";
   result += this.reason || "(unknown reason)";
-  if (!compact && this.mark) {
+  if (!compact3 && this.mark) {
     result += " " + this.mark.toString();
   }
   return result;
@@ -14756,13 +16795,13 @@ Mark$1.prototype.getSnippet = function getSnippet(indent, maxLength) {
   snippet2 = this.buffer.slice(start, end);
   return common$6.repeat(" ", indent) + head + snippet2 + tail + "\n" + common$6.repeat(" ", indent + this.position - start + head.length) + "^";
 };
-Mark$1.prototype.toString = function toString2(compact) {
+Mark$1.prototype.toString = function toString2(compact3) {
   var snippet2, where = "";
   if (this.name) {
     where += 'in "' + this.name + '" ';
   }
   where += "at line " + (this.line + 1) + ", column " + (this.column + 1);
-  if (!compact) {
+  if (!compact3) {
     snippet2 = this.getSnippet();
     if (snippet2) {
       where += ":\n" + snippet2;
@@ -15575,14 +17614,14 @@ function representJavascriptRegExp(object) {
     result += "i";
   return result;
 }
-function isRegExp(object) {
+function isRegExp2(object) {
   return Object.prototype.toString.call(object) === "[object RegExp]";
 }
 var regexp = new Type$3("tag:yaml.org,2002:js/regexp", {
   kind: "scalar",
   resolve: resolveJavascriptRegExp,
   construct: constructJavascriptRegExp,
-  predicate: isRegExp,
+  predicate: isRegExp2,
   represent: representJavascriptRegExp
 });
 var esprima;
@@ -17077,11 +19116,11 @@ function writeFlowSequence$1(state, level, object) {
   state.tag = _tag;
   state.dump = "[" + _result + "]";
 }
-function writeBlockSequence$1(state, level, object, compact) {
+function writeBlockSequence$1(state, level, object, compact3) {
   var _result = "", _tag = state.tag, index, length2;
   for (index = 0, length2 = object.length; index < length2; index += 1) {
     if (writeNode$1(state, level + 1, object[index], true, true)) {
-      if (!compact || index !== 0) {
+      if (!compact3 || index !== 0) {
         _result += generateNextLine$1(state, level);
       }
       if (state.dump && CHAR_LINE_FEED$1 === state.dump.charCodeAt(0)) {
@@ -17120,7 +19159,7 @@ function writeFlowMapping$1(state, level, object) {
   state.tag = _tag;
   state.dump = "{" + _result + "}";
 }
-function writeBlockMapping$1(state, level, object, compact) {
+function writeBlockMapping$1(state, level, object, compact3) {
   var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length2, objectKey, objectValue, explicitPair, pairBuffer;
   if (state.sortKeys === true) {
     objectKeyList.sort();
@@ -17131,7 +19170,7 @@ function writeBlockMapping$1(state, level, object, compact) {
   }
   for (index = 0, length2 = objectKeyList.length; index < length2; index += 1) {
     pairBuffer = "";
-    if (!compact || index !== 0) {
+    if (!compact3 || index !== 0) {
       pairBuffer += generateNextLine$1(state, level);
     }
     objectKey = objectKeyList[index];
@@ -17188,7 +19227,7 @@ function detectType$1(state, object, explicit) {
   }
   return false;
 }
-function writeNode$1(state, level, object, block, compact, iskey) {
+function writeNode$1(state, level, object, block, compact3, iskey) {
   state.tag = null;
   state.dump = object;
   if (!detectType$1(state, object, false)) {
@@ -17204,7 +19243,7 @@ function writeNode$1(state, level, object, block, compact, iskey) {
     duplicate = duplicateIndex !== -1;
   }
   if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
-    compact = false;
+    compact3 = false;
   }
   if (duplicate && state.usedDuplicates[duplicateIndex]) {
     state.dump = "*ref_" + duplicateIndex;
@@ -17214,7 +19253,7 @@ function writeNode$1(state, level, object, block, compact, iskey) {
     }
     if (type2 === "[object Object]") {
       if (block && Object.keys(state.dump).length !== 0) {
-        writeBlockMapping$1(state, level, state.dump, compact);
+        writeBlockMapping$1(state, level, state.dump, compact3);
         if (duplicate) {
           state.dump = "&ref_" + duplicateIndex + state.dump;
         }
@@ -17227,7 +19266,7 @@ function writeNode$1(state, level, object, block, compact, iskey) {
     } else if (type2 === "[object Array]") {
       var arrayLevel = state.noArrayIndent && level > 0 ? level - 1 : level;
       if (block && state.dump.length !== 0) {
-        writeBlockSequence$1(state, arrayLevel, state.dump, compact);
+        writeBlockSequence$1(state, arrayLevel, state.dump, compact3);
         if (duplicate) {
           state.dump = "&ref_" + duplicateIndex + state.dump;
         }
@@ -18851,7 +20890,7 @@ function extend$1(target, source) {
   }
   return target;
 }
-function repeat(string2, count) {
+function repeat2(string2, count) {
   var result = "", cycle;
   for (cycle = 0; cycle < count; cycle += 1) {
     result += string2;
@@ -18864,7 +20903,7 @@ function isNegativeZero$1(number2) {
 var isNothing_1 = isNothing;
 var isObject_1 = isObject;
 var toArray_1 = toArray;
-var repeat_1 = repeat;
+var repeat_1 = repeat2;
 var isNegativeZero_1 = isNegativeZero$1;
 var extend_1 = extend$1;
 var common = {
@@ -18875,7 +20914,7 @@ var common = {
   isNegativeZero: isNegativeZero_1,
   extend: extend_1
 };
-function formatError(exception2, compact) {
+function formatError(exception2, compact3) {
   var where = "", message = exception2.reason || "(unknown reason)";
   if (!exception2.mark)
     return message;
@@ -18883,7 +20922,7 @@ function formatError(exception2, compact) {
     where += 'in "' + exception2.mark.name + '" ';
   }
   where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")";
-  if (!compact && exception2.mark.snippet) {
+  if (!compact3 && exception2.mark.snippet) {
     where += "\n\n" + exception2.mark.snippet;
   }
   return message + " " + where;
@@ -18902,8 +20941,8 @@ function YAMLException$1(reason, mark2) {
 }
 YAMLException$1.prototype = Object.create(Error.prototype);
 YAMLException$1.prototype.constructor = YAMLException$1;
-YAMLException$1.prototype.toString = function toString3(compact) {
-  return this.name + ": " + formatError(this, compact);
+YAMLException$1.prototype.toString = function toString3(compact3) {
+  return this.name + ": " + formatError(this, compact3);
 };
 var exception = YAMLException$1;
 function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
@@ -19492,7 +21531,7 @@ var timestamp = new type("tag:yaml.org,2002:timestamp", {
 function resolveYamlMerge(data) {
   return data === "<<" || data === null;
 }
-var merge = new type("tag:yaml.org,2002:merge", {
+var merge2 = new type("tag:yaml.org,2002:merge", {
   kind: "scalar",
   resolve: resolveYamlMerge
 });
@@ -19668,7 +21707,7 @@ var set = new type("tag:yaml.org,2002:set", {
 var _default = core.extend({
   implicit: [
     timestamp,
-    merge
+    merge2
   ],
   explicit: [
     binary,
@@ -21207,7 +23246,7 @@ function writeFlowSequence(state, level, object) {
   state.tag = _tag;
   state.dump = "[" + _result + "]";
 }
-function writeBlockSequence(state, level, object, compact) {
+function writeBlockSequence(state, level, object, compact3) {
   var _result = "", _tag = state.tag, index, length2, value;
   for (index = 0, length2 = object.length; index < length2; index += 1) {
     value = object[index];
@@ -21215,7 +23254,7 @@ function writeBlockSequence(state, level, object, compact) {
       value = state.replacer.call(object, String(index), value);
     }
     if (writeNode(state, level + 1, value, true, true, false, true) || typeof value === "undefined" && writeNode(state, level + 1, null, true, true, false, true)) {
-      if (!compact || _result !== "") {
+      if (!compact3 || _result !== "") {
         _result += generateNextLine(state, level);
       }
       if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
@@ -21257,7 +23296,7 @@ function writeFlowMapping(state, level, object) {
   state.tag = _tag;
   state.dump = "{" + _result + "}";
 }
-function writeBlockMapping(state, level, object, compact) {
+function writeBlockMapping(state, level, object, compact3) {
   var _result = "", _tag = state.tag, objectKeyList = Object.keys(object), index, length2, objectKey, objectValue, explicitPair, pairBuffer;
   if (state.sortKeys === true) {
     objectKeyList.sort();
@@ -21268,7 +23307,7 @@ function writeBlockMapping(state, level, object, compact) {
   }
   for (index = 0, length2 = objectKeyList.length; index < length2; index += 1) {
     pairBuffer = "";
-    if (!compact || _result !== "") {
+    if (!compact3 || _result !== "") {
       pairBuffer += generateNextLine(state, level);
     }
     objectKey = objectKeyList[index];
@@ -21336,7 +23375,7 @@ function detectType(state, object, explicit) {
   }
   return false;
 }
-function writeNode(state, level, object, block, compact, iskey, isblockseq) {
+function writeNode(state, level, object, block, compact3, iskey, isblockseq) {
   state.tag = null;
   state.dump = object;
   if (!detectType(state, object, false)) {
@@ -21354,7 +23393,7 @@ function writeNode(state, level, object, block, compact, iskey, isblockseq) {
     duplicate = duplicateIndex !== -1;
   }
   if (state.tag !== null && state.tag !== "?" || duplicate || state.indent !== 2 && level > 0) {
-    compact = false;
+    compact3 = false;
   }
   if (duplicate && state.usedDuplicates[duplicateIndex]) {
     state.dump = "*ref_" + duplicateIndex;
@@ -21364,7 +23403,7 @@ function writeNode(state, level, object, block, compact, iskey, isblockseq) {
     }
     if (type2 === "[object Object]") {
       if (block && Object.keys(state.dump).length !== 0) {
-        writeBlockMapping(state, level, state.dump, compact);
+        writeBlockMapping(state, level, state.dump, compact3);
         if (duplicate) {
           state.dump = "&ref_" + duplicateIndex + state.dump;
         }
@@ -21377,9 +23416,9 @@ function writeNode(state, level, object, block, compact, iskey, isblockseq) {
     } else if (type2 === "[object Array]") {
       if (block && state.dump.length !== 0) {
         if (state.noArrayIndent && !isblockseq && level > 0) {
-          writeBlockSequence(state, level - 1, state.dump, compact);
+          writeBlockSequence(state, level - 1, state.dump, compact3);
         } else {
-          writeBlockSequence(state, level, state.dump, compact);
+          writeBlockSequence(state, level, state.dump, compact3);
         }
         if (duplicate) {
           state.dump = "&ref_" + duplicateIndex + state.dump;
@@ -21490,7 +23529,7 @@ var types$1 = {
   timestamp,
   bool,
   int,
-  merge,
+  merge: merge2,
   omap,
   seq,
   str
@@ -29540,13 +31579,13 @@ function checkSelection(selection, docLength) {
 }
 let nextID = 0;
 class Facet {
-  constructor(combine, compareInput, compare2, isStatic, enables) {
-    this.combine = combine;
+  constructor(combine3, compareInput, compare2, isStatic, enables) {
+    this.combine = combine3;
     this.compareInput = compareInput;
     this.compare = compare2;
     this.isStatic = isStatic;
     this.id = nextID++;
-    this.default = combine([]);
+    this.default = combine3([]);
     this.extensions = typeof enables == "function" ? enables(this) : enables;
   }
   /**
@@ -30652,7 +32691,7 @@ EditorState.changeFilter = changeFilter;
 EditorState.transactionFilter = transactionFilter;
 EditorState.transactionExtender = transactionExtender;
 Compartment.reconfigure = /* @__PURE__ */ StateEffect.define();
-function combineConfig(configs, defaults2, combine = {}) {
+function combineConfig(configs, defaults2, combine3 = {}) {
   let result = {};
   for (let config2 of configs)
     for (let key of Object.keys(config2)) {
@@ -30661,8 +32700,8 @@ function combineConfig(configs, defaults2, combine = {}) {
         result[key] = value;
       else if (current === value || value === void 0)
         ;
-      else if (Object.hasOwnProperty.call(combine, key))
-        result[key] = combine[key](current, value);
+      else if (Object.hasOwnProperty.call(combine3, key))
+        result[key] = combine3[key](current, value);
       else
         throw new Error("Config merge conflict for field " + key);
     }
@@ -33836,9 +35875,9 @@ function computeOrder(line, direction) {
       let end = i + 1;
       while (end < len && types[end] == 64)
         end++;
-      let replace = i && prev == 8 || end < len && types[end] == 8 ? prevStrong == 1 ? 1 : 8 : 256;
+      let replace2 = i && prev == 8 || end < len && types[end] == 8 ? prevStrong == 1 ? 1 : 8 : 256;
       for (let j2 = i; j2 < end; j2++)
-        types[j2] = replace;
+        types[j2] = replace2;
       i = end - 1;
     } else if (type2 == 8 && prevStrong == 1) {
       types[i] = 1;
@@ -33891,9 +35930,9 @@ function computeOrder(line, direction) {
         end++;
       let beforeL = (i ? types[i - 1] : outerType) == 1;
       let afterL = (end < len ? types[end] : outerType) == 1;
-      let replace = beforeL == afterL ? beforeL ? 1 : 2 : outerType;
+      let replace2 = beforeL == afterL ? beforeL ? 1 : 2 : outerType;
       for (let j2 = i; j2 < end; j2++)
-        types[j2] = replace;
+        types[j2] = replace2;
       i = end - 1;
     }
   }
@@ -41903,14 +43942,14 @@ function bracketMatching(config2 = {}) {
   return [bracketMatchingConfig.of(config2), bracketMatchingUnique];
 }
 const bracketMatchingHandle = /* @__PURE__ */ new NodeProp();
-function matchingNodes(node, dir, brackets) {
+function matchingNodes(node, dir, brackets2) {
   let byProp = node.prop(dir < 0 ? NodeProp.openedBy : NodeProp.closedBy);
   if (byProp)
     return byProp;
   if (node.name.length == 1) {
-    let index = brackets.indexOf(node.name);
+    let index = brackets2.indexOf(node.name);
     if (index > -1 && index % 2 == (dir < 0 ? 1 : 0))
-      return [brackets[index + dir]];
+      return [brackets2[index + dir]];
   }
   return null;
 }
@@ -41919,19 +43958,19 @@ function findHandle(node) {
   return hasHandle ? hasHandle(node.node) : node;
 }
 function matchBrackets(state, pos, dir, config2 = {}) {
-  let maxScanDistance = config2.maxScanDistance || DefaultScanDist, brackets = config2.brackets || DefaultBrackets;
+  let maxScanDistance = config2.maxScanDistance || DefaultScanDist, brackets2 = config2.brackets || DefaultBrackets;
   let tree = syntaxTree(state), node = tree.resolveInner(pos, dir);
   for (let cur2 = node; cur2; cur2 = cur2.parent) {
-    let matches = matchingNodes(cur2.type, dir, brackets);
+    let matches = matchingNodes(cur2.type, dir, brackets2);
     if (matches && cur2.from < cur2.to) {
       let handle = findHandle(cur2);
       if (handle && (dir > 0 ? pos >= handle.from && pos < handle.to : pos > handle.from && pos <= handle.to))
-        return matchMarkedBrackets(state, pos, dir, cur2, handle, matches, brackets);
+        return matchMarkedBrackets(state, pos, dir, cur2, handle, matches, brackets2);
     }
   }
-  return matchPlainBrackets(state, pos, dir, tree, node.type, maxScanDistance, brackets);
+  return matchPlainBrackets(state, pos, dir, tree, node.type, maxScanDistance, brackets2);
 }
-function matchMarkedBrackets(_state, _pos, dir, token, handle, matching, brackets) {
+function matchMarkedBrackets(_state, _pos, dir, token, handle, matching, brackets2) {
   let parent = token.parent, firstToken = { from: handle.from, to: handle.to };
   let depth = 0, cursor = parent === null || parent === void 0 ? void 0 : parent.cursor();
   if (cursor && (dir < 0 ? cursor.childBefore(token.from) : cursor.childAfter(token.to)))
@@ -41940,9 +43979,9 @@ function matchMarkedBrackets(_state, _pos, dir, token, handle, matching, bracket
         if (depth == 0 && matching.indexOf(cursor.type.name) > -1 && cursor.from < cursor.to) {
           let endHandle = findHandle(cursor);
           return { start: firstToken, end: endHandle ? { from: endHandle.from, to: endHandle.to } : void 0, matched: true };
-        } else if (matchingNodes(cursor.type, dir, brackets)) {
+        } else if (matchingNodes(cursor.type, dir, brackets2)) {
           depth++;
-        } else if (matchingNodes(cursor.type, -dir, brackets)) {
+        } else if (matchingNodes(cursor.type, -dir, brackets2)) {
           if (depth == 0) {
             let endHandle = findHandle(cursor);
             return {
@@ -41957,9 +43996,9 @@ function matchMarkedBrackets(_state, _pos, dir, token, handle, matching, bracket
     } while (dir < 0 ? cursor.prevSibling() : cursor.nextSibling());
   return { start: firstToken, matched: false };
 }
-function matchPlainBrackets(state, pos, dir, tree, tokenType, maxScanDistance, brackets) {
+function matchPlainBrackets(state, pos, dir, tree, tokenType, maxScanDistance, brackets2) {
   let startCh = dir < 0 ? state.sliceDoc(pos - 1, pos) : state.sliceDoc(pos, pos + 1);
-  let bracket2 = brackets.indexOf(startCh);
+  let bracket2 = brackets2.indexOf(startCh);
   if (bracket2 < 0 || bracket2 % 2 == 0 != dir > 0)
     return null;
   let startToken = { from: dir < 0 ? pos - 1 : pos, to: dir > 0 ? pos + 1 : pos };
@@ -41970,7 +44009,7 @@ function matchPlainBrackets(state, pos, dir, tree, tokenType, maxScanDistance, b
       distance += text2.length;
     let basePos = pos + distance * dir;
     for (let pos2 = dir > 0 ? 0 : text2.length - 1, end = dir > 0 ? text2.length : -1; pos2 != end; pos2 += dir) {
-      let found = brackets.indexOf(text2[pos2]);
+      let found = brackets2.indexOf(text2[pos2]);
       if (found < 0 || tree.resolveInner(basePos + pos2, 1).type != tokenType)
         continue;
       if (found % 2 == 0 == dir > 0) {