https://champagne-henriot.com/node_modules/.vite/deps/axios.js?v=ff419b1c

3// node_modules/axios/lib/helpers/bind.js
4function bind(fn, thisArg) {
5  return function wrap() {
6    return fn.apply(thisArg, arguments);
7  };
8}
9

10// node_modules/axios/lib/utils.js
11var { toString } = Object.prototype;
12var { getPrototypeOf } = Object;
13var kindOf = ((cache) => (thing) => {
14  const str = toString.call(thing);
15  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
16})(/* @__PURE__ */ Object.create(null));
17var kindOfTest = (type) => {
18  type = type.toLowerCase();
19  return (thing) => kindOf(thing) === type;
20};
21var typeOfTest = (type) => (thing) => typeof thing === type;
22var { isArray } = Array;
23var isUndefined = typeOfTest("undefined");
24function isBuffer(val) {
25  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
26}
27var isArrayBuffer = kindOfTest("ArrayBuffer");
28function isArrayBufferView(val) {
29  let result;
30  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
31    result = ArrayBuffer.isView(val);
32  } else {
33    result = val && val.buffer && isArrayBuffer(val.buffer);
34  }
35  return result;
36}
37var isString = typeOfTest("string");
38var isFunction = typeOfTest("function");
39var isNumber = typeOfTest("number");
40var isObject = (thing) => thing !== null && typeof thing === "object";
41var isBoolean = (thing) => thing === true || thing === false;
42var isPlainObject = (val) => {
43  if (kindOf(val) !== "object") {
44    return false;
45  }
46  const prototype3 = getPrototypeOf(val);
47  return (prototype3 === null || prototype3 === Object.prototype || Object.getPrototypeOf(prototype3) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);
48};
49var isDate = kindOfTest("Date");
50var isFile = kindOfTest("File");
51var isBlob = kindOfTest("Blob");
52var isFileList = kindOfTest("FileList");
53var isStream = (val) => isObject(val) && isFunction(val.pipe);
54var isFormData = (thing) => {
55  let kind;
56  return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || // detect form-data instance
57  kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]"));
58};
59var isURLSearchParams = kindOfTest("URLSearchParams");
60var trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
61function forEach(obj, fn, { allOwnKeys = false } = {}) {
62  if (obj === null || typeof obj === "undefined") {
63    return;
64  }
65  let i;
66  let l;
67  if (typeof obj !== "object") {
68    obj = [obj];
69  }
70  if (isArray(obj)) {
71    for (i = 0, l = obj.length; i < l; i++) {
72      fn.call(null, obj[i], i, obj);
73    }
74  } else {
75    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
76    const len = keys.length;
77    let key;
78    for (i = 0; i < len; i++) {
79      key = keys[i];
80      fn.call(null, obj[key], key, obj);
81    }
82  }
83}
84function findKey(obj, key) {
85  key = key.toLowerCase();
86  const keys = Object.keys(obj);
87  let i = keys.length;
88  let _key;
89  while (i-- > 0) {
90    _key = keys[i];
91    if (key === _key.toLowerCase()) {
92      return _key;
93    }
94  }
95  return null;
96}
97var _global = (() => {
98  if (typeof globalThis !== "undefined")
99    return globalThis;
100  return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
101})();
102var isContextDefined = (context) => !isUndefined(context) && context !== _global;
103function merge() {
104  const { caseless } = isContextDefined(this) && this || {};
105  const result = {};
106  const assignValue = (val, key) => {
107    const targetKey = caseless && findKey(result, key) || key;
108    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
109      result[targetKey] = merge(result[targetKey], val);
110    } else if (isPlainObject(val)) {
111      result[targetKey] = merge({}, val);
112    } else if (isArray(val)) {
113      result[targetKey] = val.slice();
114    } else {
115      result[targetKey] = val;
116    }
117  };
118  for (let i = 0, l = arguments.length; i < l; i++) {
119    arguments[i] && forEach(arguments[i], assignValue);
120  }
121  return result;
122}
123var extend = (a, b, thisArg, { allOwnKeys } = {}) => {
124  forEach(b, (val, key) => {
125    if (thisArg && isFunction(val)) {
126      a[key] = bind(val, thisArg);
127    } else {
128      a[key] = val;
129    }
130  }, { allOwnKeys });
131  return a;
132};
133var stripBOM = (content) => {
134  if (content.charCodeAt(0) === 65279) {
135    content = content.slice(1);
136  }
137  return content;
138};
139var inherits = (constructor, superConstructor, props, descriptors2) => {
140  constructor.prototype = Object.create(superConstructor.prototype, descriptors2);
141  constructor.prototype.constructor = constructor;
142  Object.defineProperty(constructor, "super", {
143    value: superConstructor.prototype
144  });
145  props && Object.assign(constructor.prototype, props);
146};
147var toFlatObject = (sourceObj, destObj, filter2, propFilter) => {
148  let props;
149  let i;
150  let prop;
151  const merged = {};
152  destObj = destObj || {};
153  if (sourceObj == null)
154    return destObj;
155  do {
156    props = Object.getOwnPropertyNames(sourceObj);
157    i = props.length;
158    while (i-- > 0) {
159      prop = props[i];
160      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
161        destObj[prop] = sourceObj[prop];
162        merged[prop] = true;
163      }
164    }
165    sourceObj = filter2 !== false && getPrototypeOf(sourceObj);
166  } while (sourceObj && (!filter2 || filter2(sourceObj, destObj)) && sourceObj !== Object.prototype);
167  return destObj;
168};
169var endsWith = (str, searchString, position) => {
170  str = String(str);
171  if (position === void 0 || position > str.length) {
172    position = str.length;
173  }
174  position -= searchString.length;
175  const lastIndex = str.indexOf(searchString, position);
176  return lastIndex !== -1 && lastIndex === position;
177};
178var toArray = (thing) => {
179  if (!thing)
180    return null;
181  if (isArray(thing))
182    return thing;
183  let i = thing.length;
184  if (!isNumber(i))
185    return null;
186  const arr = new Array(i);
187  while (i-- > 0) {
188    arr[i] = thing[i];
189  }
190  return arr;
191};
192var isTypedArray = ((TypedArray) => {
193  return (thing) => {
194    return TypedArray && thing instanceof TypedArray;
195  };
196})(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
197var forEachEntry = (obj, fn) => {
198  const generator = obj && obj[Symbol.iterator];
199  const iterator = generator.call(obj);
200  let result;
201  while ((result = iterator.next()) && !result.done) {
202    const pair = result.value;
203    fn.call(obj, pair[0], pair[1]);
204  }
205};
206var matchAll = (regExp, str) => {
207  let matches;
208  const arr = [];
209  while ((matches = regExp.exec(str)) !== null) {
210    arr.push(matches);
211  }
212  return arr;
213};
214var isHTMLForm = kindOfTest("HTMLFormElement");
215var toCamelCase = (str) => {
216  return str.toLowerCase().replace(
217    /[-_\s]([a-z\d])(\w*)/g,
218    function replacer(m, p1, p2) {
219      return p1.toUpperCase() + p2;
220    }
221  );
222};
223var hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
224var isRegExp = kindOfTest("RegExp");
225var reduceDescriptors = (obj, reducer) => {
226  const descriptors2 = Object.getOwnPropertyDescriptors(obj);
227  const reducedDescriptors = {};
228  forEach(descriptors2, (descriptor, name) => {
229    if (reducer(descriptor, name, obj) !== false) {
230      reducedDescriptors[name] = descriptor;
231    }
232  });
233  Object.defineProperties(obj, reducedDescriptors);
234};
235var freezeMethods = (obj) => {
236  reduceDescriptors(obj, (descriptor, name) => {
237    if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1) {
238      return false;
239    }
240    const value = obj[name];
241    if (!isFunction(value))
242      return;
243    descriptor.enumerable = false;
244    if ("writable" in descriptor) {
245      descriptor.writable = false;
246      return;
247    }
248    if (!descriptor.set) {
249      descriptor.set = () => {
250        throw Error("Can not rewrite read-only method '" + name + "'");
251      };
252    }
253  });
254};
255var toObjectSet = (arrayOrString, delimiter) => {
256  const obj = {};
257  const define = (arr) => {
258    arr.forEach((value) => {
259      obj[value] = true;
260    });
261  };
262  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
263  return obj;
264};
265var noop = () => {
266};
267var toFiniteNumber = (value, defaultValue) => {
268  value = +value;
269  return Number.isFinite(value) ? value : defaultValue;
270};
271var ALPHA = "abcdefghijklmnopqrstuvwxyz";
272var DIGIT = "0123456789";
273var ALPHABET = {
274  DIGIT,
275  ALPHA,
276  ALPHA_DIGIT: ALPHA + ALPHA.toUpperCase() + DIGIT
277};
278var generateString = (size = 16, alphabet = ALPHABET.ALPHA_DIGIT) => {
279  let str = "";
280  const { length } = alphabet;
281  while (size--) {
282    str += alphabet[Math.random() * length | 0];
283  }
284  return str;
285};
286function isSpecCompliantForm(thing) {
287  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === "FormData" && thing[Symbol.iterator]);
288}
289var toJSONObject = (obj) => {
290  const stack = new Array(10);
291  const visit = (source, i) => {
292    if (isObject(source)) {
293      if (stack.indexOf(source) >= 0) {
294        return;
295      }
296      if (!("toJSON" in source)) {
297        stack[i] = source;
298        const target = isArray(source) ? [] : {};
299        forEach(source, (value, key) => {
300          const reducedValue = visit(value, i + 1);
301          !isUndefined(reducedValue) && (target[key] = reducedValue);
302        });
303        stack[i] = void 0;
304        return target;
305      }
306    }
307    return source;
308  };
309  return visit(obj, 0);
310};
311var isAsyncFn = kindOfTest("AsyncFunction");
312var isThenable = (thing) => thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
313var utils_default = {
314  isArray,
315  isArrayBuffer,
316  isBuffer,
317  isFormData,
318  isArrayBufferView,
319  isString,
320  isNumber,
321  isBoolean,
322  isObject,
323  isPlainObject,
324  isUndefined,
325  isDate,
326  isFile,
327  isBlob,
328  isRegExp,
329  isFunction,
330  isStream,
331  isURLSearchParams,
332  isTypedArray,
333  isFileList,
334  forEach,
335  merge,
336  extend,
337  trim,
338  stripBOM,
339  inherits,
340  toFlatObject,
341  kindOf,
342  kindOfTest,
343  endsWith,
344  toArray,
345  forEachEntry,
346  matchAll,
347  isHTMLForm,
348  hasOwnProperty,
349  hasOwnProp: hasOwnProperty,
350  // an alias to avoid ESLint no-prototype-builtins detection
351  reduceDescriptors,
352  freezeMethods,
353  toObjectSet,
354  toCamelCase,
355  noop,
356  toFiniteNumber,
357  findKey,
358  global: _global,
359  isContextDefined,
360  ALPHABET,
361  generateString,
362  isSpecCompliantForm,
363  toJSONObject,
364  isAsyncFn,
365  isThenable
366};
367

