@nhost/nhost-js 0.3.4 → 0.3.8

package/dist/index.es.js

@@ -0,0 +1,4471 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var axios$8 = { exports: {} };
+var bind$8 = 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);
+  };
+};
+var bind$7 = bind$8;
+var toString$2 = Object.prototype.toString;
+function isArray$2(val) {
+  return Array.isArray(val);
+}
+function isUndefined$2(val) {
+  return typeof val === "undefined";
+}
+function isBuffer$2(val) {
+  return val !== null && !isUndefined$2(val) && val.constructor !== null && !isUndefined$2(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+}
+function isArrayBuffer$2(val) {
+  return toString$2.call(val) === "[object ArrayBuffer]";
+}
+function isFormData$2(val) {
+  return toString$2.call(val) === "[object FormData]";
+}
+function isArrayBufferView$2(val) {
+  var result;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+    result = ArrayBuffer.isView(val);
+  } else {
+    result = val && val.buffer && isArrayBuffer$2(val.buffer);
+  }
+  return result;
+}
+function isString$2(val) {
+  return typeof val === "string";
+}
+function isNumber$2(val) {
+  return typeof val === "number";
+}
+function isObject$2(val) {
+  return val !== null && typeof val === "object";
+}
+function isPlainObject$2(val) {
+  if (toString$2.call(val) !== "[object Object]") {
+    return false;
+  }
+  var prototype = Object.getPrototypeOf(val);
+  return prototype === null || prototype === Object.prototype;
+}
+function isDate$2(val) {
+  return toString$2.call(val) === "[object Date]";
+}
+function isFile$2(val) {
+  return toString$2.call(val) === "[object File]";
+}
+function isBlob$2(val) {
+  return toString$2.call(val) === "[object Blob]";
+}
+function isFunction$2(val) {
+  return toString$2.call(val) === "[object Function]";
+}
+function isStream$2(val) {
+  return isObject$2(val) && isFunction$2(val.pipe);
+}
+function isURLSearchParams$2(val) {
+  return toString$2.call(val) === "[object URLSearchParams]";
+}
+function trim$2(str) {
+  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+}
+function isStandardBrowserEnv$2() {
+  if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+    return false;
+  }
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function forEach$2(obj, fn) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray$2(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$2() {
+  var result = {};
+  function assignValue(val, key) {
+    if (isPlainObject$2(result[key]) && isPlainObject$2(val)) {
+      result[key] = merge$2(result[key], val);
+    } else if (isPlainObject$2(val)) {
+      result[key] = merge$2({}, val);
+    } else if (isArray$2(val)) {
+      result[key] = val.slice();
+    } else {
+      result[key] = val;
+    }
+  }
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    forEach$2(arguments[i], assignValue);
+  }
+  return result;
+}
+function extend$2(a, b, thisArg) {
+  forEach$2(b, function assignValue(val, key) {
+    if (thisArg && typeof val === "function") {
+      a[key] = bind$7(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  });
+  return a;
+}
+function stripBOM$2(content) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+}
+var utils$G = {
+  isArray: isArray$2,
+  isArrayBuffer: isArrayBuffer$2,
+  isBuffer: isBuffer$2,
+  isFormData: isFormData$2,
+  isArrayBufferView: isArrayBufferView$2,
+  isString: isString$2,
+  isNumber: isNumber$2,
+  isObject: isObject$2,
+  isPlainObject: isPlainObject$2,
+  isUndefined: isUndefined$2,
+  isDate: isDate$2,
+  isFile: isFile$2,
+  isBlob: isBlob$2,
+  isFunction: isFunction$2,
+  isStream: isStream$2,
+  isURLSearchParams: isURLSearchParams$2,
+  isStandardBrowserEnv: isStandardBrowserEnv$2,
+  forEach: forEach$2,
+  merge: merge$2,
+  extend: extend$2,
+  trim: trim$2,
+  stripBOM: stripBOM$2
+};
+var utils$F = utils$G;
+function encode$2(val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+var buildURL$8 = function buildURL(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (utils$F.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    utils$F.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (utils$F.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      utils$F.forEach(val, function parseValue(v) {
+        if (utils$F.isDate(v)) {
+          v = v.toISOString();
+        } else if (utils$F.isObject(v)) {
+          v = JSON.stringify(v);
+        }
+        parts.push(encode$2(key) + "=" + encode$2(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;
+};
+var utils$E = utils$G;
+function InterceptorManager$5() {
+  this.handlers = [];
+}
+InterceptorManager$5.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$5.prototype.eject = function eject(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager$5.prototype.forEach = function forEach(fn) {
+  utils$E.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+var InterceptorManager_1$2 = InterceptorManager$5;
+var utils$D = utils$G;
+var normalizeHeaderName$5 = function normalizeHeaderName(headers, normalizedName) {
+  utils$D.forEach(headers, function processHeader(value, name2) {
+    if (name2 !== normalizedName && name2.toUpperCase() === normalizedName.toUpperCase()) {
+      headers[normalizedName] = value;
+      delete headers[name2];
+    }
+  });
+};
+var enhanceError$8 = function enhanceError(error, config, code, request4, response) {
+  error.config = config;
+  if (code) {
+    error.code = code;
+  }
+  error.request = request4;
+  error.response = response;
+  error.isAxiosError = true;
+  error.toJSON = function toJSON() {
+    return {
+      message: this.message,
+      name: this.name,
+      description: this.description,
+      number: this.number,
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      config: this.config,
+      code: this.code,
+      status: this.response && this.response.status ? this.response.status : null
+    };
+  };
+  return error;
+};
+var enhanceError$7 = enhanceError$8;
+var createError$8 = function createError(message, config, code, request4, response) {
+  var error = new Error(message);
+  return enhanceError$7(error, config, code, request4, response);
+};
+var createError$7 = createError$8;
+var settle$5 = function settle(resolve, reject, response) {
+  var validateStatus4 = response.config.validateStatus;
+  if (!response.status || !validateStatus4 || validateStatus4(response.status)) {
+    resolve(response);
+  } else {
+    reject(createError$7("Request failed with status code " + response.status, response.config, null, response.request, response));
+  }
+};
+var utils$C = utils$G;
+var cookies$5 = utils$C.isStandardBrowserEnv() ? function standardBrowserEnv() {
+  return {
+    write: function write(name2, value, expires, path, domain, secure) {
+      var cookie = [];
+      cookie.push(name2 + "=" + encodeURIComponent(value));
+      if (utils$C.isNumber(expires)) {
+        cookie.push("expires=" + new Date(expires).toGMTString());
+      }
+      if (utils$C.isString(path)) {
+        cookie.push("path=" + path);
+      }
+      if (utils$C.isString(domain)) {
+        cookie.push("domain=" + domain);
+      }
+      if (secure === true) {
+        cookie.push("secure");
+      }
+      document.cookie = cookie.join("; ");
+    },
+    read: function read(name2) {
+      var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name2 + ")=([^;]*)"));
+      return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove: function remove(name2) {
+      this.write(name2, "", Date.now() - 864e5);
+    }
+  };
+}() : function nonStandardBrowserEnv() {
+  return {
+    write: function write() {
+    },
+    read: function read() {
+      return null;
+    },
+    remove: function remove() {
+    }
+  };
+}();
+var isAbsoluteURL$5 = function isAbsoluteURL(url) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+};
+var combineURLs$5 = function combineURLs(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+};
+var isAbsoluteURL$4 = isAbsoluteURL$5;
+var combineURLs$4 = combineURLs$5;
+var buildFullPath$5 = function buildFullPath(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL$4(requestedURL)) {
+    return combineURLs$4(baseURL, requestedURL);
+  }
+  return requestedURL;
+};
+var utils$B = utils$G;
+var ignoreDuplicateOf$2 = [
+  "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"
+];
+var parseHeaders$5 = function parseHeaders(headers) {
+  var parsed = {};
+  var key;
+  var val;
+  var i;
+  if (!headers) {
+    return parsed;
+  }
+  utils$B.forEach(headers.split("\n"), function parser(line) {
+    i = line.indexOf(":");
+    key = utils$B.trim(line.substr(0, i)).toLowerCase();
+    val = utils$B.trim(line.substr(i + 1));
+    if (key) {
+      if (parsed[key] && ignoreDuplicateOf$2.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;
+};
+var utils$A = utils$G;
+var isURLSameOrigin$5 = utils$A.isStandardBrowserEnv() ? function standardBrowserEnv2() {
+  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 isURLSameOrigin2(requestURL) {
+    var parsed = utils$A.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+    return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+  };
+}() : function nonStandardBrowserEnv2() {
+  return function isURLSameOrigin2() {
+    return true;
+  };
+}();
+function Cancel$9(message) {
+  this.message = message;
+}
+Cancel$9.prototype.toString = function toString() {
+  return "Cancel" + (this.message ? ": " + this.message : "");
+};
+Cancel$9.prototype.__CANCEL__ = true;
+var Cancel_1$2 = Cancel$9;
+var utils$z = utils$G;
+var settle$4 = settle$5;
+var cookies$4 = cookies$5;
+var buildURL$7 = buildURL$8;
+var buildFullPath$4 = buildFullPath$5;
+var parseHeaders$4 = parseHeaders$5;
+var isURLSameOrigin$4 = isURLSameOrigin$5;
+var createError$6 = createError$8;
+var defaults$d = defaults_1$2;
+var Cancel$8 = Cancel_1$2;
+var xhr$2 = function xhrAdapter(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    var requestData = config.data;
+    var requestHeaders = config.headers;
+    var responseType = config.responseType;
+    var onCanceled;
+    function done() {
+      if (config.cancelToken) {
+        config.cancelToken.unsubscribe(onCanceled);
+      }
+      if (config.signal) {
+        config.signal.removeEventListener("abort", onCanceled);
+      }
+    }
+    if (utils$z.isFormData(requestData)) {
+      delete requestHeaders["Content-Type"];
+    }
+    var request4 = 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$4(config.baseURL, config.url);
+    request4.open(config.method.toUpperCase(), buildURL$7(fullPath, config.params, config.paramsSerializer), true);
+    request4.timeout = config.timeout;
+    function onloadend() {
+      if (!request4) {
+        return;
+      }
+      var responseHeaders = "getAllResponseHeaders" in request4 ? parseHeaders$4(request4.getAllResponseHeaders()) : null;
+      var responseData = !responseType || responseType === "text" || responseType === "json" ? request4.responseText : request4.response;
+      var response = {
+        data: responseData,
+        status: request4.status,
+        statusText: request4.statusText,
+        headers: responseHeaders,
+        config,
+        request: request4
+      };
+      settle$4(function _resolve(value) {
+        resolve(value);
+        done();
+      }, function _reject(err) {
+        reject(err);
+        done();
+      }, response);
+      request4 = null;
+    }
+    if ("onloadend" in request4) {
+      request4.onloadend = onloadend;
+    } else {
+      request4.onreadystatechange = function handleLoad() {
+        if (!request4 || request4.readyState !== 4) {
+          return;
+        }
+        if (request4.status === 0 && !(request4.responseURL && request4.responseURL.indexOf("file:") === 0)) {
+          return;
+        }
+        setTimeout(onloadend);
+      };
+    }
+    request4.onabort = function handleAbort() {
+      if (!request4) {
+        return;
+      }
+      reject(createError$6("Request aborted", config, "ECONNABORTED", request4));
+      request4 = null;
+    };
+    request4.onerror = function handleError() {
+      reject(createError$6("Network Error", config, null, request4));
+      request4 = null;
+    };
+    request4.ontimeout = function handleTimeout() {
+      var timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
+      var transitional4 = config.transitional || defaults$d.transitional;
+      if (config.timeoutErrorMessage) {
+        timeoutErrorMessage = config.timeoutErrorMessage;
+      }
+      reject(createError$6(timeoutErrorMessage, config, transitional4.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", request4));
+      request4 = null;
+    };
+    if (utils$z.isStandardBrowserEnv()) {
+      var xsrfValue = (config.withCredentials || isURLSameOrigin$4(fullPath)) && config.xsrfCookieName ? cookies$4.read(config.xsrfCookieName) : void 0;
+      if (xsrfValue) {
+        requestHeaders[config.xsrfHeaderName] = xsrfValue;
+      }
+    }
+    if ("setRequestHeader" in request4) {
+      utils$z.forEach(requestHeaders, function setRequestHeader(val, key) {
+        if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+          delete requestHeaders[key];
+        } else {
+          request4.setRequestHeader(key, val);
+        }
+      });
+    }
+    if (!utils$z.isUndefined(config.withCredentials)) {
+      request4.withCredentials = !!config.withCredentials;
+    }
+    if (responseType && responseType !== "json") {
+      request4.responseType = config.responseType;
+    }
+    if (typeof config.onDownloadProgress === "function") {
+      request4.addEventListener("progress", config.onDownloadProgress);
+    }
+    if (typeof config.onUploadProgress === "function" && request4.upload) {
+      request4.upload.addEventListener("progress", config.onUploadProgress);
+    }
+    if (config.cancelToken || config.signal) {
+      onCanceled = function(cancel) {
+        if (!request4) {
+          return;
+        }
+        reject(!cancel || cancel && cancel.type ? new Cancel$8("canceled") : cancel);
+        request4.abort();
+        request4 = null;
+      };
+      config.cancelToken && config.cancelToken.subscribe(onCanceled);
+      if (config.signal) {
+        config.signal.aborted ? onCanceled() : config.signal.addEventListener("abort", onCanceled);
+      }
+    }
+    if (!requestData) {
+      requestData = null;
+    }
+    request4.send(requestData);
+  });
+};
+var utils$y = utils$G;
+var normalizeHeaderName$4 = normalizeHeaderName$5;
+var enhanceError$6 = enhanceError$8;
+var DEFAULT_CONTENT_TYPE$2 = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function setContentTypeIfUnset$2(headers, value) {
+  if (!utils$y.isUndefined(headers) && utils$y.isUndefined(headers["Content-Type"])) {
+    headers["Content-Type"] = value;
+  }
+}
+function getDefaultAdapter$2() {
+  var adapter;
+  if (typeof XMLHttpRequest !== "undefined") {
+    adapter = xhr$2;
+  } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+    adapter = xhr$2;
+  }
+  return adapter;
+}
+function stringifySafely$2(rawValue, parser, encoder) {
+  if (utils$y.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils$y.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError") {
+        throw e;
+      }
+    }
+  }
+  return (encoder || JSON.stringify)(rawValue);
+}
+var defaults$c = {
+  transitional: {
+    silentJSONParsing: true,
+    forcedJSONParsing: true,
+    clarifyTimeoutError: false
+  },
+  adapter: getDefaultAdapter$2(),
+  transformRequest: [function transformRequest(data2, headers) {
+    normalizeHeaderName$4(headers, "Accept");
+    normalizeHeaderName$4(headers, "Content-Type");
+    if (utils$y.isFormData(data2) || utils$y.isArrayBuffer(data2) || utils$y.isBuffer(data2) || utils$y.isStream(data2) || utils$y.isFile(data2) || utils$y.isBlob(data2)) {
+      return data2;
+    }
+    if (utils$y.isArrayBufferView(data2)) {
+      return data2.buffer;
+    }
+    if (utils$y.isURLSearchParams(data2)) {
+      setContentTypeIfUnset$2(headers, "application/x-www-form-urlencoded;charset=utf-8");
+      return data2.toString();
+    }
+    if (utils$y.isObject(data2) || headers && headers["Content-Type"] === "application/json") {
+      setContentTypeIfUnset$2(headers, "application/json");
+      return stringifySafely$2(data2);
+    }
+    return data2;
+  }],
+  transformResponse: [function transformResponse(data2) {
+    var transitional4 = this.transitional || defaults$c.transitional;
+    var silentJSONParsing = transitional4 && transitional4.silentJSONParsing;
+    var forcedJSONParsing = transitional4 && transitional4.forcedJSONParsing;
+    var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+    if (strictJSONParsing || forcedJSONParsing && utils$y.isString(data2) && data2.length) {
+      try {
+        return JSON.parse(data2);
+      } catch (e) {
+        if (strictJSONParsing) {
+          if (e.name === "SyntaxError") {
+            throw enhanceError$6(e, this, "E_JSON_PARSE");
+          }
+          throw e;
+        }
+      }
+    }
+    return data2;
+  }],
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  validateStatus: function validateStatus(status) {
+    return status >= 200 && status < 300;
+  },
+  headers: {
+    common: {
+      "Accept": "application/json, text/plain, */*"
+    }
+  }
+};
+utils$y.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+  defaults$c.headers[method] = {};
+});
+utils$y.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+  defaults$c.headers[method] = utils$y.merge(DEFAULT_CONTENT_TYPE$2);
+});
+var defaults_1$2 = defaults$c;
+var utils$x = utils$G;
+var defaults$b = defaults_1$2;
+var transformData$5 = function transformData(data2, headers, fns) {
+  var context = this || defaults$b;
+  utils$x.forEach(fns, function transform(fn) {
+    data2 = fn.call(context, data2, headers);
+  });
+  return data2;
+};
+var isCancel$5 = function isCancel(value) {
+  return !!(value && value.__CANCEL__);
+};
+var utils$w = utils$G;
+var transformData$4 = transformData$5;
+var isCancel$4 = isCancel$5;
+var defaults$a = defaults_1$2;
+var Cancel$7 = Cancel_1$2;
+function throwIfCancellationRequested$2(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
+  }
+  if (config.signal && config.signal.aborted) {
+    throw new Cancel$7("canceled");
+  }
+}
+var dispatchRequest$5 = function dispatchRequest(config) {
+  throwIfCancellationRequested$2(config);
+  config.headers = config.headers || {};
+  config.data = transformData$4.call(config, config.data, config.headers, config.transformRequest);
+  config.headers = utils$w.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
+  utils$w.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) {
+    delete config.headers[method];
+  });
+  var adapter = config.adapter || defaults$a.adapter;
+  return adapter(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested$2(config);
+    response.data = transformData$4.call(config, response.data, response.headers, config.transformResponse);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel$4(reason)) {
+      throwIfCancellationRequested$2(config);
+      if (reason && reason.response) {
+        reason.response.data = transformData$4.call(config, reason.response.data, reason.response.headers, config.transformResponse);
+      }
+    }
+    return Promise.reject(reason);
+  });
+};
+var utils$v = utils$G;
+var mergeConfig$8 = function mergeConfig(config1, config2) {
+  config2 = config2 || {};
+  var config = {};
+  function getMergedValue(target, source4) {
+    if (utils$v.isPlainObject(target) && utils$v.isPlainObject(source4)) {
+      return utils$v.merge(target, source4);
+    } else if (utils$v.isPlainObject(source4)) {
+      return utils$v.merge({}, source4);
+    } else if (utils$v.isArray(source4)) {
+      return source4.slice();
+    }
+    return source4;
+  }
+  function mergeDeepProperties(prop) {
+    if (!utils$v.isUndefined(config2[prop])) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (!utils$v.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function valueFromConfig2(prop) {
+    if (!utils$v.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    }
+  }
+  function defaultToConfig2(prop) {
+    if (!utils$v.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    } else if (!utils$v.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function mergeDirectKeys(prop) {
+    if (prop in config2) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (prop in config1) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  var mergeMap = {
+    "url": valueFromConfig2,
+    "method": valueFromConfig2,
+    "data": valueFromConfig2,
+    "baseURL": defaultToConfig2,
+    "transformRequest": defaultToConfig2,
+    "transformResponse": defaultToConfig2,
+    "paramsSerializer": defaultToConfig2,
+    "timeout": defaultToConfig2,
+    "timeoutMessage": defaultToConfig2,
+    "withCredentials": defaultToConfig2,
+    "adapter": defaultToConfig2,
+    "responseType": defaultToConfig2,
+    "xsrfCookieName": defaultToConfig2,
+    "xsrfHeaderName": defaultToConfig2,
+    "onUploadProgress": defaultToConfig2,
+    "onDownloadProgress": defaultToConfig2,
+    "decompress": defaultToConfig2,
+    "maxContentLength": defaultToConfig2,
+    "maxBodyLength": defaultToConfig2,
+    "transport": defaultToConfig2,
+    "httpAgent": defaultToConfig2,
+    "httpsAgent": defaultToConfig2,
+    "cancelToken": defaultToConfig2,
+    "socketPath": defaultToConfig2,
+    "responseEncoding": defaultToConfig2,
+    "validateStatus": mergeDirectKeys
+  };
+  utils$v.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
+    var merge2 = mergeMap[prop] || mergeDeepProperties;
+    var configValue = merge2(prop);
+    utils$v.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
+  });
+  return config;
+};
+var data$1 = {
+  "version": "0.25.0"
+};
+var VERSION$1 = data$1.version;
+var validators$5 = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+  validators$5[type] = function validator2(thing) {
+    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+  };
+});
+var deprecatedWarnings$2 = {};
+validators$5.transitional = function transitional(validator2, version2, message) {
+  function formatMessage(opt, desc) {
+    return "[Axios v" + VERSION$1 + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+  }
+  return function(value, opt, opts) {
+    if (validator2 === false) {
+      throw new Error(formatMessage(opt, " has been removed" + (version2 ? " in " + version2 : "")));
+    }
+    if (version2 && !deprecatedWarnings$2[opt]) {
+      deprecatedWarnings$2[opt] = true;
+      console.warn(formatMessage(opt, " has been deprecated since v" + version2 + " and will be removed in the near future"));
+    }
+    return validator2 ? validator2(value, opt, opts) : true;
+  };
+};
+function assertOptions$2(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 validator2 = schema[opt];
+    if (validator2) {
+      var value = options[opt];
+      var result = value === void 0 || validator2(value, opt, options);
+      if (result !== true) {
+        throw new TypeError("option " + opt + " must be " + result);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw Error("Unknown option " + opt);
+    }
+  }
+}
+var validator$5 = {
+  assertOptions: assertOptions$2,
+  validators: validators$5
+};
+var utils$u = utils$G;
+var buildURL$6 = buildURL$8;
+var InterceptorManager$4 = InterceptorManager_1$2;
+var dispatchRequest$4 = dispatchRequest$5;
+var mergeConfig$7 = mergeConfig$8;
+var validator$4 = validator$5;
+var validators$4 = validator$4.validators;
+function Axios$5(instanceConfig) {
+  this.defaults = instanceConfig;
+  this.interceptors = {
+    request: new InterceptorManager$4(),
+    response: new InterceptorManager$4()
+  };
+}
+Axios$5.prototype.request = function request(configOrUrl, config) {
+  if (typeof configOrUrl === "string") {
+    config = config || {};
+    config.url = configOrUrl;
+  } else {
+    config = configOrUrl || {};
+  }
+  if (!config.url) {
+    throw new Error("Provided config url is not valid");
+  }
+  config = mergeConfig$7(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 transitional4 = config.transitional;
+  if (transitional4 !== void 0) {
+    validator$4.assertOptions(transitional4, {
+      silentJSONParsing: validators$4.transitional(validators$4.boolean),
+      forcedJSONParsing: validators$4.transitional(validators$4.boolean),
+      clarifyTimeoutError: validators$4.transitional(validators$4.boolean)
+    }, 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$4, 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$4(newConfig);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  while (responseInterceptorChain.length) {
+    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+  }
+  return promise;
+};
+Axios$5.prototype.getUri = function getUri(config) {
+  if (!config.url) {
+    throw new Error("Provided config url is not valid");
+  }
+  config = mergeConfig$7(this.defaults, config);
+  return buildURL$6(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
+};
+utils$u.forEach(["delete", "get", "head", "options"], function forEachMethodNoData2(method) {
+  Axios$5.prototype[method] = function(url, config) {
+    return this.request(mergeConfig$7(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+utils$u.forEach(["post", "put", "patch"], function forEachMethodWithData2(method) {
+  Axios$5.prototype[method] = function(url, data2, config) {
+    return this.request(mergeConfig$7(config || {}, {
+      method,
+      url,
+      data: data2
+    }));
+  };
+});
+var Axios_1$2 = Axios$5;
+var Cancel$6 = Cancel_1$2;
+function CancelToken$2(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 token2 = this;
+  this.promise.then(function(cancel) {
+    if (!token2._listeners)
+      return;
+    var i;
+    var l = token2._listeners.length;
+    for (i = 0; i < l; i++) {
+      token2._listeners[i](cancel);
+    }
+    token2._listeners = null;
+  });
+  this.promise.then = function(onfulfilled) {
+    var _resolve;
+    var promise = new Promise(function(resolve) {
+      token2.subscribe(resolve);
+      _resolve = resolve;
+    }).then(onfulfilled);
+    promise.cancel = function reject() {
+      token2.unsubscribe(_resolve);
+    };
+    return promise;
+  };
+  executor(function cancel(message) {
+    if (token2.reason) {
+      return;
+    }
+    token2.reason = new Cancel$6(message);
+    resolvePromise(token2.reason);
+  });
+}
+CancelToken$2.prototype.throwIfRequested = function throwIfRequested() {
+  if (this.reason) {
+    throw this.reason;
+  }
+};
+CancelToken$2.prototype.subscribe = function subscribe(listener) {
+  if (this.reason) {
+    listener(this.reason);
+    return;
+  }
+  if (this._listeners) {
+    this._listeners.push(listener);
+  } else {
+    this._listeners = [listener];
+  }
+};
+CancelToken$2.prototype.unsubscribe = function unsubscribe(listener) {
+  if (!this._listeners) {
+    return;
+  }
+  var index = this._listeners.indexOf(listener);
+  if (index !== -1) {
+    this._listeners.splice(index, 1);
+  }
+};
+CancelToken$2.source = function source() {
+  var cancel;
+  var token2 = new CancelToken$2(function executor(c) {
+    cancel = c;
+  });
+  return {
+    token: token2,
+    cancel
+  };
+};
+var CancelToken_1$2 = CancelToken$2;
+var spread$2 = function spread(callback) {
+  return function wrap(arr) {
+    return callback.apply(null, arr);
+  };
+};
+var utils$t = utils$G;
+var isAxiosError$2 = function isAxiosError(payload) {
+  return utils$t.isObject(payload) && payload.isAxiosError === true;
+};
+var utils$s = utils$G;
+var bind$6 = bind$8;
+var Axios$4 = Axios_1$2;
+var mergeConfig$6 = mergeConfig$8;
+var defaults$9 = defaults_1$2;
+function createInstance$2(defaultConfig) {
+  var context = new Axios$4(defaultConfig);
+  var instance = bind$6(Axios$4.prototype.request, context);
+  utils$s.extend(instance, Axios$4.prototype, context);
+  utils$s.extend(instance, context);
+  instance.create = function create2(instanceConfig) {
+    return createInstance$2(mergeConfig$6(defaultConfig, instanceConfig));
+  };
+  return instance;
+}
+var axios$7 = createInstance$2(defaults$9);
+axios$7.Axios = Axios$4;
+axios$7.Cancel = Cancel_1$2;
+axios$7.CancelToken = CancelToken_1$2;
+axios$7.isCancel = isCancel$5;
+axios$7.VERSION = data$1.version;
+axios$7.all = function all(promises) {
+  return Promise.all(promises);
+};
+axios$7.spread = spread$2;
+axios$7.isAxiosError = isAxiosError$2;
+axios$8.exports = axios$7;
+axios$8.exports.default = axios$7;
+var axios$6 = axios$8.exports;
+const SERVER_ERROR_CODE = 500;
+class HasuraAuthApi {
+  constructor({ url = "" }) {
+    this.url = url;
+    this.httpClient = axios$6.create({
+      baseURL: this.url
+    });
+    this.httpClient.interceptors.response.use((response) => response, (error) => {
+      var _a, _b, _c, _d, _e, _f;
+      return Promise.reject({
+        message: (_d = (_c = (_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) != null ? _c : error.message) != null ? _d : JSON.stringify(error),
+        status: (_f = (_e = error.response) == null ? void 0 : _e.status) != null ? _f : SERVER_ERROR_CODE
+      });
+    });
+  }
+  async signUpEmailPassword(params) {
+    try {
+      const res = await this.httpClient.post("/signup/email-password", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signInEmailPassword(params) {
+    try {
+      const res = await this.httpClient.post("/signin/email-password", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signInPasswordlessEmail(params) {
+    try {
+      const res = await this.httpClient.post("/signin/passwordless/email", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signInPasswordlessSms(params) {
+    try {
+      const res = await this.httpClient.post("/signin/passwordless/sms", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signInPasswordlessSmsOtp(params) {
+    try {
+      const res = await this.httpClient.post("/signin/passwordless/sms/otp", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signOut(params) {
+    try {
+      await this.httpClient.post("/signout", params);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async refreshToken(params) {
+    try {
+      const res = await this.httpClient.post("/token", params);
+      return { error: null, session: res.data };
+    } catch (error) {
+      return { error, session: null };
+    }
+  }
+  async resetPassword(params) {
+    try {
+      await this.httpClient.post("/user/password/reset", params);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async changePassword(params) {
+    try {
+      await this.httpClient.post("/user/password", params, {
+        headers: __spreadValues({}, this.generateAuthHeaders())
+      });
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async sendVerificationEmail(params) {
+    try {
+      await this.httpClient.post("/user/email/send-verification-email", params);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async changeEmail(params) {
+    try {
+      await this.httpClient.post("/user/email/change", params, {
+        headers: __spreadValues({}, this.generateAuthHeaders())
+      });
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async deanonymize(params) {
+    try {
+      await this.httpClient.post("/user/deanonymize", params);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async verifyEmail(params) {
+    try {
+      const res = await this.httpClient.post("/user/email/verify", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  setAccessToken(accessToken) {
+    this.accessToken = accessToken;
+  }
+  generateAuthHeaders() {
+    if (!this.accessToken) {
+      return null;
+    }
+    return {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+  }
+}
+var queryString = {};
+var strictUriEncode = (str) => encodeURIComponent(str).replace(/[!'()*]/g, (x) => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+var token = "%[a-f0-9]{2}";
+var singleMatcher = new RegExp(token, "gi");
+var multiMatcher = new RegExp("(" + token + ")+", "gi");
+function decodeComponents(components, split) {
+  try {
+    return decodeURIComponent(components.join(""));
+  } catch (err) {
+  }
+  if (components.length === 1) {
+    return components;
+  }
+  split = split || 1;
+  var left = components.slice(0, split);
+  var right = components.slice(split);
+  return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode(input) {
+  try {
+    return decodeURIComponent(input);
+  } catch (err) {
+    var tokens = input.match(singleMatcher);
+    for (var i = 1; i < tokens.length; i++) {
+      input = decodeComponents(tokens, i).join("");
+      tokens = input.match(singleMatcher);
+    }
+    return input;
+  }
+}
+function customDecodeURIComponent(input) {
+  var replaceMap = {
+    "%FE%FF": "\uFFFD\uFFFD",
+    "%FF%FE": "\uFFFD\uFFFD"
+  };
+  var match = multiMatcher.exec(input);
+  while (match) {
+    try {
+      replaceMap[match[0]] = decodeURIComponent(match[0]);
+    } catch (err) {
+      var result = decode(match[0]);
+      if (result !== match[0]) {
+        replaceMap[match[0]] = result;
+      }
+    }
+    match = multiMatcher.exec(input);
+  }
+  replaceMap["%C2"] = "\uFFFD";
+  var entries = Object.keys(replaceMap);
+  for (var i = 0; i < entries.length; i++) {
+    var key = entries[i];
+    input = input.replace(new RegExp(key, "g"), replaceMap[key]);
+  }
+  return input;
+}
+var decodeUriComponent = function(encodedURI) {
+  if (typeof encodedURI !== "string") {
+    throw new TypeError("Expected `encodedURI` to be of type `string`, got `" + typeof encodedURI + "`");
+  }
+  try {
+    encodedURI = encodedURI.replace(/\+/g, " ");
+    return decodeURIComponent(encodedURI);
+  } catch (err) {
+    return customDecodeURIComponent(encodedURI);
+  }
+};
+var splitOnFirst = (string, separator) => {
+  if (!(typeof string === "string" && typeof separator === "string")) {
+    throw new TypeError("Expected the arguments to be of type `string`");
+  }
+  if (separator === "") {
+    return [string];
+  }
+  const separatorIndex = string.indexOf(separator);
+  if (separatorIndex === -1) {
+    return [string];
+  }
+  return [
+    string.slice(0, separatorIndex),
+    string.slice(separatorIndex + separator.length)
+  ];
+};
+var filterObj = function(obj, predicate) {
+  var ret = {};
+  var keys = Object.keys(obj);
+  var isArr = Array.isArray(predicate);
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var val = obj[key];
+    if (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {
+      ret[key] = val;
+    }
+  }
+  return ret;
+};
+(function(exports) {
+  const strictUriEncode$1 = strictUriEncode;
+  const decodeComponent = decodeUriComponent;
+  const splitOnFirst$1 = splitOnFirst;
+  const filterObject = filterObj;
+  const isNullOrUndefined = (value) => value === null || value === void 0;
+  const encodeFragmentIdentifier = Symbol("encodeFragmentIdentifier");
+  function encoderForArrayFormat(options) {
+    switch (options.arrayFormat) {
+      case "index":
+        return (key) => (result, value) => {
+          const index = result.length;
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode2(key, options), "[", index, "]"].join("")];
+          }
+          return [
+            ...result,
+            [encode2(key, options), "[", encode2(index, options), "]=", encode2(value, options)].join("")
+          ];
+        };
+      case "bracket":
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode2(key, options), "[]"].join("")];
+          }
+          return [...result, [encode2(key, options), "[]=", encode2(value, options)].join("")];
+        };
+      case "colon-list-separator":
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode2(key, options), ":list="].join("")];
+          }
+          return [...result, [encode2(key, options), ":list=", encode2(value, options)].join("")];
+        };
+      case "comma":
+      case "separator":
+      case "bracket-separator": {
+        const keyValueSep = options.arrayFormat === "bracket-separator" ? "[]=" : "=";
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          value = value === null ? "" : value;
+          if (result.length === 0) {
+            return [[encode2(key, options), keyValueSep, encode2(value, options)].join("")];
+          }
+          return [[result, encode2(value, options)].join(options.arrayFormatSeparator)];
+        };
+      }
+      default:
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, encode2(key, options)];
+          }
+          return [...result, [encode2(key, options), "=", encode2(value, options)].join("")];
+        };
+    }
+  }
+  function parserForArrayFormat(options) {
+    let result;
+    switch (options.arrayFormat) {
+      case "index":
+        return (key, value, accumulator) => {
+          result = /\[(\d*)\]$/.exec(key);
+          key = key.replace(/\[\d*\]$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = {};
+          }
+          accumulator[key][result[1]] = value;
+        };
+      case "bracket":
+        return (key, value, accumulator) => {
+          result = /(\[\])$/.exec(key);
+          key = key.replace(/\[\]$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = [value];
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+      case "colon-list-separator":
+        return (key, value, accumulator) => {
+          result = /(:list)$/.exec(key);
+          key = key.replace(/:list$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = [value];
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+      case "comma":
+      case "separator":
+        return (key, value, accumulator) => {
+          const isArray2 = typeof value === "string" && value.includes(options.arrayFormatSeparator);
+          const isEncodedArray = typeof value === "string" && !isArray2 && decode2(value, options).includes(options.arrayFormatSeparator);
+          value = isEncodedArray ? decode2(value, options) : value;
+          const newValue = isArray2 || isEncodedArray ? value.split(options.arrayFormatSeparator).map((item) => decode2(item, options)) : value === null ? value : decode2(value, options);
+          accumulator[key] = newValue;
+        };
+      case "bracket-separator":
+        return (key, value, accumulator) => {
+          const isArray2 = /(\[\])$/.test(key);
+          key = key.replace(/\[\]$/, "");
+          if (!isArray2) {
+            accumulator[key] = value ? decode2(value, options) : value;
+            return;
+          }
+          const arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map((item) => decode2(item, options));
+          if (accumulator[key] === void 0) {
+            accumulator[key] = arrayValue;
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], arrayValue);
+        };
+      default:
+        return (key, value, accumulator) => {
+          if (accumulator[key] === void 0) {
+            accumulator[key] = value;
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+    }
+  }
+  function validateArrayFormatSeparator(value) {
+    if (typeof value !== "string" || value.length !== 1) {
+      throw new TypeError("arrayFormatSeparator must be single character string");
+    }
+  }
+  function encode2(value, options) {
+    if (options.encode) {
+      return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
+    }
+    return value;
+  }
+  function decode2(value, options) {
+    if (options.decode) {
+      return decodeComponent(value);
+    }
+    return value;
+  }
+  function keysSorter(input) {
+    if (Array.isArray(input)) {
+      return input.sort();
+    }
+    if (typeof input === "object") {
+      return keysSorter(Object.keys(input)).sort((a, b) => Number(a) - Number(b)).map((key) => input[key]);
+    }
+    return input;
+  }
+  function removeHash(input) {
+    const hashStart = input.indexOf("#");
+    if (hashStart !== -1) {
+      input = input.slice(0, hashStart);
+    }
+    return input;
+  }
+  function getHash(url) {
+    let hash = "";
+    const hashStart = url.indexOf("#");
+    if (hashStart !== -1) {
+      hash = url.slice(hashStart);
+    }
+    return hash;
+  }
+  function extract(input) {
+    input = removeHash(input);
+    const queryStart = input.indexOf("?");
+    if (queryStart === -1) {
+      return "";
+    }
+    return input.slice(queryStart + 1);
+  }
+  function parseValue(value, options) {
+    if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
+      value = Number(value);
+    } else if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
+      value = value.toLowerCase() === "true";
+    }
+    return value;
+  }
+  function parse(query, options) {
+    options = Object.assign({
+      decode: true,
+      sort: true,
+      arrayFormat: "none",
+      arrayFormatSeparator: ",",
+      parseNumbers: false,
+      parseBooleans: false
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const formatter = parserForArrayFormat(options);
+    const ret = Object.create(null);
+    if (typeof query !== "string") {
+      return ret;
+    }
+    query = query.trim().replace(/^[?#&]/, "");
+    if (!query) {
+      return ret;
+    }
+    for (const param of query.split("&")) {
+      if (param === "") {
+        continue;
+      }
+      let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, " ") : param, "=");
+      value = value === void 0 ? null : ["comma", "separator", "bracket-separator"].includes(options.arrayFormat) ? value : decode2(value, options);
+      formatter(decode2(key, options), value, ret);
+    }
+    for (const key of Object.keys(ret)) {
+      const value = ret[key];
+      if (typeof value === "object" && value !== null) {
+        for (const k of Object.keys(value)) {
+          value[k] = parseValue(value[k], options);
+        }
+      } else {
+        ret[key] = parseValue(value, options);
+      }
+    }
+    if (options.sort === false) {
+      return ret;
+    }
+    return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
+      const value = ret[key];
+      if (Boolean(value) && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = keysSorter(value);
+      } else {
+        result[key] = value;
+      }
+      return result;
+    }, Object.create(null));
+  }
+  exports.extract = extract;
+  exports.parse = parse;
+  exports.stringify = (object, options) => {
+    if (!object) {
+      return "";
+    }
+    options = Object.assign({
+      encode: true,
+      strict: true,
+      arrayFormat: "none",
+      arrayFormatSeparator: ","
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const shouldFilter = (key) => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
+    const formatter = encoderForArrayFormat(options);
+    const objectCopy = {};
+    for (const key of Object.keys(object)) {
+      if (!shouldFilter(key)) {
+        objectCopy[key] = object[key];
+      }
+    }
+    const keys = Object.keys(objectCopy);
+    if (options.sort !== false) {
+      keys.sort(options.sort);
+    }
+    return keys.map((key) => {
+      const value = object[key];
+      if (value === void 0) {
+        return "";
+      }
+      if (value === null) {
+        return encode2(key, options);
+      }
+      if (Array.isArray(value)) {
+        if (value.length === 0 && options.arrayFormat === "bracket-separator") {
+          return encode2(key, options) + "[]";
+        }
+        return value.reduce(formatter(key), []).join("&");
+      }
+      return encode2(key, options) + "=" + encode2(value, options);
+    }).filter((x) => x.length > 0).join("&");
+  };
+  exports.parseUrl = (url, options) => {
+    options = Object.assign({
+      decode: true
+    }, options);
+    const [url_, hash] = splitOnFirst$1(url, "#");
+    return Object.assign({
+      url: url_.split("?")[0] || "",
+      query: parse(extract(url), options)
+    }, options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode2(hash, options) } : {});
+  };
+  exports.stringifyUrl = (object, options) => {
+    options = Object.assign({
+      encode: true,
+      strict: true,
+      [encodeFragmentIdentifier]: true
+    }, options);
+    const url = removeHash(object.url).split("?")[0] || "";
+    const queryFromUrl = exports.extract(object.url);
+    const parsedQueryFromUrl = exports.parse(queryFromUrl, { sort: false });
+    const query = Object.assign(parsedQueryFromUrl, object.query);
+    let queryString2 = exports.stringify(query, options);
+    if (queryString2) {
+      queryString2 = `?${queryString2}`;
+    }
+    let hash = getHash(object.url);
+    if (object.fragmentIdentifier) {
+      hash = `#${options[encodeFragmentIdentifier] ? encode2(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;
+    }
+    return `${url}${queryString2}${hash}`;
+  };
+  exports.pick = (input, filter, options) => {
+    options = Object.assign({
+      parseFragmentIdentifier: true,
+      [encodeFragmentIdentifier]: false
+    }, options);
+    const { url, query, fragmentIdentifier } = exports.parseUrl(input, options);
+    return exports.stringifyUrl({
+      url,
+      query: filterObject(query, filter),
+      fragmentIdentifier
+    }, options);
+  };
+  exports.exclude = (input, filter, options) => {
+    const exclusionFilter = Array.isArray(filter) ? (key) => !filter.includes(key) : (key, value) => !filter(key, value);
+    return exports.pick(input, exclusionFilter, options);
+  };
+})(queryString);
+const NHOST_REFRESH_TOKEN = "nhostRefreshToken";
+const isBrowser = () => typeof window !== "undefined";
+class inMemoryLocalStorage {
+  constructor() {
+    this.memory = {};
+  }
+  setItem(key, value) {
+    this.memory[key] = value;
+  }
+  getItem(key) {
+    return this.memory[key];
+  }
+  removeItem(key) {
+    delete this.memory[key];
+  }
+}
+class HasuraAuthClient {
+  constructor({
+    url,
+    autoRefreshToken = true,
+    autoLogin = true,
+    refreshIntervalTime,
+    clientStorage,
+    clientStorageType = "web"
+  }) {
+    this.refreshIntervalTime = refreshIntervalTime;
+    if (!clientStorage) {
+      this.clientStorage = isBrowser() ? localStorage : new inMemoryLocalStorage();
+    } else {
+      this.clientStorage = clientStorage;
+    }
+    this.clientStorageType = clientStorageType;
+    this.onTokenChangedFunctions = [];
+    this.onAuthChangedFunctions = [];
+    this.refreshInterval;
+    this.refreshSleepCheckInterval = 0;
+    this.refreshIntervalSleepCheckLastSample = Date.now();
+    this.sampleRate = 2e3;
+    this.url = url;
+    this.autoRefreshToken = autoRefreshToken;
+    this.initAuthLoading = true;
+    this.session = null;
+    this.api = new HasuraAuthApi({ url: this.url });
+    let refreshToken = null;
+    let autoLoginFromQueryParameters = false;
+    if (autoLogin && isBrowser() && window.location) {
+      const urlParams = queryString.parse(window.location.toString().split("#")[1]);
+      if ("refreshToken" in urlParams) {
+        refreshToken = urlParams.refreshToken;
+      }
+      if ("otp" in urlParams && "email" in urlParams) {
+        const { otp, email } = urlParams;
+        this.signIn({
+          otp,
+          email
+        });
+        autoLoginFromQueryParameters = true;
+      }
+    }
+    if (!autoLoginFromQueryParameters && autoLogin) {
+      this._autoLogin(refreshToken);
+    } else if (refreshToken) {
+      this._setItem(NHOST_REFRESH_TOKEN, refreshToken);
+    }
+  }
+  async signUp(params) {
+    const { email, password } = params;
+    if (email && password) {
+      const { data: data2, error } = await this.api.signUpEmailPassword(params);
+      if (error) {
+        return { session: null, error };
+      }
+      if (!data2) {
+        return {
+          session: null,
+          error: { message: "An error occurred on sign up.", status: 500 }
+        };
+      }
+      const { session } = data2;
+      if (session) {
+        await this._setSession(session);
+      }
+      return { session, error: null };
+    }
+    return {
+      session: null,
+      error: { message: "Incorrect parameters", status: 500 }
+    };
+  }
+  async signIn(params) {
+    if ("provider" in params) {
+      const { provider } = params;
+      const providerUrl = `${this.url}/signin/provider/${provider}`;
+      if (isBrowser()) {
+        window.location.href = providerUrl;
+      }
+      return { providerUrl, provider, session: null, mfa: null, error: null };
+    }
+    if ("email" in params && "password" in params) {
+      const { data: data2, error } = await this.api.signInEmailPassword(params);
+      if (error) {
+        return { session: null, mfa: null, error };
+      }
+      if (!data2) {
+        return {
+          session: null,
+          mfa: null,
+          error: { message: "Incorrect Data", status: 500 }
+        };
+      }
+      const { session, mfa } = data2;
+      if (session) {
+        await this._setSession(session);
+      }
+      return { session, mfa, error: null };
+    }
+    if ("email" in params && !("otp" in params)) {
+      const { error } = await this.api.signInPasswordlessEmail(params);
+      if (error) {
+        return { session: null, mfa: null, error };
+      }
+      return { session: null, mfa: null, error: null };
+    }
+    if ("phoneNumber" in params && !("otp" in params)) {
+      const { error } = await this.api.signInPasswordlessSms(params);
+      if (error) {
+        return { session: null, mfa: null, error };
+      }
+      return { session: null, mfa: null, error: null };
+    }
+    if ("otp" in params) {
+      const { data: data2, error } = await this.api.signInPasswordlessSmsOtp(params);
+      if (error) {
+        return { session: null, mfa: null, error };
+      }
+      if (!data2) {
+        return {
+          session: null,
+          mfa: null,
+          error: { message: "Incorrect data", status: 500 }
+        };
+      }
+      const { session, mfa } = data2;
+      if (session) {
+        await this._setSession(session);
+      }
+      return { session, mfa, error: null };
+    }
+    return {
+      session: null,
+      mfa: null,
+      error: { message: "Incorrect parameters", status: 500 }
+    };
+  }
+  async signOut(params) {
+    const refreshToken = await this._getItem(NHOST_REFRESH_TOKEN);
+    this._clearSession();
+    const { error } = await this.api.signOut({
+      refreshToken,
+      all: params == null ? void 0 : params.all
+    });
+    return { error };
+  }
+  async verifyEmail(params) {
+    return await this.api.verifyEmail(params);
+  }
+  async resetPassword(params) {
+    const { error } = await this.api.resetPassword(params);
+    return { error };
+  }
+  async changePassword(params) {
+    const { error } = await this.api.changePassword(params);
+    return { error };
+  }
+  async sendVerificationEmail(params) {
+    const { error } = await this.api.sendVerificationEmail(params);
+    return { error };
+  }
+  async changeEmail(params) {
+    const { error } = await this.api.changeEmail(params);
+    return { error };
+  }
+  async deanonymize(params) {
+    const { error } = await this.api.deanonymize(params);
+    return { error };
+  }
+  onTokenChanged(fn) {
+    this.onTokenChangedFunctions.push(fn);
+    const index = this.onTokenChangedFunctions.length - 1;
+    const unsubscribe3 = () => {
+      try {
+        this.onTokenChangedFunctions[index] = () => {
+        };
+      } catch {
+        console.warn("Unable to unsubscribe onTokenChanged function. Maybe the functions is already unsubscribed?");
+      }
+    };
+    return unsubscribe3;
+  }
+  onAuthStateChanged(fn) {
+    this.onAuthChangedFunctions.push(fn);
+    const index = this.onAuthChangedFunctions.length - 1;
+    const unsubscribe3 = () => {
+      try {
+        this.onAuthChangedFunctions[index] = () => {
+        };
+      } catch {
+        console.warn("Unable to unsubscribe onAuthStateChanged function. Maybe you already did?");
+      }
+    };
+    return unsubscribe3;
+  }
+  isAuthenticated() {
+    return this.session !== null;
+  }
+  async isAuthenticatedAsync() {
+    return new Promise((resolve) => {
+      if (!this.initAuthLoading) {
+        resolve(this.isAuthenticated());
+      } else {
+        const unsubscribe3 = this.onAuthStateChanged((event, _session) => {
+          resolve(event === "SIGNED_IN");
+          unsubscribe3();
+        });
+      }
+    });
+  }
+  getAuthenticationStatus() {
+    if (this.initAuthLoading)
+      return { isAuthenticated: false, isLoading: true };
+    return { isAuthenticated: this.session !== null, isLoading: false };
+  }
+  getJWTToken() {
+    return this.getAccessToken();
+  }
+  getAccessToken() {
+    if (!this.session) {
+      return void 0;
+    }
+    return this.session.accessToken;
+  }
+  async refreshSession(refreshToken) {
+    const refreshTokenToUse = refreshToken || await this._getItem(NHOST_REFRESH_TOKEN);
+    if (!refreshTokenToUse) {
+      console.warn("no refresh token found. No way of refreshing session");
+    }
+    return this._refreshTokens(refreshTokenToUse);
+  }
+  getSession() {
+    return this.session;
+  }
+  getUser() {
+    return this.session ? this.session.user : null;
+  }
+  async _setItem(key, value) {
+    if (typeof value !== "string") {
+      console.error(`value is not of type "string"`);
+      return;
+    }
+    switch (this.clientStorageType) {
+      case "web":
+        if (typeof this.clientStorage.setItem !== "function") {
+          console.error(`this.clientStorage.setItem is not a function`);
+          break;
+        }
+        this.clientStorage.setItem(key, value);
+        break;
+      case "custom":
+      case "react-native":
+        if (typeof this.clientStorage.setItem !== "function") {
+          console.error(`this.clientStorage.setItem is not a function`);
+          break;
+        }
+        await this.clientStorage.setItem(key, value);
+        break;
+      case "capacitor":
+        if (typeof this.clientStorage.set !== "function") {
+          console.error(`this.clientStorage.set is not a function`);
+          break;
+        }
+        await this.clientStorage.set({ key, value });
+        break;
+      case "expo-secure-storage":
+        if (typeof this.clientStorage.setItemAsync !== "function") {
+          console.error(`this.clientStorage.setItemAsync is not a function`);
+          break;
+        }
+        this.clientStorage.setItemAsync(key, value);
+        break;
+    }
+  }
+  async _getItem(key) {
+    switch (this.clientStorageType) {
+      case "web":
+        if (typeof this.clientStorage.getItem !== "function") {
+          console.error(`this.clientStorage.getItem is not a function`);
+          break;
+        }
+        return this.clientStorage.getItem(key);
+      case "custom":
+      case "react-native":
+        if (typeof this.clientStorage.getItem !== "function") {
+          console.error(`this.clientStorage.getItem is not a function`);
+          break;
+        }
+        return await this.clientStorage.getItem(key);
+      case "capacitor":
+        if (typeof this.clientStorage.get !== "function") {
+          console.error(`this.clientStorage.get is not a function`);
+          break;
+        }
+        const res = await this.clientStorage.get({ key });
+        return res.value;
+      case "expo-secure-storage":
+        if (typeof this.clientStorage.getItemAsync !== "function") {
+          console.error(`this.clientStorage.getItemAsync is not a function`);
+          break;
+        }
+        return this.clientStorage.getItemAsync(key);
+      default:
+        return "";
+    }
+    return "";
+  }
+  async _removeItem(key) {
+    switch (this.clientStorageType) {
+      case "web":
+        if (typeof this.clientStorage.removeItem !== "function") {
+          console.error(`this.clientStorage.removeItem is not a function`);
+          break;
+        }
+        return void this.clientStorage.removeItem(key);
+      case "custom":
+      case "react-native":
+        if (typeof this.clientStorage.removeItem !== "function") {
+          console.error(`this.clientStorage.removeItem is not a function`);
+          break;
+        }
+        return void this.clientStorage.removeItem(key);
+      case "capacitor":
+        if (typeof this.clientStorage.remove !== "function") {
+          console.error(`this.clientStorage.remove is not a function`);
+          break;
+        }
+        await this.clientStorage.remove({ key });
+        break;
+      case "expo-secure-storage":
+        if (typeof this.clientStorage.deleteItemAsync !== "function") {
+          console.error(`this.clientStorage.deleteItemAsync is not a function`);
+          break;
+        }
+        this.clientStorage.deleteItemAsync(key);
+        break;
+    }
+  }
+  _autoLogin(refreshToken) {
+    if (!isBrowser()) {
+      return;
+    }
+    this._refreshTokens(refreshToken);
+  }
+  async _refreshTokens(paramRefreshToken) {
+    const refreshToken = paramRefreshToken || await this._getItem(NHOST_REFRESH_TOKEN);
+    if (!refreshToken) {
+      setTimeout(async () => {
+        await this._clearSession();
+      }, 0);
+      return;
+    }
+    try {
+      const { session, error } = await this.api.refreshToken({ refreshToken });
+      if (error && error.status === 401) {
+        await this._clearSession();
+        return;
+      }
+      if (!session)
+        throw new Error("Invalid session data");
+      await this._setSession(session);
+      this.tokenChanged();
+    } catch {
+    }
+  }
+  tokenChanged() {
+    for (const tokenChangedFunction of this.onTokenChangedFunctions) {
+      tokenChangedFunction(this.session);
+    }
+  }
+  authStateChanged({
+    event,
+    session
+  }) {
+    if (event === "SIGNED_IN" && session) {
+      this.api.setAccessToken(session.accessToken);
+    } else {
+      this.api.setAccessToken(void 0);
+    }
+    for (const authChangedFunction of this.onAuthChangedFunctions) {
+      authChangedFunction(event, session);
+    }
+  }
+  async _clearSession() {
+    const { isLoading, isAuthenticated } = this.getAuthenticationStatus();
+    this.session = null;
+    this.initAuthLoading = false;
+    await this._removeItem(NHOST_REFRESH_TOKEN);
+    if (isLoading || isAuthenticated) {
+      clearInterval(this.refreshInterval);
+      clearInterval(this.refreshSleepCheckInterval);
+      this.authStateChanged({ event: "SIGNED_OUT", session: null });
+    }
+  }
+  async _setSession(session) {
+    const { isAuthenticated } = this.getAuthenticationStatus();
+    this.session = session;
+    await this._setItem(NHOST_REFRESH_TOKEN, session.refreshToken);
+    if (this.autoRefreshToken && !isAuthenticated) {
+      const JWTExpiresIn = session.accessTokenExpiresIn;
+      const refreshIntervalTime = this.refreshIntervalTime ? this.refreshIntervalTime : Math.max(1, JWTExpiresIn - 1);
+      this.refreshInterval = setInterval(async () => {
+        const refreshToken = await this._getItem(NHOST_REFRESH_TOKEN);
+        await this._refreshTokens(refreshToken);
+      }, refreshIntervalTime * 1e3);
+      this.refreshIntervalSleepCheckLastSample = Date.now();
+      this.refreshSleepCheckInterval = setInterval(async () => {
+        if (Date.now() - this.refreshIntervalSleepCheckLastSample >= this.sampleRate * 2) {
+          const refreshToken = await this._getItem(NHOST_REFRESH_TOKEN);
+          await this._refreshTokens(refreshToken);
+        }
+        this.refreshIntervalSleepCheckLastSample = Date.now();
+      }, this.sampleRate);
+      this.authStateChanged({ event: "SIGNED_IN", session: this.session });
+    }
+    this.initAuthLoading = false;
+  }
+}
+var axios$5 = { exports: {} };
+var bind$5 = function bind2(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);
+  };
+};
+var bind$4 = bind$5;
+var toString$1 = Object.prototype.toString;
+function isArray$1(val) {
+  return toString$1.call(val) === "[object Array]";
+}
+function isUndefined$1(val) {
+  return typeof val === "undefined";
+}
+function isBuffer$1(val) {
+  return val !== null && !isUndefined$1(val) && val.constructor !== null && !isUndefined$1(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+}
+function isArrayBuffer$1(val) {
+  return toString$1.call(val) === "[object ArrayBuffer]";
+}
+function isFormData$1(val) {
+  return typeof FormData !== "undefined" && val instanceof FormData;
+}
+function isArrayBufferView$1(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$1(val) {
+  return typeof val === "string";
+}
+function isNumber$1(val) {
+  return typeof val === "number";
+}
+function isObject$1(val) {
+  return val !== null && typeof val === "object";
+}
+function isPlainObject$1(val) {
+  if (toString$1.call(val) !== "[object Object]") {
+    return false;
+  }
+  var prototype = Object.getPrototypeOf(val);
+  return prototype === null || prototype === Object.prototype;
+}
+function isDate$1(val) {
+  return toString$1.call(val) === "[object Date]";
+}
+function isFile$1(val) {
+  return toString$1.call(val) === "[object File]";
+}
+function isBlob$1(val) {
+  return toString$1.call(val) === "[object Blob]";
+}
+function isFunction$1(val) {
+  return toString$1.call(val) === "[object Function]";
+}
+function isStream$1(val) {
+  return isObject$1(val) && isFunction$1(val.pipe);
+}
+function isURLSearchParams$1(val) {
+  return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
+}
+function trim$1(str) {
+  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+}
+function isStandardBrowserEnv$1() {
+  if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+    return false;
+  }
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function forEach$1(obj, fn) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray$1(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$1() {
+  var result = {};
+  function assignValue(val, key) {
+    if (isPlainObject$1(result[key]) && isPlainObject$1(val)) {
+      result[key] = merge$1(result[key], val);
+    } else if (isPlainObject$1(val)) {
+      result[key] = merge$1({}, val);
+    } else if (isArray$1(val)) {
+      result[key] = val.slice();
+    } else {
+      result[key] = val;
+    }
+  }
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    forEach$1(arguments[i], assignValue);
+  }
+  return result;
+}
+function extend$1(a, b, thisArg) {
+  forEach$1(b, function assignValue(val, key) {
+    if (thisArg && typeof val === "function") {
+      a[key] = bind$4(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  });
+  return a;
+}
+function stripBOM$1(content) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+}
+var utils$r = {
+  isArray: isArray$1,
+  isArrayBuffer: isArrayBuffer$1,
+  isBuffer: isBuffer$1,
+  isFormData: isFormData$1,
+  isArrayBufferView: isArrayBufferView$1,
+  isString: isString$1,
+  isNumber: isNumber$1,
+  isObject: isObject$1,
+  isPlainObject: isPlainObject$1,
+  isUndefined: isUndefined$1,
+  isDate: isDate$1,
+  isFile: isFile$1,
+  isBlob: isBlob$1,
+  isFunction: isFunction$1,
+  isStream: isStream$1,
+  isURLSearchParams: isURLSearchParams$1,
+  isStandardBrowserEnv: isStandardBrowserEnv$1,
+  forEach: forEach$1,
+  merge: merge$1,
+  extend: extend$1,
+  trim: trim$1,
+  stripBOM: stripBOM$1
+};
+var utils$q = utils$r;
+function encode$1(val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+var buildURL$5 = function buildURL2(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (utils$q.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    utils$q.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (utils$q.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      utils$q.forEach(val, function parseValue(v) {
+        if (utils$q.isDate(v)) {
+          v = v.toISOString();
+        } else if (utils$q.isObject(v)) {
+          v = JSON.stringify(v);
+        }
+        parts.push(encode$1(key) + "=" + encode$1(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;
+};
+var utils$p = utils$r;
+function InterceptorManager$3() {
+  this.handlers = [];
+}
+InterceptorManager$3.prototype.use = function use2(fulfilled, rejected, options) {
+  this.handlers.push({
+    fulfilled,
+    rejected,
+    synchronous: options ? options.synchronous : false,
+    runWhen: options ? options.runWhen : null
+  });
+  return this.handlers.length - 1;
+};
+InterceptorManager$3.prototype.eject = function eject2(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager$3.prototype.forEach = function forEach2(fn) {
+  utils$p.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+var InterceptorManager_1$1 = InterceptorManager$3;
+var utils$o = utils$r;
+var normalizeHeaderName$3 = function normalizeHeaderName2(headers, normalizedName) {
+  utils$o.forEach(headers, function processHeader(value, name2) {
+    if (name2 !== normalizedName && name2.toUpperCase() === normalizedName.toUpperCase()) {
+      headers[normalizedName] = value;
+      delete headers[name2];
+    }
+  });
+};
+var enhanceError$5 = function enhanceError2(error, config, code, request4, response) {
+  error.config = config;
+  if (code) {
+    error.code = code;
+  }
+  error.request = request4;
+  error.response = response;
+  error.isAxiosError = true;
+  error.toJSON = function toJSON() {
+    return {
+      message: this.message,
+      name: this.name,
+      description: this.description,
+      number: this.number,
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      config: this.config,
+      code: this.code
+    };
+  };
+  return error;
+};
+var enhanceError$4 = enhanceError$5;
+var createError$5 = function createError2(message, config, code, request4, response) {
+  var error = new Error(message);
+  return enhanceError$4(error, config, code, request4, response);
+};
+var createError$4 = createError$5;
+var settle$3 = function settle2(resolve, reject, response) {
+  var validateStatus4 = response.config.validateStatus;
+  if (!response.status || !validateStatus4 || validateStatus4(response.status)) {
+    resolve(response);
+  } else {
+    reject(createError$4("Request failed with status code " + response.status, response.config, null, response.request, response));
+  }
+};
+var utils$n = utils$r;
+var cookies$3 = utils$n.isStandardBrowserEnv() ? function standardBrowserEnv3() {
+  return {
+    write: function write(name2, value, expires, path, domain, secure) {
+      var cookie = [];
+      cookie.push(name2 + "=" + encodeURIComponent(value));
+      if (utils$n.isNumber(expires)) {
+        cookie.push("expires=" + new Date(expires).toGMTString());
+      }
+      if (utils$n.isString(path)) {
+        cookie.push("path=" + path);
+      }
+      if (utils$n.isString(domain)) {
+        cookie.push("domain=" + domain);
+      }
+      if (secure === true) {
+        cookie.push("secure");
+      }
+      document.cookie = cookie.join("; ");
+    },
+    read: function read(name2) {
+      var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name2 + ")=([^;]*)"));
+      return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove: function remove(name2) {
+      this.write(name2, "", Date.now() - 864e5);
+    }
+  };
+}() : function nonStandardBrowserEnv3() {
+  return {
+    write: function write() {
+    },
+    read: function read() {
+      return null;
+    },
+    remove: function remove() {
+    }
+  };
+}();
+var isAbsoluteURL$3 = function isAbsoluteURL2(url) {
+  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+};
+var combineURLs$3 = function combineURLs2(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+};
+var isAbsoluteURL$2 = isAbsoluteURL$3;
+var combineURLs$2 = combineURLs$3;
+var buildFullPath$3 = function buildFullPath2(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL$2(requestedURL)) {
+    return combineURLs$2(baseURL, requestedURL);
+  }
+  return requestedURL;
+};
+var utils$m = utils$r;
+var ignoreDuplicateOf$1 = [
+  "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"
+];
+var parseHeaders$3 = function parseHeaders2(headers) {
+  var parsed = {};
+  var key;
+  var val;
+  var i;
+  if (!headers) {
+    return parsed;
+  }
+  utils$m.forEach(headers.split("\n"), function parser(line) {
+    i = line.indexOf(":");
+    key = utils$m.trim(line.substr(0, i)).toLowerCase();
+    val = utils$m.trim(line.substr(i + 1));
+    if (key) {
+      if (parsed[key] && ignoreDuplicateOf$1.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;
+};
+var utils$l = utils$r;
+var isURLSameOrigin$3 = utils$l.isStandardBrowserEnv() ? function standardBrowserEnv4() {
+  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 isURLSameOrigin2(requestURL) {
+    var parsed = utils$l.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+    return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+  };
+}() : function nonStandardBrowserEnv4() {
+  return function isURLSameOrigin2() {
+    return true;
+  };
+}();
+var utils$k = utils$r;
+var settle$2 = settle$3;
+var cookies$2 = cookies$3;
+var buildURL$4 = buildURL$5;
+var buildFullPath$2 = buildFullPath$3;
+var parseHeaders$2 = parseHeaders$3;
+var isURLSameOrigin$2 = isURLSameOrigin$3;
+var createError$3 = createError$5;
+var xhr$1 = function xhrAdapter2(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    var requestData = config.data;
+    var requestHeaders = config.headers;
+    var responseType = config.responseType;
+    if (utils$k.isFormData(requestData)) {
+      delete requestHeaders["Content-Type"];
+    }
+    var request4 = 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$2(config.baseURL, config.url);
+    request4.open(config.method.toUpperCase(), buildURL$4(fullPath, config.params, config.paramsSerializer), true);
+    request4.timeout = config.timeout;
+    function onloadend() {
+      if (!request4) {
+        return;
+      }
+      var responseHeaders = "getAllResponseHeaders" in request4 ? parseHeaders$2(request4.getAllResponseHeaders()) : null;
+      var responseData = !responseType || responseType === "text" || responseType === "json" ? request4.responseText : request4.response;
+      var response = {
+        data: responseData,
+        status: request4.status,
+        statusText: request4.statusText,
+        headers: responseHeaders,
+        config,
+        request: request4
+      };
+      settle$2(resolve, reject, response);
+      request4 = null;
+    }
+    if ("onloadend" in request4) {
+      request4.onloadend = onloadend;
+    } else {
+      request4.onreadystatechange = function handleLoad() {
+        if (!request4 || request4.readyState !== 4) {
+          return;
+        }
+        if (request4.status === 0 && !(request4.responseURL && request4.responseURL.indexOf("file:") === 0)) {
+          return;
+        }
+        setTimeout(onloadend);
+      };
+    }
+    request4.onabort = function handleAbort() {
+      if (!request4) {
+        return;
+      }
+      reject(createError$3("Request aborted", config, "ECONNABORTED", request4));
+      request4 = null;
+    };
+    request4.onerror = function handleError() {
+      reject(createError$3("Network Error", config, null, request4));
+      request4 = null;
+    };
+    request4.ontimeout = function handleTimeout() {
+      var timeoutErrorMessage = "timeout of " + config.timeout + "ms exceeded";
+      if (config.timeoutErrorMessage) {
+        timeoutErrorMessage = config.timeoutErrorMessage;
+      }
+      reject(createError$3(timeoutErrorMessage, config, config.transitional && config.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", request4));
+      request4 = null;
+    };
+    if (utils$k.isStandardBrowserEnv()) {
+      var xsrfValue = (config.withCredentials || isURLSameOrigin$2(fullPath)) && config.xsrfCookieName ? cookies$2.read(config.xsrfCookieName) : void 0;
+      if (xsrfValue) {
+        requestHeaders[config.xsrfHeaderName] = xsrfValue;
+      }
+    }
+    if ("setRequestHeader" in request4) {
+      utils$k.forEach(requestHeaders, function setRequestHeader(val, key) {
+        if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+          delete requestHeaders[key];
+        } else {
+          request4.setRequestHeader(key, val);
+        }
+      });
+    }
+    if (!utils$k.isUndefined(config.withCredentials)) {
+      request4.withCredentials = !!config.withCredentials;
+    }
+    if (responseType && responseType !== "json") {
+      request4.responseType = config.responseType;
+    }
+    if (typeof config.onDownloadProgress === "function") {
+      request4.addEventListener("progress", config.onDownloadProgress);
+    }
+    if (typeof config.onUploadProgress === "function" && request4.upload) {
+      request4.upload.addEventListener("progress", config.onUploadProgress);
+    }
+    if (config.cancelToken) {
+      config.cancelToken.promise.then(function onCanceled(cancel) {
+        if (!request4) {
+          return;
+        }
+        request4.abort();
+        reject(cancel);
+        request4 = null;
+      });
+    }
+    if (!requestData) {
+      requestData = null;
+    }
+    request4.send(requestData);
+  });
+};
+var utils$j = utils$r;
+var normalizeHeaderName$2 = normalizeHeaderName$3;
+var enhanceError$3 = enhanceError$5;
+var DEFAULT_CONTENT_TYPE$1 = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function setContentTypeIfUnset$1(headers, value) {
+  if (!utils$j.isUndefined(headers) && utils$j.isUndefined(headers["Content-Type"])) {
+    headers["Content-Type"] = value;
+  }
+}
+function getDefaultAdapter$1() {
+  var adapter;
+  if (typeof XMLHttpRequest !== "undefined") {
+    adapter = xhr$1;
+  } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+    adapter = xhr$1;
+  }
+  return adapter;
+}
+function stringifySafely$1(rawValue, parser, encoder) {
+  if (utils$j.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils$j.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError") {
+        throw e;
+      }
+    }
+  }
+  return (encoder || JSON.stringify)(rawValue);
+}
+var defaults$8 = {
+  transitional: {
+    silentJSONParsing: true,
+    forcedJSONParsing: true,
+    clarifyTimeoutError: false
+  },
+  adapter: getDefaultAdapter$1(),
+  transformRequest: [function transformRequest2(data2, headers) {
+    normalizeHeaderName$2(headers, "Accept");
+    normalizeHeaderName$2(headers, "Content-Type");
+    if (utils$j.isFormData(data2) || utils$j.isArrayBuffer(data2) || utils$j.isBuffer(data2) || utils$j.isStream(data2) || utils$j.isFile(data2) || utils$j.isBlob(data2)) {
+      return data2;
+    }
+    if (utils$j.isArrayBufferView(data2)) {
+      return data2.buffer;
+    }
+    if (utils$j.isURLSearchParams(data2)) {
+      setContentTypeIfUnset$1(headers, "application/x-www-form-urlencoded;charset=utf-8");
+      return data2.toString();
+    }
+    if (utils$j.isObject(data2) || headers && headers["Content-Type"] === "application/json") {
+      setContentTypeIfUnset$1(headers, "application/json");
+      return stringifySafely$1(data2);
+    }
+    return data2;
+  }],
+  transformResponse: [function transformResponse2(data2) {
+    var transitional4 = this.transitional;
+    var silentJSONParsing = transitional4 && transitional4.silentJSONParsing;
+    var forcedJSONParsing = transitional4 && transitional4.forcedJSONParsing;
+    var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+    if (strictJSONParsing || forcedJSONParsing && utils$j.isString(data2) && data2.length) {
+      try {
+        return JSON.parse(data2);
+      } catch (e) {
+        if (strictJSONParsing) {
+          if (e.name === "SyntaxError") {
+            throw enhanceError$3(e, this, "E_JSON_PARSE");
+          }
+          throw e;
+        }
+      }
+    }
+    return data2;
+  }],
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  validateStatus: function validateStatus2(status) {
+    return status >= 200 && status < 300;
+  }
+};
+defaults$8.headers = {
+  common: {
+    "Accept": "application/json, text/plain, */*"
+  }
+};
+utils$j.forEach(["delete", "get", "head"], function forEachMethodNoData3(method) {
+  defaults$8.headers[method] = {};
+});
+utils$j.forEach(["post", "put", "patch"], function forEachMethodWithData3(method) {
+  defaults$8.headers[method] = utils$j.merge(DEFAULT_CONTENT_TYPE$1);
+});
+var defaults_1$1 = defaults$8;
+var utils$i = utils$r;
+var defaults$7 = defaults_1$1;
+var transformData$3 = function transformData2(data2, headers, fns) {
+  var context = this || defaults$7;
+  utils$i.forEach(fns, function transform(fn) {
+    data2 = fn.call(context, data2, headers);
+  });
+  return data2;
+};
+var isCancel$3 = function isCancel2(value) {
+  return !!(value && value.__CANCEL__);
+};
+var utils$h = utils$r;
+var transformData$2 = transformData$3;
+var isCancel$2 = isCancel$3;
+var defaults$6 = defaults_1$1;
+function throwIfCancellationRequested$1(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
+  }
+}
+var dispatchRequest$3 = function dispatchRequest2(config) {
+  throwIfCancellationRequested$1(config);
+  config.headers = config.headers || {};
+  config.data = transformData$2.call(config, config.data, config.headers, config.transformRequest);
+  config.headers = utils$h.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
+  utils$h.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) {
+    delete config.headers[method];
+  });
+  var adapter = config.adapter || defaults$6.adapter;
+  return adapter(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested$1(config);
+    response.data = transformData$2.call(config, response.data, response.headers, config.transformResponse);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel$2(reason)) {
+      throwIfCancellationRequested$1(config);
+      if (reason && reason.response) {
+        reason.response.data = transformData$2.call(config, reason.response.data, reason.response.headers, config.transformResponse);
+      }
+    }
+    return Promise.reject(reason);
+  });
+};
+var utils$g = utils$r;
+var mergeConfig$5 = function mergeConfig2(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, source4) {
+    if (utils$g.isPlainObject(target) && utils$g.isPlainObject(source4)) {
+      return utils$g.merge(target, source4);
+    } else if (utils$g.isPlainObject(source4)) {
+      return utils$g.merge({}, source4);
+    } else if (utils$g.isArray(source4)) {
+      return source4.slice();
+    }
+    return source4;
+  }
+  function mergeDeepProperties(prop) {
+    if (!utils$g.isUndefined(config2[prop])) {
+      config[prop] = getMergedValue(config1[prop], config2[prop]);
+    } else if (!utils$g.isUndefined(config1[prop])) {
+      config[prop] = getMergedValue(void 0, config1[prop]);
+    }
+  }
+  utils$g.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+    if (!utils$g.isUndefined(config2[prop])) {
+      config[prop] = getMergedValue(void 0, config2[prop]);
+    }
+  });
+  utils$g.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+  utils$g.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+    if (!utils$g.isUndefined(config2[prop])) {
+      config[prop] = getMergedValue(void 0, config2[prop]);
+    } else if (!utils$g.isUndefined(config1[prop])) {
+      config[prop] = getMergedValue(void 0, config1[prop]);
+    }
+  });
+  utils$g.forEach(directMergeKeys, function merge2(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$g.forEach(otherKeys, mergeDeepProperties);
+  return config;
+};
+const name = "axios";
+const version = "0.21.4";
+const description = "Promise based HTTP client for the browser and node.js";
+const main = "index.js";
+const 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"
+};
+const repository = {
+  type: "git",
+  url: "https://github.com/axios/axios.git"
+};
+const keywords = [
+  "xhr",
+  "http",
+  "ajax",
+  "promise",
+  "node"
+];
+const author = "Matt Zabriskie";
+const license = "MIT";
+const bugs = {
+  url: "https://github.com/axios/axios/issues"
+};
+const homepage = "https://axios-http.com";
+const 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"
+};
+const browser = {
+  "./lib/adapters/http.js": "./lib/adapters/xhr.js"
+};
+const jsdelivr = "dist/axios.min.js";
+const unpkg = "dist/axios.min.js";
+const typings = "./index.d.ts";
+const dependencies = {
+  "follow-redirects": "^1.14.0"
+};
+const bundlesize = [
+  {
+    path: "./dist/axios.min.js",
+    threshold: "5kB"
+  }
+];
+var require$$0 = {
+  name,
+  version,
+  description,
+  main,
+  scripts,
+  repository,
+  keywords,
+  author,
+  license,
+  bugs,
+  homepage,
+  devDependencies,
+  browser,
+  jsdelivr,
+  unpkg,
+  typings,
+  dependencies,
+  bundlesize
+};
+var pkg = require$$0;
+var validators$3 = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+  validators$3[type] = function validator2(thing) {
+    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+  };
+});
+var deprecatedWarnings$1 = {};
+var currentVerArr = pkg.version.split(".");
+function isOlderVersion(version2, thanVersion) {
+  var pkgVersionArr = thanVersion ? thanVersion.split(".") : currentVerArr;
+  var destVer = version2.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$3.transitional = function transitional2(validator2, version2, message) {
+  var isDeprecated = version2 && isOlderVersion(version2);
+  function formatMessage(opt, desc) {
+    return "[Axios v" + pkg.version + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+  }
+  return function(value, opt, opts) {
+    if (validator2 === false) {
+      throw new Error(formatMessage(opt, " has been removed in " + version2));
+    }
+    if (isDeprecated && !deprecatedWarnings$1[opt]) {
+      deprecatedWarnings$1[opt] = true;
+      console.warn(formatMessage(opt, " has been deprecated since v" + version2 + " and will be removed in the near future"));
+    }
+    return validator2 ? validator2(value, opt, opts) : true;
+  };
+};
+function assertOptions$1(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 validator2 = schema[opt];
+    if (validator2) {
+      var value = options[opt];
+      var result = value === void 0 || validator2(value, opt, options);
+      if (result !== true) {
+        throw new TypeError("option " + opt + " must be " + result);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw Error("Unknown option " + opt);
+    }
+  }
+}
+var validator$3 = {
+  isOlderVersion,
+  assertOptions: assertOptions$1,
+  validators: validators$3
+};
+var utils$f = utils$r;
+var buildURL$3 = buildURL$5;
+var InterceptorManager$2 = InterceptorManager_1$1;
+var dispatchRequest$2 = dispatchRequest$3;
+var mergeConfig$4 = mergeConfig$5;
+var validator$2 = validator$3;
+var validators$2 = validator$2.validators;
+function Axios$3(instanceConfig) {
+  this.defaults = instanceConfig;
+  this.interceptors = {
+    request: new InterceptorManager$2(),
+    response: new InterceptorManager$2()
+  };
+}
+Axios$3.prototype.request = function request2(config) {
+  if (typeof config === "string") {
+    config = arguments[1] || {};
+    config.url = arguments[0];
+  } else {
+    config = config || {};
+  }
+  config = mergeConfig$4(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 transitional4 = config.transitional;
+  if (transitional4 !== void 0) {
+    validator$2.assertOptions(transitional4, {
+      silentJSONParsing: validators$2.transitional(validators$2.boolean, "1.0.0"),
+      forcedJSONParsing: validators$2.transitional(validators$2.boolean, "1.0.0"),
+      clarifyTimeoutError: validators$2.transitional(validators$2.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$2, 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$2(newConfig);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  while (responseInterceptorChain.length) {
+    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+  }
+  return promise;
+};
+Axios$3.prototype.getUri = function getUri2(config) {
+  config = mergeConfig$4(this.defaults, config);
+  return buildURL$3(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
+};
+utils$f.forEach(["delete", "get", "head", "options"], function forEachMethodNoData4(method) {
+  Axios$3.prototype[method] = function(url, config) {
+    return this.request(mergeConfig$4(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+utils$f.forEach(["post", "put", "patch"], function forEachMethodWithData4(method) {
+  Axios$3.prototype[method] = function(url, data2, config) {
+    return this.request(mergeConfig$4(config || {}, {
+      method,
+      url,
+      data: data2
+    }));
+  };
+});
+var Axios_1$1 = Axios$3;
+function Cancel$5(message) {
+  this.message = message;
+}
+Cancel$5.prototype.toString = function toString2() {
+  return "Cancel" + (this.message ? ": " + this.message : "");
+};
+Cancel$5.prototype.__CANCEL__ = true;
+var Cancel_1$1 = Cancel$5;
+var Cancel$4 = Cancel_1$1;
+function CancelToken$1(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 token2 = this;
+  executor(function cancel(message) {
+    if (token2.reason) {
+      return;
+    }
+    token2.reason = new Cancel$4(message);
+    resolvePromise(token2.reason);
+  });
+}
+CancelToken$1.prototype.throwIfRequested = function throwIfRequested2() {
+  if (this.reason) {
+    throw this.reason;
+  }
+};
+CancelToken$1.source = function source2() {
+  var cancel;
+  var token2 = new CancelToken$1(function executor(c) {
+    cancel = c;
+  });
+  return {
+    token: token2,
+    cancel
+  };
+};
+var CancelToken_1$1 = CancelToken$1;
+var spread$1 = function spread2(callback) {
+  return function wrap(arr) {
+    return callback.apply(null, arr);
+  };
+};
+var isAxiosError$1 = function isAxiosError2(payload) {
+  return typeof payload === "object" && payload.isAxiosError === true;
+};
+var utils$e = utils$r;
+var bind$3 = bind$5;
+var Axios$2 = Axios_1$1;
+var mergeConfig$3 = mergeConfig$5;
+var defaults$5 = defaults_1$1;
+function createInstance$1(defaultConfig) {
+  var context = new Axios$2(defaultConfig);
+  var instance = bind$3(Axios$2.prototype.request, context);
+  utils$e.extend(instance, Axios$2.prototype, context);
+  utils$e.extend(instance, context);
+  return instance;
+}
+var axios$4 = createInstance$1(defaults$5);
+axios$4.Axios = Axios$2;
+axios$4.create = function create(instanceConfig) {
+  return createInstance$1(mergeConfig$3(axios$4.defaults, instanceConfig));
+};
+axios$4.Cancel = Cancel_1$1;
+axios$4.CancelToken = CancelToken_1$1;
+axios$4.isCancel = isCancel$3;
+axios$4.all = function all2(promises) {
+  return Promise.all(promises);
+};
+axios$4.spread = spread$1;
+axios$4.isAxiosError = isAxiosError$1;
+axios$5.exports = axios$4;
+axios$5.exports.default = axios$4;
+var axios$3 = axios$5.exports;
+class HasuraStorageApi {
+  constructor({ url }) {
+    this.url = url;
+    this.httpClient = axios$3.create({
+      baseURL: this.url
+    });
+  }
+  async upload(params) {
+    try {
+      const res = await this.httpClient.post("/files", params.file, {
+        headers: __spreadValues(__spreadValues({}, this.generateUploadHeaders(params)), this.generateAuthHeaders())
+      });
+      return { fileMetadata: res.data, error: null };
+    } catch (error) {
+      return { fileMetadata: null, error };
+    }
+  }
+  async getPresignedUrl(params) {
+    try {
+      const { fileId } = params;
+      const res = await this.httpClient.get(`/files/${fileId}/presignedurl`, {
+        headers: __spreadValues({}, this.generateAuthHeaders())
+      });
+      return { presignedUrl: res.data, error: null };
+    } catch (error) {
+      return { presignedUrl: null, error };
+    }
+  }
+  async delete(params) {
+    try {
+      const { fileId } = params;
+      await this.httpClient.delete(`/files/${fileId}`, {
+        headers: __spreadValues({}, this.generateAuthHeaders())
+      });
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  setAccessToken(accessToken) {
+    this.accessToken = accessToken;
+  }
+  generateUploadHeaders(params) {
+    const { bucketId, name: name2, id } = params;
+    const uploadheaders = {};
+    if (bucketId) {
+      uploadheaders["x-nhost-bucket-id"] = bucketId;
+    }
+    if (id) {
+      uploadheaders["x-nhost-file-id"] = id;
+    }
+    if (name2) {
+      uploadheaders["x-nhost-file-name"] = name2;
+    }
+    return uploadheaders;
+  }
+  generateAuthHeaders() {
+    if (!this.accessToken) {
+      return null;
+    }
+    return {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+  }
+}
+class HasuraStorageClient {
+  constructor({ url }) {
+    this.url = url;
+    this.api = new HasuraStorageApi({ url });
+  }
+  async upload(params) {
+    const file = new FormData();
+    file.append("file", params.file);
+    const { fileMetadata, error } = await this.api.upload(__spreadProps(__spreadValues({}, params), {
+      file
+    }));
+    if (error) {
+      return { fileMetadata: null, error };
+    }
+    if (!fileMetadata) {
+      return { fileMetadata: null, error: new Error("Invalid file returned") };
+    }
+    return { fileMetadata, error: null };
+  }
+  getUrl(params) {
+    const { fileId } = params;
+    return `${this.url}/files/${fileId}`;
+  }
+  async getPresignedUrl(params) {
+    const { presignedUrl, error } = await this.api.getPresignedUrl(params);
+    if (error) {
+      return { presignedUrl: null, error };
+    }
+    if (!presignedUrl) {
+      return { presignedUrl: null, error: new Error("Invalid file id") };
+    }
+    return { presignedUrl, error: null };
+  }
+  async delete(params) {
+    const { error } = await this.api.delete(params);
+    if (error) {
+      return { error };
+    }
+    return { error: null };
+  }
+  setAccessToken(accessToken) {
+    this.api.setAccessToken(accessToken);
+  }
+}
+var axios$2 = { exports: {} };
+var bind$2 = function bind3(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);
+  };
+};
+var bind$1 = bind$2;
+var toString3 = Object.prototype.toString;
+function isArray(val) {
+  return toString3.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 toString3.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 (toString3.call(val) !== "[object Object]") {
+    return false;
+  }
+  var prototype = Object.getPrototypeOf(val);
+  return prototype === null || prototype === Object.prototype;
+}
+function isDate(val) {
+  return toString3.call(val) === "[object Date]";
+}
+function isFile(val) {
+  return toString3.call(val) === "[object File]";
+}
+function isBlob(val) {
+  return toString3.call(val) === "[object Blob]";
+}
+function isFunction(val) {
+  return toString3.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 forEach3(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++) {
+    forEach3(arguments[i], assignValue);
+  }
+  return result;
+}
+function extend(a, b, thisArg) {
+  forEach3(b, function assignValue(val, key) {
+    if (thisArg && typeof val === "function") {
+      a[key] = bind$1(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  });
+  return a;
+}
+function stripBOM(content) {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+}
+var utils$d = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isObject,
+  isPlainObject,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isStandardBrowserEnv,
+  forEach: forEach3,
+  merge,
+  extend,
+  trim,
+  stripBOM
+};
+var utils$c = utils$d;
+function encode(val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+}
+var buildURL$2 = function buildURL3(url, params, paramsSerializer) {
+  if (!params) {
+    return url;
+  }
+  var serializedParams;
+  if (paramsSerializer) {
+    serializedParams = paramsSerializer(params);
+  } else if (utils$c.isURLSearchParams(params)) {
+    serializedParams = params.toString();
+  } else {
+    var parts = [];
+    utils$c.forEach(params, function serialize(val, key) {
+      if (val === null || typeof val === "undefined") {
+        return;
+      }
+      if (utils$c.isArray(val)) {
+        key = key + "[]";
+      } else {
+        val = [val];
+      }
+      utils$c.forEach(val, function parseValue(v) {
+        if (utils$c.isDate(v)) {
+          v = v.toISOString();
+        } else if (utils$c.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;
+};
+var utils$b = utils$d;
+function InterceptorManager$1() {
+  this.handlers = [];
+}
+InterceptorManager$1.prototype.use = function use3(fulfilled, rejected, options) {
+  this.handlers.push({
+    fulfilled,
+    rejected,
+    synchronous: options ? options.synchronous : false,
+    runWhen: options ? options.runWhen : null
+  });
+  return this.handlers.length - 1;
+};
+InterceptorManager$1.prototype.eject = function eject3(id) {
+  if (this.handlers[id]) {
+    this.handlers[id] = null;
+  }
+};
+InterceptorManager$1.prototype.forEach = function forEach4(fn) {
+  utils$b.forEach(this.handlers, function forEachHandler(h) {
+    if (h !== null) {
+      fn(h);
+    }
+  });
+};
+var InterceptorManager_1 = InterceptorManager$1;
+var utils$a = utils$d;
+var normalizeHeaderName$1 = function normalizeHeaderName3(headers, normalizedName) {
+  utils$a.forEach(headers, function processHeader(value, name2) {
+    if (name2 !== normalizedName && name2.toUpperCase() === normalizedName.toUpperCase()) {
+      headers[normalizedName] = value;
+      delete headers[name2];
+    }
+  });
+};
+var enhanceError$2 = function enhanceError3(error, config, code, request4, response) {
+  error.config = config;
+  if (code) {
+    error.code = code;
+  }
+  error.request = request4;
+  error.response = response;
+  error.isAxiosError = true;
+  error.toJSON = function toJSON() {
+    return {
+      message: this.message,
+      name: this.name,
+      description: this.description,
+      number: this.number,
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      config: this.config,
+      code: this.code,
+      status: this.response && this.response.status ? this.response.status : null
+    };
+  };
+  return error;
+};
+var enhanceError$1 = enhanceError$2;
+var createError$2 = function createError3(message, config, code, request4, response) {
+  var error = new Error(message);
+  return enhanceError$1(error, config, code, request4, response);
+};
+var createError$1 = createError$2;
+var settle$1 = function settle3(resolve, reject, response) {
+  var validateStatus4 = response.config.validateStatus;
+  if (!response.status || !validateStatus4 || validateStatus4(response.status)) {
+    resolve(response);
+  } else {
+    reject(createError$1("Request failed with status code " + response.status, response.config, null, response.request, response));
+  }
+};
+var utils$9 = utils$d;
+var cookies$1 = utils$9.isStandardBrowserEnv() ? function standardBrowserEnv5() {
+  return {
+    write: function write(name2, value, expires, path, domain, secure) {
+      var cookie = [];
+      cookie.push(name2 + "=" + encodeURIComponent(value));
+      if (utils$9.isNumber(expires)) {
+        cookie.push("expires=" + new Date(expires).toGMTString());
+      }
+      if (utils$9.isString(path)) {
+        cookie.push("path=" + path);
+      }
+      if (utils$9.isString(domain)) {
+        cookie.push("domain=" + domain);
+      }
+      if (secure === true) {
+        cookie.push("secure");
+      }
+      document.cookie = cookie.join("; ");
+    },
+    read: function read(name2) {
+      var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name2 + ")=([^;]*)"));
+      return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove: function remove(name2) {
+      this.write(name2, "", Date.now() - 864e5);
+    }
+  };
+}() : function nonStandardBrowserEnv5() {
+  return {
+    write: function write() {
+    },
+    read: function read() {
+      return null;
+    },
+    remove: function remove() {
+    }
+  };
+}();
+var isAbsoluteURL$1 = function isAbsoluteURL3(url) {
+  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+};
+var combineURLs$1 = function combineURLs3(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+};
+var isAbsoluteURL4 = isAbsoluteURL$1;
+var combineURLs4 = combineURLs$1;
+var buildFullPath$1 = function buildFullPath3(baseURL, requestedURL) {
+  if (baseURL && !isAbsoluteURL4(requestedURL)) {
+    return combineURLs4(baseURL, requestedURL);
+  }
+  return requestedURL;
+};
+var utils$8 = utils$d;
+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"
+];
+var parseHeaders$1 = function parseHeaders3(headers) {
+  var parsed = {};
+  var key;
+  var val;
+  var i;
+  if (!headers) {
+    return parsed;
+  }
+  utils$8.forEach(headers.split("\n"), function parser(line) {
+    i = line.indexOf(":");
+    key = utils$8.trim(line.substr(0, i)).toLowerCase();
+    val = utils$8.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;
+};
+var utils$7 = utils$d;
+var isURLSameOrigin$1 = utils$7.isStandardBrowserEnv() ? function standardBrowserEnv6() {
+  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 isURLSameOrigin2(requestURL) {
+    var parsed = utils$7.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+    return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+  };
+}() : function nonStandardBrowserEnv6() {
+  return function isURLSameOrigin2() {
+    return true;
+  };
+}();
+function Cancel$3(message) {
+  this.message = message;
+}
+Cancel$3.prototype.toString = function toString4() {
+  return "Cancel" + (this.message ? ": " + this.message : "");
+};
+Cancel$3.prototype.__CANCEL__ = true;
+var Cancel_1 = Cancel$3;
+var utils$6 = utils$d;
+var settle4 = settle$1;
+var cookies = cookies$1;
+var buildURL$1 = buildURL$2;
+var buildFullPath4 = buildFullPath$1;
+var parseHeaders4 = parseHeaders$1;
+var isURLSameOrigin = isURLSameOrigin$1;
+var createError4 = createError$2;
+var defaults$4 = defaults_1;
+var Cancel$2 = Cancel_1;
+var xhr = function xhrAdapter3(config) {
+  return new Promise(function dispatchXhrRequest(resolve, reject) {
+    var requestData = config.data;
+    var requestHeaders = config.headers;
+    var responseType = config.responseType;
+    var onCanceled;
+    function done() {
+      if (config.cancelToken) {
+        config.cancelToken.unsubscribe(onCanceled);
+      }
+      if (config.signal) {
+        config.signal.removeEventListener("abort", onCanceled);
+      }
+    }
+    if (utils$6.isFormData(requestData)) {
+      delete requestHeaders["Content-Type"];
+    }
+    var request4 = 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 = buildFullPath4(config.baseURL, config.url);
+    request4.open(config.method.toUpperCase(), buildURL$1(fullPath, config.params, config.paramsSerializer), true);
+    request4.timeout = config.timeout;
+    function onloadend() {
+      if (!request4) {
+        return;
+      }
+      var responseHeaders = "getAllResponseHeaders" in request4 ? parseHeaders4(request4.getAllResponseHeaders()) : null;
+      var responseData = !responseType || responseType === "text" || responseType === "json" ? request4.responseText : request4.response;
+      var response = {
+        data: responseData,
+        status: request4.status,
+        statusText: request4.statusText,
+        headers: responseHeaders,
+        config,
+        request: request4
+      };
+      settle4(function _resolve(value) {
+        resolve(value);
+        done();
+      }, function _reject(err) {
+        reject(err);
+        done();
+      }, response);
+      request4 = null;
+    }
+    if ("onloadend" in request4) {
+      request4.onloadend = onloadend;
+    } else {
+      request4.onreadystatechange = function handleLoad() {
+        if (!request4 || request4.readyState !== 4) {
+          return;
+        }
+        if (request4.status === 0 && !(request4.responseURL && request4.responseURL.indexOf("file:") === 0)) {
+          return;
+        }
+        setTimeout(onloadend);
+      };
+    }
+    request4.onabort = function handleAbort() {
+      if (!request4) {
+        return;
+      }
+      reject(createError4("Request aborted", config, "ECONNABORTED", request4));
+      request4 = null;
+    };
+    request4.onerror = function handleError() {
+      reject(createError4("Network Error", config, null, request4));
+      request4 = null;
+    };
+    request4.ontimeout = function handleTimeout() {
+      var timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
+      var transitional4 = config.transitional || defaults$4.transitional;
+      if (config.timeoutErrorMessage) {
+        timeoutErrorMessage = config.timeoutErrorMessage;
+      }
+      reject(createError4(timeoutErrorMessage, config, transitional4.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED", request4));
+      request4 = null;
+    };
+    if (utils$6.isStandardBrowserEnv()) {
+      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
+      if (xsrfValue) {
+        requestHeaders[config.xsrfHeaderName] = xsrfValue;
+      }
+    }
+    if ("setRequestHeader" in request4) {
+      utils$6.forEach(requestHeaders, function setRequestHeader(val, key) {
+        if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+          delete requestHeaders[key];
+        } else {
+          request4.setRequestHeader(key, val);
+        }
+      });
+    }
+    if (!utils$6.isUndefined(config.withCredentials)) {
+      request4.withCredentials = !!config.withCredentials;
+    }
+    if (responseType && responseType !== "json") {
+      request4.responseType = config.responseType;
+    }
+    if (typeof config.onDownloadProgress === "function") {
+      request4.addEventListener("progress", config.onDownloadProgress);
+    }
+    if (typeof config.onUploadProgress === "function" && request4.upload) {
+      request4.upload.addEventListener("progress", config.onUploadProgress);
+    }
+    if (config.cancelToken || config.signal) {
+      onCanceled = function(cancel) {
+        if (!request4) {
+          return;
+        }
+        reject(!cancel || cancel && cancel.type ? new Cancel$2("canceled") : cancel);
+        request4.abort();
+        request4 = null;
+      };
+      config.cancelToken && config.cancelToken.subscribe(onCanceled);
+      if (config.signal) {
+        config.signal.aborted ? onCanceled() : config.signal.addEventListener("abort", onCanceled);
+      }
+    }
+    if (!requestData) {
+      requestData = null;
+    }
+    request4.send(requestData);
+  });
+};
+var utils$5 = utils$d;
+var normalizeHeaderName4 = normalizeHeaderName$1;
+var enhanceError4 = enhanceError$2;
+var DEFAULT_CONTENT_TYPE = {
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+function setContentTypeIfUnset(headers, value) {
+  if (!utils$5.isUndefined(headers) && utils$5.isUndefined(headers["Content-Type"])) {
+    headers["Content-Type"] = value;
+  }
+}
+function getDefaultAdapter() {
+  var adapter;
+  if (typeof XMLHttpRequest !== "undefined") {
+    adapter = xhr;
+  } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+    adapter = xhr;
+  }
+  return adapter;
+}
+function stringifySafely(rawValue, parser, encoder) {
+  if (utils$5.isString(rawValue)) {
+    try {
+      (parser || JSON.parse)(rawValue);
+      return utils$5.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError") {
+        throw e;
+      }
+    }
+  }
+  return (encoder || JSON.stringify)(rawValue);
+}
+var defaults$3 = {
+  transitional: {
+    silentJSONParsing: true,
+    forcedJSONParsing: true,
+    clarifyTimeoutError: false
+  },
+  adapter: getDefaultAdapter(),
+  transformRequest: [function transformRequest3(data2, headers) {
+    normalizeHeaderName4(headers, "Accept");
+    normalizeHeaderName4(headers, "Content-Type");
+    if (utils$5.isFormData(data2) || utils$5.isArrayBuffer(data2) || utils$5.isBuffer(data2) || utils$5.isStream(data2) || utils$5.isFile(data2) || utils$5.isBlob(data2)) {
+      return data2;
+    }
+    if (utils$5.isArrayBufferView(data2)) {
+      return data2.buffer;
+    }
+    if (utils$5.isURLSearchParams(data2)) {
+      setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+      return data2.toString();
+    }
+    if (utils$5.isObject(data2) || headers && headers["Content-Type"] === "application/json") {
+      setContentTypeIfUnset(headers, "application/json");
+      return stringifySafely(data2);
+    }
+    return data2;
+  }],
+  transformResponse: [function transformResponse3(data2) {
+    var transitional4 = this.transitional || defaults$3.transitional;
+    var silentJSONParsing = transitional4 && transitional4.silentJSONParsing;
+    var forcedJSONParsing = transitional4 && transitional4.forcedJSONParsing;
+    var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+    if (strictJSONParsing || forcedJSONParsing && utils$5.isString(data2) && data2.length) {
+      try {
+        return JSON.parse(data2);
+      } catch (e) {
+        if (strictJSONParsing) {
+          if (e.name === "SyntaxError") {
+            throw enhanceError4(e, this, "E_JSON_PARSE");
+          }
+          throw e;
+        }
+      }
+    }
+    return data2;
+  }],
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  validateStatus: function validateStatus3(status) {
+    return status >= 200 && status < 300;
+  },
+  headers: {
+    common: {
+      "Accept": "application/json, text/plain, */*"
+    }
+  }
+};
+utils$5.forEach(["delete", "get", "head"], function forEachMethodNoData5(method) {
+  defaults$3.headers[method] = {};
+});
+utils$5.forEach(["post", "put", "patch"], function forEachMethodWithData5(method) {
+  defaults$3.headers[method] = utils$5.merge(DEFAULT_CONTENT_TYPE);
+});
+var defaults_1 = defaults$3;
+var utils$4 = utils$d;
+var defaults$2 = defaults_1;
+var transformData$1 = function transformData3(data2, headers, fns) {
+  var context = this || defaults$2;
+  utils$4.forEach(fns, function transform(fn) {
+    data2 = fn.call(context, data2, headers);
+  });
+  return data2;
+};
+var isCancel$1 = function isCancel3(value) {
+  return !!(value && value.__CANCEL__);
+};
+var utils$3 = utils$d;
+var transformData4 = transformData$1;
+var isCancel4 = isCancel$1;
+var defaults$1 = defaults_1;
+var Cancel$1 = Cancel_1;
+function throwIfCancellationRequested(config) {
+  if (config.cancelToken) {
+    config.cancelToken.throwIfRequested();
+  }
+  if (config.signal && config.signal.aborted) {
+    throw new Cancel$1("canceled");
+  }
+}
+var dispatchRequest$1 = function dispatchRequest3(config) {
+  throwIfCancellationRequested(config);
+  config.headers = config.headers || {};
+  config.data = transformData4.call(config, config.data, config.headers, config.transformRequest);
+  config.headers = utils$3.merge(config.headers.common || {}, config.headers[config.method] || {}, config.headers);
+  utils$3.forEach(["delete", "get", "head", "post", "put", "patch", "common"], function cleanHeaderConfig(method) {
+    delete config.headers[method];
+  });
+  var adapter = config.adapter || defaults$1.adapter;
+  return adapter(config).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config);
+    response.data = transformData4.call(config, response.data, response.headers, config.transformResponse);
+    return response;
+  }, function onAdapterRejection(reason) {
+    if (!isCancel4(reason)) {
+      throwIfCancellationRequested(config);
+      if (reason && reason.response) {
+        reason.response.data = transformData4.call(config, reason.response.data, reason.response.headers, config.transformResponse);
+      }
+    }
+    return Promise.reject(reason);
+  });
+};
+var utils$2 = utils$d;
+var mergeConfig$2 = function mergeConfig3(config1, config2) {
+  config2 = config2 || {};
+  var config = {};
+  function getMergedValue(target, source4) {
+    if (utils$2.isPlainObject(target) && utils$2.isPlainObject(source4)) {
+      return utils$2.merge(target, source4);
+    } else if (utils$2.isPlainObject(source4)) {
+      return utils$2.merge({}, source4);
+    } else if (utils$2.isArray(source4)) {
+      return source4.slice();
+    }
+    return source4;
+  }
+  function mergeDeepProperties(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (!utils$2.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function valueFromConfig2(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    }
+  }
+  function defaultToConfig2(prop) {
+    if (!utils$2.isUndefined(config2[prop])) {
+      return getMergedValue(void 0, config2[prop]);
+    } else if (!utils$2.isUndefined(config1[prop])) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  function mergeDirectKeys(prop) {
+    if (prop in config2) {
+      return getMergedValue(config1[prop], config2[prop]);
+    } else if (prop in config1) {
+      return getMergedValue(void 0, config1[prop]);
+    }
+  }
+  var mergeMap = {
+    "url": valueFromConfig2,
+    "method": valueFromConfig2,
+    "data": valueFromConfig2,
+    "baseURL": defaultToConfig2,
+    "transformRequest": defaultToConfig2,
+    "transformResponse": defaultToConfig2,
+    "paramsSerializer": defaultToConfig2,
+    "timeout": defaultToConfig2,
+    "timeoutMessage": defaultToConfig2,
+    "withCredentials": defaultToConfig2,
+    "adapter": defaultToConfig2,
+    "responseType": defaultToConfig2,
+    "xsrfCookieName": defaultToConfig2,
+    "xsrfHeaderName": defaultToConfig2,
+    "onUploadProgress": defaultToConfig2,
+    "onDownloadProgress": defaultToConfig2,
+    "decompress": defaultToConfig2,
+    "maxContentLength": defaultToConfig2,
+    "maxBodyLength": defaultToConfig2,
+    "transport": defaultToConfig2,
+    "httpAgent": defaultToConfig2,
+    "httpsAgent": defaultToConfig2,
+    "cancelToken": defaultToConfig2,
+    "socketPath": defaultToConfig2,
+    "responseEncoding": defaultToConfig2,
+    "validateStatus": mergeDirectKeys
+  };
+  utils$2.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
+    var merge2 = mergeMap[prop] || mergeDeepProperties;
+    var configValue = merge2(prop);
+    utils$2.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
+  });
+  return config;
+};
+var data = {
+  "version": "0.23.0"
+};
+var VERSION = data.version;
+var validators$1 = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+  validators$1[type] = function validator2(thing) {
+    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+  };
+});
+var deprecatedWarnings = {};
+validators$1.transitional = function transitional3(validator2, version2, message) {
+  function formatMessage(opt, desc) {
+    return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+  }
+  return function(value, opt, opts) {
+    if (validator2 === false) {
+      throw new Error(formatMessage(opt, " has been removed" + (version2 ? " in " + version2 : "")));
+    }
+    if (version2 && !deprecatedWarnings[opt]) {
+      deprecatedWarnings[opt] = true;
+      console.warn(formatMessage(opt, " has been deprecated since v" + version2 + " and will be removed in the near future"));
+    }
+    return validator2 ? validator2(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 validator2 = schema[opt];
+    if (validator2) {
+      var value = options[opt];
+      var result = value === void 0 || validator2(value, opt, options);
+      if (result !== true) {
+        throw new TypeError("option " + opt + " must be " + result);
+      }
+      continue;
+    }
+    if (allowUnknown !== true) {
+      throw Error("Unknown option " + opt);
+    }
+  }
+}
+var validator$1 = {
+  assertOptions,
+  validators: validators$1
+};
+var utils$1 = utils$d;
+var buildURL4 = buildURL$2;
+var InterceptorManager = InterceptorManager_1;
+var dispatchRequest4 = dispatchRequest$1;
+var mergeConfig$1 = mergeConfig$2;
+var validator = validator$1;
+var validators = validator.validators;
+function Axios$1(instanceConfig) {
+  this.defaults = instanceConfig;
+  this.interceptors = {
+    request: new InterceptorManager(),
+    response: new InterceptorManager()
+  };
+}
+Axios$1.prototype.request = function request3(config) {
+  if (typeof config === "string") {
+    config = arguments[1] || {};
+    config.url = arguments[0];
+  } else {
+    config = config || {};
+  }
+  config = mergeConfig$1(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 transitional4 = config.transitional;
+  if (transitional4 !== void 0) {
+    validator.assertOptions(transitional4, {
+      silentJSONParsing: validators.transitional(validators.boolean),
+      forcedJSONParsing: validators.transitional(validators.boolean),
+      clarifyTimeoutError: validators.transitional(validators.boolean)
+    }, 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 = [dispatchRequest4, 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 = dispatchRequest4(newConfig);
+  } catch (error) {
+    return Promise.reject(error);
+  }
+  while (responseInterceptorChain.length) {
+    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+  }
+  return promise;
+};
+Axios$1.prototype.getUri = function getUri3(config) {
+  config = mergeConfig$1(this.defaults, config);
+  return buildURL4(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
+};
+utils$1.forEach(["delete", "get", "head", "options"], function forEachMethodNoData6(method) {
+  Axios$1.prototype[method] = function(url, config) {
+    return this.request(mergeConfig$1(config || {}, {
+      method,
+      url,
+      data: (config || {}).data
+    }));
+  };
+});
+utils$1.forEach(["post", "put", "patch"], function forEachMethodWithData6(method) {
+  Axios$1.prototype[method] = function(url, data2, config) {
+    return this.request(mergeConfig$1(config || {}, {
+      method,
+      url,
+      data: data2
+    }));
+  };
+});
+var Axios_1 = Axios$1;
+var Cancel = Cancel_1;
+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 token2 = this;
+  this.promise.then(function(cancel) {
+    if (!token2._listeners)
+      return;
+    var i;
+    var l = token2._listeners.length;
+    for (i = 0; i < l; i++) {
+      token2._listeners[i](cancel);
+    }
+    token2._listeners = null;
+  });
+  this.promise.then = function(onfulfilled) {
+    var _resolve;
+    var promise = new Promise(function(resolve) {
+      token2.subscribe(resolve);
+      _resolve = resolve;
+    }).then(onfulfilled);
+    promise.cancel = function reject() {
+      token2.unsubscribe(_resolve);
+    };
+    return promise;
+  };
+  executor(function cancel(message) {
+    if (token2.reason) {
+      return;
+    }
+    token2.reason = new Cancel(message);
+    resolvePromise(token2.reason);
+  });
+}
+CancelToken.prototype.throwIfRequested = function throwIfRequested3() {
+  if (this.reason) {
+    throw this.reason;
+  }
+};
+CancelToken.prototype.subscribe = function subscribe2(listener) {
+  if (this.reason) {
+    listener(this.reason);
+    return;
+  }
+  if (this._listeners) {
+    this._listeners.push(listener);
+  } else {
+    this._listeners = [listener];
+  }
+};
+CancelToken.prototype.unsubscribe = function unsubscribe2(listener) {
+  if (!this._listeners) {
+    return;
+  }
+  var index = this._listeners.indexOf(listener);
+  if (index !== -1) {
+    this._listeners.splice(index, 1);
+  }
+};
+CancelToken.source = function source3() {
+  var cancel;
+  var token2 = new CancelToken(function executor(c) {
+    cancel = c;
+  });
+  return {
+    token: token2,
+    cancel
+  };
+};
+var CancelToken_1 = CancelToken;
+var spread3 = function spread4(callback) {
+  return function wrap(arr) {
+    return callback.apply(null, arr);
+  };
+};
+var isAxiosError3 = function isAxiosError4(payload) {
+  return typeof payload === "object" && payload.isAxiosError === true;
+};
+var utils = utils$d;
+var bind4 = bind$2;
+var Axios = Axios_1;
+var mergeConfig4 = mergeConfig$2;
+var defaults = defaults_1;
+function createInstance(defaultConfig) {
+  var context = new Axios(defaultConfig);
+  var instance = bind4(Axios.prototype.request, context);
+  utils.extend(instance, Axios.prototype, context);
+  utils.extend(instance, context);
+  instance.create = function create2(instanceConfig) {
+    return createInstance(mergeConfig4(defaultConfig, instanceConfig));
+  };
+  return instance;
+}
+var axios$1 = createInstance(defaults);
+axios$1.Axios = Axios;
+axios$1.Cancel = Cancel_1;
+axios$1.CancelToken = CancelToken_1;
+axios$1.isCancel = isCancel$1;
+axios$1.VERSION = data.version;
+axios$1.all = function all3(promises) {
+  return Promise.all(promises);
+};
+axios$1.spread = spread3;
+axios$1.isAxiosError = isAxiosError3;
+axios$2.exports = axios$1;
+axios$2.exports.default = axios$1;
+var axios = axios$2.exports;
+class NhostFunctionsClient {
+  constructor(params) {
+    const { url } = params;
+    this.accessToken = null;
+    this.instance = axios.create({
+      baseURL: url
+    });
+  }
+  async call(url, data2, config) {
+    const headers = __spreadValues(__spreadValues({}, this.generateAccessTokenHeaders()), config == null ? void 0 : config.headers);
+    let res;
+    try {
+      res = await this.instance.post(url, data2, __spreadProps(__spreadValues({}, config), { headers }));
+    } catch (error) {
+      if (error instanceof Error) {
+        return { res: null, error };
+      }
+    }
+    if (!res) {
+      return {
+        res: null,
+        error: new Error("Unable to make post request to funtion")
+      };
+    }
+    return { res, error: null };
+  }
+  setAccessToken(accessToken) {
+    if (!accessToken) {
+      this.accessToken = null;
+      return;
+    }
+    this.accessToken = accessToken;
+  }
+  generateAccessTokenHeaders() {
+    if (!this.accessToken) {
+      return;
+    }
+    return {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+  }
+}
+class NhostGraphqlClient {
+  constructor(params) {
+    const { url } = params;
+    this.url = url;
+    this.accessToken = null;
+    this.instance = axios.create({
+      baseURL: url
+    });
+  }
+  async request(document2, variables, config) {
+    const headers = __spreadValues(__spreadValues({}, config == null ? void 0 : config.headers), this.generateAccessTokenHeaders());
+    const operationName = "";
+    let responseData;
+    try {
+      const res = await this.instance.post("", {
+        operationName: operationName || void 0,
+        query: document2,
+        variables
+      }, __spreadProps(__spreadValues({}, config), { headers }));
+      responseData = res.data;
+    } catch (error) {
+      if (error instanceof Error) {
+        return { data: null, error };
+      }
+      console.error(error);
+      return {
+        data: null,
+        error: new Error("Unable to get do GraphQL request")
+      };
+    }
+    if (typeof responseData !== "object" || Array.isArray(responseData) || responseData === null) {
+      return {
+        data: null,
+        error: new Error("incorrect response data from GraphQL server")
+      };
+    }
+    responseData = responseData;
+    if (responseData.errors) {
+      return {
+        data: null,
+        error: responseData.errors
+      };
+    }
+    return { data: responseData.data, error: null };
+  }
+  getUrl() {
+    return this.url;
+  }
+  setAccessToken(accessToken) {
+    if (!accessToken) {
+      this.accessToken = null;
+      return;
+    }
+    this.accessToken = accessToken;
+  }
+  generateAccessTokenHeaders() {
+    if (!this.accessToken) {
+      return;
+    }
+    return {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+  }
+}
+class NhostClient {
+  constructor(params) {
+    if (!params.backendUrl)
+      throw new Error("Please specify a `backendUrl`. Docs: [todo]!");
+    const {
+      backendUrl,
+      refreshIntervalTime,
+      clientStorage,
+      clientStorageType,
+      autoRefreshToken,
+      autoLogin
+    } = params;
+    this.auth = new HasuraAuthClient({
+      url: `${backendUrl}/v1/auth`,
+      refreshIntervalTime,
+      clientStorage,
+      clientStorageType,
+      autoRefreshToken,
+      autoLogin
+    });
+    this.storage = new HasuraStorageClient({
+      url: `${backendUrl}/v1/storage`
+    });
+    this.functions = new NhostFunctionsClient({
+      url: `${backendUrl}/v1/functions`
+    });
+    this.graphql = new NhostGraphqlClient({
+      url: `${backendUrl}/v1/graphql`
+    });
+    this.storage.setAccessToken(this.auth.getAccessToken());
+    this.functions.setAccessToken(this.auth.getAccessToken());
+    this.graphql.setAccessToken(this.auth.getAccessToken());
+    this.auth.onAuthStateChanged((_event, session) => {
+      this.storage.setAccessToken(session == null ? void 0 : session.accessToken);
+      this.functions.setAccessToken(session == null ? void 0 : session.accessToken);
+      this.graphql.setAccessToken(session == null ? void 0 : session.accessToken);
+    });
+    this.auth.onTokenChanged((session) => {
+      this.storage.setAccessToken(session == null ? void 0 : session.accessToken);
+      this.functions.setAccessToken(session == null ? void 0 : session.accessToken);
+      this.graphql.setAccessToken(session == null ? void 0 : session.accessToken);
+    });
+  }
+}
+const createClient = (config) => new NhostClient(config);
+export { NhostClient, createClient };