nikcli-remote 1.0.0

package/dist/localtunnel-XT32JGNN.js

@@ -0,0 +1,3805 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-MCKGQKYU.js";
+
+// node_modules/axios/lib/helpers/bind.js
+var require_bind = __commonJS({
+  "node_modules/axios/lib/helpers/bind.js"(exports, module) {
+    "use strict";
+    module.exports = function bind(fn, thisArg) {
+      return function wrap() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        return fn.apply(thisArg, args);
+      };
+    };
+  }
+});
+
+// node_modules/axios/lib/utils.js
+var require_utils = __commonJS({
+  "node_modules/axios/lib/utils.js"(exports, module) {
+    "use strict";
+    var bind = require_bind();
+    var toString = Object.prototype.toString;
+    function isArray(val) {
+      return toString.call(val) === "[object Array]";
+    }
+    function isUndefined(val) {
+      return typeof val === "undefined";
+    }
+    function isBuffer(val) {
+      return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+    }
+    function isArrayBuffer(val) {
+      return toString.call(val) === "[object ArrayBuffer]";
+    }
+    function isFormData(val) {
+      return typeof FormData !== "undefined" && val instanceof FormData;
+    }
+    function isArrayBufferView(val) {
+      var result;
+      if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+        result = ArrayBuffer.isView(val);
+      } else {
+        result = val && val.buffer && val.buffer instanceof ArrayBuffer;
+      }
+      return result;
+    }
+    function isString(val) {
+      return typeof val === "string";
+    }
+    function isNumber(val) {
+      return typeof val === "number";
+    }
+    function isObject(val) {
+      return val !== null && typeof val === "object";
+    }
+    function isPlainObject(val) {
+      if (toString.call(val) !== "[object Object]") {
+        return false;
+      }
+      var prototype = Object.getPrototypeOf(val);
+      return prototype === null || prototype === Object.prototype;
+    }
+    function isDate(val) {
+      return toString.call(val) === "[object Date]";
+    }
+    function isFile(val) {
+      return toString.call(val) === "[object File]";
+    }
+    function isBlob(val) {
+      return toString.call(val) === "[object Blob]";
+    }
+    function isFunction(val) {
+      return toString.call(val) === "[object Function]";
+    }
+    function isStream(val) {
+      return isObject(val) && isFunction(val.pipe);
+    }
+    function isURLSearchParams(val) {
+      return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
+    }
+    function trim(str) {
+      return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+    }
+    function isStandardBrowserEnv() {
+      if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+        return false;
+      }
+      return typeof window !== "undefined" && typeof document !== "undefined";
+    }
+    function forEach(obj, fn) {
+      if (obj === null || typeof obj === "undefined") {
+        return;
+      }
+      if (typeof obj !== "object") {
+        obj = [obj];
+      }
+      if (isArray(obj)) {
+        for (var i = 0, l = obj.length; i < l; i++) {
+          fn.call(null, obj[i], i, obj);
+        }
+      } else {
+        for (var key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            fn.call(null, obj[key], key, obj);
+          }
+        }
+      }
+    }
+    function merge() {
+      var result = {};
+      function assignValue(val, key) {
+        if (isPlainObject(result[key]) && isPlainObject(val)) {
+          result[key] = merge(result[key], val);
+        } else if (isPlainObject(val)) {
+          result[key] = merge({}, val);
+        } else if (isArray(val)) {
+          result[key] = val.slice();
+        } else {
+          result[key] = val;
+        }
+      }
+      for (var i = 0, l = arguments.length; i < l; i++) {
+        forEach(arguments[i], assignValue);
+      }
+      return result;
+    }
+    function extend(a, b, thisArg) {
+      forEach(b, function assignValue(val, key) {
+        if (thisArg && typeof val === "function") {
+          a[key] = bind(val, thisArg);
+        } else {
+          a[key] = val;
+        }
+      });
+      return a;
+    }
+    function stripBOM(content) {
+      if (content.charCodeAt(0) === 65279) {
+        content = content.slice(1);
+      }
+      return content;
+    }
+    module.exports = {
+      isArray,
+      isArrayBuffer,
+      isBuffer,
+      isFormData,
+      isArrayBufferView,
+      isString,
+      isNumber,
+      isObject,
+      isPlainObject,
+      isUndefined,
+      isDate,
+      isFile,
+      isBlob,
+      isFunction,
+      isStream,
+      isURLSearchParams,
+      isStandardBrowserEnv,
+      forEach,
+      merge,
+      extend,
+      trim,
+      stripBOM
+    };
+  }
+});
+
+// node_modules/axios/lib/helpers/buildURL.js
+var require_buildURL = __commonJS({
+  "node_modules/axios/lib/helpers/buildURL.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    function encode(val) {
+      return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+    }
+    module.exports = function buildURL(url, params, paramsSerializer) {
+      if (!params) {
+        return url;
+      }
+      var serializedParams;
+      if (paramsSerializer) {
+        serializedParams = paramsSerializer(params);
+      } else if (utils.isURLSearchParams(params)) {
+        serializedParams = params.toString();
+      } else {
+        var parts = [];
+        utils.forEach(params, function serialize(val, key) {
+          if (val === null || typeof val === "undefined") {
+            return;
+          }
+          if (utils.isArray(val)) {
+            key = key + "[]";
+          } else {
+            val = [val];
+          }
+          utils.forEach(val, function parseValue(v) {
+            if (utils.isDate(v)) {
+              v = v.toISOString();
+            } else if (utils.isObject(v)) {
+              v = JSON.stringify(v);
+            }
+            parts.push(encode(key) + "=" + encode(v));
+          });
+        });
+        serializedParams = parts.join("&");
+      }
+      if (serializedParams) {
+        var hashmarkIndex = url.indexOf("#");
+        if (hashmarkIndex !== -1) {
+          url = url.slice(0, hashmarkIndex);
+        }
+        url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+      }
+      return url;
+    };
+  }
+});
+
+// node_modules/axios/lib/core/InterceptorManager.js
+var require_InterceptorManager = __commonJS({
+  "node_modules/axios/lib/core/InterceptorManager.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    function InterceptorManager() {
+      this.handlers = [];
+    }
+    InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
+      this.handlers.push({
+        fulfilled,
+        rejected,
+        synchronous: options ? options.synchronous : false,
+        runWhen: options ? options.runWhen : null
+      });
+      return this.handlers.length - 1;
+    };
+    InterceptorManager.prototype.eject = function eject(id) {
+      if (this.handlers[id]) {
+        this.handlers[id] = null;
+      }
+    };
+    InterceptorManager.prototype.forEach = function forEach(fn) {
+      utils.forEach(this.handlers, function forEachHandler(h) {
+        if (h !== null) {
+          fn(h);
+        }
+      });
+    };
+    module.exports = InterceptorManager;
+  }
+});
+
+// node_modules/axios/lib/helpers/normalizeHeaderName.js
+var require_normalizeHeaderName = __commonJS({
+  "node_modules/axios/lib/helpers/normalizeHeaderName.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    module.exports = function normalizeHeaderName(headers, normalizedName) {
+      utils.forEach(headers, function processHeader(value, name) {
+        if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+          headers[normalizedName] = value;
+          delete headers[name];
+        }
+      });
+    };
+  }
+});
+
+// node_modules/axios/lib/core/enhanceError.js
+var require_enhanceError = __commonJS({
+  "node_modules/axios/lib/core/enhanceError.js"(exports, module) {
+    "use strict";
+    module.exports = function enhanceError(error, config, code, request, response) {
+      error.config = config;
+      if (code) {
+        error.code = code;
+      }
+      error.request = request;
+      error.response = response;
+      error.isAxiosError = true;
+      error.toJSON = function toJSON() {
+        return {
+          // Standard
+          message: this.message,
+          name: this.name,
+          // Microsoft
+          description: this.description,
+          number: this.number,
+          // Mozilla
+          fileName: this.fileName,
+          lineNumber: this.lineNumber,
+          columnNumber: this.columnNumber,
+          stack: this.stack,
+          // Axios
+          config: this.config,
+          code: this.code
+        };
+      };
+      return error;
+    };
+  }
+});
+
+// node_modules/axios/lib/core/createError.js
+var require_createError = __commonJS({
+  "node_modules/axios/lib/core/createError.js"(exports, module) {
+    "use strict";
+    var enhanceError = require_enhanceError();
+    module.exports = function createError(message, config, code, request, response) {
+      var error = new Error(message);
+      return enhanceError(error, config, code, request, response);
+    };
+  }
+});
+
+// node_modules/axios/lib/core/settle.js
+var require_settle = __commonJS({
+  "node_modules/axios/lib/core/settle.js"(exports, module) {
+    "use strict";
+    var createError = require_createError();
+    module.exports = function settle(resolve, reject, response) {
+      var validateStatus = response.config.validateStatus;
+      if (!response.status || !validateStatus || validateStatus(response.status)) {
+        resolve(response);
+      } else {
+        reject(createError(
+          "Request failed with status code " + response.status,
+          response.config,
+          null,
+          response.request,
+          response
+        ));
+      }
+    };
+  }
+});
+
+// node_modules/axios/lib/helpers/cookies.js
+var require_cookies = __commonJS({
+  "node_modules/axios/lib/helpers/cookies.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    module.exports = utils.isStandardBrowserEnv() ? (
+      // Standard browser envs support document.cookie
+      /* @__PURE__ */ (function standardBrowserEnv() {
+        return {
+          write: function write(name, value, expires, path, domain, secure) {
+            var cookie = [];
+            cookie.push(name + "=" + encodeURIComponent(value));
+            if (utils.isNumber(expires)) {
+              cookie.push("expires=" + new Date(expires).toGMTString());
+            }
+            if (utils.isString(path)) {
+              cookie.push("path=" + path);
+            }
+            if (utils.isString(domain)) {
+              cookie.push("domain=" + domain);
+            }
+            if (secure === true) {
+              cookie.push("secure");
+            }
+            document.cookie = cookie.join("; ");
+          },
+          read: function read(name) {
+            var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
+            return match ? decodeURIComponent(match[3]) : null;
+          },
+          remove: function remove(name) {
+            this.write(name, "", Date.now() - 864e5);
+          }
+        };
+      })()
+    ) : (
+      // Non standard browser env (web workers, react-native) lack needed support.
+      /* @__PURE__ */ (function nonStandardBrowserEnv() {
+        return {
+          write: function write() {
+          },
+          read: function read() {
+            return null;
+          },
+          remove: function remove() {
+          }
+        };
+      })()
+    );
+  }
+});
+
+// node_modules/axios/lib/helpers/isAbsoluteURL.js
+var require_isAbsoluteURL = __commonJS({
+  "node_modules/axios/lib/helpers/isAbsoluteURL.js"(exports, module) {
+    "use strict";
+    module.exports = function isAbsoluteURL(url) {
+      return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+    };
+  }
+});
+
+// node_modules/axios/lib/helpers/combineURLs.js
+var require_combineURLs = __commonJS({
+  "node_modules/axios/lib/helpers/combineURLs.js"(exports, module) {
+    "use strict";
+    module.exports = function combineURLs(baseURL, relativeURL) {
+      return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+    };
+  }
+});
+
+// node_modules/axios/lib/core/buildFullPath.js
+var require_buildFullPath = __commonJS({
+  "node_modules/axios/lib/core/buildFullPath.js"(exports, module) {
+    "use strict";
+    var isAbsoluteURL = require_isAbsoluteURL();
+    var combineURLs = require_combineURLs();
+    module.exports = function buildFullPath(baseURL, requestedURL) {
+      if (baseURL && !isAbsoluteURL(requestedURL)) {
+        return combineURLs(baseURL, requestedURL);
+      }
+      return requestedURL;
+    };
+  }
+});
+
+// node_modules/axios/lib/helpers/parseHeaders.js
+var require_parseHeaders = __commonJS({
+  "node_modules/axios/lib/helpers/parseHeaders.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var ignoreDuplicateOf = [
+      "age",
+      "authorization",
+      "content-length",
+      "content-type",
+      "etag",
+      "expires",
+      "from",
+      "host",
+      "if-modified-since",
+      "if-unmodified-since",
+      "last-modified",
+      "location",
+      "max-forwards",
+      "proxy-authorization",
+      "referer",
+      "retry-after",
+      "user-agent"
+    ];
+    module.exports = function parseHeaders(headers) {
+      var parsed = {};
+      var key;
+      var val;
+      var i;
+      if (!headers) {
+        return parsed;
+      }
+      utils.forEach(headers.split("\n"), function parser(line) {
+        i = line.indexOf(":");
+        key = utils.trim(line.substr(0, i)).toLowerCase();
+        val = utils.trim(line.substr(i + 1));
+        if (key) {
+          if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+            return;
+          }
+          if (key === "set-cookie") {
+            parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+          } else {
+            parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+          }
+        }
+      });
+      return parsed;
+    };
+  }
+});
+
+// node_modules/axios/lib/helpers/isURLSameOrigin.js
+var require_isURLSameOrigin = __commonJS({
+  "node_modules/axios/lib/helpers/isURLSameOrigin.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    module.exports = utils.isStandardBrowserEnv() ? (
+      // Standard browser envs have full support of the APIs needed to test
+      // whether the request URL is of the same origin as current location.
+      (function standardBrowserEnv() {
+        var msie = /(msie|trident)/i.test(navigator.userAgent);
+        var urlParsingNode = document.createElement("a");
+        var originURL;
+        function resolveURL(url) {
+          var href = url;
+          if (msie) {
+            urlParsingNode.setAttribute("href", href);
+            href = urlParsingNode.href;
+          }
+          urlParsingNode.setAttribute("href", href);
+          return {
+            href: urlParsingNode.href,
+            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
+            host: urlParsingNode.host,
+            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
+            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
+            hostname: urlParsingNode.hostname,
+            port: urlParsingNode.port,
+            pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
+          };
+        }
+        originURL = resolveURL(window.location.href);
+        return function isURLSameOrigin(requestURL) {
+          var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+          return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+        };
+      })()
+    ) : (
+      // Non standard browser envs (web workers, react-native) lack needed support.
+      /* @__PURE__ */ (function nonStandardBrowserEnv() {
+        return function isURLSameOrigin() {
+          return true;
+        };
+      })()
+    );
+  }
+});
+
+// node_modules/axios/lib/adapters/xhr.js
+var require_xhr = __commonJS({
+  "node_modules/axios/lib/adapters/xhr.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var settle = require_settle();
+    var cookies = require_cookies();
+    var buildURL = require_buildURL();
+    var buildFullPath = require_buildFullPath();
+    var parseHeaders = require_parseHeaders();
+    var isURLSameOrigin = require_isURLSameOrigin();
+    var createError = require_createError();
+    module.exports = function xhrAdapter(config) {
+      return new Promise(function dispatchXhrRequest(resolve, reject) {
+        var requestData = config.data;
+        var requestHeaders = config.headers;
+        var responseType = config.responseType;
+        if (utils.isFormData(requestData)) {
+          delete requestHeaders["Content-Type"];
+        }
+        var request = new XMLHttpRequest();
+        if (config.auth) {
+          var username = config.auth.username || "";
+          var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
+          requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
+        }
+        var fullPath = buildFullPath(config.baseURL, config.url);
+        request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+        request.timeout = config.timeout;
+        function onloadend() {
+          if (!request) {
+            return;
+          }
+          var responseHeaders = "getAllResponseHeaders" in request ? parseHeaders(request.getAllResponseHeaders()) : null;
+          var responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
+          var response = {
+            data: responseData,
+            status: request.status,
+            statusText: request.statusText,
+            headers: responseHeaders,
+            config,
+            request
+          };
+          settle(resolve, reject, response);
+          request = null;
+        }
+        if ("onloadend" in request) {
+          request.onloadend = onloadend;
+        } else {
+          request.onreadystatechange = function handleLoad() {
+            if (!request || request.readyState !== 4) {
+              return;
+            }
+            if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
+              return;
+            }
+            setTimeout(onloadend);
+          };
+        }
+        request.onabort = function handleAbort() {
+          if (!request) {
+            return;
+          }
+          reject(createError("Request aborted", config, "ECONNABORTED", request));
+          request = null;
+        };
+        request.onerror = function handleError() {
+          reject(createError("Network Error", config, null, request));
+          request = null;
+        };
+        request.ontimeout = function handleTimeout() {
+          var timeoutErrorMessage = "timeout of " + config.timeout + "ms exceeded";
+          if (config.timeoutErrorMessage) {
+            timeoutErrorMessage = config.timeoutErrorMessage;
+          }
+          reject(createError(
+            timeoutErrorMessage,
+            config,
+            config.transitional && config.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED",
+            request
+          ));
+          request = null;
+        };
+        if (utils.isStandardBrowserEnv()) {
+          var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
+          if (xsrfValue) {
+            requestHeaders[config.xsrfHeaderName] = xsrfValue;
+          }
+        }
+        if ("setRequestHeader" in request) {
+          utils.forEach(requestHeaders, function setRequestHeader(val, key) {
+            if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+              delete requestHeaders[key];
+            } else {
+              request.setRequestHeader(key, val);
+            }
+          });
+        }
+        if (!utils.isUndefined(config.withCredentials)) {
+          request.withCredentials = !!config.withCredentials;
+        }
+        if (responseType && responseType !== "json") {
+          request.responseType = config.responseType;
+        }
+        if (typeof config.onDownloadProgress === "function") {
+          request.addEventListener("progress", config.onDownloadProgress);
+        }
+        if (typeof config.onUploadProgress === "function" && request.upload) {
+          request.upload.addEventListener("progress", config.onUploadProgress);
+        }
+        if (config.cancelToken) {
+          config.cancelToken.promise.then(function onCanceled(cancel) {
+            if (!request) {
+              return;
+            }
+            request.abort();
+            reject(cancel);
+            request = null;
+          });
+        }
+        if (!requestData) {
+          requestData = null;
+        }
+        request.send(requestData);
+      });
+    };
+  }
+});
+
+// node_modules/ms/index.js
+var require_ms = __commonJS({
+  "node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// node_modules/debug/src/common.js
+var require_common = __commonJS({
+  "node_modules/debug/src/common.js"(exports, module) {
+    "use strict";
+    function setup(env) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug[key] = env[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self, args);
+          const logFn = self.log || createDebug.log;
+          logFn.apply(self, args);
+        }
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug);
+        }
+        return debug;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
+        for (const ns of split) {
+          if (ns[0] === "-") {
+            createDebug.skips.push(ns.slice(1));
+          } else {
+            createDebug.names.push(ns);
+          }
+        }
+      }
+      function matchesTemplate(search, template) {
+        let searchIndex = 0;
+        let templateIndex = 0;
+        let starIndex = -1;
+        let matchIndex = 0;
+        while (searchIndex < search.length) {
+          if (templateIndex < template.length && (template[templateIndex] === search[searchIndex] || template[templateIndex] === "*")) {
+            if (template[templateIndex] === "*") {
+              starIndex = templateIndex;
+              matchIndex = searchIndex;
+              templateIndex++;
+            } else {
+              searchIndex++;
+              templateIndex++;
+            }
+          } else if (starIndex !== -1) {
+            templateIndex = starIndex + 1;
+            matchIndex++;
+            searchIndex = matchIndex;
+          } else {
+            return false;
+          }
+        }
+        while (templateIndex < template.length && template[templateIndex] === "*") {
+          templateIndex++;
+        }
+        return templateIndex === template.length;
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names,
+          ...createDebug.skips.map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        for (const skip of createDebug.skips) {
+          if (matchesTemplate(name, skip)) {
+            return false;
+          }
+        }
+        for (const ns of createDebug.names) {
+          if (matchesTemplate(name, ns)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module.exports = setup;
+  }
+});
+
+// node_modules/debug/src/browser.js
+var require_browser = __commonJS({
+  "node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      let m;
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && (m = navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/)) && parseInt(m[1], 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// ../../node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    module.exports = (flag, argv = process.argv) => {
+      const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+      const position = argv.indexOf(prefix + flag);
+      const terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+// ../../node_modules/supports-color/index.js
+var require_supports_color = __commonJS({
+  "../../node_modules/supports-color/index.js"(exports, module) {
+    "use strict";
+    var os = __require("os");
+    var tty = __require("tty");
+    var hasFlag = require_has_flag();
+    var { env } = process;
+    var forceColor;
+    if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+      forceColor = 0;
+    } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+      forceColor = 1;
+    }
+    if ("FORCE_COLOR" in env) {
+      if (env.FORCE_COLOR === "true") {
+        forceColor = 1;
+      } else if (env.FORCE_COLOR === "false") {
+        forceColor = 0;
+      } else {
+        forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+      }
+    }
+    function translateLevel(level) {
+      if (level === 0) {
+        return false;
+      }
+      return {
+        level,
+        hasBasic: true,
+        has256: level >= 2,
+        has16m: level >= 3
+      };
+    }
+    function supportsColor(haveStream, streamIsTTY) {
+      if (forceColor === 0) {
+        return 0;
+      }
+      if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+        return 3;
+      }
+      if (hasFlag("color=256")) {
+        return 2;
+      }
+      if (haveStream && !streamIsTTY && forceColor === void 0) {
+        return 0;
+      }
+      const min = forceColor || 0;
+      if (env.TERM === "dumb") {
+        return min;
+      }
+      if (process.platform === "win32") {
+        const osRelease = os.release().split(".");
+        if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+          return Number(osRelease[2]) >= 14931 ? 3 : 2;
+        }
+        return 1;
+      }
+      if ("CI" in env) {
+        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+          return 1;
+        }
+        return min;
+      }
+      if ("TEAMCITY_VERSION" in env) {
+        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+      }
+      if (env.COLORTERM === "truecolor") {
+        return 3;
+      }
+      if ("TERM_PROGRAM" in env) {
+        const version = parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+        switch (env.TERM_PROGRAM) {
+          case "iTerm.app":
+            return version >= 3 ? 3 : 2;
+          case "Apple_Terminal":
+            return 2;
+        }
+      }
+      if (/-256(color)?$/i.test(env.TERM)) {
+        return 2;
+      }
+      if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+        return 1;
+      }
+      if ("COLORTERM" in env) {
+        return 1;
+      }
+      return min;
+    }
+    function getSupportLevel(stream) {
+      const level = supportsColor(stream, stream && stream.isTTY);
+      return translateLevel(level);
+    }
+    module.exports = {
+      supportsColor: getSupportLevel,
+      stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+      stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+    };
+  }
+});
+
+// node_modules/debug/src/node.js
+var require_node = __commonJS({
+  "node_modules/debug/src/node.js"(exports, module) {
+    "use strict";
+    var tty = __require("tty");
+    var util = __require("util");
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = require_supports_color();
+      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error) {
+    }
+    exports.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug) {
+      debug.inspectOpts = {};
+      const keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = require_common()(exports);
+    var { formatters } = module.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// node_modules/debug/src/index.js
+var require_src = __commonJS({
+  "node_modules/debug/src/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module.exports = require_browser();
+    } else {
+      module.exports = require_node();
+    }
+  }
+});
+
+// node_modules/follow-redirects/debug.js
+var require_debug = __commonJS({
+  "node_modules/follow-redirects/debug.js"(exports, module) {
+    "use strict";
+    var debug;
+    module.exports = function() {
+      if (!debug) {
+        try {
+          debug = require_src()("follow-redirects");
+        } catch (error) {
+        }
+        if (typeof debug !== "function") {
+          debug = function() {
+          };
+        }
+      }
+      debug.apply(null, arguments);
+    };
+  }
+});
+
+// node_modules/follow-redirects/index.js
+var require_follow_redirects = __commonJS({
+  "node_modules/follow-redirects/index.js"(exports, module) {
+    "use strict";
+    var url = __require("url");
+    var URL = url.URL;
+    var http = __require("http");
+    var https = __require("https");
+    var Writable = __require("stream").Writable;
+    var assert = __require("assert");
+    var debug = require_debug();
+    (function detectUnsupportedEnvironment() {
+      var looksLikeNode = typeof process !== "undefined";
+      var looksLikeBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+      var looksLikeV8 = isFunction(Error.captureStackTrace);
+      if (!looksLikeNode && (looksLikeBrowser || !looksLikeV8)) {
+        console.warn("The follow-redirects package should be excluded from browser builds.");
+      }
+    })();
+    var useNativeURL = false;
+    try {
+      assert(new URL(""));
+    } catch (error) {
+      useNativeURL = error.code === "ERR_INVALID_URL";
+    }
+    var preservedUrlFields = [
+      "auth",
+      "host",
+      "hostname",
+      "href",
+      "path",
+      "pathname",
+      "port",
+      "protocol",
+      "query",
+      "search",
+      "hash"
+    ];
+    var events = ["abort", "aborted", "connect", "error", "socket", "timeout"];
+    var eventHandlers = /* @__PURE__ */ Object.create(null);
+    events.forEach(function(event) {
+      eventHandlers[event] = function(arg1, arg2, arg3) {
+        this._redirectable.emit(event, arg1, arg2, arg3);
+      };
+    });
+    var InvalidUrlError = createErrorType(
+      "ERR_INVALID_URL",
+      "Invalid URL",
+      TypeError
+    );
+    var RedirectionError = createErrorType(
+      "ERR_FR_REDIRECTION_FAILURE",
+      "Redirected request failed"
+    );
+    var TooManyRedirectsError = createErrorType(
+      "ERR_FR_TOO_MANY_REDIRECTS",
+      "Maximum number of redirects exceeded",
+      RedirectionError
+    );
+    var MaxBodyLengthExceededError = createErrorType(
+      "ERR_FR_MAX_BODY_LENGTH_EXCEEDED",
+      "Request body larger than maxBodyLength limit"
+    );
+    var WriteAfterEndError = createErrorType(
+      "ERR_STREAM_WRITE_AFTER_END",
+      "write after end"
+    );
+    var destroy = Writable.prototype.destroy || noop;
+    function RedirectableRequest(options, responseCallback) {
+      Writable.call(this);
+      this._sanitizeOptions(options);
+      this._options = options;
+      this._ended = false;
+      this._ending = false;
+      this._redirectCount = 0;
+      this._redirects = [];
+      this._requestBodyLength = 0;
+      this._requestBodyBuffers = [];
+      if (responseCallback) {
+        this.on("response", responseCallback);
+      }
+      var self = this;
+      this._onNativeResponse = function(response) {
+        try {
+          self._processResponse(response);
+        } catch (cause) {
+          self.emit("error", cause instanceof RedirectionError ? cause : new RedirectionError({ cause }));
+        }
+      };
+      this._performRequest();
+    }
+    RedirectableRequest.prototype = Object.create(Writable.prototype);
+    RedirectableRequest.prototype.abort = function() {
+      destroyRequest(this._currentRequest);
+      this._currentRequest.abort();
+      this.emit("abort");
+    };
+    RedirectableRequest.prototype.destroy = function(error) {
+      destroyRequest(this._currentRequest, error);
+      destroy.call(this, error);
+      return this;
+    };
+    RedirectableRequest.prototype.write = function(data, encoding, callback) {
+      if (this._ending) {
+        throw new WriteAfterEndError();
+      }
+      if (!isString(data) && !isBuffer(data)) {
+        throw new TypeError("data should be a string, Buffer or Uint8Array");
+      }
+      if (isFunction(encoding)) {
+        callback = encoding;
+        encoding = null;
+      }
+      if (data.length === 0) {
+        if (callback) {
+          callback();
+        }
+        return;
+      }
+      if (this._requestBodyLength + data.length <= this._options.maxBodyLength) {
+        this._requestBodyLength += data.length;
+        this._requestBodyBuffers.push({ data, encoding });
+        this._currentRequest.write(data, encoding, callback);
+      } else {
+        this.emit("error", new MaxBodyLengthExceededError());
+        this.abort();
+      }
+    };
+    RedirectableRequest.prototype.end = function(data, encoding, callback) {
+      if (isFunction(data)) {
+        callback = data;
+        data = encoding = null;
+      } else if (isFunction(encoding)) {
+        callback = encoding;
+        encoding = null;
+      }
+      if (!data) {
+        this._ended = this._ending = true;
+        this._currentRequest.end(null, null, callback);
+      } else {
+        var self = this;
+        var currentRequest = this._currentRequest;
+        this.write(data, encoding, function() {
+          self._ended = true;
+          currentRequest.end(null, null, callback);
+        });
+        this._ending = true;
+      }
+    };
+    RedirectableRequest.prototype.setHeader = function(name, value) {
+      this._options.headers[name] = value;
+      this._currentRequest.setHeader(name, value);
+    };
+    RedirectableRequest.prototype.removeHeader = function(name) {
+      delete this._options.headers[name];
+      this._currentRequest.removeHeader(name);
+    };
+    RedirectableRequest.prototype.setTimeout = function(msecs, callback) {
+      var self = this;
+      function destroyOnTimeout(socket) {
+        socket.setTimeout(msecs);
+        socket.removeListener("timeout", socket.destroy);
+        socket.addListener("timeout", socket.destroy);
+      }
+      function startTimer(socket) {
+        if (self._timeout) {
+          clearTimeout(self._timeout);
+        }
+        self._timeout = setTimeout(function() {
+          self.emit("timeout");
+          clearTimer();
+        }, msecs);
+        destroyOnTimeout(socket);
+      }
+      function clearTimer() {
+        if (self._timeout) {
+          clearTimeout(self._timeout);
+          self._timeout = null;
+        }
+        self.removeListener("abort", clearTimer);
+        self.removeListener("error", clearTimer);
+        self.removeListener("response", clearTimer);
+        self.removeListener("close", clearTimer);
+        if (callback) {
+          self.removeListener("timeout", callback);
+        }
+        if (!self.socket) {
+          self._currentRequest.removeListener("socket", startTimer);
+        }
+      }
+      if (callback) {
+        this.on("timeout", callback);
+      }
+      if (this.socket) {
+        startTimer(this.socket);
+      } else {
+        this._currentRequest.once("socket", startTimer);
+      }
+      this.on("socket", destroyOnTimeout);
+      this.on("abort", clearTimer);
+      this.on("error", clearTimer);
+      this.on("response", clearTimer);
+      this.on("close", clearTimer);
+      return this;
+    };
+    [
+      "flushHeaders",
+      "getHeader",
+      "setNoDelay",
+      "setSocketKeepAlive"
+    ].forEach(function(method) {
+      RedirectableRequest.prototype[method] = function(a, b) {
+        return this._currentRequest[method](a, b);
+      };
+    });
+    ["aborted", "connection", "socket"].forEach(function(property) {
+      Object.defineProperty(RedirectableRequest.prototype, property, {
+        get: function() {
+          return this._currentRequest[property];
+        }
+      });
+    });
+    RedirectableRequest.prototype._sanitizeOptions = function(options) {
+      if (!options.headers) {
+        options.headers = {};
+      }
+      if (options.host) {
+        if (!options.hostname) {
+          options.hostname = options.host;
+        }
+        delete options.host;
+      }
+      if (!options.pathname && options.path) {
+        var searchPos = options.path.indexOf("?");
+        if (searchPos < 0) {
+          options.pathname = options.path;
+        } else {
+          options.pathname = options.path.substring(0, searchPos);
+          options.search = options.path.substring(searchPos);
+        }
+      }
+    };
+    RedirectableRequest.prototype._performRequest = function() {
+      var protocol = this._options.protocol;
+      var nativeProtocol = this._options.nativeProtocols[protocol];
+      if (!nativeProtocol) {
+        throw new TypeError("Unsupported protocol " + protocol);
+      }
+      if (this._options.agents) {
+        var scheme = protocol.slice(0, -1);
+        this._options.agent = this._options.agents[scheme];
+      }
+      var request = this._currentRequest = nativeProtocol.request(this._options, this._onNativeResponse);
+      request._redirectable = this;
+      for (var event of events) {
+        request.on(event, eventHandlers[event]);
+      }
+      this._currentUrl = /^\//.test(this._options.path) ? url.format(this._options) : (
+        // When making a request to a proxy, […]
+        // a client MUST send the target URI in absolute-form […].
+        this._options.path
+      );
+      if (this._isRedirect) {
+        var i = 0;
+        var self = this;
+        var buffers = this._requestBodyBuffers;
+        (function writeNext(error) {
+          if (request === self._currentRequest) {
+            if (error) {
+              self.emit("error", error);
+            } else if (i < buffers.length) {
+              var buffer = buffers[i++];
+              if (!request.finished) {
+                request.write(buffer.data, buffer.encoding, writeNext);
+              }
+            } else if (self._ended) {
+              request.end();
+            }
+          }
+        })();
+      }
+    };
+    RedirectableRequest.prototype._processResponse = function(response) {
+      var statusCode = response.statusCode;
+      if (this._options.trackRedirects) {
+        this._redirects.push({
+          url: this._currentUrl,
+          headers: response.headers,
+          statusCode
+        });
+      }
+      var location = response.headers.location;
+      if (!location || this._options.followRedirects === false || statusCode < 300 || statusCode >= 400) {
+        response.responseUrl = this._currentUrl;
+        response.redirects = this._redirects;
+        this.emit("response", response);
+        this._requestBodyBuffers = [];
+        return;
+      }
+      destroyRequest(this._currentRequest);
+      response.destroy();
+      if (++this._redirectCount > this._options.maxRedirects) {
+        throw new TooManyRedirectsError();
+      }
+      var requestHeaders;
+      var beforeRedirect = this._options.beforeRedirect;
+      if (beforeRedirect) {
+        requestHeaders = Object.assign({
+          // The Host header was set by nativeProtocol.request
+          Host: response.req.getHeader("host")
+        }, this._options.headers);
+      }
+      var method = this._options.method;
+      if ((statusCode === 301 || statusCode === 302) && this._options.method === "POST" || // RFC7231§6.4.4: The 303 (See Other) status code indicates that
+      // the server is redirecting the user agent to a different resource […]
+      // A user agent can perform a retrieval request targeting that URI
+      // (a GET or HEAD request if using HTTP) […]
+      statusCode === 303 && !/^(?:GET|HEAD)$/.test(this._options.method)) {
+        this._options.method = "GET";
+        this._requestBodyBuffers = [];
+        removeMatchingHeaders(/^content-/i, this._options.headers);
+      }
+      var currentHostHeader = removeMatchingHeaders(/^host$/i, this._options.headers);
+      var currentUrlParts = parseUrl(this._currentUrl);
+      var currentHost = currentHostHeader || currentUrlParts.host;
+      var currentUrl = /^\w+:/.test(location) ? this._currentUrl : url.format(Object.assign(currentUrlParts, { host: currentHost }));
+      var redirectUrl = resolveUrl(location, currentUrl);
+      debug("redirecting to", redirectUrl.href);
+      this._isRedirect = true;
+      spreadUrlObject(redirectUrl, this._options);
+      if (redirectUrl.protocol !== currentUrlParts.protocol && redirectUrl.protocol !== "https:" || redirectUrl.host !== currentHost && !isSubdomain(redirectUrl.host, currentHost)) {
+        removeMatchingHeaders(/^(?:(?:proxy-)?authorization|cookie)$/i, this._options.headers);
+      }
+      if (isFunction(beforeRedirect)) {
+        var responseDetails = {
+          headers: response.headers,
+          statusCode
+        };
+        var requestDetails = {
+          url: currentUrl,
+          method,
+          headers: requestHeaders
+        };
+        beforeRedirect(this._options, responseDetails, requestDetails);
+        this._sanitizeOptions(this._options);
+      }
+      this._performRequest();
+    };
+    function wrap(protocols) {
+      var exports2 = {
+        maxRedirects: 21,
+        maxBodyLength: 10 * 1024 * 1024
+      };
+      var nativeProtocols = {};
+      Object.keys(protocols).forEach(function(scheme) {
+        var protocol = scheme + ":";
+        var nativeProtocol = nativeProtocols[protocol] = protocols[scheme];
+        var wrappedProtocol = exports2[scheme] = Object.create(nativeProtocol);
+        function request(input, options, callback) {
+          if (isURL(input)) {
+            input = spreadUrlObject(input);
+          } else if (isString(input)) {
+            input = spreadUrlObject(parseUrl(input));
+          } else {
+            callback = options;
+            options = validateUrl(input);
+            input = { protocol };
+          }
+          if (isFunction(options)) {
+            callback = options;
+            options = null;
+          }
+          options = Object.assign({
+            maxRedirects: exports2.maxRedirects,
+            maxBodyLength: exports2.maxBodyLength
+          }, input, options);
+          options.nativeProtocols = nativeProtocols;
+          if (!isString(options.host) && !isString(options.hostname)) {
+            options.hostname = "::1";
+          }
+          assert.equal(options.protocol, protocol, "protocol mismatch");
+          debug("options", options);
+          return new RedirectableRequest(options, callback);
+        }
+        function get(input, options, callback) {
+          var wrappedRequest = wrappedProtocol.request(input, options, callback);
+          wrappedRequest.end();
+          return wrappedRequest;
+        }
+        Object.defineProperties(wrappedProtocol, {
+          request: { value: request, configurable: true, enumerable: true, writable: true },
+          get: { value: get, configurable: true, enumerable: true, writable: true }
+        });
+      });
+      return exports2;
+    }
+    function noop() {
+    }
+    function parseUrl(input) {
+      var parsed;
+      if (useNativeURL) {
+        parsed = new URL(input);
+      } else {
+        parsed = validateUrl(url.parse(input));
+        if (!isString(parsed.protocol)) {
+          throw new InvalidUrlError({ input });
+        }
+      }
+      return parsed;
+    }
+    function resolveUrl(relative, base) {
+      return useNativeURL ? new URL(relative, base) : parseUrl(url.resolve(base, relative));
+    }
+    function validateUrl(input) {
+      if (/^\[/.test(input.hostname) && !/^\[[:0-9a-f]+\]$/i.test(input.hostname)) {
+        throw new InvalidUrlError({ input: input.href || input });
+      }
+      if (/^\[/.test(input.host) && !/^\[[:0-9a-f]+\](:\d+)?$/i.test(input.host)) {
+        throw new InvalidUrlError({ input: input.href || input });
+      }
+      return input;
+    }
+    function spreadUrlObject(urlObject, target) {
+      var spread = target || {};
+      for (var key of preservedUrlFields) {
+        spread[key] = urlObject[key];
+      }
+      if (spread.hostname.startsWith("[")) {
+        spread.hostname = spread.hostname.slice(1, -1);
+      }
+      if (spread.port !== "") {
+        spread.port = Number(spread.port);
+      }
+      spread.path = spread.search ? spread.pathname + spread.search : spread.pathname;
+      return spread;
+    }
+    function removeMatchingHeaders(regex, headers) {
+      var lastValue;
+      for (var header in headers) {
+        if (regex.test(header)) {
+          lastValue = headers[header];
+          delete headers[header];
+        }
+      }
+      return lastValue === null || typeof lastValue === "undefined" ? void 0 : String(lastValue).trim();
+    }
+    function createErrorType(code, message, baseClass) {
+      function CustomError(properties) {
+        if (isFunction(Error.captureStackTrace)) {
+          Error.captureStackTrace(this, this.constructor);
+        }
+        Object.assign(this, properties || {});
+        this.code = code;
+        this.message = this.cause ? message + ": " + this.cause.message : message;
+      }
+      CustomError.prototype = new (baseClass || Error)();
+      Object.defineProperties(CustomError.prototype, {
+        constructor: {
+          value: CustomError,
+          enumerable: false
+        },
+        name: {
+          value: "Error [" + code + "]",
+          enumerable: false
+        }
+      });
+      return CustomError;
+    }
+    function destroyRequest(request, error) {
+      for (var event of events) {
+        request.removeListener(event, eventHandlers[event]);
+      }
+      request.on("error", noop);
+      request.destroy(error);
+    }
+    function isSubdomain(subdomain, domain) {
+      assert(isString(subdomain) && isString(domain));
+      var dot = subdomain.length - domain.length - 1;
+      return dot > 0 && subdomain[dot] === "." && subdomain.endsWith(domain);
+    }
+    function isString(value) {
+      return typeof value === "string" || value instanceof String;
+    }
+    function isFunction(value) {
+      return typeof value === "function";
+    }
+    function isBuffer(value) {
+      return typeof value === "object" && "length" in value;
+    }
+    function isURL(value) {
+      return URL && value instanceof URL;
+    }
+    module.exports = wrap({ http, https });
+    module.exports.wrap = wrap;
+  }
+});
+
+// node_modules/axios/package.json
+var require_package = __commonJS({
+  "node_modules/axios/package.json"(exports, module) {
+    module.exports = {
+      name: "axios",
+      version: "0.21.4",
+      description: "Promise based HTTP client for the browser and node.js",
+      main: "index.js",
+      scripts: {
+        test: "grunt test",
+        start: "node ./sandbox/server.js",
+        build: "NODE_ENV=production grunt build",
+        preversion: "npm test",
+        version: "npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json",
+        postversion: "git push && git push --tags",
+        examples: "node ./examples/server.js",
+        coveralls: "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
+        fix: "eslint --fix lib/**/*.js"
+      },
+      repository: {
+        type: "git",
+        url: "https://github.com/axios/axios.git"
+      },
+      keywords: [
+        "xhr",
+        "http",
+        "ajax",
+        "promise",
+        "node"
+      ],
+      author: "Matt Zabriskie",
+      license: "MIT",
+      bugs: {
+        url: "https://github.com/axios/axios/issues"
+      },
+      homepage: "https://axios-http.com",
+      devDependencies: {
+        coveralls: "^3.0.0",
+        "es6-promise": "^4.2.4",
+        grunt: "^1.3.0",
+        "grunt-banner": "^0.6.0",
+        "grunt-cli": "^1.2.0",
+        "grunt-contrib-clean": "^1.1.0",
+        "grunt-contrib-watch": "^1.0.0",
+        "grunt-eslint": "^23.0.0",
+        "grunt-karma": "^4.0.0",
+        "grunt-mocha-test": "^0.13.3",
+        "grunt-ts": "^6.0.0-beta.19",
+        "grunt-webpack": "^4.0.2",
+        "istanbul-instrumenter-loader": "^1.0.0",
+        "jasmine-core": "^2.4.1",
+        karma: "^6.3.2",
+        "karma-chrome-launcher": "^3.1.0",
+        "karma-firefox-launcher": "^2.1.0",
+        "karma-jasmine": "^1.1.1",
+        "karma-jasmine-ajax": "^0.1.13",
+        "karma-safari-launcher": "^1.0.0",
+        "karma-sauce-launcher": "^4.3.6",
+        "karma-sinon": "^1.0.5",
+        "karma-sourcemap-loader": "^0.3.8",
+        "karma-webpack": "^4.0.2",
+        "load-grunt-tasks": "^3.5.2",
+        minimist: "^1.2.0",
+        mocha: "^8.2.1",
+        sinon: "^4.5.0",
+        "terser-webpack-plugin": "^4.2.3",
+        typescript: "^4.0.5",
+        "url-search-params": "^0.10.0",
+        webpack: "^4.44.2",
+        "webpack-dev-server": "^3.11.0"
+      },
+      browser: {
+        "./lib/adapters/http.js": "./lib/adapters/xhr.js"
+      },
+      jsdelivr: "dist/axios.min.js",
+      unpkg: "dist/axios.min.js",
+      typings: "./index.d.ts",
+      dependencies: {
+        "follow-redirects": "^1.14.0"
+      },
+      bundlesize: [
+        {
+          path: "./dist/axios.min.js",
+          threshold: "5kB"
+        }
+      ]
+    };
+  }
+});
+
+// node_modules/axios/lib/adapters/http.js
+var require_http = __commonJS({
+  "node_modules/axios/lib/adapters/http.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var settle = require_settle();
+    var buildFullPath = require_buildFullPath();
+    var buildURL = require_buildURL();
+    var http = __require("http");
+    var https = __require("https");
+    var httpFollow = require_follow_redirects().http;
+    var httpsFollow = require_follow_redirects().https;
+    var url = __require("url");
+    var zlib = __require("zlib");
+    var pkg = require_package();
+    var createError = require_createError();
+    var enhanceError = require_enhanceError();
+    var isHttps = /https:?/;
+    function setProxy(options, proxy, location) {
+      options.hostname = proxy.host;
+      options.host = proxy.host;
+      options.port = proxy.port;
+      options.path = location;
+      if (proxy.auth) {
+        var base64 = Buffer.from(proxy.auth.username + ":" + proxy.auth.password, "utf8").toString("base64");
+        options.headers["Proxy-Authorization"] = "Basic " + base64;
+      }
+      options.beforeRedirect = function beforeRedirect(redirection) {
+        redirection.headers.host = redirection.host;
+        setProxy(redirection, proxy, redirection.href);
+      };
+    }
+    module.exports = function httpAdapter(config) {
+      return new Promise(function dispatchHttpRequest(resolvePromise, rejectPromise) {
+        var resolve = function resolve2(value) {
+          resolvePromise(value);
+        };
+        var reject = function reject2(value) {
+          rejectPromise(value);
+        };
+        var data = config.data;
+        var headers = config.headers;
+        if ("User-Agent" in headers || "user-agent" in headers) {
+          if (!headers["User-Agent"] && !headers["user-agent"]) {
+            delete headers["User-Agent"];
+            delete headers["user-agent"];
+          }
+        } else {
+          headers["User-Agent"] = "axios/" + pkg.version;
+        }
+        if (data && !utils.isStream(data)) {
+          if (Buffer.isBuffer(data)) {
+          } else if (utils.isArrayBuffer(data)) {
+            data = Buffer.from(new Uint8Array(data));
+          } else if (utils.isString(data)) {
+            data = Buffer.from(data, "utf-8");
+          } else {
+            return reject(createError(
+              "Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream",
+              config
+            ));
+          }
+          headers["Content-Length"] = data.length;
+        }
+        var auth = void 0;
+        if (config.auth) {
+          var username = config.auth.username || "";
+          var password = config.auth.password || "";
+          auth = username + ":" + password;
+        }
+        var fullPath = buildFullPath(config.baseURL, config.url);
+        var parsed = url.parse(fullPath);
+        var protocol = parsed.protocol || "http:";
+        if (!auth && parsed.auth) {
+          var urlAuth = parsed.auth.split(":");
+          var urlUsername = urlAuth[0] || "";
+          var urlPassword = urlAuth[1] || "";
+          auth = urlUsername + ":" + urlPassword;
+        }
+        if (auth) {
+          delete headers.Authorization;
+        }
+        var isHttpsRequest = isHttps.test(protocol);
+        var agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
+        var options = {
+          path: buildURL(parsed.path, config.params, config.paramsSerializer).replace(/^\?/, ""),
+          method: config.method.toUpperCase(),
+          headers,
+          agent,
+          agents: { http: config.httpAgent, https: config.httpsAgent },
+          auth
+        };
+        if (config.socketPath) {
+          options.socketPath = config.socketPath;
+        } else {
+          options.hostname = parsed.hostname;
+          options.port = parsed.port;
+        }
+        var proxy = config.proxy;
+        if (!proxy && proxy !== false) {
+          var proxyEnv = protocol.slice(0, -1) + "_proxy";
+          var proxyUrl = process.env[proxyEnv] || process.env[proxyEnv.toUpperCase()];
+          if (proxyUrl) {
+            var parsedProxyUrl = url.parse(proxyUrl);
+            var noProxyEnv = process.env.no_proxy || process.env.NO_PROXY;
+            var shouldProxy = true;
+            if (noProxyEnv) {
+              var noProxy = noProxyEnv.split(",").map(function trim(s) {
+                return s.trim();
+              });
+              shouldProxy = !noProxy.some(function proxyMatch(proxyElement) {
+                if (!proxyElement) {
+                  return false;
+                }
+                if (proxyElement === "*") {
+                  return true;
+                }
+                if (proxyElement[0] === "." && parsed.hostname.substr(parsed.hostname.length - proxyElement.length) === proxyElement) {
+                  return true;
+                }
+                return parsed.hostname === proxyElement;
+              });
+            }
+            if (shouldProxy) {
+              proxy = {
+                host: parsedProxyUrl.hostname,
+                port: parsedProxyUrl.port,
+                protocol: parsedProxyUrl.protocol
+              };
+              if (parsedProxyUrl.auth) {
+                var proxyUrlAuth = parsedProxyUrl.auth.split(":");
+                proxy.auth = {
+                  username: proxyUrlAuth[0],
+                  password: proxyUrlAuth[1]
+                };
+              }
+            }
+          }
+        }
+        if (proxy) {
+          options.headers.host = parsed.hostname + (parsed.port ? ":" + parsed.port : "");
+          setProxy(options, proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
+        }
+        var transport;
+        var isHttpsProxy = isHttpsRequest && (proxy ? isHttps.test(proxy.protocol) : true);
+        if (config.transport) {
+          transport = config.transport;
+        } else if (config.maxRedirects === 0) {
+          transport = isHttpsProxy ? https : http;
+        } else {
+          if (config.maxRedirects) {
+            options.maxRedirects = config.maxRedirects;
+          }
+          transport = isHttpsProxy ? httpsFollow : httpFollow;
+        }
+        if (config.maxBodyLength > -1) {
+          options.maxBodyLength = config.maxBodyLength;
+        }
+        var req = transport.request(options, function handleResponse(res) {
+          if (req.aborted) return;
+          var stream = res;
+          var lastRequest = res.req || req;
+          if (res.statusCode !== 204 && lastRequest.method !== "HEAD" && config.decompress !== false) {
+            switch (res.headers["content-encoding"]) {
+              /*eslint default-case:0*/
+              case "gzip":
+              case "compress":
+              case "deflate":
+                stream = stream.pipe(zlib.createUnzip());
+                delete res.headers["content-encoding"];
+                break;
+            }
+          }
+          var response = {
+            status: res.statusCode,
+            statusText: res.statusMessage,
+            headers: res.headers,
+            config,
+            request: lastRequest
+          };
+          if (config.responseType === "stream") {
+            response.data = stream;
+            settle(resolve, reject, response);
+          } else {
+            var responseBuffer = [];
+            var totalResponseBytes = 0;
+            stream.on("data", function handleStreamData(chunk) {
+              responseBuffer.push(chunk);
+              totalResponseBytes += chunk.length;
+              if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
+                stream.destroy();
+                reject(createError(
+                  "maxContentLength size of " + config.maxContentLength + " exceeded",
+                  config,
+                  null,
+                  lastRequest
+                ));
+              }
+            });
+            stream.on("error", function handleStreamError(err) {
+              if (req.aborted) return;
+              reject(enhanceError(err, config, null, lastRequest));
+            });
+            stream.on("end", function handleStreamEnd() {
+              var responseData = Buffer.concat(responseBuffer);
+              if (config.responseType !== "arraybuffer") {
+                responseData = responseData.toString(config.responseEncoding);
+                if (!config.responseEncoding || config.responseEncoding === "utf8") {
+                  responseData = utils.stripBOM(responseData);
+                }
+              }
+              response.data = responseData;
+              settle(resolve, reject, response);
+            });
+          }
+        });
+        req.on("error", function handleRequestError(err) {
+          if (req.aborted && err.code !== "ERR_FR_TOO_MANY_REDIRECTS") return;
+          reject(enhanceError(err, config, null, req));
+        });
+        if (config.timeout) {
+          var timeout = parseInt(config.timeout, 10);
+          if (isNaN(timeout)) {
+            reject(createError(
+              "error trying to parse `config.timeout` to int",
+              config,
+              "ERR_PARSE_TIMEOUT",
+              req
+            ));
+            return;
+          }
+          req.setTimeout(timeout, function handleRequestTimeout() {
+            req.abort();
+            reject(createError(
+              "timeout of " + timeout + "ms exceeded",
+              config,
+              config.transitional && config.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED",
+              req
+            ));
+          });
+        }
+        if (config.cancelToken) {
+          config.cancelToken.promise.then(function onCanceled(cancel) {
+            if (req.aborted) return;
+            req.abort();
+            reject(cancel);
+          });
+        }
+        if (utils.isStream(data)) {
+          data.on("error", function handleStreamError(err) {
+            reject(enhanceError(err, config, null, req));
+          }).pipe(req);
+        } else {
+          req.end(data);
+        }
+      });
+    };
+  }
+});
+
+// node_modules/axios/lib/defaults.js
+var require_defaults = __commonJS({
+  "node_modules/axios/lib/defaults.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var normalizeHeaderName = require_normalizeHeaderName();
+    var enhanceError = require_enhanceError();
+    var DEFAULT_CONTENT_TYPE = {
+      "Content-Type": "application/x-www-form-urlencoded"
+    };
+    function setContentTypeIfUnset(headers, value) {
+      if (!utils.isUndefined(headers) && utils.isUndefined(headers["Content-Type"])) {
+        headers["Content-Type"] = value;
+      }
+    }
+    function getDefaultAdapter() {
+      var adapter;
+      if (typeof XMLHttpRequest !== "undefined") {
+        adapter = require_xhr();
+      } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+        adapter = require_http();
+      }
+      return adapter;
+    }
+    function stringifySafely(rawValue, parser, encoder) {
+      if (utils.isString(rawValue)) {
+        try {
+          (parser || JSON.parse)(rawValue);
+          return utils.trim(rawValue);
+        } catch (e) {
+          if (e.name !== "SyntaxError") {
+            throw e;
+          }
+        }
+      }
+      return (encoder || JSON.stringify)(rawValue);
+    }
+    var defaults = {
+      transitional: {
+        silentJSONParsing: true,
+        forcedJSONParsing: true,
+        clarifyTimeoutError: false
+      },
+      adapter: getDefaultAdapter(),
+      transformRequest: [function transformRequest(data, headers) {
+        normalizeHeaderName(headers, "Accept");
+        normalizeHeaderName(headers, "Content-Type");
+        if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) {
+          return data;
+        }
+        if (utils.isArrayBufferView(data)) {
+          return data.buffer;
+        }
+        if (utils.isURLSearchParams(data)) {
+          setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+          return data.toString();
+        }
+        if (utils.isObject(data) || headers && headers["Content-Type"] === "application/json") {
+          setContentTypeIfUnset(headers, "application/json");
+          return stringifySafely(data);
+        }
+        return data;
+      }],
+      transformResponse: [function transformResponse(data) {
+        var transitional = this.transitional;
+        var silentJSONParsing = transitional && transitional.silentJSONParsing;
+        var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+        var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+        if (strictJSONParsing || forcedJSONParsing && utils.isString(data) && data.length) {
+          try {
+            return JSON.parse(data);
+          } catch (e) {
+            if (strictJSONParsing) {
+              if (e.name === "SyntaxError") {
+                throw enhanceError(e, this, "E_JSON_PARSE");
+              }
+              throw e;
+            }
+          }
+        }
+        return data;
+      }],
+      /**
+       * A timeout in milliseconds to abort a request. If set to 0 (default) a
+       * timeout is not created.
+       */
+      timeout: 0,
+      xsrfCookieName: "XSRF-TOKEN",
+      xsrfHeaderName: "X-XSRF-TOKEN",
+      maxContentLength: -1,
+      maxBodyLength: -1,
+      validateStatus: function validateStatus(status) {
+        return status >= 200 && status < 300;
+      }
+    };
+    defaults.headers = {
+      common: {
+        "Accept": "application/json, text/plain, */*"
+      }
+    };
+    utils.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+      defaults.headers[method] = {};
+    });
+    utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+      defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+    });
+    module.exports = defaults;
+  }
+});
+
+// node_modules/axios/lib/core/transformData.js
+var require_transformData = __commonJS({
+  "node_modules/axios/lib/core/transformData.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var defaults = require_defaults();
+    module.exports = function transformData(data, headers, fns) {
+      var context = this || defaults;
+      utils.forEach(fns, function transform(fn) {
+        data = fn.call(context, data, headers);
+      });
+      return data;
+    };
+  }
+});
+
+// node_modules/axios/lib/cancel/isCancel.js
+var require_isCancel = __commonJS({
+  "node_modules/axios/lib/cancel/isCancel.js"(exports, module) {
+    "use strict";
+    module.exports = function isCancel(value) {
+      return !!(value && value.__CANCEL__);
+    };
+  }
+});
+
+// node_modules/axios/lib/core/dispatchRequest.js
+var require_dispatchRequest = __commonJS({
+  "node_modules/axios/lib/core/dispatchRequest.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var transformData = require_transformData();
+    var isCancel = require_isCancel();
+    var defaults = require_defaults();
+    function throwIfCancellationRequested(config) {
+      if (config.cancelToken) {
+        config.cancelToken.throwIfRequested();
+      }
+    }
+    module.exports = function dispatchRequest(config) {
+      throwIfCancellationRequested(config);
+      config.headers = config.headers || {};
+      config.data = transformData.call(
+        config,
+        config.data,
+        config.headers,
+        config.transformRequest
+      );
+      config.headers = utils.merge(
+        config.headers.common || {},
+        config.headers[config.method] || {},
+        config.headers
+      );
+      utils.forEach(
+        ["delete", "get", "head", "post", "put", "patch", "common"],
+        function cleanHeaderConfig(method) {
+          delete config.headers[method];
+        }
+      );
+      var adapter = config.adapter || defaults.adapter;
+      return adapter(config).then(function onAdapterResolution(response) {
+        throwIfCancellationRequested(config);
+        response.data = transformData.call(
+          config,
+          response.data,
+          response.headers,
+          config.transformResponse
+        );
+        return response;
+      }, function onAdapterRejection(reason) {
+        if (!isCancel(reason)) {
+          throwIfCancellationRequested(config);
+          if (reason && reason.response) {
+            reason.response.data = transformData.call(
+              config,
+              reason.response.data,
+              reason.response.headers,
+              config.transformResponse
+            );
+          }
+        }
+        return Promise.reject(reason);
+      });
+    };
+  }
+});
+
+// node_modules/axios/lib/core/mergeConfig.js
+var require_mergeConfig = __commonJS({
+  "node_modules/axios/lib/core/mergeConfig.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    module.exports = function mergeConfig(config1, config2) {
+      config2 = config2 || {};
+      var config = {};
+      var valueFromConfig2Keys = ["url", "method", "data"];
+      var mergeDeepPropertiesKeys = ["headers", "auth", "proxy", "params"];
+      var defaultToConfig2Keys = [
+        "baseURL",
+        "transformRequest",
+        "transformResponse",
+        "paramsSerializer",
+        "timeout",
+        "timeoutMessage",
+        "withCredentials",
+        "adapter",
+        "responseType",
+        "xsrfCookieName",
+        "xsrfHeaderName",
+        "onUploadProgress",
+        "onDownloadProgress",
+        "decompress",
+        "maxContentLength",
+        "maxBodyLength",
+        "maxRedirects",
+        "transport",
+        "httpAgent",
+        "httpsAgent",
+        "cancelToken",
+        "socketPath",
+        "responseEncoding"
+      ];
+      var directMergeKeys = ["validateStatus"];
+      function getMergedValue(target, source) {
+        if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
+          return utils.merge(target, source);
+        } else if (utils.isPlainObject(source)) {
+          return utils.merge({}, source);
+        } else if (utils.isArray(source)) {
+          return source.slice();
+        }
+        return source;
+      }
+      function mergeDeepProperties(prop) {
+        if (!utils.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(config1[prop], config2[prop]);
+        } else if (!utils.isUndefined(config1[prop])) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      }
+      utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+        if (!utils.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(void 0, config2[prop]);
+        }
+      });
+      utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+      utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+        if (!utils.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(void 0, config2[prop]);
+        } else if (!utils.isUndefined(config1[prop])) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      });
+      utils.forEach(directMergeKeys, function merge(prop) {
+        if (prop in config2) {
+          config[prop] = getMergedValue(config1[prop], config2[prop]);
+        } else if (prop in config1) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      });
+      var axiosKeys = valueFromConfig2Keys.concat(mergeDeepPropertiesKeys).concat(defaultToConfig2Keys).concat(directMergeKeys);
+      var otherKeys = Object.keys(config1).concat(Object.keys(config2)).filter(function filterAxiosKeys(key) {
+        return axiosKeys.indexOf(key) === -1;
+      });
+      utils.forEach(otherKeys, mergeDeepProperties);
+      return config;
+    };
+  }
+});
+
+// node_modules/axios/lib/helpers/validator.js
+var require_validator = __commonJS({
+  "node_modules/axios/lib/helpers/validator.js"(exports, module) {
+    "use strict";
+    var pkg = require_package();
+    var validators = {};
+    ["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+      validators[type] = function validator(thing) {
+        return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+      };
+    });
+    var deprecatedWarnings = {};
+    var currentVerArr = pkg.version.split(".");
+    function isOlderVersion(version, thanVersion) {
+      var pkgVersionArr = thanVersion ? thanVersion.split(".") : currentVerArr;
+      var destVer = version.split(".");
+      for (var i = 0; i < 3; i++) {
+        if (pkgVersionArr[i] > destVer[i]) {
+          return true;
+        } else if (pkgVersionArr[i] < destVer[i]) {
+          return false;
+        }
+      }
+      return false;
+    }
+    validators.transitional = function transitional(validator, version, message) {
+      var isDeprecated = version && isOlderVersion(version);
+      function formatMessage(opt, desc) {
+        return "[Axios v" + pkg.version + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+      }
+      return function(value, opt, opts) {
+        if (validator === false) {
+          throw new Error(formatMessage(opt, " has been removed in " + version));
+        }
+        if (isDeprecated && !deprecatedWarnings[opt]) {
+          deprecatedWarnings[opt] = true;
+          console.warn(
+            formatMessage(
+              opt,
+              " has been deprecated since v" + version + " and will be removed in the near future"
+            )
+          );
+        }
+        return validator ? validator(value, opt, opts) : true;
+      };
+    };
+    function assertOptions(options, schema, allowUnknown) {
+      if (typeof options !== "object") {
+        throw new TypeError("options must be an object");
+      }
+      var keys = Object.keys(options);
+      var i = keys.length;
+      while (i-- > 0) {
+        var opt = keys[i];
+        var validator = schema[opt];
+        if (validator) {
+          var value = options[opt];
+          var result = value === void 0 || validator(value, opt, options);
+          if (result !== true) {
+            throw new TypeError("option " + opt + " must be " + result);
+          }
+          continue;
+        }
+        if (allowUnknown !== true) {
+          throw Error("Unknown option " + opt);
+        }
+      }
+    }
+    module.exports = {
+      isOlderVersion,
+      assertOptions,
+      validators
+    };
+  }
+});
+
+// node_modules/axios/lib/core/Axios.js
+var require_Axios = __commonJS({
+  "node_modules/axios/lib/core/Axios.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var buildURL = require_buildURL();
+    var InterceptorManager = require_InterceptorManager();
+    var dispatchRequest = require_dispatchRequest();
+    var mergeConfig = require_mergeConfig();
+    var validator = require_validator();
+    var validators = validator.validators;
+    function Axios(instanceConfig) {
+      this.defaults = instanceConfig;
+      this.interceptors = {
+        request: new InterceptorManager(),
+        response: new InterceptorManager()
+      };
+    }
+    Axios.prototype.request = function request(config) {
+      if (typeof config === "string") {
+        config = arguments[1] || {};
+        config.url = arguments[0];
+      } else {
+        config = config || {};
+      }
+      config = mergeConfig(this.defaults, config);
+      if (config.method) {
+        config.method = config.method.toLowerCase();
+      } else if (this.defaults.method) {
+        config.method = this.defaults.method.toLowerCase();
+      } else {
+        config.method = "get";
+      }
+      var transitional = config.transitional;
+      if (transitional !== void 0) {
+        validator.assertOptions(transitional, {
+          silentJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+          forcedJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+          clarifyTimeoutError: validators.transitional(validators.boolean, "1.0.0")
+        }, false);
+      }
+      var requestInterceptorChain = [];
+      var synchronousRequestInterceptors = true;
+      this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+        if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
+          return;
+        }
+        synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+        requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+      });
+      var responseInterceptorChain = [];
+      this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+        responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+      });
+      var promise;
+      if (!synchronousRequestInterceptors) {
+        var chain = [dispatchRequest, void 0];
+        Array.prototype.unshift.apply(chain, requestInterceptorChain);
+        chain = chain.concat(responseInterceptorChain);
+        promise = Promise.resolve(config);
+        while (chain.length) {
+          promise = promise.then(chain.shift(), chain.shift());
+        }
+        return promise;
+      }
+      var newConfig = config;
+      while (requestInterceptorChain.length) {
+        var onFulfilled = requestInterceptorChain.shift();
+        var onRejected = requestInterceptorChain.shift();
+        try {
+          newConfig = onFulfilled(newConfig);
+        } catch (error) {
+          onRejected(error);
+          break;
+        }
+      }
+      try {
+        promise = dispatchRequest(newConfig);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      while (responseInterceptorChain.length) {
+        promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+      }
+      return promise;
+    };
+    Axios.prototype.getUri = function getUri(config) {
+      config = mergeConfig(this.defaults, config);
+      return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
+    };
+    utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
+      Axios.prototype[method] = function(url, config) {
+        return this.request(mergeConfig(config || {}, {
+          method,
+          url,
+          data: (config || {}).data
+        }));
+      };
+    });
+    utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+      Axios.prototype[method] = function(url, data, config) {
+        return this.request(mergeConfig(config || {}, {
+          method,
+          url,
+          data
+        }));
+      };
+    });
+    module.exports = Axios;
+  }
+});
+
+// node_modules/axios/lib/cancel/Cancel.js
+var require_Cancel = __commonJS({
+  "node_modules/axios/lib/cancel/Cancel.js"(exports, module) {
+    "use strict";
+    function Cancel(message) {
+      this.message = message;
+    }
+    Cancel.prototype.toString = function toString() {
+      return "Cancel" + (this.message ? ": " + this.message : "");
+    };
+    Cancel.prototype.__CANCEL__ = true;
+    module.exports = Cancel;
+  }
+});
+
+// node_modules/axios/lib/cancel/CancelToken.js
+var require_CancelToken = __commonJS({
+  "node_modules/axios/lib/cancel/CancelToken.js"(exports, module) {
+    "use strict";
+    var Cancel = require_Cancel();
+    function CancelToken(executor) {
+      if (typeof executor !== "function") {
+        throw new TypeError("executor must be a function.");
+      }
+      var resolvePromise;
+      this.promise = new Promise(function promiseExecutor(resolve) {
+        resolvePromise = resolve;
+      });
+      var token = this;
+      executor(function cancel(message) {
+        if (token.reason) {
+          return;
+        }
+        token.reason = new Cancel(message);
+        resolvePromise(token.reason);
+      });
+    }
+    CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+      if (this.reason) {
+        throw this.reason;
+      }
+    };
+    CancelToken.source = function source() {
+      var cancel;
+      var token = new CancelToken(function executor(c) {
+        cancel = c;
+      });
+      return {
+        token,
+        cancel
+      };
+    };
+    module.exports = CancelToken;
+  }
+});
+
+// node_modules/axios/lib/helpers/spread.js
+var require_spread = __commonJS({
+  "node_modules/axios/lib/helpers/spread.js"(exports, module) {
+    "use strict";
+    module.exports = function spread(callback) {
+      return function wrap(arr) {
+        return callback.apply(null, arr);
+      };
+    };
+  }
+});
+
+// node_modules/axios/lib/helpers/isAxiosError.js
+var require_isAxiosError = __commonJS({
+  "node_modules/axios/lib/helpers/isAxiosError.js"(exports, module) {
+    "use strict";
+    module.exports = function isAxiosError(payload) {
+      return typeof payload === "object" && payload.isAxiosError === true;
+    };
+  }
+});
+
+// node_modules/axios/lib/axios.js
+var require_axios = __commonJS({
+  "node_modules/axios/lib/axios.js"(exports, module) {
+    "use strict";
+    var utils = require_utils();
+    var bind = require_bind();
+    var Axios = require_Axios();
+    var mergeConfig = require_mergeConfig();
+    var defaults = require_defaults();
+    function createInstance(defaultConfig) {
+      var context = new Axios(defaultConfig);
+      var instance = bind(Axios.prototype.request, context);
+      utils.extend(instance, Axios.prototype, context);
+      utils.extend(instance, context);
+      return instance;
+    }
+    var axios = createInstance(defaults);
+    axios.Axios = Axios;
+    axios.create = function create(instanceConfig) {
+      return createInstance(mergeConfig(axios.defaults, instanceConfig));
+    };
+    axios.Cancel = require_Cancel();
+    axios.CancelToken = require_CancelToken();
+    axios.isCancel = require_isCancel();
+    axios.all = function all(promises) {
+      return Promise.all(promises);
+    };
+    axios.spread = require_spread();
+    axios.isAxiosError = require_isAxiosError();
+    module.exports = axios;
+    module.exports.default = axios;
+  }
+});
+
+// node_modules/axios/index.js
+var require_axios2 = __commonJS({
+  "node_modules/axios/index.js"(exports, module) {
+    "use strict";
+    module.exports = require_axios();
+  }
+});
+
+// node_modules/localtunnel/node_modules/debug/node_modules/ms/index.js
+var require_ms2 = __commonJS({
+  "node_modules/localtunnel/node_modules/debug/node_modules/ms/index.js"(exports, module) {
+    "use strict";
+    var s = 1e3;
+    var m = s * 60;
+    var h = m * 60;
+    var d = h * 24;
+    var w = d * 7;
+    var y = d * 365.25;
+    module.exports = function(val, options) {
+      options = options || {};
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
+        return parse(val);
+      } else if (type === "number" && isFinite(val)) {
+        return options.long ? fmtLong(val) : fmtShort(val);
+      }
+      throw new Error(
+        "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
+      );
+    };
+    function parse(str) {
+      str = String(str);
+      if (str.length > 100) {
+        return;
+      }
+      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+        str
+      );
+      if (!match) {
+        return;
+      }
+      var n = parseFloat(match[1]);
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
+        case "years":
+        case "year":
+        case "yrs":
+        case "yr":
+        case "y":
+          return n * y;
+        case "weeks":
+        case "week":
+        case "w":
+          return n * w;
+        case "days":
+        case "day":
+        case "d":
+          return n * d;
+        case "hours":
+        case "hour":
+        case "hrs":
+        case "hr":
+        case "h":
+          return n * h;
+        case "minutes":
+        case "minute":
+        case "mins":
+        case "min":
+        case "m":
+          return n * m;
+        case "seconds":
+        case "second":
+        case "secs":
+        case "sec":
+        case "s":
+          return n * s;
+        case "milliseconds":
+        case "millisecond":
+        case "msecs":
+        case "msec":
+        case "ms":
+          return n;
+        default:
+          return void 0;
+      }
+    }
+    function fmtShort(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return Math.round(ms / d) + "d";
+      }
+      if (msAbs >= h) {
+        return Math.round(ms / h) + "h";
+      }
+      if (msAbs >= m) {
+        return Math.round(ms / m) + "m";
+      }
+      if (msAbs >= s) {
+        return Math.round(ms / s) + "s";
+      }
+      return ms + "ms";
+    }
+    function fmtLong(ms) {
+      var msAbs = Math.abs(ms);
+      if (msAbs >= d) {
+        return plural(ms, msAbs, d, "day");
+      }
+      if (msAbs >= h) {
+        return plural(ms, msAbs, h, "hour");
+      }
+      if (msAbs >= m) {
+        return plural(ms, msAbs, m, "minute");
+      }
+      if (msAbs >= s) {
+        return plural(ms, msAbs, s, "second");
+      }
+      return ms + " ms";
+    }
+    function plural(ms, msAbs, n, name) {
+      var isPlural = msAbs >= n * 1.5;
+      return Math.round(ms / n) + " " + name + (isPlural ? "s" : "");
+    }
+  }
+});
+
+// node_modules/localtunnel/node_modules/debug/src/common.js
+var require_common2 = __commonJS({
+  "node_modules/localtunnel/node_modules/debug/src/common.js"(exports, module) {
+    "use strict";
+    function setup(env) {
+      createDebug.debug = createDebug;
+      createDebug.default = createDebug;
+      createDebug.coerce = coerce;
+      createDebug.disable = disable;
+      createDebug.enable = enable;
+      createDebug.enabled = enabled;
+      createDebug.humanize = require_ms2();
+      createDebug.destroy = destroy;
+      Object.keys(env).forEach((key) => {
+        createDebug[key] = env[key];
+      });
+      createDebug.names = [];
+      createDebug.skips = [];
+      createDebug.formatters = {};
+      function selectColor(namespace) {
+        let hash = 0;
+        for (let i = 0; i < namespace.length; i++) {
+          hash = (hash << 5) - hash + namespace.charCodeAt(i);
+          hash |= 0;
+        }
+        return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
+      }
+      createDebug.selectColor = selectColor;
+      function createDebug(namespace) {
+        let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
+        function debug(...args) {
+          if (!debug.enabled) {
+            return;
+          }
+          const self = debug;
+          const curr = Number(/* @__PURE__ */ new Date());
+          const ms = curr - (prevTime || curr);
+          self.diff = ms;
+          self.prev = prevTime;
+          self.curr = curr;
+          prevTime = curr;
+          args[0] = createDebug.coerce(args[0]);
+          if (typeof args[0] !== "string") {
+            args.unshift("%O");
+          }
+          let index = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
+            if (match === "%%") {
+              return "%";
+            }
+            index++;
+            const formatter = createDebug.formatters[format];
+            if (typeof formatter === "function") {
+              const val = args[index];
+              match = formatter.call(self, val);
+              args.splice(index, 1);
+              index--;
+            }
+            return match;
+          });
+          createDebug.formatArgs.call(self, args);
+          const logFn = self.log || createDebug.log;
+          logFn.apply(self, args);
+        }
+        debug.namespace = namespace;
+        debug.useColors = createDebug.useColors();
+        debug.color = createDebug.selectColor(namespace);
+        debug.extend = extend;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
+        if (typeof createDebug.init === "function") {
+          createDebug.init(debug);
+        }
+        return debug;
+      }
+      function extend(namespace, delimiter) {
+        const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
+        newDebug.log = this.log;
+        return newDebug;
+      }
+      function enable(namespaces) {
+        createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
+        createDebug.names = [];
+        createDebug.skips = [];
+        let i;
+        const split = (typeof namespaces === "string" ? namespaces : "").split(/[\s,]+/);
+        const len = split.length;
+        for (i = 0; i < len; i++) {
+          if (!split[i]) {
+            continue;
+          }
+          namespaces = split[i].replace(/\*/g, ".*?");
+          if (namespaces[0] === "-") {
+            createDebug.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+          } else {
+            createDebug.names.push(new RegExp("^" + namespaces + "$"));
+          }
+        }
+      }
+      function disable() {
+        const namespaces = [
+          ...createDebug.names.map(toNamespace),
+          ...createDebug.skips.map(toNamespace).map((namespace) => "-" + namespace)
+        ].join(",");
+        createDebug.enable("");
+        return namespaces;
+      }
+      function enabled(name) {
+        if (name[name.length - 1] === "*") {
+          return true;
+        }
+        let i;
+        let len;
+        for (i = 0, len = createDebug.skips.length; i < len; i++) {
+          if (createDebug.skips[i].test(name)) {
+            return false;
+          }
+        }
+        for (i = 0, len = createDebug.names.length; i < len; i++) {
+          if (createDebug.names[i].test(name)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      function toNamespace(regexp) {
+        return regexp.toString().substring(2, regexp.toString().length - 2).replace(/\.\*\?$/, "*");
+      }
+      function coerce(val) {
+        if (val instanceof Error) {
+          return val.stack || val.message;
+        }
+        return val;
+      }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
+      createDebug.enable(createDebug.load());
+      return createDebug;
+    }
+    module.exports = setup;
+  }
+});
+
+// node_modules/localtunnel/node_modules/debug/src/browser.js
+var require_browser2 = __commonJS({
+  "node_modules/localtunnel/node_modules/debug/src/browser.js"(exports, module) {
+    "use strict";
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.storage = localstorage();
+    exports.destroy = /* @__PURE__ */ (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
+    exports.colors = [
+      "#0000CC",
+      "#0000FF",
+      "#0033CC",
+      "#0033FF",
+      "#0066CC",
+      "#0066FF",
+      "#0099CC",
+      "#0099FF",
+      "#00CC00",
+      "#00CC33",
+      "#00CC66",
+      "#00CC99",
+      "#00CCCC",
+      "#00CCFF",
+      "#3300CC",
+      "#3300FF",
+      "#3333CC",
+      "#3333FF",
+      "#3366CC",
+      "#3366FF",
+      "#3399CC",
+      "#3399FF",
+      "#33CC00",
+      "#33CC33",
+      "#33CC66",
+      "#33CC99",
+      "#33CCCC",
+      "#33CCFF",
+      "#6600CC",
+      "#6600FF",
+      "#6633CC",
+      "#6633FF",
+      "#66CC00",
+      "#66CC33",
+      "#9900CC",
+      "#9900FF",
+      "#9933CC",
+      "#9933FF",
+      "#99CC00",
+      "#99CC33",
+      "#CC0000",
+      "#CC0033",
+      "#CC0066",
+      "#CC0099",
+      "#CC00CC",
+      "#CC00FF",
+      "#CC3300",
+      "#CC3333",
+      "#CC3366",
+      "#CC3399",
+      "#CC33CC",
+      "#CC33FF",
+      "#CC6600",
+      "#CC6633",
+      "#CC9900",
+      "#CC9933",
+      "#CCCC00",
+      "#CCCC33",
+      "#FF0000",
+      "#FF0033",
+      "#FF0066",
+      "#FF0099",
+      "#FF00CC",
+      "#FF00FF",
+      "#FF3300",
+      "#FF3333",
+      "#FF3366",
+      "#FF3399",
+      "#FF33CC",
+      "#FF33FF",
+      "#FF6600",
+      "#FF6633",
+      "#FF9900",
+      "#FF9933",
+      "#FFCC00",
+      "#FFCC33"
+    ];
+    function useColors() {
+      if (typeof window !== "undefined" && window.process && (window.process.type === "renderer" || window.process.__nwjs)) {
+        return true;
+      }
+      if (typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/(edge|trident)\/(\d+)/)) {
+        return false;
+      }
+      return typeof document !== "undefined" && document.documentElement && document.documentElement.style && document.documentElement.style.WebkitAppearance || // Is firebug? http://stackoverflow.com/a/398120/376773
+      typeof window !== "undefined" && window.console && (window.console.firebug || window.console.exception && window.console.table) || // Is firefox >= v31?
+      // https://developer.mozilla.org/en-US/docs/Tools/Web_Console#Styling_messages
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
+      typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
+    }
+    function formatArgs(args) {
+      args[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args[0] + (this.useColors ? "%c " : " ") + "+" + module.exports.humanize(this.diff);
+      if (!this.useColors) {
+        return;
+      }
+      const c = "color: " + this.color;
+      args.splice(1, 0, c, "color: inherit");
+      let index = 0;
+      let lastC = 0;
+      args[0].replace(/%[a-zA-Z%]/g, (match) => {
+        if (match === "%%") {
+          return;
+        }
+        index++;
+        if (match === "%c") {
+          lastC = index;
+        }
+      });
+      args.splice(lastC, 0, c);
+    }
+    exports.log = console.debug || console.log || (() => {
+    });
+    function save(namespaces) {
+      try {
+        if (namespaces) {
+          exports.storage.setItem("debug", namespaces);
+        } else {
+          exports.storage.removeItem("debug");
+        }
+      } catch (error) {
+      }
+    }
+    function load() {
+      let r;
+      try {
+        r = exports.storage.getItem("debug");
+      } catch (error) {
+      }
+      if (!r && typeof process !== "undefined" && "env" in process) {
+        r = process.env.DEBUG;
+      }
+      return r;
+    }
+    function localstorage() {
+      try {
+        return localStorage;
+      } catch (error) {
+      }
+    }
+    module.exports = require_common2()(exports);
+    var { formatters } = module.exports;
+    formatters.j = function(v) {
+      try {
+        return JSON.stringify(v);
+      } catch (error) {
+        return "[UnexpectedJSONParseError]: " + error.message;
+      }
+    };
+  }
+});
+
+// node_modules/localtunnel/node_modules/debug/src/node.js
+var require_node2 = __commonJS({
+  "node_modules/localtunnel/node_modules/debug/src/node.js"(exports, module) {
+    "use strict";
+    var tty = __require("tty");
+    var util = __require("util");
+    exports.init = init;
+    exports.log = log;
+    exports.formatArgs = formatArgs;
+    exports.save = save;
+    exports.load = load;
+    exports.useColors = useColors;
+    exports.destroy = util.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
+    exports.colors = [6, 2, 3, 4, 5, 1];
+    try {
+      const supportsColor = require_supports_color();
+      if (supportsColor && (supportsColor.stderr || supportsColor).level >= 2) {
+        exports.colors = [
+          20,
+          21,
+          26,
+          27,
+          32,
+          33,
+          38,
+          39,
+          40,
+          41,
+          42,
+          43,
+          44,
+          45,
+          56,
+          57,
+          62,
+          63,
+          68,
+          69,
+          74,
+          75,
+          76,
+          77,
+          78,
+          79,
+          80,
+          81,
+          92,
+          93,
+          98,
+          99,
+          112,
+          113,
+          128,
+          129,
+          134,
+          135,
+          148,
+          149,
+          160,
+          161,
+          162,
+          163,
+          164,
+          165,
+          166,
+          167,
+          168,
+          169,
+          170,
+          171,
+          172,
+          173,
+          178,
+          179,
+          184,
+          185,
+          196,
+          197,
+          198,
+          199,
+          200,
+          201,
+          202,
+          203,
+          204,
+          205,
+          206,
+          207,
+          208,
+          209,
+          214,
+          215,
+          220,
+          221
+        ];
+      }
+    } catch (error) {
+    }
+    exports.inspectOpts = Object.keys(process.env).filter((key) => {
+      return /^debug_/i.test(key);
+    }).reduce((obj, key) => {
+      const prop = key.substring(6).toLowerCase().replace(/_([a-z])/g, (_, k) => {
+        return k.toUpperCase();
+      });
+      let val = process.env[key];
+      if (/^(yes|on|true|enabled)$/i.test(val)) {
+        val = true;
+      } else if (/^(no|off|false|disabled)$/i.test(val)) {
+        val = false;
+      } else if (val === "null") {
+        val = null;
+      } else {
+        val = Number(val);
+      }
+      obj[prop] = val;
+      return obj;
+    }, {});
+    function useColors() {
+      return "colors" in exports.inspectOpts ? Boolean(exports.inspectOpts.colors) : tty.isatty(process.stderr.fd);
+    }
+    function formatArgs(args) {
+      const { namespace: name, useColors: useColors2 } = this;
+      if (useColors2) {
+        const c = this.color;
+        const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
+        const prefix = `  ${colorCode};1m${name} \x1B[0m`;
+        args[0] = prefix + args[0].split("\n").join("\n" + prefix);
+        args.push(colorCode + "m+" + module.exports.humanize(this.diff) + "\x1B[0m");
+      } else {
+        args[0] = getDate() + name + " " + args[0];
+      }
+    }
+    function getDate() {
+      if (exports.inspectOpts.hideDate) {
+        return "";
+      }
+      return (/* @__PURE__ */ new Date()).toISOString() + " ";
+    }
+    function log(...args) {
+      return process.stderr.write(util.format(...args) + "\n");
+    }
+    function save(namespaces) {
+      if (namespaces) {
+        process.env.DEBUG = namespaces;
+      } else {
+        delete process.env.DEBUG;
+      }
+    }
+    function load() {
+      return process.env.DEBUG;
+    }
+    function init(debug) {
+      debug.inspectOpts = {};
+      const keys = Object.keys(exports.inspectOpts);
+      for (let i = 0; i < keys.length; i++) {
+        debug.inspectOpts[keys[i]] = exports.inspectOpts[keys[i]];
+      }
+    }
+    module.exports = require_common2()(exports);
+    var { formatters } = module.exports;
+    formatters.o = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+    };
+    formatters.O = function(v) {
+      this.inspectOpts.colors = this.useColors;
+      return util.inspect(v, this.inspectOpts);
+    };
+  }
+});
+
+// node_modules/localtunnel/node_modules/debug/src/index.js
+var require_src2 = __commonJS({
+  "node_modules/localtunnel/node_modules/debug/src/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || process.type === "renderer" || process.browser === true || process.__nwjs) {
+      module.exports = require_browser2();
+    } else {
+      module.exports = require_node2();
+    }
+  }
+});
+
+// node_modules/localtunnel/lib/HeaderHostTransformer.js
+var require_HeaderHostTransformer = __commonJS({
+  "node_modules/localtunnel/lib/HeaderHostTransformer.js"(exports, module) {
+    "use strict";
+    var { Transform } = __require("stream");
+    var HeaderHostTransformer = class extends Transform {
+      constructor(opts = {}) {
+        super(opts);
+        this.host = opts.host || "localhost";
+        this.replaced = false;
+      }
+      _transform(data, encoding, callback) {
+        callback(
+          null,
+          this.replaced ? data : data.toString().replace(/(\r\n[Hh]ost: )\S+/, (match, $1) => {
+            this.replaced = true;
+            return $1 + this.host;
+          })
+        );
+      }
+    };
+    module.exports = HeaderHostTransformer;
+  }
+});
+
+// node_modules/localtunnel/lib/TunnelCluster.js
+var require_TunnelCluster = __commonJS({
+  "node_modules/localtunnel/lib/TunnelCluster.js"(exports, module) {
+    "use strict";
+    var { EventEmitter } = __require("events");
+    var debug = require_src2()("localtunnel:client");
+    var fs = __require("fs");
+    var net = __require("net");
+    var tls = __require("tls");
+    var HeaderHostTransformer = require_HeaderHostTransformer();
+    module.exports = class TunnelCluster extends EventEmitter {
+      constructor(opts = {}) {
+        super(opts);
+        this.opts = opts;
+      }
+      open() {
+        const opt = this.opts;
+        const remoteHostOrIp = opt.remote_ip || opt.remote_host;
+        const remotePort = opt.remote_port;
+        const localHost = opt.local_host || "localhost";
+        const localPort = opt.local_port;
+        const localProtocol = opt.local_https ? "https" : "http";
+        const allowInvalidCert = opt.allow_invalid_cert;
+        debug(
+          "establishing tunnel %s://%s:%s <> %s:%s",
+          localProtocol,
+          localHost,
+          localPort,
+          remoteHostOrIp,
+          remotePort
+        );
+        const remote = net.connect({
+          host: remoteHostOrIp,
+          port: remotePort
+        });
+        remote.setKeepAlive(true);
+        remote.on("error", (err) => {
+          debug("got remote connection error", err.message);
+          if (err.code === "ECONNREFUSED") {
+            this.emit(
+              "error",
+              new Error(
+                `connection refused: ${remoteHostOrIp}:${remotePort} (check your firewall settings)`
+              )
+            );
+          }
+          remote.end();
+        });
+        const connLocal = () => {
+          if (remote.destroyed) {
+            debug("remote destroyed");
+            this.emit("dead");
+            return;
+          }
+          debug("connecting locally to %s://%s:%d", localProtocol, localHost, localPort);
+          remote.pause();
+          if (allowInvalidCert) {
+            debug("allowing invalid certificates");
+          }
+          const getLocalCertOpts = () => allowInvalidCert ? { rejectUnauthorized: false } : {
+            cert: fs.readFileSync(opt.local_cert),
+            key: fs.readFileSync(opt.local_key),
+            ca: opt.local_ca ? [fs.readFileSync(opt.local_ca)] : void 0
+          };
+          const local = opt.local_https ? tls.connect({ host: localHost, port: localPort, ...getLocalCertOpts() }) : net.connect({ host: localHost, port: localPort });
+          const remoteClose = () => {
+            debug("remote close");
+            this.emit("dead");
+            local.end();
+          };
+          remote.once("close", remoteClose);
+          local.once("error", (err) => {
+            debug("local error %s", err.message);
+            local.end();
+            remote.removeListener("close", remoteClose);
+            if (err.code !== "ECONNREFUSED") {
+              return remote.end();
+            }
+            setTimeout(connLocal, 1e3);
+          });
+          local.once("connect", () => {
+            debug("connected locally");
+            remote.resume();
+            let stream = remote;
+            if (opt.local_host) {
+              debug("transform Host header to %s", opt.local_host);
+              stream = remote.pipe(new HeaderHostTransformer({ host: opt.local_host }));
+            }
+            stream.pipe(local).pipe(remote);
+            local.once("close", (hadError) => {
+              debug("local connection closed [%s]", hadError);
+            });
+          });
+        };
+        remote.on("data", (data) => {
+          const match = data.toString().match(/^(\w+) (\S+)/);
+          if (match) {
+            this.emit("request", {
+              method: match[1],
+              path: match[2]
+            });
+          }
+        });
+        remote.once("connect", () => {
+          this.emit("open", remote);
+          connLocal();
+        });
+      }
+    };
+  }
+});
+
+// node_modules/localtunnel/lib/Tunnel.js
+var require_Tunnel = __commonJS({
+  "node_modules/localtunnel/lib/Tunnel.js"(exports, module) {
+    "use strict";
+    var { parse } = __require("url");
+    var { EventEmitter } = __require("events");
+    var axios = require_axios2();
+    var debug = require_src2()("localtunnel:client");
+    var TunnelCluster = require_TunnelCluster();
+    module.exports = class Tunnel extends EventEmitter {
+      constructor(opts = {}) {
+        super(opts);
+        this.opts = opts;
+        this.closed = false;
+        if (!this.opts.host) {
+          this.opts.host = "https://localtunnel.me";
+        }
+      }
+      _getInfo(body) {
+        const { id, ip, port, url, cached_url, max_conn_count } = body;
+        const { host, port: local_port, local_host } = this.opts;
+        const { local_https, local_cert, local_key, local_ca, allow_invalid_cert } = this.opts;
+        return {
+          name: id,
+          url,
+          cached_url,
+          max_conn: max_conn_count || 1,
+          remote_host: parse(host).hostname,
+          remote_ip: ip,
+          remote_port: port,
+          local_port,
+          local_host,
+          local_https,
+          local_cert,
+          local_key,
+          local_ca,
+          allow_invalid_cert
+        };
+      }
+      // initialize connection
+      // callback with connection info
+      _init(cb) {
+        const opt = this.opts;
+        const getInfo = this._getInfo.bind(this);
+        const params = {
+          responseType: "json"
+        };
+        const baseUri = `${opt.host}/`;
+        const assignedDomain = opt.subdomain;
+        const uri = baseUri + (assignedDomain || "?new");
+        (function getUrl() {
+          axios.get(uri, params).then((res) => {
+            const body = res.data;
+            debug("got tunnel information", res.data);
+            if (res.status !== 200) {
+              const err = new Error(
+                body && body.message || "localtunnel server returned an error, please try again"
+              );
+              return cb(err);
+            }
+            cb(null, getInfo(body));
+          }).catch((err) => {
+            debug(`tunnel server offline: ${err.message}, retry 1s`);
+            return setTimeout(getUrl, 1e3);
+          });
+        })();
+      }
+      _establish(info) {
+        this.setMaxListeners(info.max_conn + (EventEmitter.defaultMaxListeners || 10));
+        this.tunnelCluster = new TunnelCluster(info);
+        this.tunnelCluster.once("open", () => {
+          this.emit("url", info.url);
+        });
+        this.tunnelCluster.on("error", (err) => {
+          debug("got socket error", err.message);
+          this.emit("error", err);
+        });
+        let tunnelCount = 0;
+        this.tunnelCluster.on("open", (tunnel) => {
+          tunnelCount++;
+          debug("tunnel open [total: %d]", tunnelCount);
+          const closeHandler = () => {
+            tunnel.destroy();
+          };
+          if (this.closed) {
+            return closeHandler();
+          }
+          this.once("close", closeHandler);
+          tunnel.once("close", () => {
+            this.removeListener("close", closeHandler);
+          });
+        });
+        this.tunnelCluster.on("dead", () => {
+          tunnelCount--;
+          debug("tunnel dead [total: %d]", tunnelCount);
+          if (this.closed) {
+            return;
+          }
+          this.tunnelCluster.open();
+        });
+        this.tunnelCluster.on("request", (req) => {
+          this.emit("request", req);
+        });
+        for (let count = 0; count < info.max_conn; ++count) {
+          this.tunnelCluster.open();
+        }
+      }
+      open(cb) {
+        this._init((err, info) => {
+          if (err) {
+            return cb(err);
+          }
+          this.clientId = info.name;
+          this.url = info.url;
+          if (info.cached_url) {
+            this.cachedUrl = info.cached_url;
+          }
+          this._establish(info);
+          cb();
+        });
+      }
+      close() {
+        this.closed = true;
+        this.emit("close");
+      }
+    };
+  }
+});
+
+// node_modules/localtunnel/localtunnel.js
+var require_localtunnel = __commonJS({
+  "node_modules/localtunnel/localtunnel.js"(exports, module) {
+    var Tunnel = require_Tunnel();
+    module.exports = function localtunnel(arg1, arg2, arg3) {
+      const options = typeof arg1 === "object" ? arg1 : { ...arg2, port: arg1 };
+      const callback = typeof arg1 === "object" ? arg2 : arg3;
+      const client = new Tunnel(options);
+      if (callback) {
+        client.open((err) => err ? callback(err) : callback(null, client));
+        return client;
+      }
+      return new Promise(
+        (resolve, reject) => client.open((err) => err ? reject(err) : resolve(client))
+      );
+    };
+  }
+});
+export default require_localtunnel();