zsysview 0.0.28 → 0.0.29

package/dist/http_api_v1-DiDJPhUb.js

@@ -0,0 +1,2755 @@
+import { x as getDefaultExportFromCjs, k as useTokenStore } from "./index-Cz5HRyMQ.js";
+function bind(fn, thisArg) {
+  return function() {
+    return fn.apply(thisArg, arguments);
+  };
+}
+const { toString } = Object.prototype, { getPrototypeOf } = Object, { iterator, toStringTag } = Symbol, kindOf = /* @__PURE__ */ ((cache) => (thing) => {
+  const str = toString.call(thing);
+  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+})(/* @__PURE__ */ Object.create(null)), kindOfTest = (type) => (type = type.toLowerCase(), (thing) => kindOf(thing) === type), typeOfTest = (type) => (thing) => typeof thing === type, { isArray } = Array, isUndefined = typeOfTest("undefined");
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+}
+const isArrayBuffer = kindOfTest("ArrayBuffer");
+function isArrayBufferView(val) {
+  let result;
+  return typeof ArrayBuffer < "u" && ArrayBuffer.isView ? result = ArrayBuffer.isView(val) : result = val && val.buffer && isArrayBuffer(val.buffer), result;
+}
+const isString = typeOfTest("string"), isFunction$1 = typeOfTest("function"), isNumber = typeOfTest("number"), isObject = (thing) => thing !== null && typeof thing == "object", isBoolean = (thing) => thing === !0 || thing === !1, isPlainObject = (val) => {
+  if (kindOf(val) !== "object")
+    return !1;
+  const prototype2 = getPrototypeOf(val);
+  return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(toStringTag in val) && !(iterator in val);
+}, isEmptyObject = (val) => {
+  if (!isObject(val) || isBuffer(val))
+    return !1;
+  try {
+    return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+  } catch {
+    return !1;
+  }
+}, isDate = kindOfTest("Date"), isFile = kindOfTest("File"), isBlob = kindOfTest("Blob"), isFileList = kindOfTest("FileList"), isStream = (val) => isObject(val) && isFunction$1(val.pipe), isFormData = (thing) => {
+  let kind;
+  return thing && (typeof FormData == "function" && thing instanceof FormData || isFunction$1(thing.append) && ((kind = kindOf(thing)) === "formdata" || // detect form-data instance
+  kind === "object" && isFunction$1(thing.toString) && thing.toString() === "[object FormData]"));
+}, isURLSearchParams = kindOfTest("URLSearchParams"), [isReadableStream, isRequest, isResponse, isHeaders] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest), trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+function forEach(obj, fn, { allOwnKeys = !1 } = {}) {
+  if (obj === null || typeof obj > "u")
+    return;
+  let i, l;
+  if (typeof obj != "object" && (obj = [obj]), isArray(obj))
+    for (i = 0, l = obj.length; i < l; i++)
+      fn.call(null, obj[i], i, obj);
+  else {
+    if (isBuffer(obj))
+      return;
+    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj), len = keys.length;
+    let key;
+    for (i = 0; i < len; i++)
+      key = keys[i], fn.call(null, obj[key], key, obj);
+  }
+}
+function findKey(obj, key) {
+  if (isBuffer(obj))
+    return null;
+  key = key.toLowerCase();
+  const keys = Object.keys(obj);
+  let i = keys.length, _key;
+  for (; i-- > 0; )
+    if (_key = keys[i], key === _key.toLowerCase())
+      return _key;
+  return null;
+}
+const _global = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : global, isContextDefined = (context) => !isUndefined(context) && context !== _global;
+function merge() {
+  const { caseless, skipUndefined } = isContextDefined(this) && this || {}, result = {}, assignValue = (val, key) => {
+    const targetKey = caseless && findKey(result, key) || key;
+    isPlainObject(result[targetKey]) && isPlainObject(val) ? result[targetKey] = merge(result[targetKey], val) : isPlainObject(val) ? result[targetKey] = merge({}, val) : isArray(val) ? result[targetKey] = val.slice() : (!skipUndefined || !isUndefined(val)) && (result[targetKey] = val);
+  };
+  for (let i = 0, l = arguments.length; i < l; i++)
+    arguments[i] && forEach(arguments[i], assignValue);
+  return result;
+}
+const extend = (a, b, thisArg, { allOwnKeys } = {}) => (forEach(b, (val, key) => {
+  thisArg && isFunction$1(val) ? a[key] = bind(val, thisArg) : a[key] = val;
+}, { allOwnKeys }), a), stripBOM = (content) => (content.charCodeAt(0) === 65279 && (content = content.slice(1)), content), inherits = (constructor, superConstructor, props, descriptors2) => {
+  constructor.prototype = Object.create(superConstructor.prototype, descriptors2), constructor.prototype.constructor = constructor, Object.defineProperty(constructor, "super", {
+    value: superConstructor.prototype
+  }), props && Object.assign(constructor.prototype, props);
+}, toFlatObject = (sourceObj, destObj, filter2, propFilter) => {
+  let props, i, prop;
+  const merged = {};
+  if (destObj = destObj || {}, sourceObj == null) return destObj;
+  do {
+    for (props = Object.getOwnPropertyNames(sourceObj), i = props.length; i-- > 0; )
+      prop = props[i], (!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop] && (destObj[prop] = sourceObj[prop], merged[prop] = !0);
+    sourceObj = filter2 !== !1 && getPrototypeOf(sourceObj);
+  } while (sourceObj && (!filter2 || filter2(sourceObj, destObj)) && sourceObj !== Object.prototype);
+  return destObj;
+}, endsWith = (str, searchString, position) => {
+  str = String(str), (position === void 0 || position > str.length) && (position = str.length), position -= searchString.length;
+  const lastIndex = str.indexOf(searchString, position);
+  return lastIndex !== -1 && lastIndex === position;
+}, toArray = (thing) => {
+  if (!thing) return null;
+  if (isArray(thing)) return thing;
+  let i = thing.length;
+  if (!isNumber(i)) return null;
+  const arr = new Array(i);
+  for (; i-- > 0; )
+    arr[i] = thing[i];
+  return arr;
+}, isTypedArray = /* @__PURE__ */ ((TypedArray) => (thing) => TypedArray && thing instanceof TypedArray)(typeof Uint8Array < "u" && getPrototypeOf(Uint8Array)), forEachEntry = (obj, fn) => {
+  const _iterator = (obj && obj[iterator]).call(obj);
+  let result;
+  for (; (result = _iterator.next()) && !result.done; ) {
+    const pair = result.value;
+    fn.call(obj, pair[0], pair[1]);
+  }
+}, matchAll = (regExp, str) => {
+  let matches;
+  const arr = [];
+  for (; (matches = regExp.exec(str)) !== null; )
+    arr.push(matches);
+  return arr;
+}, isHTMLForm = kindOfTest("HTMLFormElement"), toCamelCase = (str) => str.toLowerCase().replace(
+  /[-_\s]([a-z\d])(\w*)/g,
+  function(m, p1, p2) {
+    return p1.toUpperCase() + p2;
+  }
+), hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype), isRegExp = kindOfTest("RegExp"), reduceDescriptors = (obj, reducer) => {
+  const descriptors2 = Object.getOwnPropertyDescriptors(obj), reducedDescriptors = {};
+  forEach(descriptors2, (descriptor, name) => {
+    let ret;
+    (ret = reducer(descriptor, name, obj)) !== !1 && (reducedDescriptors[name] = ret || descriptor);
+  }), Object.defineProperties(obj, reducedDescriptors);
+}, freezeMethods = (obj) => {
+  reduceDescriptors(obj, (descriptor, name) => {
+    if (isFunction$1(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1)
+      return !1;
+    const value = obj[name];
+    if (isFunction$1(value)) {
+      if (descriptor.enumerable = !1, "writable" in descriptor) {
+        descriptor.writable = !1;
+        return;
+      }
+      descriptor.set || (descriptor.set = () => {
+        throw Error("Can not rewrite read-only method '" + name + "'");
+      });
+    }
+  });
+}, toObjectSet = (arrayOrString, delimiter) => {
+  const obj = {}, define = (arr) => {
+    arr.forEach((value) => {
+      obj[value] = !0;
+    });
+  };
+  return isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter)), obj;
+}, noop = () => {
+}, toFiniteNumber = (value, defaultValue) => value != null && Number.isFinite(value = +value) ? value : defaultValue;
+function isSpecCompliantForm(thing) {
+  return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
+}
+const toJSONObject = (obj) => {
+  const stack = new Array(10), visit = (source, i) => {
+    if (isObject(source)) {
+      if (stack.indexOf(source) >= 0)
+        return;
+      if (isBuffer(source))
+        return source;
+      if (!("toJSON" in source)) {
+        stack[i] = source;
+        const target = isArray(source) ? [] : {};
+        return forEach(source, (value, key) => {
+          const reducedValue = visit(value, i + 1);
+          !isUndefined(reducedValue) && (target[key] = reducedValue);
+        }), stack[i] = void 0, target;
+      }
+    }
+    return source;
+  };
+  return visit(obj, 0);
+}, isAsyncFn = kindOfTest("AsyncFunction"), isThenable = (thing) => thing && (isObject(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch), _setImmediate = ((setImmediateSupported, postMessageSupported) => setImmediateSupported ? setImmediate : postMessageSupported ? ((token, callbacks) => (_global.addEventListener("message", ({ source, data }) => {
+  source === _global && data === token && callbacks.length && callbacks.shift()();
+}, !1), (cb) => {
+  callbacks.push(cb), _global.postMessage(token, "*");
+}))(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb))(
+  typeof setImmediate == "function",
+  isFunction$1(_global.postMessage)
+), asap = typeof queueMicrotask < "u" ? queueMicrotask.bind(_global) : typeof process < "u" && process.nextTick || _setImmediate, isIterable = (thing) => thing != null && isFunction$1(thing[iterator]), utils$1 = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isBoolean,
+  isObject,
+  isPlainObject,
+  isEmptyObject,
+  isReadableStream,
+  isRequest,
+  isResponse,
+  isHeaders,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isRegExp,
+  isFunction: isFunction$1,
+  isStream,
+  isURLSearchParams,
+  isTypedArray,
+  isFileList,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM,
+  inherits,
+  toFlatObject,
+  kindOf,
+  kindOfTest,
+  endsWith,
+  toArray,
+  forEachEntry,
+  matchAll,
+  isHTMLForm,
+  hasOwnProperty,
+  hasOwnProp: hasOwnProperty,
+  // an alias to avoid ESLint no-prototype-builtins detection
+  reduceDescriptors,
+  freezeMethods,
+  toObjectSet,
+  toCamelCase,
+  noop,
+  toFiniteNumber,
+  findKey,
+  global: _global,
+  isContextDefined,
+  isSpecCompliantForm,
+  toJSONObject,
+  isAsyncFn,
+  isThenable,
+  setImmediate: _setImmediate,
+  asap,
+  isIterable
+};
+function AxiosError$1(message, code, config, request, response) {
+  Error.call(this), Error.captureStackTrace ? Error.captureStackTrace(this, this.constructor) : this.stack = new Error().stack, this.message = message, this.name = "AxiosError", code && (this.code = code), config && (this.config = config), request && (this.request = request), response && (this.response = response, this.status = response.status ? response.status : null);
+}
+utils$1.inherits(AxiosError$1, Error, {
+  toJSON: function() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: utils$1.toJSONObject(this.config),
+      code: this.code,
+      status: this.status
+    };
+  }
+});
+const prototype$1 = AxiosError$1.prototype, descriptors = {};
+[
+  "ERR_BAD_OPTION_VALUE",
+  "ERR_BAD_OPTION",
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "ERR_NETWORK",
+  "ERR_FR_TOO_MANY_REDIRECTS",
+  "ERR_DEPRECATED",
+  "ERR_BAD_RESPONSE",
+  "ERR_BAD_REQUEST",
+  "ERR_CANCELED",
+  "ERR_NOT_SUPPORT",
+  "ERR_INVALID_URL"
+  // eslint-disable-next-line func-names
+].forEach((code) => {
+  descriptors[code] = { value: code };
+});
+Object.defineProperties(AxiosError$1, descriptors);
+Object.defineProperty(prototype$1, "isAxiosError", { value: !0 });
+AxiosError$1.from = (error, code, config, request, response, customProps) => {
+  const axiosError = Object.create(prototype$1);
+  utils$1.toFlatObject(error, axiosError, function(obj) {
+    return obj !== Error.prototype;
+  }, (prop) => prop !== "isAxiosError");
+  const msg = error && error.message ? error.message : "Error", errCode = code == null && error ? error.code : code;
+  return AxiosError$1.call(axiosError, msg, errCode, config, request, response), error && axiosError.cause == null && Object.defineProperty(axiosError, "cause", { value: error, configurable: !0 }), axiosError.name = error && error.name || "Error", customProps && Object.assign(axiosError, customProps), axiosError;
+};
+const httpAdapter = null;
+function isVisitable(thing) {
+  return utils$1.isPlainObject(thing) || utils$1.isArray(thing);
+}
+function removeBrackets(key) {
+  return utils$1.endsWith(key, "[]") ? key.slice(0, -2) : key;
+}
+function renderKey(path, key, dots) {
+  return path ? path.concat(key).map(function(token, i) {
+    return token = removeBrackets(token), !dots && i ? "[" + token + "]" : token;
+  }).join(dots ? "." : "") : key;
+}
+function isFlatArray(arr) {
+  return utils$1.isArray(arr) && !arr.some(isVisitable);
+}
+const predicates = utils$1.toFlatObject(utils$1, {}, null, function(prop) {
+  return /^is[A-Z]/.test(prop);
+});
+function toFormData$1(obj, formData, options) {
+  if (!utils$1.isObject(obj))
+    throw new TypeError("target must be an object");
+  formData = formData || new FormData(), options = utils$1.toFlatObject(options, {
+    metaTokens: !0,
+    dots: !1,
+    indexes: !1
+  }, !1, function(option, source) {
+    return !utils$1.isUndefined(source[option]);
+  });
+  const metaTokens = options.metaTokens, visitor = options.visitor || defaultVisitor, dots = options.dots, indexes = options.indexes, useBlob = (options.Blob || typeof Blob < "u" && Blob) && utils$1.isSpecCompliantForm(formData);
+  if (!utils$1.isFunction(visitor))
+    throw new TypeError("visitor must be a function");
+  function convertValue(value) {
+    if (value === null) return "";
+    if (utils$1.isDate(value))
+      return value.toISOString();
+    if (utils$1.isBoolean(value))
+      return value.toString();
+    if (!useBlob && utils$1.isBlob(value))
+      throw new AxiosError$1("Blob is not supported. Use a Buffer instead.");
+    return utils$1.isArrayBuffer(value) || utils$1.isTypedArray(value) ? useBlob && typeof Blob == "function" ? new Blob([value]) : Buffer.from(value) : value;
+  }
+  function defaultVisitor(value, key, path) {
+    let arr = value;
+    if (value && !path && typeof value == "object") {
+      if (utils$1.endsWith(key, "{}"))
+        key = metaTokens ? key : key.slice(0, -2), value = JSON.stringify(value);
+      else if (utils$1.isArray(value) && isFlatArray(value) || (utils$1.isFileList(value) || utils$1.endsWith(key, "[]")) && (arr = utils$1.toArray(value)))
+        return key = removeBrackets(key), arr.forEach(function(el, index) {
+          !(utils$1.isUndefined(el) || el === null) && formData.append(
+            // eslint-disable-next-line no-nested-ternary
+            indexes === !0 ? renderKey([key], index, dots) : indexes === null ? key : key + "[]",
+            convertValue(el)
+          );
+        }), !1;
+    }
+    return isVisitable(value) ? !0 : (formData.append(renderKey(path, key, dots), convertValue(value)), !1);
+  }
+  const stack = [], exposedHelpers = Object.assign(predicates, {
+    defaultVisitor,
+    convertValue,
+    isVisitable
+  });
+  function build(value, path) {
+    if (!utils$1.isUndefined(value)) {
+      if (stack.indexOf(value) !== -1)
+        throw Error("Circular reference detected in " + path.join("."));
+      stack.push(value), utils$1.forEach(value, function(el, key) {
+        (!(utils$1.isUndefined(el) || el === null) && visitor.call(
+          formData,
+          el,
+          utils$1.isString(key) ? key.trim() : key,
+          path,
+          exposedHelpers
+        )) === !0 && build(el, path ? path.concat(key) : [key]);
+      }), stack.pop();
+    }
+  }
+  if (!utils$1.isObject(obj))
+    throw new TypeError("data must be an object");
+  return build(obj), formData;
+}
+function encode$1(str) {
+  const charMap = {
+    "!": "%21",
+    "'": "%27",
+    "(": "%28",
+    ")": "%29",
+    "~": "%7E",
+    "%20": "+",
+    "%00": "\0"
+  };
+  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function(match) {
+    return charMap[match];
+  });
+}
+function AxiosURLSearchParams(params, options) {
+  this._pairs = [], params && toFormData$1(params, this, options);
+}
+const prototype = AxiosURLSearchParams.prototype;
+prototype.append = function(name, value) {
+  this._pairs.push([name, value]);
+};
+prototype.toString = function(encoder) {
+  const _encode = encoder ? function(value) {
+    return encoder.call(this, value, encode$1);
+  } : encode$1;
+  return this._pairs.map(function(pair) {
+    return _encode(pair[0]) + "=" + _encode(pair[1]);
+  }, "").join("&");
+};
+function encode(val) {
+  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+");
+}
+function buildURL(url, params, options) {
+  if (!params)
+    return url;
+  const _encode = options && options.encode || encode;
+  utils$1.isFunction(options) && (options = {
+    serialize: options
+  });
+  const serializeFn = options && options.serialize;
+  let serializedParams;
+  if (serializeFn ? serializedParams = serializeFn(params, options) : serializedParams = utils$1.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, options).toString(_encode), serializedParams) {
+    const hashmarkIndex = url.indexOf("#");
+    hashmarkIndex !== -1 && (url = url.slice(0, hashmarkIndex)), url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+  }
+  return url;
+}
+class InterceptorManager {
+  constructor() {
+    this.handlers = [];
+  }
+  /**
+   * Add a new interceptor to the stack
+   *
+   * @param {Function} fulfilled The function to handle `then` for a `Promise`
+   * @param {Function} rejected The function to handle `reject` for a `Promise`
+   *
+   * @return {Number} An ID used to remove interceptor later
+   */
+  use(fulfilled, rejected, options) {
+    return this.handlers.push({
+      fulfilled,
+      rejected,
+      synchronous: options ? options.synchronous : !1,
+      runWhen: options ? options.runWhen : null
+    }), this.handlers.length - 1;
+  }
+  /**
+   * Remove an interceptor from the stack
+   *
+   * @param {Number} id The ID that was returned by `use`
+   *
+   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+   */
+  eject(id) {
+    this.handlers[id] && (this.handlers[id] = null);
+  }
+  /**
+   * Clear all interceptors from the stack
+   *
+   * @returns {void}
+   */
+  clear() {
+    this.handlers && (this.handlers = []);
+  }
+  /**
+   * Iterate over all the registered interceptors
+   *
+   * This method is particularly useful for skipping over any
+   * interceptors that may have become `null` calling `eject`.
+   *
+   * @param {Function} fn The function to call for each interceptor
+   *
+   * @returns {void}
+   */
+  forEach(fn) {
+    utils$1.forEach(this.handlers, function(h) {
+      h !== null && fn(h);
+    });
+  }
+}
+const transitionalDefaults = {
+  silentJSONParsing: !0,
+  forcedJSONParsing: !0,
+  clarifyTimeoutError: !1
+}, URLSearchParams$1 = typeof URLSearchParams < "u" ? URLSearchParams : AxiosURLSearchParams, FormData$1 = typeof FormData < "u" ? FormData : null, Blob$1 = typeof Blob < "u" ? Blob : null, platform$1 = {
+  isBrowser: !0,
+  classes: {
+    URLSearchParams: URLSearchParams$1,
+    FormData: FormData$1,
+    Blob: Blob$1
+  },
+  protocols: ["http", "https", "file", "blob", "url", "data"]
+}, hasBrowserEnv = typeof window < "u" && typeof document < "u", _navigator = typeof navigator == "object" && navigator || void 0, hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || ["ReactNative", "NativeScript", "NS"].indexOf(_navigator.product) < 0), hasStandardBrowserWebWorkerEnv = typeof WorkerGlobalScope < "u" && // eslint-disable-next-line no-undef
+self instanceof WorkerGlobalScope && typeof self.importScripts == "function", origin = hasBrowserEnv && window.location.href || "http://localhost", utils = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  hasBrowserEnv,
+  hasStandardBrowserEnv,
+  hasStandardBrowserWebWorkerEnv,
+  navigator: _navigator,
+  origin
+}, Symbol.toStringTag, { value: "Module" })), platform = {
+  ...utils,
+  ...platform$1
+};
+function toURLEncodedForm(data, options) {
+  return toFormData$1(data, new platform.classes.URLSearchParams(), {
+    visitor: function(value, key, path, helpers) {
+      return platform.isNode && utils$1.isBuffer(value) ? (this.append(key, value.toString("base64")), !1) : helpers.defaultVisitor.apply(this, arguments);
+    },
+    ...options
+  });
+}
+function parsePropPath(name) {
+  return utils$1.matchAll(/\w+|\[(\w*)]/g, name).map((match) => match[0] === "[]" ? "" : match[1] || match[0]);
+}
+function arrayToObject(arr) {
+  const obj = {}, keys = Object.keys(arr);
+  let i;
+  const len = keys.length;
+  let key;
+  for (i = 0; i < len; i++)
+    key = keys[i], obj[key] = arr[key];
+  return obj;
+}
+function formDataToJSON(formData) {
+  function buildPath(path, value, target, index) {
+    let name = path[index++];
+    if (name === "__proto__") return !0;
+    const isNumericKey = Number.isFinite(+name), isLast = index >= path.length;
+    return name = !name && utils$1.isArray(target) ? target.length : name, isLast ? (utils$1.hasOwnProp(target, name) ? target[name] = [target[name], value] : target[name] = value, !isNumericKey) : ((!target[name] || !utils$1.isObject(target[name])) && (target[name] = []), buildPath(path, value, target[name], index) && utils$1.isArray(target[name]) && (target[name] = arrayToObject(target[name])), !isNumericKey);
+  }
+  if (utils$1.isFormData(formData) && utils$1.isFunction(formData.entries)) {
+    const obj = {};
+    return utils$1.forEachEntry(formData, (name, value) => {
+      buildPath(parsePropPath(name), value, obj, 0);
+    }), obj;
+  }
+  return null;
+}
+function stringifySafely(rawValue, parser, encoder) {
+  if (utils$1.isString(rawValue))
+    try {
+      return (parser || JSON.parse)(rawValue), utils$1.trim(rawValue);
+    } catch (e) {
+      if (e.name !== "SyntaxError")
+        throw e;
+    }
+  return (encoder || JSON.stringify)(rawValue);
+}
+const defaults = {
+  transitional: transitionalDefaults,
+  adapter: ["xhr", "http", "fetch"],
+  transformRequest: [function(data, headers) {
+    const contentType = headers.getContentType() || "", hasJSONContentType = contentType.indexOf("application/json") > -1, isObjectPayload = utils$1.isObject(data);
+    if (isObjectPayload && utils$1.isHTMLForm(data) && (data = new FormData(data)), utils$1.isFormData(data))
+      return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
+    if (utils$1.isArrayBuffer(data) || utils$1.isBuffer(data) || utils$1.isStream(data) || utils$1.isFile(data) || utils$1.isBlob(data) || utils$1.isReadableStream(data))
+      return data;
+    if (utils$1.isArrayBufferView(data))
+      return data.buffer;
+    if (utils$1.isURLSearchParams(data))
+      return headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", !1), data.toString();
+    let isFileList2;
+    if (isObjectPayload) {
+      if (contentType.indexOf("application/x-www-form-urlencoded") > -1)
+        return toURLEncodedForm(data, this.formSerializer).toString();
+      if ((isFileList2 = utils$1.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
+        const _FormData = this.env && this.env.FormData;
+        return toFormData$1(
+          isFileList2 ? { "files[]": data } : data,
+          _FormData && new _FormData(),
+          this.formSerializer
+        );
+      }
+    }
+    return isObjectPayload || hasJSONContentType ? (headers.setContentType("application/json", !1), stringifySafely(data)) : data;
+  }],
+  transformResponse: [function(data) {
+    const transitional2 = this.transitional || defaults.transitional, forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing, JSONRequested = this.responseType === "json";
+    if (utils$1.isResponse(data) || utils$1.isReadableStream(data))
+      return data;
+    if (data && utils$1.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
+      const strictJSONParsing = !(transitional2 && transitional2.silentJSONParsing) && JSONRequested;
+      try {
+        return JSON.parse(data, this.parseReviver);
+      } catch (e) {
+        if (strictJSONParsing)
+          throw e.name === "SyntaxError" ? AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response) : e;
+      }
+    }
+    return data;
+  }],
+  /**
+   * A timeout in milliseconds to abort a request. If set to 0 (default) a
+   * timeout is not created.
+   */
+  timeout: 0,
+  xsrfCookieName: "XSRF-TOKEN",
+  xsrfHeaderName: "X-XSRF-TOKEN",
+  maxContentLength: -1,
+  maxBodyLength: -1,
+  env: {
+    FormData: platform.classes.FormData,
+    Blob: platform.classes.Blob
+  },
+  validateStatus: function(status) {
+    return status >= 200 && status < 300;
+  },
+  headers: {
+    common: {
+      Accept: "application/json, text/plain, */*",
+      "Content-Type": void 0
+    }
+  }
+};
+utils$1.forEach(["delete", "get", "head", "post", "put", "patch"], (method) => {
+  defaults.headers[method] = {};
+});
+const ignoreDuplicateOf = utils$1.toObjectSet([
+  "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"
+]), parseHeaders = (rawHeaders) => {
+  const parsed = {};
+  let key, val, i;
+  return rawHeaders && rawHeaders.split(`
+`).forEach(function(line) {
+    i = line.indexOf(":"), key = line.substring(0, i).trim().toLowerCase(), val = line.substring(i + 1).trim(), !(!key || parsed[key] && ignoreDuplicateOf[key]) && (key === "set-cookie" ? parsed[key] ? parsed[key].push(val) : parsed[key] = [val] : parsed[key] = parsed[key] ? parsed[key] + ", " + val : val);
+  }), parsed;
+}, $internals = Symbol("internals");
+function normalizeHeader(header) {
+  return header && String(header).trim().toLowerCase();
+}
+function normalizeValue(value) {
+  return value === !1 || value == null ? value : utils$1.isArray(value) ? value.map(normalizeValue) : String(value);
+}
+function parseTokens(str) {
+  const tokens = /* @__PURE__ */ Object.create(null), tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
+  let match;
+  for (; match = tokensRE.exec(str); )
+    tokens[match[1]] = match[2];
+  return tokens;
+}
+const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
+function matchHeaderValue(context, value, header, filter2, isHeaderNameFilter) {
+  if (utils$1.isFunction(filter2))
+    return filter2.call(this, value, header);
+  if (isHeaderNameFilter && (value = header), !!utils$1.isString(value)) {
+    if (utils$1.isString(filter2))
+      return value.indexOf(filter2) !== -1;
+    if (utils$1.isRegExp(filter2))
+      return filter2.test(value);
+  }
+}
+function formatHeader(header) {
+  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => char.toUpperCase() + str);
+}
+function buildAccessors(obj, header) {
+  const accessorName = utils$1.toCamelCase(" " + header);
+  ["get", "set", "has"].forEach((methodName) => {
+    Object.defineProperty(obj, methodName + accessorName, {
+      value: function(arg1, arg2, arg3) {
+        return this[methodName].call(this, header, arg1, arg2, arg3);
+      },
+      configurable: !0
+    });
+  });
+}
+let AxiosHeaders$1 = class {
+  constructor(headers) {
+    headers && this.set(headers);
+  }
+  set(header, valueOrRewrite, rewrite) {
+    const self2 = this;
+    function setHeader(_value, _header, _rewrite) {
+      const lHeader = normalizeHeader(_header);
+      if (!lHeader)
+        throw new Error("header name must be a non-empty string");
+      const key = utils$1.findKey(self2, lHeader);
+      (!key || self2[key] === void 0 || _rewrite === !0 || _rewrite === void 0 && self2[key] !== !1) && (self2[key || _header] = normalizeValue(_value));
+    }
+    const setHeaders = (headers, _rewrite) => utils$1.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
+    if (utils$1.isPlainObject(header) || header instanceof this.constructor)
+      setHeaders(header, valueOrRewrite);
+    else if (utils$1.isString(header) && (header = header.trim()) && !isValidHeaderName(header))
+      setHeaders(parseHeaders(header), valueOrRewrite);
+    else if (utils$1.isObject(header) && utils$1.isIterable(header)) {
+      let obj = {}, dest, key;
+      for (const entry of header) {
+        if (!utils$1.isArray(entry))
+          throw TypeError("Object iterator must return a key-value pair");
+        obj[key = entry[0]] = (dest = obj[key]) ? utils$1.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
+      }
+      setHeaders(obj, valueOrRewrite);
+    } else
+      header != null && setHeader(valueOrRewrite, header, rewrite);
+    return this;
+  }
+  get(header, parser) {
+    if (header = normalizeHeader(header), header) {
+      const key = utils$1.findKey(this, header);
+      if (key) {
+        const value = this[key];
+        if (!parser)
+          return value;
+        if (parser === !0)
+          return parseTokens(value);
+        if (utils$1.isFunction(parser))
+          return parser.call(this, value, key);
+        if (utils$1.isRegExp(parser))
+          return parser.exec(value);
+        throw new TypeError("parser must be boolean|regexp|function");
+      }
+    }
+  }
+  has(header, matcher) {
+    if (header = normalizeHeader(header), header) {
+      const key = utils$1.findKey(this, header);
+      return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
+    }
+    return !1;
+  }
+  delete(header, matcher) {
+    const self2 = this;
+    let deleted = !1;
+    function deleteHeader(_header) {
+      if (_header = normalizeHeader(_header), _header) {
+        const key = utils$1.findKey(self2, _header);
+        key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher)) && (delete self2[key], deleted = !0);
+      }
+    }
+    return utils$1.isArray(header) ? header.forEach(deleteHeader) : deleteHeader(header), deleted;
+  }
+  clear(matcher) {
+    const keys = Object.keys(this);
+    let i = keys.length, deleted = !1;
+    for (; i--; ) {
+      const key = keys[i];
+      (!matcher || matchHeaderValue(this, this[key], key, matcher, !0)) && (delete this[key], deleted = !0);
+    }
+    return deleted;
+  }
+  normalize(format) {
+    const self2 = this, headers = {};
+    return utils$1.forEach(this, (value, header) => {
+      const key = utils$1.findKey(headers, header);
+      if (key) {
+        self2[key] = normalizeValue(value), delete self2[header];
+        return;
+      }
+      const normalized = format ? formatHeader(header) : String(header).trim();
+      normalized !== header && delete self2[header], self2[normalized] = normalizeValue(value), headers[normalized] = !0;
+    }), this;
+  }
+  concat(...targets) {
+    return this.constructor.concat(this, ...targets);
+  }
+  toJSON(asStrings) {
+    const obj = /* @__PURE__ */ Object.create(null);
+    return utils$1.forEach(this, (value, header) => {
+      value != null && value !== !1 && (obj[header] = asStrings && utils$1.isArray(value) ? value.join(", ") : value);
+    }), obj;
+  }
+  [Symbol.iterator]() {
+    return Object.entries(this.toJSON())[Symbol.iterator]();
+  }
+  toString() {
+    return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join(`
+`);
+  }
+  getSetCookie() {
+    return this.get("set-cookie") || [];
+  }
+  get [Symbol.toStringTag]() {
+    return "AxiosHeaders";
+  }
+  static from(thing) {
+    return thing instanceof this ? thing : new this(thing);
+  }
+  static concat(first, ...targets) {
+    const computed = new this(first);
+    return targets.forEach((target) => computed.set(target)), computed;
+  }
+  static accessor(header) {
+    const accessors = (this[$internals] = this[$internals] = {
+      accessors: {}
+    }).accessors, prototype2 = this.prototype;
+    function defineAccessor(_header) {
+      const lHeader = normalizeHeader(_header);
+      accessors[lHeader] || (buildAccessors(prototype2, _header), accessors[lHeader] = !0);
+    }
+    return utils$1.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header), this;
+  }
+};
+AxiosHeaders$1.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
+utils$1.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key) => {
+  let mapped = key[0].toUpperCase() + key.slice(1);
+  return {
+    get: () => value,
+    set(headerValue) {
+      this[mapped] = headerValue;
+    }
+  };
+});
+utils$1.freezeMethods(AxiosHeaders$1);
+function transformData(fns, response) {
+  const config = this || defaults, context = response || config, headers = AxiosHeaders$1.from(context.headers);
+  let data = context.data;
+  return utils$1.forEach(fns, function(fn) {
+    data = fn.call(config, data, headers.normalize(), response ? response.status : void 0);
+  }), headers.normalize(), data;
+}
+function isCancel$1(value) {
+  return !!(value && value.__CANCEL__);
+}
+function CanceledError$1(message, config, request) {
+  AxiosError$1.call(this, message ?? "canceled", AxiosError$1.ERR_CANCELED, config, request), this.name = "CanceledError";
+}
+utils$1.inherits(CanceledError$1, AxiosError$1, {
+  __CANCEL__: !0
+});
+function settle(resolve, reject, response) {
+  const validateStatus2 = response.config.validateStatus;
+  !response.status || !validateStatus2 || validateStatus2(response.status) ? resolve(response) : reject(new AxiosError$1(
+    "Request failed with status code " + response.status,
+    [AxiosError$1.ERR_BAD_REQUEST, AxiosError$1.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
+    response.config,
+    response.request,
+    response
+  ));
+}
+function parseProtocol(url) {
+  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+  return match && match[1] || "";
+}
+function speedometer(samplesCount, min) {
+  samplesCount = samplesCount || 10;
+  const bytes = new Array(samplesCount), timestamps = new Array(samplesCount);
+  let head = 0, tail = 0, firstSampleTS;
+  return min = min !== void 0 ? min : 1e3, function(chunkLength) {
+    const now = Date.now(), startedAt = timestamps[tail];
+    firstSampleTS || (firstSampleTS = now), bytes[head] = chunkLength, timestamps[head] = now;
+    let i = tail, bytesCount = 0;
+    for (; i !== head; )
+      bytesCount += bytes[i++], i = i % samplesCount;
+    if (head = (head + 1) % samplesCount, head === tail && (tail = (tail + 1) % samplesCount), now - firstSampleTS < min)
+      return;
+    const passed = startedAt && now - startedAt;
+    return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
+  };
+}
+function throttle(fn, freq) {
+  let timestamp = 0, threshold = 1e3 / freq, lastArgs, timer;
+  const invoke = (args, now = Date.now()) => {
+    timestamp = now, lastArgs = null, timer && (clearTimeout(timer), timer = null), fn(...args);
+  };
+  return [(...args) => {
+    const now = Date.now(), passed = now - timestamp;
+    passed >= threshold ? invoke(args, now) : (lastArgs = args, timer || (timer = setTimeout(() => {
+      timer = null, invoke(lastArgs);
+    }, threshold - passed)));
+  }, () => lastArgs && invoke(lastArgs)];
+}
+const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
+  let bytesNotified = 0;
+  const _speedometer = speedometer(50, 250);
+  return throttle((e) => {
+    const loaded = e.loaded, total = e.lengthComputable ? e.total : void 0, progressBytes = loaded - bytesNotified, rate = _speedometer(progressBytes), inRange = loaded <= total;
+    bytesNotified = loaded;
+    const data = {
+      loaded,
+      total,
+      progress: total ? loaded / total : void 0,
+      bytes: progressBytes,
+      rate: rate || void 0,
+      estimated: rate && total && inRange ? (total - loaded) / rate : void 0,
+      event: e,
+      lengthComputable: total != null,
+      [isDownloadStream ? "download" : "upload"]: !0
+    };
+    listener(data);
+  }, freq);
+}, progressEventDecorator = (total, throttled) => {
+  const lengthComputable = total != null;
+  return [(loaded) => throttled[0]({
+    lengthComputable,
+    total,
+    loaded
+  }), throttled[1]];
+}, asyncDecorator = (fn) => (...args) => utils$1.asap(() => fn(...args)), isURLSameOrigin = platform.hasStandardBrowserEnv ? /* @__PURE__ */ ((origin2, isMSIE) => (url) => (url = new URL(url, platform.origin), origin2.protocol === url.protocol && origin2.host === url.host && (isMSIE || origin2.port === url.port)))(
+  new URL(platform.origin),
+  platform.navigator && /(msie|trident)/i.test(platform.navigator.userAgent)
+) : () => !0, cookies = platform.hasStandardBrowserEnv ? (
+  // Standard browser envs support document.cookie
+  {
+    write(name, value, expires, path, domain, secure) {
+      const cookie = [name + "=" + encodeURIComponent(value)];
+      utils$1.isNumber(expires) && cookie.push("expires=" + new Date(expires).toGMTString()), utils$1.isString(path) && cookie.push("path=" + path), utils$1.isString(domain) && cookie.push("domain=" + domain), secure === !0 && cookie.push("secure"), document.cookie = cookie.join("; ");
+    },
+    read(name) {
+      const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
+      return match ? decodeURIComponent(match[3]) : null;
+    },
+    remove(name) {
+      this.write(name, "", Date.now() - 864e5);
+    }
+  }
+) : (
+  // Non-standard browser env (web workers, react-native) lack needed support.
+  {
+    write() {
+    },
+    read() {
+      return null;
+    },
+    remove() {
+    }
+  }
+);
+function isAbsoluteURL(url) {
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}
+function combineURLs(baseURL, relativeURL) {
+  return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+}
+function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
+  let isRelativeUrl = !isAbsoluteURL(requestedURL);
+  return baseURL && (isRelativeUrl || allowAbsoluteUrls == !1) ? combineURLs(baseURL, requestedURL) : requestedURL;
+}
+const headersToObject = (thing) => thing instanceof AxiosHeaders$1 ? { ...thing } : thing;
+function mergeConfig$1(config1, config2) {
+  config2 = config2 || {};
+  const config = {};
+  function getMergedValue(target, source, prop, caseless) {
+    return utils$1.isPlainObject(target) && utils$1.isPlainObject(source) ? utils$1.merge.call({ caseless }, target, source) : utils$1.isPlainObject(source) ? utils$1.merge({}, source) : utils$1.isArray(source) ? source.slice() : source;
+  }
+  function mergeDeepProperties(a, b, prop, caseless) {
+    if (utils$1.isUndefined(b)) {
+      if (!utils$1.isUndefined(a))
+        return getMergedValue(void 0, a, prop, caseless);
+    } else return getMergedValue(a, b, prop, caseless);
+  }
+  function valueFromConfig2(a, b) {
+    if (!utils$1.isUndefined(b))
+      return getMergedValue(void 0, b);
+  }
+  function defaultToConfig2(a, b) {
+    if (utils$1.isUndefined(b)) {
+      if (!utils$1.isUndefined(a))
+        return getMergedValue(void 0, a);
+    } else return getMergedValue(void 0, b);
+  }
+  function mergeDirectKeys(a, b, prop) {
+    if (prop in config2)
+      return getMergedValue(a, b);
+    if (prop in config1)
+      return getMergedValue(void 0, a);
+  }
+  const mergeMap = {
+    url: valueFromConfig2,
+    method: valueFromConfig2,
+    data: valueFromConfig2,
+    baseURL: defaultToConfig2,
+    transformRequest: defaultToConfig2,
+    transformResponse: defaultToConfig2,
+    paramsSerializer: defaultToConfig2,
+    timeout: defaultToConfig2,
+    timeoutMessage: defaultToConfig2,
+    withCredentials: defaultToConfig2,
+    withXSRFToken: defaultToConfig2,
+    adapter: defaultToConfig2,
+    responseType: defaultToConfig2,
+    xsrfCookieName: defaultToConfig2,
+    xsrfHeaderName: defaultToConfig2,
+    onUploadProgress: defaultToConfig2,
+    onDownloadProgress: defaultToConfig2,
+    decompress: defaultToConfig2,
+    maxContentLength: defaultToConfig2,
+    maxBodyLength: defaultToConfig2,
+    beforeRedirect: defaultToConfig2,
+    transport: defaultToConfig2,
+    httpAgent: defaultToConfig2,
+    httpsAgent: defaultToConfig2,
+    cancelToken: defaultToConfig2,
+    socketPath: defaultToConfig2,
+    responseEncoding: defaultToConfig2,
+    validateStatus: mergeDirectKeys,
+    headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, !0)
+  };
+  return utils$1.forEach(Object.keys({ ...config1, ...config2 }), function(prop) {
+    const merge2 = mergeMap[prop] || mergeDeepProperties, configValue = merge2(config1[prop], config2[prop], prop);
+    utils$1.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
+  }), config;
+}
+const resolveConfig = (config) => {
+  const newConfig = mergeConfig$1({}, config);
+  let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
+  if (newConfig.headers = headers = AxiosHeaders$1.from(headers), newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer), auth && headers.set(
+    "Authorization",
+    "Basic " + btoa((auth.username || "") + ":" + (auth.password ? unescape(encodeURIComponent(auth.password)) : ""))
+  ), utils$1.isFormData(data)) {
+    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv)
+      headers.setContentType(void 0);
+    else if (utils$1.isFunction(data.getHeaders)) {
+      const formHeaders = data.getHeaders(), allowedHeaders = ["content-type", "content-length"];
+      Object.entries(formHeaders).forEach(([key, val]) => {
+        allowedHeaders.includes(key.toLowerCase()) && headers.set(key, val);
+      });
+    }
+  }
+  if (platform.hasStandardBrowserEnv && (withXSRFToken && utils$1.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig)), withXSRFToken || withXSRFToken !== !1 && isURLSameOrigin(newConfig.url))) {
+    const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);
+    xsrfValue && headers.set(xsrfHeaderName, xsrfValue);
+  }
+  return newConfig;
+}, isXHRAdapterSupported = typeof XMLHttpRequest < "u", xhrAdapter = isXHRAdapterSupported && function(config) {
+  return new Promise(function(resolve, reject) {
+    const _config = resolveConfig(config);
+    let requestData = _config.data;
+    const requestHeaders = AxiosHeaders$1.from(_config.headers).normalize();
+    let { responseType, onUploadProgress, onDownloadProgress } = _config, onCanceled, uploadThrottled, downloadThrottled, flushUpload, flushDownload;
+    function done() {
+      flushUpload && flushUpload(), flushDownload && flushDownload(), _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled), _config.signal && _config.signal.removeEventListener("abort", onCanceled);
+    }
+    let request = new XMLHttpRequest();
+    request.open(_config.method.toUpperCase(), _config.url, !0), request.timeout = _config.timeout;
+    function onloadend() {
+      if (!request)
+        return;
+      const responseHeaders = AxiosHeaders$1.from(
+        "getAllResponseHeaders" in request && request.getAllResponseHeaders()
+      ), response = {
+        data: !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response,
+        status: request.status,
+        statusText: request.statusText,
+        headers: responseHeaders,
+        config,
+        request
+      };
+      settle(function(value) {
+        resolve(value), done();
+      }, function(err) {
+        reject(err), done();
+      }, response), request = null;
+    }
+    "onloadend" in request ? request.onloadend = onloadend : request.onreadystatechange = function() {
+      !request || request.readyState !== 4 || request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0) || setTimeout(onloadend);
+    }, request.onabort = function() {
+      request && (reject(new AxiosError$1("Request aborted", AxiosError$1.ECONNABORTED, config, request)), request = null);
+    }, request.onerror = function(event) {
+      const msg = event && event.message ? event.message : "Network Error", err = new AxiosError$1(msg, AxiosError$1.ERR_NETWORK, config, request);
+      err.event = event || null, reject(err), request = null;
+    }, request.ontimeout = function() {
+      let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
+      const transitional2 = _config.transitional || transitionalDefaults;
+      _config.timeoutErrorMessage && (timeoutErrorMessage = _config.timeoutErrorMessage), reject(new AxiosError$1(
+        timeoutErrorMessage,
+        transitional2.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED,
+        config,
+        request
+      )), request = null;
+    }, requestData === void 0 && requestHeaders.setContentType(null), "setRequestHeader" in request && utils$1.forEach(requestHeaders.toJSON(), function(val, key) {
+      request.setRequestHeader(key, val);
+    }), utils$1.isUndefined(_config.withCredentials) || (request.withCredentials = !!_config.withCredentials), responseType && responseType !== "json" && (request.responseType = _config.responseType), onDownloadProgress && ([downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, !0), request.addEventListener("progress", downloadThrottled)), onUploadProgress && request.upload && ([uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress), request.upload.addEventListener("progress", uploadThrottled), request.upload.addEventListener("loadend", flushUpload)), (_config.cancelToken || _config.signal) && (onCanceled = (cancel) => {
+      request && (reject(!cancel || cancel.type ? new CanceledError$1(null, config, request) : cancel), request.abort(), request = null);
+    }, _config.cancelToken && _config.cancelToken.subscribe(onCanceled), _config.signal && (_config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled)));
+    const protocol = parseProtocol(_config.url);
+    if (protocol && platform.protocols.indexOf(protocol) === -1) {
+      reject(new AxiosError$1("Unsupported protocol " + protocol + ":", AxiosError$1.ERR_BAD_REQUEST, config));
+      return;
+    }
+    request.send(requestData || null);
+  });
+}, composeSignals = (signals, timeout) => {
+  const { length } = signals = signals ? signals.filter(Boolean) : [];
+  if (timeout || length) {
+    let controller = new AbortController(), aborted;
+    const onabort = function(reason) {
+      if (!aborted) {
+        aborted = !0, unsubscribe();
+        const err = reason instanceof Error ? reason : this.reason;
+        controller.abort(err instanceof AxiosError$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err));
+      }
+    };
+    let timer = timeout && setTimeout(() => {
+      timer = null, onabort(new AxiosError$1(`timeout ${timeout} of ms exceeded`, AxiosError$1.ETIMEDOUT));
+    }, timeout);
+    const unsubscribe = () => {
+      signals && (timer && clearTimeout(timer), timer = null, signals.forEach((signal2) => {
+        signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
+      }), signals = null);
+    };
+    signals.forEach((signal2) => signal2.addEventListener("abort", onabort));
+    const { signal } = controller;
+    return signal.unsubscribe = () => utils$1.asap(unsubscribe), signal;
+  }
+}, streamChunk = function* (chunk, chunkSize) {
+  let len = chunk.byteLength;
+  if (len < chunkSize) {
+    yield chunk;
+    return;
+  }
+  let pos = 0, end;
+  for (; pos < len; )
+    end = pos + chunkSize, yield chunk.slice(pos, end), pos = end;
+}, readBytes = async function* (iterable, chunkSize) {
+  for await (const chunk of readStream(iterable))
+    yield* streamChunk(chunk, chunkSize);
+}, readStream = async function* (stream) {
+  if (stream[Symbol.asyncIterator]) {
+    yield* stream;
+    return;
+  }
+  const reader = stream.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      yield value;
+    }
+  } finally {
+    await reader.cancel();
+  }
+}, trackStream = (stream, chunkSize, onProgress, onFinish) => {
+  const iterator2 = readBytes(stream, chunkSize);
+  let bytes = 0, done, _onFinish = (e) => {
+    done || (done = !0, onFinish && onFinish(e));
+  };
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done: done2, value } = await iterator2.next();
+        if (done2) {
+          _onFinish(), controller.close();
+          return;
+        }
+        let len = value.byteLength;
+        if (onProgress) {
+          let loadedBytes = bytes += len;
+          onProgress(loadedBytes);
+        }
+        controller.enqueue(new Uint8Array(value));
+      } catch (err) {
+        throw _onFinish(err), err;
+      }
+    },
+    cancel(reason) {
+      return _onFinish(reason), iterator2.return();
+    }
+  }, {
+    highWaterMark: 2
+  });
+}, DEFAULT_CHUNK_SIZE = 64 * 1024, { isFunction } = utils$1, globalFetchAPI = (({ Request, Response }) => ({
+  Request,
+  Response
+}))(utils$1.global), {
+  ReadableStream: ReadableStream$1,
+  TextEncoder
+} = utils$1.global, test = (fn, ...args) => {
+  try {
+    return !!fn(...args);
+  } catch {
+    return !1;
+  }
+}, factory = (env) => {
+  env = utils$1.merge.call({
+    skipUndefined: !0
+  }, globalFetchAPI, env);
+  const { fetch: envFetch, Request, Response } = env, isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch == "function", isRequestSupported = isFunction(Request), isResponseSupported = isFunction(Response);
+  if (!isFetchSupported)
+    return !1;
+  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream$1), encodeText = isFetchSupported && (typeof TextEncoder == "function" ? /* @__PURE__ */ ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Request(str).arrayBuffer())), supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
+    let duplexAccessed = !1;
+    const hasContentType = new Request(platform.origin, {
+      body: new ReadableStream$1(),
+      method: "POST",
+      get duplex() {
+        return duplexAccessed = !0, "half";
+      }
+    }).headers.has("Content-Type");
+    return duplexAccessed && !hasContentType;
+  }), supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils$1.isReadableStream(new Response("").body)), resolvers = {
+    stream: supportsResponseStream && ((res) => res.body)
+  };
+  isFetchSupported && ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
+    !resolvers[type] && (resolvers[type] = (res, config) => {
+      let method = res && res[type];
+      if (method)
+        return method.call(res);
+      throw new AxiosError$1(`Response type '${type}' is not supported`, AxiosError$1.ERR_NOT_SUPPORT, config);
+    });
+  });
+  const getBodyLength = async (body) => {
+    if (body == null)
+      return 0;
+    if (utils$1.isBlob(body))
+      return body.size;
+    if (utils$1.isSpecCompliantForm(body))
+      return (await new Request(platform.origin, {
+        method: "POST",
+        body
+      }).arrayBuffer()).byteLength;
+    if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body))
+      return body.byteLength;
+    if (utils$1.isURLSearchParams(body) && (body = body + ""), utils$1.isString(body))
+      return (await encodeText(body)).byteLength;
+  }, resolveBodyLength = async (headers, body) => {
+    const length = utils$1.toFiniteNumber(headers.getContentLength());
+    return length ?? getBodyLength(body);
+  };
+  return async (config) => {
+    let {
+      url,
+      method,
+      data,
+      signal,
+      cancelToken,
+      timeout,
+      onDownloadProgress,
+      onUploadProgress,
+      responseType,
+      headers,
+      withCredentials = "same-origin",
+      fetchOptions
+    } = resolveConfig(config), _fetch = envFetch || fetch;
+    responseType = responseType ? (responseType + "").toLowerCase() : "text";
+    let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout), request = null;
+    const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+      composedSignal.unsubscribe();
+    });
+    let requestContentLength;
+    try {
+      if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
+        let _request = new Request(url, {
+          method: "POST",
+          body: data,
+          duplex: "half"
+        }), contentTypeHeader;
+        if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type")) && headers.setContentType(contentTypeHeader), _request.body) {
+          const [onProgress, flush] = progressEventDecorator(
+            requestContentLength,
+            progressEventReducer(asyncDecorator(onUploadProgress))
+          );
+          data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+        }
+      }
+      utils$1.isString(withCredentials) || (withCredentials = withCredentials ? "include" : "omit");
+      const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype, resolvedOptions = {
+        ...fetchOptions,
+        signal: composedSignal,
+        method: method.toUpperCase(),
+        headers: headers.normalize().toJSON(),
+        body: data,
+        duplex: "half",
+        credentials: isCredentialsSupported ? withCredentials : void 0
+      };
+      request = isRequestSupported && new Request(url, resolvedOptions);
+      let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
+      const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
+      if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
+        const options = {};
+        ["status", "statusText", "headers"].forEach((prop) => {
+          options[prop] = response[prop];
+        });
+        const responseContentLength = utils$1.toFiniteNumber(response.headers.get("content-length")), [onProgress, flush] = onDownloadProgress && progressEventDecorator(
+          responseContentLength,
+          progressEventReducer(asyncDecorator(onDownloadProgress), !0)
+        ) || [];
+        response = new Response(
+          trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+            flush && flush(), unsubscribe && unsubscribe();
+          }),
+          options
+        );
+      }
+      responseType = responseType || "text";
+      let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || "text"](response, config);
+      return !isStreamResponse && unsubscribe && unsubscribe(), await new Promise((resolve, reject) => {
+        settle(resolve, reject, {
+          data: responseData,
+          headers: AxiosHeaders$1.from(response.headers),
+          status: response.status,
+          statusText: response.statusText,
+          config,
+          request
+        });
+      });
+    } catch (err) {
+      throw unsubscribe && unsubscribe(), err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message) ? Object.assign(
+        new AxiosError$1("Network Error", AxiosError$1.ERR_NETWORK, config, request),
+        {
+          cause: err.cause || err
+        }
+      ) : AxiosError$1.from(err, err && err.code, config, request);
+    }
+  };
+}, seedCache = /* @__PURE__ */ new Map(), getFetch = (config) => {
+  let env = config ? config.env : {};
+  const { fetch: fetch2, Request, Response } = env, seeds = [
+    Request,
+    Response,
+    fetch2
+  ];
+  let len = seeds.length, i = len, seed, target, map = seedCache;
+  for (; i--; )
+    seed = seeds[i], target = map.get(seed), target === void 0 && map.set(seed, target = i ? /* @__PURE__ */ new Map() : factory(env)), map = target;
+  return target;
+};
+getFetch();
+const knownAdapters = {
+  http: httpAdapter,
+  xhr: xhrAdapter,
+  fetch: {
+    get: getFetch
+  }
+};
+utils$1.forEach(knownAdapters, (fn, value) => {
+  if (fn) {
+    try {
+      Object.defineProperty(fn, "name", { value });
+    } catch {
+    }
+    Object.defineProperty(fn, "adapterName", { value });
+  }
+});
+const renderReason = (reason) => `- ${reason}`, isResolvedHandle = (adapter) => utils$1.isFunction(adapter) || adapter === null || adapter === !1, adapters = {
+  getAdapter: (adapters2, config) => {
+    adapters2 = utils$1.isArray(adapters2) ? adapters2 : [adapters2];
+    const { length } = adapters2;
+    let nameOrAdapter, adapter;
+    const rejectedReasons = {};
+    for (let i = 0; i < length; i++) {
+      nameOrAdapter = adapters2[i];
+      let id;
+      if (adapter = nameOrAdapter, !isResolvedHandle(nameOrAdapter) && (adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()], adapter === void 0))
+        throw new AxiosError$1(`Unknown adapter '${id}'`);
+      if (adapter && (utils$1.isFunction(adapter) || (adapter = adapter.get(config))))
+        break;
+      rejectedReasons[id || "#" + i] = adapter;
+    }
+    if (!adapter) {
+      const reasons = Object.entries(rejectedReasons).map(
+        ([id, state]) => `adapter ${id} ` + (state === !1 ? "is not supported by the environment" : "is not available in the build")
+      );
+      let s = length ? reasons.length > 1 ? `since :
+` + reasons.map(renderReason).join(`
+`) : " " + renderReason(reasons[0]) : "as no adapter specified";
+      throw new AxiosError$1(
+        "There is no suitable adapter to dispatch the request " + s,
+        "ERR_NOT_SUPPORT"
+      );
+    }
+    return adapter;
+  },
+  adapters: knownAdapters
+};
+function throwIfCancellationRequested(config) {
+  if (config.cancelToken && config.cancelToken.throwIfRequested(), config.signal && config.signal.aborted)
+    throw new CanceledError$1(null, config);
+}
+function dispatchRequest(config) {
+  return throwIfCancellationRequested(config), config.headers = AxiosHeaders$1.from(config.headers), config.data = transformData.call(
+    config,
+    config.transformRequest
+  ), ["post", "put", "patch"].indexOf(config.method) !== -1 && config.headers.setContentType("application/x-www-form-urlencoded", !1), adapters.getAdapter(config.adapter || defaults.adapter, config)(config).then(function(response) {
+    return throwIfCancellationRequested(config), response.data = transformData.call(
+      config,
+      config.transformResponse,
+      response
+    ), response.headers = AxiosHeaders$1.from(response.headers), response;
+  }, function(reason) {
+    return isCancel$1(reason) || (throwIfCancellationRequested(config), reason && reason.response && (reason.response.data = transformData.call(
+      config,
+      config.transformResponse,
+      reason.response
+    ), reason.response.headers = AxiosHeaders$1.from(reason.response.headers))), Promise.reject(reason);
+  });
+}
+const VERSION$1 = "1.12.2", validators$1 = {};
+["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
+  validators$1[type] = function(thing) {
+    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+  };
+});
+const deprecatedWarnings = {};
+validators$1.transitional = function(validator2, version, message) {
+  function formatMessage(opt, desc) {
+    return "[Axios v" + VERSION$1 + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+  }
+  return (value, opt, opts) => {
+    if (validator2 === !1)
+      throw new AxiosError$1(
+        formatMessage(opt, " has been removed" + (version ? " in " + version : "")),
+        AxiosError$1.ERR_DEPRECATED
+      );
+    return version && !deprecatedWarnings[opt] && (deprecatedWarnings[opt] = !0, console.warn(
+      formatMessage(
+        opt,
+        " has been deprecated since v" + version + " and will be removed in the near future"
+      )
+    )), validator2 ? validator2(value, opt, opts) : !0;
+  };
+};
+validators$1.spelling = function(correctSpelling) {
+  return (value, opt) => (console.warn(`${opt} is likely a misspelling of ${correctSpelling}`), !0);
+};
+function assertOptions(options, schema, allowUnknown) {
+  if (typeof options != "object")
+    throw new AxiosError$1("options must be an object", AxiosError$1.ERR_BAD_OPTION_VALUE);
+  const keys = Object.keys(options);
+  let i = keys.length;
+  for (; i-- > 0; ) {
+    const opt = keys[i], validator2 = schema[opt];
+    if (validator2) {
+      const value = options[opt], result = value === void 0 || validator2(value, opt, options);
+      if (result !== !0)
+        throw new AxiosError$1("option " + opt + " must be " + result, AxiosError$1.ERR_BAD_OPTION_VALUE);
+      continue;
+    }
+    if (allowUnknown !== !0)
+      throw new AxiosError$1("Unknown option " + opt, AxiosError$1.ERR_BAD_OPTION);
+  }
+}
+const validator = {
+  assertOptions,
+  validators: validators$1
+}, validators = validator.validators;
+let Axios$1 = class {
+  constructor(instanceConfig) {
+    this.defaults = instanceConfig || {}, this.interceptors = {
+      request: new InterceptorManager(),
+      response: new InterceptorManager()
+    };
+  }
+  /**
+   * Dispatch a request
+   *
+   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
+   * @param {?Object} config
+   *
+   * @returns {Promise} The Promise to be fulfilled
+   */
+  async request(configOrUrl, config) {
+    try {
+      return await this._request(configOrUrl, config);
+    } catch (err) {
+      if (err instanceof Error) {
+        let dummy = {};
+        Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = new Error();
+        const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, "") : "";
+        try {
+          err.stack ? stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, "")) && (err.stack += `
+` + stack) : err.stack = stack;
+        } catch {
+        }
+      }
+      throw err;
+    }
+  }
+  _request(configOrUrl, config) {
+    typeof configOrUrl == "string" ? (config = config || {}, config.url = configOrUrl) : config = configOrUrl || {}, config = mergeConfig$1(this.defaults, config);
+    const { transitional: transitional2, paramsSerializer, headers } = config;
+    transitional2 !== void 0 && validator.assertOptions(transitional2, {
+      silentJSONParsing: validators.transitional(validators.boolean),
+      forcedJSONParsing: validators.transitional(validators.boolean),
+      clarifyTimeoutError: validators.transitional(validators.boolean)
+    }, !1), paramsSerializer != null && (utils$1.isFunction(paramsSerializer) ? config.paramsSerializer = {
+      serialize: paramsSerializer
+    } : validator.assertOptions(paramsSerializer, {
+      encode: validators.function,
+      serialize: validators.function
+    }, !0)), config.allowAbsoluteUrls !== void 0 || (this.defaults.allowAbsoluteUrls !== void 0 ? config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls : config.allowAbsoluteUrls = !0), validator.assertOptions(config, {
+      baseUrl: validators.spelling("baseURL"),
+      withXsrfToken: validators.spelling("withXSRFToken")
+    }, !0), config.method = (config.method || this.defaults.method || "get").toLowerCase();
+    let contextHeaders = headers && utils$1.merge(
+      headers.common,
+      headers[config.method]
+    );
+    headers && utils$1.forEach(
+      ["delete", "get", "head", "post", "put", "patch", "common"],
+      (method) => {
+        delete headers[method];
+      }
+    ), config.headers = AxiosHeaders$1.concat(contextHeaders, headers);
+    const requestInterceptorChain = [];
+    let synchronousRequestInterceptors = !0;
+    this.interceptors.request.forEach(function(interceptor) {
+      typeof interceptor.runWhen == "function" && interceptor.runWhen(config) === !1 || (synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous, requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected));
+    });
+    const responseInterceptorChain = [];
+    this.interceptors.response.forEach(function(interceptor) {
+      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+    });
+    let promise, i = 0, len;
+    if (!synchronousRequestInterceptors) {
+      const chain = [dispatchRequest.bind(this), void 0];
+      for (chain.unshift(...requestInterceptorChain), chain.push(...responseInterceptorChain), len = chain.length, promise = Promise.resolve(config); i < len; )
+        promise = promise.then(chain[i++], chain[i++]);
+      return promise;
+    }
+    len = requestInterceptorChain.length;
+    let newConfig = config;
+    for (; i < len; ) {
+      const onFulfilled = requestInterceptorChain[i++], onRejected = requestInterceptorChain[i++];
+      try {
+        newConfig = onFulfilled(newConfig);
+      } catch (error) {
+        onRejected.call(this, error);
+        break;
+      }
+    }
+    try {
+      promise = dispatchRequest.call(this, newConfig);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    for (i = 0, len = responseInterceptorChain.length; i < len; )
+      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
+    return promise;
+  }
+  getUri(config) {
+    config = mergeConfig$1(this.defaults, config);
+    const fullPath = buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls);
+    return buildURL(fullPath, config.params, config.paramsSerializer);
+  }
+};
+utils$1.forEach(["delete", "get", "head", "options"], function(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(method) {
+  function generateHTTPMethod(isForm) {
+    return function(url, data, config) {
+      return this.request(mergeConfig$1(config || {}, {
+        method,
+        headers: isForm ? {
+          "Content-Type": "multipart/form-data"
+        } : {},
+        url,
+        data
+      }));
+    };
+  }
+  Axios$1.prototype[method] = generateHTTPMethod(), Axios$1.prototype[method + "Form"] = generateHTTPMethod(!0);
+});
+let CancelToken$1 = class CancelToken {
+  constructor(executor) {
+    if (typeof executor != "function")
+      throw new TypeError("executor must be a function.");
+    let resolvePromise;
+    this.promise = new Promise(function(resolve) {
+      resolvePromise = resolve;
+    });
+    const token = this;
+    this.promise.then((cancel) => {
+      if (!token._listeners) return;
+      let i = token._listeners.length;
+      for (; i-- > 0; )
+        token._listeners[i](cancel);
+      token._listeners = null;
+    }), this.promise.then = (onfulfilled) => {
+      let _resolve;
+      const promise = new Promise((resolve) => {
+        token.subscribe(resolve), _resolve = resolve;
+      }).then(onfulfilled);
+      return promise.cancel = function() {
+        token.unsubscribe(_resolve);
+      }, promise;
+    }, executor(function(message, config, request) {
+      token.reason || (token.reason = new CanceledError$1(message, config, request), resolvePromise(token.reason));
+    });
+  }
+  /**
+   * Throws a `CanceledError` if cancellation has been requested.
+   */
+  throwIfRequested() {
+    if (this.reason)
+      throw this.reason;
+  }
+  /**
+   * Subscribe to the cancel signal
+   */
+  subscribe(listener) {
+    if (this.reason) {
+      listener(this.reason);
+      return;
+    }
+    this._listeners ? this._listeners.push(listener) : this._listeners = [listener];
+  }
+  /**
+   * Unsubscribe from the cancel signal
+   */
+  unsubscribe(listener) {
+    if (!this._listeners)
+      return;
+    const index = this._listeners.indexOf(listener);
+    index !== -1 && this._listeners.splice(index, 1);
+  }
+  toAbortSignal() {
+    const controller = new AbortController(), abort = (err) => {
+      controller.abort(err);
+    };
+    return this.subscribe(abort), controller.signal.unsubscribe = () => this.unsubscribe(abort), controller.signal;
+  }
+  /**
+   * Returns an object that contains a new `CancelToken` and a function that, when called,
+   * cancels the `CancelToken`.
+   */
+  static source() {
+    let cancel;
+    return {
+      token: new CancelToken(function(c) {
+        cancel = c;
+      }),
+      cancel
+    };
+  }
+};
+function spread$1(callback) {
+  return function(arr) {
+    return callback.apply(null, arr);
+  };
+}
+function isAxiosError$1(payload) {
+  return utils$1.isObject(payload) && payload.isAxiosError === !0;
+}
+const HttpStatusCode$1 = {
+  Continue: 100,
+  SwitchingProtocols: 101,
+  Processing: 102,
+  EarlyHints: 103,
+  Ok: 200,
+  Created: 201,
+  Accepted: 202,
+  NonAuthoritativeInformation: 203,
+  NoContent: 204,
+  ResetContent: 205,
+  PartialContent: 206,
+  MultiStatus: 207,
+  AlreadyReported: 208,
+  ImUsed: 226,
+  MultipleChoices: 300,
+  MovedPermanently: 301,
+  Found: 302,
+  SeeOther: 303,
+  NotModified: 304,
+  UseProxy: 305,
+  Unused: 306,
+  TemporaryRedirect: 307,
+  PermanentRedirect: 308,
+  BadRequest: 400,
+  Unauthorized: 401,
+  PaymentRequired: 402,
+  Forbidden: 403,
+  NotFound: 404,
+  MethodNotAllowed: 405,
+  NotAcceptable: 406,
+  ProxyAuthenticationRequired: 407,
+  RequestTimeout: 408,
+  Conflict: 409,
+  Gone: 410,
+  LengthRequired: 411,
+  PreconditionFailed: 412,
+  PayloadTooLarge: 413,
+  UriTooLong: 414,
+  UnsupportedMediaType: 415,
+  RangeNotSatisfiable: 416,
+  ExpectationFailed: 417,
+  ImATeapot: 418,
+  MisdirectedRequest: 421,
+  UnprocessableEntity: 422,
+  Locked: 423,
+  FailedDependency: 424,
+  TooEarly: 425,
+  UpgradeRequired: 426,
+  PreconditionRequired: 428,
+  TooManyRequests: 429,
+  RequestHeaderFieldsTooLarge: 431,
+  UnavailableForLegalReasons: 451,
+  InternalServerError: 500,
+  NotImplemented: 501,
+  BadGateway: 502,
+  ServiceUnavailable: 503,
+  GatewayTimeout: 504,
+  HttpVersionNotSupported: 505,
+  VariantAlsoNegotiates: 506,
+  InsufficientStorage: 507,
+  LoopDetected: 508,
+  NotExtended: 510,
+  NetworkAuthenticationRequired: 511
+};
+Object.entries(HttpStatusCode$1).forEach(([key, value]) => {
+  HttpStatusCode$1[value] = key;
+});
+function createInstance(defaultConfig) {
+  const context = new Axios$1(defaultConfig), instance = bind(Axios$1.prototype.request, context);
+  return utils$1.extend(instance, Axios$1.prototype, context, { allOwnKeys: !0 }), utils$1.extend(instance, context, null, { allOwnKeys: !0 }), instance.create = function(instanceConfig) {
+    return createInstance(mergeConfig$1(defaultConfig, instanceConfig));
+  }, instance;
+}
+const axios = createInstance(defaults);
+axios.Axios = Axios$1;
+axios.CanceledError = CanceledError$1;
+axios.CancelToken = CancelToken$1;
+axios.isCancel = isCancel$1;
+axios.VERSION = VERSION$1;
+axios.toFormData = toFormData$1;
+axios.AxiosError = AxiosError$1;
+axios.Cancel = axios.CanceledError;
+axios.all = function(promises) {
+  return Promise.all(promises);
+};
+axios.spread = spread$1;
+axios.isAxiosError = isAxiosError$1;
+axios.mergeConfig = mergeConfig$1;
+axios.AxiosHeaders = AxiosHeaders$1;
+axios.formToJSON = (thing) => formDataToJSON(utils$1.isHTMLForm(thing) ? new FormData(thing) : thing);
+axios.getAdapter = adapters.getAdapter;
+axios.HttpStatusCode = HttpStatusCode$1;
+axios.default = axios;
+const {
+  Axios: Axios2,
+  AxiosError,
+  CanceledError,
+  isCancel,
+  CancelToken: CancelToken2,
+  VERSION,
+  all: all2,
+  Cancel,
+  isAxiosError,
+  spread,
+  toFormData,
+  AxiosHeaders: AxiosHeaders2,
+  HttpStatusCode,
+  formToJSON,
+  getAdapter,
+  mergeConfig
+} = axios;
+var jsonBigint = { exports: {} }, stringify = { exports: {} }, bignumber$1 = { exports: {} }, bignumber = bignumber$1.exports, hasRequiredBignumber;
+function requireBignumber() {
+  return hasRequiredBignumber || (hasRequiredBignumber = 1, (function(module) {
+    (function(globalObject) {
+      var BigNumber, isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, mathceil = Math.ceil, mathfloor = Math.floor, bignumberError = "[BigNumber Error] ", tooManyDigits = bignumberError + "Number primitive has more than 15 significant digits: ", BASE = 1e14, LOG_BASE = 14, MAX_SAFE_INTEGER = 9007199254740991, POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13], SQRT_BASE = 1e7, MAX = 1e9;
+      function clone(configObject) {
+        var div, convertBase, parseNumeric, P = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = !1, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
+          prefix: "",
+          groupSize: 3,
+          secondaryGroupSize: 0,
+          groupSeparator: ",",
+          decimalSeparator: ".",
+          fractionGroupSize: 0,
+          fractionGroupSeparator: " ",
+          // non-breaking space
+          suffix: ""
+        }, ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz", alphabetHasNormalDecimalDigits = !0;
+        function BigNumber2(v, b) {
+          var alphabet, c, caseChanged, e, i, isNum, len, str, x = this;
+          if (!(x instanceof BigNumber2)) return new BigNumber2(v, b);
+          if (b == null) {
+            if (v && v._isBigNumber === !0) {
+              x.s = v.s, !v.c || v.e > MAX_EXP ? x.c = x.e = null : v.e < MIN_EXP ? x.c = [x.e = 0] : (x.e = v.e, x.c = v.c.slice());
+              return;
+            }
+            if ((isNum = typeof v == "number") && v * 0 == 0) {
+              if (x.s = 1 / v < 0 ? (v = -v, -1) : 1, v === ~~v) {
+                for (e = 0, i = v; i >= 10; i /= 10, e++) ;
+                e > MAX_EXP ? x.c = x.e = null : (x.e = e, x.c = [v]);
+                return;
+              }
+              str = String(v);
+            } else {
+              if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);
+              x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
+            }
+            (e = str.indexOf(".")) > -1 && (str = str.replace(".", "")), (i = str.search(/e/i)) > 0 ? (e < 0 && (e = i), e += +str.slice(i + 1), str = str.substring(0, i)) : e < 0 && (e = str.length);
+          } else {
+            if (intCheck(b, 2, ALPHABET.length, "Base"), b == 10 && alphabetHasNormalDecimalDigits)
+              return x = new BigNumber2(v), round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
+            if (str = String(v), isNum = typeof v == "number") {
+              if (v * 0 != 0) return parseNumeric(x, str, isNum, b);
+              if (x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1, BigNumber2.DEBUG && str.replace(/^0\.0*|\./, "").length > 15)
+                throw Error(tooManyDigits + v);
+            } else
+              x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
+            for (alphabet = ALPHABET.slice(0, b), e = i = 0, len = str.length; i < len; i++)
+              if (alphabet.indexOf(c = str.charAt(i)) < 0) {
+                if (c == ".") {
+                  if (i > e) {
+                    e = len;
+                    continue;
+                  }
+                } else if (!caseChanged && (str == str.toUpperCase() && (str = str.toLowerCase()) || str == str.toLowerCase() && (str = str.toUpperCase()))) {
+                  caseChanged = !0, i = -1, e = 0;
+                  continue;
+                }
+                return parseNumeric(x, String(v), isNum, b);
+              }
+            isNum = !1, str = convertBase(str, b, 10, x.s), (e = str.indexOf(".")) > -1 ? str = str.replace(".", "") : e = str.length;
+          }
+          for (i = 0; str.charCodeAt(i) === 48; i++) ;
+          for (len = str.length; str.charCodeAt(--len) === 48; ) ;
+          if (str = str.slice(i, ++len)) {
+            if (len -= i, isNum && BigNumber2.DEBUG && len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v)))
+              throw Error(tooManyDigits + x.s * v);
+            if ((e = e - i - 1) > MAX_EXP)
+              x.c = x.e = null;
+            else if (e < MIN_EXP)
+              x.c = [x.e = 0];
+            else {
+              if (x.e = e, x.c = [], i = (e + 1) % LOG_BASE, e < 0 && (i += LOG_BASE), i < len) {
+                for (i && x.c.push(+str.slice(0, i)), len -= LOG_BASE; i < len; )
+                  x.c.push(+str.slice(i, i += LOG_BASE));
+                i = LOG_BASE - (str = str.slice(i)).length;
+              } else
+                i -= len;
+              for (; i--; str += "0") ;
+              x.c.push(+str);
+            }
+          } else
+            x.c = [x.e = 0];
+        }
+        BigNumber2.clone = clone, BigNumber2.ROUND_UP = 0, BigNumber2.ROUND_DOWN = 1, BigNumber2.ROUND_CEIL = 2, BigNumber2.ROUND_FLOOR = 3, BigNumber2.ROUND_HALF_UP = 4, BigNumber2.ROUND_HALF_DOWN = 5, BigNumber2.ROUND_HALF_EVEN = 6, BigNumber2.ROUND_HALF_CEIL = 7, BigNumber2.ROUND_HALF_FLOOR = 8, BigNumber2.EUCLID = 9, BigNumber2.config = BigNumber2.set = function(obj) {
+          var p, v;
+          if (obj != null)
+            if (typeof obj == "object") {
+              if (obj.hasOwnProperty(p = "DECIMAL_PLACES") && (v = obj[p], intCheck(v, 0, MAX, p), DECIMAL_PLACES = v), obj.hasOwnProperty(p = "ROUNDING_MODE") && (v = obj[p], intCheck(v, 0, 8, p), ROUNDING_MODE = v), obj.hasOwnProperty(p = "EXPONENTIAL_AT") && (v = obj[p], v && v.pop ? (intCheck(v[0], -MAX, 0, p), intCheck(v[1], 0, MAX, p), TO_EXP_NEG = v[0], TO_EXP_POS = v[1]) : (intCheck(v, -MAX, MAX, p), TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v))), obj.hasOwnProperty(p = "RANGE"))
+                if (v = obj[p], v && v.pop)
+                  intCheck(v[0], -MAX, -1, p), intCheck(v[1], 1, MAX, p), MIN_EXP = v[0], MAX_EXP = v[1];
+                else if (intCheck(v, -MAX, MAX, p), v)
+                  MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
+                else
+                  throw Error(bignumberError + p + " cannot be zero: " + v);
+              if (obj.hasOwnProperty(p = "CRYPTO"))
+                if (v = obj[p], v === !!v)
+                  if (v)
+                    if (typeof crypto < "u" && crypto && (crypto.getRandomValues || crypto.randomBytes))
+                      CRYPTO = v;
+                    else
+                      throw CRYPTO = !v, Error(bignumberError + "crypto unavailable");
+                  else
+                    CRYPTO = v;
+                else
+                  throw Error(bignumberError + p + " not true or false: " + v);
+              if (obj.hasOwnProperty(p = "MODULO_MODE") && (v = obj[p], intCheck(v, 0, 9, p), MODULO_MODE = v), obj.hasOwnProperty(p = "POW_PRECISION") && (v = obj[p], intCheck(v, 0, MAX, p), POW_PRECISION = v), obj.hasOwnProperty(p = "FORMAT"))
+                if (v = obj[p], typeof v == "object") FORMAT = v;
+                else throw Error(bignumberError + p + " not an object: " + v);
+              if (obj.hasOwnProperty(p = "ALPHABET"))
+                if (v = obj[p], typeof v == "string" && !/^.?$|[+\-.\s]|(.).*\1/.test(v))
+                  alphabetHasNormalDecimalDigits = v.slice(0, 10) == "0123456789", ALPHABET = v;
+                else
+                  throw Error(bignumberError + p + " invalid: " + v);
+            } else
+              throw Error(bignumberError + "Object expected: " + obj);
+          return {
+            DECIMAL_PLACES,
+            ROUNDING_MODE,
+            EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
+            RANGE: [MIN_EXP, MAX_EXP],
+            CRYPTO,
+            MODULO_MODE,
+            POW_PRECISION,
+            FORMAT,
+            ALPHABET
+          };
+        }, BigNumber2.isBigNumber = function(v) {
+          if (!v || v._isBigNumber !== !0) return !1;
+          if (!BigNumber2.DEBUG) return !0;
+          var i, n, c = v.c, e = v.e, s = v.s;
+          out: if ({}.toString.call(c) == "[object Array]") {
+            if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {
+              if (c[0] === 0) {
+                if (e === 0 && c.length === 1) return !0;
+                break out;
+              }
+              if (i = (e + 1) % LOG_BASE, i < 1 && (i += LOG_BASE), String(c[0]).length == i) {
+                for (i = 0; i < c.length; i++)
+                  if (n = c[i], n < 0 || n >= BASE || n !== mathfloor(n)) break out;
+                if (n !== 0) return !0;
+              }
+            }
+          } else if (c === null && e === null && (s === null || s === 1 || s === -1))
+            return !0;
+          throw Error(bignumberError + "Invalid BigNumber: " + v);
+        }, BigNumber2.maximum = BigNumber2.max = function() {
+          return maxOrMin(arguments, -1);
+        }, BigNumber2.minimum = BigNumber2.min = function() {
+          return maxOrMin(arguments, 1);
+        }, BigNumber2.random = (function() {
+          var pow2_53 = 9007199254740992, random53bitInt = Math.random() * pow2_53 & 2097151 ? function() {
+            return mathfloor(Math.random() * pow2_53);
+          } : function() {
+            return (Math.random() * 1073741824 | 0) * 8388608 + (Math.random() * 8388608 | 0);
+          };
+          return function(dp) {
+            var a, b, e, k, v, i = 0, c = [], rand = new BigNumber2(ONE);
+            if (dp == null ? dp = DECIMAL_PLACES : intCheck(dp, 0, MAX), k = mathceil(dp / LOG_BASE), CRYPTO)
+              if (crypto.getRandomValues) {
+                for (a = crypto.getRandomValues(new Uint32Array(k *= 2)); i < k; )
+                  v = a[i] * 131072 + (a[i + 1] >>> 11), v >= 9e15 ? (b = crypto.getRandomValues(new Uint32Array(2)), a[i] = b[0], a[i + 1] = b[1]) : (c.push(v % 1e14), i += 2);
+                i = k / 2;
+              } else if (crypto.randomBytes) {
+                for (a = crypto.randomBytes(k *= 7); i < k; )
+                  v = (a[i] & 31) * 281474976710656 + a[i + 1] * 1099511627776 + a[i + 2] * 4294967296 + a[i + 3] * 16777216 + (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6], v >= 9e15 ? crypto.randomBytes(7).copy(a, i) : (c.push(v % 1e14), i += 7);
+                i = k / 7;
+              } else
+                throw CRYPTO = !1, Error(bignumberError + "crypto unavailable");
+            if (!CRYPTO)
+              for (; i < k; )
+                v = random53bitInt(), v < 9e15 && (c[i++] = v % 1e14);
+            for (k = c[--i], dp %= LOG_BASE, k && dp && (v = POWS_TEN[LOG_BASE - dp], c[i] = mathfloor(k / v) * v); c[i] === 0; c.pop(), i--) ;
+            if (i < 0)
+              c = [e = 0];
+            else {
+              for (e = -1; c[0] === 0; c.splice(0, 1), e -= LOG_BASE) ;
+              for (i = 1, v = c[0]; v >= 10; v /= 10, i++) ;
+              i < LOG_BASE && (e -= LOG_BASE - i);
+            }
+            return rand.e = e, rand.c = c, rand;
+          };
+        })(), BigNumber2.sum = function() {
+          for (var i = 1, args = arguments, sum = new BigNumber2(args[0]); i < args.length; ) sum = sum.plus(args[i++]);
+          return sum;
+        }, convertBase = /* @__PURE__ */ (function() {
+          var decimal = "0123456789";
+          function toBaseOut(str, baseIn, baseOut, alphabet) {
+            for (var j, arr = [0], arrL, i = 0, len = str.length; i < len; ) {
+              for (arrL = arr.length; arrL--; arr[arrL] *= baseIn) ;
+              for (arr[0] += alphabet.indexOf(str.charAt(i++)), j = 0; j < arr.length; j++)
+                arr[j] > baseOut - 1 && (arr[j + 1] == null && (arr[j + 1] = 0), arr[j + 1] += arr[j] / baseOut | 0, arr[j] %= baseOut);
+            }
+            return arr.reverse();
+          }
+          return function(str, baseIn, baseOut, sign, callerIsToString) {
+            var alphabet, d, e, k, r, x, xc, y, i = str.indexOf("."), dp = DECIMAL_PLACES, rm = ROUNDING_MODE;
+            for (i >= 0 && (k = POW_PRECISION, POW_PRECISION = 0, str = str.replace(".", ""), y = new BigNumber2(baseIn), x = y.pow(str.length - i), POW_PRECISION = k, y.c = toBaseOut(
+              toFixedPoint(coeffToString(x.c), x.e, "0"),
+              10,
+              baseOut,
+              decimal
+            ), y.e = y.c.length), xc = toBaseOut(str, baseIn, baseOut, callerIsToString ? (alphabet = ALPHABET, decimal) : (alphabet = decimal, ALPHABET)), e = k = xc.length; xc[--k] == 0; xc.pop()) ;
+            if (!xc[0]) return alphabet.charAt(0);
+            if (i < 0 ? --e : (x.c = xc, x.e = e, x.s = sign, x = div(x, y, dp, rm, baseOut), xc = x.c, r = x.r, e = x.e), d = e + dp + 1, i = xc[d], k = baseOut / 2, r = r || d < 0 || xc[d + 1] != null, r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : i > k || i == k && (rm == 4 || r || rm == 6 && xc[d - 1] & 1 || rm == (x.s < 0 ? 8 : 7)), d < 1 || !xc[0])
+              str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);
+            else {
+              if (xc.length = d, r)
+                for (--baseOut; ++xc[--d] > baseOut; )
+                  xc[d] = 0, d || (++e, xc = [1].concat(xc));
+              for (k = xc.length; !xc[--k]; ) ;
+              for (i = 0, str = ""; i <= k; str += alphabet.charAt(xc[i++])) ;
+              str = toFixedPoint(str, e, alphabet.charAt(0));
+            }
+            return str;
+          };
+        })(), div = /* @__PURE__ */ (function() {
+          function multiply(x, k, base) {
+            var m, temp, xlo, xhi, carry = 0, i = x.length, klo = k % SQRT_BASE, khi = k / SQRT_BASE | 0;
+            for (x = x.slice(); i--; )
+              xlo = x[i] % SQRT_BASE, xhi = x[i] / SQRT_BASE | 0, m = khi * xlo + xhi * klo, temp = klo * xlo + m % SQRT_BASE * SQRT_BASE + carry, carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi, x[i] = temp % base;
+            return carry && (x = [carry].concat(x)), x;
+          }
+          function compare2(a, b, aL, bL) {
+            var i, cmp;
+            if (aL != bL)
+              cmp = aL > bL ? 1 : -1;
+            else
+              for (i = cmp = 0; i < aL; i++)
+                if (a[i] != b[i]) {
+                  cmp = a[i] > b[i] ? 1 : -1;
+                  break;
+                }
+            return cmp;
+          }
+          function subtract(a, b, aL, base) {
+            for (var i = 0; aL--; )
+              a[aL] -= i, i = a[aL] < b[aL] ? 1 : 0, a[aL] = i * base + a[aL] - b[aL];
+            for (; !a[0] && a.length > 1; a.splice(0, 1)) ;
+          }
+          return function(x, y, dp, rm, base) {
+            var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0, yL, yz, s = x.s == y.s ? 1 : -1, xc = x.c, yc = y.c;
+            if (!xc || !xc[0] || !yc || !yc[0])
+              return new BigNumber2(
+                // Return NaN if either NaN, or both Infinity or 0.
+                !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN : (
+                  // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.
+                  xc && xc[0] == 0 || !yc ? s * 0 : s / 0
+                )
+              );
+            for (q = new BigNumber2(s), qc = q.c = [], e = x.e - y.e, s = dp + e + 1, base || (base = BASE, e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE), s = s / LOG_BASE | 0), i = 0; yc[i] == (xc[i] || 0); i++) ;
+            if (yc[i] > (xc[i] || 0) && e--, s < 0)
+              qc.push(1), more = !0;
+            else {
+              for (xL = xc.length, yL = yc.length, i = 0, s += 2, n = mathfloor(base / (yc[0] + 1)), n > 1 && (yc = multiply(yc, n, base), xc = multiply(xc, n, base), yL = yc.length, xL = xc.length), xi = yL, rem = xc.slice(0, yL), remL = rem.length; remL < yL; rem[remL++] = 0) ;
+              yz = yc.slice(), yz = [0].concat(yz), yc0 = yc[0], yc[1] >= base / 2 && yc0++;
+              do {
+                if (n = 0, cmp = compare2(yc, rem, yL, remL), cmp < 0) {
+                  if (rem0 = rem[0], yL != remL && (rem0 = rem0 * base + (rem[1] || 0)), n = mathfloor(rem0 / yc0), n > 1)
+                    for (n >= base && (n = base - 1), prod = multiply(yc, n, base), prodL = prod.length, remL = rem.length; compare2(prod, rem, prodL, remL) == 1; )
+                      n--, subtract(prod, yL < prodL ? yz : yc, prodL, base), prodL = prod.length, cmp = 1;
+                  else
+                    n == 0 && (cmp = n = 1), prod = yc.slice(), prodL = prod.length;
+                  if (prodL < remL && (prod = [0].concat(prod)), subtract(rem, prod, remL, base), remL = rem.length, cmp == -1)
+                    for (; compare2(yc, rem, yL, remL) < 1; )
+                      n++, subtract(rem, yL < remL ? yz : yc, remL, base), remL = rem.length;
+                } else cmp === 0 && (n++, rem = [0]);
+                qc[i++] = n, rem[0] ? rem[remL++] = xc[xi] || 0 : (rem = [xc[xi]], remL = 1);
+              } while ((xi++ < xL || rem[0] != null) && s--);
+              more = rem[0] != null, qc[0] || qc.splice(0, 1);
+            }
+            if (base == BASE) {
+              for (i = 1, s = qc[0]; s >= 10; s /= 10, i++) ;
+              round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);
+            } else
+              q.e = e, q.r = +more;
+            return q;
+          };
+        })();
+        function format(n, i, rm, id) {
+          var c0, e, ne, len, str;
+          if (rm == null ? rm = ROUNDING_MODE : intCheck(rm, 0, 8), !n.c) return n.toString();
+          if (c0 = n.c[0], ne = n.e, i == null)
+            str = coeffToString(n.c), str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS) ? toExponential(str, ne) : toFixedPoint(str, ne, "0");
+          else if (n = round(new BigNumber2(n), i, rm), e = n.e, str = coeffToString(n.c), len = str.length, id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {
+            for (; len < i; str += "0", len++) ;
+            str = toExponential(str, e);
+          } else if (i -= ne + (id === 2 && e > ne), str = toFixedPoint(str, e, "0"), e + 1 > len) {
+            if (--i > 0) for (str += "."; i--; str += "0") ;
+          } else if (i += e - len, i > 0)
+            for (e + 1 == len && (str += "."); i--; str += "0") ;
+          return n.s < 0 && c0 ? "-" + str : str;
+        }
+        function maxOrMin(args, n) {
+          for (var k, y, i = 1, x = new BigNumber2(args[0]); i < args.length; i++)
+            y = new BigNumber2(args[i]), (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) && (x = y);
+          return x;
+        }
+        function normalise(n, c, e) {
+          for (var i = 1, j = c.length; !c[--j]; c.pop()) ;
+          for (j = c[0]; j >= 10; j /= 10, i++) ;
+          return (e = i + e * LOG_BASE - 1) > MAX_EXP ? n.c = n.e = null : e < MIN_EXP ? n.c = [n.e = 0] : (n.e = e, n.c = c), n;
+        }
+        parseNumeric = /* @__PURE__ */ (function() {
+          var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, dotAfter = /^([^.]+)\.$/, dotBefore = /^\.([^.]+)$/, isInfinityOrNaN = /^-?(Infinity|NaN)$/, whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
+          return function(x, str, isNum, b) {
+            var base, s = isNum ? str : str.replace(whitespaceOrPlus, "");
+            if (isInfinityOrNaN.test(s))
+              x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
+            else {
+              if (!isNum && (s = s.replace(basePrefix, function(m, p1, p2) {
+                return base = (p2 = p2.toLowerCase()) == "x" ? 16 : p2 == "b" ? 2 : 8, !b || b == base ? p1 : m;
+              }), b && (base = b, s = s.replace(dotAfter, "$1").replace(dotBefore, "0.$1")), str != s))
+                return new BigNumber2(s, base);
+              if (BigNumber2.DEBUG)
+                throw Error(bignumberError + "Not a" + (b ? " base " + b : "") + " number: " + str);
+              x.s = null;
+            }
+            x.c = x.e = null;
+          };
+        })();
+        function round(x, sd, rm, r) {
+          var d, i, j, k, n, ni, rd, xc = x.c, pows10 = POWS_TEN;
+          if (xc) {
+            out: {
+              for (d = 1, k = xc[0]; k >= 10; k /= 10, d++) ;
+              if (i = sd - d, i < 0)
+                i += LOG_BASE, j = sd, n = xc[ni = 0], rd = mathfloor(n / pows10[d - j - 1] % 10);
+              else if (ni = mathceil((i + 1) / LOG_BASE), ni >= xc.length)
+                if (r) {
+                  for (; xc.length <= ni; xc.push(0)) ;
+                  n = rd = 0, d = 1, i %= LOG_BASE, j = i - LOG_BASE + 1;
+                } else
+                  break out;
+              else {
+                for (n = k = xc[ni], d = 1; k >= 10; k /= 10, d++) ;
+                i %= LOG_BASE, j = i - LOG_BASE + d, rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);
+              }
+              if (r = r || sd < 0 || // Are there any non-zero digits after the rounding digit?
+              // The expression  n % pows10[d - j - 1]  returns all digits of n to the right
+              // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.
+              xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]), r = rm < 4 ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 && // Check whether the digit to the left of the rounding digit is odd.
+              (i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10 & 1 || rm == (x.s < 0 ? 8 : 7)), sd < 1 || !xc[0])
+                return xc.length = 0, r ? (sd -= x.e + 1, xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE], x.e = -sd || 0) : xc[0] = x.e = 0, x;
+              if (i == 0 ? (xc.length = ni, k = 1, ni--) : (xc.length = ni + 1, k = pows10[LOG_BASE - i], xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0), r)
+                for (; ; )
+                  if (ni == 0) {
+                    for (i = 1, j = xc[0]; j >= 10; j /= 10, i++) ;
+                    for (j = xc[0] += k, k = 1; j >= 10; j /= 10, k++) ;
+                    i != k && (x.e++, xc[0] == BASE && (xc[0] = 1));
+                    break;
+                  } else {
+                    if (xc[ni] += k, xc[ni] != BASE) break;
+                    xc[ni--] = 0, k = 1;
+                  }
+              for (i = xc.length; xc[--i] === 0; xc.pop()) ;
+            }
+            x.e > MAX_EXP ? x.c = x.e = null : x.e < MIN_EXP && (x.c = [x.e = 0]);
+          }
+          return x;
+        }
+        function valueOf(n) {
+          var str, e = n.e;
+          return e === null ? n.toString() : (str = coeffToString(n.c), str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(str, e) : toFixedPoint(str, e, "0"), n.s < 0 ? "-" + str : str);
+        }
+        return P.absoluteValue = P.abs = function() {
+          var x = new BigNumber2(this);
+          return x.s < 0 && (x.s = 1), x;
+        }, P.comparedTo = function(y, b) {
+          return compare(this, new BigNumber2(y, b));
+        }, P.decimalPlaces = P.dp = function(dp, rm) {
+          var c, n, v, x = this;
+          if (dp != null)
+            return intCheck(dp, 0, MAX), rm == null ? rm = ROUNDING_MODE : intCheck(rm, 0, 8), round(new BigNumber2(x), dp + x.e + 1, rm);
+          if (!(c = x.c)) return null;
+          if (n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE, v = c[v]) for (; v % 10 == 0; v /= 10, n--) ;
+          return n < 0 && (n = 0), n;
+        }, P.dividedBy = P.div = function(y, b) {
+          return div(this, new BigNumber2(y, b), DECIMAL_PLACES, ROUNDING_MODE);
+        }, P.dividedToIntegerBy = P.idiv = function(y, b) {
+          return div(this, new BigNumber2(y, b), 0, 1);
+        }, P.exponentiatedBy = P.pow = function(n, m) {
+          var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y, x = this;
+          if (n = new BigNumber2(n), n.c && !n.isInteger())
+            throw Error(bignumberError + "Exponent not an integer: " + valueOf(n));
+          if (m != null && (m = new BigNumber2(m)), nIsBig = n.e > 14, !x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0])
+            return y = new BigNumber2(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n))), m ? y.mod(m) : y;
+          if (nIsNeg = n.s < 0, m) {
+            if (m.c ? !m.c[0] : !m.s) return new BigNumber2(NaN);
+            isModExp = !nIsNeg && x.isInteger() && m.isInteger(), isModExp && (x = x.mod(m));
+          } else {
+            if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0 ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7 : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7)))
+              return k = x.s < 0 && isOdd(n) ? -0 : 0, x.e > -1 && (k = 1 / k), new BigNumber2(nIsNeg ? 1 / k : k);
+            POW_PRECISION && (k = mathceil(POW_PRECISION / LOG_BASE + 2));
+          }
+          for (nIsBig ? (half = new BigNumber2(0.5), nIsNeg && (n.s = 1), nIsOdd = isOdd(n)) : (i = Math.abs(+valueOf(n)), nIsOdd = i % 2), y = new BigNumber2(ONE); ; ) {
+            if (nIsOdd) {
+              if (y = y.times(x), !y.c) break;
+              k ? y.c.length > k && (y.c.length = k) : isModExp && (y = y.mod(m));
+            }
+            if (i) {
+              if (i = mathfloor(i / 2), i === 0) break;
+              nIsOdd = i % 2;
+            } else if (n = n.times(half), round(n, n.e + 1, 1), n.e > 14)
+              nIsOdd = isOdd(n);
+            else {
+              if (i = +valueOf(n), i === 0) break;
+              nIsOdd = i % 2;
+            }
+            x = x.times(x), k ? x.c && x.c.length > k && (x.c.length = k) : isModExp && (x = x.mod(m));
+          }
+          return isModExp ? y : (nIsNeg && (y = ONE.div(y)), m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y);
+        }, P.integerValue = function(rm) {
+          var n = new BigNumber2(this);
+          return rm == null ? rm = ROUNDING_MODE : intCheck(rm, 0, 8), round(n, n.e + 1, rm);
+        }, P.isEqualTo = P.eq = function(y, b) {
+          return compare(this, new BigNumber2(y, b)) === 0;
+        }, P.isFinite = function() {
+          return !!this.c;
+        }, P.isGreaterThan = P.gt = function(y, b) {
+          return compare(this, new BigNumber2(y, b)) > 0;
+        }, P.isGreaterThanOrEqualTo = P.gte = function(y, b) {
+          return (b = compare(this, new BigNumber2(y, b))) === 1 || b === 0;
+        }, P.isInteger = function() {
+          return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
+        }, P.isLessThan = P.lt = function(y, b) {
+          return compare(this, new BigNumber2(y, b)) < 0;
+        }, P.isLessThanOrEqualTo = P.lte = function(y, b) {
+          return (b = compare(this, new BigNumber2(y, b))) === -1 || b === 0;
+        }, P.isNaN = function() {
+          return !this.s;
+        }, P.isNegative = function() {
+          return this.s < 0;
+        }, P.isPositive = function() {
+          return this.s > 0;
+        }, P.isZero = function() {
+          return !!this.c && this.c[0] == 0;
+        }, P.minus = function(y, b) {
+          var i, j, t, xLTy, x = this, a = x.s;
+          if (y = new BigNumber2(y, b), b = y.s, !a || !b) return new BigNumber2(NaN);
+          if (a != b)
+            return y.s = -b, x.plus(y);
+          var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
+          if (!xe || !ye) {
+            if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber2(yc ? x : NaN);
+            if (!xc[0] || !yc[0])
+              return yc[0] ? (y.s = -b, y) : new BigNumber2(xc[0] ? x : (
+                // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity
+                ROUNDING_MODE == 3 ? -0 : 0
+              ));
+          }
+          if (xe = bitFloor(xe), ye = bitFloor(ye), xc = xc.slice(), a = xe - ye) {
+            for ((xLTy = a < 0) ? (a = -a, t = xc) : (ye = xe, t = yc), t.reverse(), b = a; b--; t.push(0)) ;
+            t.reverse();
+          } else
+            for (j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b, a = b = 0; b < j; b++)
+              if (xc[b] != yc[b]) {
+                xLTy = xc[b] < yc[b];
+                break;
+              }
+          if (xLTy && (t = xc, xc = yc, yc = t, y.s = -y.s), b = (j = yc.length) - (i = xc.length), b > 0) for (; b--; xc[i++] = 0) ;
+          for (b = BASE - 1; j > a; ) {
+            if (xc[--j] < yc[j]) {
+              for (i = j; i && !xc[--i]; xc[i] = b) ;
+              --xc[i], xc[j] += BASE;
+            }
+            xc[j] -= yc[j];
+          }
+          for (; xc[0] == 0; xc.splice(0, 1), --ye) ;
+          return xc[0] ? normalise(y, xc, ye) : (y.s = ROUNDING_MODE == 3 ? -1 : 1, y.c = [y.e = 0], y);
+        }, P.modulo = P.mod = function(y, b) {
+          var q, s, x = this;
+          return y = new BigNumber2(y, b), !x.c || !y.s || y.c && !y.c[0] ? new BigNumber2(NaN) : !y.c || x.c && !x.c[0] ? new BigNumber2(x) : (MODULO_MODE == 9 ? (s = y.s, y.s = 1, q = div(x, y, 0, 3), y.s = s, q.s *= s) : q = div(x, y, 0, MODULO_MODE), y = x.minus(q.times(y)), !y.c[0] && MODULO_MODE == 1 && (y.s = x.s), y);
+        }, P.multipliedBy = P.times = function(y, b) {
+          var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, base, sqrtBase, x = this, xc = x.c, yc = (y = new BigNumber2(y, b)).c;
+          if (!xc || !yc || !xc[0] || !yc[0])
+            return !x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc ? y.c = y.e = y.s = null : (y.s *= x.s, !xc || !yc ? y.c = y.e = null : (y.c = [0], y.e = 0)), y;
+          for (e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE), y.s *= x.s, xcL = xc.length, ycL = yc.length, xcL < ycL && (zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i), i = xcL + ycL, zc = []; i--; zc.push(0)) ;
+          for (base = BASE, sqrtBase = SQRT_BASE, i = ycL; --i >= 0; ) {
+            for (c = 0, ylo = yc[i] % sqrtBase, yhi = yc[i] / sqrtBase | 0, k = xcL, j = i + k; j > i; )
+              xlo = xc[--k] % sqrtBase, xhi = xc[k] / sqrtBase | 0, m = yhi * xlo + xhi * ylo, xlo = ylo * xlo + m % sqrtBase * sqrtBase + zc[j] + c, c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi, zc[j--] = xlo % base;
+            zc[j] = c;
+          }
+          return c ? ++e : zc.splice(0, 1), normalise(y, zc, e);
+        }, P.negated = function() {
+          var x = new BigNumber2(this);
+          return x.s = -x.s || null, x;
+        }, P.plus = function(y, b) {
+          var t, x = this, a = x.s;
+          if (y = new BigNumber2(y, b), b = y.s, !a || !b) return new BigNumber2(NaN);
+          if (a != b)
+            return y.s = -b, x.minus(y);
+          var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
+          if (!xe || !ye) {
+            if (!xc || !yc) return new BigNumber2(a / 0);
+            if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber2(xc[0] ? x : a * 0);
+          }
+          if (xe = bitFloor(xe), ye = bitFloor(ye), xc = xc.slice(), a = xe - ye) {
+            for (a > 0 ? (ye = xe, t = yc) : (a = -a, t = xc), t.reverse(); a--; t.push(0)) ;
+            t.reverse();
+          }
+          for (a = xc.length, b = yc.length, a - b < 0 && (t = yc, yc = xc, xc = t, b = a), a = 0; b; )
+            a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0, xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;
+          return a && (xc = [a].concat(xc), ++ye), normalise(y, xc, ye);
+        }, P.precision = P.sd = function(sd, rm) {
+          var c, n, v, x = this;
+          if (sd != null && sd !== !!sd)
+            return intCheck(sd, 1, MAX), rm == null ? rm = ROUNDING_MODE : intCheck(rm, 0, 8), round(new BigNumber2(x), sd, rm);
+          if (!(c = x.c)) return null;
+          if (v = c.length - 1, n = v * LOG_BASE + 1, v = c[v]) {
+            for (; v % 10 == 0; v /= 10, n--) ;
+            for (v = c[0]; v >= 10; v /= 10, n++) ;
+          }
+          return sd && x.e + 1 > n && (n = x.e + 1), n;
+        }, P.shiftedBy = function(k) {
+          return intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER), this.times("1e" + k);
+        }, P.squareRoot = P.sqrt = function() {
+          var m, n, r, rep, t, x = this, c = x.c, s = x.s, e = x.e, dp = DECIMAL_PLACES + 4, half = new BigNumber2("0.5");
+          if (s !== 1 || !c || !c[0])
+            return new BigNumber2(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);
+          if (s = Math.sqrt(+valueOf(x)), s == 0 || s == 1 / 0 ? (n = coeffToString(c), (n.length + e) % 2 == 0 && (n += "0"), s = Math.sqrt(+n), e = bitFloor((e + 1) / 2) - (e < 0 || e % 2), s == 1 / 0 ? n = "5e" + e : (n = s.toExponential(), n = n.slice(0, n.indexOf("e") + 1) + e), r = new BigNumber2(n)) : r = new BigNumber2(s + ""), r.c[0]) {
+            for (e = r.e, s = e + dp, s < 3 && (s = 0); ; )
+              if (t = r, r = half.times(t.plus(div(x, t, dp, 1))), coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s))
+                if (r.e < e && --s, n = n.slice(s - 3, s + 1), n == "9999" || !rep && n == "4999") {
+                  if (!rep && (round(t, t.e + DECIMAL_PLACES + 2, 0), t.times(t).eq(x))) {
+                    r = t;
+                    break;
+                  }
+                  dp += 4, s += 4, rep = 1;
+                } else {
+                  (!+n || !+n.slice(1) && n.charAt(0) == "5") && (round(r, r.e + DECIMAL_PLACES + 2, 1), m = !r.times(r).eq(x));
+                  break;
+                }
+          }
+          return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
+        }, P.toExponential = function(dp, rm) {
+          return dp != null && (intCheck(dp, 0, MAX), dp++), format(this, dp, rm, 1);
+        }, P.toFixed = function(dp, rm) {
+          return dp != null && (intCheck(dp, 0, MAX), dp = dp + this.e + 1), format(this, dp, rm);
+        }, P.toFormat = function(dp, rm, format2) {
+          var str, x = this;
+          if (format2 == null)
+            dp != null && rm && typeof rm == "object" ? (format2 = rm, rm = null) : dp && typeof dp == "object" ? (format2 = dp, dp = rm = null) : format2 = FORMAT;
+          else if (typeof format2 != "object")
+            throw Error(bignumberError + "Argument not an object: " + format2);
+          if (str = x.toFixed(dp, rm), x.c) {
+            var i, arr = str.split("."), g1 = +format2.groupSize, g2 = +format2.secondaryGroupSize, groupSeparator = format2.groupSeparator || "", intPart = arr[0], fractionPart = arr[1], isNeg = x.s < 0, intDigits = isNeg ? intPart.slice(1) : intPart, len = intDigits.length;
+            if (g2 && (i = g1, g1 = g2, g2 = i, len -= i), g1 > 0 && len > 0) {
+              for (i = len % g1 || g1, intPart = intDigits.substr(0, i); i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);
+              g2 > 0 && (intPart += groupSeparator + intDigits.slice(i)), isNeg && (intPart = "-" + intPart);
+            }
+            str = fractionPart ? intPart + (format2.decimalSeparator || "") + ((g2 = +format2.fractionGroupSize) ? fractionPart.replace(
+              new RegExp("\\d{" + g2 + "}\\B", "g"),
+              "$&" + (format2.fractionGroupSeparator || "")
+            ) : fractionPart) : intPart;
+          }
+          return (format2.prefix || "") + str + (format2.suffix || "");
+        }, P.toFraction = function(md) {
+          var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s, x = this, xc = x.c;
+          if (md != null && (n = new BigNumber2(md), !n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)))
+            throw Error(bignumberError + "Argument " + (n.isInteger() ? "out of range: " : "not an integer: ") + valueOf(n));
+          if (!xc) return new BigNumber2(x);
+          for (d = new BigNumber2(ONE), n1 = d0 = new BigNumber2(ONE), d1 = n0 = new BigNumber2(ONE), s = coeffToString(xc), e = d.e = s.length - x.e - 1, d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp], md = !md || n.comparedTo(d) > 0 ? e > 0 ? d : n1 : n, exp = MAX_EXP, MAX_EXP = 1 / 0, n = new BigNumber2(s), n0.c[0] = 0; q = div(n, d, 0, 1), d2 = d0.plus(q.times(d1)), d2.comparedTo(md) != 1; )
+            d0 = d1, d1 = d2, n1 = n0.plus(q.times(d2 = n1)), n0 = d2, d = n.minus(q.times(d2 = d)), n = d2;
+          return d2 = div(md.minus(d0), d1, 0, 1), n0 = n0.plus(d2.times(n1)), d0 = d0.plus(d2.times(d1)), n0.s = n1.s = x.s, e = e * 2, r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(
+            div(n0, d0, e, ROUNDING_MODE).minus(x).abs()
+          ) < 1 ? [n1, d1] : [n0, d0], MAX_EXP = exp, r;
+        }, P.toNumber = function() {
+          return +valueOf(this);
+        }, P.toPrecision = function(sd, rm) {
+          return sd != null && intCheck(sd, 1, MAX), format(this, sd, rm, 2);
+        }, P.toString = function(b) {
+          var str, n = this, s = n.s, e = n.e;
+          return e === null ? s ? (str = "Infinity", s < 0 && (str = "-" + str)) : str = "NaN" : (b == null ? str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(coeffToString(n.c), e) : toFixedPoint(coeffToString(n.c), e, "0") : b === 10 && alphabetHasNormalDecimalDigits ? (n = round(new BigNumber2(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE), str = toFixedPoint(coeffToString(n.c), n.e, "0")) : (intCheck(b, 2, ALPHABET.length, "Base"), str = convertBase(toFixedPoint(coeffToString(n.c), e, "0"), 10, b, s, !0)), s < 0 && n.c[0] && (str = "-" + str)), str;
+        }, P.valueOf = P.toJSON = function() {
+          return valueOf(this);
+        }, P._isBigNumber = !0, configObject != null && BigNumber2.set(configObject), BigNumber2;
+      }
+      function bitFloor(n) {
+        var i = n | 0;
+        return n > 0 || n === i ? i : i - 1;
+      }
+      function coeffToString(a) {
+        for (var s, z, i = 1, j = a.length, r = a[0] + ""; i < j; ) {
+          for (s = a[i++] + "", z = LOG_BASE - s.length; z--; s = "0" + s) ;
+          r += s;
+        }
+        for (j = r.length; r.charCodeAt(--j) === 48; ) ;
+        return r.slice(0, j + 1 || 1);
+      }
+      function compare(x, y) {
+        var a, b, xc = x.c, yc = y.c, i = x.s, j = y.s, k = x.e, l = y.e;
+        if (!i || !j) return null;
+        if (a = xc && !xc[0], b = yc && !yc[0], a || b) return a ? b ? 0 : -j : i;
+        if (i != j) return i;
+        if (a = i < 0, b = k == l, !xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;
+        if (!b) return k > l ^ a ? 1 : -1;
+        for (j = (k = xc.length) < (l = yc.length) ? k : l, i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;
+        return k == l ? 0 : k > l ^ a ? 1 : -1;
+      }
+      function intCheck(n, min, max, name) {
+        if (n < min || n > max || n !== mathfloor(n))
+          throw Error(bignumberError + (name || "Argument") + (typeof n == "number" ? n < min || n > max ? " out of range: " : " not an integer: " : " not a primitive number: ") + String(n));
+      }
+      function isOdd(n) {
+        var k = n.c.length - 1;
+        return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;
+      }
+      function toExponential(str, e) {
+        return (str.length > 1 ? str.charAt(0) + "." + str.slice(1) : str) + (e < 0 ? "e" : "e+") + e;
+      }
+      function toFixedPoint(str, e, z) {
+        var len, zs;
+        if (e < 0) {
+          for (zs = z + "."; ++e; zs += z) ;
+          str = zs + str;
+        } else if (len = str.length, ++e > len) {
+          for (zs = z, e -= len; --e; zs += z) ;
+          str += zs;
+        } else e < len && (str = str.slice(0, e) + "." + str.slice(e));
+        return str;
+      }
+      BigNumber = clone(), BigNumber.default = BigNumber.BigNumber = BigNumber, module.exports ? module.exports = BigNumber : (globalObject || (globalObject = typeof self < "u" && self ? self : window), globalObject.BigNumber = BigNumber);
+    })(bignumber);
+  })(bignumber$1)), bignumber$1.exports;
+}
+var hasRequiredStringify;
+function requireStringify() {
+  return hasRequiredStringify || (hasRequiredStringify = 1, (function(module) {
+    var BigNumber = requireBignumber(), JSON2 = module.exports;
+    (function() {
+      var escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta = {
+        // table of character substitutions
+        "\b": "\\b",
+        "	": "\\t",
+        "\n": "\\n",
+        "\f": "\\f",
+        "\r": "\\r",
+        '"': '\\"',
+        "\\": "\\\\"
+      }, rep;
+      function quote(string) {
+        return escapable.lastIndex = 0, escapable.test(string) ? '"' + string.replace(escapable, function(a) {
+          var c = meta[a];
+          return typeof c == "string" ? c : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
+        }) + '"' : '"' + string + '"';
+      }
+      function str(key, holder) {
+        var i, k, v, length, mind = gap, partial, value = holder[key], isBigNumber = value != null && (value instanceof BigNumber || BigNumber.isBigNumber(value));
+        switch (value && typeof value == "object" && typeof value.toJSON == "function" && (value = value.toJSON(key)), typeof rep == "function" && (value = rep.call(holder, key, value)), typeof value) {
+          case "string":
+            return isBigNumber ? value : quote(value);
+          case "number":
+            return isFinite(value) ? String(value) : "null";
+          case "boolean":
+          case "null":
+          case "bigint":
+            return String(value);
+          // If the type is 'object', we might be dealing with an object or an array or
+          // null.
+          case "object":
+            if (!value)
+              return "null";
+            if (gap += indent, partial = [], Object.prototype.toString.apply(value) === "[object Array]") {
+              for (length = value.length, i = 0; i < length; i += 1)
+                partial[i] = str(i, value) || "null";
+              return v = partial.length === 0 ? "[]" : gap ? `[
+` + gap + partial.join(`,
+` + gap) + `
+` + mind + "]" : "[" + partial.join(",") + "]", gap = mind, v;
+            }
+            if (rep && typeof rep == "object")
+              for (length = rep.length, i = 0; i < length; i += 1)
+                typeof rep[i] == "string" && (k = rep[i], v = str(k, value), v && partial.push(quote(k) + (gap ? ": " : ":") + v));
+            else
+              Object.keys(value).forEach(function(k2) {
+                var v2 = str(k2, value);
+                v2 && partial.push(quote(k2) + (gap ? ": " : ":") + v2);
+              });
+            return v = partial.length === 0 ? "{}" : gap ? `{
+` + gap + partial.join(`,
+` + gap) + `
+` + mind + "}" : "{" + partial.join(",") + "}", gap = mind, v;
+        }
+      }
+      typeof JSON2.stringify != "function" && (JSON2.stringify = function(value, replacer, space) {
+        var i;
+        if (gap = "", indent = "", typeof space == "number")
+          for (i = 0; i < space; i += 1)
+            indent += " ";
+        else typeof space == "string" && (indent = space);
+        if (rep = replacer, replacer && typeof replacer != "function" && (typeof replacer != "object" || typeof replacer.length != "number"))
+          throw new Error("JSON.stringify");
+        return str("", { "": value });
+      });
+    })();
+  })(stringify)), stringify.exports;
+}
+var parse, hasRequiredParse;
+function requireParse() {
+  if (hasRequiredParse) return parse;
+  hasRequiredParse = 1;
+  var BigNumber = null;
+  const suspectProtoRx = /(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])/, suspectConstructorRx = /(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)/;
+  var json_parse = function(options) {
+    var _options = {
+      strict: !1,
+      // not being strict means do not generate syntax errors for "duplicate key"
+      storeAsString: !1,
+      // toggles whether the values should be stored as BigNumber (default) or a string
+      alwaysParseAsBig: !1,
+      // toggles whether all numbers should be Big
+      useNativeBigInt: !1,
+      // toggles whether to use native BigInt instead of bignumber.js
+      protoAction: "error",
+      constructorAction: "error"
+    };
+    if (options != null) {
+      if (options.strict === !0 && (_options.strict = !0), options.storeAsString === !0 && (_options.storeAsString = !0), _options.alwaysParseAsBig = options.alwaysParseAsBig === !0 ? options.alwaysParseAsBig : !1, _options.useNativeBigInt = options.useNativeBigInt === !0 ? options.useNativeBigInt : !1, typeof options.constructorAction < "u")
+        if (options.constructorAction === "error" || options.constructorAction === "ignore" || options.constructorAction === "preserve")
+          _options.constructorAction = options.constructorAction;
+        else
+          throw new Error(
+            `Incorrect value for constructorAction option, must be "error", "ignore" or undefined but passed ${options.constructorAction}`
+          );
+      if (typeof options.protoAction < "u")
+        if (options.protoAction === "error" || options.protoAction === "ignore" || options.protoAction === "preserve")
+          _options.protoAction = options.protoAction;
+        else
+          throw new Error(
+            `Incorrect value for protoAction option, must be "error", "ignore" or undefined but passed ${options.protoAction}`
+          );
+    }
+    var at, ch, escapee = {
+      '"': '"',
+      "\\": "\\",
+      "/": "/",
+      b: "\b",
+      f: "\f",
+      n: `
+`,
+      r: "\r",
+      t: "	"
+    }, text, error = function(m) {
+      throw {
+        name: "SyntaxError",
+        message: m,
+        at,
+        text
+      };
+    }, next = function(c) {
+      return c && c !== ch && error("Expected '" + c + "' instead of '" + ch + "'"), ch = text.charAt(at), at += 1, ch;
+    }, number = function() {
+      var number2, string2 = "";
+      for (ch === "-" && (string2 = "-", next("-")); ch >= "0" && ch <= "9"; )
+        string2 += ch, next();
+      if (ch === ".")
+        for (string2 += "."; next() && ch >= "0" && ch <= "9"; )
+          string2 += ch;
+      if (ch === "e" || ch === "E")
+        for (string2 += ch, next(), (ch === "-" || ch === "+") && (string2 += ch, next()); ch >= "0" && ch <= "9"; )
+          string2 += ch, next();
+      if (number2 = +string2, !isFinite(number2))
+        error("Bad number");
+      else
+        return BigNumber == null && (BigNumber = requireBignumber()), string2.length > 15 ? _options.storeAsString ? string2 : _options.useNativeBigInt ? BigInt(string2) : new BigNumber(string2) : _options.alwaysParseAsBig ? _options.useNativeBigInt ? BigInt(number2) : new BigNumber(number2) : number2;
+    }, string = function() {
+      var hex, i, string2 = "", uffff;
+      if (ch === '"')
+        for (var startAt = at; next(); ) {
+          if (ch === '"')
+            return at - 1 > startAt && (string2 += text.substring(startAt, at - 1)), next(), string2;
+          if (ch === "\\") {
+            if (at - 1 > startAt && (string2 += text.substring(startAt, at - 1)), next(), ch === "u") {
+              for (uffff = 0, i = 0; i < 4 && (hex = parseInt(next(), 16), !!isFinite(hex)); i += 1)
+                uffff = uffff * 16 + hex;
+              string2 += String.fromCharCode(uffff);
+            } else if (typeof escapee[ch] == "string")
+              string2 += escapee[ch];
+            else
+              break;
+            startAt = at;
+          }
+        }
+      error("Bad string");
+    }, white = function() {
+      for (; ch && ch <= " "; )
+        next();
+    }, word = function() {
+      switch (ch) {
+        case "t":
+          return next("t"), next("r"), next("u"), next("e"), !0;
+        case "f":
+          return next("f"), next("a"), next("l"), next("s"), next("e"), !1;
+        case "n":
+          return next("n"), next("u"), next("l"), next("l"), null;
+      }
+      error("Unexpected '" + ch + "'");
+    }, value, array = function() {
+      var array2 = [];
+      if (ch === "[") {
+        if (next("["), white(), ch === "]")
+          return next("]"), array2;
+        for (; ch; ) {
+          if (array2.push(value()), white(), ch === "]")
+            return next("]"), array2;
+          next(","), white();
+        }
+      }
+      error("Bad array");
+    }, object = function() {
+      var key, object2 = /* @__PURE__ */ Object.create(null);
+      if (ch === "{") {
+        if (next("{"), white(), ch === "}")
+          return next("}"), object2;
+        for (; ch; ) {
+          if (key = string(), white(), next(":"), _options.strict === !0 && Object.hasOwnProperty.call(object2, key) && error('Duplicate key "' + key + '"'), suspectProtoRx.test(key) === !0 ? _options.protoAction === "error" ? error("Object contains forbidden prototype property") : _options.protoAction === "ignore" ? value() : object2[key] = value() : suspectConstructorRx.test(key) === !0 ? _options.constructorAction === "error" ? error("Object contains forbidden constructor property") : _options.constructorAction === "ignore" ? value() : object2[key] = value() : object2[key] = value(), white(), ch === "}")
+            return next("}"), object2;
+          next(","), white();
+        }
+      }
+      error("Bad object");
+    };
+    return value = function() {
+      switch (white(), ch) {
+        case "{":
+          return object();
+        case "[":
+          return array();
+        case '"':
+          return string();
+        case "-":
+          return number();
+        default:
+          return ch >= "0" && ch <= "9" ? number() : word();
+      }
+    }, function(source, reviver) {
+      var result;
+      return text = source + "", at = 0, ch = " ", result = value(), white(), ch && error("Syntax error"), typeof reviver == "function" ? (function walk(holder, key) {
+        var v, value2 = holder[key];
+        return value2 && typeof value2 == "object" && Object.keys(value2).forEach(function(k) {
+          v = walk(value2, k), v !== void 0 ? value2[k] = v : delete value2[k];
+        }), reviver.call(holder, key, value2);
+      })({ "": result }, "") : result;
+    };
+  };
+  return parse = json_parse, parse;
+}
+var hasRequiredJsonBigint;
+function requireJsonBigint() {
+  if (hasRequiredJsonBigint) return jsonBigint.exports;
+  hasRequiredJsonBigint = 1;
+  var json_stringify = requireStringify().stringify, json_parse = requireParse();
+  return jsonBigint.exports = function(options) {
+    return {
+      parse: json_parse(options),
+      stringify: json_stringify
+    };
+  }, jsonBigint.exports.parse = json_parse(), jsonBigint.exports.stringify = json_stringify, jsonBigint.exports;
+}
+var jsonBigintExports = requireJsonBigint();
+const JSONbig = /* @__PURE__ */ getDefaultExportFromCjs(jsonBigintExports), store = useTokenStore();
+let http_axios = axios.create({
+  transformResponse: [(data) => {
+    try {
+      return JSONbig.parse(data);
+    } catch (error) {
+      throw console.error("JSON parse error:", error), error;
+    }
+  }],
+  transformRequest: [(data) => JSONbig.stringify(data)]
+  // transformRequest: [(data) => {
+  //       return JSON.stringify(data, (_, value) => {
+  //           if (typeof value === 'bigint') {
+  //               return value.toString(); // 自动转换 BigInt
+  //           }
+  //           return value;
+  //       });
+  //   }],
+});
+http_axios.interceptors.request.use((config) => (console.log(store.token.value), config.headers.authorization = "Bearer " + store.token.value, config));
+http_axios.interceptors.response.use((res) => (res.data.error_code == 100 && store.saveToken("none"), typeof res.headers.authorization < "u" && store.saveToken(res.headers.authorization), res), (err) => Promise.reject(err));
+class HttpApiReturnData {
+  error_code;
+  message;
+  data;
+  constructor() {
+    this.error_code = 1, this.message = "未知错误", this.data = {};
+  }
+  get IsSuccess() {
+    return this.error_code == 0;
+  }
+  static fromObject(obj) {
+    const instance = new HttpApiReturnData();
+    return Object.assign(instance, obj), instance;
+  }
+}
+const hostUrl = `${window.location.protocol}//${window.location.host}/`;
+class HttpApiV1 {
+  //系统基础接口
+  static api_host = hostUrl;
+  //'http://localhost:1788/' //1788
+  //当前用户
+  static url_login = "api/login";
+  static url_usercenter = "api/user_center";
+  static url_change_password = "api/change_password";
+  static url_user_permission = "api/user_permission";
+  //用户管理
+  static url_user_save = "api/user_save";
+  static url_user_list = "api/user_list";
+  static url_user_export = "api/user_export";
+  static url_user_del = "api/user_del";
+  static url_user_detail = "api/user_detail";
+  static url_user_change_pwd = "api/user_change_pwd";
+  //组织架构
+  static url_department_save = "api/department_save";
+  static url_department_list = "api/department_list";
+  static url_department_del = "api/department_del";
+  static url_department_detail = "api/department_detail";
+  //职务
+  static url_position_list = "api/position_list";
+  static url_position_detail = "api/position_detail";
+  static url_position_save = "api/position_save";
+  static url_position_del = "api/position_del";
+  //系统日志
+  static url_syslog_list = "api/syslog_list";
+  static url_syslog_config_detail = "api/syslog_config_detail";
+  static url_syslog_config_save = "api/syslog_config_save";
+  //备份
+  static url_backup_start = "api/backup_start";
+  static url_backup_list = "api/backup_list";
+  static url_backup_del = "api/backup_del";
+  static url_backup_config_get = "api/backup_config_get";
+  static url_backup_config_save = "api/backup_config_save";
+  //权限
+  static url_syspermission_list = "api/permission_list";
+  static url_sysrole_list = "api/role_list";
+  static url_sysrole_del = "api/role_del";
+  static url_sysrole_save = "api/role_save";
+  static url_sysrole_detail = "api/role_detail";
+  //导出
+  static url_export_detail = "api/export_detail";
+  static url_export_file = "api/export_file";
+  // 系统
+  static url_system_publish = "api/system_publish";
+  //应用级接口==========================
+  //桌面
+  static url_desktop = "api/desktop";
+  static url_desktop_config_detail = "api/desktop_config_detail";
+  static url_desktop_config_save = "api/desktop_config_save";
+  //数据看板
+  static url_chart_weekly = "api/chart_weekly";
+  static url_chart_all = "api/chart_all";
+  static url_chart_last = "api/chart_last";
+  //事件
+  static url_event_list = "api/event_list";
+  static url_event_detail = "api/event_detail";
+  static url_event_file = "api/event_file";
+  static url_event_dispose = "api/event_dispose";
+  //规则
+  static url_rule_list = "api/rule_list";
+  static url_rule_save = "api/rule_save";
+  static url_rule_del = "api/rule_del";
+  static url_rule_detail = "api/rule_detail";
+  //时间模板
+  static url_time_list = "api/time_list";
+  static url_time_save = "api/time_save";
+  static url_time_del = "api/time_del";
+  static url_time_detail = "api/time_detail";
+  //区域
+  static url_area_save = "api/area_save";
+  static url_area_list = "api/area_list";
+  static url_area_del = "api/area_del";
+  static url_area_detail = "api/area_detail";
+  //设备
+  static url_equipment_save = "api/equipment_save";
+  static url_equipment_list = "api/equipment_list";
+  static url_equipment_detail = "api/equipment_detail";
+  static url_equipment_del = "api/equipment_del";
+  //通道画面
+  static url_channel_save = "api/channel_save";
+  static url_channel_list = "api/channel_list";
+  static url_channel_detail = "api/channel_detail";
+  static url_channel_del = "api/channel_del";
+  static GetFullApiUrl(api) {
+    return this.api_host + api;
+  }
+  static async Post(url, obj) {
+    try {
+      let res = await http_axios.post(this.api_host + url, obj);
+      return HttpApiReturnData.fromObject(res.data);
+    } catch (err) {
+      return console.log(err), Promise.reject("访问服务器失败");
+    }
+  }
+  //   http_axios.interceptors.response.use(res=>{
+  //     return res
+  // },err=>{
+  //     return Promise.reject(err)
+  // })
+}
+export {
+  HttpApiV1 as H
+};