368// node_modules/axios/lib/core/AxiosError.js
369function AxiosError(message, code, config, request, response) {
370  Error.call(this);
371  if (Error.captureStackTrace) {
372    Error.captureStackTrace(this, this.constructor);
373  } else {
374    this.stack = new Error().stack;
375  }
376  this.message = message;
377  this.name = "AxiosError";
378  code && (this.code = code);
379  config && (this.config = config);
380  request && (this.request = request);
381  response && (this.response = response);
382}
383utils_default.inherits(AxiosError, Error, {
384  toJSON: function toJSON() {
385    return {
386      // Standard
387      message: this.message,
388      name: this.name,
389      // Microsoft
390      description: this.description,
391      number: this.number,
392      // Mozilla
393      fileName: this.fileName,
394      lineNumber: this.lineNumber,
395      columnNumber: this.columnNumber,
396      stack: this.stack,
397      // Axios
398      config: utils_default.toJSONObject(this.config),
399      code: this.code,
400      status: this.response && this.response.status ? this.response.status : null
401    };
402  }
403});
404var prototype = AxiosError.prototype;
405var descriptors = {};
406[
407  "ERR_BAD_OPTION_VALUE",
408  "ERR_BAD_OPTION",
409  "ECONNABORTED",
410  "ETIMEDOUT",
411  "ERR_NETWORK",
412  "ERR_FR_TOO_MANY_REDIRECTS",
413  "ERR_DEPRECATED",
414  "ERR_BAD_RESPONSE",
415  "ERR_BAD_REQUEST",
416  "ERR_CANCELED",
417  "ERR_NOT_SUPPORT",
418  "ERR_INVALID_URL"
419  // eslint-disable-next-line func-names
420].forEach((code) => {
421  descriptors[code] = { value: code };
422});
423Object.defineProperties(AxiosError, descriptors);
424Object.defineProperty(prototype, "isAxiosError", { value: true });
425AxiosError.from = (error, code, config, request, response, customProps) => {
426  const axiosError = Object.create(prototype);
427  utils_default.toFlatObject(error, axiosError, function filter2(obj) {
428    return obj !== Error.prototype;
429  }, (prop) => {
430    return prop !== "isAxiosError";
431  });
432  AxiosError.call(axiosError, error.message, code, config, request, response);
433  axiosError.cause = error;
434  axiosError.name = error.name;
435  customProps && Object.assign(axiosError, customProps);
436  return axiosError;
437};
438var AxiosError_default = AxiosError;
439

440// node_modules/axios/lib/helpers/null.js
441var null_default = null;
442

443// node_modules/axios/lib/helpers/toFormData.js
444function isVisitable(thing) {
445  return utils_default.isPlainObject(thing) || utils_default.isArray(thing);
446}
447function removeBrackets(key) {
448  return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
449}
450function renderKey(path, key, dots) {
451  if (!path)
452    return key;
453  return path.concat(key).map(function each(token, i) {
454    token = removeBrackets(token);
455    return !dots && i ? "[" + token + "]" : token;
456  }).join(dots ? "." : "");
457}
458function isFlatArray(arr) {
459  return utils_default.isArray(arr) && !arr.some(isVisitable);
460}
461var predicates = utils_default.toFlatObject(utils_default, {}, null, function filter(prop) {
462  return /^is[A-Z]/.test(prop);
463});
464function toFormData(obj, formData, options) {
465  if (!utils_default.isObject(obj)) {
466    throw new TypeError("target must be an object");
467  }
468  formData = formData || new (null_default || FormData)();
469  options = utils_default.toFlatObject(options, {
470    metaTokens: true,
471    dots: false,
472    indexes: false
473  }, false, function defined(option, source) {
474    return !utils_default.isUndefined(source[option]);
475  });
476  const metaTokens = options.metaTokens;
477  const visitor = options.visitor || defaultVisitor;
478  const dots = options.dots;
479  const indexes = options.indexes;
480  const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
481  const useBlob = _Blob && utils_default.isSpecCompliantForm(formData);
482  if (!utils_default.isFunction(visitor)) {
483    throw new TypeError("visitor must be a function");
484  }
485  function convertValue(value) {
486    if (value === null)
487      return "";
488    if (utils_default.isDate(value)) {
489      return value.toISOString();
490    }
491    if (!useBlob && utils_default.isBlob(value)) {
492      throw new AxiosError_default("Blob is not supported. Use a Buffer instead.");
493    }
494    if (utils_default.isArrayBuffer(value) || utils_default.isTypedArray(value)) {
495      return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
496    }
497    return value;
498  }
499  function defaultVisitor(value, key, path) {
500    let arr = value;
501    if (value && !path && typeof value === "object") {
502      if (utils_default.endsWith(key, "{}")) {
503        key = metaTokens ? key : key.slice(0, -2);
504        value = JSON.stringify(value);
505      } else if (utils_default.isArray(value) && isFlatArray(value) || (utils_default.isFileList(value) || utils_default.endsWith(key, "[]")) && (arr = utils_default.toArray(value))) {
506        key = removeBrackets(key);
507        arr.forEach(function each(el, index) {
508          !(utils_default.isUndefined(el) || el === null) && formData.append(
509            // eslint-disable-next-line no-nested-ternary
510            indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + "[]",
511            convertValue(el)
512          );
513        });
514        return false;
515      }
516    }
517    if (isVisitable(value)) {
518      return true;
519    }
520    formData.append(renderKey(path, key, dots), convertValue(value));
521    return false;
522  }
523  const stack = [];
524  const exposedHelpers = Object.assign(predicates, {
525    defaultVisitor,
526    convertValue,
527    isVisitable
528  });
529  function build(value, path) {
530    if (utils_default.isUndefined(value))
531      return;
532    if (stack.indexOf(value) !== -1) {
533      throw Error("Circular reference detected in " + path.join("."));
534    }
535    stack.push(value);
536    utils_default.forEach(value, function each(el, key) {
537      const result = !(utils_default.isUndefined(el) || el === null) && visitor.call(
538        formData,
539        el,
540        utils_default.isString(key) ? key.trim() : key,
541        path,
542        exposedHelpers
543      );
544      if (result === true) {
545        build(el, path ? path.concat(key) : [key]);
546      }
547    });
548    stack.pop();
549  }
550  if (!utils_default.isObject(obj)) {
551    throw new TypeError("data must be an object");
552  }
553  build(obj);
554  return formData;
555}
556var toFormData_default = toFormData;
557

