PluginProbe
Elementor Website Builder – more than just a page builder / 4.3.2
Elementor Website Builder – more than just a page builder v4.3.2
4.3.2 4.3.1 4.3.0 4.3.0-beta3 4.3.0-beta2 4.3.0-beta1 4.2.4 4.2.3 4.2.2 4.2.1 4.2.0 4.1.5 4.2.0-beta2 4.2.0-dev2 4.2.0-beta1 4.1.4 4.1.3 4.1.2 4.1.1 4.1.0 4.1.0-beta3 4.1.0-dev3 4.0.9 4.1.0-beta2 4.1.0-dev2 All 455 releases
← All changes | assets/js/packages/http-client/http-client.js +2962 -5052 4.2.0-dev2 → 4.3.2 View file →
@@ -1,5131 +1,3041 @@
1 -/******/ (function() { // webpackBootstrap
2 -/******/ "use strict";
3 -/******/ var __webpack_modules__ = ({
1 +(function(_elementor_env) {
4 2
5 -/***/ "./node_modules/axios/index.js":
6 -/*!*************************************!*\
7 - !*** ./node_modules/axios/index.js ***!
8 - \*************************************/
9 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3 +//#region \0rolldown/runtime.js
4 + var __defProp = Object.defineProperty;
5 + var __name = (target, value) => __defProp(target, "name", {
6 + value,
7 + configurable: true
8 + });
9 + var __exportAll = (all, no_symbols) => {
10 + let target = {};
11 + for (var name in all) {
12 + __defProp(target, name, {
13 + get: all[name],
14 + enumerable: true
15 + });
16 + }
17 + if (!no_symbols) {
18 + __defProp(target, Symbol.toStringTag, { value: "Module" });
19 + }
20 + return target;
21 + };
10 22
11 -__webpack_require__.r(__webpack_exports__);
12 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
13 -/* harmony export */ Axios: function() { return /* binding */ Axios; },
14 -/* harmony export */ AxiosError: function() { return /* binding */ AxiosError; },
15 -/* harmony export */ AxiosHeaders: function() { return /* binding */ AxiosHeaders; },
16 -/* harmony export */ Cancel: function() { return /* binding */ Cancel; },
17 -/* harmony export */ CancelToken: function() { return /* binding */ CancelToken; },
18 -/* harmony export */ CanceledError: function() { return /* binding */ CanceledError; },
19 -/* harmony export */ HttpStatusCode: function() { return /* binding */ HttpStatusCode; },
20 -/* harmony export */ VERSION: function() { return /* binding */ VERSION; },
21 -/* harmony export */ all: function() { return /* binding */ all; },
22 -/* harmony export */ "default": function() { return /* reexport safe */ _lib_axios_js__WEBPACK_IMPORTED_MODULE_0__["default"]; },
23 -/* harmony export */ formToJSON: function() { return /* binding */ formToJSON; },
24 -/* harmony export */ getAdapter: function() { return /* binding */ getAdapter; },
25 -/* harmony export */ isAxiosError: function() { return /* binding */ isAxiosError; },
26 -/* harmony export */ isCancel: function() { return /* binding */ isCancel; },
27 -/* harmony export */ mergeConfig: function() { return /* binding */ mergeConfig; },
28 -/* harmony export */ spread: function() { return /* binding */ spread; },
29 -/* harmony export */ toFormData: function() { return /* binding */ toFormData; }
30 -/* harmony export */ });
31 -/* harmony import */ var _lib_axios_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./lib/axios.js */ "./node_modules/axios/lib/axios.js");
23 +//#endregion
32 24
33 -
34 -// This module is intended to unwrap Axios default export as named.
35 -// Keep top-level export same with static properties
36 -// so that it can keep same with es module or cjs
37 -const {
38 - Axios,
39 - AxiosError,
40 - CanceledError,
41 - isCancel,
42 - CancelToken,
43 - VERSION,
44 - all,
45 - Cancel,
46 - isAxiosError,
47 - spread,
48 - toFormData,
49 - AxiosHeaders,
50 - HttpStatusCode,
51 - formToJSON,
52 - getAdapter,
53 - mergeConfig
54 -} = _lib_axios_js__WEBPACK_IMPORTED_MODULE_0__["default"];
55 -
56 -
57 -
58 -
59 -/***/ }),
60 -
61 -/***/ "./node_modules/axios/lib/adapters/adapters.js":
62 -/*!*****************************************************!*\
63 - !*** ./node_modules/axios/lib/adapters/adapters.js ***!
64 - \*****************************************************/
65 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
66 -
67 -__webpack_require__.r(__webpack_exports__);
68 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
69 -/* harmony import */ var _http_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./http.js */ "./node_modules/axios/lib/helpers/null.js");
70 -/* harmony import */ var _xhr_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./xhr.js */ "./node_modules/axios/lib/adapters/xhr.js");
71 -/* harmony import */ var _fetch_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./fetch.js */ "./node_modules/axios/lib/adapters/fetch.js");
72 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
73 -
74 -
75 -
76 -
77 -
78 -
25 +//#region node_modules/axios/lib/helpers/bind.js
79 26 /**
80 - * Known adapters mapping.
81 - * Provides environment-specific adapters for Axios:
82 - * - `http` for Node.js
83 - * - `xhr` for browsers
84 - * - `fetch` for fetch API-based requests
85 - *
86 - * @type {Object<string, Function|Object>}
87 - */
88 -const knownAdapters = {
89 - http: _http_js__WEBPACK_IMPORTED_MODULE_1__["default"],
90 - xhr: _xhr_js__WEBPACK_IMPORTED_MODULE_2__["default"],
91 - fetch: {
92 - get: _fetch_js__WEBPACK_IMPORTED_MODULE_3__.getFetch,
93 - }
94 -};
27 + * Create a bound version of a function with a specified `this` context
28 + *
29 + * @param {Function} fn - The function to bind
30 + * @param {*} thisArg - The value to be passed as the `this` parameter
31 + * @returns {Function} A new function that will call the original function with the specified `this` context
32 + */
33 + function bind(fn, thisArg) {
34 + return function wrap() {
35 + return fn.apply(thisArg, arguments);
36 + };
37 + }
95 38
96 -// Assign adapter names for easier debugging and identification
97 -_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(knownAdapters, (fn, value) => {
98 - if (fn) {
99 - try {
100 - Object.defineProperty(fn, 'name', { value });
101 - } catch (e) {
102 - // eslint-disable-next-line no-empty
103 - }
104 - Object.defineProperty(fn, 'adapterName', { value });
105 - }
106 -});
39 +//#endregion
40 +//#region node_modules/axios/lib/utils.js
41 + var { toString } = Object.prototype;
42 + var { getPrototypeOf } = Object;
43 + var { iterator, toStringTag } = Symbol;
44 + var kindOf = ((cache) => (thing) => {
45 + const str = toString.call(thing);
46 + return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
47 + })(Object.create(null));
48 + var kindOfTest = (type) => {
49 + type = type.toLowerCase();
50 + return (thing) => kindOf(thing) === type;
51 + };
52 + var typeOfTest = (type) => (thing) => typeof thing === type;
53 + /**
54 + * Determine if a value is an Array
55 + *
56 + * @param {Object} val The value to test
57 + *
58 + * @returns {boolean} True if value is an Array, otherwise false
59 + */
60 + var { isArray } = Array;
61 + /**
62 + * Determine if a value is undefined
63 + *
64 + * @param {*} val The value to test
65 + *
66 + * @returns {boolean} True if the value is undefined, otherwise false
67 + */
68 + var isUndefined = typeOfTest("undefined");
69 + /**
70 + * Determine if a value is a Buffer
71 + *
72 + * @param {*} val The value to test
73 + *
74 + * @returns {boolean} True if value is a Buffer, otherwise false
75 + */
76 + function isBuffer(val) {
77 + return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);
78 + }
79 + /**
80 + * Determine if a value is an ArrayBuffer
81 + *
82 + * @param {*} val The value to test
83 + *
84 + * @returns {boolean} True if value is an ArrayBuffer, otherwise false
85 + */
86 + var isArrayBuffer = kindOfTest("ArrayBuffer");
87 + /**
88 + * Determine if a value is a view on an ArrayBuffer
89 + *
90 + * @param {*} val The value to test
91 + *
92 + * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
93 + */
94 + function isArrayBufferView(val) {
95 + let result;
96 + if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) result = ArrayBuffer.isView(val);
97 + else result = val && val.buffer && isArrayBuffer(val.buffer);
98 + return result;
99 + }
100 + /**
101 + * Determine if a value is a String
102 + *
103 + * @param {*} val The value to test
104 + *
105 + * @returns {boolean} True if value is a String, otherwise false
106 + */
107 + var isString = typeOfTest("string");
108 + /**
109 + * Determine if a value is a Function
110 + *
111 + * @param {*} val The value to test
112 + * @returns {boolean} True if value is a Function, otherwise false
113 + */
114 + var isFunction$1 = typeOfTest("function");
115 + /**
116 + * Determine if a value is a Number
117 + *
118 + * @param {*} val The value to test
119 + *
120 + * @returns {boolean} True if value is a Number, otherwise false
121 + */
122 + var isNumber = typeOfTest("number");
123 + /**
124 + * Determine if a value is an Object
125 + *
126 + * @param {*} thing The value to test
127 + *
128 + * @returns {boolean} True if value is an Object, otherwise false
129 + */
130 + var isObject = (thing) => thing !== null && typeof thing === "object";
131 + /**
132 + * Determine if a value is a Boolean
133 + *
134 + * @param {*} thing The value to test
135 + * @returns {boolean} True if value is a Boolean, otherwise false
136 + */
137 + var isBoolean = (thing) => thing === true || thing === false;
138 + /**
139 + * Determine if a value is a plain Object
140 + *
141 + * @param {*} val The value to test
142 + *
143 + * @returns {boolean} True if value is a plain Object, otherwise false
144 + */
145 + var isPlainObject = (val) => {
146 + if (kindOf(val) !== "object") return false;
147 + const prototype = getPrototypeOf(val);
148 + return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator in val);
149 + };
150 + /**
151 + * Determine if a value is an empty object (safely handles Buffers)
152 + *
153 + * @param {*} val The value to test
154 + *
155 + * @returns {boolean} True if value is an empty object, otherwise false
156 + */
157 + var isEmptyObject = (val) => {
158 + if (!isObject(val) || isBuffer(val)) return false;
159 + try {
160 + return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
161 + } catch (e) {
162 + return false;
163 + }
164 + };
165 + /**
166 + * Determine if a value is a Date
167 + *
168 + * @param {*} val The value to test
169 + *
170 + * @returns {boolean} True if value is a Date, otherwise false
171 + */
172 + var isDate = kindOfTest("Date");
173 + /**
174 + * Determine if a value is a File
175 + *
176 + * @param {*} val The value to test
177 + *
178 + * @returns {boolean} True if value is a File, otherwise false
179 + */
180 + var isFile = kindOfTest("File");
181 + /**
182 + * Determine if a value is a Blob
183 + *
184 + * @param {*} val The value to test
185 + *
186 + * @returns {boolean} True if value is a Blob, otherwise false
187 + */
188 + var isBlob = kindOfTest("Blob");
189 + /**
190 + * Determine if a value is a FileList
191 + *
192 + * @param {*} val The value to test
193 + *
194 + * @returns {boolean} True if value is a File, otherwise false
195 + */
196 + var isFileList = kindOfTest("FileList");
197 + /**
198 + * Determine if a value is a Stream
199 + *
200 + * @param {*} val The value to test
201 + *
202 + * @returns {boolean} True if value is a Stream, otherwise false
203 + */
204 + var isStream = (val) => isObject(val) && isFunction$1(val.pipe);
205 + /**
206 + * Determine if a value is a FormData
207 + *
208 + * @param {*} thing The value to test
209 + *
210 + * @returns {boolean} True if value is an FormData, otherwise false
211 + */
212 + var isFormData = (thing) => {
213 + let kind;
214 + return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction$1(thing.append) && ((kind = kindOf(thing)) === "formdata" || kind === "object" && isFunction$1(thing.toString) && thing.toString() === "[object FormData]"));
215 + };
216 + /**
217 + * Determine if a value is a URLSearchParams object
218 + *
219 + * @param {*} val The value to test
220 + *
221 + * @returns {boolean} True if value is a URLSearchParams object, otherwise false
222 + */
223 + var isURLSearchParams = kindOfTest("URLSearchParams");
224 + var [isReadableStream, isRequest, isResponse, isHeaders] = [
225 + "ReadableStream",
226 + "Request",
227 + "Response",
228 + "Headers"
229 + ].map(kindOfTest);
230 + /**
231 + * Trim excess whitespace off the beginning and end of a string
232 + *
233 + * @param {String} str The String to trim
234 + *
235 + * @returns {String} The String freed of excess whitespace
236 + */
237 + var trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
238 + /**
239 + * Iterate over an Array or an Object invoking a function for each item.
240 + *
241 + * If `obj` is an Array callback will be called passing
242 + * the value, index, and complete array for each item.
243 + *
244 + * If 'obj' is an Object callback will be called passing
245 + * the value, key, and complete object for each property.
246 + *
247 + * @param {Object|Array} obj The object to iterate
248 + * @param {Function} fn The callback to invoke for each item
249 + *
250 + * @param {Boolean} [allOwnKeys = false]
251 + * @returns {any}
252 + */
253 + function forEach(obj, fn, { allOwnKeys = false } = {}) {
254 + if (obj === null || typeof obj === "undefined") return;
255 + let i;
256 + let l;
257 + if (typeof obj !== "object") obj = [obj];
258 + if (isArray(obj)) for (i = 0, l = obj.length; i < l; i++) fn.call(null, obj[i], i, obj);
259 + else {
260 + if (isBuffer(obj)) return;
261 + const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
262 + const len = keys.length;
263 + let key;
264 + for (i = 0; i < len; i++) {
265 + key = keys[i];
266 + fn.call(null, obj[key], key, obj);
267 + }
268 + }
269 + }
270 + function findKey(obj, key) {
271 + if (isBuffer(obj)) return null;
272 + key = key.toLowerCase();
273 + const keys = Object.keys(obj);
274 + let i = keys.length;
275 + let _key;
276 + while (i-- > 0) {
277 + _key = keys[i];
278 + if (key === _key.toLowerCase()) return _key;
279 + }
280 + return null;
281 + }
282 + var _global = (() => {
283 + if (typeof globalThis !== "undefined") return globalThis;
284 + return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
285 + })();
286 + var isContextDefined = (context) => !isUndefined(context) && context !== _global;
287 + /**
288 + * Accepts varargs expecting each argument to be an object, then
289 + * immutably merges the properties of each object and returns result.
290 + *
291 + * When multiple objects contain the same key the later object in
292 + * the arguments list will take precedence.
293 + *
294 + * Example:
295 + *
296 + * ```js
297 + * var result = merge({foo: 123}, {foo: 456});
298 + * console.log(result.foo); // outputs 456
299 + * ```
300 + *
301 + * @param {Object} obj1 Object to merge
302 + *
303 + * @returns {Object} Result of all merge properties
304 + */
305 + function merge() {
306 + const { caseless, skipUndefined } = isContextDefined(this) && this || {};
307 + const result = {};
308 + const assignValue = (val, key) => {
309 + const targetKey = caseless && findKey(result, key) || key;
310 + if (isPlainObject(result[targetKey]) && isPlainObject(val)) result[targetKey] = merge(result[targetKey], val);
311 + else if (isPlainObject(val)) result[targetKey] = merge({}, val);
312 + else if (isArray(val)) result[targetKey] = val.slice();
313 + else if (!skipUndefined || !isUndefined(val)) result[targetKey] = val;
314 + };
315 + for (let i = 0, l = arguments.length; i < l; i++) arguments[i] && forEach(arguments[i], assignValue);
316 + return result;
317 + }
318 + /**
319 + * Extends object a by mutably adding to it the properties of object b.
320 + *
321 + * @param {Object} a The object to be extended
322 + * @param {Object} b The object to copy properties from
323 + * @param {Object} thisArg The object to bind function to
324 + *
325 + * @param {Boolean} [allOwnKeys]
326 + * @returns {Object} The resulting value of object a
327 + */
328 + var extend = (a, b, thisArg, { allOwnKeys } = {}) => {
329 + forEach(b, (val, key) => {
330 + if (thisArg && isFunction$1(val)) a[key] = bind(val, thisArg);
331 + else a[key] = val;
332 + }, { allOwnKeys });
333 + return a;
334 + };
335 + /**
336 + * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
337 + *
338 + * @param {string} content with BOM
339 + *
340 + * @returns {string} content value without BOM
341 + */
342 + var stripBOM = (content) => {
343 + if (content.charCodeAt(0) === 65279) content = content.slice(1);
344 + return content;
345 + };
346 + /**
347 + * Inherit the prototype methods from one constructor into another
348 + * @param {function} constructor
349 + * @param {function} superConstructor
350 + * @param {object} [props]
351 + * @param {object} [descriptors]
352 + *
353 + * @returns {void}
354 + */
355 + var inherits = (constructor, superConstructor, props, descriptors) => {
356 + constructor.prototype = Object.create(superConstructor.prototype, descriptors);
357 + constructor.prototype.constructor = constructor;
358 + Object.defineProperty(constructor, "super", { value: superConstructor.prototype });
359 + props && Object.assign(constructor.prototype, props);
360 + };
361 + /**
362 + * Resolve object with deep prototype chain to a flat object
363 + * @param {Object} sourceObj source object
364 + * @param {Object} [destObj]
365 + * @param {Function|Boolean} [filter]
366 + * @param {Function} [propFilter]
367 + *
368 + * @returns {Object}
369 + */
370 + var toFlatObject = (sourceObj, destObj, filter, propFilter) => {
371 + let props;
372 + let i;
373 + let prop;
374 + const merged = {};
375 + destObj = destObj || {};
376 + if (sourceObj == null) return destObj;
377 + do {
378 + props = Object.getOwnPropertyNames(sourceObj);
379 + i = props.length;
380 + while (i-- > 0) {
381 + prop = props[i];
382 + if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
383 + destObj[prop] = sourceObj[prop];
384 + merged[prop] = true;
385 + }
386 + }
387 + sourceObj = filter !== false && getPrototypeOf(sourceObj);
388 + } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
389 + return destObj;
390 + };
391 + /**
392 + * Determines whether a string ends with the characters of a specified string
393 + *
394 + * @param {String} str
395 + * @param {String} searchString
396 + * @param {Number} [position= 0]
397 + *
398 + * @returns {boolean}
399 + */
400 + var endsWith = (str, searchString, position) => {
401 + str = String(str);
402 + if (position === void 0 || position > str.length) position = str.length;
403 + position -= searchString.length;
404 + const lastIndex = str.indexOf(searchString, position);
405 + return lastIndex !== -1 && lastIndex === position;
406 + };
407 + /**
408 + * Returns new array from array like object or null if failed
409 + *
410 + * @param {*} [thing]
411 + *
412 + * @returns {?Array}
413 + */
414 + var toArray = (thing) => {
415 + if (!thing) return null;
416 + if (isArray(thing)) return thing;
417 + let i = thing.length;
418 + if (!isNumber(i)) return null;
419 + const arr = new Array(i);
420 + while (i-- > 0) arr[i] = thing[i];
421 + return arr;
422 + };
423 + /**
424 + * Checking if the Uint8Array exists and if it does, it returns a function that checks if the
425 + * thing passed in is an instance of Uint8Array
426 + *
427 + * @param {TypedArray}
428 + *
429 + * @returns {Array}
430 + */
431 + var isTypedArray = ((TypedArray) => {
432 + return (thing) => {
433 + return TypedArray && thing instanceof TypedArray;
434 + };
435 + })(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
436 + /**
437 + * For each entry in the object, call the function with the key and value.
438 + *
439 + * @param {Object<any, any>} obj - The object to iterate over.
440 + * @param {Function} fn - The function to call for each entry.
441 + *
442 + * @returns {void}
443 + */
444 + var forEachEntry = (obj, fn) => {
445 + const _iterator = (obj && obj[iterator]).call(obj);
446 + let result;
447 + while ((result = _iterator.next()) && !result.done) {
448 + const pair = result.value;
449 + fn.call(obj, pair[0], pair[1]);
450 + }
451 + };
452 + /**
453 + * It takes a regular expression and a string, and returns an array of all the matches
454 + *
455 + * @param {string} regExp - The regular expression to match against.
456 + * @param {string} str - The string to search.
457 + *
458 + * @returns {Array<boolean>}
459 + */
460 + var matchAll = (regExp, str) => {
461 + let matches;
462 + const arr = [];
463 + while ((matches = regExp.exec(str)) !== null) arr.push(matches);
464 + return arr;
465 + };
466 + var isHTMLForm = kindOfTest("HTMLFormElement");
467 + var toCamelCase = (str) => {
468 + return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g, function replacer(m, p1, p2) {
469 + return p1.toUpperCase() + p2;
470 + });
471 + };
472 + var hasOwnProperty = (({ hasOwnProperty }) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);
473 + /**
474 + * Determine if a value is a RegExp object
475 + *
476 + * @param {*} val The value to test
477 + *
478 + * @returns {boolean} True if value is a RegExp object, otherwise false
479 + */
480 + var isRegExp = kindOfTest("RegExp");
481 + var reduceDescriptors = (obj, reducer) => {
482 + const descriptors = Object.getOwnPropertyDescriptors(obj);
483 + const reducedDescriptors = {};
484 + forEach(descriptors, (descriptor, name) => {
485 + let ret;
486 + if ((ret = reducer(descriptor, name, obj)) !== false) reducedDescriptors[name] = ret || descriptor;
487 + });
488 + Object.defineProperties(obj, reducedDescriptors);
489 + };
490 + /**
491 + * Makes all methods read-only
492 + * @param {Object} obj
493 + */
494 + var freezeMethods = (obj) => {
495 + reduceDescriptors(obj, (descriptor, name) => {
496 + if (isFunction$1(obj) && [
497 + "arguments",
498 + "caller",
499 + "callee"
500 + ].indexOf(name) !== -1) return false;
501 + const value = obj[name];
502 + if (!isFunction$1(value)) return;
503 + descriptor.enumerable = false;
504 + if ("writable" in descriptor) {
505 + descriptor.writable = false;
506 + return;
507 + }
508 + if (!descriptor.set) descriptor.set = () => {
509 + throw Error("Can not rewrite read-only method '" + name + "'");
510 + };
511 + });
512 + };
513 + var toObjectSet = (arrayOrString, delimiter) => {
514 + const obj = {};
515 + const define = (arr) => {
516 + arr.forEach((value) => {
517 + obj[value] = true;
518 + });
519 + };
520 + isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
521 + return obj;
522 + };
523 + var noop = () => {};
524 + var toFiniteNumber = (value, defaultValue) => {
525 + return value != null && Number.isFinite(value = +value) ? value : defaultValue;
526 + };
527 + /**
528 + * If the thing is a FormData object, return true, otherwise return false.
529 + *
530 + * @param {unknown} thing - The thing to check.
531 + *
532 + * @returns {boolean}
533 + */
534 + function isSpecCompliantForm(thing) {
535 + return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === "FormData" && thing[iterator]);
536 + }
537 + var toJSONObject = (obj) => {
538 + const stack = new Array(10);
539 + const visit = (source, i) => {
540 + if (isObject(source)) {
541 + if (stack.indexOf(source) >= 0) return;
542 + if (isBuffer(source)) return source;
543 + if (!("toJSON" in source)) {
544 + stack[i] = source;
545 + const target = isArray(source) ? [] : {};
546 + forEach(source, (value, key) => {
547 + const reducedValue = visit(value, i + 1);
548 + !isUndefined(reducedValue) && (target[key] = reducedValue);
549 + });
550 + stack[i] = void 0;
551 + return target;
552 + }
553 + }
554 + return source;
555 + };
556 + return visit(obj, 0);
557 + };
558 + var isAsyncFn = kindOfTest("AsyncFunction");
559 + var isThenable = (thing) => thing && (isObject(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
560 + var _setImmediate = ((setImmediateSupported, postMessageSupported) => {
561 + if (setImmediateSupported) return setImmediate;
562 + return postMessageSupported ? ((token, callbacks) => {
563 + _global.addEventListener("message", ({ source, data }) => {
564 + if (source === _global && data === token) callbacks.length && callbacks.shift()();
565 + }, false);
566 + return (cb) => {
567 + callbacks.push(cb);
568 + _global.postMessage(token, "*");
569 + };
570 + })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
571 + })(typeof setImmediate === "function", isFunction$1(_global.postMessage));
572 + var asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process !== "undefined" && process.nextTick || _setImmediate;
573 + var isIterable = (thing) => thing != null && isFunction$1(thing[iterator]);
574 + var utils_default = {
575 + isArray,
576 + isArrayBuffer,
577 + isBuffer,
578 + isFormData,
579 + isArrayBufferView,
580 + isString,
581 + isNumber,
582 + isBoolean,
583 + isObject,
584 + isPlainObject,
585 + isEmptyObject,
586 + isReadableStream,
587 + isRequest,
588 + isResponse,
589 + isHeaders,
590 + isUndefined,
591 + isDate,
592 + isFile,
593 + isBlob,
594 + isRegExp,
595 + isFunction: isFunction$1,
596 + isStream,
597 + isURLSearchParams,
598 + isTypedArray,
599 + isFileList,
600 + forEach,
601 + merge,
602 + extend,
603 + trim,
604 + stripBOM,
605 + inherits,
606 + toFlatObject,
607 + kindOf,
608 + kindOfTest,
609 + endsWith,
610 + toArray,
611 + forEachEntry,
612 + matchAll,
613 + isHTMLForm,
614 + hasOwnProperty,
615 + hasOwnProp: hasOwnProperty,
616 + reduceDescriptors,
617 + freezeMethods,
618 + toObjectSet,
619 + toCamelCase,
620 + noop,
621 + toFiniteNumber,
622 + findKey,
623 + global: _global,
624 + isContextDefined,
625 + isSpecCompliantForm,
626 + toJSONObject,
627 + isAsyncFn,
628 + isThenable,
629 + setImmediate: _setImmediate,
630 + asap,
631 + isIterable
632 + };
107 633
634 +//#endregion
635 +//#region node_modules/axios/lib/core/AxiosError.js
108 636 /**
109 - * Render a rejection reason string for unknown or unsupported adapters
110 - *
111 - * @param {string} reason
112 - * @returns {string}
113 - */
114 -const renderReason = (reason) => `- ${reason}`;
637 + * Create an Error with the specified message, config, error code, request and response.
638 + *
639 + * @param {string} message The error message.
640 + * @param {string} [code] The error code (for example, 'ECONNABORTED').
641 + * @param {Object} [config] The config.
642 + * @param {Object} [request] The request.
643 + * @param {Object} [response] The response.
644 + *
645 + * @returns {Error} The created error.
646 + */
647 + function AxiosError$1(message, code, config, request, response) {
648 + Error.call(this);
649 + if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
650 + else this.stack = (/* @__PURE__ */ new Error()).stack;
651 + this.message = message;
652 + this.name = "AxiosError";
653 + code && (this.code = code);
654 + config && (this.config = config);
655 + request && (this.request = request);
656 + if (response) {
657 + this.response = response;
658 + this.status = response.status ? response.status : null;
659 + }
660 + }
661 + __name(AxiosError$1, "AxiosError");
662 + utils_default.inherits(AxiosError$1, Error, { toJSON: function toJSON() {
663 + return {
664 + message: this.message,
665 + name: this.name,
666 + description: this.description,
667 + number: this.number,
668 + fileName: this.fileName,
669 + lineNumber: this.lineNumber,
670 + columnNumber: this.columnNumber,
671 + stack: this.stack,
672 + config: utils_default.toJSONObject(this.config),
673 + code: this.code,
674 + status: this.status
675 + };
676 + } });
677 + var prototype$1 = AxiosError$1.prototype;
678 + var descriptors = {};
679 + [
680 + "ERR_BAD_OPTION_VALUE",
681 + "ERR_BAD_OPTION",
682 + "ECONNABORTED",
683 + "ETIMEDOUT",
684 + "ERR_NETWORK",
685 + "ERR_FR_TOO_MANY_REDIRECTS",
686 + "ERR_DEPRECATED",
687 + "ERR_BAD_RESPONSE",
688 + "ERR_BAD_REQUEST",
689 + "ERR_CANCELED",
690 + "ERR_NOT_SUPPORT",
691 + "ERR_INVALID_URL"
692 + ].forEach((code) => {
693 + descriptors[code] = { value: code };
694 + });
695 + Object.defineProperties(AxiosError$1, descriptors);
696 + Object.defineProperty(prototype$1, "isAxiosError", { value: true });
697 + AxiosError$1.from = (error, code, config, request, response, customProps) => {
698 + const axiosError = Object.create(prototype$1);
699 + utils_default.toFlatObject(error, axiosError, function filter(obj) {
700 + return obj !== Error.prototype;
701 + }, (prop) => {
702 + return prop !== "isAxiosError";
703 + });
704 + const msg = error && error.message ? error.message : "Error";
705 + const errCode = code == null && error ? error.code : code;
706 + AxiosError$1.call(axiosError, msg, errCode, config, request, response);
707 + if (error && axiosError.cause == null) Object.defineProperty(axiosError, "cause", {
708 + value: error,
709 + configurable: true
710 + });
711 + axiosError.name = error && error.name || "Error";
712 + customProps && Object.assign(axiosError, customProps);
713 + return axiosError;
714 + };
115 715
716 +//#endregion
717 +//#region node_modules/axios/lib/helpers/toFormData.js
116 718 /**
117 - * Check if the adapter is resolved (function, null, or false)
118 - *
119 - * @param {Function|null|false} adapter
120 - * @returns {boolean}
121 - */
122 -const isResolvedHandle = (adapter) => _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(adapter) || adapter === null || adapter === false;
719 + * Determines if the given thing is a array or js object.
720 + *
721 + * @param {string} thing - The object or array to be visited.
722 + *
723 + * @returns {boolean}
724 + */
725 + function isVisitable(thing) {
726 + return utils_default.isPlainObject(thing) || utils_default.isArray(thing);
727 + }
728 + /**
729 + * It removes the brackets from the end of a string
730 + *
731 + * @param {string} key - The key of the parameter.
732 + *
733 + * @returns {string} the key without the brackets.
734 + */
735 + function removeBrackets(key) {
736 + return utils_default.endsWith(key, "[]") ? key.slice(0, -2) : key;
737 + }
738 + /**
739 + * It takes a path, a key, and a boolean, and returns a string
740 + *
741 + * @param {string} path - The path to the current key.
742 + * @param {string} key - The key of the current object being iterated over.
743 + * @param {string} dots - If true, the key will be rendered with dots instead of brackets.
744 + *
745 + * @returns {string} The path to the current key.
746 + */
747 + function renderKey(path, key, dots) {
748 + if (!path) return key;
749 + return path.concat(key).map(function each(token, i) {
750 + token = removeBrackets(token);
751 + return !dots && i ? "[" + token + "]" : token;
752 + }).join(dots ? "." : "");
753 + }
754 + /**
755 + * If the array is an array and none of its elements are visitable, then it's a flat array.
756 + *
757 + * @param {Array<any>} arr - The array to check
758 + *
759 + * @returns {boolean}
760 + */
761 + function isFlatArray(arr) {
762 + return utils_default.isArray(arr) && !arr.some(isVisitable);
763 + }
764 + var predicates = utils_default.toFlatObject(utils_default, {}, null, function filter(prop) {
765 + return /^is[A-Z]/.test(prop);
766 + });
767 + /**
768 + * Convert a data object to FormData
769 + *
770 + * @param {Object} obj
771 + * @param {?Object} [formData]
772 + * @param {?Object} [options]
773 + * @param {Function} [options.visitor]
774 + * @param {Boolean} [options.metaTokens = true]
775 + * @param {Boolean} [options.dots = false]
776 + * @param {?Boolean} [options.indexes = false]
777 + *
778 + * @returns {Object}
779 + **/
780 + /**
781 + * It converts an object into a FormData object
782 + *
783 + * @param {Object<any, any>} obj - The object to convert to form data.
784 + * @param {string} formData - The FormData object to append to.
785 + * @param {Object<string, any>} options
786 + *
787 + * @returns
788 + */
789 + function toFormData$1(obj, formData, options) {
790 + if (!utils_default.isObject(obj)) throw new TypeError("target must be an object");
791 + formData = formData || new (null || FormData)();
792 + options = utils_default.toFlatObject(options, {
793 + metaTokens: true,
794 + dots: false,
795 + indexes: false
796 + }, false, function defined(option, source) {
797 + return !utils_default.isUndefined(source[option]);
798 + });
799 + const metaTokens = options.metaTokens;
800 + const visitor = options.visitor || defaultVisitor;
801 + const dots = options.dots;
802 + const indexes = options.indexes;
803 + const useBlob = (options.Blob || typeof Blob !== "undefined" && Blob) && utils_default.isSpecCompliantForm(formData);
804 + if (!utils_default.isFunction(visitor)) throw new TypeError("visitor must be a function");
805 + function convertValue(value) {
806 + if (value === null) return "";
807 + if (utils_default.isDate(value)) return value.toISOString();
808 + if (utils_default.isBoolean(value)) return value.toString();
809 + if (!useBlob && utils_default.isBlob(value)) throw new AxiosError$1("Blob is not supported. Use a Buffer instead.");
810 + if (utils_default.isArrayBuffer(value) || utils_default.isTypedArray(value)) return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
811 + return value;
812 + }
813 + /**
814 + * Default visitor.
815 + *
816 + * @param {*} value
817 + * @param {String|Number} key
818 + * @param {Array<String|Number>} path
819 + * @this {FormData}
820 + *
821 + * @returns {boolean} return true to visit the each prop of the value recursively
822 + */
823 + function defaultVisitor(value, key, path) {
824 + let arr = value;
825 + if (value && !path && typeof value === "object") {
826 + if (utils_default.endsWith(key, "{}")) {
827 + key = metaTokens ? key : key.slice(0, -2);
828 + value = JSON.stringify(value);
829 + } else if (utils_default.isArray(value) && isFlatArray(value) || (utils_default.isFileList(value) || utils_default.endsWith(key, "[]")) && (arr = utils_default.toArray(value))) {
830 + key = removeBrackets(key);
831 + arr.forEach(function each(el, index) {
832 + !(utils_default.isUndefined(el) || el === null) && formData.append(indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + "[]", convertValue(el));
833 + });
834 + return false;
835 + }
836 + }
837 + if (isVisitable(value)) return true;
838 + formData.append(renderKey(path, key, dots), convertValue(value));
839 + return false;
840 + }
841 + const stack = [];
842 + const exposedHelpers = Object.assign(predicates, {
843 + defaultVisitor,
844 + convertValue,
845 + isVisitable
846 + });
847 + function build(value, path) {
848 + if (utils_default.isUndefined(value)) return;
849 + if (stack.indexOf(value) !== -1) throw Error("Circular reference detected in " + path.join("."));
850 + stack.push(value);
851 + utils_default.forEach(value, function each(el, key) {
852 + if ((!(utils_default.isUndefined(el) || el === null) && visitor.call(formData, el, utils_default.isString(key) ? key.trim() : key, path, exposedHelpers)) === true) build(el, path ? path.concat(key) : [key]);
853 + });
854 + stack.pop();
855 + }
856 + if (!utils_default.isObject(obj)) throw new TypeError("data must be an object");
857 + build(obj);
858 + return formData;
859 + }
860 + __name(toFormData$1, "toFormData");
123 861
862 +//#endregion
863 +//#region node_modules/axios/lib/helpers/AxiosURLSearchParams.js
124 864 /**
125 - * Get the first suitable adapter from the provided list.
126 - * Tries each adapter in order until a supported one is found.
127 - * Throws an AxiosError if no adapter is suitable.
128 - *
129 - * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.
130 - * @param {Object} config - Axios request configuration
131 - * @throws {AxiosError} If no suitable adapter is available
132 - * @returns {Function} The resolved adapter function
133 - */
134 -function getAdapter(adapters, config) {
135 - adapters = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(adapters) ? adapters : [adapters];
865 + * It encodes a string by replacing all characters that are not in the unreserved set with
866 + * their percent-encoded equivalents
867 + *
868 + * @param {string} str - The string to encode.
869 + *
870 + * @returns {string} The encoded string.
871 + */
872 + function encode$1(str) {
873 + const charMap = {
874 + "!": "%21",
875 + "'": "%27",
876 + "(": "%28",
877 + ")": "%29",
878 + "~": "%7E",
879 + "%20": "+",
880 + "%00": "\0"
881 + };
882 + return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
883 + return charMap[match];
884 + });
885 + }
886 + __name(encode$1, "encode");
887 + /**
888 + * It takes a params object and converts it to a FormData object
889 + *
890 + * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
891 + * @param {Object<string, any>} options - The options object passed to the Axios constructor.
892 + *
893 + * @returns {void}
894 + */
895 + function AxiosURLSearchParams(params, options) {
896 + this._pairs = [];
897 + params && toFormData$1(params, this, options);
898 + }
899 + var prototype = AxiosURLSearchParams.prototype;
900 + prototype.append = function append(name, value) {
901 + this._pairs.push([name, value]);
902 + };
903 + prototype.toString = function toString(encoder) {
904 + const _encode = encoder ? function(value) {
905 + return encoder.call(this, value, encode$1);
906 + } : encode$1;
907 + return this._pairs.map(function each(pair) {
908 + return _encode(pair[0]) + "=" + _encode(pair[1]);
909 + }, "").join("&");
910 + };
136 911
137 - const { length } = adapters;
138 - let nameOrAdapter;
139 - let adapter;
140 -
141 - const rejectedReasons = {};
142 -
143 - for (let i = 0; i < length; i++) {
144 - nameOrAdapter = adapters[i];
145 - let id;
146 -
147 - adapter = nameOrAdapter;
148 -
149 - if (!isResolvedHandle(nameOrAdapter)) {
150 - adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
151 -
152 - if (adapter === undefined) {
153 - throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_4__["default"](`Unknown adapter '${id}'`);
154 - }
155 - }
156 -
157 - if (adapter && (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(adapter) || (adapter = adapter.get(config)))) {
158 - break;
159 - }
160 -
161 - rejectedReasons[id || '#' + i] = adapter;
162 - }
163 -
164 - if (!adapter) {
165 - const reasons = Object.entries(rejectedReasons)
166 - .map(([id, state]) => `adapter ${id} ` +
167 - (state === false ? 'is not supported by the environment' : 'is not available in the build')
168 - );
169 -
170 - let s = length ?
171 - (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
172 - 'as no adapter specified';
173 -
174 - throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_4__["default"](
175 - `There is no suitable adapter to dispatch the request ` + s,
176 - 'ERR_NOT_SUPPORT'
177 - );
178 - }
179 -
180 - return adapter;
181 -}
182 -
912 +//#endregion
913 +//#region node_modules/axios/lib/helpers/buildURL.js
183 914 /**
184 - * Exports Axios adapters and utility to resolve an adapter
185 - */
186 -/* harmony default export */ __webpack_exports__["default"] = ({
187 - /**
188 - * Resolve an adapter from a list of adapter names or functions.
189 - * @type {Function}
190 - */
191 - getAdapter,
915 + * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
916 + * URI encoded counterparts
917 + *
918 + * @param {string} val The value to be encoded.
919 + *
920 + * @returns {string} The encoded value.
921 + */
922 + function encode(val) {
923 + return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+");
924 + }
925 + /**
926 + * Build a URL by appending params to the end
927 + *
928 + * @param {string} url The base of the url (e.g., http://www.google.com)
929 + * @param {object} [params] The params to be appended
930 + * @param {?(object|Function)} options
931 + *
932 + * @returns {string} The formatted url
933 + */
934 + function buildURL(url, params, options) {
935 + if (!params) return url;
936 + const _encode = options && options.encode || encode;
937 + if (utils_default.isFunction(options)) options = { serialize: options };
938 + const serializeFn = options && options.serialize;
939 + let serializedParams;
940 + if (serializeFn) serializedParams = serializeFn(params, options);
941 + else serializedParams = utils_default.isURLSearchParams(params) ? params.toString() : new AxiosURLSearchParams(params, options).toString(_encode);
942 + if (serializedParams) {
943 + const hashmarkIndex = url.indexOf("#");
944 + if (hashmarkIndex !== -1) url = url.slice(0, hashmarkIndex);
945 + url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
946 + }
947 + return url;
948 + }
192 949
193 - /**
194 - * Exposes all known adapters
195 - * @type {Object<string, Function|Object>}
196 - */
197 - adapters: knownAdapters
198 -});
950 +//#endregion
951 +//#region node_modules/axios/lib/core/InterceptorManager.js
952 + var InterceptorManager = class {
953 + constructor() {
954 + this.handlers = [];
955 + }
956 + /**
957 + * Add a new interceptor to the stack
958 + *
959 + * @param {Function} fulfilled The function to handle `then` for a `Promise`
960 + * @param {Function} rejected The function to handle `reject` for a `Promise`
961 + *
962 + * @return {Number} An ID used to remove interceptor later
963 + */
964 + use(fulfilled, rejected, options) {
965 + this.handlers.push({
966 + fulfilled,
967 + rejected,
968 + synchronous: options ? options.synchronous : false,
969 + runWhen: options ? options.runWhen : null
970 + });
971 + return this.handlers.length - 1;
972 + }
973 + /**
974 + * Remove an interceptor from the stack
975 + *
976 + * @param {Number} id The ID that was returned by `use`
977 + *
978 + * @returns {void}
979 + */
980 + eject(id) {
981 + if (this.handlers[id]) this.handlers[id] = null;
982 + }
983 + /**
984 + * Clear all interceptors from the stack
985 + *
986 + * @returns {void}
987 + */
988 + clear() {
989 + if (this.handlers) this.handlers = [];
990 + }
991 + /**
992 + * Iterate over all the registered interceptors
993 + *
994 + * This method is particularly useful for skipping over any
995 + * interceptors that may have become `null` calling `eject`.
996 + *
997 + * @param {Function} fn The function to call for each interceptor
998 + *
999 + * @returns {void}
1000 + */
1001 + forEach(fn) {
1002 + utils_default.forEach(this.handlers, function forEachHandler(h) {
1003 + if (h !== null) fn(h);
1004 + });
1005 + }
1006 + };
199 1007
1008 +//#endregion
1009 +//#region node_modules/axios/lib/defaults/transitional.js
1010 + var transitional_default = {
1011 + silentJSONParsing: true,
1012 + forcedJSONParsing: true,
1013 + clarifyTimeoutError: false
1014 + };
200 1015
201 -/***/ }),
1016 +//#endregion
1017 +//#region node_modules/axios/lib/platform/browser/classes/URLSearchParams.js
1018 + var URLSearchParams_default = typeof URLSearchParams !== "undefined" ? URLSearchParams : AxiosURLSearchParams;
202 1019
203 -/***/ "./node_modules/axios/lib/adapters/fetch.js":
204 -/*!**************************************************!*\
205 - !*** ./node_modules/axios/lib/adapters/fetch.js ***!
206 - \**************************************************/
207 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1020 +//#endregion
1021 +//#region node_modules/axios/lib/platform/browser/classes/FormData.js
1022 + var FormData_default = typeof FormData !== "undefined" ? FormData : null;
208 1023
209 -__webpack_require__.r(__webpack_exports__);
210 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
211 -/* harmony export */ getFetch: function() { return /* binding */ getFetch; }
212 -/* harmony export */ });
213 -/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js");
214 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
215 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
216 -/* harmony import */ var _helpers_composeSignals_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../helpers/composeSignals.js */ "./node_modules/axios/lib/helpers/composeSignals.js");
217 -/* harmony import */ var _helpers_trackStream_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../helpers/trackStream.js */ "./node_modules/axios/lib/helpers/trackStream.js");
218 -/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js");
219 -/* harmony import */ var _helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../helpers/progressEventReducer.js */ "./node_modules/axios/lib/helpers/progressEventReducer.js");
220 -/* harmony import */ var _helpers_resolveConfig_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../helpers/resolveConfig.js */ "./node_modules/axios/lib/helpers/resolveConfig.js");
221 -/* harmony import */ var _core_settle_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../core/settle.js */ "./node_modules/axios/lib/core/settle.js");
1024 +//#endregion
1025 +//#region node_modules/axios/lib/platform/browser/classes/Blob.js
1026 + var Blob_default = typeof Blob !== "undefined" ? Blob : null;
222 1027
1028 +//#endregion
1029 +//#region node_modules/axios/lib/platform/browser/index.js
1030 + var browser_default = {
1031 + isBrowser: true,
1032 + classes: {
1033 + URLSearchParams: URLSearchParams_default,
1034 + FormData: FormData_default,
1035 + Blob: Blob_default
1036 + },
1037 + protocols: [
1038 + "http",
1039 + "https",
1040 + "file",
1041 + "blob",
1042 + "url",
1043 + "data"
1044 + ]
1045 + };
223 1046
1047 +//#endregion
1048 +//#region node_modules/axios/lib/platform/common/utils.js
1049 + var utils_exports = /* @__PURE__ */ __exportAll({
1050 + hasBrowserEnv: () => hasBrowserEnv,
1051 + hasStandardBrowserEnv: () => hasStandardBrowserEnv,
1052 + hasStandardBrowserWebWorkerEnv: () => hasStandardBrowserWebWorkerEnv,
1053 + navigator: () => _navigator,
1054 + origin: () => origin
1055 + });
1056 + var hasBrowserEnv = typeof window !== "undefined" && typeof document !== "undefined";
1057 + var _navigator = typeof navigator === "object" && navigator || void 0;
1058 + /**
1059 + * Determine if we're running in a standard browser environment
1060 + *
1061 + * This allows axios to run in a web worker, and react-native.
1062 + * Both environments support XMLHttpRequest, but not fully standard globals.
1063 + *
1064 + * web workers:
1065 + * typeof window -> undefined
1066 + * typeof document -> undefined
1067 + *
1068 + * react-native:
1069 + * navigator.product -> 'ReactNative'
1070 + * nativescript
1071 + * navigator.product -> 'NativeScript' or 'NS'
1072 + *
1073 + * @returns {boolean}
1074 + */
1075 + var hasStandardBrowserEnv = hasBrowserEnv && (!_navigator || [
1076 + "ReactNative",
1077 + "NativeScript",
1078 + "NS"
1079 + ].indexOf(_navigator.product) < 0);
1080 + /**
1081 + * Determine if we're running in a standard browser webWorker environment
1082 + *
1083 + * Although the `isStandardBrowserEnv` method indicates that
1084 + * `allows axios to run in a web worker`, the WebWorker will still be
1085 + * filtered out due to its judgment standard
1086 + * `typeof window !== 'undefined' && typeof document !== 'undefined'`.
1087 + * This leads to a problem when axios post `FormData` in webWorker
1088 + */
1089 + var hasStandardBrowserWebWorkerEnv = (() => {
1090 + return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope && typeof self.importScripts === "function";
1091 + })();
1092 + var origin = hasBrowserEnv && window.location.href || "http://localhost";
224 1093
1094 +//#endregion
1095 +//#region node_modules/axios/lib/platform/index.js
1096 + var platform_default = {
1097 + ...utils_exports,
1098 + ...browser_default
1099 + };
225 1100
1101 +//#endregion
1102 +//#region node_modules/axios/lib/helpers/toURLEncodedForm.js
1103 + function toURLEncodedForm(data, options) {
1104 + return toFormData$1(data, new platform_default.classes.URLSearchParams(), {
1105 + visitor: function(value, key, path, helpers) {
1106 + if (platform_default.isNode && utils_default.isBuffer(value)) {
1107 + this.append(key, value.toString("base64"));
1108 + return false;
1109 + }
1110 + return helpers.defaultVisitor.apply(this, arguments);
1111 + },
1112 + ...options
1113 + });
1114 + }
226 1115
227 -
228 -
229 -
230 -
231 -
232 -const DEFAULT_CHUNK_SIZE = 64 * 1024;
233 -
234 -const {isFunction} = _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"];
235 -
236 -const globalFetchAPI = (({Request, Response}) => ({
237 - Request, Response
238 -}))(_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].global);
239 -
240 -const {
241 - ReadableStream, TextEncoder
242 -} = _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].global;
243 -
244 -
245 -const test = (fn, ...args) => {
246 - try {
247 - return !!fn(...args);
248 - } catch (e) {
249 - return false
250 - }
251 -}
252 -
253 -const factory = (env) => {
254 - env = _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].merge.call({
255 - skipUndefined: true
256 - }, globalFetchAPI, env);
257 -
258 - const {fetch: envFetch, Request, Response} = env;
259 - const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';
260 - const isRequestSupported = isFunction(Request);
261 - const isResponseSupported = isFunction(Response);
262 -
263 - if (!isFetchSupported) {
264 - return false;
265 - }
266 -
267 - const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream);
268 -
269 - const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
270 - ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
271 - async (str) => new Uint8Array(await new Request(str).arrayBuffer())
272 - );
273 -
274 - const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
275 - let duplexAccessed = false;
276 -
277 - const hasContentType = new Request(_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].origin, {
278 - body: new ReadableStream(),
279 - method: 'POST',
280 - get duplex() {
281 - duplexAccessed = true;
282 - return 'half';
283 - },
284 - }).headers.has('Content-Type');
285 -
286 - return duplexAccessed && !hasContentType;
287 - });
288 -
289 - const supportsResponseStream = isResponseSupported && isReadableStreamSupported &&
290 - test(() => _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isReadableStream(new Response('').body));
291 -
292 - const resolvers = {
293 - stream: supportsResponseStream && ((res) => res.body)
294 - };
295 -
296 - isFetchSupported && ((() => {
297 - ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
298 - !resolvers[type] && (resolvers[type] = (res, config) => {
299 - let method = res && res[type];
300 -
301 - if (method) {
302 - return method.call(res);
303 - }
304 -
305 - throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"](`Response type '${type}' is not supported`, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].ERR_NOT_SUPPORT, config);
306 - })
307 - });
308 - })());
309 -
310 - const getBodyLength = async (body) => {
311 - if (body == null) {
312 - return 0;
313 - }
314 -
315 - if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isBlob(body)) {
316 - return body.size;
317 - }
318 -
319 - if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isSpecCompliantForm(body)) {
320 - const _request = new Request(_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].origin, {
321 - method: 'POST',
322 - body,
323 - });
324 - return (await _request.arrayBuffer()).byteLength;
325 - }
326 -
327 - if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isArrayBufferView(body) || _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isArrayBuffer(body)) {
328 - return body.byteLength;
329 - }
330 -
331 - if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isURLSearchParams(body)) {
332 - body = body + '';
333 - }
334 -
335 - if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isString(body)) {
336 - return (await encodeText(body)).byteLength;
337 - }
338 - }
339 -
340 - const resolveBodyLength = async (headers, body) => {
341 - const length = _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].toFiniteNumber(headers.getContentLength());
342 -
343 - return length == null ? getBodyLength(body) : length;
344 - }
345 -
346 - return async (config) => {
347 - let {
348 - url,
349 - method,
350 - data,
351 - signal,
352 - cancelToken,
353 - timeout,
354 - onDownloadProgress,
355 - onUploadProgress,
356 - responseType,
357 - headers,
358 - withCredentials = 'same-origin',
359 - fetchOptions
360 - } = (0,_helpers_resolveConfig_js__WEBPACK_IMPORTED_MODULE_7__["default"])(config);
361 -
362 - let _fetch = envFetch || fetch;
363 -
364 - responseType = responseType ? (responseType + '').toLowerCase() : 'text';
365 -
366 - let composedSignal = (0,_helpers_composeSignals_js__WEBPACK_IMPORTED_MODULE_3__["default"])([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
367 -
368 - let request = null;
369 -
370 - const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
371 - composedSignal.unsubscribe();
372 - });
373 -
374 - let requestContentLength;
375 -
376 - try {
377 - if (
378 - onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
379 - (requestContentLength = await resolveBodyLength(headers, data)) !== 0
380 - ) {
381 - let _request = new Request(url, {
382 - method: 'POST',
383 - body: data,
384 - duplex: "half"
385 - });
386 -
387 - let contentTypeHeader;
388 -
389 - if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
390 - headers.setContentType(contentTypeHeader)
391 - }
392 -
393 - if (_request.body) {
394 - const [onProgress, flush] = (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__.progressEventDecorator)(
395 - requestContentLength,
396 - (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__.progressEventReducer)((0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__.asyncDecorator)(onUploadProgress))
397 - );
398 -
399 - data = (0,_helpers_trackStream_js__WEBPACK_IMPORTED_MODULE_4__.trackStream)(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
400 - }
401 - }
402 -
403 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isString(withCredentials)) {
404 - withCredentials = withCredentials ? 'include' : 'omit';
405 - }
406 -
407 - // Cloudflare Workers throws when credentials are defined
408 - // see https://github.com/cloudflare/workerd/issues/902
409 - const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
410 -
411 - const resolvedOptions = {
412 - ...fetchOptions,
413 - signal: composedSignal,
414 - method: method.toUpperCase(),
415 - headers: headers.normalize().toJSON(),
416 - body: data,
417 - duplex: "half",
418 - credentials: isCredentialsSupported ? withCredentials : undefined
419 - };
420 -
421 - request = isRequestSupported && new Request(url, resolvedOptions);
422 -
423 - let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
424 -
425 - const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
426 -
427 - if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
428 - const options = {};
429 -
430 - ['status', 'statusText', 'headers'].forEach(prop => {
431 - options[prop] = response[prop];
432 - });
433 -
434 - const responseContentLength = _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].toFiniteNumber(response.headers.get('content-length'));
435 -
436 - const [onProgress, flush] = onDownloadProgress && (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__.progressEventDecorator)(
437 - responseContentLength,
438 - (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__.progressEventReducer)((0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_6__.asyncDecorator)(onDownloadProgress), true)
439 - ) || [];
440 -
441 - response = new Response(
442 - (0,_helpers_trackStream_js__WEBPACK_IMPORTED_MODULE_4__.trackStream)(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
443 - flush && flush();
444 - unsubscribe && unsubscribe();
445 - }),
446 - options
447 - );
448 - }
449 -
450 - responseType = responseType || 'text';
451 -
452 - let responseData = await resolvers[_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].findKey(resolvers, responseType) || 'text'](response, config);
453 -
454 - !isStreamResponse && unsubscribe && unsubscribe();
455 -
456 - return await new Promise((resolve, reject) => {
457 - (0,_core_settle_js__WEBPACK_IMPORTED_MODULE_8__["default"])(resolve, reject, {
458 - data: responseData,
459 - headers: _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_5__["default"].from(response.headers),
460 - status: response.status,
461 - statusText: response.statusText,
462 - config,
463 - request
464 - })
465 - })
466 - } catch (err) {
467 - unsubscribe && unsubscribe();
468 -
469 - if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
470 - throw Object.assign(
471 - new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"]('Network Error', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].ERR_NETWORK, config, request),
472 - {
473 - cause: err.cause || err
474 - }
475 - )
476 - }
477 -
478 - throw _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_2__["default"].from(err, err && err.code, config, request);
479 - }
480 - }
481 -}
482 -
483 -const seedCache = new Map();
484 -
485 -const getFetch = (config) => {
486 - let env = (config && config.env) || {};
487 - const {fetch, Request, Response} = env;
488 - const seeds = [
489 - Request, Response, fetch
490 - ];
491 -
492 - let len = seeds.length, i = len,
493 - seed, target, map = seedCache;
494 -
495 - while (i--) {
496 - seed = seeds[i];
497 - target = map.get(seed);
498 -
499 - target === undefined && map.set(seed, target = (i ? new Map() : factory(env)))
500 -
501 - map = target;
502 - }
503 -
504 - return target;
505 -};
506 -
507 -const adapter = getFetch();
508 -
509 -/* harmony default export */ __webpack_exports__["default"] = (adapter);
510 -
511 -
512 -/***/ }),
513 -
514 -/***/ "./node_modules/axios/lib/adapters/xhr.js":
515 -/*!************************************************!*\
516 - !*** ./node_modules/axios/lib/adapters/xhr.js ***!
517 - \************************************************/
518 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
519 -
520 -__webpack_require__.r(__webpack_exports__);
521 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js");
522 -/* harmony import */ var _core_settle_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./../core/settle.js */ "./node_modules/axios/lib/core/settle.js");
523 -/* harmony import */ var _defaults_transitional_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../defaults/transitional.js */ "./node_modules/axios/lib/defaults/transitional.js");
524 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
525 -/* harmony import */ var _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../cancel/CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js");
526 -/* harmony import */ var _helpers_parseProtocol_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../helpers/parseProtocol.js */ "./node_modules/axios/lib/helpers/parseProtocol.js");
527 -/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js");
528 -/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js");
529 -/* harmony import */ var _helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ../helpers/progressEventReducer.js */ "./node_modules/axios/lib/helpers/progressEventReducer.js");
530 -/* harmony import */ var _helpers_resolveConfig_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ../helpers/resolveConfig.js */ "./node_modules/axios/lib/helpers/resolveConfig.js");
531 -
532 -
533 -
534 -
535 -
536 -
537 -
538 -
539 -
540 -
541 -
542 -const isXHRAdapterSupported = typeof XMLHttpRequest !== 'undefined';
543 -
544 -/* harmony default export */ __webpack_exports__["default"] = (isXHRAdapterSupported && function (config) {
545 - return new Promise(function dispatchXhrRequest(resolve, reject) {
546 - const _config = (0,_helpers_resolveConfig_js__WEBPACK_IMPORTED_MODULE_9__["default"])(config);
547 - let requestData = _config.data;
548 - const requestHeaders = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_7__["default"].from(_config.headers).normalize();
549 - let {responseType, onUploadProgress, onDownloadProgress} = _config;
550 - let onCanceled;
551 - let uploadThrottled, downloadThrottled;
552 - let flushUpload, flushDownload;
553 -
554 - function done() {
555 - flushUpload && flushUpload(); // flush events
556 - flushDownload && flushDownload(); // flush events
557 -
558 - _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
559 -
560 - _config.signal && _config.signal.removeEventListener('abort', onCanceled);
561 - }
562 -
563 - let request = new XMLHttpRequest();
564 -
565 - request.open(_config.method.toUpperCase(), _config.url, true);
566 -
567 - // Set the request timeout in MS
568 - request.timeout = _config.timeout;
569 -
570 - function onloadend() {
571 - if (!request) {
572 - return;
573 - }
574 - // Prepare the response
575 - const responseHeaders = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_7__["default"].from(
576 - 'getAllResponseHeaders' in request && request.getAllResponseHeaders()
577 - );
578 - const responseData = !responseType || responseType === 'text' || responseType === 'json' ?
579 - request.responseText : request.response;
580 - const response = {
581 - data: responseData,
582 - status: request.status,
583 - statusText: request.statusText,
584 - headers: responseHeaders,
585 - config,
586 - request
587 - };
588 -
589 - (0,_core_settle_js__WEBPACK_IMPORTED_MODULE_1__["default"])(function _resolve(value) {
590 - resolve(value);
591 - done();
592 - }, function _reject(err) {
593 - reject(err);
594 - done();
595 - }, response);
596 -
597 - // Clean up request
598 - request = null;
599 - }
600 -
601 - if ('onloadend' in request) {
602 - // Use onloadend if available
603 - request.onloadend = onloadend;
604 - } else {
605 - // Listen for ready state to emulate onloadend
606 - request.onreadystatechange = function handleLoad() {
607 - if (!request || request.readyState !== 4) {
608 - return;
609 - }
610 -
611 - // The request errored out and we didn't get a response, this will be
612 - // handled by onerror instead
613 - // With one exception: request that using file: protocol, most browsers
614 - // will return status as 0 even though it's a successful request
615 - if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
616 - return;
617 - }
618 - // readystate handler is calling before onerror or ontimeout handlers,
619 - // so we should call onloadend on the next 'tick'
620 - setTimeout(onloadend);
621 - };
622 - }
623 -
624 - // Handle browser request cancellation (as opposed to a manual cancellation)
625 - request.onabort = function handleAbort() {
626 - if (!request) {
627 - return;
628 - }
629 -
630 - reject(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Request aborted', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ECONNABORTED, config, request));
631 -
632 - // Clean up request
633 - request = null;
634 - };
635 -
636 - // Handle low level network errors
637 - request.onerror = function handleError(event) {
638 - // Browsers deliver a ProgressEvent in XHR onerror
639 - // (message may be empty; when present, surface it)
640 - // See https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/error_event
641 - const msg = event && event.message ? event.message : 'Network Error';
642 - const err = new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"](msg, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ERR_NETWORK, config, request);
643 - // attach the underlying event for consumers who want details
644 - err.event = event || null;
645 - reject(err);
646 - request = null;
647 - };
648 -
649 - // Handle timeout
650 - request.ontimeout = function handleTimeout() {
651 - let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';
652 - const transitional = _config.transitional || _defaults_transitional_js__WEBPACK_IMPORTED_MODULE_2__["default"];
653 - if (_config.timeoutErrorMessage) {
654 - timeoutErrorMessage = _config.timeoutErrorMessage;
655 - }
656 - reject(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"](
657 - timeoutErrorMessage,
658 - transitional.clarifyTimeoutError ? _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ETIMEDOUT : _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ECONNABORTED,
659 - config,
660 - request));
661 -
662 - // Clean up request
663 - request = null;
664 - };
665 -
666 - // Remove Content-Type if data is undefined
667 - requestData === undefined && requestHeaders.setContentType(null);
668 -
669 - // Add headers to the request
670 - if ('setRequestHeader' in request) {
671 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
672 - request.setRequestHeader(key, val);
673 - });
674 - }
675 -
676 - // Add withCredentials to request if needed
677 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(_config.withCredentials)) {
678 - request.withCredentials = !!_config.withCredentials;
679 - }
680 -
681 - // Add responseType to request if needed
682 - if (responseType && responseType !== 'json') {
683 - request.responseType = _config.responseType;
684 - }
685 -
686 - // Handle progress if needed
687 - if (onDownloadProgress) {
688 - ([downloadThrottled, flushDownload] = (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_8__.progressEventReducer)(onDownloadProgress, true));
689 - request.addEventListener('progress', downloadThrottled);
690 - }
691 -
692 - // Not all browsers support upload events
693 - if (onUploadProgress && request.upload) {
694 - ([uploadThrottled, flushUpload] = (0,_helpers_progressEventReducer_js__WEBPACK_IMPORTED_MODULE_8__.progressEventReducer)(onUploadProgress));
695 -
696 - request.upload.addEventListener('progress', uploadThrottled);
697 -
698 - request.upload.addEventListener('loadend', flushUpload);
699 - }
700 -
701 - if (_config.cancelToken || _config.signal) {
702 - // Handle cancellation
703 - // eslint-disable-next-line func-names
704 - onCanceled = cancel => {
705 - if (!request) {
706 - return;
707 - }
708 - reject(!cancel || cancel.type ? new _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_4__["default"](null, config, request) : cancel);
709 - request.abort();
710 - request = null;
711 - };
712 -
713 - _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
714 - if (_config.signal) {
715 - _config.signal.aborted ? onCanceled() : _config.signal.addEventListener('abort', onCanceled);
716 - }
717 - }
718 -
719 - const protocol = (0,_helpers_parseProtocol_js__WEBPACK_IMPORTED_MODULE_5__["default"])(_config.url);
720 -
721 - if (protocol && _platform_index_js__WEBPACK_IMPORTED_MODULE_6__["default"].protocols.indexOf(protocol) === -1) {
722 - reject(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"]('Unsupported protocol ' + protocol + ':', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_3__["default"].ERR_BAD_REQUEST, config));
723 - return;
724 - }
725 -
726 -
727 - // Send the request
728 - request.send(requestData || null);
729 - });
730 -});
731 -
732 -
733 -/***/ }),
734 -
735 -/***/ "./node_modules/axios/lib/axios.js":
736 -/*!*****************************************!*\
737 - !*** ./node_modules/axios/lib/axios.js ***!
738 - \*****************************************/
739 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
740 -
741 -__webpack_require__.r(__webpack_exports__);
742 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./utils.js */ "./node_modules/axios/lib/utils.js");
743 -/* harmony import */ var _helpers_bind_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./helpers/bind.js */ "./node_modules/axios/lib/helpers/bind.js");
744 -/* harmony import */ var _core_Axios_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./core/Axios.js */ "./node_modules/axios/lib/core/Axios.js");
745 -/* harmony import */ var _core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./core/mergeConfig.js */ "./node_modules/axios/lib/core/mergeConfig.js");
746 -/* harmony import */ var _defaults_index_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./defaults/index.js */ "./node_modules/axios/lib/defaults/index.js");
747 -/* harmony import */ var _helpers_formDataToJSON_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./helpers/formDataToJSON.js */ "./node_modules/axios/lib/helpers/formDataToJSON.js");
748 -/* harmony import */ var _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./cancel/CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js");
749 -/* harmony import */ var _cancel_CancelToken_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./cancel/CancelToken.js */ "./node_modules/axios/lib/cancel/CancelToken.js");
750 -/* harmony import */ var _cancel_isCancel_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./cancel/isCancel.js */ "./node_modules/axios/lib/cancel/isCancel.js");
751 -/* harmony import */ var _env_data_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./env/data.js */ "./node_modules/axios/lib/env/data.js");
752 -/* harmony import */ var _helpers_toFormData_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./helpers/toFormData.js */ "./node_modules/axios/lib/helpers/toFormData.js");
753 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
754 -/* harmony import */ var _helpers_spread_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./helpers/spread.js */ "./node_modules/axios/lib/helpers/spread.js");
755 -/* harmony import */ var _helpers_isAxiosError_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./helpers/isAxiosError.js */ "./node_modules/axios/lib/helpers/isAxiosError.js");
756 -/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js");
757 -/* harmony import */ var _adapters_adapters_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./adapters/adapters.js */ "./node_modules/axios/lib/adapters/adapters.js");
758 -/* harmony import */ var _helpers_HttpStatusCode_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./helpers/HttpStatusCode.js */ "./node_modules/axios/lib/helpers/HttpStatusCode.js");
759 -
760 -
761 -
762 -
763 -
764 -
765 -
766 -
767 -
768 -
769 -
770 -
771 -
772 -
773 -
774 -
775 -
776 -
777 -
778 -
1116 +//#endregion
1117 +//#region node_modules/axios/lib/helpers/formDataToJSON.js
779 1118 /**
780 - * Create an instance of Axios
781 - *
782 - * @param {Object} defaultConfig The default config for the instance
783 - *
784 - * @returns {Axios} A new instance of Axios
785 - */
786 -function createInstance(defaultConfig) {
787 - const context = new _core_Axios_js__WEBPACK_IMPORTED_MODULE_2__["default"](defaultConfig);
788 - const instance = (0,_helpers_bind_js__WEBPACK_IMPORTED_MODULE_1__["default"])(_core_Axios_js__WEBPACK_IMPORTED_MODULE_2__["default"].prototype.request, context);
1119 + * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
1120 + *
1121 + * @param {string} name - The name of the property to get.
1122 + *
1123 + * @returns An array of strings.
1124 + */
1125 + function parsePropPath(name) {
1126 + return utils_default.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
1127 + return match[0] === "[]" ? "" : match[1] || match[0];
1128 + });
1129 + }
1130 + /**
1131 + * Convert an array to an object.
1132 + *
1133 + * @param {Array<any>} arr - The array to convert to an object.
1134 + *
1135 + * @returns An object with the same keys and values as the array.
1136 + */
1137 + function arrayToObject(arr) {
1138 + const obj = {};
1139 + const keys = Object.keys(arr);
1140 + let i;
1141 + const len = keys.length;
1142 + let key;
1143 + for (i = 0; i < len; i++) {
1144 + key = keys[i];
1145 + obj[key] = arr[key];
1146 + }
1147 + return obj;
1148 + }
1149 + /**
1150 + * It takes a FormData object and returns a JavaScript object
1151 + *
1152 + * @param {string} formData The FormData object to convert to JSON.
1153 + *
1154 + * @returns {Object<string, any> | null} The converted object.
1155 + */
1156 + function formDataToJSON(formData) {
1157 + function buildPath(path, value, target, index) {
1158 + let name = path[index++];
1159 + if (name === "__proto__") return true;
1160 + const isNumericKey = Number.isFinite(+name);
1161 + const isLast = index >= path.length;
1162 + name = !name && utils_default.isArray(target) ? target.length : name;
1163 + if (isLast) {
1164 + if (utils_default.hasOwnProp(target, name)) target[name] = [target[name], value];
1165 + else target[name] = value;
1166 + return !isNumericKey;
1167 + }
1168 + if (!target[name] || !utils_default.isObject(target[name])) target[name] = [];
1169 + if (buildPath(path, value, target[name], index) && utils_default.isArray(target[name])) target[name] = arrayToObject(target[name]);
1170 + return !isNumericKey;
1171 + }
1172 + if (utils_default.isFormData(formData) && utils_default.isFunction(formData.entries)) {
1173 + const obj = {};
1174 + utils_default.forEachEntry(formData, (name, value) => {
1175 + buildPath(parsePropPath(name), value, obj, 0);
1176 + });
1177 + return obj;
1178 + }
1179 + return null;
1180 + }
789 1181
790 - // Copy axios.prototype to instance
791 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].extend(instance, _core_Axios_js__WEBPACK_IMPORTED_MODULE_2__["default"].prototype, context, {allOwnKeys: true});
792 -
793 - // Copy context to instance
794 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].extend(instance, context, null, {allOwnKeys: true});
795 -
796 - // Factory for creating new instances
797 - instance.create = function create(instanceConfig) {
798 - return createInstance((0,_core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_3__["default"])(defaultConfig, instanceConfig));
799 - };
800 -
801 - return instance;
802 -}
803 -
804 -// Create the default instance to be exported
805 -const axios = createInstance(_defaults_index_js__WEBPACK_IMPORTED_MODULE_4__["default"]);
806 -
807 -// Expose Axios class to allow class inheritance
808 -axios.Axios = _core_Axios_js__WEBPACK_IMPORTED_MODULE_2__["default"];
809 -
810 -// Expose Cancel & CancelToken
811 -axios.CanceledError = _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_6__["default"];
812 -axios.CancelToken = _cancel_CancelToken_js__WEBPACK_IMPORTED_MODULE_7__["default"];
813 -axios.isCancel = _cancel_isCancel_js__WEBPACK_IMPORTED_MODULE_8__["default"];
814 -axios.VERSION = _env_data_js__WEBPACK_IMPORTED_MODULE_9__.VERSION;
815 -axios.toFormData = _helpers_toFormData_js__WEBPACK_IMPORTED_MODULE_10__["default"];
816 -
817 -// Expose AxiosError class
818 -axios.AxiosError = _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_11__["default"];
819 -
820 -// alias for CanceledError for backward compatibility
821 -axios.Cancel = axios.CanceledError;
822 -
823 -// Expose all/spread
824 -axios.all = function all(promises) {
825 - return Promise.all(promises);
826 -};
827 -
828 -axios.spread = _helpers_spread_js__WEBPACK_IMPORTED_MODULE_12__["default"];
829 -
830 -// Expose isAxiosError
831 -axios.isAxiosError = _helpers_isAxiosError_js__WEBPACK_IMPORTED_MODULE_13__["default"];
832 -
833 -// Expose mergeConfig
834 -axios.mergeConfig = _core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_3__["default"];
835 -
836 -axios.AxiosHeaders = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_14__["default"];
837 -
838 -axios.formToJSON = thing => (0,_helpers_formDataToJSON_js__WEBPACK_IMPORTED_MODULE_5__["default"])(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isHTMLForm(thing) ? new FormData(thing) : thing);
839 -
840 -axios.getAdapter = _adapters_adapters_js__WEBPACK_IMPORTED_MODULE_15__["default"].getAdapter;
841 -
842 -axios.HttpStatusCode = _helpers_HttpStatusCode_js__WEBPACK_IMPORTED_MODULE_16__["default"];
843 -
844 -axios.default = axios;
845 -
846 -// this module should only have a default export
847 -/* harmony default export */ __webpack_exports__["default"] = (axios);
848 -
849 -
850 -/***/ }),
851 -
852 -/***/ "./node_modules/axios/lib/cancel/CancelToken.js":
853 -/*!******************************************************!*\
854 - !*** ./node_modules/axios/lib/cancel/CancelToken.js ***!
855 - \******************************************************/
856 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
857 -
858 -__webpack_require__.r(__webpack_exports__);
859 -/* harmony import */ var _CanceledError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js");
860 -
861 -
862 -
863 -
1182 +//#endregion
1183 +//#region node_modules/axios/lib/defaults/index.js
864 1184 /**
865 - * A `CancelToken` is an object that can be used to request cancellation of an operation.
866 - *
867 - * @param {Function} executor The executor function.
868 - *
869 - * @returns {CancelToken}
870 - */
871 -class CancelToken {
872 - constructor(executor) {
873 - if (typeof executor !== 'function') {
874 - throw new TypeError('executor must be a function.');
875 - }
1185 + * It takes a string, tries to parse it, and if it fails, it returns the stringified version
1186 + * of the input
1187 + *
1188 + * @param {any} rawValue - The value to be stringified.
1189 + * @param {Function} parser - A function that parses a string into a JavaScript object.
1190 + * @param {Function} encoder - A function that takes a value and returns a string.
1191 + *
1192 + * @returns {string} A stringified version of the rawValue.
1193 + */
1194 + function stringifySafely(rawValue, parser, encoder) {
1195 + if (utils_default.isString(rawValue)) try {
1196 + (parser || JSON.parse)(rawValue);
1197 + return utils_default.trim(rawValue);
1198 + } catch (e) {
1199 + if (e.name !== "SyntaxError") throw e;
1200 + }
1201 + return (encoder || JSON.stringify)(rawValue);
1202 + }
1203 + var defaults = {
1204 + transitional: transitional_default,
1205 + adapter: [
1206 + "xhr",
1207 + "http",
1208 + "fetch"
1209 + ],
1210 + transformRequest: [function transformRequest(data, headers) {
1211 + const contentType = headers.getContentType() || "";
1212 + const hasJSONContentType = contentType.indexOf("application/json") > -1;
1213 + const isObjectPayload = utils_default.isObject(data);
1214 + if (isObjectPayload && utils_default.isHTMLForm(data)) data = new FormData(data);
1215 + if (utils_default.isFormData(data)) return hasJSONContentType ? JSON.stringify(formDataToJSON(data)) : data;
1216 + if (utils_default.isArrayBuffer(data) || utils_default.isBuffer(data) || utils_default.isStream(data) || utils_default.isFile(data) || utils_default.isBlob(data) || utils_default.isReadableStream(data)) return data;
1217 + if (utils_default.isArrayBufferView(data)) return data.buffer;
1218 + if (utils_default.isURLSearchParams(data)) {
1219 + headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false);
1220 + return data.toString();
1221 + }
1222 + let isFileList;
1223 + if (isObjectPayload) {
1224 + if (contentType.indexOf("application/x-www-form-urlencoded") > -1) return toURLEncodedForm(data, this.formSerializer).toString();
1225 + if ((isFileList = utils_default.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
1226 + const _FormData = this.env && this.env.FormData;
1227 + return toFormData$1(isFileList ? { "files[]": data } : data, _FormData && new _FormData(), this.formSerializer);
1228 + }
1229 + }
1230 + if (isObjectPayload || hasJSONContentType) {
1231 + headers.setContentType("application/json", false);
1232 + return stringifySafely(data);
1233 + }
1234 + return data;
1235 + }],
1236 + transformResponse: [function transformResponse(data) {
1237 + const transitional = this.transitional || defaults.transitional;
1238 + const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
1239 + const JSONRequested = this.responseType === "json";
1240 + if (utils_default.isResponse(data) || utils_default.isReadableStream(data)) return data;
1241 + if (data && utils_default.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
1242 + const strictJSONParsing = !(transitional && transitional.silentJSONParsing) && JSONRequested;
1243 + try {
1244 + return JSON.parse(data, this.parseReviver);
1245 + } catch (e) {
1246 + if (strictJSONParsing) {
1247 + if (e.name === "SyntaxError") throw AxiosError$1.from(e, AxiosError$1.ERR_BAD_RESPONSE, this, null, this.response);
1248 + throw e;
1249 + }
1250 + }
1251 + }
1252 + return data;
1253 + }],
1254 + /**
1255 + * A timeout in milliseconds to abort a request. If set to 0 (default) a
1256 + * timeout is not created.
1257 + */
1258 + timeout: 0,
1259 + xsrfCookieName: "XSRF-TOKEN",
1260 + xsrfHeaderName: "X-XSRF-TOKEN",
1261 + maxContentLength: -1,
1262 + maxBodyLength: -1,
1263 + env: {
1264 + FormData: platform_default.classes.FormData,
1265 + Blob: platform_default.classes.Blob
1266 + },
1267 + validateStatus: function validateStatus(status) {
1268 + return status >= 200 && status < 300;
1269 + },
1270 + headers: { common: {
1271 + "Accept": "application/json, text/plain, */*",
1272 + "Content-Type": void 0
1273 + } }
1274 + };
1275 + utils_default.forEach([
1276 + "delete",
1277 + "get",
1278 + "head",
1279 + "post",
1280 + "put",
1281 + "patch"
1282 + ], (method) => {
1283 + defaults.headers[method] = {};
1284 + });
876 1285
877 - let resolvePromise;
1286 +//#endregion
1287 +//#region node_modules/axios/lib/helpers/parseHeaders.js
1288 + var ignoreDuplicateOf = utils_default.toObjectSet([
1289 + "age",
1290 + "authorization",
1291 + "content-length",
1292 + "content-type",
1293 + "etag",
1294 + "expires",
1295 + "from",
1296 + "host",
1297 + "if-modified-since",
1298 + "if-unmodified-since",
1299 + "last-modified",
1300 + "location",
1301 + "max-forwards",
1302 + "proxy-authorization",
1303 + "referer",
1304 + "retry-after",
1305 + "user-agent"
1306 + ]);
1307 + /**
1308 + * Parse headers into an object
1309 + *
1310 + * ```
1311 + * Date: Wed, 27 Aug 2014 08:58:49 GMT
1312 + * Content-Type: application/json
1313 + * Connection: keep-alive
1314 + * Transfer-Encoding: chunked
1315 + * ```
1316 + *
1317 + * @param {String} rawHeaders Headers needing to be parsed
1318 + *
1319 + * @returns {Object} Headers parsed into an object
1320 + */
1321 + var parseHeaders_default = /* @__PURE__ */ __name((rawHeaders) => {
1322 + const parsed = {};
1323 + let key;
1324 + let val;
1325 + let i;
1326 + rawHeaders && rawHeaders.split("\n").forEach(function parser(line) {
1327 + i = line.indexOf(":");
1328 + key = line.substring(0, i).trim().toLowerCase();
1329 + val = line.substring(i + 1).trim();
1330 + if (!key || parsed[key] && ignoreDuplicateOf[key]) return;
1331 + if (key === "set-cookie") if (parsed[key]) parsed[key].push(val);
1332 + else parsed[key] = [val];
1333 + else parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
1334 + });
1335 + return parsed;
1336 + }, "default");
878 1337
879 - this.promise = new Promise(function promiseExecutor(resolve) {
880 - resolvePromise = resolve;
881 - });
1338 +//#endregion
1339 +//#region node_modules/axios/lib/core/AxiosHeaders.js
1340 + var $internals = Symbol("internals");
1341 + function normalizeHeader(header) {
1342 + return header && String(header).trim().toLowerCase();
1343 + }
1344 + function normalizeValue(value) {
1345 + if (value === false || value == null) return value;
1346 + return utils_default.isArray(value) ? value.map(normalizeValue) : String(value);
1347 + }
1348 + function parseTokens(str) {
1349 + const tokens = Object.create(null);
1350 + const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
1351 + let match;
1352 + while (match = tokensRE.exec(str)) tokens[match[1]] = match[2];
1353 + return tokens;
1354 + }
1355 + var isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
1356 + function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
1357 + if (utils_default.isFunction(filter)) return filter.call(this, value, header);
1358 + if (isHeaderNameFilter) value = header;
1359 + if (!utils_default.isString(value)) return;
1360 + if (utils_default.isString(filter)) return value.indexOf(filter) !== -1;
1361 + if (utils_default.isRegExp(filter)) return filter.test(value);
1362 + }
1363 + function formatHeader(header) {
1364 + return header.trim().toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
1365 + return char.toUpperCase() + str;
1366 + });
1367 + }
1368 + function buildAccessors(obj, header) {
1369 + const accessorName = utils_default.toCamelCase(" " + header);
1370 + [
1371 + "get",
1372 + "set",
1373 + "has"
1374 + ].forEach((methodName) => {
1375 + Object.defineProperty(obj, methodName + accessorName, {
1376 + value: function(arg1, arg2, arg3) {
1377 + return this[methodName].call(this, header, arg1, arg2, arg3);
1378 + },
1379 + configurable: true
1380 + });
1381 + });
1382 + }
1383 + var AxiosHeaders$1 = class {
1384 + static {
1385 + __name(this, "AxiosHeaders");
1386 + }
1387 + constructor(headers) {
1388 + headers && this.set(headers);
1389 + }
1390 + set(header, valueOrRewrite, rewrite) {
1391 + const self = this;
1392 + function setHeader(_value, _header, _rewrite) {
1393 + const lHeader = normalizeHeader(_header);
1394 + if (!lHeader) throw new Error("header name must be a non-empty string");
1395 + const key = utils_default.findKey(self, lHeader);
1396 + if (!key || self[key] === void 0 || _rewrite === true || _rewrite === void 0 && self[key] !== false) self[key || _header] = normalizeValue(_value);
1397 + }
1398 + const setHeaders = (headers, _rewrite) => utils_default.forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
1399 + if (utils_default.isPlainObject(header) || header instanceof this.constructor) setHeaders(header, valueOrRewrite);
1400 + else if (utils_default.isString(header) && (header = header.trim()) && !isValidHeaderName(header)) setHeaders(parseHeaders_default(header), valueOrRewrite);
1401 + else if (utils_default.isObject(header) && utils_default.isIterable(header)) {
1402 + let obj = {};
1403 + let dest;
1404 + let key;
1405 + for (const entry of header) {
1406 + if (!utils_default.isArray(entry)) throw TypeError("Object iterator must return a key-value pair");
1407 + obj[key = entry[0]] = (dest = obj[key]) ? utils_default.isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]] : entry[1];
1408 + }
1409 + setHeaders(obj, valueOrRewrite);
1410 + } else header != null && setHeader(valueOrRewrite, header, rewrite);
1411 + return this;
1412 + }
1413 + get(header, parser) {
1414 + header = normalizeHeader(header);
1415 + if (header) {
1416 + const key = utils_default.findKey(this, header);
1417 + if (key) {
1418 + const value = this[key];
1419 + if (!parser) return value;
1420 + if (parser === true) return parseTokens(value);
1421 + if (utils_default.isFunction(parser)) return parser.call(this, value, key);
1422 + if (utils_default.isRegExp(parser)) return parser.exec(value);
1423 + throw new TypeError("parser must be boolean|regexp|function");
1424 + }
1425 + }
1426 + }
1427 + has(header, matcher) {
1428 + header = normalizeHeader(header);
1429 + if (header) {
1430 + const key = utils_default.findKey(this, header);
1431 + return !!(key && this[key] !== void 0 && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
1432 + }
1433 + return false;
1434 + }
1435 + delete(header, matcher) {
1436 + const self = this;
1437 + let deleted = false;
1438 + function deleteHeader(_header) {
1439 + _header = normalizeHeader(_header);
1440 + if (_header) {
1441 + const key = utils_default.findKey(self, _header);
1442 + if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
1443 + delete self[key];
1444 + deleted = true;
1445 + }
1446 + }
1447 + }
1448 + if (utils_default.isArray(header)) header.forEach(deleteHeader);
1449 + else deleteHeader(header);
1450 + return deleted;
1451 + }
1452 + clear(matcher) {
1453 + const keys = Object.keys(this);
1454 + let i = keys.length;
1455 + let deleted = false;
1456 + while (i--) {
1457 + const key = keys[i];
1458 + if (!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
1459 + delete this[key];
1460 + deleted = true;
1461 + }
1462 + }
1463 + return deleted;
1464 + }
1465 + normalize(format) {
1466 + const self = this;
1467 + const headers = {};
1468 + utils_default.forEach(this, (value, header) => {
1469 + const key = utils_default.findKey(headers, header);
1470 + if (key) {
1471 + self[key] = normalizeValue(value);
1472 + delete self[header];
1473 + return;
1474 + }
1475 + const normalized = format ? formatHeader(header) : String(header).trim();
1476 + if (normalized !== header) delete self[header];
1477 + self[normalized] = normalizeValue(value);
1478 + headers[normalized] = true;
1479 + });
1480 + return this;
1481 + }
1482 + concat(...targets) {
1483 + return this.constructor.concat(this, ...targets);
1484 + }
1485 + toJSON(asStrings) {
1486 + const obj = Object.create(null);
1487 + utils_default.forEach(this, (value, header) => {
1488 + value != null && value !== false && (obj[header] = asStrings && utils_default.isArray(value) ? value.join(", ") : value);
1489 + });
1490 + return obj;
1491 + }
1492 + [Symbol.iterator]() {
1493 + return Object.entries(this.toJSON())[Symbol.iterator]();
1494 + }
1495 + toString() {
1496 + return Object.entries(this.toJSON()).map(([header, value]) => header + ": " + value).join("\n");
1497 + }
1498 + getSetCookie() {
1499 + return this.get("set-cookie") || [];
1500 + }
1501 + get [Symbol.toStringTag]() {
1502 + return "AxiosHeaders";
1503 + }
1504 + static from(thing) {
1505 + return thing instanceof this ? thing : new this(thing);
1506 + }
1507 + static concat(first, ...targets) {
1508 + const computed = new this(first);
1509 + targets.forEach((target) => computed.set(target));
1510 + return computed;
1511 + }
1512 + static accessor(header) {
1513 + const accessors = (this[$internals] = this[$internals] = { accessors: {} }).accessors;
1514 + const prototype = this.prototype;
1515 + function defineAccessor(_header) {
1516 + const lHeader = normalizeHeader(_header);
1517 + if (!accessors[lHeader]) {
1518 + buildAccessors(prototype, _header);
1519 + accessors[lHeader] = true;
1520 + }
1521 + }
1522 + utils_default.isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
1523 + return this;
1524 + }
1525 + };
1526 + AxiosHeaders$1.accessor([
1527 + "Content-Type",
1528 + "Content-Length",
1529 + "Accept",
1530 + "Accept-Encoding",
1531 + "User-Agent",
1532 + "Authorization"
1533 + ]);
1534 + utils_default.reduceDescriptors(AxiosHeaders$1.prototype, ({ value }, key) => {
1535 + let mapped = key[0].toUpperCase() + key.slice(1);
1536 + return {
1537 + get: () => value,
1538 + set(headerValue) {
1539 + this[mapped] = headerValue;
1540 + }
1541 + };
1542 + });
1543 + utils_default.freezeMethods(AxiosHeaders$1);
882 1544
883 - const token = this;
884 -
885 - // eslint-disable-next-line func-names
886 - this.promise.then(cancel => {
887 - if (!token._listeners) return;
888 -
889 - let i = token._listeners.length;
890 -
891 - while (i-- > 0) {
892 - token._listeners[i](cancel);
893 - }
894 - token._listeners = null;
895 - });
896 -
897 - // eslint-disable-next-line func-names
898 - this.promise.then = onfulfilled => {
899 - let _resolve;
900 - // eslint-disable-next-line func-names
901 - const promise = new Promise(resolve => {
902 - token.subscribe(resolve);
903 - _resolve = resolve;
904 - }).then(onfulfilled);
905 -
906 - promise.cancel = function reject() {
907 - token.unsubscribe(_resolve);
908 - };
909 -
910 - return promise;
911 - };
912 -
913 - executor(function cancel(message, config, request) {
914 - if (token.reason) {
915 - // Cancellation has already been requested
916 - return;
917 - }
918 -
919 - token.reason = new _CanceledError_js__WEBPACK_IMPORTED_MODULE_0__["default"](message, config, request);
920 - resolvePromise(token.reason);
921 - });
922 - }
923 -
924 - /**
925 - * Throws a `CanceledError` if cancellation has been requested.
926 - */
927 - throwIfRequested() {
928 - if (this.reason) {
929 - throw this.reason;
930 - }
931 - }
932 -
933 - /**
934 - * Subscribe to the cancel signal
935 - */
936 -
937 - subscribe(listener) {
938 - if (this.reason) {
939 - listener(this.reason);
940 - return;
941 - }
942 -
943 - if (this._listeners) {
944 - this._listeners.push(listener);
945 - } else {
946 - this._listeners = [listener];
947 - }
948 - }
949 -
950 - /**
951 - * Unsubscribe from the cancel signal
952 - */
953 -
954 - unsubscribe(listener) {
955 - if (!this._listeners) {
956 - return;
957 - }
958 - const index = this._listeners.indexOf(listener);
959 - if (index !== -1) {
960 - this._listeners.splice(index, 1);
961 - }
962 - }
963 -
964 - toAbortSignal() {
965 - const controller = new AbortController();
966 -
967 - const abort = (err) => {
968 - controller.abort(err);
969 - };
970 -
971 - this.subscribe(abort);
972 -
973 - controller.signal.unsubscribe = () => this.unsubscribe(abort);
974 -
975 - return controller.signal;
976 - }
977 -
978 - /**
979 - * Returns an object that contains a new `CancelToken` and a function that, when called,
980 - * cancels the `CancelToken`.
981 - */
982 - static source() {
983 - let cancel;
984 - const token = new CancelToken(function executor(c) {
985 - cancel = c;
986 - });
987 - return {
988 - token,
989 - cancel
990 - };
991 - }
992 -}
993 -
994 -/* harmony default export */ __webpack_exports__["default"] = (CancelToken);
995 -
996 -
997 -/***/ }),
998 -
999 -/***/ "./node_modules/axios/lib/cancel/CanceledError.js":
1000 -/*!********************************************************!*\
1001 - !*** ./node_modules/axios/lib/cancel/CanceledError.js ***!
1002 - \********************************************************/
1003 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1004 -
1005 -__webpack_require__.r(__webpack_exports__);
1006 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
1007 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
1008 -
1009 -
1010 -
1011 -
1012 -
1545 +//#endregion
1546 +//#region node_modules/axios/lib/core/transformData.js
1013 1547 /**
1014 - * A `CanceledError` is an object that is thrown when an operation is canceled.
1015 - *
1016 - * @param {string=} message The message.
1017 - * @param {Object=} config The config.
1018 - * @param {Object=} request The request.
1019 - *
1020 - * @returns {CanceledError} The created error.
1021 - */
1022 -function CanceledError(message, config, request) {
1023 - // eslint-disable-next-line no-eq-null,eqeqeq
1024 - _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].call(this, message == null ? 'canceled' : message, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].ERR_CANCELED, config, request);
1025 - this.name = 'CanceledError';
1026 -}
1548 + * Transform the data for a request or a response
1549 + *
1550 + * @param {Array|Function} fns A single function or Array of functions
1551 + * @param {?Object} response The response object
1552 + *
1553 + * @returns {*} The resulting transformed data
1554 + */
1555 + function transformData(fns, response) {
1556 + const config = this || defaults;
1557 + const context = response || config;
1558 + const headers = AxiosHeaders$1.from(context.headers);
1559 + let data = context.data;
1560 + utils_default.forEach(fns, function transform(fn) {
1561 + data = fn.call(config, data, headers.normalize(), response ? response.status : void 0);
1562 + });
1563 + headers.normalize();
1564 + return data;
1565 + }
1027 1566
1028 -_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].inherits(CanceledError, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"], {
1029 - __CANCEL__: true
1030 -});
1567 +//#endregion
1568 +//#region node_modules/axios/lib/cancel/isCancel.js
1569 + function isCancel$1(value) {
1570 + return !!(value && value.__CANCEL__);
1571 + }
1572 + __name(isCancel$1, "isCancel");
1031 1573
1032 -/* harmony default export */ __webpack_exports__["default"] = (CanceledError);
1033 -
1034 -
1035 -/***/ }),
1036 -
1037 -/***/ "./node_modules/axios/lib/cancel/isCancel.js":
1038 -/*!***************************************************!*\
1039 - !*** ./node_modules/axios/lib/cancel/isCancel.js ***!
1040 - \***************************************************/
1041 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1042 -
1043 -__webpack_require__.r(__webpack_exports__);
1044 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1045 -/* harmony export */ "default": function() { return /* binding */ isCancel; }
1046 -/* harmony export */ });
1047 -
1048 -
1049 -function isCancel(value) {
1050 - return !!(value && value.__CANCEL__);
1051 -}
1052 -
1053 -
1054 -/***/ }),
1055 -
1056 -/***/ "./node_modules/axios/lib/core/Axios.js":
1057 -/*!**********************************************!*\
1058 - !*** ./node_modules/axios/lib/core/Axios.js ***!
1059 - \**********************************************/
1060 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1061 -
1062 -__webpack_require__.r(__webpack_exports__);
1063 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js");
1064 -/* harmony import */ var _helpers_buildURL_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../helpers/buildURL.js */ "./node_modules/axios/lib/helpers/buildURL.js");
1065 -/* harmony import */ var _InterceptorManager_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./InterceptorManager.js */ "./node_modules/axios/lib/core/InterceptorManager.js");
1066 -/* harmony import */ var _dispatchRequest_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./dispatchRequest.js */ "./node_modules/axios/lib/core/dispatchRequest.js");
1067 -/* harmony import */ var _mergeConfig_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./mergeConfig.js */ "./node_modules/axios/lib/core/mergeConfig.js");
1068 -/* harmony import */ var _buildFullPath_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./buildFullPath.js */ "./node_modules/axios/lib/core/buildFullPath.js");
1069 -/* harmony import */ var _helpers_validator_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../helpers/validator.js */ "./node_modules/axios/lib/helpers/validator.js");
1070 -/* harmony import */ var _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js");
1071 -
1072 -
1073 -
1074 -
1075 -
1076 -
1077 -
1078 -
1079 -
1080 -
1081 -
1082 -const validators = _helpers_validator_js__WEBPACK_IMPORTED_MODULE_6__["default"].validators;
1083 -
1574 +//#endregion
1575 +//#region node_modules/axios/lib/cancel/CanceledError.js
1084 1576 /**
1085 - * Create a new instance of Axios
1086 - *
1087 - * @param {Object} instanceConfig The default config for the instance
1088 - *
1089 - * @return {Axios} A new instance of Axios
1090 - */
1091 -class Axios {
1092 - constructor(instanceConfig) {
1093 - this.defaults = instanceConfig || {};
1094 - this.interceptors = {
1095 - request: new _InterceptorManager_js__WEBPACK_IMPORTED_MODULE_2__["default"](),
1096 - response: new _InterceptorManager_js__WEBPACK_IMPORTED_MODULE_2__["default"]()
1097 - };
1098 - }
1577 + * A `CanceledError` is an object that is thrown when an operation is canceled.
1578 + *
1579 + * @param {string=} message The message.
1580 + * @param {Object=} config The config.
1581 + * @param {Object=} request The request.
1582 + *
1583 + * @returns {CanceledError} The created error.
1584 + */
1585 + function CanceledError$1(message, config, request) {
1586 + AxiosError$1.call(this, message == null ? "canceled" : message, AxiosError$1.ERR_CANCELED, config, request);
1587 + this.name = "CanceledError";
1588 + }
1589 + __name(CanceledError$1, "CanceledError");
1590 + utils_default.inherits(CanceledError$1, AxiosError$1, { __CANCEL__: true });
1099 1591
1100 - /**
1101 - * Dispatch a request
1102 - *
1103 - * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
1104 - * @param {?Object} config
1105 - *
1106 - * @returns {Promise} The Promise to be fulfilled
1107 - */
1108 - async request(configOrUrl, config) {
1109 - try {
1110 - return await this._request(configOrUrl, config);
1111 - } catch (err) {
1112 - if (err instanceof Error) {
1113 - let dummy = {};
1114 -
1115 - Error.captureStackTrace ? Error.captureStackTrace(dummy) : (dummy = new Error());
1116 -
1117 - // slice off the Error: ... line
1118 - const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, '') : '';
1119 - try {
1120 - if (!err.stack) {
1121 - err.stack = stack;
1122 - // match without the 2 top stack lines
1123 - } else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ''))) {
1124 - err.stack += '\n' + stack
1125 - }
1126 - } catch (e) {
1127 - // ignore the case where "stack" is an un-writable property
1128 - }
1129 - }
1130 -
1131 - throw err;
1132 - }
1133 - }
1134 -
1135 - _request(configOrUrl, config) {
1136 - /*eslint no-param-reassign:0*/
1137 - // Allow for axios('example/url'[, config]) a la fetch API
1138 - if (typeof configOrUrl === 'string') {
1139 - config = config || {};
1140 - config.url = configOrUrl;
1141 - } else {
1142 - config = configOrUrl || {};
1143 - }
1144 -
1145 - config = (0,_mergeConfig_js__WEBPACK_IMPORTED_MODULE_4__["default"])(this.defaults, config);
1146 -
1147 - const {transitional, paramsSerializer, headers} = config;
1148 -
1149 - if (transitional !== undefined) {
1150 - _helpers_validator_js__WEBPACK_IMPORTED_MODULE_6__["default"].assertOptions(transitional, {
1151 - silentJSONParsing: validators.transitional(validators.boolean),
1152 - forcedJSONParsing: validators.transitional(validators.boolean),
1153 - clarifyTimeoutError: validators.transitional(validators.boolean)
1154 - }, false);
1155 - }
1156 -
1157 - if (paramsSerializer != null) {
1158 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(paramsSerializer)) {
1159 - config.paramsSerializer = {
1160 - serialize: paramsSerializer
1161 - }
1162 - } else {
1163 - _helpers_validator_js__WEBPACK_IMPORTED_MODULE_6__["default"].assertOptions(paramsSerializer, {
1164 - encode: validators.function,
1165 - serialize: validators.function
1166 - }, true);
1167 - }
1168 - }
1169 -
1170 - // Set config.allowAbsoluteUrls
1171 - if (config.allowAbsoluteUrls !== undefined) {
1172 - // do nothing
1173 - } else if (this.defaults.allowAbsoluteUrls !== undefined) {
1174 - config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
1175 - } else {
1176 - config.allowAbsoluteUrls = true;
1177 - }
1178 -
1179 - _helpers_validator_js__WEBPACK_IMPORTED_MODULE_6__["default"].assertOptions(config, {
1180 - baseUrl: validators.spelling('baseURL'),
1181 - withXsrfToken: validators.spelling('withXSRFToken')
1182 - }, true);
1183 -
1184 - // Set config.method
1185 - config.method = (config.method || this.defaults.method || 'get').toLowerCase();
1186 -
1187 - // Flatten headers
1188 - let contextHeaders = headers && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].merge(
1189 - headers.common,
1190 - headers[config.method]
1191 - );
1192 -
1193 - headers && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(
1194 - ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
1195 - (method) => {
1196 - delete headers[method];
1197 - }
1198 - );
1199 -
1200 - config.headers = _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_7__["default"].concat(contextHeaders, headers);
1201 -
1202 - // filter out skipped interceptors
1203 - const requestInterceptorChain = [];
1204 - let synchronousRequestInterceptors = true;
1205 - this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
1206 - if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
1207 - return;
1208 - }
1209 -
1210 - synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
1211 -
1212 - requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
1213 - });
1214 -
1215 - const responseInterceptorChain = [];
1216 - this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
1217 - responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
1218 - });
1219 -
1220 - let promise;
1221 - let i = 0;
1222 - let len;
1223 -
1224 - if (!synchronousRequestInterceptors) {
1225 - const chain = [_dispatchRequest_js__WEBPACK_IMPORTED_MODULE_3__["default"].bind(this), undefined];
1226 - chain.unshift(...requestInterceptorChain);
1227 - chain.push(...responseInterceptorChain);
1228 - len = chain.length;
1229 -
1230 - promise = Promise.resolve(config);
1231 -
1232 - while (i < len) {
1233 - promise = promise.then(chain[i++], chain[i++]);
1234 - }
1235 -
1236 - return promise;
1237 - }
1238 -
1239 - len = requestInterceptorChain.length;
1240 -
1241 - let newConfig = config;
1242 -
1243 - while (i < len) {
1244 - const onFulfilled = requestInterceptorChain[i++];
1245 - const onRejected = requestInterceptorChain[i++];
1246 - try {
1247 - newConfig = onFulfilled(newConfig);
1248 - } catch (error) {
1249 - onRejected.call(this, error);
1250 - break;
1251 - }
1252 - }
1253 -
1254 - try {
1255 - promise = _dispatchRequest_js__WEBPACK_IMPORTED_MODULE_3__["default"].call(this, newConfig);
1256 - } catch (error) {
1257 - return Promise.reject(error);
1258 - }
1259 -
1260 - i = 0;
1261 - len = responseInterceptorChain.length;
1262 -
1263 - while (i < len) {
1264 - promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
1265 - }
1266 -
1267 - return promise;
1268 - }
1269 -
1270 - getUri(config) {
1271 - config = (0,_mergeConfig_js__WEBPACK_IMPORTED_MODULE_4__["default"])(this.defaults, config);
1272 - const fullPath = (0,_buildFullPath_js__WEBPACK_IMPORTED_MODULE_5__["default"])(config.baseURL, config.url, config.allowAbsoluteUrls);
1273 - return (0,_helpers_buildURL_js__WEBPACK_IMPORTED_MODULE_1__["default"])(fullPath, config.params, config.paramsSerializer);
1274 - }
1275 -}
1276 -
1277 -// Provide aliases for supported request methods
1278 -_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
1279 - /*eslint func-names:0*/
1280 - Axios.prototype[method] = function(url, config) {
1281 - return this.request((0,_mergeConfig_js__WEBPACK_IMPORTED_MODULE_4__["default"])(config || {}, {
1282 - method,
1283 - url,
1284 - data: (config || {}).data
1285 - }));
1286 - };
1287 -});
1288 -
1289 -_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
1290 - /*eslint func-names:0*/
1291 -
1292 - function generateHTTPMethod(isForm) {
1293 - return function httpMethod(url, data, config) {
1294 - return this.request((0,_mergeConfig_js__WEBPACK_IMPORTED_MODULE_4__["default"])(config || {}, {
1295 - method,
1296 - headers: isForm ? {
1297 - 'Content-Type': 'multipart/form-data'
1298 - } : {},
1299 - url,
1300 - data
1301 - }));
1302 - };
1303 - }
1304 -
1305 - Axios.prototype[method] = generateHTTPMethod();
1306 -
1307 - Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
1308 -});
1309 -
1310 -/* harmony default export */ __webpack_exports__["default"] = (Axios);
1311 -
1312 -
1313 -/***/ }),
1314 -
1315 -/***/ "./node_modules/axios/lib/core/AxiosError.js":
1316 -/*!***************************************************!*\
1317 - !*** ./node_modules/axios/lib/core/AxiosError.js ***!
1318 - \***************************************************/
1319 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1320 -
1321 -__webpack_require__.r(__webpack_exports__);
1322 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
1323 -
1324 -
1325 -
1326 -
1592 +//#endregion
1593 +//#region node_modules/axios/lib/core/settle.js
1327 1594 /**
1328 - * Create an Error with the specified message, config, error code, request and response.
1329 - *
1330 - * @param {string} message The error message.
1331 - * @param {string} [code] The error code (for example, 'ECONNABORTED').
1332 - * @param {Object} [config] The config.
1333 - * @param {Object} [request] The request.
1334 - * @param {Object} [response] The response.
1335 - *
1336 - * @returns {Error} The created error.
1337 - */
1338 -function AxiosError(message, code, config, request, response) {
1339 - Error.call(this);
1595 + * Resolve or reject a Promise based on response status.
1596 + *
1597 + * @param {Function} resolve A function that resolves the promise.
1598 + * @param {Function} reject A function that rejects the promise.
1599 + * @param {object} response The response.
1600 + *
1601 + * @returns {object} The response.
1602 + */
1603 + function settle(resolve, reject, response) {
1604 + const validateStatus = response.config.validateStatus;
1605 + if (!response.status || !validateStatus || validateStatus(response.status)) resolve(response);
1606 + else 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));
1607 + }
1340 1608
1341 - if (Error.captureStackTrace) {
1342 - Error.captureStackTrace(this, this.constructor);
1343 - } else {
1344 - this.stack = (new Error()).stack;
1345 - }
1609 +//#endregion
1610 +//#region node_modules/axios/lib/helpers/parseProtocol.js
1611 + function parseProtocol(url) {
1612 + const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
1613 + return match && match[1] || "";
1614 + }
1346 1615
1347 - this.message = message;
1348 - this.name = 'AxiosError';
1349 - code && (this.code = code);
1350 - config && (this.config = config);
1351 - request && (this.request = request);
1352 - if (response) {
1353 - this.response = response;
1354 - this.status = response.status ? response.status : null;
1355 - }
1356 -}
1357 -
1358 -_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].inherits(AxiosError, Error, {
1359 - toJSON: function toJSON() {
1360 - return {
1361 - // Standard
1362 - message: this.message,
1363 - name: this.name,
1364 - // Microsoft
1365 - description: this.description,
1366 - number: this.number,
1367 - // Mozilla
1368 - fileName: this.fileName,
1369 - lineNumber: this.lineNumber,
1370 - columnNumber: this.columnNumber,
1371 - stack: this.stack,
1372 - // Axios
1373 - config: _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toJSONObject(this.config),
1374 - code: this.code,
1375 - status: this.status
1376 - };
1377 - }
1378 -});
1379 -
1380 -const prototype = AxiosError.prototype;
1381 -const descriptors = {};
1382 -
1383 -[
1384 - 'ERR_BAD_OPTION_VALUE',
1385 - 'ERR_BAD_OPTION',
1386 - 'ECONNABORTED',
1387 - 'ETIMEDOUT',
1388 - 'ERR_NETWORK',
1389 - 'ERR_FR_TOO_MANY_REDIRECTS',
1390 - 'ERR_DEPRECATED',
1391 - 'ERR_BAD_RESPONSE',
1392 - 'ERR_BAD_REQUEST',
1393 - 'ERR_CANCELED',
1394 - 'ERR_NOT_SUPPORT',
1395 - 'ERR_INVALID_URL'
1396 -// eslint-disable-next-line func-names
1397 -].forEach(code => {
1398 - descriptors[code] = {value: code};
1399 -});
1400 -
1401 -Object.defineProperties(AxiosError, descriptors);
1402 -Object.defineProperty(prototype, 'isAxiosError', {value: true});
1403 -
1404 -// eslint-disable-next-line func-names
1405 -AxiosError.from = (error, code, config, request, response, customProps) => {
1406 - const axiosError = Object.create(prototype);
1407 -
1408 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toFlatObject(error, axiosError, function filter(obj) {
1409 - return obj !== Error.prototype;
1410 - }, prop => {
1411 - return prop !== 'isAxiosError';
1412 - });
1413 -
1414 - const msg = error && error.message ? error.message : 'Error';
1415 -
1416 - // Prefer explicit code; otherwise copy the low-level error's code (e.g. ECONNREFUSED)
1417 - const errCode = code == null && error ? error.code : code;
1418 - AxiosError.call(axiosError, msg, errCode, config, request, response);
1419 -
1420 - // Chain the original error on the standard field; non-enumerable to avoid JSON noise
1421 - if (error && axiosError.cause == null) {
1422 - Object.defineProperty(axiosError, 'cause', { value: error, configurable: true });
1423 - }
1424 -
1425 - axiosError.name = (error && error.name) || 'Error';
1426 -
1427 - customProps && Object.assign(axiosError, customProps);
1428 -
1429 - return axiosError;
1430 -};
1431 -
1432 -/* harmony default export */ __webpack_exports__["default"] = (AxiosError);
1433 -
1434 -
1435 -/***/ }),
1436 -
1437 -/***/ "./node_modules/axios/lib/core/AxiosHeaders.js":
1438 -/*!*****************************************************!*\
1439 - !*** ./node_modules/axios/lib/core/AxiosHeaders.js ***!
1440 - \*****************************************************/
1441 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1442 -
1443 -__webpack_require__.r(__webpack_exports__);
1444 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
1445 -/* harmony import */ var _helpers_parseHeaders_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../helpers/parseHeaders.js */ "./node_modules/axios/lib/helpers/parseHeaders.js");
1446 -
1447 -
1448 -
1449 -
1450 -
1451 -const $internals = Symbol('internals');
1452 -
1453 -function normalizeHeader(header) {
1454 - return header && String(header).trim().toLowerCase();
1455 -}
1456 -
1457 -function normalizeValue(value) {
1458 - if (value === false || value == null) {
1459 - return value;
1460 - }
1461 -
1462 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(value) ? value.map(normalizeValue) : String(value);
1463 -}
1464 -
1465 -function parseTokens(str) {
1466 - const tokens = Object.create(null);
1467 - const tokensRE = /([^\s,;=]+)\s*(?:=\s*([^,;]+))?/g;
1468 - let match;
1469 -
1470 - while ((match = tokensRE.exec(str))) {
1471 - tokens[match[1]] = match[2];
1472 - }
1473 -
1474 - return tokens;
1475 -}
1476 -
1477 -const isValidHeaderName = (str) => /^[-_a-zA-Z0-9^`|~,!#$%&'*+.]+$/.test(str.trim());
1478 -
1479 -function matchHeaderValue(context, value, header, filter, isHeaderNameFilter) {
1480 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(filter)) {
1481 - return filter.call(this, value, header);
1482 - }
1483 -
1484 - if (isHeaderNameFilter) {
1485 - value = header;
1486 - }
1487 -
1488 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(value)) return;
1489 -
1490 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(filter)) {
1491 - return value.indexOf(filter) !== -1;
1492 - }
1493 -
1494 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isRegExp(filter)) {
1495 - return filter.test(value);
1496 - }
1497 -}
1498 -
1499 -function formatHeader(header) {
1500 - return header.trim()
1501 - .toLowerCase().replace(/([a-z\d])(\w*)/g, (w, char, str) => {
1502 - return char.toUpperCase() + str;
1503 - });
1504 -}
1505 -
1506 -function buildAccessors(obj, header) {
1507 - const accessorName = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toCamelCase(' ' + header);
1508 -
1509 - ['get', 'set', 'has'].forEach(methodName => {
1510 - Object.defineProperty(obj, methodName + accessorName, {
1511 - value: function(arg1, arg2, arg3) {
1512 - return this[methodName].call(this, header, arg1, arg2, arg3);
1513 - },
1514 - configurable: true
1515 - });
1516 - });
1517 -}
1518 -
1519 -class AxiosHeaders {
1520 - constructor(headers) {
1521 - headers && this.set(headers);
1522 - }
1523 -
1524 - set(header, valueOrRewrite, rewrite) {
1525 - const self = this;
1526 -
1527 - function setHeader(_value, _header, _rewrite) {
1528 - const lHeader = normalizeHeader(_header);
1529 -
1530 - if (!lHeader) {
1531 - throw new Error('header name must be a non-empty string');
1532 - }
1533 -
1534 - const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(self, lHeader);
1535 -
1536 - if(!key || self[key] === undefined || _rewrite === true || (_rewrite === undefined && self[key] !== false)) {
1537 - self[key || _header] = normalizeValue(_value);
1538 - }
1539 - }
1540 -
1541 - const setHeaders = (headers, _rewrite) =>
1542 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(headers, (_value, _header) => setHeader(_value, _header, _rewrite));
1543 -
1544 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isPlainObject(header) || header instanceof this.constructor) {
1545 - setHeaders(header, valueOrRewrite)
1546 - } else if(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(header) && (header = header.trim()) && !isValidHeaderName(header)) {
1547 - setHeaders((0,_helpers_parseHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"])(header), valueOrRewrite);
1548 - } else if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(header) && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isIterable(header)) {
1549 - let obj = {}, dest, key;
1550 - for (const entry of header) {
1551 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(entry)) {
1552 - throw TypeError('Object iterator must return a key-value pair');
1553 - }
1554 -
1555 - obj[key = entry[0]] = (dest = obj[key]) ?
1556 - (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(dest) ? [...dest, entry[1]] : [dest, entry[1]]) : entry[1];
1557 - }
1558 -
1559 - setHeaders(obj, valueOrRewrite)
1560 - } else {
1561 - header != null && setHeader(valueOrRewrite, header, rewrite);
1562 - }
1563 -
1564 - return this;
1565 - }
1566 -
1567 - get(header, parser) {
1568 - header = normalizeHeader(header);
1569 -
1570 - if (header) {
1571 - const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(this, header);
1572 -
1573 - if (key) {
1574 - const value = this[key];
1575 -
1576 - if (!parser) {
1577 - return value;
1578 - }
1579 -
1580 - if (parser === true) {
1581 - return parseTokens(value);
1582 - }
1583 -
1584 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(parser)) {
1585 - return parser.call(this, value, key);
1586 - }
1587 -
1588 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isRegExp(parser)) {
1589 - return parser.exec(value);
1590 - }
1591 -
1592 - throw new TypeError('parser must be boolean|regexp|function');
1593 - }
1594 - }
1595 - }
1596 -
1597 - has(header, matcher) {
1598 - header = normalizeHeader(header);
1599 -
1600 - if (header) {
1601 - const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(this, header);
1602 -
1603 - return !!(key && this[key] !== undefined && (!matcher || matchHeaderValue(this, this[key], key, matcher)));
1604 - }
1605 -
1606 - return false;
1607 - }
1608 -
1609 - delete(header, matcher) {
1610 - const self = this;
1611 - let deleted = false;
1612 -
1613 - function deleteHeader(_header) {
1614 - _header = normalizeHeader(_header);
1615 -
1616 - if (_header) {
1617 - const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(self, _header);
1618 -
1619 - if (key && (!matcher || matchHeaderValue(self, self[key], key, matcher))) {
1620 - delete self[key];
1621 -
1622 - deleted = true;
1623 - }
1624 - }
1625 - }
1626 -
1627 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(header)) {
1628 - header.forEach(deleteHeader);
1629 - } else {
1630 - deleteHeader(header);
1631 - }
1632 -
1633 - return deleted;
1634 - }
1635 -
1636 - clear(matcher) {
1637 - const keys = Object.keys(this);
1638 - let i = keys.length;
1639 - let deleted = false;
1640 -
1641 - while (i--) {
1642 - const key = keys[i];
1643 - if(!matcher || matchHeaderValue(this, this[key], key, matcher, true)) {
1644 - delete this[key];
1645 - deleted = true;
1646 - }
1647 - }
1648 -
1649 - return deleted;
1650 - }
1651 -
1652 - normalize(format) {
1653 - const self = this;
1654 - const headers = {};
1655 -
1656 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(this, (value, header) => {
1657 - const key = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].findKey(headers, header);
1658 -
1659 - if (key) {
1660 - self[key] = normalizeValue(value);
1661 - delete self[header];
1662 - return;
1663 - }
1664 -
1665 - const normalized = format ? formatHeader(header) : String(header).trim();
1666 -
1667 - if (normalized !== header) {
1668 - delete self[header];
1669 - }
1670 -
1671 - self[normalized] = normalizeValue(value);
1672 -
1673 - headers[normalized] = true;
1674 - });
1675 -
1676 - return this;
1677 - }
1678 -
1679 - concat(...targets) {
1680 - return this.constructor.concat(this, ...targets);
1681 - }
1682 -
1683 - toJSON(asStrings) {
1684 - const obj = Object.create(null);
1685 -
1686 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(this, (value, header) => {
1687 - value != null && value !== false && (obj[header] = asStrings && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(value) ? value.join(', ') : value);
1688 - });
1689 -
1690 - return obj;
1691 - }
1692 -
1693 - [Symbol.iterator]() {
1694 - return Object.entries(this.toJSON())[Symbol.iterator]();
1695 - }
1696 -
1697 - toString() {
1698 - return Object.entries(this.toJSON()).map(([header, value]) => header + ': ' + value).join('\n');
1699 - }
1700 -
1701 - getSetCookie() {
1702 - return this.get("set-cookie") || [];
1703 - }
1704 -
1705 - get [Symbol.toStringTag]() {
1706 - return 'AxiosHeaders';
1707 - }
1708 -
1709 - static from(thing) {
1710 - return thing instanceof this ? thing : new this(thing);
1711 - }
1712 -
1713 - static concat(first, ...targets) {
1714 - const computed = new this(first);
1715 -
1716 - targets.forEach((target) => computed.set(target));
1717 -
1718 - return computed;
1719 - }
1720 -
1721 - static accessor(header) {
1722 - const internals = this[$internals] = (this[$internals] = {
1723 - accessors: {}
1724 - });
1725 -
1726 - const accessors = internals.accessors;
1727 - const prototype = this.prototype;
1728 -
1729 - function defineAccessor(_header) {
1730 - const lHeader = normalizeHeader(_header);
1731 -
1732 - if (!accessors[lHeader]) {
1733 - buildAccessors(prototype, _header);
1734 - accessors[lHeader] = true;
1735 - }
1736 - }
1737 -
1738 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(header) ? header.forEach(defineAccessor) : defineAccessor(header);
1739 -
1740 - return this;
1741 - }
1742 -}
1743 -
1744 -AxiosHeaders.accessor(['Content-Type', 'Content-Length', 'Accept', 'Accept-Encoding', 'User-Agent', 'Authorization']);
1745 -
1746 -// reserved names hotfix
1747 -_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].reduceDescriptors(AxiosHeaders.prototype, ({value}, key) => {
1748 - let mapped = key[0].toUpperCase() + key.slice(1); // map `set` => `Set`
1749 - return {
1750 - get: () => value,
1751 - set(headerValue) {
1752 - this[mapped] = headerValue;
1753 - }
1754 - }
1755 -});
1756 -
1757 -_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].freezeMethods(AxiosHeaders);
1758 -
1759 -/* harmony default export */ __webpack_exports__["default"] = (AxiosHeaders);
1760 -
1761 -
1762 -/***/ }),
1763 -
1764 -/***/ "./node_modules/axios/lib/core/InterceptorManager.js":
1765 -/*!***********************************************************!*\
1766 - !*** ./node_modules/axios/lib/core/InterceptorManager.js ***!
1767 - \***********************************************************/
1768 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1769 -
1770 -__webpack_require__.r(__webpack_exports__);
1771 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js");
1772 -
1773 -
1774 -
1775 -
1776 -class InterceptorManager {
1777 - constructor() {
1778 - this.handlers = [];
1779 - }
1780 -
1781 - /**
1782 - * Add a new interceptor to the stack
1783 - *
1784 - * @param {Function} fulfilled The function to handle `then` for a `Promise`
1785 - * @param {Function} rejected The function to handle `reject` for a `Promise`
1786 - *
1787 - * @return {Number} An ID used to remove interceptor later
1788 - */
1789 - use(fulfilled, rejected, options) {
1790 - this.handlers.push({
1791 - fulfilled,
1792 - rejected,
1793 - synchronous: options ? options.synchronous : false,
1794 - runWhen: options ? options.runWhen : null
1795 - });
1796 - return this.handlers.length - 1;
1797 - }
1798 -
1799 - /**
1800 - * Remove an interceptor from the stack
1801 - *
1802 - * @param {Number} id The ID that was returned by `use`
1803 - *
1804 - * @returns {void}
1805 - */
1806 - eject(id) {
1807 - if (this.handlers[id]) {
1808 - this.handlers[id] = null;
1809 - }
1810 - }
1811 -
1812 - /**
1813 - * Clear all interceptors from the stack
1814 - *
1815 - * @returns {void}
1816 - */
1817 - clear() {
1818 - if (this.handlers) {
1819 - this.handlers = [];
1820 - }
1821 - }
1822 -
1823 - /**
1824 - * Iterate over all the registered interceptors
1825 - *
1826 - * This method is particularly useful for skipping over any
1827 - * interceptors that may have become `null` calling `eject`.
1828 - *
1829 - * @param {Function} fn The function to call for each interceptor
1830 - *
1831 - * @returns {void}
1832 - */
1833 - forEach(fn) {
1834 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(this.handlers, function forEachHandler(h) {
1835 - if (h !== null) {
1836 - fn(h);
1837 - }
1838 - });
1839 - }
1840 -}
1841 -
1842 -/* harmony default export */ __webpack_exports__["default"] = (InterceptorManager);
1843 -
1844 -
1845 -/***/ }),
1846 -
1847 -/***/ "./node_modules/axios/lib/core/buildFullPath.js":
1848 -/*!******************************************************!*\
1849 - !*** ./node_modules/axios/lib/core/buildFullPath.js ***!
1850 - \******************************************************/
1851 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1852 -
1853 -__webpack_require__.r(__webpack_exports__);
1854 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1855 -/* harmony export */ "default": function() { return /* binding */ buildFullPath; }
1856 -/* harmony export */ });
1857 -/* harmony import */ var _helpers_isAbsoluteURL_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../helpers/isAbsoluteURL.js */ "./node_modules/axios/lib/helpers/isAbsoluteURL.js");
1858 -/* harmony import */ var _helpers_combineURLs_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../helpers/combineURLs.js */ "./node_modules/axios/lib/helpers/combineURLs.js");
1859 -
1860 -
1861 -
1862 -
1863 -
1616 +//#endregion
1617 +//#region node_modules/axios/lib/helpers/speedometer.js
1864 1618 /**
1865 - * Creates a new URL by combining the baseURL with the requestedURL,
1866 - * only when the requestedURL is not already an absolute URL.
1867 - * If the requestURL is absolute, this function returns the requestedURL untouched.
1868 - *
1869 - * @param {string} baseURL The base URL
1870 - * @param {string} requestedURL Absolute or relative URL to combine
1871 - *
1872 - * @returns {string} The combined full path
1873 - */
1874 -function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
1875 - let isRelativeUrl = !(0,_helpers_isAbsoluteURL_js__WEBPACK_IMPORTED_MODULE_0__["default"])(requestedURL);
1876 - if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) {
1877 - return (0,_helpers_combineURLs_js__WEBPACK_IMPORTED_MODULE_1__["default"])(baseURL, requestedURL);
1878 - }
1879 - return requestedURL;
1880 -}
1619 + * Calculate data maxRate
1620 + * @param {Number} [samplesCount= 10]
1621 + * @param {Number} [min= 1000]
1622 + * @returns {Function}
1623 + */
1624 + function speedometer(samplesCount, min) {
1625 + samplesCount = samplesCount || 10;
1626 + const bytes = new Array(samplesCount);
1627 + const timestamps = new Array(samplesCount);
1628 + let head = 0;
1629 + let tail = 0;
1630 + let firstSampleTS;
1631 + min = min !== void 0 ? min : 1e3;
1632 + return function push(chunkLength) {
1633 + const now = Date.now();
1634 + const startedAt = timestamps[tail];
1635 + if (!firstSampleTS) firstSampleTS = now;
1636 + bytes[head] = chunkLength;
1637 + timestamps[head] = now;
1638 + let i = tail;
1639 + let bytesCount = 0;
1640 + while (i !== head) {
1641 + bytesCount += bytes[i++];
1642 + i = i % samplesCount;
1643 + }
1644 + head = (head + 1) % samplesCount;
1645 + if (head === tail) tail = (tail + 1) % samplesCount;
1646 + if (now - firstSampleTS < min) return;
1647 + const passed = startedAt && now - startedAt;
1648 + return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
1649 + };
1650 + }
1881 1651
1882 -
1883 -/***/ }),
1884 -
1885 -/***/ "./node_modules/axios/lib/core/dispatchRequest.js":
1886 -/*!********************************************************!*\
1887 - !*** ./node_modules/axios/lib/core/dispatchRequest.js ***!
1888 - \********************************************************/
1889 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1890 -
1891 -__webpack_require__.r(__webpack_exports__);
1892 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1893 -/* harmony export */ "default": function() { return /* binding */ dispatchRequest; }
1894 -/* harmony export */ });
1895 -/* harmony import */ var _transformData_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./transformData.js */ "./node_modules/axios/lib/core/transformData.js");
1896 -/* harmony import */ var _cancel_isCancel_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../cancel/isCancel.js */ "./node_modules/axios/lib/cancel/isCancel.js");
1897 -/* harmony import */ var _defaults_index_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../defaults/index.js */ "./node_modules/axios/lib/defaults/index.js");
1898 -/* harmony import */ var _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../cancel/CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js");
1899 -/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js");
1900 -/* harmony import */ var _adapters_adapters_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../adapters/adapters.js */ "./node_modules/axios/lib/adapters/adapters.js");
1901 -
1902 -
1903 -
1904 -
1905 -
1906 -
1907 -
1908 -
1909 -
1652 +//#endregion
1653 +//#region node_modules/axios/lib/helpers/throttle.js
1910 1654 /**
1911 - * Throws a `CanceledError` if cancellation has been requested.
1912 - *
1913 - * @param {Object} config The config that is to be used for the request
1914 - *
1915 - * @returns {void}
1916 - */
1917 -function throwIfCancellationRequested(config) {
1918 - if (config.cancelToken) {
1919 - config.cancelToken.throwIfRequested();
1920 - }
1655 + * Throttle decorator
1656 + * @param {Function} fn
1657 + * @param {Number} freq
1658 + * @return {Function}
1659 + */
1660 + function throttle(fn, freq) {
1661 + let timestamp = 0;
1662 + let threshold = 1e3 / freq;
1663 + let lastArgs;
1664 + let timer;
1665 + const invoke = (args, now = Date.now()) => {
1666 + timestamp = now;
1667 + lastArgs = null;
1668 + if (timer) {
1669 + clearTimeout(timer);
1670 + timer = null;
1671 + }
1672 + fn(...args);
1673 + };
1674 + const throttled = (...args) => {
1675 + const now = Date.now();
1676 + const passed = now - timestamp;
1677 + if (passed >= threshold) invoke(args, now);
1678 + else {
1679 + lastArgs = args;
1680 + if (!timer) timer = setTimeout(() => {
1681 + timer = null;
1682 + invoke(lastArgs);
1683 + }, threshold - passed);
1684 + }
1685 + };
1686 + const flush = () => lastArgs && invoke(lastArgs);
1687 + return [throttled, flush];
1688 + }
1921 1689
1922 - if (config.signal && config.signal.aborted) {
1923 - throw new _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_3__["default"](null, config);
1924 - }
1925 -}
1690 +//#endregion
1691 +//#region node_modules/axios/lib/helpers/progressEventReducer.js
1692 + var progressEventReducer = (listener, isDownloadStream, freq = 3) => {
1693 + let bytesNotified = 0;
1694 + const _speedometer = speedometer(50, 250);
1695 + return throttle((e) => {
1696 + const loaded = e.loaded;
1697 + const total = e.lengthComputable ? e.total : void 0;
1698 + const progressBytes = loaded - bytesNotified;
1699 + const rate = _speedometer(progressBytes);
1700 + const inRange = loaded <= total;
1701 + bytesNotified = loaded;
1702 + listener({
1703 + loaded,
1704 + total,
1705 + progress: total ? loaded / total : void 0,
1706 + bytes: progressBytes,
1707 + rate: rate ? rate : void 0,
1708 + estimated: rate && total && inRange ? (total - loaded) / rate : void 0,
1709 + event: e,
1710 + lengthComputable: total != null,
1711 + [isDownloadStream ? "download" : "upload"]: true
1712 + });
1713 + }, freq);
1714 + };
1715 + var progressEventDecorator = (total, throttled) => {
1716 + const lengthComputable = total != null;
1717 + return [(loaded) => throttled[0]({
1718 + lengthComputable,
1719 + total,
1720 + loaded
1721 + }), throttled[1]];
1722 + };
1723 + var asyncDecorator = (fn) => (...args) => utils_default.asap(() => fn(...args));
1926 1724
1927 -/**
1928 - * Dispatch a request to the server using the configured adapter.
1929 - *
1930 - * @param {object} config The config that is to be used for the request
1931 - *
1932 - * @returns {Promise} The Promise to be fulfilled
1933 - */
1934 -function dispatchRequest(config) {
1935 - throwIfCancellationRequested(config);
1725 +//#endregion
1726 +//#region node_modules/axios/lib/helpers/isURLSameOrigin.js
1727 + var isURLSameOrigin_default = platform_default.hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {
1728 + url = new URL(url, platform_default.origin);
1729 + return origin.protocol === url.protocol && origin.host === url.host && (isMSIE || origin.port === url.port);
1730 + })(new URL(platform_default.origin), platform_default.navigator && /(msie|trident)/i.test(platform_default.navigator.userAgent)) : () => true;
1936 1731
1937 - config.headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_4__["default"].from(config.headers);
1732 +//#endregion
1733 +//#region node_modules/axios/lib/helpers/cookies.js
1734 + var cookies_default = platform_default.hasStandardBrowserEnv ? {
1735 + write(name, value, expires, path, domain, secure, sameSite) {
1736 + if (typeof document === "undefined") return;
1737 + const cookie = [`${name}=${encodeURIComponent(value)}`];
1738 + if (utils_default.isNumber(expires)) cookie.push(`expires=${new Date(expires).toUTCString()}`);
1739 + if (utils_default.isString(path)) cookie.push(`path=${path}`);
1740 + if (utils_default.isString(domain)) cookie.push(`domain=${domain}`);
1741 + if (secure === true) cookie.push("secure");
1742 + if (utils_default.isString(sameSite)) cookie.push(`SameSite=${sameSite}`);
1743 + document.cookie = cookie.join("; ");
1744 + },
1745 + read(name) {
1746 + if (typeof document === "undefined") return null;
1747 + const match = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
1748 + return match ? decodeURIComponent(match[1]) : null;
1749 + },
1750 + remove(name) {
1751 + this.write(name, "", Date.now() - 864e5, "/");
1752 + }
1753 + } : {
1754 + write() {},
1755 + read() {
1756 + return null;
1757 + },
1758 + remove() {}
1759 + };
1938 1760
1939 - // Transform request data
1940 - config.data = _transformData_js__WEBPACK_IMPORTED_MODULE_0__["default"].call(
1941 - config,
1942 - config.transformRequest
1943 - );
1944 -
1945 - if (['post', 'put', 'patch'].indexOf(config.method) !== -1) {
1946 - config.headers.setContentType('application/x-www-form-urlencoded', false);
1947 - }
1948 -
1949 - const adapter = _adapters_adapters_js__WEBPACK_IMPORTED_MODULE_5__["default"].getAdapter(config.adapter || _defaults_index_js__WEBPACK_IMPORTED_MODULE_2__["default"].adapter, config);
1950 -
1951 - return adapter(config).then(function onAdapterResolution(response) {
1952 - throwIfCancellationRequested(config);
1953 -
1954 - // Transform response data
1955 - response.data = _transformData_js__WEBPACK_IMPORTED_MODULE_0__["default"].call(
1956 - config,
1957 - config.transformResponse,
1958 - response
1959 - );
1960 -
1961 - response.headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_4__["default"].from(response.headers);
1962 -
1963 - return response;
1964 - }, function onAdapterRejection(reason) {
1965 - if (!(0,_cancel_isCancel_js__WEBPACK_IMPORTED_MODULE_1__["default"])(reason)) {
1966 - throwIfCancellationRequested(config);
1967 -
1968 - // Transform response data
1969 - if (reason && reason.response) {
1970 - reason.response.data = _transformData_js__WEBPACK_IMPORTED_MODULE_0__["default"].call(
1971 - config,
1972 - config.transformResponse,
1973 - reason.response
1974 - );
1975 - reason.response.headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_4__["default"].from(reason.response.headers);
1976 - }
1977 - }
1978 -
1979 - return Promise.reject(reason);
1980 - });
1981 -}
1982 -
1983 -
1984 -/***/ }),
1985 -
1986 -/***/ "./node_modules/axios/lib/core/mergeConfig.js":
1987 -/*!****************************************************!*\
1988 - !*** ./node_modules/axios/lib/core/mergeConfig.js ***!
1989 - \****************************************************/
1990 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
1991 -
1992 -__webpack_require__.r(__webpack_exports__);
1993 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
1994 -/* harmony export */ "default": function() { return /* binding */ mergeConfig; }
1995 -/* harmony export */ });
1996 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
1997 -/* harmony import */ var _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js");
1998 -
1999 -
2000 -
2001 -
2002 -
2003 -const headersToObject = (thing) => thing instanceof _AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_1__["default"] ? { ...thing } : thing;
2004 -
1761 +//#endregion
1762 +//#region node_modules/axios/lib/helpers/isAbsoluteURL.js
2005 1763 /**
2006 - * Config-specific merge-function which creates a new config-object
2007 - * by merging two configuration objects together.
2008 - *
2009 - * @param {Object} config1
2010 - * @param {Object} config2
2011 - *
2012 - * @returns {Object} New object resulting from merging config2 to config1
2013 - */
2014 -function mergeConfig(config1, config2) {
2015 - // eslint-disable-next-line no-param-reassign
2016 - config2 = config2 || {};
2017 - const config = {};
1764 + * Determines whether the specified URL is absolute
1765 + *
1766 + * @param {string} url The URL to test
1767 + *
1768 + * @returns {boolean} True if the specified URL is absolute, otherwise false
1769 + */
1770 + function isAbsoluteURL(url) {
1771 + return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
1772 + }
2018 1773
2019 - function getMergedValue(target, source, prop, caseless) {
2020 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isPlainObject(target) && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isPlainObject(source)) {
2021 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].merge.call({caseless}, target, source);
2022 - } else if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isPlainObject(source)) {
2023 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].merge({}, source);
2024 - } else if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(source)) {
2025 - return source.slice();
2026 - }
2027 - return source;
2028 - }
2029 -
2030 - // eslint-disable-next-line consistent-return
2031 - function mergeDeepProperties(a, b, prop, caseless) {
2032 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(b)) {
2033 - return getMergedValue(a, b, prop, caseless);
2034 - } else if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(a)) {
2035 - return getMergedValue(undefined, a, prop, caseless);
2036 - }
2037 - }
2038 -
2039 - // eslint-disable-next-line consistent-return
2040 - function valueFromConfig2(a, b) {
2041 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(b)) {
2042 - return getMergedValue(undefined, b);
2043 - }
2044 - }
2045 -
2046 - // eslint-disable-next-line consistent-return
2047 - function defaultToConfig2(a, b) {
2048 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(b)) {
2049 - return getMergedValue(undefined, b);
2050 - } else if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(a)) {
2051 - return getMergedValue(undefined, a);
2052 - }
2053 - }
2054 -
2055 - // eslint-disable-next-line consistent-return
2056 - function mergeDirectKeys(a, b, prop) {
2057 - if (prop in config2) {
2058 - return getMergedValue(a, b);
2059 - } else if (prop in config1) {
2060 - return getMergedValue(undefined, a);
2061 - }
2062 - }
2063 -
2064 - const mergeMap = {
2065 - url: valueFromConfig2,
2066 - method: valueFromConfig2,
2067 - data: valueFromConfig2,
2068 - baseURL: defaultToConfig2,
2069 - transformRequest: defaultToConfig2,
2070 - transformResponse: defaultToConfig2,
2071 - paramsSerializer: defaultToConfig2,
2072 - timeout: defaultToConfig2,
2073 - timeoutMessage: defaultToConfig2,
2074 - withCredentials: defaultToConfig2,
2075 - withXSRFToken: defaultToConfig2,
2076 - adapter: defaultToConfig2,
2077 - responseType: defaultToConfig2,
2078 - xsrfCookieName: defaultToConfig2,
2079 - xsrfHeaderName: defaultToConfig2,
2080 - onUploadProgress: defaultToConfig2,
2081 - onDownloadProgress: defaultToConfig2,
2082 - decompress: defaultToConfig2,
2083 - maxContentLength: defaultToConfig2,
2084 - maxBodyLength: defaultToConfig2,
2085 - beforeRedirect: defaultToConfig2,
2086 - transport: defaultToConfig2,
2087 - httpAgent: defaultToConfig2,
2088 - httpsAgent: defaultToConfig2,
2089 - cancelToken: defaultToConfig2,
2090 - socketPath: defaultToConfig2,
2091 - responseEncoding: defaultToConfig2,
2092 - validateStatus: mergeDirectKeys,
2093 - headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
2094 - };
2095 -
2096 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(Object.keys({...config1, ...config2}), function computeConfigValue(prop) {
2097 - const merge = mergeMap[prop] || mergeDeepProperties;
2098 - const configValue = merge(config1[prop], config2[prop], prop);
2099 - (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
2100 - });
2101 -
2102 - return config;
2103 -}
2104 -
2105 -
2106 -/***/ }),
2107 -
2108 -/***/ "./node_modules/axios/lib/core/settle.js":
2109 -/*!***********************************************!*\
2110 - !*** ./node_modules/axios/lib/core/settle.js ***!
2111 - \***********************************************/
2112 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2113 -
2114 -__webpack_require__.r(__webpack_exports__);
2115 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2116 -/* harmony export */ "default": function() { return /* binding */ settle; }
2117 -/* harmony export */ });
2118 -/* harmony import */ var _AxiosError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
2119 -
2120 -
2121 -
2122 -
1774 +//#endregion
1775 +//#region node_modules/axios/lib/helpers/combineURLs.js
2123 1776 /**
2124 - * Resolve or reject a Promise based on response status.
2125 - *
2126 - * @param {Function} resolve A function that resolves the promise.
2127 - * @param {Function} reject A function that rejects the promise.
2128 - * @param {object} response The response.
2129 - *
2130 - * @returns {object} The response.
2131 - */
2132 -function settle(resolve, reject, response) {
2133 - const validateStatus = response.config.validateStatus;
2134 - if (!response.status || !validateStatus || validateStatus(response.status)) {
2135 - resolve(response);
2136 - } else {
2137 - reject(new _AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"](
2138 - 'Request failed with status code ' + response.status,
2139 - [_AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].ERR_BAD_REQUEST, _AxiosError_js__WEBPACK_IMPORTED_MODULE_0__["default"].ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
2140 - response.config,
2141 - response.request,
2142 - response
2143 - ));
2144 - }
2145 -}
1777 + * Creates a new URL by combining the specified URLs
1778 + *
1779 + * @param {string} baseURL The base URL
1780 + * @param {string} relativeURL The relative URL
1781 + *
1782 + * @returns {string} The combined URL
1783 + */
1784 + function combineURLs(baseURL, relativeURL) {
1785 + return relativeURL ? baseURL.replace(/\/?\/$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
1786 + }
2146 1787
2147 -
2148 -/***/ }),
2149 -
2150 -/***/ "./node_modules/axios/lib/core/transformData.js":
2151 -/*!******************************************************!*\
2152 - !*** ./node_modules/axios/lib/core/transformData.js ***!
2153 - \******************************************************/
2154 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2155 -
2156 -__webpack_require__.r(__webpack_exports__);
2157 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2158 -/* harmony export */ "default": function() { return /* binding */ transformData; }
2159 -/* harmony export */ });
2160 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js");
2161 -/* harmony import */ var _defaults_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../defaults/index.js */ "./node_modules/axios/lib/defaults/index.js");
2162 -/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js");
2163 -
2164 -
2165 -
2166 -
2167 -
2168 -
1788 +//#endregion
1789 +//#region node_modules/axios/lib/core/buildFullPath.js
2169 1790 /**
2170 - * Transform the data for a request or a response
2171 - *
2172 - * @param {Array|Function} fns A single function or Array of functions
2173 - * @param {?Object} response The response object
2174 - *
2175 - * @returns {*} The resulting transformed data
2176 - */
2177 -function transformData(fns, response) {
2178 - const config = this || _defaults_index_js__WEBPACK_IMPORTED_MODULE_1__["default"];
2179 - const context = response || config;
2180 - const headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_2__["default"].from(context.headers);
2181 - let data = context.data;
1791 + * Creates a new URL by combining the baseURL with the requestedURL,
1792 + * only when the requestedURL is not already an absolute URL.
1793 + * If the requestURL is absolute, this function returns the requestedURL untouched.
1794 + *
1795 + * @param {string} baseURL The base URL
1796 + * @param {string} requestedURL Absolute or relative URL to combine
1797 + *
1798 + * @returns {string} The combined full path
1799 + */
1800 + function buildFullPath(baseURL, requestedURL, allowAbsoluteUrls) {
1801 + let isRelativeUrl = !isAbsoluteURL(requestedURL);
1802 + if (baseURL && (isRelativeUrl || allowAbsoluteUrls == false)) return combineURLs(baseURL, requestedURL);
1803 + return requestedURL;
1804 + }
2182 1805
2183 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(fns, function transform(fn) {
2184 - data = fn.call(config, data, headers.normalize(), response ? response.status : undefined);
2185 - });
1806 +//#endregion
1807 +//#region node_modules/axios/lib/core/mergeConfig.js
1808 + var headersToObject = (thing) => thing instanceof AxiosHeaders$1 ? { ...thing } : thing;
1809 + /**
1810 + * Config-specific merge-function which creates a new config-object
1811 + * by merging two configuration objects together.
1812 + *
1813 + * @param {Object} config1
1814 + * @param {Object} config2
1815 + *
1816 + * @returns {Object} New object resulting from merging config2 to config1
1817 + */
1818 + function mergeConfig$1(config1, config2) {
1819 + config2 = config2 || {};
1820 + const config = {};
1821 + function getMergedValue(target, source, prop, caseless) {
1822 + if (utils_default.isPlainObject(target) && utils_default.isPlainObject(source)) return utils_default.merge.call({ caseless }, target, source);
1823 + else if (utils_default.isPlainObject(source)) return utils_default.merge({}, source);
1824 + else if (utils_default.isArray(source)) return source.slice();
1825 + return source;
1826 + }
1827 + function mergeDeepProperties(a, b, prop, caseless) {
1828 + if (!utils_default.isUndefined(b)) return getMergedValue(a, b, prop, caseless);
1829 + else if (!utils_default.isUndefined(a)) return getMergedValue(void 0, a, prop, caseless);
1830 + }
1831 + function valueFromConfig2(a, b) {
1832 + if (!utils_default.isUndefined(b)) return getMergedValue(void 0, b);
1833 + }
1834 + function defaultToConfig2(a, b) {
1835 + if (!utils_default.isUndefined(b)) return getMergedValue(void 0, b);
1836 + else if (!utils_default.isUndefined(a)) return getMergedValue(void 0, a);
1837 + }
1838 + function mergeDirectKeys(a, b, prop) {
1839 + if (prop in config2) return getMergedValue(a, b);
1840 + else if (prop in config1) return getMergedValue(void 0, a);
1841 + }
1842 + const mergeMap = {
1843 + url: valueFromConfig2,
1844 + method: valueFromConfig2,
1845 + data: valueFromConfig2,
1846 + baseURL: defaultToConfig2,
1847 + transformRequest: defaultToConfig2,
1848 + transformResponse: defaultToConfig2,
1849 + paramsSerializer: defaultToConfig2,
1850 + timeout: defaultToConfig2,
1851 + timeoutMessage: defaultToConfig2,
1852 + withCredentials: defaultToConfig2,
1853 + withXSRFToken: defaultToConfig2,
1854 + adapter: defaultToConfig2,
1855 + responseType: defaultToConfig2,
1856 + xsrfCookieName: defaultToConfig2,
1857 + xsrfHeaderName: defaultToConfig2,
1858 + onUploadProgress: defaultToConfig2,
1859 + onDownloadProgress: defaultToConfig2,
1860 + decompress: defaultToConfig2,
1861 + maxContentLength: defaultToConfig2,
1862 + maxBodyLength: defaultToConfig2,
1863 + beforeRedirect: defaultToConfig2,
1864 + transport: defaultToConfig2,
1865 + httpAgent: defaultToConfig2,
1866 + httpsAgent: defaultToConfig2,
1867 + cancelToken: defaultToConfig2,
1868 + socketPath: defaultToConfig2,
1869 + responseEncoding: defaultToConfig2,
1870 + validateStatus: mergeDirectKeys,
1871 + headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
1872 + };
1873 + utils_default.forEach(Object.keys({
1874 + ...config1,
1875 + ...config2
1876 + }), function computeConfigValue(prop) {
1877 + const merge = mergeMap[prop] || mergeDeepProperties;
1878 + const configValue = merge(config1[prop], config2[prop], prop);
1879 + utils_default.isUndefined(configValue) && merge !== mergeDirectKeys || (config[prop] = configValue);
1880 + });
1881 + return config;
1882 + }
1883 + __name(mergeConfig$1, "mergeConfig");
2186 1884
2187 - headers.normalize();
1885 +//#endregion
1886 +//#region node_modules/axios/lib/helpers/resolveConfig.js
1887 + var resolveConfig_default = /* @__PURE__ */ __name((config) => {
1888 + const newConfig = mergeConfig$1({}, config);
1889 + let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
1890 + newConfig.headers = headers = AxiosHeaders$1.from(headers);
1891 + newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
1892 + if (auth) headers.set("Authorization", "Basic " + btoa((auth.username || "") + ":" + (auth.password ? unescape(encodeURIComponent(auth.password)) : "")));
1893 + if (utils_default.isFormData(data)) {
1894 + if (platform_default.hasStandardBrowserEnv || platform_default.hasStandardBrowserWebWorkerEnv) headers.setContentType(void 0);
1895 + else if (utils_default.isFunction(data.getHeaders)) {
1896 + const formHeaders = data.getHeaders();
1897 + const allowedHeaders = ["content-type", "content-length"];
1898 + Object.entries(formHeaders).forEach(([key, val]) => {
1899 + if (allowedHeaders.includes(key.toLowerCase())) headers.set(key, val);
1900 + });
1901 + }
1902 + }
1903 + if (platform_default.hasStandardBrowserEnv) {
1904 + withXSRFToken && utils_default.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
1905 + if (withXSRFToken || withXSRFToken !== false && isURLSameOrigin_default(newConfig.url)) {
1906 + const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies_default.read(xsrfCookieName);
1907 + if (xsrfValue) headers.set(xsrfHeaderName, xsrfValue);
1908 + }
1909 + }
1910 + return newConfig;
1911 + }, "default");
2188 1912
2189 - return data;
2190 -}
1913 +//#endregion
1914 +//#region node_modules/axios/lib/adapters/xhr.js
1915 + var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
1916 + var xhr_default = isXHRAdapterSupported && function(config) {
1917 + return new Promise(function dispatchXhrRequest(resolve, reject) {
1918 + const _config = resolveConfig_default(config);
1919 + let requestData = _config.data;
1920 + const requestHeaders = AxiosHeaders$1.from(_config.headers).normalize();
1921 + let { responseType, onUploadProgress, onDownloadProgress } = _config;
1922 + let onCanceled;
1923 + let uploadThrottled;
1924 + let downloadThrottled;
1925 + let flushUpload;
1926 + let flushDownload;
1927 + function done() {
1928 + flushUpload && flushUpload();
1929 + flushDownload && flushDownload();
1930 + _config.cancelToken && _config.cancelToken.unsubscribe(onCanceled);
1931 + _config.signal && _config.signal.removeEventListener("abort", onCanceled);
1932 + }
1933 + let request = new XMLHttpRequest();
1934 + request.open(_config.method.toUpperCase(), _config.url, true);
1935 + request.timeout = _config.timeout;
1936 + function onloadend() {
1937 + if (!request) return;
1938 + const responseHeaders = AxiosHeaders$1.from("getAllResponseHeaders" in request && request.getAllResponseHeaders());
1939 + settle(function _resolve(value) {
1940 + resolve(value);
1941 + done();
1942 + }, function _reject(err) {
1943 + reject(err);
1944 + done();
1945 + }, {
1946 + data: !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response,
1947 + status: request.status,
1948 + statusText: request.statusText,
1949 + headers: responseHeaders,
1950 + config,
1951 + request
1952 + });
1953 + request = null;
1954 + }
1955 + if ("onloadend" in request) request.onloadend = onloadend;
1956 + else request.onreadystatechange = function handleLoad() {
1957 + if (!request || request.readyState !== 4) return;
1958 + if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) return;
1959 + setTimeout(onloadend);
1960 + };
1961 + request.onabort = function handleAbort() {
1962 + if (!request) return;
1963 + reject(new AxiosError$1("Request aborted", AxiosError$1.ECONNABORTED, config, request));
1964 + request = null;
1965 + };
1966 + request.onerror = function handleError(event) {
1967 + const err = new AxiosError$1(event && event.message ? event.message : "Network Error", AxiosError$1.ERR_NETWORK, config, request);
1968 + err.event = event || null;
1969 + reject(err);
1970 + request = null;
1971 + };
1972 + request.ontimeout = function handleTimeout() {
1973 + let timeoutErrorMessage = _config.timeout ? "timeout of " + _config.timeout + "ms exceeded" : "timeout exceeded";
1974 + const transitional = _config.transitional || transitional_default;
1975 + if (_config.timeoutErrorMessage) timeoutErrorMessage = _config.timeoutErrorMessage;
1976 + reject(new AxiosError$1(timeoutErrorMessage, transitional.clarifyTimeoutError ? AxiosError$1.ETIMEDOUT : AxiosError$1.ECONNABORTED, config, request));
1977 + request = null;
1978 + };
1979 + requestData === void 0 && requestHeaders.setContentType(null);
1980 + if ("setRequestHeader" in request) utils_default.forEach(requestHeaders.toJSON(), function setRequestHeader(val, key) {
1981 + request.setRequestHeader(key, val);
1982 + });
1983 + if (!utils_default.isUndefined(_config.withCredentials)) request.withCredentials = !!_config.withCredentials;
1984 + if (responseType && responseType !== "json") request.responseType = _config.responseType;
1985 + if (onDownloadProgress) {
1986 + [downloadThrottled, flushDownload] = progressEventReducer(onDownloadProgress, true);
1987 + request.addEventListener("progress", downloadThrottled);
1988 + }
1989 + if (onUploadProgress && request.upload) {
1990 + [uploadThrottled, flushUpload] = progressEventReducer(onUploadProgress);
1991 + request.upload.addEventListener("progress", uploadThrottled);
1992 + request.upload.addEventListener("loadend", flushUpload);
1993 + }
1994 + if (_config.cancelToken || _config.signal) {
1995 + onCanceled = (cancel) => {
1996 + if (!request) return;
1997 + reject(!cancel || cancel.type ? new CanceledError$1(null, config, request) : cancel);
1998 + request.abort();
1999 + request = null;
2000 + };
2001 + _config.cancelToken && _config.cancelToken.subscribe(onCanceled);
2002 + if (_config.signal) _config.signal.aborted ? onCanceled() : _config.signal.addEventListener("abort", onCanceled);
2003 + }
2004 + const protocol = parseProtocol(_config.url);
2005 + if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
2006 + reject(new AxiosError$1("Unsupported protocol " + protocol + ":", AxiosError$1.ERR_BAD_REQUEST, config));
2007 + return;
2008 + }
2009 + request.send(requestData || null);
2010 + });
2011 + };
2191 2012
2013 +//#endregion
2014 +//#region node_modules/axios/lib/helpers/composeSignals.js
2015 + var composeSignals = (signals, timeout) => {
2016 + const { length } = signals = signals ? signals.filter(Boolean) : [];
2017 + if (timeout || length) {
2018 + let controller = new AbortController();
2019 + let aborted;
2020 + const onabort = function(reason) {
2021 + if (!aborted) {
2022 + aborted = true;
2023 + unsubscribe();
2024 + const err = reason instanceof Error ? reason : this.reason;
2025 + controller.abort(err instanceof AxiosError$1 ? err : new CanceledError$1(err instanceof Error ? err.message : err));
2026 + }
2027 + };
2028 + let timer = timeout && setTimeout(() => {
2029 + timer = null;
2030 + onabort(new AxiosError$1(`timeout ${timeout} of ms exceeded`, AxiosError$1.ETIMEDOUT));
2031 + }, timeout);
2032 + const unsubscribe = () => {
2033 + if (signals) {
2034 + timer && clearTimeout(timer);
2035 + timer = null;
2036 + signals.forEach((signal) => {
2037 + signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener("abort", onabort);
2038 + });
2039 + signals = null;
2040 + }
2041 + };
2042 + signals.forEach((signal) => signal.addEventListener("abort", onabort));
2043 + const { signal } = controller;
2044 + signal.unsubscribe = () => utils_default.asap(unsubscribe);
2045 + return signal;
2046 + }
2047 + };
2192 2048
2193 -/***/ }),
2049 +//#endregion
2050 +//#region node_modules/axios/lib/helpers/trackStream.js
2051 + var streamChunk = function* (chunk, chunkSize) {
2052 + let len = chunk.byteLength;
2053 + if (!chunkSize || len < chunkSize) {
2054 + yield chunk;
2055 + return;
2056 + }
2057 + let pos = 0;
2058 + let end;
2059 + while (pos < len) {
2060 + end = pos + chunkSize;
2061 + yield chunk.slice(pos, end);
2062 + pos = end;
2063 + }
2064 + };
2065 + var readBytes = async function* (iterable, chunkSize) {
2066 + for await (const chunk of readStream(iterable)) yield* streamChunk(chunk, chunkSize);
2067 + };
2068 + var readStream = async function* (stream) {
2069 + if (stream[Symbol.asyncIterator]) {
2070 + yield* stream;
2071 + return;
2072 + }
2073 + const reader = stream.getReader();
2074 + try {
2075 + for (;;) {
2076 + const { done, value } = await reader.read();
2077 + if (done) break;
2078 + yield value;
2079 + }
2080 + } finally {
2081 + await reader.cancel();
2082 + }
2083 + };
2084 + var trackStream = (stream, chunkSize, onProgress, onFinish) => {
2085 + const iterator = readBytes(stream, chunkSize);
2086 + let bytes = 0;
2087 + let done;
2088 + let _onFinish = (e) => {
2089 + if (!done) {
2090 + done = true;
2091 + onFinish && onFinish(e);
2092 + }
2093 + };
2094 + return new ReadableStream({
2095 + async pull(controller) {
2096 + try {
2097 + const { done, value } = await iterator.next();
2098 + if (done) {
2099 + _onFinish();
2100 + controller.close();
2101 + return;
2102 + }
2103 + let len = value.byteLength;
2104 + if (onProgress) onProgress(bytes += len);
2105 + controller.enqueue(new Uint8Array(value));
2106 + } catch (err) {
2107 + _onFinish(err);
2108 + throw err;
2109 + }
2110 + },
2111 + cancel(reason) {
2112 + _onFinish(reason);
2113 + return iterator.return();
2114 + }
2115 + }, { highWaterMark: 2 });
2116 + };
2194 2117
2195 -/***/ "./node_modules/axios/lib/defaults/index.js":
2196 -/*!**************************************************!*\
2197 - !*** ./node_modules/axios/lib/defaults/index.js ***!
2198 - \**************************************************/
2199 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2118 +//#endregion
2119 +//#region node_modules/axios/lib/adapters/fetch.js
2120 + var DEFAULT_CHUNK_SIZE = 64 * 1024;
2121 + var { isFunction } = utils_default;
2122 + var globalFetchAPI = (({ Request, Response }) => ({
2123 + Request,
2124 + Response
2125 + }))(utils_default.global);
2126 + var { ReadableStream: ReadableStream$1, TextEncoder } = utils_default.global;
2127 + var test = (fn, ...args) => {
2128 + try {
2129 + return !!fn(...args);
2130 + } catch (e) {
2131 + return false;
2132 + }
2133 + };
2134 + var factory = (env) => {
2135 + env = utils_default.merge.call({ skipUndefined: true }, globalFetchAPI, env);
2136 + const { fetch: envFetch, Request, Response } = env;
2137 + const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === "function";
2138 + const isRequestSupported = isFunction(Request);
2139 + const isResponseSupported = isFunction(Response);
2140 + if (!isFetchSupported) return false;
2141 + const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream$1);
2142 + const encodeText = isFetchSupported && (typeof TextEncoder === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
2143 + const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
2144 + let duplexAccessed = false;
2145 + const hasContentType = new Request(platform_default.origin, {
2146 + body: new ReadableStream$1(),
2147 + method: "POST",
2148 + get duplex() {
2149 + duplexAccessed = true;
2150 + return "half";
2151 + }
2152 + }).headers.has("Content-Type");
2153 + return duplexAccessed && !hasContentType;
2154 + });
2155 + const supportsResponseStream = isResponseSupported && isReadableStreamSupported && test(() => utils_default.isReadableStream(new Response("").body));
2156 + const resolvers = { stream: supportsResponseStream && ((res) => res.body) };
2157 + isFetchSupported && (() => {
2158 + [
2159 + "text",
2160 + "arrayBuffer",
2161 + "blob",
2162 + "formData",
2163 + "stream"
2164 + ].forEach((type) => {
2165 + !resolvers[type] && (resolvers[type] = (res, config) => {
2166 + let method = res && res[type];
2167 + if (method) return method.call(res);
2168 + throw new AxiosError$1(`Response type '${type}' is not supported`, AxiosError$1.ERR_NOT_SUPPORT, config);
2169 + });
2170 + });
2171 + })();
2172 + const getBodyLength = async (body) => {
2173 + if (body == null) return 0;
2174 + if (utils_default.isBlob(body)) return body.size;
2175 + if (utils_default.isSpecCompliantForm(body)) return (await new Request(platform_default.origin, {
2176 + method: "POST",
2177 + body
2178 + }).arrayBuffer()).byteLength;
2179 + if (utils_default.isArrayBufferView(body) || utils_default.isArrayBuffer(body)) return body.byteLength;
2180 + if (utils_default.isURLSearchParams(body)) body = body + "";
2181 + if (utils_default.isString(body)) return (await encodeText(body)).byteLength;
2182 + };
2183 + const resolveBodyLength = async (headers, body) => {
2184 + const length = utils_default.toFiniteNumber(headers.getContentLength());
2185 + return length == null ? getBodyLength(body) : length;
2186 + };
2187 + return async (config) => {
2188 + let { url, method, data, signal, cancelToken, timeout, onDownloadProgress, onUploadProgress, responseType, headers, withCredentials = "same-origin", fetchOptions } = resolveConfig_default(config);
2189 + let _fetch = envFetch || fetch;
2190 + responseType = responseType ? (responseType + "").toLowerCase() : "text";
2191 + let composedSignal = composeSignals([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
2192 + let request = null;
2193 + const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
2194 + composedSignal.unsubscribe();
2195 + });
2196 + let requestContentLength;
2197 + try {
2198 + if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
2199 + let _request = new Request(url, {
2200 + method: "POST",
2201 + body: data,
2202 + duplex: "half"
2203 + });
2204 + let contentTypeHeader;
2205 + if (utils_default.isFormData(data) && (contentTypeHeader = _request.headers.get("content-type"))) headers.setContentType(contentTypeHeader);
2206 + if (_request.body) {
2207 + const [onProgress, flush] = progressEventDecorator(requestContentLength, progressEventReducer(asyncDecorator(onUploadProgress)));
2208 + data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
2209 + }
2210 + }
2211 + if (!utils_default.isString(withCredentials)) withCredentials = withCredentials ? "include" : "omit";
2212 + const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
2213 + const resolvedOptions = {
2214 + ...fetchOptions,
2215 + signal: composedSignal,
2216 + method: method.toUpperCase(),
2217 + headers: headers.normalize().toJSON(),
2218 + body: data,
2219 + duplex: "half",
2220 + credentials: isCredentialsSupported ? withCredentials : void 0
2221 + };
2222 + request = isRequestSupported && new Request(url, resolvedOptions);
2223 + let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
2224 + const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
2225 + if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
2226 + const options = {};
2227 + [
2228 + "status",
2229 + "statusText",
2230 + "headers"
2231 + ].forEach((prop) => {
2232 + options[prop] = response[prop];
2233 + });
2234 + const responseContentLength = utils_default.toFiniteNumber(response.headers.get("content-length"));
2235 + const [onProgress, flush] = onDownloadProgress && progressEventDecorator(responseContentLength, progressEventReducer(asyncDecorator(onDownloadProgress), true)) || [];
2236 + response = new Response(trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
2237 + flush && flush();
2238 + unsubscribe && unsubscribe();
2239 + }), options);
2240 + }
2241 + responseType = responseType || "text";
2242 + let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config);
2243 + !isStreamResponse && unsubscribe && unsubscribe();
2244 + return await new Promise((resolve, reject) => {
2245 + settle(resolve, reject, {
2246 + data: responseData,
2247 + headers: AxiosHeaders$1.from(response.headers),
2248 + status: response.status,
2249 + statusText: response.statusText,
2250 + config,
2251 + request
2252 + });
2253 + });
2254 + } catch (err) {
2255 + unsubscribe && unsubscribe();
2256 + if (err && err.name === "TypeError" && /Load failed|fetch/i.test(err.message)) throw Object.assign(new AxiosError$1("Network Error", AxiosError$1.ERR_NETWORK, config, request), { cause: err.cause || err });
2257 + throw AxiosError$1.from(err, err && err.code, config, request);
2258 + }
2259 + };
2260 + };
2261 + var seedCache = /* @__PURE__ */ new Map();
2262 + var getFetch = (config) => {
2263 + let env = config && config.env || {};
2264 + const { fetch, Request, Response } = env;
2265 + const seeds = [
2266 + Request,
2267 + Response,
2268 + fetch
2269 + ];
2270 + let i = seeds.length;
2271 + let seed;
2272 + let target;
2273 + let map = seedCache;
2274 + while (i--) {
2275 + seed = seeds[i];
2276 + target = map.get(seed);
2277 + target === void 0 && map.set(seed, target = i ? /* @__PURE__ */ new Map() : factory(env));
2278 + map = target;
2279 + }
2280 + return target;
2281 + };
2282 + var adapter = getFetch();
2200 2283
2201 -__webpack_require__.r(__webpack_exports__);
2202 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
2203 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
2204 -/* harmony import */ var _transitional_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./transitional.js */ "./node_modules/axios/lib/defaults/transitional.js");
2205 -/* harmony import */ var _helpers_toFormData_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../helpers/toFormData.js */ "./node_modules/axios/lib/helpers/toFormData.js");
2206 -/* harmony import */ var _helpers_toURLEncodedForm_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../helpers/toURLEncodedForm.js */ "./node_modules/axios/lib/helpers/toURLEncodedForm.js");
2207 -/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js");
2208 -/* harmony import */ var _helpers_formDataToJSON_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../helpers/formDataToJSON.js */ "./node_modules/axios/lib/helpers/formDataToJSON.js");
2209 -
2210 -
2211 -
2212 -
2213 -
2214 -
2215 -
2216 -
2217 -
2218 -
2284 +//#endregion
2285 +//#region node_modules/axios/lib/adapters/adapters.js
2219 2286 /**
2220 - * It takes a string, tries to parse it, and if it fails, it returns the stringified version
2221 - * of the input
2222 - *
2223 - * @param {any} rawValue - The value to be stringified.
2224 - * @param {Function} parser - A function that parses a string into a JavaScript object.
2225 - * @param {Function} encoder - A function that takes a value and returns a string.
2226 - *
2227 - * @returns {string} A stringified version of the rawValue.
2228 - */
2229 -function stringifySafely(rawValue, parser, encoder) {
2230 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(rawValue)) {
2231 - try {
2232 - (parser || JSON.parse)(rawValue);
2233 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].trim(rawValue);
2234 - } catch (e) {
2235 - if (e.name !== 'SyntaxError') {
2236 - throw e;
2237 - }
2238 - }
2239 - }
2287 + * Known adapters mapping.
2288 + * Provides environment-specific adapters for Axios:
2289 + * - `http` for Node.js
2290 + * - `xhr` for browsers
2291 + * - `fetch` for fetch API-based requests
2292 + *
2293 + * @type {Object<string, Function|Object>}
2294 + */
2295 + var knownAdapters = {
2296 + http: null,
2297 + xhr: xhr_default,
2298 + fetch: { get: getFetch }
2299 + };
2300 + utils_default.forEach(knownAdapters, (fn, value) => {
2301 + if (fn) {
2302 + try {
2303 + Object.defineProperty(fn, "name", { value });
2304 + } catch (e) {}
2305 + Object.defineProperty(fn, "adapterName", { value });
2306 + }
2307 + });
2308 + /**
2309 + * Render a rejection reason string for unknown or unsupported adapters
2310 + *
2311 + * @param {string} reason
2312 + * @returns {string}
2313 + */
2314 + var renderReason = (reason) => `- ${reason}`;
2315 + /**
2316 + * Check if the adapter is resolved (function, null, or false)
2317 + *
2318 + * @param {Function|null|false} adapter
2319 + * @returns {boolean}
2320 + */
2321 + var isResolvedHandle = (adapter) => utils_default.isFunction(adapter) || adapter === null || adapter === false;
2322 + /**
2323 + * Get the first suitable adapter from the provided list.
2324 + * Tries each adapter in order until a supported one is found.
2325 + * Throws an AxiosError if no adapter is suitable.
2326 + *
2327 + * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.
2328 + * @param {Object} config - Axios request configuration
2329 + * @throws {AxiosError} If no suitable adapter is available
2330 + * @returns {Function} The resolved adapter function
2331 + */
2332 + function getAdapter$1(adapters, config) {
2333 + adapters = utils_default.isArray(adapters) ? adapters : [adapters];
2334 + const { length } = adapters;
2335 + let nameOrAdapter;
2336 + let adapter;
2337 + const rejectedReasons = {};
2338 + for (let i = 0; i < length; i++) {
2339 + nameOrAdapter = adapters[i];
2340 + let id;
2341 + adapter = nameOrAdapter;
2342 + if (!isResolvedHandle(nameOrAdapter)) {
2343 + adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
2344 + if (adapter === void 0) throw new AxiosError$1(`Unknown adapter '${id}'`);
2345 + }
2346 + if (adapter && (utils_default.isFunction(adapter) || (adapter = adapter.get(config)))) break;
2347 + rejectedReasons[id || "#" + i] = adapter;
2348 + }
2349 + if (!adapter) {
2350 + const reasons = Object.entries(rejectedReasons).map(([id, state]) => `adapter ${id} ` + (state === false ? "is not supported by the environment" : "is not available in the build"));
2351 + throw new AxiosError$1(`There is no suitable adapter to dispatch the request ` + (length ? reasons.length > 1 ? "since :\n" + reasons.map(renderReason).join("\n") : " " + renderReason(reasons[0]) : "as no adapter specified"), "ERR_NOT_SUPPORT");
2352 + }
2353 + return adapter;
2354 + }
2355 + __name(getAdapter$1, "getAdapter");
2356 + /**
2357 + * Exports Axios adapters and utility to resolve an adapter
2358 + */
2359 + var adapters_default = {
2360 + /**
2361 + * Resolve an adapter from a list of adapter names or functions.
2362 + * @type {Function}
2363 + */
2364 + getAdapter: getAdapter$1,
2365 + /**
2366 + * Exposes all known adapters
2367 + * @type {Object<string, Function|Object>}
2368 + */
2369 + adapters: knownAdapters
2370 + };
2240 2371
2241 - return (encoder || JSON.stringify)(rawValue);
2242 -}
2243 -
2244 -const defaults = {
2245 -
2246 - transitional: _transitional_js__WEBPACK_IMPORTED_MODULE_2__["default"],
2247 -
2248 - adapter: ['xhr', 'http', 'fetch'],
2249 -
2250 - transformRequest: [function transformRequest(data, headers) {
2251 - const contentType = headers.getContentType() || '';
2252 - const hasJSONContentType = contentType.indexOf('application/json') > -1;
2253 - const isObjectPayload = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(data);
2254 -
2255 - if (isObjectPayload && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isHTMLForm(data)) {
2256 - data = new FormData(data);
2257 - }
2258 -
2259 - const isFormData = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFormData(data);
2260 -
2261 - if (isFormData) {
2262 - return hasJSONContentType ? JSON.stringify((0,_helpers_formDataToJSON_js__WEBPACK_IMPORTED_MODULE_6__["default"])(data)) : data;
2263 - }
2264 -
2265 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArrayBuffer(data) ||
2266 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isBuffer(data) ||
2267 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isStream(data) ||
2268 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFile(data) ||
2269 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isBlob(data) ||
2270 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isReadableStream(data)
2271 - ) {
2272 - return data;
2273 - }
2274 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArrayBufferView(data)) {
2275 - return data.buffer;
2276 - }
2277 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isURLSearchParams(data)) {
2278 - headers.setContentType('application/x-www-form-urlencoded;charset=utf-8', false);
2279 - return data.toString();
2280 - }
2281 -
2282 - let isFileList;
2283 -
2284 - if (isObjectPayload) {
2285 - if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
2286 - return (0,_helpers_toURLEncodedForm_js__WEBPACK_IMPORTED_MODULE_4__["default"])(data, this.formSerializer).toString();
2287 - }
2288 -
2289 - if ((isFileList = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFileList(data)) || contentType.indexOf('multipart/form-data') > -1) {
2290 - const _FormData = this.env && this.env.FormData;
2291 -
2292 - return (0,_helpers_toFormData_js__WEBPACK_IMPORTED_MODULE_3__["default"])(
2293 - isFileList ? {'files[]': data} : data,
2294 - _FormData && new _FormData(),
2295 - this.formSerializer
2296 - );
2297 - }
2298 - }
2299 -
2300 - if (isObjectPayload || hasJSONContentType ) {
2301 - headers.setContentType('application/json', false);
2302 - return stringifySafely(data);
2303 - }
2304 -
2305 - return data;
2306 - }],
2307 -
2308 - transformResponse: [function transformResponse(data) {
2309 - const transitional = this.transitional || defaults.transitional;
2310 - const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
2311 - const JSONRequested = this.responseType === 'json';
2312 -
2313 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isResponse(data) || _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isReadableStream(data)) {
2314 - return data;
2315 - }
2316 -
2317 - if (data && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(data) && ((forcedJSONParsing && !this.responseType) || JSONRequested)) {
2318 - const silentJSONParsing = transitional && transitional.silentJSONParsing;
2319 - const strictJSONParsing = !silentJSONParsing && JSONRequested;
2320 -
2321 - try {
2322 - return JSON.parse(data, this.parseReviver);
2323 - } catch (e) {
2324 - if (strictJSONParsing) {
2325 - if (e.name === 'SyntaxError') {
2326 - throw _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].from(e, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_BAD_RESPONSE, this, null, this.response);
2327 - }
2328 - throw e;
2329 - }
2330 - }
2331 - }
2332 -
2333 - return data;
2334 - }],
2335 -
2336 - /**
2337 - * A timeout in milliseconds to abort a request. If set to 0 (default) a
2338 - * timeout is not created.
2339 - */
2340 - timeout: 0,
2341 -
2342 - xsrfCookieName: 'XSRF-TOKEN',
2343 - xsrfHeaderName: 'X-XSRF-TOKEN',
2344 -
2345 - maxContentLength: -1,
2346 - maxBodyLength: -1,
2347 -
2348 - env: {
2349 - FormData: _platform_index_js__WEBPACK_IMPORTED_MODULE_5__["default"].classes.FormData,
2350 - Blob: _platform_index_js__WEBPACK_IMPORTED_MODULE_5__["default"].classes.Blob
2351 - },
2352 -
2353 - validateStatus: function validateStatus(status) {
2354 - return status >= 200 && status < 300;
2355 - },
2356 -
2357 - headers: {
2358 - common: {
2359 - 'Accept': 'application/json, text/plain, */*',
2360 - 'Content-Type': undefined
2361 - }
2362 - }
2363 -};
2364 -
2365 -_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(['delete', 'get', 'head', 'post', 'put', 'patch'], (method) => {
2366 - defaults.headers[method] = {};
2367 -});
2368 -
2369 -/* harmony default export */ __webpack_exports__["default"] = (defaults);
2370 -
2371 -
2372 -/***/ }),
2373 -
2374 -/***/ "./node_modules/axios/lib/defaults/transitional.js":
2375 -/*!*********************************************************!*\
2376 - !*** ./node_modules/axios/lib/defaults/transitional.js ***!
2377 - \*********************************************************/
2378 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2379 -
2380 -__webpack_require__.r(__webpack_exports__);
2381 -
2382 -
2383 -/* harmony default export */ __webpack_exports__["default"] = ({
2384 - silentJSONParsing: true,
2385 - forcedJSONParsing: true,
2386 - clarifyTimeoutError: false
2387 -});
2388 -
2389 -
2390 -/***/ }),
2391 -
2392 -/***/ "./node_modules/axios/lib/env/data.js":
2393 -/*!********************************************!*\
2394 - !*** ./node_modules/axios/lib/env/data.js ***!
2395 - \********************************************/
2396 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2397 -
2398 -__webpack_require__.r(__webpack_exports__);
2399 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2400 -/* harmony export */ VERSION: function() { return /* binding */ VERSION; }
2401 -/* harmony export */ });
2402 -const VERSION = "1.13.2";
2403 -
2404 -/***/ }),
2405 -
2406 -/***/ "./node_modules/axios/lib/helpers/AxiosURLSearchParams.js":
2407 -/*!****************************************************************!*\
2408 - !*** ./node_modules/axios/lib/helpers/AxiosURLSearchParams.js ***!
2409 - \****************************************************************/
2410 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2411 -
2412 -__webpack_require__.r(__webpack_exports__);
2413 -/* harmony import */ var _toFormData_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./toFormData.js */ "./node_modules/axios/lib/helpers/toFormData.js");
2414 -
2415 -
2416 -
2417 -
2372 +//#endregion
2373 +//#region node_modules/axios/lib/core/dispatchRequest.js
2418 2374 /**
2419 - * It encodes a string by replacing all characters that are not in the unreserved set with
2420 - * their percent-encoded equivalents
2421 - *
2422 - * @param {string} str - The string to encode.
2423 - *
2424 - * @returns {string} The encoded string.
2425 - */
2426 -function encode(str) {
2427 - const charMap = {
2428 - '!': '%21',
2429 - "'": '%27',
2430 - '(': '%28',
2431 - ')': '%29',
2432 - '~': '%7E',
2433 - '%20': '+',
2434 - '%00': '\x00'
2435 - };
2436 - return encodeURIComponent(str).replace(/[!'()~]|%20|%00/g, function replacer(match) {
2437 - return charMap[match];
2438 - });
2439 -}
2375 + * Throws a `CanceledError` if cancellation has been requested.
2376 + *
2377 + * @param {Object} config The config that is to be used for the request
2378 + *
2379 + * @returns {void}
2380 + */
2381 + function throwIfCancellationRequested(config) {
2382 + if (config.cancelToken) config.cancelToken.throwIfRequested();
2383 + if (config.signal && config.signal.aborted) throw new CanceledError$1(null, config);
2384 + }
2385 + /**
2386 + * Dispatch a request to the server using the configured adapter.
2387 + *
2388 + * @param {object} config The config that is to be used for the request
2389 + *
2390 + * @returns {Promise} The Promise to be fulfilled
2391 + */
2392 + function dispatchRequest(config) {
2393 + throwIfCancellationRequested(config);
2394 + config.headers = AxiosHeaders$1.from(config.headers);
2395 + config.data = transformData.call(config, config.transformRequest);
2396 + if ([
2397 + "post",
2398 + "put",
2399 + "patch"
2400 + ].indexOf(config.method) !== -1) config.headers.setContentType("application/x-www-form-urlencoded", false);
2401 + return adapters_default.getAdapter(config.adapter || defaults.adapter, config)(config).then(function onAdapterResolution(response) {
2402 + throwIfCancellationRequested(config);
2403 + response.data = transformData.call(config, config.transformResponse, response);
2404 + response.headers = AxiosHeaders$1.from(response.headers);
2405 + return response;
2406 + }, function onAdapterRejection(reason) {
2407 + if (!isCancel$1(reason)) {
2408 + throwIfCancellationRequested(config);
2409 + if (reason && reason.response) {
2410 + reason.response.data = transformData.call(config, config.transformResponse, reason.response);
2411 + reason.response.headers = AxiosHeaders$1.from(reason.response.headers);
2412 + }
2413 + }
2414 + return Promise.reject(reason);
2415 + });
2416 + }
2440 2417
2441 -/**
2442 - * It takes a params object and converts it to a FormData object
2443 - *
2444 - * @param {Object<string, any>} params - The parameters to be converted to a FormData object.
2445 - * @param {Object<string, any>} options - The options object passed to the Axios constructor.
2446 - *
2447 - * @returns {void}
2448 - */
2449 -function AxiosURLSearchParams(params, options) {
2450 - this._pairs = [];
2418 +//#endregion
2419 +//#region node_modules/axios/lib/env/data.js
2420 + var VERSION$1 = "1.13.2";
2451 2421
2452 - params && (0,_toFormData_js__WEBPACK_IMPORTED_MODULE_0__["default"])(params, this, options);
2453 -}
2422 +//#endregion
2423 +//#region node_modules/axios/lib/helpers/validator.js
2424 + var validators$1 = {};
2425 + [
2426 + "object",
2427 + "boolean",
2428 + "number",
2429 + "function",
2430 + "string",
2431 + "symbol"
2432 + ].forEach((type, i) => {
2433 + validators$1[type] = function validator(thing) {
2434 + return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
2435 + };
2436 + });
2437 + var deprecatedWarnings = {};
2438 + /**
2439 + * Transitional option validator
2440 + *
2441 + * @param {function|boolean?} validator - set to false if the transitional option has been removed
2442 + * @param {string?} version - deprecated version / removed since version
2443 + * @param {string?} message - some message with additional info
2444 + *
2445 + * @returns {function}
2446 + */
2447 + validators$1.transitional = function transitional(validator, version, message) {
2448 + function formatMessage(opt, desc) {
2449 + return "[Axios v" + VERSION$1 + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
2450 + }
2451 + return (value, opt, opts) => {
2452 + if (validator === false) throw new AxiosError$1(formatMessage(opt, " has been removed" + (version ? " in " + version : "")), AxiosError$1.ERR_DEPRECATED);
2453 + if (version && !deprecatedWarnings[opt]) {
2454 + deprecatedWarnings[opt] = true;
2455 + console.warn(formatMessage(opt, " has been deprecated since v" + version + " and will be removed in the near future"));
2456 + }
2457 + return validator ? validator(value, opt, opts) : true;
2458 + };
2459 + };
2460 + validators$1.spelling = function spelling(correctSpelling) {
2461 + return (value, opt) => {
2462 + console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
2463 + return true;
2464 + };
2465 + };
2466 + /**
2467 + * Assert object's properties type
2468 + *
2469 + * @param {object} options
2470 + * @param {object} schema
2471 + * @param {boolean?} allowUnknown
2472 + *
2473 + * @returns {object}
2474 + */
2475 + function assertOptions(options, schema, allowUnknown) {
2476 + if (typeof options !== "object") throw new AxiosError$1("options must be an object", AxiosError$1.ERR_BAD_OPTION_VALUE);
2477 + const keys = Object.keys(options);
2478 + let i = keys.length;
2479 + while (i-- > 0) {
2480 + const opt = keys[i];
2481 + const validator = schema[opt];
2482 + if (validator) {
2483 + const value = options[opt];
2484 + const result = value === void 0 || validator(value, opt, options);
2485 + if (result !== true) throw new AxiosError$1("option " + opt + " must be " + result, AxiosError$1.ERR_BAD_OPTION_VALUE);
2486 + continue;
2487 + }
2488 + if (allowUnknown !== true) throw new AxiosError$1("Unknown option " + opt, AxiosError$1.ERR_BAD_OPTION);
2489 + }
2490 + }
2491 + var validator_default = {
2492 + assertOptions,
2493 + validators: validators$1
2494 + };
2454 2495
2455 -const prototype = AxiosURLSearchParams.prototype;
2496 +//#endregion
2497 +//#region node_modules/axios/lib/core/Axios.js
2498 + var validators = validator_default.validators;
2499 + /**
2500 + * Create a new instance of Axios
2501 + *
2502 + * @param {Object} instanceConfig The default config for the instance
2503 + *
2504 + * @return {Axios} A new instance of Axios
2505 + */
2506 + var Axios$1 = class {
2507 + static {
2508 + __name(this, "Axios");
2509 + }
2510 + constructor(instanceConfig) {
2511 + this.defaults = instanceConfig || {};
2512 + this.interceptors = {
2513 + request: new InterceptorManager(),
2514 + response: new InterceptorManager()
2515 + };
2516 + }
2517 + /**
2518 + * Dispatch a request
2519 + *
2520 + * @param {String|Object} configOrUrl The config specific for this request (merged with this.defaults)
2521 + * @param {?Object} config
2522 + *
2523 + * @returns {Promise} The Promise to be fulfilled
2524 + */
2525 + async request(configOrUrl, config) {
2526 + try {
2527 + return await this._request(configOrUrl, config);
2528 + } catch (err) {
2529 + if (err instanceof Error) {
2530 + let dummy = {};
2531 + Error.captureStackTrace ? Error.captureStackTrace(dummy) : dummy = /* @__PURE__ */ new Error();
2532 + const stack = dummy.stack ? dummy.stack.replace(/^.+\n/, "") : "";
2533 + try {
2534 + if (!err.stack) err.stack = stack;
2535 + else if (stack && !String(err.stack).endsWith(stack.replace(/^.+\n.+\n/, ""))) err.stack += "\n" + stack;
2536 + } catch (e) {}
2537 + }
2538 + throw err;
2539 + }
2540 + }
2541 + _request(configOrUrl, config) {
2542 + if (typeof configOrUrl === "string") {
2543 + config = config || {};
2544 + config.url = configOrUrl;
2545 + } else config = configOrUrl || {};
2546 + config = mergeConfig$1(this.defaults, config);
2547 + const { transitional, paramsSerializer, headers } = config;
2548 + if (transitional !== void 0) validator_default.assertOptions(transitional, {
2549 + silentJSONParsing: validators.transitional(validators.boolean),
2550 + forcedJSONParsing: validators.transitional(validators.boolean),
2551 + clarifyTimeoutError: validators.transitional(validators.boolean)
2552 + }, false);
2553 + if (paramsSerializer != null) if (utils_default.isFunction(paramsSerializer)) config.paramsSerializer = { serialize: paramsSerializer };
2554 + else validator_default.assertOptions(paramsSerializer, {
2555 + encode: validators.function,
2556 + serialize: validators.function
2557 + }, true);
2558 + if (config.allowAbsoluteUrls !== void 0) {} else if (this.defaults.allowAbsoluteUrls !== void 0) config.allowAbsoluteUrls = this.defaults.allowAbsoluteUrls;
2559 + else config.allowAbsoluteUrls = true;
2560 + validator_default.assertOptions(config, {
2561 + baseUrl: validators.spelling("baseURL"),
2562 + withXsrfToken: validators.spelling("withXSRFToken")
2563 + }, true);
2564 + config.method = (config.method || this.defaults.method || "get").toLowerCase();
2565 + let contextHeaders = headers && utils_default.merge(headers.common, headers[config.method]);
2566 + headers && utils_default.forEach([
2567 + "delete",
2568 + "get",
2569 + "head",
2570 + "post",
2571 + "put",
2572 + "patch",
2573 + "common"
2574 + ], (method) => {
2575 + delete headers[method];
2576 + });
2577 + config.headers = AxiosHeaders$1.concat(contextHeaders, headers);
2578 + const requestInterceptorChain = [];
2579 + let synchronousRequestInterceptors = true;
2580 + this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
2581 + if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) return;
2582 + synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
2583 + requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
2584 + });
2585 + const responseInterceptorChain = [];
2586 + this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
2587 + responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
2588 + });
2589 + let promise;
2590 + let i = 0;
2591 + let len;
2592 + if (!synchronousRequestInterceptors) {
2593 + const chain = [dispatchRequest.bind(this), void 0];
2594 + chain.unshift(...requestInterceptorChain);
2595 + chain.push(...responseInterceptorChain);
2596 + len = chain.length;
2597 + promise = Promise.resolve(config);
2598 + while (i < len) promise = promise.then(chain[i++], chain[i++]);
2599 + return promise;
2600 + }
2601 + len = requestInterceptorChain.length;
2602 + let newConfig = config;
2603 + while (i < len) {
2604 + const onFulfilled = requestInterceptorChain[i++];
2605 + const onRejected = requestInterceptorChain[i++];
2606 + try {
2607 + newConfig = onFulfilled(newConfig);
2608 + } catch (error) {
2609 + onRejected.call(this, error);
2610 + break;
2611 + }
2612 + }
2613 + try {
2614 + promise = dispatchRequest.call(this, newConfig);
2615 + } catch (error) {
2616 + return Promise.reject(error);
2617 + }
2618 + i = 0;
2619 + len = responseInterceptorChain.length;
2620 + while (i < len) promise = promise.then(responseInterceptorChain[i++], responseInterceptorChain[i++]);
2621 + return promise;
2622 + }
2623 + getUri(config) {
2624 + config = mergeConfig$1(this.defaults, config);
2625 + return buildURL(buildFullPath(config.baseURL, config.url, config.allowAbsoluteUrls), config.params, config.paramsSerializer);
2626 + }
2627 + };
2628 + utils_default.forEach([
2629 + "delete",
2630 + "get",
2631 + "head",
2632 + "options"
2633 + ], function forEachMethodNoData(method) {
2634 + Axios$1.prototype[method] = function(url, config) {
2635 + return this.request(mergeConfig$1(config || {}, {
2636 + method,
2637 + url,
2638 + data: (config || {}).data
2639 + }));
2640 + };
2641 + });
2642 + utils_default.forEach([
2643 + "post",
2644 + "put",
2645 + "patch"
2646 + ], function forEachMethodWithData(method) {
2647 + function generateHTTPMethod(isForm) {
2648 + return function httpMethod(url, data, config) {
2649 + return this.request(mergeConfig$1(config || {}, {
2650 + method,
2651 + headers: isForm ? { "Content-Type": "multipart/form-data" } : {},
2652 + url,
2653 + data
2654 + }));
2655 + };
2656 + }
2657 + Axios$1.prototype[method] = generateHTTPMethod();
2658 + Axios$1.prototype[method + "Form"] = generateHTTPMethod(true);
2659 + });
2456 2660
2457 -prototype.append = function append(name, value) {
2458 - this._pairs.push([name, value]);
2459 -};
2460 -
2461 -prototype.toString = function toString(encoder) {
2462 - const _encode = encoder ? function(value) {
2463 - return encoder.call(this, value, encode);
2464 - } : encode;
2465 -
2466 - return this._pairs.map(function each(pair) {
2467 - return _encode(pair[0]) + '=' + _encode(pair[1]);
2468 - }, '').join('&');
2469 -};
2470 -
2471 -/* harmony default export */ __webpack_exports__["default"] = (AxiosURLSearchParams);
2472 -
2473 -
2474 -/***/ }),
2475 -
2476 -/***/ "./node_modules/axios/lib/helpers/HttpStatusCode.js":
2477 -/*!**********************************************************!*\
2478 - !*** ./node_modules/axios/lib/helpers/HttpStatusCode.js ***!
2479 - \**********************************************************/
2480 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2481 -
2482 -__webpack_require__.r(__webpack_exports__);
2483 -const HttpStatusCode = {
2484 - Continue: 100,
2485 - SwitchingProtocols: 101,
2486 - Processing: 102,
2487 - EarlyHints: 103,
2488 - Ok: 200,
2489 - Created: 201,
2490 - Accepted: 202,
2491 - NonAuthoritativeInformation: 203,
2492 - NoContent: 204,
2493 - ResetContent: 205,
2494 - PartialContent: 206,
2495 - MultiStatus: 207,
2496 - AlreadyReported: 208,
2497 - ImUsed: 226,
2498 - MultipleChoices: 300,
2499 - MovedPermanently: 301,
2500 - Found: 302,
2501 - SeeOther: 303,
2502 - NotModified: 304,
2503 - UseProxy: 305,
2504 - Unused: 306,
2505 - TemporaryRedirect: 307,
2506 - PermanentRedirect: 308,
2507 - BadRequest: 400,
2508 - Unauthorized: 401,
2509 - PaymentRequired: 402,
2510 - Forbidden: 403,
2511 - NotFound: 404,
2512 - MethodNotAllowed: 405,
2513 - NotAcceptable: 406,
2514 - ProxyAuthenticationRequired: 407,
2515 - RequestTimeout: 408,
2516 - Conflict: 409,
2517 - Gone: 410,
2518 - LengthRequired: 411,
2519 - PreconditionFailed: 412,
2520 - PayloadTooLarge: 413,
2521 - UriTooLong: 414,
2522 - UnsupportedMediaType: 415,
2523 - RangeNotSatisfiable: 416,
2524 - ExpectationFailed: 417,
2525 - ImATeapot: 418,
2526 - MisdirectedRequest: 421,
2527 - UnprocessableEntity: 422,
2528 - Locked: 423,
2529 - FailedDependency: 424,
2530 - TooEarly: 425,
2531 - UpgradeRequired: 426,
2532 - PreconditionRequired: 428,
2533 - TooManyRequests: 429,
2534 - RequestHeaderFieldsTooLarge: 431,
2535 - UnavailableForLegalReasons: 451,
2536 - InternalServerError: 500,
2537 - NotImplemented: 501,
2538 - BadGateway: 502,
2539 - ServiceUnavailable: 503,
2540 - GatewayTimeout: 504,
2541 - HttpVersionNotSupported: 505,
2542 - VariantAlsoNegotiates: 506,
2543 - InsufficientStorage: 507,
2544 - LoopDetected: 508,
2545 - NotExtended: 510,
2546 - NetworkAuthenticationRequired: 511,
2547 - WebServerIsDown: 521,
2548 - ConnectionTimedOut: 522,
2549 - OriginIsUnreachable: 523,
2550 - TimeoutOccurred: 524,
2551 - SslHandshakeFailed: 525,
2552 - InvalidSslCertificate: 526,
2553 -};
2554 -
2555 -Object.entries(HttpStatusCode).forEach(([key, value]) => {
2556 - HttpStatusCode[value] = key;
2557 -});
2558 -
2559 -/* harmony default export */ __webpack_exports__["default"] = (HttpStatusCode);
2560 -
2561 -
2562 -/***/ }),
2563 -
2564 -/***/ "./node_modules/axios/lib/helpers/bind.js":
2565 -/*!************************************************!*\
2566 - !*** ./node_modules/axios/lib/helpers/bind.js ***!
2567 - \************************************************/
2568 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2569 -
2570 -__webpack_require__.r(__webpack_exports__);
2571 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2572 -/* harmony export */ "default": function() { return /* binding */ bind; }
2573 -/* harmony export */ });
2574 -
2575 -
2661 +//#endregion
2662 +//#region node_modules/axios/lib/cancel/CancelToken.js
2576 2663 /**
2577 - * Create a bound version of a function with a specified `this` context
2578 - *
2579 - * @param {Function} fn - The function to bind
2580 - * @param {*} thisArg - The value to be passed as the `this` parameter
2581 - * @returns {Function} A new function that will call the original function with the specified `this` context
2582 - */
2583 -function bind(fn, thisArg) {
2584 - return function wrap() {
2585 - return fn.apply(thisArg, arguments);
2586 - };
2587 -}
2664 + * A `CancelToken` is an object that can be used to request cancellation of an operation.
2665 + *
2666 + * @param {Function} executor The executor function.
2667 + *
2668 + * @returns {CancelToken}
2669 + */
2670 + var CancelToken$1 = class CancelToken$1 {
2671 + static {
2672 + __name(this, "CancelToken");
2673 + }
2674 + constructor(executor) {
2675 + if (typeof executor !== "function") throw new TypeError("executor must be a function.");
2676 + let resolvePromise;
2677 + this.promise = new Promise(function promiseExecutor(resolve) {
2678 + resolvePromise = resolve;
2679 + });
2680 + const token = this;
2681 + this.promise.then((cancel) => {
2682 + if (!token._listeners) return;
2683 + let i = token._listeners.length;
2684 + while (i-- > 0) token._listeners[i](cancel);
2685 + token._listeners = null;
2686 + });
2687 + this.promise.then = (onfulfilled) => {
2688 + let _resolve;
2689 + const promise = new Promise((resolve) => {
2690 + token.subscribe(resolve);
2691 + _resolve = resolve;
2692 + }).then(onfulfilled);
2693 + promise.cancel = function reject() {
2694 + token.unsubscribe(_resolve);
2695 + };
2696 + return promise;
2697 + };
2698 + executor(function cancel(message, config, request) {
2699 + if (token.reason) return;
2700 + token.reason = new CanceledError$1(message, config, request);
2701 + resolvePromise(token.reason);
2702 + });
2703 + }
2704 + /**
2705 + * Throws a `CanceledError` if cancellation has been requested.
2706 + */
2707 + throwIfRequested() {
2708 + if (this.reason) throw this.reason;
2709 + }
2710 + /**
2711 + * Subscribe to the cancel signal
2712 + */
2713 + subscribe(listener) {
2714 + if (this.reason) {
2715 + listener(this.reason);
2716 + return;
2717 + }
2718 + if (this._listeners) this._listeners.push(listener);
2719 + else this._listeners = [listener];
2720 + }
2721 + /**
2722 + * Unsubscribe from the cancel signal
2723 + */
2724 + unsubscribe(listener) {
2725 + if (!this._listeners) return;
2726 + const index = this._listeners.indexOf(listener);
2727 + if (index !== -1) this._listeners.splice(index, 1);
2728 + }
2729 + toAbortSignal() {
2730 + const controller = new AbortController();
2731 + const abort = (err) => {
2732 + controller.abort(err);
2733 + };
2734 + this.subscribe(abort);
2735 + controller.signal.unsubscribe = () => this.unsubscribe(abort);
2736 + return controller.signal;
2737 + }
2738 + /**
2739 + * Returns an object that contains a new `CancelToken` and a function that, when called,
2740 + * cancels the `CancelToken`.
2741 + */
2742 + static source() {
2743 + let cancel;
2744 + return {
2745 + token: new CancelToken$1(function executor(c) {
2746 + cancel = c;
2747 + }),
2748 + cancel
2749 + };
2750 + }
2751 + };
2588 2752
2589 -
2590 -/***/ }),
2591 -
2592 -/***/ "./node_modules/axios/lib/helpers/buildURL.js":
2593 -/*!****************************************************!*\
2594 - !*** ./node_modules/axios/lib/helpers/buildURL.js ***!
2595 - \****************************************************/
2596 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2597 -
2598 -__webpack_require__.r(__webpack_exports__);
2599 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2600 -/* harmony export */ "default": function() { return /* binding */ buildURL; }
2601 -/* harmony export */ });
2602 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
2603 -/* harmony import */ var _helpers_AxiosURLSearchParams_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../helpers/AxiosURLSearchParams.js */ "./node_modules/axios/lib/helpers/AxiosURLSearchParams.js");
2604 -
2605 -
2606 -
2607 -
2608 -
2753 +//#endregion
2754 +//#region node_modules/axios/lib/helpers/spread.js
2609 2755 /**
2610 - * It replaces all instances of the characters `:`, `$`, `,`, `+`, `[`, and `]` with their
2611 - * URI encoded counterparts
2612 - *
2613 - * @param {string} val The value to be encoded.
2614 - *
2615 - * @returns {string} The encoded value.
2616 - */
2617 -function encode(val) {
2618 - return encodeURIComponent(val).
2619 - replace(/%3A/gi, ':').
2620 - replace(/%24/g, '$').
2621 - replace(/%2C/gi, ',').
2622 - replace(/%20/g, '+');
2623 -}
2756 + * Syntactic sugar for invoking a function and expanding an array for arguments.
2757 + *
2758 + * Common use case would be to use `Function.prototype.apply`.
2759 + *
2760 + * ```js
2761 + * function f(x, y, z) {}
2762 + * var args = [1, 2, 3];
2763 + * f.apply(null, args);
2764 + * ```
2765 + *
2766 + * With `spread` this example can be re-written.
2767 + *
2768 + * ```js
2769 + * spread(function(x, y, z) {})([1, 2, 3]);
2770 + * ```
2771 + *
2772 + * @param {Function} callback
2773 + *
2774 + * @returns {Function}
2775 + */
2776 + function spread$1(callback) {
2777 + return function wrap(arr) {
2778 + return callback.apply(null, arr);
2779 + };
2780 + }
2781 + __name(spread$1, "spread");
2624 2782
2783 +//#endregion
2784 +//#region node_modules/axios/lib/helpers/isAxiosError.js
2625 2785 /**
2626 - * Build a URL by appending params to the end
2627 - *
2628 - * @param {string} url The base of the url (e.g., http://www.google.com)
2629 - * @param {object} [params] The params to be appended
2630 - * @param {?(object|Function)} options
2631 - *
2632 - * @returns {string} The formatted url
2633 - */
2634 -function buildURL(url, params, options) {
2635 - /*eslint no-param-reassign:0*/
2636 - if (!params) {
2637 - return url;
2638 - }
2639 -
2640 - const _encode = options && options.encode || encode;
2786 + * Determines whether the payload is an error thrown by Axios
2787 + *
2788 + * @param {*} payload The value to test
2789 + *
2790 + * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
2791 + */
2792 + function isAxiosError$1(payload) {
2793 + return utils_default.isObject(payload) && payload.isAxiosError === true;
2794 + }
2795 + __name(isAxiosError$1, "isAxiosError");
2641 2796
2642 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(options)) {
2643 - options = {
2644 - serialize: options
2645 - };
2646 - }
2797 +//#endregion
2798 +//#region node_modules/axios/lib/helpers/HttpStatusCode.js
2799 + var HttpStatusCode$1 = {
2800 + Continue: 100,
2801 + SwitchingProtocols: 101,
2802 + Processing: 102,
2803 + EarlyHints: 103,
2804 + Ok: 200,
2805 + Created: 201,
2806 + Accepted: 202,
2807 + NonAuthoritativeInformation: 203,
2808 + NoContent: 204,
2809 + ResetContent: 205,
2810 + PartialContent: 206,
2811 + MultiStatus: 207,
2812 + AlreadyReported: 208,
2813 + ImUsed: 226,
2814 + MultipleChoices: 300,
2815 + MovedPermanently: 301,
2816 + Found: 302,
2817 + SeeOther: 303,
2818 + NotModified: 304,
2819 + UseProxy: 305,
2820 + Unused: 306,
2821 + TemporaryRedirect: 307,
2822 + PermanentRedirect: 308,
2823 + BadRequest: 400,
2824 + Unauthorized: 401,
2825 + PaymentRequired: 402,
2826 + Forbidden: 403,
2827 + NotFound: 404,
2828 + MethodNotAllowed: 405,
2829 + NotAcceptable: 406,
2830 + ProxyAuthenticationRequired: 407,
2831 + RequestTimeout: 408,
2832 + Conflict: 409,
2833 + Gone: 410,
2834 + LengthRequired: 411,
2835 + PreconditionFailed: 412,
2836 + PayloadTooLarge: 413,
2837 + UriTooLong: 414,
2838 + UnsupportedMediaType: 415,
2839 + RangeNotSatisfiable: 416,
2840 + ExpectationFailed: 417,
2841 + ImATeapot: 418,
2842 + MisdirectedRequest: 421,
2843 + UnprocessableEntity: 422,
2844 + Locked: 423,
2845 + FailedDependency: 424,
2846 + TooEarly: 425,
2847 + UpgradeRequired: 426,
2848 + PreconditionRequired: 428,
2849 + TooManyRequests: 429,
2850 + RequestHeaderFieldsTooLarge: 431,
2851 + UnavailableForLegalReasons: 451,
2852 + InternalServerError: 500,
2853 + NotImplemented: 501,
2854 + BadGateway: 502,
2855 + ServiceUnavailable: 503,
2856 + GatewayTimeout: 504,
2857 + HttpVersionNotSupported: 505,
2858 + VariantAlsoNegotiates: 506,
2859 + InsufficientStorage: 507,
2860 + LoopDetected: 508,
2861 + NotExtended: 510,
2862 + NetworkAuthenticationRequired: 511,
2863 + WebServerIsDown: 521,
2864 + ConnectionTimedOut: 522,
2865 + OriginIsUnreachable: 523,
2866 + TimeoutOccurred: 524,
2867 + SslHandshakeFailed: 525,
2868 + InvalidSslCertificate: 526
2869 + };
2870 + Object.entries(HttpStatusCode$1).forEach(([key, value]) => {
2871 + HttpStatusCode$1[value] = key;
2872 + });
2647 2873
2648 - const serializeFn = options && options.serialize;
2649 -
2650 - let serializedParams;
2651 -
2652 - if (serializeFn) {
2653 - serializedParams = serializeFn(params, options);
2654 - } else {
2655 - serializedParams = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isURLSearchParams(params) ?
2656 - params.toString() :
2657 - new _helpers_AxiosURLSearchParams_js__WEBPACK_IMPORTED_MODULE_1__["default"](params, options).toString(_encode);
2658 - }
2659 -
2660 - if (serializedParams) {
2661 - const hashmarkIndex = url.indexOf("#");
2662 -
2663 - if (hashmarkIndex !== -1) {
2664 - url = url.slice(0, hashmarkIndex);
2665 - }
2666 - url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
2667 - }
2668 -
2669 - return url;
2670 -}
2671 -
2672 -
2673 -/***/ }),
2674 -
2675 -/***/ "./node_modules/axios/lib/helpers/combineURLs.js":
2676 -/*!*******************************************************!*\
2677 - !*** ./node_modules/axios/lib/helpers/combineURLs.js ***!
2678 - \*******************************************************/
2679 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2680 -
2681 -__webpack_require__.r(__webpack_exports__);
2682 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2683 -/* harmony export */ "default": function() { return /* binding */ combineURLs; }
2684 -/* harmony export */ });
2685 -
2686 -
2874 +//#endregion
2875 +//#region node_modules/axios/lib/axios.js
2687 2876 /**
2688 - * Creates a new URL by combining the specified URLs
2689 - *
2690 - * @param {string} baseURL The base URL
2691 - * @param {string} relativeURL The relative URL
2692 - *
2693 - * @returns {string} The combined URL
2694 - */
2695 -function combineURLs(baseURL, relativeURL) {
2696 - return relativeURL
2697 - ? baseURL.replace(/\/?\/$/, '') + '/' + relativeURL.replace(/^\/+/, '')
2698 - : baseURL;
2699 -}
2877 + * Create an instance of Axios
2878 + *
2879 + * @param {Object} defaultConfig The default config for the instance
2880 + *
2881 + * @returns {Axios} A new instance of Axios
2882 + */
2883 + function createInstance(defaultConfig) {
2884 + const context = new Axios$1(defaultConfig);
2885 + const instance = bind(Axios$1.prototype.request, context);
2886 + utils_default.extend(instance, Axios$1.prototype, context, { allOwnKeys: true });
2887 + utils_default.extend(instance, context, null, { allOwnKeys: true });
2888 + instance.create = function create(instanceConfig) {
2889 + return createInstance(mergeConfig$1(defaultConfig, instanceConfig));
2890 + };
2891 + return instance;
2892 + }
2893 + var axios = createInstance(defaults);
2894 + axios.Axios = Axios$1;
2895 + axios.CanceledError = CanceledError$1;
2896 + axios.CancelToken = CancelToken$1;
2897 + axios.isCancel = isCancel$1;
2898 + axios.VERSION = VERSION$1;
2899 + axios.toFormData = toFormData$1;
2900 + axios.AxiosError = AxiosError$1;
2901 + axios.Cancel = axios.CanceledError;
2902 + axios.all = function all(promises) {
2903 + return Promise.all(promises);
2904 + };
2905 + axios.spread = spread$1;
2906 + axios.isAxiosError = isAxiosError$1;
2907 + axios.mergeConfig = mergeConfig$1;
2908 + axios.AxiosHeaders = AxiosHeaders$1;
2909 + axios.formToJSON = (thing) => formDataToJSON(utils_default.isHTMLForm(thing) ? new FormData(thing) : thing);
2910 + axios.getAdapter = adapters_default.getAdapter;
2911 + axios.HttpStatusCode = HttpStatusCode$1;
2912 + axios.default = axios;
2700 2913
2914 +//#endregion
2915 +//#region node_modules/axios/index.js
2916 + var { Axios, AxiosError, CanceledError, isCancel, CancelToken, VERSION, all, Cancel, isAxiosError, spread, toFormData, AxiosHeaders, HttpStatusCode, formToJSON, getAdapter, mergeConfig } = axios;
2701 2917
2702 -/***/ }),
2918 +//#endregion
2919 +//#region packages/packages/libs/http-client/src/env.ts
2920 + var { env } = (0, _elementor_env.parseEnv)("@elementor/http-client");
2703 2921
2704 -/***/ "./node_modules/axios/lib/helpers/composeSignals.js":
2705 -/*!**********************************************************!*\
2706 - !*** ./node_modules/axios/lib/helpers/composeSignals.js ***!
2707 - \**********************************************************/
2708 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2922 +//#endregion
2923 +//#region packages/packages/libs/http-client/src/http.ts
2924 + var MAX_RETRIES = 3;
2925 + var BASE_DELAY_MS = 1e3;
2926 + var CACHE_TTL_MS = 2e4;
2927 + var cache = /* @__PURE__ */ new Map();
2928 + var cacheableUrls = /* @__PURE__ */ new Map();
2929 + function registerUrlForCache(partialUrl, ttlMs = CACHE_TTL_MS) {
2930 + cacheableUrls.set(partialUrl, ttlMs);
2931 + }
2932 + function getUrlCacheTtl(url) {
2933 + for (const [pattern, ttl] of cacheableUrls) if (url.includes(pattern)) return ttl;
2934 + return null;
2935 + }
2936 + function getCacheKey(config) {
2937 + const url = config.url ?? "";
2938 + const params = config.params ? JSON.stringify(config.params) : "";
2939 + return `${config.baseURL ?? ""}${url}${params}`;
2940 + }
2941 + function getCachedResponse(config) {
2942 + if (config.method?.toLowerCase() !== "get") return null;
2943 + const ttl = getUrlCacheTtl(`${config.baseURL ?? ""}${config.url ?? ""}`);
2944 + if (ttl === null) return null;
2945 + const key = getCacheKey(config);
2946 + const entry = cache.get(key);
2947 + if (!entry) return null;
2948 + if (Date.now() - entry.timestamp > ttl) {
2949 + cache.delete(key);
2950 + return null;
2951 + }
2952 + return entry.response;
2953 + }
2954 + function setCachedResponse(config, response) {
2955 + if (!config || config.method?.toLowerCase() !== "get") return;
2956 + if (getUrlCacheTtl(`${config.baseURL ?? ""}${config.url ?? ""}`) === null) return;
2957 + const key = getCacheKey(config);
2958 + cache.set(key, {
2959 + response,
2960 + timestamp: Date.now()
2961 + });
2962 + }
2963 + var RETRYABLE_METHODS = /* @__PURE__ */ new Set([
2964 + "get",
2965 + "head",
2966 + "options",
2967 + "put",
2968 + "delete"
2969 + ]);
2970 + var instance;
2971 + var httpService = () => {
2972 + if (!instance) {
2973 + instance = axios.create({
2974 + baseURL: env.base_url,
2975 + timeout: 1e4,
2976 + headers: {
2977 + "Content-Type": "application/json",
2978 + ...env.headers
2979 + }
2980 + });
2981 + instance.interceptors.request.use((config) => {
2982 + const cachedResponse = getCachedResponse(config);
2983 + if (cachedResponse) {
2984 + const controller = new AbortController();
2985 + controller.abort();
2986 + return {
2987 + ...config,
2988 + signal: controller.signal,
2989 + __cachedResponse: cachedResponse
2990 + };
2991 + }
2992 + return config;
2993 + });
2994 + instance.interceptors.response.use((response) => {
2995 + setCachedResponse(response.config, response);
2996 + return response;
2997 + }, async (error) => {
2998 + const config = error.config;
2999 + if (config?.__cachedResponse) return config.__cachedResponse;
3000 + if (!config || !shouldRetry(error)) return Promise.reject(error);
3001 + const retryCount = config.__retryCount ?? 0;
3002 + if (retryCount >= MAX_RETRIES) return Promise.reject(error);
3003 + await sleep(BASE_DELAY_MS * Math.pow(2, retryCount) + Math.random() * BASE_DELAY_MS * .1);
3004 + const baseTimeout = config.__baseTimeout ?? config.timeout ?? 1e4;
3005 + return instance({
3006 + ...config,
3007 + __retryCount: retryCount + 1,
3008 + __baseTimeout: baseTimeout,
3009 + timeout: baseTimeout * (retryCount + 2)
3010 + });
3011 + });
3012 + }
3013 + return instance;
3014 + };
3015 + function shouldRetry(error) {
3016 + const method = error.config?.method?.toLowerCase();
3017 + if (method && !RETRYABLE_METHODS.has(method)) return false;
3018 + if (!error.response) return true;
3019 + if (error.response.status === 429) return true;
3020 + return error.response.status >= 500;
3021 + }
3022 + function sleep(ms) {
3023 + return new Promise((resolve) => setTimeout(resolve, ms));
3024 + }
2709 3025
2710 -__webpack_require__.r(__webpack_exports__);
2711 -/* harmony import */ var _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../cancel/CanceledError.js */ "./node_modules/axios/lib/cancel/CanceledError.js");
2712 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
2713 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
3026 +//#endregion
3027 +//#region packages/packages/libs/http-client/src/index.ts
3028 + var src_exports = /* @__PURE__ */ __exportAll({
3029 + AxiosError: () => AxiosError,
3030 + httpService: () => httpService,
3031 + registerUrlForCache: () => registerUrlForCache
3032 + });
2714 3033
3034 +//#endregion
3035 +//#region \0elementor-package-library-entry
3036 + (window.elementorV2 = window.elementorV2 || {}).httpClient = src_exports;
2715 3037
2716 -
2717 -
2718 -const composeSignals = (signals, timeout) => {
2719 - const {length} = (signals = signals ? signals.filter(Boolean) : []);
2720 -
2721 - if (timeout || length) {
2722 - let controller = new AbortController();
2723 -
2724 - let aborted;
2725 -
2726 - const onabort = function (reason) {
2727 - if (!aborted) {
2728 - aborted = true;
2729 - unsubscribe();
2730 - const err = reason instanceof Error ? reason : this.reason;
2731 - controller.abort(err instanceof _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"] ? err : new _cancel_CanceledError_js__WEBPACK_IMPORTED_MODULE_0__["default"](err instanceof Error ? err.message : err));
2732 - }
2733 - }
2734 -
2735 - let timer = timeout && setTimeout(() => {
2736 - timer = null;
2737 - onabort(new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"](`timeout ${timeout} of ms exceeded`, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ETIMEDOUT))
2738 - }, timeout)
2739 -
2740 - const unsubscribe = () => {
2741 - if (signals) {
2742 - timer && clearTimeout(timer);
2743 - timer = null;
2744 - signals.forEach(signal => {
2745 - signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);
2746 - });
2747 - signals = null;
2748 - }
2749 - }
2750 -
2751 - signals.forEach((signal) => signal.addEventListener('abort', onabort));
2752 -
2753 - const {signal} = controller;
2754 -
2755 - signal.unsubscribe = () => _utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].asap(unsubscribe);
2756 -
2757 - return signal;
2758 - }
2759 -}
2760 -
2761 -/* harmony default export */ __webpack_exports__["default"] = (composeSignals);
2762 -
2763 -
2764 -/***/ }),
2765 -
2766 -/***/ "./node_modules/axios/lib/helpers/cookies.js":
2767 -/*!***************************************************!*\
2768 - !*** ./node_modules/axios/lib/helpers/cookies.js ***!
2769 - \***************************************************/
2770 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2771 -
2772 -__webpack_require__.r(__webpack_exports__);
2773 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js");
2774 -/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js");
2775 -
2776 -
2777 -
2778 -/* harmony default export */ __webpack_exports__["default"] = (_platform_index_js__WEBPACK_IMPORTED_MODULE_1__["default"].hasStandardBrowserEnv ?
2779 -
2780 - // Standard browser envs support document.cookie
2781 - {
2782 - write(name, value, expires, path, domain, secure, sameSite) {
2783 - if (typeof document === 'undefined') return;
2784 -
2785 - const cookie = [`${name}=${encodeURIComponent(value)}`];
2786 -
2787 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isNumber(expires)) {
2788 - cookie.push(`expires=${new Date(expires).toUTCString()}`);
2789 - }
2790 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(path)) {
2791 - cookie.push(`path=${path}`);
2792 - }
2793 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(domain)) {
2794 - cookie.push(`domain=${domain}`);
2795 - }
2796 - if (secure === true) {
2797 - cookie.push('secure');
2798 - }
2799 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(sameSite)) {
2800 - cookie.push(`SameSite=${sameSite}`);
2801 - }
2802 -
2803 - document.cookie = cookie.join('; ');
2804 - },
2805 -
2806 - read(name) {
2807 - if (typeof document === 'undefined') return null;
2808 - const match = document.cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)'));
2809 - return match ? decodeURIComponent(match[1]) : null;
2810 - },
2811 -
2812 - remove(name) {
2813 - this.write(name, '', Date.now() - 86400000, '/');
2814 - }
2815 - }
2816 -
2817 - :
2818 -
2819 - // Non-standard browser env (web workers, react-native) lack needed support.
2820 - {
2821 - write() {},
2822 - read() {
2823 - return null;
2824 - },
2825 - remove() {}
2826 - });
2827 -
2828 -
2829 -
2830 -/***/ }),
2831 -
2832 -/***/ "./node_modules/axios/lib/helpers/formDataToJSON.js":
2833 -/*!**********************************************************!*\
2834 - !*** ./node_modules/axios/lib/helpers/formDataToJSON.js ***!
2835 - \**********************************************************/
2836 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2837 -
2838 -__webpack_require__.r(__webpack_exports__);
2839 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
2840 -
2841 -
2842 -
2843 -
2844 -/**
2845 - * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
2846 - *
2847 - * @param {string} name - The name of the property to get.
2848 - *
2849 - * @returns An array of strings.
2850 - */
2851 -function parsePropPath(name) {
2852 - // foo[x][y][z]
2853 - // foo.x.y.z
2854 - // foo-x-y-z
2855 - // foo x y z
2856 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].matchAll(/\w+|\[(\w*)]/g, name).map(match => {
2857 - return match[0] === '[]' ? '' : match[1] || match[0];
2858 - });
2859 -}
2860 -
2861 -/**
2862 - * Convert an array to an object.
2863 - *
2864 - * @param {Array<any>} arr - The array to convert to an object.
2865 - *
2866 - * @returns An object with the same keys and values as the array.
2867 - */
2868 -function arrayToObject(arr) {
2869 - const obj = {};
2870 - const keys = Object.keys(arr);
2871 - let i;
2872 - const len = keys.length;
2873 - let key;
2874 - for (i = 0; i < len; i++) {
2875 - key = keys[i];
2876 - obj[key] = arr[key];
2877 - }
2878 - return obj;
2879 -}
2880 -
2881 -/**
2882 - * It takes a FormData object and returns a JavaScript object
2883 - *
2884 - * @param {string} formData The FormData object to convert to JSON.
2885 - *
2886 - * @returns {Object<string, any> | null} The converted object.
2887 - */
2888 -function formDataToJSON(formData) {
2889 - function buildPath(path, value, target, index) {
2890 - let name = path[index++];
2891 -
2892 - if (name === '__proto__') return true;
2893 -
2894 - const isNumericKey = Number.isFinite(+name);
2895 - const isLast = index >= path.length;
2896 - name = !name && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(target) ? target.length : name;
2897 -
2898 - if (isLast) {
2899 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasOwnProp(target, name)) {
2900 - target[name] = [target[name], value];
2901 - } else {
2902 - target[name] = value;
2903 - }
2904 -
2905 - return !isNumericKey;
2906 - }
2907 -
2908 - if (!target[name] || !_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(target[name])) {
2909 - target[name] = [];
2910 - }
2911 -
2912 - const result = buildPath(path, value, target[name], index);
2913 -
2914 - if (result && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(target[name])) {
2915 - target[name] = arrayToObject(target[name]);
2916 - }
2917 -
2918 - return !isNumericKey;
2919 - }
2920 -
2921 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFormData(formData) && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(formData.entries)) {
2922 - const obj = {};
2923 -
2924 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEachEntry(formData, (name, value) => {
2925 - buildPath(parsePropPath(name), value, obj, 0);
2926 - });
2927 -
2928 - return obj;
2929 - }
2930 -
2931 - return null;
2932 -}
2933 -
2934 -/* harmony default export */ __webpack_exports__["default"] = (formDataToJSON);
2935 -
2936 -
2937 -/***/ }),
2938 -
2939 -/***/ "./node_modules/axios/lib/helpers/isAbsoluteURL.js":
2940 -/*!*********************************************************!*\
2941 - !*** ./node_modules/axios/lib/helpers/isAbsoluteURL.js ***!
2942 - \*********************************************************/
2943 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2944 -
2945 -__webpack_require__.r(__webpack_exports__);
2946 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2947 -/* harmony export */ "default": function() { return /* binding */ isAbsoluteURL; }
2948 -/* harmony export */ });
2949 -
2950 -
2951 -/**
2952 - * Determines whether the specified URL is absolute
2953 - *
2954 - * @param {string} url The URL to test
2955 - *
2956 - * @returns {boolean} True if the specified URL is absolute, otherwise false
2957 - */
2958 -function isAbsoluteURL(url) {
2959 - // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
2960 - // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
2961 - // by any combination of letters, digits, plus, period, or hyphen.
2962 - return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
2963 -}
2964 -
2965 -
2966 -/***/ }),
2967 -
2968 -/***/ "./node_modules/axios/lib/helpers/isAxiosError.js":
2969 -/*!********************************************************!*\
2970 - !*** ./node_modules/axios/lib/helpers/isAxiosError.js ***!
2971 - \********************************************************/
2972 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
2973 -
2974 -__webpack_require__.r(__webpack_exports__);
2975 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2976 -/* harmony export */ "default": function() { return /* binding */ isAxiosError; }
2977 -/* harmony export */ });
2978 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js");
2979 -
2980 -
2981 -
2982 -
2983 -/**
2984 - * Determines whether the payload is an error thrown by Axios
2985 - *
2986 - * @param {*} payload The value to test
2987 - *
2988 - * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
2989 - */
2990 -function isAxiosError(payload) {
2991 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(payload) && (payload.isAxiosError === true);
2992 -}
2993 -
2994 -
2995 -/***/ }),
2996 -
2997 -/***/ "./node_modules/axios/lib/helpers/isURLSameOrigin.js":
2998 -/*!***********************************************************!*\
2999 - !*** ./node_modules/axios/lib/helpers/isURLSameOrigin.js ***!
3000 - \***********************************************************/
3001 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3002 -
3003 -__webpack_require__.r(__webpack_exports__);
3004 -/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js");
3005 -
3006 -
3007 -/* harmony default export */ __webpack_exports__["default"] = (_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasStandardBrowserEnv ? ((origin, isMSIE) => (url) => {
3008 - url = new URL(url, _platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].origin);
3009 -
3010 - return (
3011 - origin.protocol === url.protocol &&
3012 - origin.host === url.host &&
3013 - (isMSIE || origin.port === url.port)
3014 - );
3015 -})(
3016 - new URL(_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].origin),
3017 - _platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].navigator && /(msie|trident)/i.test(_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].navigator.userAgent)
3018 -) : () => true);
3019 -
3020 -
3021 -/***/ }),
3022 -
3023 -/***/ "./node_modules/axios/lib/helpers/null.js":
3024 -/*!************************************************!*\
3025 - !*** ./node_modules/axios/lib/helpers/null.js ***!
3026 - \************************************************/
3027 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3028 -
3029 -__webpack_require__.r(__webpack_exports__);
3030 -// eslint-disable-next-line strict
3031 -/* harmony default export */ __webpack_exports__["default"] = (null);
3032 -
3033 -
3034 -/***/ }),
3035 -
3036 -/***/ "./node_modules/axios/lib/helpers/parseHeaders.js":
3037 -/*!********************************************************!*\
3038 - !*** ./node_modules/axios/lib/helpers/parseHeaders.js ***!
3039 - \********************************************************/
3040 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3041 -
3042 -__webpack_require__.r(__webpack_exports__);
3043 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./../utils.js */ "./node_modules/axios/lib/utils.js");
3044 -
3045 -
3046 -
3047 -
3048 -// RawAxiosHeaders whose duplicates are ignored by node
3049 -// c.f. https://nodejs.org/api/http.html#http_message_headers
3050 -const ignoreDuplicateOf = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toObjectSet([
3051 - 'age', 'authorization', 'content-length', 'content-type', 'etag',
3052 - 'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
3053 - 'last-modified', 'location', 'max-forwards', 'proxy-authorization',
3054 - 'referer', 'retry-after', 'user-agent'
3055 -]);
3056 -
3057 -/**
3058 - * Parse headers into an object
3059 - *
3060 - * ```
3061 - * Date: Wed, 27 Aug 2014 08:58:49 GMT
3062 - * Content-Type: application/json
3063 - * Connection: keep-alive
3064 - * Transfer-Encoding: chunked
3065 - * ```
3066 - *
3067 - * @param {String} rawHeaders Headers needing to be parsed
3068 - *
3069 - * @returns {Object} Headers parsed into an object
3070 - */
3071 -/* harmony default export */ __webpack_exports__["default"] = (rawHeaders => {
3072 - const parsed = {};
3073 - let key;
3074 - let val;
3075 - let i;
3076 -
3077 - rawHeaders && rawHeaders.split('\n').forEach(function parser(line) {
3078 - i = line.indexOf(':');
3079 - key = line.substring(0, i).trim().toLowerCase();
3080 - val = line.substring(i + 1).trim();
3081 -
3082 - if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
3083 - return;
3084 - }
3085 -
3086 - if (key === 'set-cookie') {
3087 - if (parsed[key]) {
3088 - parsed[key].push(val);
3089 - } else {
3090 - parsed[key] = [val];
3091 - }
3092 - } else {
3093 - parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
3094 - }
3095 - });
3096 -
3097 - return parsed;
3098 -});
3099 -
3100 -
3101 -/***/ }),
3102 -
3103 -/***/ "./node_modules/axios/lib/helpers/parseProtocol.js":
3104 -/*!*********************************************************!*\
3105 - !*** ./node_modules/axios/lib/helpers/parseProtocol.js ***!
3106 - \*********************************************************/
3107 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3108 -
3109 -__webpack_require__.r(__webpack_exports__);
3110 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
3111 -/* harmony export */ "default": function() { return /* binding */ parseProtocol; }
3112 -/* harmony export */ });
3113 -
3114 -
3115 -function parseProtocol(url) {
3116 - const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
3117 - return match && match[1] || '';
3118 -}
3119 -
3120 -
3121 -/***/ }),
3122 -
3123 -/***/ "./node_modules/axios/lib/helpers/progressEventReducer.js":
3124 -/*!****************************************************************!*\
3125 - !*** ./node_modules/axios/lib/helpers/progressEventReducer.js ***!
3126 - \****************************************************************/
3127 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3128 -
3129 -__webpack_require__.r(__webpack_exports__);
3130 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
3131 -/* harmony export */ asyncDecorator: function() { return /* binding */ asyncDecorator; },
3132 -/* harmony export */ progressEventDecorator: function() { return /* binding */ progressEventDecorator; },
3133 -/* harmony export */ progressEventReducer: function() { return /* binding */ progressEventReducer; }
3134 -/* harmony export */ });
3135 -/* harmony import */ var _speedometer_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./speedometer.js */ "./node_modules/axios/lib/helpers/speedometer.js");
3136 -/* harmony import */ var _throttle_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./throttle.js */ "./node_modules/axios/lib/helpers/throttle.js");
3137 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
3138 -
3139 -
3140 -
3141 -
3142 -const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
3143 - let bytesNotified = 0;
3144 - const _speedometer = (0,_speedometer_js__WEBPACK_IMPORTED_MODULE_0__["default"])(50, 250);
3145 -
3146 - return (0,_throttle_js__WEBPACK_IMPORTED_MODULE_1__["default"])(e => {
3147 - const loaded = e.loaded;
3148 - const total = e.lengthComputable ? e.total : undefined;
3149 - const progressBytes = loaded - bytesNotified;
3150 - const rate = _speedometer(progressBytes);
3151 - const inRange = loaded <= total;
3152 -
3153 - bytesNotified = loaded;
3154 -
3155 - const data = {
3156 - loaded,
3157 - total,
3158 - progress: total ? (loaded / total) : undefined,
3159 - bytes: progressBytes,
3160 - rate: rate ? rate : undefined,
3161 - estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
3162 - event: e,
3163 - lengthComputable: total != null,
3164 - [isDownloadStream ? 'download' : 'upload']: true
3165 - };
3166 -
3167 - listener(data);
3168 - }, freq);
3169 -}
3170 -
3171 -const progressEventDecorator = (total, throttled) => {
3172 - const lengthComputable = total != null;
3173 -
3174 - return [(loaded) => throttled[0]({
3175 - lengthComputable,
3176 - total,
3177 - loaded
3178 - }), throttled[1]];
3179 -}
3180 -
3181 -const asyncDecorator = (fn) => (...args) => _utils_js__WEBPACK_IMPORTED_MODULE_2__["default"].asap(() => fn(...args));
3182 -
3183 -
3184 -/***/ }),
3185 -
3186 -/***/ "./node_modules/axios/lib/helpers/resolveConfig.js":
3187 -/*!*********************************************************!*\
3188 - !*** ./node_modules/axios/lib/helpers/resolveConfig.js ***!
3189 - \*********************************************************/
3190 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3191 -
3192 -__webpack_require__.r(__webpack_exports__);
3193 -/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js");
3194 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
3195 -/* harmony import */ var _isURLSameOrigin_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./isURLSameOrigin.js */ "./node_modules/axios/lib/helpers/isURLSameOrigin.js");
3196 -/* harmony import */ var _cookies_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./cookies.js */ "./node_modules/axios/lib/helpers/cookies.js");
3197 -/* harmony import */ var _core_buildFullPath_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../core/buildFullPath.js */ "./node_modules/axios/lib/core/buildFullPath.js");
3198 -/* harmony import */ var _core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../core/mergeConfig.js */ "./node_modules/axios/lib/core/mergeConfig.js");
3199 -/* harmony import */ var _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ../core/AxiosHeaders.js */ "./node_modules/axios/lib/core/AxiosHeaders.js");
3200 -/* harmony import */ var _buildURL_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./buildURL.js */ "./node_modules/axios/lib/helpers/buildURL.js");
3201 -
3202 -
3203 -
3204 -
3205 -
3206 -
3207 -
3208 -
3209 -
3210 -/* harmony default export */ __webpack_exports__["default"] = ((config) => {
3211 - const newConfig = (0,_core_mergeConfig_js__WEBPACK_IMPORTED_MODULE_5__["default"])({}, config);
3212 -
3213 - let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
3214 -
3215 - newConfig.headers = headers = _core_AxiosHeaders_js__WEBPACK_IMPORTED_MODULE_6__["default"].from(headers);
3216 -
3217 - newConfig.url = (0,_buildURL_js__WEBPACK_IMPORTED_MODULE_7__["default"])((0,_core_buildFullPath_js__WEBPACK_IMPORTED_MODULE_4__["default"])(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);
3218 -
3219 - // HTTP basic authentication
3220 - if (auth) {
3221 - headers.set('Authorization', 'Basic ' +
3222 - btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : ''))
3223 - );
3224 - }
3225 -
3226 - if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isFormData(data)) {
3227 - if (_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasStandardBrowserEnv || _platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasStandardBrowserWebWorkerEnv) {
3228 - headers.setContentType(undefined); // browser handles it
3229 - } else if (_utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isFunction(data.getHeaders)) {
3230 - // Node.js FormData (like form-data package)
3231 - const formHeaders = data.getHeaders();
3232 - // Only set safe headers to avoid overwriting security headers
3233 - const allowedHeaders = ['content-type', 'content-length'];
3234 - Object.entries(formHeaders).forEach(([key, val]) => {
3235 - if (allowedHeaders.includes(key.toLowerCase())) {
3236 - headers.set(key, val);
3237 - }
3238 - });
3239 - }
3240 - }
3241 -
3242 - // Add xsrf header
3243 - // This is only done if running in a standard browser environment.
3244 - // Specifically not if we're in a web worker, or react-native.
3245 -
3246 - if (_platform_index_js__WEBPACK_IMPORTED_MODULE_0__["default"].hasStandardBrowserEnv) {
3247 - withXSRFToken && _utils_js__WEBPACK_IMPORTED_MODULE_1__["default"].isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));
3248 -
3249 - if (withXSRFToken || (withXSRFToken !== false && (0,_isURLSameOrigin_js__WEBPACK_IMPORTED_MODULE_2__["default"])(newConfig.url))) {
3250 - // Add xsrf header
3251 - const xsrfValue = xsrfHeaderName && xsrfCookieName && _cookies_js__WEBPACK_IMPORTED_MODULE_3__["default"].read(xsrfCookieName);
3252 -
3253 - if (xsrfValue) {
3254 - headers.set(xsrfHeaderName, xsrfValue);
3255 - }
3256 - }
3257 - }
3258 -
3259 - return newConfig;
3260 -});
3261 -
3262 -
3263 -
3264 -/***/ }),
3265 -
3266 -/***/ "./node_modules/axios/lib/helpers/speedometer.js":
3267 -/*!*******************************************************!*\
3268 - !*** ./node_modules/axios/lib/helpers/speedometer.js ***!
3269 - \*******************************************************/
3270 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3271 -
3272 -__webpack_require__.r(__webpack_exports__);
3273 -
3274 -
3275 -/**
3276 - * Calculate data maxRate
3277 - * @param {Number} [samplesCount= 10]
3278 - * @param {Number} [min= 1000]
3279 - * @returns {Function}
3280 - */
3281 -function speedometer(samplesCount, min) {
3282 - samplesCount = samplesCount || 10;
3283 - const bytes = new Array(samplesCount);
3284 - const timestamps = new Array(samplesCount);
3285 - let head = 0;
3286 - let tail = 0;
3287 - let firstSampleTS;
3288 -
3289 - min = min !== undefined ? min : 1000;
3290 -
3291 - return function push(chunkLength) {
3292 - const now = Date.now();
3293 -
3294 - const startedAt = timestamps[tail];
3295 -
3296 - if (!firstSampleTS) {
3297 - firstSampleTS = now;
3298 - }
3299 -
3300 - bytes[head] = chunkLength;
3301 - timestamps[head] = now;
3302 -
3303 - let i = tail;
3304 - let bytesCount = 0;
3305 -
3306 - while (i !== head) {
3307 - bytesCount += bytes[i++];
3308 - i = i % samplesCount;
3309 - }
3310 -
3311 - head = (head + 1) % samplesCount;
3312 -
3313 - if (head === tail) {
3314 - tail = (tail + 1) % samplesCount;
3315 - }
3316 -
3317 - if (now - firstSampleTS < min) {
3318 - return;
3319 - }
3320 -
3321 - const passed = startedAt && now - startedAt;
3322 -
3323 - return passed ? Math.round(bytesCount * 1000 / passed) : undefined;
3324 - };
3325 -}
3326 -
3327 -/* harmony default export */ __webpack_exports__["default"] = (speedometer);
3328 -
3329 -
3330 -/***/ }),
3331 -
3332 -/***/ "./node_modules/axios/lib/helpers/spread.js":
3333 -/*!**************************************************!*\
3334 - !*** ./node_modules/axios/lib/helpers/spread.js ***!
3335 - \**************************************************/
3336 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3337 -
3338 -__webpack_require__.r(__webpack_exports__);
3339 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
3340 -/* harmony export */ "default": function() { return /* binding */ spread; }
3341 -/* harmony export */ });
3342 -
3343 -
3344 -/**
3345 - * Syntactic sugar for invoking a function and expanding an array for arguments.
3346 - *
3347 - * Common use case would be to use `Function.prototype.apply`.
3348 - *
3349 - * ```js
3350 - * function f(x, y, z) {}
3351 - * var args = [1, 2, 3];
3352 - * f.apply(null, args);
3353 - * ```
3354 - *
3355 - * With `spread` this example can be re-written.
3356 - *
3357 - * ```js
3358 - * spread(function(x, y, z) {})([1, 2, 3]);
3359 - * ```
3360 - *
3361 - * @param {Function} callback
3362 - *
3363 - * @returns {Function}
3364 - */
3365 -function spread(callback) {
3366 - return function wrap(arr) {
3367 - return callback.apply(null, arr);
3368 - };
3369 -}
3370 -
3371 -
3372 -/***/ }),
3373 -
3374 -/***/ "./node_modules/axios/lib/helpers/throttle.js":
3375 -/*!****************************************************!*\
3376 - !*** ./node_modules/axios/lib/helpers/throttle.js ***!
3377 - \****************************************************/
3378 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3379 -
3380 -__webpack_require__.r(__webpack_exports__);
3381 -/**
3382 - * Throttle decorator
3383 - * @param {Function} fn
3384 - * @param {Number} freq
3385 - * @return {Function}
3386 - */
3387 -function throttle(fn, freq) {
3388 - let timestamp = 0;
3389 - let threshold = 1000 / freq;
3390 - let lastArgs;
3391 - let timer;
3392 -
3393 - const invoke = (args, now = Date.now()) => {
3394 - timestamp = now;
3395 - lastArgs = null;
3396 - if (timer) {
3397 - clearTimeout(timer);
3398 - timer = null;
3399 - }
3400 - fn(...args);
3401 - }
3402 -
3403 - const throttled = (...args) => {
3404 - const now = Date.now();
3405 - const passed = now - timestamp;
3406 - if ( passed >= threshold) {
3407 - invoke(args, now);
3408 - } else {
3409 - lastArgs = args;
3410 - if (!timer) {
3411 - timer = setTimeout(() => {
3412 - timer = null;
3413 - invoke(lastArgs)
3414 - }, threshold - passed);
3415 - }
3416 - }
3417 - }
3418 -
3419 - const flush = () => lastArgs && invoke(lastArgs);
3420 -
3421 - return [throttled, flush];
3422 -}
3423 -
3424 -/* harmony default export */ __webpack_exports__["default"] = (throttle);
3425 -
3426 -
3427 -/***/ }),
3428 -
3429 -/***/ "./node_modules/axios/lib/helpers/toFormData.js":
3430 -/*!******************************************************!*\
3431 - !*** ./node_modules/axios/lib/helpers/toFormData.js ***!
3432 - \******************************************************/
3433 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3434 -
3435 -__webpack_require__.r(__webpack_exports__);
3436 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
3437 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
3438 -/* harmony import */ var _platform_node_classes_FormData_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../platform/node/classes/FormData.js */ "./node_modules/axios/lib/helpers/null.js");
3439 -
3440 -
3441 -
3442 -
3443 -// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored
3444 -
3445 -
3446 -/**
3447 - * Determines if the given thing is a array or js object.
3448 - *
3449 - * @param {string} thing - The object or array to be visited.
3450 - *
3451 - * @returns {boolean}
3452 - */
3453 -function isVisitable(thing) {
3454 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isPlainObject(thing) || _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(thing);
3455 -}
3456 -
3457 -/**
3458 - * It removes the brackets from the end of a string
3459 - *
3460 - * @param {string} key - The key of the parameter.
3461 - *
3462 - * @returns {string} the key without the brackets.
3463 - */
3464 -function removeBrackets(key) {
3465 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].endsWith(key, '[]') ? key.slice(0, -2) : key;
3466 -}
3467 -
3468 -/**
3469 - * It takes a path, a key, and a boolean, and returns a string
3470 - *
3471 - * @param {string} path - The path to the current key.
3472 - * @param {string} key - The key of the current object being iterated over.
3473 - * @param {string} dots - If true, the key will be rendered with dots instead of brackets.
3474 - *
3475 - * @returns {string} The path to the current key.
3476 - */
3477 -function renderKey(path, key, dots) {
3478 - if (!path) return key;
3479 - return path.concat(key).map(function each(token, i) {
3480 - // eslint-disable-next-line no-param-reassign
3481 - token = removeBrackets(token);
3482 - return !dots && i ? '[' + token + ']' : token;
3483 - }).join(dots ? '.' : '');
3484 -}
3485 -
3486 -/**
3487 - * If the array is an array and none of its elements are visitable, then it's a flat array.
3488 - *
3489 - * @param {Array<any>} arr - The array to check
3490 - *
3491 - * @returns {boolean}
3492 - */
3493 -function isFlatArray(arr) {
3494 - return _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(arr) && !arr.some(isVisitable);
3495 -}
3496 -
3497 -const predicates = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toFlatObject(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"], {}, null, function filter(prop) {
3498 - return /^is[A-Z]/.test(prop);
3499 -});
3500 -
3501 -/**
3502 - * Convert a data object to FormData
3503 - *
3504 - * @param {Object} obj
3505 - * @param {?Object} [formData]
3506 - * @param {?Object} [options]
3507 - * @param {Function} [options.visitor]
3508 - * @param {Boolean} [options.metaTokens = true]
3509 - * @param {Boolean} [options.dots = false]
3510 - * @param {?Boolean} [options.indexes = false]
3511 - *
3512 - * @returns {Object}
3513 - **/
3514 -
3515 -/**
3516 - * It converts an object into a FormData object
3517 - *
3518 - * @param {Object<any, any>} obj - The object to convert to form data.
3519 - * @param {string} formData - The FormData object to append to.
3520 - * @param {Object<string, any>} options
3521 - *
3522 - * @returns
3523 - */
3524 -function toFormData(obj, formData, options) {
3525 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(obj)) {
3526 - throw new TypeError('target must be an object');
3527 - }
3528 -
3529 - // eslint-disable-next-line no-param-reassign
3530 - formData = formData || new (_platform_node_classes_FormData_js__WEBPACK_IMPORTED_MODULE_2__["default"] || FormData)();
3531 -
3532 - // eslint-disable-next-line no-param-reassign
3533 - options = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toFlatObject(options, {
3534 - metaTokens: true,
3535 - dots: false,
3536 - indexes: false
3537 - }, false, function defined(option, source) {
3538 - // eslint-disable-next-line no-eq-null,eqeqeq
3539 - return !_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(source[option]);
3540 - });
3541 -
3542 - const metaTokens = options.metaTokens;
3543 - // eslint-disable-next-line no-use-before-define
3544 - const visitor = options.visitor || defaultVisitor;
3545 - const dots = options.dots;
3546 - const indexes = options.indexes;
3547 - const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;
3548 - const useBlob = _Blob && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isSpecCompliantForm(formData);
3549 -
3550 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFunction(visitor)) {
3551 - throw new TypeError('visitor must be a function');
3552 - }
3553 -
3554 - function convertValue(value) {
3555 - if (value === null) return '';
3556 -
3557 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isDate(value)) {
3558 - return value.toISOString();
3559 - }
3560 -
3561 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isBoolean(value)) {
3562 - return value.toString();
3563 - }
3564 -
3565 - if (!useBlob && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isBlob(value)) {
3566 - throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"]('Blob is not supported. Use a Buffer instead.');
3567 - }
3568 -
3569 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArrayBuffer(value) || _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isTypedArray(value)) {
3570 - return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
3571 - }
3572 -
3573 - return value;
3574 - }
3575 -
3576 - /**
3577 - * Default visitor.
3578 - *
3579 - * @param {*} value
3580 - * @param {String|Number} key
3581 - * @param {Array<String|Number>} path
3582 - * @this {FormData}
3583 - *
3584 - * @returns {boolean} return true to visit the each prop of the value recursively
3585 - */
3586 - function defaultVisitor(value, key, path) {
3587 - let arr = value;
3588 -
3589 - if (value && !path && typeof value === 'object') {
3590 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].endsWith(key, '{}')) {
3591 - // eslint-disable-next-line no-param-reassign
3592 - key = metaTokens ? key : key.slice(0, -2);
3593 - // eslint-disable-next-line no-param-reassign
3594 - value = JSON.stringify(value);
3595 - } else if (
3596 - (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isArray(value) && isFlatArray(value)) ||
3597 - ((_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isFileList(value) || _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].endsWith(key, '[]')) && (arr = _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].toArray(value))
3598 - )) {
3599 - // eslint-disable-next-line no-param-reassign
3600 - key = removeBrackets(key);
3601 -
3602 - arr.forEach(function each(el, index) {
3603 - !(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(el) || el === null) && formData.append(
3604 - // eslint-disable-next-line no-nested-ternary
3605 - indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),
3606 - convertValue(el)
3607 - );
3608 - });
3609 - return false;
3610 - }
3611 - }
3612 -
3613 - if (isVisitable(value)) {
3614 - return true;
3615 - }
3616 -
3617 - formData.append(renderKey(path, key, dots), convertValue(value));
3618 -
3619 - return false;
3620 - }
3621 -
3622 - const stack = [];
3623 -
3624 - const exposedHelpers = Object.assign(predicates, {
3625 - defaultVisitor,
3626 - convertValue,
3627 - isVisitable
3628 - });
3629 -
3630 - function build(value, path) {
3631 - if (_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(value)) return;
3632 -
3633 - if (stack.indexOf(value) !== -1) {
3634 - throw Error('Circular reference detected in ' + path.join('.'));
3635 - }
3636 -
3637 - stack.push(value);
3638 -
3639 - _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].forEach(value, function each(el, key) {
3640 - const result = !(_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isUndefined(el) || el === null) && visitor.call(
3641 - formData, el, _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isString(key) ? key.trim() : key, path, exposedHelpers
3642 - );
3643 -
3644 - if (result === true) {
3645 - build(el, path ? path.concat(key) : [key]);
3646 - }
3647 - });
3648 -
3649 - stack.pop();
3650 - }
3651 -
3652 - if (!_utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isObject(obj)) {
3653 - throw new TypeError('data must be an object');
3654 - }
3655 -
3656 - build(obj);
3657 -
3658 - return formData;
3659 -}
3660 -
3661 -/* harmony default export */ __webpack_exports__["default"] = (toFormData);
3662 -
3663 -
3664 -/***/ }),
3665 -
3666 -/***/ "./node_modules/axios/lib/helpers/toURLEncodedForm.js":
3667 -/*!************************************************************!*\
3668 - !*** ./node_modules/axios/lib/helpers/toURLEncodedForm.js ***!
3669 - \************************************************************/
3670 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3671 -
3672 -__webpack_require__.r(__webpack_exports__);
3673 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
3674 -/* harmony export */ "default": function() { return /* binding */ toURLEncodedForm; }
3675 -/* harmony export */ });
3676 -/* harmony import */ var _utils_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../utils.js */ "./node_modules/axios/lib/utils.js");
3677 -/* harmony import */ var _toFormData_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./toFormData.js */ "./node_modules/axios/lib/helpers/toFormData.js");
3678 -/* harmony import */ var _platform_index_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../platform/index.js */ "./node_modules/axios/lib/platform/index.js");
3679 -
3680 -
3681 -
3682 -
3683 -
3684 -
3685 -function toURLEncodedForm(data, options) {
3686 - return (0,_toFormData_js__WEBPACK_IMPORTED_MODULE_1__["default"])(data, new _platform_index_js__WEBPACK_IMPORTED_MODULE_2__["default"].classes.URLSearchParams(), {
3687 - visitor: function(value, key, path, helpers) {
3688 - if (_platform_index_js__WEBPACK_IMPORTED_MODULE_2__["default"].isNode && _utils_js__WEBPACK_IMPORTED_MODULE_0__["default"].isBuffer(value)) {
3689 - this.append(key, value.toString('base64'));
3690 - return false;
3691 - }
3692 -
3693 - return helpers.defaultVisitor.apply(this, arguments);
3694 - },
3695 - ...options
3696 - });
3697 -}
3698 -
3699 -
3700 -/***/ }),
3701 -
3702 -/***/ "./node_modules/axios/lib/helpers/trackStream.js":
3703 -/*!*******************************************************!*\
3704 - !*** ./node_modules/axios/lib/helpers/trackStream.js ***!
3705 - \*******************************************************/
3706 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3707 -
3708 -__webpack_require__.r(__webpack_exports__);
3709 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
3710 -/* harmony export */ readBytes: function() { return /* binding */ readBytes; },
3711 -/* harmony export */ streamChunk: function() { return /* binding */ streamChunk; },
3712 -/* harmony export */ trackStream: function() { return /* binding */ trackStream; }
3713 -/* harmony export */ });
3714 -
3715 -const streamChunk = function* (chunk, chunkSize) {
3716 - let len = chunk.byteLength;
3717 -
3718 - if (!chunkSize || len < chunkSize) {
3719 - yield chunk;
3720 - return;
3721 - }
3722 -
3723 - let pos = 0;
3724 - let end;
3725 -
3726 - while (pos < len) {
3727 - end = pos + chunkSize;
3728 - yield chunk.slice(pos, end);
3729 - pos = end;
3730 - }
3731 -}
3732 -
3733 -const readBytes = async function* (iterable, chunkSize) {
3734 - for await (const chunk of readStream(iterable)) {
3735 - yield* streamChunk(chunk, chunkSize);
3736 - }
3737 -}
3738 -
3739 -const readStream = async function* (stream) {
3740 - if (stream[Symbol.asyncIterator]) {
3741 - yield* stream;
3742 - return;
3743 - }
3744 -
3745 - const reader = stream.getReader();
3746 - try {
3747 - for (;;) {
3748 - const {done, value} = await reader.read();
3749 - if (done) {
3750 - break;
3751 - }
3752 - yield value;
3753 - }
3754 - } finally {
3755 - await reader.cancel();
3756 - }
3757 -}
3758 -
3759 -const trackStream = (stream, chunkSize, onProgress, onFinish) => {
3760 - const iterator = readBytes(stream, chunkSize);
3761 -
3762 - let bytes = 0;
3763 - let done;
3764 - let _onFinish = (e) => {
3765 - if (!done) {
3766 - done = true;
3767 - onFinish && onFinish(e);
3768 - }
3769 - }
3770 -
3771 - return new ReadableStream({
3772 - async pull(controller) {
3773 - try {
3774 - const {done, value} = await iterator.next();
3775 -
3776 - if (done) {
3777 - _onFinish();
3778 - controller.close();
3779 - return;
3780 - }
3781 -
3782 - let len = value.byteLength;
3783 - if (onProgress) {
3784 - let loadedBytes = bytes += len;
3785 - onProgress(loadedBytes);
3786 - }
3787 - controller.enqueue(new Uint8Array(value));
3788 - } catch (err) {
3789 - _onFinish(err);
3790 - throw err;
3791 - }
3792 - },
3793 - cancel(reason) {
3794 - _onFinish(reason);
3795 - return iterator.return();
3796 - }
3797 - }, {
3798 - highWaterMark: 2
3799 - })
3800 -}
3801 -
3802 -
3803 -/***/ }),
3804 -
3805 -/***/ "./node_modules/axios/lib/helpers/validator.js":
3806 -/*!*****************************************************!*\
3807 - !*** ./node_modules/axios/lib/helpers/validator.js ***!
3808 - \*****************************************************/
3809 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3810 -
3811 -__webpack_require__.r(__webpack_exports__);
3812 -/* harmony import */ var _env_data_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../env/data.js */ "./node_modules/axios/lib/env/data.js");
3813 -/* harmony import */ var _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../core/AxiosError.js */ "./node_modules/axios/lib/core/AxiosError.js");
3814 -
3815 -
3816 -
3817 -
3818 -
3819 -const validators = {};
3820 -
3821 -// eslint-disable-next-line func-names
3822 -['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach((type, i) => {
3823 - validators[type] = function validator(thing) {
3824 - return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
3825 - };
3826 -});
3827 -
3828 -const deprecatedWarnings = {};
3829 -
3830 -/**
3831 - * Transitional option validator
3832 - *
3833 - * @param {function|boolean?} validator - set to false if the transitional option has been removed
3834 - * @param {string?} version - deprecated version / removed since version
3835 - * @param {string?} message - some message with additional info
3836 - *
3837 - * @returns {function}
3838 - */
3839 -validators.transitional = function transitional(validator, version, message) {
3840 - function formatMessage(opt, desc) {
3841 - return '[Axios v' + _env_data_js__WEBPACK_IMPORTED_MODULE_0__.VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
3842 - }
3843 -
3844 - // eslint-disable-next-line func-names
3845 - return (value, opt, opts) => {
3846 - if (validator === false) {
3847 - throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"](
3848 - formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
3849 - _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_DEPRECATED
3850 - );
3851 - }
3852 -
3853 - if (version && !deprecatedWarnings[opt]) {
3854 - deprecatedWarnings[opt] = true;
3855 - // eslint-disable-next-line no-console
3856 - console.warn(
3857 - formatMessage(
3858 - opt,
3859 - ' has been deprecated since v' + version + ' and will be removed in the near future'
3860 - )
3861 - );
3862 - }
3863 -
3864 - return validator ? validator(value, opt, opts) : true;
3865 - };
3866 -};
3867 -
3868 -validators.spelling = function spelling(correctSpelling) {
3869 - return (value, opt) => {
3870 - // eslint-disable-next-line no-console
3871 - console.warn(`${opt} is likely a misspelling of ${correctSpelling}`);
3872 - return true;
3873 - }
3874 -};
3875 -
3876 -/**
3877 - * Assert object's properties type
3878 - *
3879 - * @param {object} options
3880 - * @param {object} schema
3881 - * @param {boolean?} allowUnknown
3882 - *
3883 - * @returns {object}
3884 - */
3885 -
3886 -function assertOptions(options, schema, allowUnknown) {
3887 - if (typeof options !== 'object') {
3888 - throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"]('options must be an object', _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_BAD_OPTION_VALUE);
3889 - }
3890 - const keys = Object.keys(options);
3891 - let i = keys.length;
3892 - while (i-- > 0) {
3893 - const opt = keys[i];
3894 - const validator = schema[opt];
3895 - if (validator) {
3896 - const value = options[opt];
3897 - const result = value === undefined || validator(value, opt, options);
3898 - if (result !== true) {
3899 - throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"]('option ' + opt + ' must be ' + result, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_BAD_OPTION_VALUE);
3900 - }
3901 - continue;
3902 - }
3903 - if (allowUnknown !== true) {
3904 - throw new _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"]('Unknown option ' + opt, _core_AxiosError_js__WEBPACK_IMPORTED_MODULE_1__["default"].ERR_BAD_OPTION);
3905 - }
3906 - }
3907 -}
3908 -
3909 -/* harmony default export */ __webpack_exports__["default"] = ({
3910 - assertOptions,
3911 - validators
3912 -});
3913 -
3914 -
3915 -/***/ }),
3916 -
3917 -/***/ "./node_modules/axios/lib/platform/browser/classes/Blob.js":
3918 -/*!*****************************************************************!*\
3919 - !*** ./node_modules/axios/lib/platform/browser/classes/Blob.js ***!
3920 - \*****************************************************************/
3921 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3922 -
3923 -__webpack_require__.r(__webpack_exports__);
3924 -
3925 -
3926 -/* harmony default export */ __webpack_exports__["default"] = (typeof Blob !== 'undefined' ? Blob : null);
3927 -
3928 -
3929 -/***/ }),
3930 -
3931 -/***/ "./node_modules/axios/lib/platform/browser/classes/FormData.js":
3932 -/*!*********************************************************************!*\
3933 - !*** ./node_modules/axios/lib/platform/browser/classes/FormData.js ***!
3934 - \*********************************************************************/
3935 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3936 -
3937 -__webpack_require__.r(__webpack_exports__);
3938 -
3939 -
3940 -/* harmony default export */ __webpack_exports__["default"] = (typeof FormData !== 'undefined' ? FormData : null);
3941 -
3942 -
3943 -/***/ }),
3944 -
3945 -/***/ "./node_modules/axios/lib/platform/browser/classes/URLSearchParams.js":
3946 -/*!****************************************************************************!*\
3947 - !*** ./node_modules/axios/lib/platform/browser/classes/URLSearchParams.js ***!
3948 - \****************************************************************************/
3949 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3950 -
3951 -__webpack_require__.r(__webpack_exports__);
3952 -/* harmony import */ var _helpers_AxiosURLSearchParams_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../helpers/AxiosURLSearchParams.js */ "./node_modules/axios/lib/helpers/AxiosURLSearchParams.js");
3953 -
3954 -
3955 -
3956 -/* harmony default export */ __webpack_exports__["default"] = (typeof URLSearchParams !== 'undefined' ? URLSearchParams : _helpers_AxiosURLSearchParams_js__WEBPACK_IMPORTED_MODULE_0__["default"]);
3957 -
3958 -
3959 -/***/ }),
3960 -
3961 -/***/ "./node_modules/axios/lib/platform/browser/index.js":
3962 -/*!**********************************************************!*\
3963 - !*** ./node_modules/axios/lib/platform/browser/index.js ***!
3964 - \**********************************************************/
3965 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3966 -
3967 -__webpack_require__.r(__webpack_exports__);
3968 -/* harmony import */ var _classes_URLSearchParams_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./classes/URLSearchParams.js */ "./node_modules/axios/lib/platform/browser/classes/URLSearchParams.js");
3969 -/* harmony import */ var _classes_FormData_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./classes/FormData.js */ "./node_modules/axios/lib/platform/browser/classes/FormData.js");
3970 -/* harmony import */ var _classes_Blob_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./classes/Blob.js */ "./node_modules/axios/lib/platform/browser/classes/Blob.js");
3971 -
3972 -
3973 -
3974 -
3975 -/* harmony default export */ __webpack_exports__["default"] = ({
3976 - isBrowser: true,
3977 - classes: {
3978 - URLSearchParams: _classes_URLSearchParams_js__WEBPACK_IMPORTED_MODULE_0__["default"],
3979 - FormData: _classes_FormData_js__WEBPACK_IMPORTED_MODULE_1__["default"],
3980 - Blob: _classes_Blob_js__WEBPACK_IMPORTED_MODULE_2__["default"]
3981 - },
3982 - protocols: ['http', 'https', 'file', 'blob', 'url', 'data']
3983 -});
3984 -
3985 -
3986 -/***/ }),
3987 -
3988 -/***/ "./node_modules/axios/lib/platform/common/utils.js":
3989 -/*!*********************************************************!*\
3990 - !*** ./node_modules/axios/lib/platform/common/utils.js ***!
3991 - \*********************************************************/
3992 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
3993 -
3994 -__webpack_require__.r(__webpack_exports__);
3995 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
3996 -/* harmony export */ hasBrowserEnv: function() { return /* binding */ hasBrowserEnv; },
3997 -/* harmony export */ hasStandardBrowserEnv: function() { return /* binding */ hasStandardBrowserEnv; },
3998 -/* harmony export */ hasStandardBrowserWebWorkerEnv: function() { return /* binding */ hasStandardBrowserWebWorkerEnv; },
3999 -/* harmony export */ navigator: function() { return /* binding */ _navigator; },
4000 -/* harmony export */ origin: function() { return /* binding */ origin; }
4001 -/* harmony export */ });
4002 -const hasBrowserEnv = typeof window !== 'undefined' && typeof document !== 'undefined';
4003 -
4004 -const _navigator = typeof navigator === 'object' && navigator || undefined;
4005 -
4006 -/**
4007 - * Determine if we're running in a standard browser environment
4008 - *
4009 - * This allows axios to run in a web worker, and react-native.
4010 - * Both environments support XMLHttpRequest, but not fully standard globals.
4011 - *
4012 - * web workers:
4013 - * typeof window -> undefined
4014 - * typeof document -> undefined
4015 - *
4016 - * react-native:
4017 - * navigator.product -> 'ReactNative'
4018 - * nativescript
4019 - * navigator.product -> 'NativeScript' or 'NS'
4020 - *
4021 - * @returns {boolean}
4022 - */
4023 -const hasStandardBrowserEnv = hasBrowserEnv &&
4024 - (!_navigator || ['ReactNative', 'NativeScript', 'NS'].indexOf(_navigator.product) < 0);
4025 -
4026 -/**
4027 - * Determine if we're running in a standard browser webWorker environment
4028 - *
4029 - * Although the `isStandardBrowserEnv` method indicates that
4030 - * `allows axios to run in a web worker`, the WebWorker will still be
4031 - * filtered out due to its judgment standard
4032 - * `typeof window !== 'undefined' && typeof document !== 'undefined'`.
4033 - * This leads to a problem when axios post `FormData` in webWorker
4034 - */
4035 -const hasStandardBrowserWebWorkerEnv = (() => {
4036 - return (
4037 - typeof WorkerGlobalScope !== 'undefined' &&
4038 - // eslint-disable-next-line no-undef
4039 - self instanceof WorkerGlobalScope &&
4040 - typeof self.importScripts === 'function'
4041 - );
4042 -})();
4043 -
4044 -const origin = hasBrowserEnv && window.location.href || 'http://localhost';
4045 -
4046 -
4047 -
4048 -
4049 -/***/ }),
4050 -
4051 -/***/ "./node_modules/axios/lib/platform/index.js":
4052 -/*!**************************************************!*\
4053 - !*** ./node_modules/axios/lib/platform/index.js ***!
4054 - \**************************************************/
4055 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
4056 -
4057 -__webpack_require__.r(__webpack_exports__);
4058 -/* harmony import */ var _node_index_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./node/index.js */ "./node_modules/axios/lib/platform/browser/index.js");
4059 -/* harmony import */ var _common_utils_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./common/utils.js */ "./node_modules/axios/lib/platform/common/utils.js");
4060 -
4061 -
4062 -
4063 -/* harmony default export */ __webpack_exports__["default"] = ({
4064 - ..._common_utils_js__WEBPACK_IMPORTED_MODULE_1__,
4065 - ..._node_index_js__WEBPACK_IMPORTED_MODULE_0__["default"]
4066 -});
4067 -
4068 -
4069 -/***/ }),
4070 -
4071 -/***/ "./node_modules/axios/lib/utils.js":
4072 -/*!*****************************************!*\
4073 - !*** ./node_modules/axios/lib/utils.js ***!
4074 - \*****************************************/
4075 -/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
4076 -
4077 -__webpack_require__.r(__webpack_exports__);
4078 -/* harmony import */ var _helpers_bind_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./helpers/bind.js */ "./node_modules/axios/lib/helpers/bind.js");
4079 -
4080 -
4081 -
4082 -
4083 -// utils is a library of generic helper functions non-specific to axios
4084 -
4085 -const {toString} = Object.prototype;
4086 -const {getPrototypeOf} = Object;
4087 -const {iterator, toStringTag} = Symbol;
4088 -
4089 -const kindOf = (cache => thing => {
4090 - const str = toString.call(thing);
4091 - return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
4092 -})(Object.create(null));
4093 -
4094 -const kindOfTest = (type) => {
4095 - type = type.toLowerCase();
4096 - return (thing) => kindOf(thing) === type
4097 -}
4098 -
4099 -const typeOfTest = type => thing => typeof thing === type;
4100 -
4101 -/**
4102 - * Determine if a value is an Array
4103 - *
4104 - * @param {Object} val The value to test
4105 - *
4106 - * @returns {boolean} True if value is an Array, otherwise false
4107 - */
4108 -const {isArray} = Array;
4109 -
4110 -/**
4111 - * Determine if a value is undefined
4112 - *
4113 - * @param {*} val The value to test
4114 - *
4115 - * @returns {boolean} True if the value is undefined, otherwise false
4116 - */
4117 -const isUndefined = typeOfTest('undefined');
4118 -
4119 -/**
4120 - * Determine if a value is a Buffer
4121 - *
4122 - * @param {*} val The value to test
4123 - *
4124 - * @returns {boolean} True if value is a Buffer, otherwise false
4125 - */
4126 -function isBuffer(val) {
4127 - return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
4128 - && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
4129 -}
4130 -
4131 -/**
4132 - * Determine if a value is an ArrayBuffer
4133 - *
4134 - * @param {*} val The value to test
4135 - *
4136 - * @returns {boolean} True if value is an ArrayBuffer, otherwise false
4137 - */
4138 -const isArrayBuffer = kindOfTest('ArrayBuffer');
4139 -
4140 -
4141 -/**
4142 - * Determine if a value is a view on an ArrayBuffer
4143 - *
4144 - * @param {*} val The value to test
4145 - *
4146 - * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
4147 - */
4148 -function isArrayBufferView(val) {
4149 - let result;
4150 - if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
4151 - result = ArrayBuffer.isView(val);
4152 - } else {
4153 - result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
4154 - }
4155 - return result;
4156 -}
4157 -
4158 -/**
4159 - * Determine if a value is a String
4160 - *
4161 - * @param {*} val The value to test
4162 - *
4163 - * @returns {boolean} True if value is a String, otherwise false
4164 - */
4165 -const isString = typeOfTest('string');
4166 -
4167 -/**
4168 - * Determine if a value is a Function
4169 - *
4170 - * @param {*} val The value to test
4171 - * @returns {boolean} True if value is a Function, otherwise false
4172 - */
4173 -const isFunction = typeOfTest('function');
4174 -
4175 -/**
4176 - * Determine if a value is a Number
4177 - *
4178 - * @param {*} val The value to test
4179 - *
4180 - * @returns {boolean} True if value is a Number, otherwise false
4181 - */
4182 -const isNumber = typeOfTest('number');
4183 -
4184 -/**
4185 - * Determine if a value is an Object
4186 - *
4187 - * @param {*} thing The value to test
4188 - *
4189 - * @returns {boolean} True if value is an Object, otherwise false
4190 - */
4191 -const isObject = (thing) => thing !== null && typeof thing === 'object';
4192 -
4193 -/**
4194 - * Determine if a value is a Boolean
4195 - *
4196 - * @param {*} thing The value to test
4197 - * @returns {boolean} True if value is a Boolean, otherwise false
4198 - */
4199 -const isBoolean = thing => thing === true || thing === false;
4200 -
4201 -/**
4202 - * Determine if a value is a plain Object
4203 - *
4204 - * @param {*} val The value to test
4205 - *
4206 - * @returns {boolean} True if value is a plain Object, otherwise false
4207 - */
4208 -const isPlainObject = (val) => {
4209 - if (kindOf(val) !== 'object') {
4210 - return false;
4211 - }
4212 -
4213 - const prototype = getPrototypeOf(val);
4214 - return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator in val);
4215 -}
4216 -
4217 -/**
4218 - * Determine if a value is an empty object (safely handles Buffers)
4219 - *
4220 - * @param {*} val The value to test
4221 - *
4222 - * @returns {boolean} True if value is an empty object, otherwise false
4223 - */
4224 -const isEmptyObject = (val) => {
4225 - // Early return for non-objects or Buffers to prevent RangeError
4226 - if (!isObject(val) || isBuffer(val)) {
4227 - return false;
4228 - }
4229 -
4230 - try {
4231 - return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
4232 - } catch (e) {
4233 - // Fallback for any other objects that might cause RangeError with Object.keys()
4234 - return false;
4235 - }
4236 -}
4237 -
4238 -/**
4239 - * Determine if a value is a Date
4240 - *
4241 - * @param {*} val The value to test
4242 - *
4243 - * @returns {boolean} True if value is a Date, otherwise false
4244 - */
4245 -const isDate = kindOfTest('Date');
4246 -
4247 -/**
4248 - * Determine if a value is a File
4249 - *
4250 - * @param {*} val The value to test
4251 - *
4252 - * @returns {boolean} True if value is a File, otherwise false
4253 - */
4254 -const isFile = kindOfTest('File');
4255 -
4256 -/**
4257 - * Determine if a value is a Blob
4258 - *
4259 - * @param {*} val The value to test
4260 - *
4261 - * @returns {boolean} True if value is a Blob, otherwise false
4262 - */
4263 -const isBlob = kindOfTest('Blob');
4264 -
4265 -/**
4266 - * Determine if a value is a FileList
4267 - *
4268 - * @param {*} val The value to test
4269 - *
4270 - * @returns {boolean} True if value is a File, otherwise false
4271 - */
4272 -const isFileList = kindOfTest('FileList');
4273 -
4274 -/**
4275 - * Determine if a value is a Stream
4276 - *
4277 - * @param {*} val The value to test
4278 - *
4279 - * @returns {boolean} True if value is a Stream, otherwise false
4280 - */
4281 -const isStream = (val) => isObject(val) && isFunction(val.pipe);
4282 -
4283 -/**
4284 - * Determine if a value is a FormData
4285 - *
4286 - * @param {*} thing The value to test
4287 - *
4288 - * @returns {boolean} True if value is an FormData, otherwise false
4289 - */
4290 -const isFormData = (thing) => {
4291 - let kind;
4292 - return thing && (
4293 - (typeof FormData === 'function' && thing instanceof FormData) || (
4294 - isFunction(thing.append) && (
4295 - (kind = kindOf(thing)) === 'formdata' ||
4296 - // detect form-data instance
4297 - (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')
4298 - )
4299 - )
4300 - )
4301 -}
4302 -
4303 -/**
4304 - * Determine if a value is a URLSearchParams object
4305 - *
4306 - * @param {*} val The value to test
4307 - *
4308 - * @returns {boolean} True if value is a URLSearchParams object, otherwise false
4309 - */
4310 -const isURLSearchParams = kindOfTest('URLSearchParams');
4311 -
4312 -const [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream', 'Request', 'Response', 'Headers'].map(kindOfTest);
4313 -
4314 -/**
4315 - * Trim excess whitespace off the beginning and end of a string
4316 - *
4317 - * @param {String} str The String to trim
4318 - *
4319 - * @returns {String} The String freed of excess whitespace
4320 - */
4321 -const trim = (str) => str.trim ?
4322 - str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
4323 -
4324 -/**
4325 - * Iterate over an Array or an Object invoking a function for each item.
4326 - *
4327 - * If `obj` is an Array callback will be called passing
4328 - * the value, index, and complete array for each item.
4329 - *
4330 - * If 'obj' is an Object callback will be called passing
4331 - * the value, key, and complete object for each property.
4332 - *
4333 - * @param {Object|Array} obj The object to iterate
4334 - * @param {Function} fn The callback to invoke for each item
4335 - *
4336 - * @param {Boolean} [allOwnKeys = false]
4337 - * @returns {any}
4338 - */
4339 -function forEach(obj, fn, {allOwnKeys = false} = {}) {
4340 - // Don't bother if no value provided
4341 - if (obj === null || typeof obj === 'undefined') {
4342 - return;
4343 - }
4344 -
4345 - let i;
4346 - let l;
4347 -
4348 - // Force an array if not already something iterable
4349 - if (typeof obj !== 'object') {
4350 - /*eslint no-param-reassign:0*/
4351 - obj = [obj];
4352 - }
4353 -
4354 - if (isArray(obj)) {
4355 - // Iterate over array values
4356 - for (i = 0, l = obj.length; i < l; i++) {
4357 - fn.call(null, obj[i], i, obj);
4358 - }
4359 - } else {
4360 - // Buffer check
4361 - if (isBuffer(obj)) {
4362 - return;
4363 - }
4364 -
4365 - // Iterate over object keys
4366 - const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
4367 - const len = keys.length;
4368 - let key;
4369 -
4370 - for (i = 0; i < len; i++) {
4371 - key = keys[i];
4372 - fn.call(null, obj[key], key, obj);
4373 - }
4374 - }
4375 -}
4376 -
4377 -function findKey(obj, key) {
4378 - if (isBuffer(obj)){
4379 - return null;
4380 - }
4381 -
4382 - key = key.toLowerCase();
4383 - const keys = Object.keys(obj);
4384 - let i = keys.length;
4385 - let _key;
4386 - while (i-- > 0) {
4387 - _key = keys[i];
4388 - if (key === _key.toLowerCase()) {
4389 - return _key;
4390 - }
4391 - }
4392 - return null;
4393 -}
4394 -
4395 -const _global = (() => {
4396 - /*eslint no-undef:0*/
4397 - if (typeof globalThis !== "undefined") return globalThis;
4398 - return typeof self !== "undefined" ? self : (typeof window !== 'undefined' ? window : global)
4399 -})();
4400 -
4401 -const isContextDefined = (context) => !isUndefined(context) && context !== _global;
4402 -
4403 -/**
4404 - * Accepts varargs expecting each argument to be an object, then
4405 - * immutably merges the properties of each object and returns result.
4406 - *
4407 - * When multiple objects contain the same key the later object in
4408 - * the arguments list will take precedence.
4409 - *
4410 - * Example:
4411 - *
4412 - * ```js
4413 - * var result = merge({foo: 123}, {foo: 456});
4414 - * console.log(result.foo); // outputs 456
4415 - * ```
4416 - *
4417 - * @param {Object} obj1 Object to merge
4418 - *
4419 - * @returns {Object} Result of all merge properties
4420 - */
4421 -function merge(/* obj1, obj2, obj3, ... */) {
4422 - const {caseless, skipUndefined} = isContextDefined(this) && this || {};
4423 - const result = {};
4424 - const assignValue = (val, key) => {
4425 - const targetKey = caseless && findKey(result, key) || key;
4426 - if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
4427 - result[targetKey] = merge(result[targetKey], val);
4428 - } else if (isPlainObject(val)) {
4429 - result[targetKey] = merge({}, val);
4430 - } else if (isArray(val)) {
4431 - result[targetKey] = val.slice();
4432 - } else if (!skipUndefined || !isUndefined(val)) {
4433 - result[targetKey] = val;
4434 - }
4435 - }
4436 -
4437 - for (let i = 0, l = arguments.length; i < l; i++) {
4438 - arguments[i] && forEach(arguments[i], assignValue);
4439 - }
4440 - return result;
4441 -}
4442 -
4443 -/**
4444 - * Extends object a by mutably adding to it the properties of object b.
4445 - *
4446 - * @param {Object} a The object to be extended
4447 - * @param {Object} b The object to copy properties from
4448 - * @param {Object} thisArg The object to bind function to
4449 - *
4450 - * @param {Boolean} [allOwnKeys]
4451 - * @returns {Object} The resulting value of object a
4452 - */
4453 -const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
4454 - forEach(b, (val, key) => {
4455 - if (thisArg && isFunction(val)) {
4456 - a[key] = (0,_helpers_bind_js__WEBPACK_IMPORTED_MODULE_0__["default"])(val, thisArg);
4457 - } else {
4458 - a[key] = val;
4459 - }
4460 - }, {allOwnKeys});
4461 - return a;
4462 -}
4463 -
4464 -/**
4465 - * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
4466 - *
4467 - * @param {string} content with BOM
4468 - *
4469 - * @returns {string} content value without BOM
4470 - */
4471 -const stripBOM = (content) => {
4472 - if (content.charCodeAt(0) === 0xFEFF) {
4473 - content = content.slice(1);
4474 - }
4475 - return content;
4476 -}
4477 -
4478 -/**
4479 - * Inherit the prototype methods from one constructor into another
4480 - * @param {function} constructor
4481 - * @param {function} superConstructor
4482 - * @param {object} [props]
4483 - * @param {object} [descriptors]
4484 - *
4485 - * @returns {void}
4486 - */
4487 -const inherits = (constructor, superConstructor, props, descriptors) => {
4488 - constructor.prototype = Object.create(superConstructor.prototype, descriptors);
4489 - constructor.prototype.constructor = constructor;
4490 - Object.defineProperty(constructor, 'super', {
4491 - value: superConstructor.prototype
4492 - });
4493 - props && Object.assign(constructor.prototype, props);
4494 -}
4495 -
4496 -/**
4497 - * Resolve object with deep prototype chain to a flat object
4498 - * @param {Object} sourceObj source object
4499 - * @param {Object} [destObj]
4500 - * @param {Function|Boolean} [filter]
4501 - * @param {Function} [propFilter]
4502 - *
4503 - * @returns {Object}
4504 - */
4505 -const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
4506 - let props;
4507 - let i;
4508 - let prop;
4509 - const merged = {};
4510 -
4511 - destObj = destObj || {};
4512 - // eslint-disable-next-line no-eq-null,eqeqeq
4513 - if (sourceObj == null) return destObj;
4514 -
4515 - do {
4516 - props = Object.getOwnPropertyNames(sourceObj);
4517 - i = props.length;
4518 - while (i-- > 0) {
4519 - prop = props[i];
4520 - if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
4521 - destObj[prop] = sourceObj[prop];
4522 - merged[prop] = true;
4523 - }
4524 - }
4525 - sourceObj = filter !== false && getPrototypeOf(sourceObj);
4526 - } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
4527 -
4528 - return destObj;
4529 -}
4530 -
4531 -/**
4532 - * Determines whether a string ends with the characters of a specified string
4533 - *
4534 - * @param {String} str
4535 - * @param {String} searchString
4536 - * @param {Number} [position= 0]
4537 - *
4538 - * @returns {boolean}
4539 - */
4540 -const endsWith = (str, searchString, position) => {
4541 - str = String(str);
4542 - if (position === undefined || position > str.length) {
4543 - position = str.length;
4544 - }
4545 - position -= searchString.length;
4546 - const lastIndex = str.indexOf(searchString, position);
4547 - return lastIndex !== -1 && lastIndex === position;
4548 -}
4549 -
4550 -
4551 -/**
4552 - * Returns new array from array like object or null if failed
4553 - *
4554 - * @param {*} [thing]
4555 - *
4556 - * @returns {?Array}
4557 - */
4558 -const toArray = (thing) => {
4559 - if (!thing) return null;
4560 - if (isArray(thing)) return thing;
4561 - let i = thing.length;
4562 - if (!isNumber(i)) return null;
4563 - const arr = new Array(i);
4564 - while (i-- > 0) {
4565 - arr[i] = thing[i];
4566 - }
4567 - return arr;
4568 -}
4569 -
4570 -/**
4571 - * Checking if the Uint8Array exists and if it does, it returns a function that checks if the
4572 - * thing passed in is an instance of Uint8Array
4573 - *
4574 - * @param {TypedArray}
4575 - *
4576 - * @returns {Array}
4577 - */
4578 -// eslint-disable-next-line func-names
4579 -const isTypedArray = (TypedArray => {
4580 - // eslint-disable-next-line func-names
4581 - return thing => {
4582 - return TypedArray && thing instanceof TypedArray;
4583 - };
4584 -})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));
4585 -
4586 -/**
4587 - * For each entry in the object, call the function with the key and value.
4588 - *
4589 - * @param {Object<any, any>} obj - The object to iterate over.
4590 - * @param {Function} fn - The function to call for each entry.
4591 - *
4592 - * @returns {void}
4593 - */
4594 -const forEachEntry = (obj, fn) => {
4595 - const generator = obj && obj[iterator];
4596 -
4597 - const _iterator = generator.call(obj);
4598 -
4599 - let result;
4600 -
4601 - while ((result = _iterator.next()) && !result.done) {
4602 - const pair = result.value;
4603 - fn.call(obj, pair[0], pair[1]);
4604 - }
4605 -}
4606 -
4607 -/**
4608 - * It takes a regular expression and a string, and returns an array of all the matches
4609 - *
4610 - * @param {string} regExp - The regular expression to match against.
4611 - * @param {string} str - The string to search.
4612 - *
4613 - * @returns {Array<boolean>}
4614 - */
4615 -const matchAll = (regExp, str) => {
4616 - let matches;
4617 - const arr = [];
4618 -
4619 - while ((matches = regExp.exec(str)) !== null) {
4620 - arr.push(matches);
4621 - }
4622 -
4623 - return arr;
4624 -}
4625 -
4626 -/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */
4627 -const isHTMLForm = kindOfTest('HTMLFormElement');
4628 -
4629 -const toCamelCase = str => {
4630 - return str.toLowerCase().replace(/[-_\s]([a-z\d])(\w*)/g,
4631 - function replacer(m, p1, p2) {
4632 - return p1.toUpperCase() + p2;
4633 - }
4634 - );
4635 -};
4636 -
4637 -/* Creating a function that will check if an object has a property. */
4638 -const hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);
4639 -
4640 -/**
4641 - * Determine if a value is a RegExp object
4642 - *
4643 - * @param {*} val The value to test
4644 - *
4645 - * @returns {boolean} True if value is a RegExp object, otherwise false
4646 - */
4647 -const isRegExp = kindOfTest('RegExp');
4648 -
4649 -const reduceDescriptors = (obj, reducer) => {
4650 - const descriptors = Object.getOwnPropertyDescriptors(obj);
4651 - const reducedDescriptors = {};
4652 -
4653 - forEach(descriptors, (descriptor, name) => {
4654 - let ret;
4655 - if ((ret = reducer(descriptor, name, obj)) !== false) {
4656 - reducedDescriptors[name] = ret || descriptor;
4657 - }
4658 - });
4659 -
4660 - Object.defineProperties(obj, reducedDescriptors);
4661 -}
4662 -
4663 -/**
4664 - * Makes all methods read-only
4665 - * @param {Object} obj
4666 - */
4667 -
4668 -const freezeMethods = (obj) => {
4669 - reduceDescriptors(obj, (descriptor, name) => {
4670 - // skip restricted props in strict mode
4671 - if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
4672 - return false;
4673 - }
4674 -
4675 - const value = obj[name];
4676 -
4677 - if (!isFunction(value)) return;
4678 -
4679 - descriptor.enumerable = false;
4680 -
4681 - if ('writable' in descriptor) {
4682 - descriptor.writable = false;
4683 - return;
4684 - }
4685 -
4686 - if (!descriptor.set) {
4687 - descriptor.set = () => {
4688 - throw Error('Can not rewrite read-only method \'' + name + '\'');
4689 - };
4690 - }
4691 - });
4692 -}
4693 -
4694 -const toObjectSet = (arrayOrString, delimiter) => {
4695 - const obj = {};
4696 -
4697 - const define = (arr) => {
4698 - arr.forEach(value => {
4699 - obj[value] = true;
4700 - });
4701 - }
4702 -
4703 - isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
4704 -
4705 - return obj;
4706 -}
4707 -
4708 -const noop = () => {}
4709 -
4710 -const toFiniteNumber = (value, defaultValue) => {
4711 - return value != null && Number.isFinite(value = +value) ? value : defaultValue;
4712 -}
4713 -
4714 -
4715 -
4716 -/**
4717 - * If the thing is a FormData object, return true, otherwise return false.
4718 - *
4719 - * @param {unknown} thing - The thing to check.
4720 - *
4721 - * @returns {boolean}
4722 - */
4723 -function isSpecCompliantForm(thing) {
4724 - return !!(thing && isFunction(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
4725 -}
4726 -
4727 -const toJSONObject = (obj) => {
4728 - const stack = new Array(10);
4729 -
4730 - const visit = (source, i) => {
4731 -
4732 - if (isObject(source)) {
4733 - if (stack.indexOf(source) >= 0) {
4734 - return;
4735 - }
4736 -
4737 - //Buffer check
4738 - if (isBuffer(source)) {
4739 - return source;
4740 - }
4741 -
4742 - if(!('toJSON' in source)) {
4743 - stack[i] = source;
4744 - const target = isArray(source) ? [] : {};
4745 -
4746 - forEach(source, (value, key) => {
4747 - const reducedValue = visit(value, i + 1);
4748 - !isUndefined(reducedValue) && (target[key] = reducedValue);
4749 - });
4750 -
4751 - stack[i] = undefined;
4752 -
4753 - return target;
4754 - }
4755 - }
4756 -
4757 - return source;
4758 - }
4759 -
4760 - return visit(obj, 0);
4761 -}
4762 -
4763 -const isAsyncFn = kindOfTest('AsyncFunction');
4764 -
4765 -const isThenable = (thing) =>
4766 - thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
4767 -
4768 -// original code
4769 -// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
4770 -
4771 -const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
4772 - if (setImmediateSupported) {
4773 - return setImmediate;
4774 - }
4775 -
4776 - return postMessageSupported ? ((token, callbacks) => {
4777 - _global.addEventListener("message", ({source, data}) => {
4778 - if (source === _global && data === token) {
4779 - callbacks.length && callbacks.shift()();
4780 - }
4781 - }, false);
4782 -
4783 - return (cb) => {
4784 - callbacks.push(cb);
4785 - _global.postMessage(token, "*");
4786 - }
4787 - })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
4788 -})(
4789 - typeof setImmediate === 'function',
4790 - isFunction(_global.postMessage)
4791 -);
4792 -
4793 -const asap = typeof queueMicrotask !== 'undefined' ?
4794 - queueMicrotask.bind(_global) : ( typeof process !== 'undefined' && process.nextTick || _setImmediate);
4795 -
4796 -// *********************
4797 -
4798 -
4799 -const isIterable = (thing) => thing != null && isFunction(thing[iterator]);
4800 -
4801 -
4802 -/* harmony default export */ __webpack_exports__["default"] = ({
4803 - isArray,
4804 - isArrayBuffer,
4805 - isBuffer,
4806 - isFormData,
4807 - isArrayBufferView,
4808 - isString,
4809 - isNumber,
4810 - isBoolean,
4811 - isObject,
4812 - isPlainObject,
4813 - isEmptyObject,
4814 - isReadableStream,
4815 - isRequest,
4816 - isResponse,
4817 - isHeaders,
4818 - isUndefined,
4819 - isDate,
4820 - isFile,
4821 - isBlob,
4822 - isRegExp,
4823 - isFunction,
4824 - isStream,
4825 - isURLSearchParams,
4826 - isTypedArray,
4827 - isFileList,
4828 - forEach,
4829 - merge,
4830 - extend,
4831 - trim,
4832 - stripBOM,
4833 - inherits,
4834 - toFlatObject,
4835 - kindOf,
4836 - kindOfTest,
4837 - endsWith,
4838 - toArray,
4839 - forEachEntry,
4840 - matchAll,
4841 - isHTMLForm,
4842 - hasOwnProperty,
4843 - hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection
4844 - reduceDescriptors,
4845 - freezeMethods,
4846 - toObjectSet,
4847 - toCamelCase,
4848 - noop,
4849 - toFiniteNumber,
4850 - findKey,
4851 - global: _global,
4852 - isContextDefined,
4853 - isSpecCompliantForm,
4854 - toJSONObject,
4855 - isAsyncFn,
4856 - isThenable,
4857 - setImmediate: _setImmediate,
4858 - asap,
4859 - isIterable
4860 -});
4861 -
4862 -
4863 -/***/ }),
4864 -
4865 -/***/ "./packages/packages/libs/http-client/src/env.ts":
4866 -/*!*******************************************************!*\
4867 - !*** ./packages/packages/libs/http-client/src/env.ts ***!
4868 - \*******************************************************/
4869 -/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
4870 -
4871 -__webpack_require__.r(__webpack_exports__);
4872 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
4873 -/* harmony export */ env: function() { return /* binding */ env; }
4874 -/* harmony export */ });
4875 -/* harmony import */ var _elementor_env__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @elementor/env */ "@elementor/env");
4876 -/* harmony import */ var _elementor_env__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_elementor_env__WEBPACK_IMPORTED_MODULE_0__);
4877 -
4878 -const {
4879 - env
4880 -} = (0,_elementor_env__WEBPACK_IMPORTED_MODULE_0__.parseEnv)('@elementor/http-client');
4881 -
4882 -/***/ }),
4883 -
4884 -/***/ "./packages/packages/libs/http-client/src/http.ts":
4885 -/*!********************************************************!*\
4886 - !*** ./packages/packages/libs/http-client/src/http.ts ***!
4887 - \********************************************************/
4888 -/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
4889 -
4890 -__webpack_require__.r(__webpack_exports__);
4891 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
4892 -/* harmony export */ httpService: function() { return /* binding */ httpService; },
4893 -/* harmony export */ registerUrlForCache: function() { return /* binding */ registerUrlForCache; }
4894 -/* harmony export */ });
4895 -/* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! axios */ "./node_modules/axios/lib/axios.js");
4896 -/* harmony import */ var _env__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./env */ "./packages/packages/libs/http-client/src/env.ts");
4897 -
4898 -
4899 -const MAX_RETRIES = 3;
4900 -const BASE_DELAY_MS = 1000;
4901 -const CACHE_TTL_MS = 20_000;
4902 -const cache = new Map();
4903 -const cacheableUrls = new Map();
4904 -function registerUrlForCache(partialUrl, ttlMs = CACHE_TTL_MS) {
4905 - cacheableUrls.set(partialUrl, ttlMs);
4906 -}
4907 -function getUrlCacheTtl(url) {
4908 - for (const [pattern, ttl] of cacheableUrls) {
4909 - if (url.includes(pattern)) {
4910 - return ttl;
4911 - }
4912 - }
4913 - return null;
4914 -}
4915 -function getCacheKey(config) {
4916 - const url = config.url ?? '';
4917 - const params = config.params ? JSON.stringify(config.params) : '';
4918 - return `${config.baseURL ?? ''}${url}${params}`;
4919 -}
4920 -function getCachedResponse(config) {
4921 - if (config.method?.toLowerCase() !== 'get') {
4922 - return null;
4923 - }
4924 - const url = `${config.baseURL ?? ''}${config.url ?? ''}`;
4925 - const ttl = getUrlCacheTtl(url);
4926 - if (ttl === null) {
4927 - return null;
4928 - }
4929 - const key = getCacheKey(config);
4930 - const entry = cache.get(key);
4931 - if (!entry) {
4932 - return null;
4933 - }
4934 - if (Date.now() - entry.timestamp > ttl) {
4935 - cache.delete(key);
4936 - return null;
4937 - }
4938 - return entry.response;
4939 -}
4940 -function setCachedResponse(config, response) {
4941 - if (!config || config.method?.toLowerCase() !== 'get') {
4942 - return;
4943 - }
4944 - const url = `${config.baseURL ?? ''}${config.url ?? ''}`;
4945 - if (getUrlCacheTtl(url) === null) {
4946 - return;
4947 - }
4948 - const key = getCacheKey(config);
4949 - cache.set(key, {
4950 - response,
4951 - timestamp: Date.now()
4952 - });
4953 -}
4954 -
4955 -// Only idempotent / safe methods are retried. POST and PATCH are excluded because
4956 -// a 500 may arrive after the server partially completed the operation, and retrying
4957 -// could produce duplicates (e.g. create, lock, archive endpoints).
4958 -const RETRYABLE_METHODS = new Set(['get', 'head', 'options', 'put', 'delete']);
4959 -let instance;
4960 -const httpService = () => {
4961 - if (!instance) {
4962 - instance = axios__WEBPACK_IMPORTED_MODULE_0__["default"].create({
4963 - baseURL: _env__WEBPACK_IMPORTED_MODULE_1__.env.base_url,
4964 - timeout: 10000,
4965 - headers: {
4966 - 'Content-Type': 'application/json',
4967 - ..._env__WEBPACK_IMPORTED_MODULE_1__.env.headers
4968 - }
4969 - });
4970 - instance.interceptors.request.use(config => {
4971 - const cachedResponse = getCachedResponse(config);
4972 - if (cachedResponse) {
4973 - const controller = new AbortController();
4974 - controller.abort();
4975 - return {
4976 - ...config,
4977 - signal: controller.signal,
4978 - __cachedResponse: cachedResponse
4979 - };
4980 - }
4981 - return config;
4982 - });
4983 - instance.interceptors.response.use(response => {
4984 - setCachedResponse(response.config, response);
4985 - return response;
4986 - }, async error => {
4987 - const config = error.config;
4988 - if (config?.__cachedResponse) {
4989 - return config.__cachedResponse;
4990 - }
4991 - if (!config || !shouldRetry(error)) {
4992 - return Promise.reject(error);
4993 - }
4994 - const retryCount = config.__retryCount ?? 0;
4995 - if (retryCount >= MAX_RETRIES) {
4996 - return Promise.reject(error);
4997 - }
4998 - const baseDelay = BASE_DELAY_MS * Math.pow(2, retryCount);
4999 - const jitter = Math.random() * BASE_DELAY_MS * 0.1;
5000 - await sleep(baseDelay + jitter);
5001 - const baseTimeout = config.__baseTimeout ?? config.timeout ?? 10000;
5002 - return instance({
5003 - ...config,
5004 - __retryCount: retryCount + 1,
5005 - __baseTimeout: baseTimeout,
5006 - timeout: baseTimeout * (retryCount + 2)
5007 - });
5008 - });
5009 - }
5010 - return instance;
5011 -};
5012 -function shouldRetry(error) {
5013 - const method = error.config?.method?.toLowerCase();
5014 - if (method && !RETRYABLE_METHODS.has(method)) {
5015 - return false;
5016 - }
5017 - if (!error.response) {
5018 - return true;
5019 - }
5020 - // 429 Too Many Requests: transient rate-limiting, backoff helps
5021 - if (error.response.status === 429) {
5022 - return true;
5023 - }
5024 - return error.response.status >= 500;
5025 -}
5026 -function sleep(ms) {
5027 - return new Promise(resolve => setTimeout(resolve, ms));
5028 -}
5029 -
5030 -/***/ }),
5031 -
5032 -/***/ "@elementor/env":
5033 -/*!**************************************!*\
5034 - !*** external ["elementorV2","env"] ***!
5035 - \**************************************/
5036 -/***/ (function(module) {
5037 -
5038 -module.exports = window["elementorV2"]["env"];
5039 -
5040 -/***/ })
5041 -
5042 -/******/ });
5043 -/************************************************************************/
5044 -/******/ // The module cache
5045 -/******/ var __webpack_module_cache__ = {};
5046 -/******/
5047 -/******/ // The require function
5048 -/******/ function __webpack_require__(moduleId) {
5049 -/******/ // Check if module is in cache
5050 -/******/ var cachedModule = __webpack_module_cache__[moduleId];
5051 -/******/ if (cachedModule !== undefined) {
5052 -/******/ return cachedModule.exports;
5053 -/******/ }
5054 -/******/ // Create a new module (and put it into the cache)
5055 -/******/ var module = __webpack_module_cache__[moduleId] = {
5056 -/******/ // no module.id needed
5057 -/******/ // no module.loaded needed
5058 -/******/ exports: {}
5059 -/******/ };
5060 -/******/
5061 -/******/ // Execute the module function
5062 -/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
5063 -/******/
5064 -/******/ // Return the exports of the module
5065 -/******/ return module.exports;
5066 -/******/ }
5067 -/******/
5068 -/************************************************************************/
5069 -/******/ /* webpack/runtime/compat get default export */
5070 -/******/ !function() {
5071 -/******/ // getDefaultExport function for compatibility with non-harmony modules
5072 -/******/ __webpack_require__.n = function(module) {
5073 -/******/ var getter = module && module.__esModule ?
5074 -/******/ function() { return module['default']; } :
5075 -/******/ function() { return module; };
5076 -/******/ __webpack_require__.d(getter, { a: getter });
5077 -/******/ return getter;
5078 -/******/ };
5079 -/******/ }();
5080 -/******/
5081 -/******/ /* webpack/runtime/define property getters */
5082 -/******/ !function() {
5083 -/******/ // define getter functions for harmony exports
5084 -/******/ __webpack_require__.d = function(exports, definition) {
5085 -/******/ for(var key in definition) {
5086 -/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
5087 -/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
5088 -/******/ }
5089 -/******/ }
5090 -/******/ };
5091 -/******/ }();
5092 -/******/
5093 -/******/ /* webpack/runtime/hasOwnProperty shorthand */
5094 -/******/ !function() {
5095 -/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
5096 -/******/ }();
5097 -/******/
5098 -/******/ /* webpack/runtime/make namespace object */
5099 -/******/ !function() {
5100 -/******/ // define __esModule on exports
5101 -/******/ __webpack_require__.r = function(exports) {
5102 -/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
5103 -/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
5104 -/******/ }
5105 -/******/ Object.defineProperty(exports, '__esModule', { value: true });
5106 -/******/ };
5107 -/******/ }();
5108 -/******/
5109 -/************************************************************************/
5110 -var __webpack_exports__ = {};
5111 -// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
5112 -!function() {
5113 -/*!*********************************************************!*\
5114 - !*** ./packages/packages/libs/http-client/src/index.ts ***!
5115 - \*********************************************************/
5116 -__webpack_require__.r(__webpack_exports__);
5117 -/* harmony export */ __webpack_require__.d(__webpack_exports__, {
5118 -/* harmony export */ AxiosError: function() { return /* reexport safe */ axios__WEBPACK_IMPORTED_MODULE_0__.AxiosError; },
5119 -/* harmony export */ httpService: function() { return /* reexport safe */ _http__WEBPACK_IMPORTED_MODULE_1__.httpService; },
5120 -/* harmony export */ registerUrlForCache: function() { return /* reexport safe */ _http__WEBPACK_IMPORTED_MODULE_1__.registerUrlForCache; }
5121 -/* harmony export */ });
5122 -/* harmony import */ var axios__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! axios */ "./node_modules/axios/index.js");
5123 -/* harmony import */ var _http__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./http */ "./packages/packages/libs/http-client/src/http.ts");
5124 -
5125 -
5126 -}();
5127 -(window.elementorV2 = window.elementorV2 || {}).httpClient = __webpack_exports__;
5128 -/******/ })()
5129 -;
3038 +//#endregion
3039 +})(elementorV2.env);
5130 3040 window.elementorV2.httpClient?.init?.();
5131 3041 //# sourceMappingURL=http-client.js.map