558// node_modules/axios/lib/helpers/AxiosURLSearchParams.js
559function encode(str) {
560  const charMap = {
561    "!": "%21",
562    "'": "%27",
563    "(": "%28",
564    ")": "%29",
565    "~": "%7E",
566    "%20": "+",
567    "%00": "\0"
568  };
569  return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
570    return charMap[match];
571  });
572}
573function AxiosURLSearchParams(params, options) {
574  this._pairs = [];
575  params && toFormData_default(params, this, options);
576}
577var prototype2 = AxiosURLSearchParams.prototype;
578prototype2.append = function append(name, value) {
579  this._pairs.push([name, value]);
580};
581prototype2.toString = function toString2(encoder) {
582  const _encode = encoder ? function(value) {
583    return encoder.call(this, value, encode);
584  } : encode;
585  return this._pairs.map(function each(pair) {
586    return _encode(pair[0]) + "=" + _encode(pair[1]);
587  }, "").join("&");
588};
589var AxiosURLSearchParams_default = AxiosURLSearchParams;
590

591// node_modules/axios/lib/helpers/buildURL.js
592function encode2(val) {
593  return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
594}
595function buildURL(url, params, options) {
596  if (!params) {
597    return url;
598  }
599  const _encode = options && options.encode || encode2;
600  const serializeFn = options && options.serialize;
601  let serializedParams;
602  if (serializeFn) {
603    serializedParams = serializeFn(params, options);
604  } else {
605    serializedParams = utils_default.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams_default(params, options).toString(_encode);
606  }
607  if (serializedParams) {
608    const hashmarkIndex = url.indexOf("#");
609    if (hashmarkIndex !== -1) {
610      url = url.slice(0, hashmarkIndex);
611    }
612    url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
613  }
614  return url;
615}
616

617// node_modules/axios/lib/core/InterceptorManager.js
618var InterceptorManager = class {
619  constructor() {
620    this.handlers = [];
621  }
622  /**
623   * Add a new interceptor to the stack
624   *
625   * @param {Function} fulfilled The function to handle `then` for a `Promise`
626   * @param {Function} rejected The function to handle `reject` for a `Promise`
627   *
628   * @return {Number} An ID used to remove interceptor later
629   */
630  use(fulfilled, rejected, options) {
631    this.handlers.push({
632      fulfilled,
633      rejected,
634      synchronous: options ? options.synchronous : false,
635      runWhen: options ? options.runWhen : null
636    });
637    return this.handlers.length - 1;
638  }
639  /**
640   * Remove an interceptor from the stack
641   *
642   * @param {Number} id The ID that was returned by `use`
643   *
644   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
645   */
646  eject(id) {
647    if (this.handlers[id]) {
648      this.handlers[id] = null;
649    }
650  }
651  /**
652   * Clear all interceptors from the stack
653   *
654   * @returns {void}
655   */
656  clear() {
657    if (this.handlers) {
658      this.handlers = [];
659    }
660  }
661  /**
662   * Iterate over all the registered interceptors
663   *
664   * This method is particularly useful for skipping over any
665   * interceptors that may have become `null` calling `eject`.
666   *
667   * @param {Function} fn The function to call for each interceptor
668   *
669   * @returns {void}
670   */
671  forEach(fn) {
672    utils_default.forEach(this.handlers, function forEachHandler(h) {
673      if (h !== null) {
674        fn(h);
675      }
676    });
677  }
678};
679var InterceptorManager_default = InterceptorManager;
680

681// node_modules/axios/lib/defaults/transitional.js
682var transitional_default = {
683  silentJSONParsing: true,
684  forcedJSONParsing: true,
685  clarifyTimeoutError: false
686};
687

688// node_modules/axios/lib/platform/browser/classes/URLSearchParams.js
689var URLSearchParams_default = typeof URLSearchParams !== "undefined" ? URLSearchParams : AxiosURLSearchParams_default;
690

691// node_modules/axios/lib/platform/browser/classes/FormData.js
692var FormData_default = typeof FormData !== "undefined" ? FormData : null;
693

694// node_modules/axios/lib/platform/browser/classes/Blob.js
695var Blob_default = typeof Blob !== "undefined" ? Blob : null;
696

697// node_modules/axios/lib/platform/browser/index.js
698var isStandardBrowserEnv = (() => {
699  let product;
700  if (typeof navigator !== "undefined" && ((product = navigator.product) === "ReactNative" || product === "NativeScript" || product === "NS")) {
701    return false;
702  }
703  return typeof window !== "undefined" && typeof document !== "undefined";
704})();
705var isStandardBrowserWebWorkerEnv = (() => {
706  return typeof WorkerGlobalScope !== "undefined" && // eslint-disable-next-line no-undef
707  self instanceof WorkerGlobalScope && typeof self.importScripts === "function";
708})();
709var browser_default = {
710  isBrowser: true,
711  classes: {
712    URLSearchParams: URLSearchParams_default,
713    FormData: FormData_default,
714    Blob: Blob_default
715  },
716  isStandardBrowserEnv,
717  isStandardBrowserWebWorkerEnv,
718  protocols: ["http", "https", "file", "blob", "url", "data"]
719};
720

721// node_modules/axios/lib/helpers/toURLEncodedForm.js
722function toURLEncodedForm(data, options) {
723  return toFormData_default(data, new browser_default.classes.URLSearchParams(), Object.assign({
724    visitor: function(value, key, path, helpers) {
725      if (browser_default.isNode && utils_default.isBuffer(value)) {
726        this.append(key, value.toString("base64"));
727        return false;
728      }
729      return helpers.defaultVisitor.apply(this, arguments);
730    }
731  }, options));
732}
733

734// node_modules/axios/lib/helpers/formDataToJSON.js
735function parsePropPath(name) {
736  return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
737    return match[0] === "[]" ? "" : match[1] || match[0];
738  });
739}
740function arrayToObject(arr) {
741  const obj = {};
742  const keys = Object.keys(arr);
743  let i;
744  const len = keys.length;
745  let key;
746  for (i = 0; i < len; i++) {
747    key = keys[i];
748    obj[key] = arr[key];
749  }
750  return obj;
751}
752function formDataToJSON(formData) {
753  function buildPath(path, value, target, index) {
754    let name = path[index++];
755    const isNumericKey = Number.isFinite(+name);
756    const isLast = index >= path.length;
757    name = !name && utils_default.isArray(target) ? target.length : name;
758    if (isLast) {
759      if (utils_default.hasOwnProp(target, name)) {
760        target[name] = [target[name], value];
761      } else {
762        target[name] = value;
763      }
764      return !isNumericKey;
765    }
766    if (!target[name] || !utils_default.isObject(target[name])) {
767      target[name] = [];
768    }
769    const result = buildPath(path, value, target[name], index);
770    if (result && utils_default.isArray(target[name])) {
771      target[name] = arrayToObject(target[name]);
772    }
773    return !isNumericKey;
774  }
775  if (utils_default.isFormData(formData) && utils_default.isFunction(formData.entries)) {
776    const obj = {};
777    utils_default.forEachEntry(formData, (name, value) => {
778      buildPath(parsePropPath(name), value, obj, 0);
779    });
780    return obj;
781  }
782  return null;
783}
784var formDataToJSON_default = formDataToJSON;
785

786// node_modules/axios/lib/defaults/index.js
787var DEFAULT_CONTENT_TYPE = {
788  "Content-Type": void 0
789};
790function stringifySafely(rawValue, parser, encoder) {
791  if (utils_default.isString(rawValue)) {
792    try {
793      (parser || JSON.parse)(rawValue);
794      return utils_default.trim(rawValue);
795    } catch (e) {
796      if (e.name !== "SyntaxError") {
797        throw e;
798      }
799    }
800  }
801  return (encoder || JSON.stringify)(rawValue);
802}
803var defaults = {
804  transitional: transitional_default,
805  adapter: ["xhr", "http"],
806  transformRequest: [function transformRequest(data, headers) {
807    const contentType = headers.getContentType() || "";
808    const hasJSONContentType = contentType.indexOf("application/json") > -1;
809    const isObjectPayload = utils_default.isObject(data);
810    if (isObjectPayload && utils_default.isHTMLForm(data)) {
811      data = new FormData(data);
812    }
813    const isFormData2 = utils_default.isFormData(data);
814    if (isFormData2) {
815      if (!hasJSONContentType) {
816        return data;
817      }
818      return hasJSONContentType ? JSON.stringify(formDataToJSON_default(data)) : data;
819    }
820    if (utils_default.isArrayBuffer(data) || utils_default.isBuffer(data) || utils_default.isStream(data) || utils_default.isFile(data) || utils_default.isBlob(data)) {
821      return data;
822    }
823    if (utils_default.isArrayBufferView(data)) {
824      return data.buffer;
825    }
826    if (utils_default.isURLSearchParams(data)) {
827      headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false);
828      return data.toString();
829    }
830    let isFileList2;
831    if (isObjectPayload) {
832      if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
833        return toURLEncodedForm(data, this.formSerializer).toString();
834      }
835      if ((isFileList2 = utils_default.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
836        const _FormData = this.env && this.env.FormData;
837        return toFormData_default(
838          isFileList2 ? { "files[]": data } : data,
839          _FormData && new _FormData(),
840          this.formSerializer
841        );
842      }
843    }
844    if (isObjectPayload || hasJSONContentType) {
845      headers.setContentType("application/json", false);
846      return stringifySafely(data);
847    }
848    return data;
849  }],
850  transformResponse: [function transformResponse(data) {
851    const transitional2 = this.transitional || defaults.transitional;
852    const forcedJSONParsing = transitional2 && transitional2.forcedJSONParsing;
853    const JSONRequested = this.responseType === "json";
854    if (data && utils_default.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
855      const silentJSONParsing = transitional2 && transitional2.silentJSONParsing;
856      const strictJSONParsing = !silentJSONParsing && JSONRequested;
857      try {
858        return JSON.parse(data);
859      } catch (e) {
860        if (strictJSONParsing) {
861          if (e.name === "SyntaxError") {
862            throw AxiosError_default.from(e, AxiosError_default.ERR_BAD_RESPONSE, this, null, this.response);
863          }
864          throw e;
865        }
866      }
867    }
868    return data;
869  }],
870  /**
871   * A timeout in milliseconds to abort a request. If set to 0 (default) a
872   * timeout is not created.
873   */
874  timeout: 0,
875  xsrfCookieName: "XSRF-TOKEN",
876  xsrfHeaderName: "X-XSRF-TOKEN",
877  maxContentLength: -1,
878  maxBodyLength: -1,
879  env: {
880    FormData: browser_default.classes.FormData,
881    Blob: browser_default.classes.Blob
882  },
883  validateStatus: function validateStatus(status) {
884    return status >= 200 && status < 300;
885  },
886  headers: {
887    common: {
888      "Accept": "application/json, text/plain, */*"
889    }
890  }
891};
892utils_default.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
893  defaults.headers[method] = {};
894});
895utils_default.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
896  defaults.headers[method] = utils_default.merge(DEFAULT_CONTENT_TYPE);
897});
898var defaults_default = defaults;
899

900// node_modules/axios/lib/helpers/parseHeaders.js
901var ignoreDuplicateOf = utils_default.toObjectSet([
902  "age",
903  "authorization",
904  "content-length",
905  "content-type",
906  "etag",
907  "expires",
908  "from",
909  "host",
910  "if-modified-since",
911  "if-unmodified-since",
912  "last-modified",
913  "location",
914  "max-forwards",
915  "proxy-authorization",
916  "referer",
917  "retry-after",
918  "user-agent"
919]);
920var parseHeaders_default = (rawHeaders) => {
921  const parsed = {};
922  let key;
923  let val;
924  let i;
925  rawHeaders && rawHeaders.split("\n").forEach(function parser(line) {
926    i = line.indexOf(":");
927    key = line.substring(0, i).trim().toLowerCase();
928    val = line.substring(i + 1).trim();
929    if (!key || parsed[key] && ignoreDuplicateOf[key]) {
930      return;
931    }
932    if (key === "set-cookie") {
933      if (parsed[key]) {
934        parsed[key].push(val);
935      } else {
936        parsed[key] = [val];
937      }
938    } else {
939      parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
940    }
941  });
942  return parsed;
943};
944

945// node_modules/axios/lib/core/AxiosHeaders.js
946var $internals = Symbol("internals");
947function normalizeHeader(header) {
948  return header && String(header).trim().toLowerCase();
949}
950function normalizeValue(value) {
951  if (value === false || value == null) {
952    return value;
953  }
954  return utils_default.isArray(value) ? value.map(normalizeValue) : String(value);
955}
956function parseTokens(str) {
957  const tokens = /* @__PURE__ */ Object.create(null);
958  const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
959  let match;
960  while (match = tokensRE.exec(str)) {
961    tokens[match[1]] = match[2];
962  }
963  return tokens;
964}
965var isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
966function matchHeaderValue(context, value, header, filter2, isHeaderNameFilter) {
967  if (utils_default.isFunction(filter2)) {
968    return filter2.call(this, value, header);
969  }
970  if (isHeaderNameFilter) {
971    value = header;
972  }
973  if (!utils_default.isString(value))
974    return;
975  if (utils_default.isString(filter2)) {
976    return value.indexOf(filter2) !== -1;
977  }
978  if (utils_default.isRegExp(filter2)) {
979    return filter2.test(value);
980  }
981}
982function formatHeader(header) {
983  return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
984    return char.toUpperCase() + str;
985  });
986}
987function buildAccessors(obj, header) {
988  const accessorName = utils_default.toCamelCase(" " + header);
989  ["get", "set", "has"].forEach((methodName) => {
990    Object.defineProperty(obj, methodName + accessorName, {
991      value: function(arg1, arg2, arg3) {
992        return this[methodName].call(this, header, arg1, arg2, arg3);
993      },
994      configurable: true
995    });
996  });
997}
998var AxiosHeaders = class {
999  constructor(headers) {
1000    headers && this.set(headers);
1001  }
1002  set(header, valueOrRewrite, rewrite) {
1003    const self2 = this;
1004    function setHeader(_value, _header, _rewrite) {
1005      const lHeader = normalizeHeader(_header);
1006      if (!lHeader) {
1007        throw new Error("header name must be a non-empty string");
1008      }
1009      const key = utils_default.findKey(self2, lHeader);
1010      if (!key || self2[key] === void 0 || _rewrite === true || _rewrite === void 0 && self2[key] !== false) {
1011        self2[key || _header] = normalizeValue(_value);
1012      }
1013    }
1014    const setHeaders = (headers, _rewrite) => utils_default.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
1015    if (utils_default.isPlainObject(header) || header instanceof this.constructor) {
1016      setHeaders(header, valueOrRewrite);
1017    } else if (utils_default.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
1018      setHeaders(parseHeaders_default(header), valueOrRewrite);
1019    } else {
1020      header != null && setHeader(valueOrRewrite, header, rewrite);
1021    }
1022    return this;
1023  }
1024  get(header, parser) {
1025    header = normalizeHeader(header);
1026    if (header) {
1027      const key = utils_default.findKey(this, header);
1028      if (key) {
1029        const value = this[key];
1030        if (!parser) {
1031          return value;
1032        }
1033        if (parser === true) {
1034          return parseTokens(value);
1035        }
1036        if (utils_default.isFunction(parser)) {
1037          return parser.call(this, value, key);
1038        }
1039        if (utils_default.isRegExp(parser)) {
1040          return parser.exec(value);
1041        }
1042        throw new TypeError("parser must be boolean|regexp|function");
1043      }
1044    }
1045  }
1046  has(header, matcher) {
1047    header = normalizeHeader(header);
1048    if (header) {
1049      const key = utils_default.findKey(this, header);
1050      return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
1051    }
1052    return false;
1053  }
1054  delete(header, matcher) {
1055    const self2 = this;
1056    let deleted = false;
1057    function deleteHeader(_header) {
1058      _header = normalizeHeader(_header);
1059      if (_header) {
1060        const key = utils_default.findKey(self2, _header);
1061        if (key && (!matcher || matchHeaderValue(self2, self2[key], key, matcher))) {
1062          delete self2[key];
1063          deleted = true;
1064        }
1065      }
1066    }
1067    if (utils_default.isArray(header)) {
1068      header.forEach(deleteHeader);
1069    } else {
1070      deleteHeader(header);
1071    }
1072    return deleted;
1073  }
1074  clear(matcher) {
1075    const keys = Object.keys(this);
1076    let i = keys.length;
1077    let deleted = false;
1078    while (i--) {
1079      const key = keys[i];
1080      if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
1081        delete this[key];
1082        deleted = true;
1083      }
1084    }
1085    return deleted;
1086  }
1087  normalize(format) {
1088    const self2 = this;
1089    const headers = {};
1090    utils_default.forEach(this, (value, header) => {
1091      const key = utils_default.findKey(headers, header);
1092      if (key) {
1093        self2[key] = normalizeValue(value);
1094        delete self2[header];
1095        return;
1096      }
1097      const normalized = format ? formatHeader(header) : String(header).trim();
1098      if (normalized !== header) {
1099        delete self2[header];
1100      }
1101      self2[normalized] = normalizeValue(value);
1102      headers[normalized] = true;
1103    });
1104    return this;
1105  }
1106  concat(...targets) {
1107    return this.constructor.concat(this, ...targets);
1108  }
1109  toJSON(asStrings) {
1110    const obj = /* @__PURE__ */ Object.create(null);
1111    utils_default.forEach(this, (value, header) => {
1112      value != null && value !== false && (obj[header] = asStrings && utils_default.isArray(value) ? value.join(", ") : value);
1113    });
1114    return obj;
1115  }
1116  [Symbol.iterator]() {
1117    return Object.entries(this.toJSON())[Symbol.iterator]();
1118  }
1119  toString() {
1120    return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
1121  }
1122  get [Symbol.toStringTag]() {
1123    return "AxiosHeaders";
1124  }
1125  static from(thing) {
1126    return thing instanceof this ? thing : new this(thing);
1127  }
1128  static concat(first, ...targets) {
1129    const computed = new this(first);
1130    targets.forEach((target) => computed.set(target));
1131    return computed;
1132  }
1133  static accessor(header) {
1134    const internals = this[$internals] = this[$internals] = {
1135      accessors: {}
1136    };
1137    const accessors = internals.accessors;
1138    const prototype3 = this.prototype;
1139    function defineAccessor(_header) {
1140      const lHeader = normalizeHeader(_header);
1141      if (!accessors[lHeader]) {
1142        buildAccessors(prototype3, _header);
1143        accessors[lHeader] = true;
1144      }
1145    }
1146    utils_default.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
1147    return this;
1148  }
1149};
1150AxiosHeaders.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
1151utils_default.freezeMethods(AxiosHeaders.prototype);
1152utils_default.freezeMethods(AxiosHeaders);
1153var AxiosHeaders_default = AxiosHeaders;
1154

1155// node_modules/axios/lib/core/transformData.js
1156function transformData(fns, response) {
1157  const config = this || defaults_default;
1158  const context = response || config;
1159  const headers = AxiosHeaders_default.from(context.headers);
1160  let data = context.data;
1161  utils_default.forEach(fns, function transform(fn) {
1162    data = fn.call(config, data, headers.normalize(), response ? response.status : void 0);
1163  });
1164  headers.normalize();
1165  return data;
1166}
1167

1168// node_modules/axios/lib/cancel/isCancel.js
1169function isCancel(value) {
1170  return !!(value && value.__CANCEL__);
1171}
1172

1173// node_modules/axios/lib/cancel/CanceledError.js
1174function CanceledError(message, config, request) {
1175  AxiosError_default.call(this, message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config, request);
1176  this.name = "CanceledError";
1177}
1178utils_default.inherits(CanceledError, AxiosError_default, {
1179  __CANCEL__: true
1180});
1181var CanceledError_default = CanceledError;
1182

1183// node_modules/axios/lib/core/settle.js
1184function settle(resolve, reject, response) {
1185  const validateStatus2 = response.config.validateStatus;
1186  if (!response.status || !validateStatus2 || validateStatus2(response.status)) {
1187    resolve(response);
1188  } else {
1189    reject(new AxiosError_default(
1190      "Request failed with status code " + response.status,
1191      [AxiosError_default.ERR_BAD_REQUEST, AxiosError_default.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
1192      response.config,
1193      response.request,
1194      response
1195    ));
1196  }
1197}
1198

1199// node_modules/axios/lib/helpers/cookies.js
1200var cookies_default = browser_default.isStandardBrowserEnv ? (
1201  // Standard browser envs support document.cookie
1202  function standardBrowserEnv() {
1203    return {
1204      write: function write(name, value, expires, path, domain, secure) {
1205        const cookie = [];
1206        cookie.push(name + "=" + encodeURIComponent(value));
1207        if (utils_default.isNumber(expires)) {
1208          cookie.push("expires=" + new Date(expires).toGMTString());
1209        }
1210        if (utils_default.isString(path)) {
1211          cookie.push("path=" + path);
1212        }
1213        if (utils_default.isString(domain)) {
1214          cookie.push("domain=" + domain);
1215        }
1216        if (secure === true) {
1217          cookie.push("secure");
1218        }
1219        document.cookie = cookie.join("; ");
1220      },
1221      read: function read(name) {
1222        const match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
1223        return match ? decodeURIComponent(match[3]) : null;
1224      },
1225      remove: function remove(name) {
1226        this.write(name, "", Date.now() - 864e5);
1227      }
1228    };
1229  }()
1230) : (
1231  // Non standard browser env (web workers, react-native) lack needed support.
1232  function nonStandardBrowserEnv() {
1233    return {
1234      write: function write() {
1235      },
1236      read: function read() {
1237        return null;
1238      },
1239      remove: function remove() {
1240      }
1241    };
1242  }()
1243);
1244

1245// node_modules/axios/lib/helpers/isAbsoluteURL.js
1246function isAbsoluteURL(url) {
1247  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
1248}
1249

1250// node_modules/axios/lib/helpers/combineURLs.js
1251function combineURLs(baseURL, relativeURL) {
1252  return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
1253}
1254

1255// node_modules/axios/lib/core/buildFullPath.js
1256function buildFullPath(baseURL, requestedURL) {
1257  if (baseURL && !isAbsoluteURL(requestedURL)) {
1258    return combineURLs(baseURL, requestedURL);
1259  }
1260  return requestedURL;
1261}
1262

1263// node_modules/axios/lib/helpers/isURLSameOrigin.js
1264var isURLSameOrigin_default = browser_default.isStandardBrowserEnv ? (
1265  // Standard browser envs have full support of the APIs needed to test
1266  // whether the request URL is of the same origin as current location.
1267  function standardBrowserEnv2() {
1268    const msie = /(msie|trident)/i.test(navigator.userAgent);
1269    const urlParsingNode = document.createElement("a");
1270    let originURL;
1271    function resolveURL(url) {
1272      let href = url;
1273      if (msie) {
1274        urlParsingNode.setAttribute("href", href);
1275        href = urlParsingNode.href;
1276      }
1277      urlParsingNode.setAttribute("href", href);
1278      return {
1279        href: urlParsingNode.href,
1280        protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
1281        host: urlParsingNode.host,
1282        search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
1283        hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
1284        hostname: urlParsingNode.hostname,
1285        port: urlParsingNode.port,
1286        pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
1287      };
1288    }
1289    originURL = resolveURL(window.location.href);
1290    return function isURLSameOrigin(requestURL) {
1291      const parsed = utils_default.isString(requestURL) ? resolveURL(requestURL) : requestURL;
1292      return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
1293    };
1294  }()
1295) : (
1296  // Non standard browser envs (web workers, react-native) lack needed support.
1297  function nonStandardBrowserEnv2() {
1298    return function isURLSameOrigin() {
1299      return true;
1300    };
1301  }()
1302);
1303

1304// node_modules/axios/lib/helpers/parseProtocol.js
1305function parseProtocol(url) {
1306  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
1307  return match && match[1] || "";
1308}
1309

1310// node_modules/axios/lib/helpers/speedometer.js
1311function speedometer(samplesCount, min) {
1312  samplesCount = samplesCount || 10;
1313  const bytes = new Array(samplesCount);
1314  const timestamps = new Array(samplesCount);
1315  let head = 0;
1316  let tail = 0;
1317  let firstSampleTS;
1318  min = min !== void 0 ? min : 1e3;
1319  return function push(chunkLength) {
1320    const now = Date.now();
1321    const startedAt = timestamps[tail];
1322    if (!firstSampleTS) {
1323      firstSampleTS = now;
1324    }
1325    bytes[head] = chunkLength;
1326    timestamps[head] = now;
1327    let i = tail;
1328    let bytesCount = 0;
1329    while (i !== head) {
1330      bytesCount += bytes[i++];
1331      i = i % samplesCount;
1332    }
1333    head = (head + 1) % samplesCount;
1334    if (head === tail) {
1335      tail = (tail + 1) % samplesCount;
1336    }
1337    if (now - firstSampleTS < min) {
1338      return;
1339    }
1340    const passed = startedAt && now - startedAt;
1341    return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
1342  };
1343}
1344var speedometer_default = speedometer;
1345

1346// node_modules/axios/lib/adapters/xhr.js
1347function progressEventReducer(listener, isDownloadStream) {
1348  let bytesNotified = 0;
1349  const _speedometer = speedometer_default(50, 250);
1350  return (e) => {
1351    const loaded = e.loaded;
1352    const total = e.lengthComputable ? e.total : void 0;
1353    const progressBytes = loaded - bytesNotified;
1354    const rate = _speedometer(progressBytes);
1355    const inRange = loaded <= total;
1356    bytesNotified = loaded;
1357    const data = {
1358      loaded,
1359      total,
1360      progress: total ? loaded / total : void 0,
1361      bytes: progressBytes,
1362      rate: rate ? rate : void 0,
1363      estimated: rate && total && inRange ? (total - loaded) / rate : void 0,
1364      event: e
1365    };
1366    data[isDownloadStream ? "download" : "upload"] = true;
1367    listener(data);
1368  };
1369}
1370var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
1371var xhr_default = isXHRAdapterSupported && function(config) {
1372  return new Promise(function dispatchXhrRequest(resolve, reject) {
1373    let requestData = config.data;
1374    const requestHeaders = AxiosHeaders_default.from(config.headers).normalize();
1375    const responseType = config.responseType;
1376    let onCanceled;
1377    function done() {
1378      if (config.cancelToken) {
1379        config.cancelToken.unsubscribe(onCanceled);
1380      }
1381      if (config.signal) {
1382        config.signal.removeEventListener("abort", onCanceled);
1383      }
1384    }
1385    if (utils_default.isFormData(requestData)) {
1386      if (browser_default.isStandardBrowserEnv || browser_default.isStandardBrowserWebWorkerEnv) {
1387        requestHeaders.setContentType(false);
1388      } else {
1389        requestHeaders.setContentType("multipart/form-data;", false);
1390      }
1391    }
1392    let request = new XMLHttpRequest();
1393    if (config.auth) {
1394      const username = config.auth.username || "";
1395      const password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
1396      requestHeaders.set("Authorization", "Basic " + btoa(username + ":" + password));
1397    }
1398    const fullPath = buildFullPath(config.baseURL, config.url);
1399    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
1400    request.timeout = config.timeout;
1401    function onloadend() {
1402      if (!request) {
1403        return;
1404      }
1405      const responseHeaders = AxiosHeaders_default.from(
1406        "getAllResponseHeaders" in request && request.getAllResponseHeaders()
1407      );
1408      const responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
1409      const response = {
1410        data: responseData,
1411        status: request.status,
1412        statusText: request.statusText,
1413        headers: responseHeaders,
1414        config,
1415        request
1416      };
1417      settle(function _resolve(value) {
1418        resolve(value);
1419        done();
1420      }, function _reject(err) {
1421        reject(err);
1422        done();
1423      }, response);
1424      request = null;
1425    }
1426    if ("onloadend" in request) {
1427      request.onloadend = onloadend;
1428    } else {
1429      request.onreadystatechange = function handleLoad() {
1430        if (!request || request.readyState !== 4) {
1431          return;
1432        }
1433        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
1434          return;
1435        }
1436        setTimeout(onloadend);
1437      };
1438    }
1439    request.onabort = function handleAbort() {
1440      if (!request) {
1441        return;
1442      }
1443      reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config, request));
1444      request = null;
1445    };
1446    request.onerror = function handleError() {
1447      reject(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request));
1448      request = null;
1449    };
1450    request.ontimeout = function handleTimeout() {
1451      let timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
1452      const transitional2 = config.transitional || transitional_default;
1453      if (config.timeoutErrorMessage) {
1454        timeoutErrorMessage = config.timeoutErrorMessage;
1455      }
1456      reject(new AxiosError_default(
1457        timeoutErrorMessage,
1458        transitional2.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED,
1459        config,
1460        request
1461      ));
1462      request = null;
1463    };
1464    if (browser_default.isStandardBrowserEnv) {
1465      const xsrfValue = (config.withCredentials || isURLSameOrigin_default(fullPath)) && config.xsrfCookieName && cookies_default.read(config.xsrfCookieName);
1466      if (xsrfValue) {
1467        requestHeaders.set(config.xsrfHeaderName, xsrfValue);
1468      }
1469    }
1470    requestData === void 0 && requestHeaders.setContentType(null);
1471    if ("setRequestHeader" in request) {
1472      utils_default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
1473        request.setRequestHeader(key, val);
1474      });
1475    }
1476    if (!utils_default.isUndefined(config.withCredentials)) {
1477      request.withCredentials = !!config.withCredentials;
1478    }
1479    if (responseType && responseType !== "json") {
1480      request.responseType = config.responseType;
1481    }
1482    if (typeof config.onDownloadProgress === "function") {
1483      request.addEventListener("progress", progressEventReducer(config.onDownloadProgress, true));
1484    }
1485    if (typeof config.onUploadProgress === "function" && request.upload) {
1486      request.upload.addEventListener("progress", progressEventReducer(config.onUploadProgress));
1487    }
1488    if (config.cancelToken || config.signal) {
1489      onCanceled = (cancel) => {
1490        if (!request) {
1491          return;
1492        }
1493        reject(!cancel || cancel.type ? new CanceledError_default(null, config, request) : cancel);
1494        request.abort();
1495        request = null;
1496      };
1497      config.cancelToken && config.cancelToken.subscribe(onCanceled);
1498      if (config.signal) {
1499        config.signal.aborted ? onCanceled() : config.signal.addEventListener("abort", onCanceled);
1500      }
1501    }
1502    const protocol = parseProtocol(fullPath);
1503    if (protocol && browser_default.protocols.indexOf(protocol) === -1) {
1504      reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config));
1505      return;
1506    }
1507    request.send(requestData || null);
1508  });
1509};
1510

1511// node_modules/axios/lib/adapters/adapters.js
1512var knownAdapters = {
1513  http: null_default,
1514  xhr: xhr_default
1515};
1516utils_default.forEach(knownAdapters, (fn, value) => {
1517  if (fn) {
1518    try {
1519      Object.defineProperty(fn, "name", { value });
1520    } catch (e) {
1521    }
1522    Object.defineProperty(fn, "adapterName", { value });
1523  }
1524});
1525var adapters_default = {
1526  getAdapter: (adapters) => {
1527    adapters = utils_default.isArray(adapters) ? adapters : [adapters];
1528    const { length } = adapters;
1529    let nameOrAdapter;
1530    let adapter;
1531    for (let i = 0; i < length; i++) {
1532      nameOrAdapter = adapters[i];
1533      if (adapter = utils_default.isString(nameOrAdapter) ? knownAdapters[nameOrAdapter.toLowerCase()] : nameOrAdapter) {
1534        break;
1535      }
1536    }
1537    if (!adapter) {
1538      if (adapter === false) {
1539        throw new AxiosError_default(
1540          `Adapter ${nameOrAdapter} is not supported by the environment`,
1541          "ERR_NOT_SUPPORT"
1542        );
1543      }
1544      throw new Error(
1545        utils_default.hasOwnProp(knownAdapters, nameOrAdapter) ? `Adapter '${nameOrAdapter}' is not available in the build` : `Unknown adapter '${nameOrAdapter}'`
1546      );
1547    }
1548    if (!utils_default.isFunction(adapter)) {
1549      throw new TypeError("adapter is not a function");
1550    }
1551    return adapter;
1552  },
1553  adapters: knownAdapters
1554};
1555

1556// node_modules/axios/lib/core/dispatchRequest.js
1557function throwIfCancellationRequested(config) {
1558  if (config.cancelToken) {
1559    config.cancelToken.throwIfRequested();
1560  }
1561  if (config.signal && config.signal.aborted) {
1562    throw new CanceledError_default(null, config);
1563  }
1564}
1565function dispatchRequest(config) {
1566  throwIfCancellationRequested(config);
1567  config.headers = AxiosHeaders_default.from(config.headers);
1568  config.data = transformData.call(
1569    config,
1570    config.transformRequest
1571  );
1572  if (["post", "put", "patch"].indexOf(config.method) !== -1) {
1573    config.headers.setContentType("application/x-www-form-urlencoded", false);
1574  }
1575  const adapter = adapters_default.getAdapter(config.adapter || defaults_default.adapter);
1576  return adapter(config).then(function onAdapterResolution(response) {
1577    throwIfCancellationRequested(config);
1578    response.data = transformData.call(
1579      config,
1580      config.transformResponse,
1581      response
1582    );
1583    response.headers = AxiosHeaders_default.from(response.headers);
1584    return response;
1585  }, function onAdapterRejection(reason) {
1586    if (!isCancel(reason)) {
1587      throwIfCancellationRequested(config);
1588      if (reason && reason.response) {
1589        reason.response.data = transformData.call(
1590          config,
1591          config.transformResponse,
1592          reason.response
1593        );
1594        reason.response.headers = AxiosHeaders_default.from(reason.response.headers);
1595      }
1596    }
1597    return Promise.reject(reason);
1598  });
1599}
1600

1601// node_modules/axios/lib/core/mergeConfig.js
1602var headersToObject = (thing) => thing instanceof AxiosHeaders_default ? thing.toJSON() : thing;
1603function mergeConfig(config1, config2) {
1604  config2 = config2 || {};
1605  const config = {};
1606  function getMergedValue(target, source, caseless) {
1607    if (utils_default.isPlainObject(target) && utils_default.isPlainObject(source)) {
1608      return utils_default.merge.call({ caseless }, target, source);
1609    } else if (utils_default.isPlainObject(source)) {
1610      return utils_default.merge({}, source);
1611    } else if (utils_default.isArray(source)) {
1612      return source.slice();
1613    }
1614    return source;
1615  }
1616  function mergeDeepProperties(a, b, caseless) {
1617    if (!utils_default.isUndefined(b)) {
1618      return getMergedValue(a, b, caseless);
1619    } else if (!utils_default.isUndefined(a)) {
1620      return getMergedValue(void 0, a, caseless);
1621    }
1622  }
1623  function valueFromConfig2(a, b) {
1624    if (!utils_default.isUndefined(b)) {
1625      return getMergedValue(void 0, b);
1626    }
1627  }
1628  function defaultToConfig2(a, b) {
1629    if (!utils_default.isUndefined(b)) {
1630      return getMergedValue(void 0, b);
1631    } else if (!utils_default.isUndefined(a)) {
1632      return getMergedValue(void 0, a);
1633    }
1634  }
1635  function mergeDirectKeys(a, b, prop) {
1636    if (prop in config2) {
1637      return getMergedValue(a, b);
1638    } else if (prop in config1) {
1639      return getMergedValue(void 0, a);
1640    }
1641  }
1642  const mergeMap = {
1643    url: valueFromConfig2,
1644    method: valueFromConfig2,
1645    data: valueFromConfig2,
1646    baseURL: defaultToConfig2,
1647    transformRequest: defaultToConfig2,
1648    transformResponse: defaultToConfig2,
1649    paramsSerializer: defaultToConfig2,
1650    timeout: defaultToConfig2,
1651    timeoutMessage: defaultToConfig2,
1652    withCredentials: defaultToConfig2,
1653    adapter: defaultToConfig2,
1654    responseType: defaultToConfig2,
1655    xsrfCookieName: defaultToConfig2,
1656    xsrfHeaderName: defaultToConfig2,
1657    onUploadProgress: defaultToConfig2,
1658    onDownloadProgress: defaultToConfig2,
1659    decompress: defaultToConfig2,
1660    maxContentLength: defaultToConfig2,
1661    maxBodyLength: defaultToConfig2,
1662    beforeRedirect: defaultToConfig2,
1663    transport: defaultToConfig2,
1664    httpAgent: defaultToConfig2,
1665    httpsAgent: defaultToConfig2,
1666    cancelToken: defaultToConfig2,
1667    socketPath: defaultToConfig2,
1668    responseEncoding: defaultToConfig2,
1669    validateStatus: mergeDirectKeys,
1670    headers: (a, b) => mergeDeepProperties(headersToObject(a), headersToObject(b), true)
1671  };
1672  utils_default.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
1673    const merge2 = mergeMap[prop] || mergeDeepProperties;
1674    const configValue = merge2(config1[prop], config2[prop], prop);
1675    utils_default.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
1676  });
1677  return config;
1678}
1679

1680// node_modules/axios/lib/env/data.js
1681var VERSION = "1.4.0";
1682

1683// node_modules/axios/lib/helpers/validator.js
1684var validators = {};
1685["object", "boolean", "number", "function", "string", "symbol"].forEach((type, i) => {
1686  validators[type] = function validator(thing) {
1687    return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
1688  };
1689});
1690var deprecatedWarnings = {};
1691validators.transitional = function transitional(validator, version, message) {
1692  function formatMessage(opt, desc) {
1693    return "[Axios v" + VERSION + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
1694  }
1695  return (value, opt, opts) => {
1696    if (validator === false) {
1697      throw new AxiosError_default(
1698        formatMessage(opt, " has been removed" + (version ? " in " + version : "")),
1699        AxiosError_default.ERR_DEPRECATED
1700      );
1701    }
1702    if (version && !deprecatedWarnings[opt]) {
1703      deprecatedWarnings[opt] = true;
1704      console.warn(
1705        formatMessage(
1706          opt,
1707          " has been deprecated since v" + version + " and will be removed in the near future"
1708        )
1709      );
1710    }
1711    return validator ? validator(value, opt, opts) : true;
1712  };
1713};
1714function assertOptions(options, schema, allowUnknown) {
1715  if (typeof options !== "object") {
1716    throw new AxiosError_default("options must be an object", AxiosError_default.ERR_BAD_OPTION_VALUE);
1717  }
1718  const keys = Object.keys(options);
1719  let i = keys.length;
1720  while (i-- > 0) {
1721    const opt = keys[i];
1722    const validator = schema[opt];
1723    if (validator) {
1724      const value = options[opt];
1725      const result = value === void 0 || validator(value, opt, options);
1726      if (result !== true) {
1727        throw new AxiosError_default("option " + opt + " must be " + result, AxiosError_default.ERR_BAD_OPTION_VALUE);
1728      }
1729      continue;
1730    }
1731    if (allowUnknown !== true) {
1732      throw new AxiosError_default("Unknown option " + opt, AxiosError_default.ERR_BAD_OPTION);
1733    }
1734  }
1735}
1736var validator_default = {
1737  assertOptions,
1738  validators
1739};
1740

1741// node_modules/axios/lib/core/Axios.js
1742var validators2 = validator_default.validators;
1743var Axios = class {
1744  constructor(instanceConfig) {
1745    this.defaults = instanceConfig;
1746    this.interceptors = {
1747      request: new InterceptorManager_default(),
1748      response: new InterceptorManager_default()
1749    };
1750  }
1751  /**
1752   * Dispatch a request
1753   *
1754   * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
1755   * @param {?Object} config
1756   *
1757   * @returns {Promise} The Promise to be fulfilled
1758   */
1759  request(configOrUrl, config) {
1760    if (typeof configOrUrl === "string") {
1761      config = config || {};
1762      config.url = configOrUrl;
1763    } else {
1764      config = configOrUrl || {};
1765    }
1766    config = mergeConfig(this.defaults, config);
1767    const { transitional: transitional2, paramsSerializer, headers } = config;
1768    if (transitional2 !== void 0) {
1769      validator_default.assertOptions(transitional2, {
1770        silentJSONParsing: validators2.transitional(validators2.boolean),
1771        forcedJSONParsing: validators2.transitional(validators2.boolean),
1772        clarifyTimeoutError: validators2.transitional(validators2.boolean)
1773      }, false);
1774    }
1775    if (paramsSerializer != null) {
1776      if (utils_default.isFunction(paramsSerializer)) {
1777        config.paramsSerializer = {
1778          serialize: paramsSerializer
1779        };
1780      } else {
1781        validator_default.assertOptions(paramsSerializer, {
1782          encode: validators2.function,
1783          serialize: validators2.function
1784        }, true);
1785      }
1786    }
1787    config.method = (config.method || this.defaults.method || "get").toLowerCase();
1788    let contextHeaders;
1789    contextHeaders = headers && utils_default.merge(
1790      headers.common,
1791      headers[config.method]
1792    );
1793    contextHeaders && utils_default.forEach(
1794      ["delete", "get", "head", "post", "put", "patch", "common"],
1795      (method) => {
1796        delete headers[method];
1797      }
1798    );
1799    config.headers = AxiosHeaders_default.concat(contextHeaders, headers);
1800    const requestInterceptorChain = [];
1801    let synchronousRequestInterceptors = true;
1802    this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
1803      if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
1804        return;
1805      }
1806      synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
1807      requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
1808    });
1809    const responseInterceptorChain = [];
1810    this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
1811      responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
1812    });
1813    let promise;
1814    let i = 0;
1815    let len;
1816    if (!synchronousRequestInterceptors) {
1817      const chain = [dispatchRequest.bind(this), void 0];
1818      chain.unshift.apply(chain, requestInterceptorChain);
1819      chain.push.apply(chain, responseInterceptorChain);
1820      len = chain.length;
1821      promise = Promise.resolve(config);
1822      while (i < len) {
1823        promise = promise.then(chain[i++], chain[i++]);
1824      }
1825      return promise;
1826    }
1827    len = requestInterceptorChain.length;
1828    let newConfig = config;
1829    i = 0;
1830    while (i < len) {
1831      const onFulfilled = requestInterceptorChain[i++];
1832      const onRejected = requestInterceptorChain[i++];
1833      try {
1834        newConfig = onFulfilled(newConfig);
1835      } catch (error) {
1836        onRejected.call(this, error);
1837        break;
1838      }
1839    }
1840    try {
1841      promise = dispatchRequest.call(this, newConfig);
1842    } catch (error) {
1843      return Promise.reject(error);
1844    }
1845    i = 0;
1846    len = responseInterceptorChain.length;
1847    while (i < len) {
1848      promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
1849    }
1850    return promise;
1851  }
1852  getUri(config) {
1853    config = mergeConfig(this.defaults, config);
1854    const fullPath = buildFullPath(config.baseURL, config.url);
1855    return buildURL(fullPath, config.params, config.paramsSerializer);
1856  }
1857};
1858utils_default.forEach(["delete", "get", "head", "options"], function forEachMethodNoData2(method) {
1859  Axios.prototype[method] = function(url, config) {
1860    return this.request(mergeConfig(config || {}, {
1861      method,
1862      url,
1863      data: (config || {}).data
1864    }));
1865  };
1866});
1867utils_default.forEach(["post", "put", "patch"], function forEachMethodWithData2(method) {
1868  function generateHTTPMethod(isForm) {
1869    return function httpMethod(url, data, config) {
1870      return this.request(mergeConfig(config || {}, {
1871        method,
1872        headers: isForm ? {
1873          "Content-Type": "multipart/form-data"
1874        } : {},
1875        url,
1876        data
1877      }));
1878    };
1879  }
1880  Axios.prototype[method] = generateHTTPMethod();
1881  Axios.prototype[method + "Form"] = generateHTTPMethod(true);
1882});
1883var Axios_default = Axios;
1884

1885// node_modules/axios/lib/cancel/CancelToken.js
1886var CancelToken = class {
1887  constructor(executor) {
1888    if (typeof executor !== "function") {
1889      throw new TypeError("executor must be a function.");
1890    }
1891    let resolvePromise;
1892    this.promise = new Promise(function promiseExecutor(resolve) {
1893      resolvePromise = resolve;
1894    });
1895    const token = this;
1896    this.promise.then((cancel) => {
1897      if (!token._listeners)
1898        return;
1899      let i = token._listeners.length;
1900      while (i-- > 0) {
1901        token._listeners[i](cancel);
1902      }
1903      token._listeners = null;
1904    });
1905    this.promise.then = (onfulfilled) => {
1906      let _resolve;
1907      const promise = new Promise((resolve) => {
1908        token.subscribe(resolve);
1909        _resolve = resolve;
1910      }).then(onfulfilled);
1911      promise.cancel = function reject() {
1912        token.unsubscribe(_resolve);
1913      };
1914      return promise;
1915    };
1916    executor(function cancel(message, config, request) {
1917      if (token.reason) {
1918        return;
1919      }
1920      token.reason = new CanceledError_default(message, config, request);
1921      resolvePromise(token.reason);
1922    });
1923  }
1924  /**
1925   * Throws a `CanceledError` if cancellation has been requested.
1926   */
1927  throwIfRequested() {
1928    if (this.reason) {
1929      throw this.reason;
1930    }
1931  }
1932  /**
1933   * Subscribe to the cancel signal
1934   */
1935  subscribe(listener) {
1936    if (this.reason) {
1937      listener(this.reason);
1938      return;
1939    }
1940    if (this._listeners) {
1941      this._listeners.push(listener);
1942    } else {
1943      this._listeners = [listener];
1944    }
1945  }
1946  /**
1947   * Unsubscribe from the cancel signal
1948   */
1949  unsubscribe(listener) {
1950    if (!this._listeners) {
1951      return;
1952    }
1953    const index = this._listeners.indexOf(listener);
1954    if (index !== -1) {
1955      this._listeners.splice(index, 1);
1956    }
1957  }
1958  /**
1959   * Returns an object that contains a new `CancelToken` and a function that, when called,
1960   * cancels the `CancelToken`.
1961   */
1962  static source() {
1963    let cancel;
1964    const token = new CancelToken(function executor(c) {
1965      cancel = c;
1966    });
1967    return {
1968      token,
1969      cancel
1970    };
1971  }
1972};
1973var CancelToken_default = CancelToken;
1974

1975// node_modules/axios/lib/helpers/spread.js
1976function spread(callback) {
1977  return function wrap(arr) {
1978    return callback.apply(null, arr);
1979  };
1980}
1981

1982// node_modules/axios/lib/helpers/isAxiosError.js
1983function isAxiosError(payload) {
1984  return utils_default.isObject(payload) && payload.isAxiosError === true;
1985}
1986

1987// node_modules/axios/lib/helpers/HttpStatusCode.js
1988var HttpStatusCode = {
1989  Continue: 100,
1990  SwitchingProtocols: 101,
1991  Processing: 102,
1992  EarlyHints: 103,
1993  Ok: 200,
1994  Created: 201,
1995  Accepted: 202,
1996  NonAuthoritativeInformation: 203,
1997  NoContent: 204,
1998  ResetContent: 205,
1999  PartialContent: 206,
2000  MultiStatus: 207,
2001  AlreadyReported: 208,
2002  ImUsed: 226,
2003  MultipleChoices: 300,
2004  MovedPermanently: 301,
2005  Found: 302,
2006  SeeOther: 303,
2007  NotModified: 304,
2008  UseProxy: 305,
2009  Unused: 306,
2010  TemporaryRedirect: 307,
2011  PermanentRedirect: 308,
2012  BadRequest: 400,
2013  Unauthorized: 401,
2014  PaymentRequired: 402,
2015  Forbidden: 403,
2016  NotFound: 404,
2017  MethodNotAllowed: 405,
2018  NotAcceptable: 406,
2019  ProxyAuthenticationRequired: 407,
2020  RequestTimeout: 408,
2021  Conflict: 409,
2022  Gone: 410,
2023  LengthRequired: 411,
2024  PreconditionFailed: 412,
2025  PayloadTooLarge: 413,
2026  UriTooLong: 414,
2027  UnsupportedMediaType: 415,
2028  RangeNotSatisfiable: 416,
2029  ExpectationFailed: 417,
2030  ImATeapot: 418,
2031  MisdirectedRequest: 421,
2032  UnprocessableEntity: 422,
2033  Locked: 423,
2034  FailedDependency: 424,
2035  TooEarly: 425,
2036  UpgradeRequired: 426,
2037  PreconditionRequired: 428,
2038  TooManyRequests: 429,
2039  RequestHeaderFieldsTooLarge: 431,
2040  UnavailableForLegalReasons: 451,
2041  InternalServerError: 500,
2042  NotImplemented: 501,
2043  BadGateway: 502,
2044  ServiceUnavailable: 503,
2045  GatewayTimeout: 504,
2046  HttpVersionNotSupported: 505,
2047  VariantAlsoNegotiates: 506,
2048  InsufficientStorage: 507,
2049  LoopDetected: 508,
2050  NotExtended: 510,
2051  NetworkAuthenticationRequired: 511
2052};
2053Object.entries(HttpStatusCode).forEach(([key, value]) => {
2054  HttpStatusCode[value] = key;
2055});
2056var HttpStatusCode_default = HttpStatusCode;
2057

2058// node_modules/axios/lib/axios.js
2059function createInstance(defaultConfig) {
2060  const context = new Axios_default(defaultConfig);
2061  const instance = bind(Axios_default.prototype.request, context);
2062  utils_default.extend(instance, Axios_default.prototype, context, { allOwnKeys: true });
2063  utils_default.extend(instance, context, null, { allOwnKeys: true });
2064  instance.create = function create(instanceConfig) {
2065    return createInstance(mergeConfig(defaultConfig, instanceConfig));
2066  };
2067  return instance;
2068}
2069var axios = createInstance(defaults_default);
2070axios.Axios = Axios_default;
2071axios.CanceledError = CanceledError_default;
2072axios.CancelToken = CancelToken_default;
2073axios.isCancel = isCancel;
2074axios.VERSION = VERSION;
2075axios.toFormData = toFormData_default;
2076axios.AxiosError = AxiosError_default;
2077axios.Cancel = axios.CanceledError;
2078axios.all = function all(promises) {
2079  return Promise.all(promises);
2080};
2081axios.spread = spread;
2082axios.isAxiosError = isAxiosError;
2083axios.mergeConfig = mergeConfig;
2084axios.AxiosHeaders = AxiosHeaders_default;
2085axios.formToJSON = (thing) => formDataToJSON_default(utils_default.isHTMLForm(thing) ? new FormData(thing) : thing);
2086axios.HttpStatusCode = HttpStatusCode_default;
2087axios.default = axios;
2088var axios_default = axios;
2089

2090// node_modules/axios/index.js
2091var {
2092  Axios: Axios2,
2093  AxiosError: AxiosError2,
2094  CanceledError: CanceledError2,
2095  isCancel: isCancel2,
2096  CancelToken: CancelToken2,
2097  VERSION: VERSION2,
2098  all: all2,
2099  Cancel,
2100  isAxiosError: isAxiosError2,
2101  spread: spread2,
2102  toFormData: toFormData2,
2103  AxiosHeaders: AxiosHeaders2,
2104  HttpStatusCode: HttpStatusCode2,
2105  formToJSON,
2106  mergeConfig: mergeConfig2
2107} = axios_default;
2108export {
2109  Axios2 as Axios,
2110  AxiosError2 as AxiosError,
2111  AxiosHeaders2 as AxiosHeaders,
2112  Cancel,
2113  CancelToken2 as CancelToken,
2114  CanceledError2 as CanceledError,
2115  HttpStatusCode2 as HttpStatusCode,
2116  VERSION2 as VERSION,
2117  all2 as all,
2118  axios_default as default,
2119  formToJSON,
2120  isAxiosError2 as isAxiosError,
2121  isCancel2 as isCancel,
2122  mergeConfig2 as mergeConfig,
2123  spread2 as spread,
2124  toFormData2 as toFormData
2125};
2126//# sourceMappingURL=axios.js.map