https://www.rfd.com/themes/user/reinos_maps/dist/maps.production.bundle.js

1/******/ (() => { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3
4/***/ 9669:
5/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
6
7module.exports = __webpack_require__(51609);
8
9/***/ }),
10
11/***/ 55448:
12/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
13
14"use strict";
15
16
17var utils = __webpack_require__(64867);
18var settle = __webpack_require__(36026);
19var cookies = __webpack_require__(4372);
20var buildURL = __webpack_require__(15327);
21var buildFullPath = __webpack_require__(94097);
22var parseHeaders = __webpack_require__(84109);
23var isURLSameOrigin = __webpack_require__(67985);
24var transitionalDefaults = __webpack_require__(77874);
25var AxiosError = __webpack_require__(82648);
26var CanceledError = __webpack_require__(60644);
27var parseProtocol = __webpack_require__(90205);
28
29module.exports = function xhrAdapter(config) {
30  return new Promise(function dispatchXhrRequest(resolve, reject) {
31    var requestData = config.data;
32    var requestHeaders = config.headers;
33    var responseType = config.responseType;
34    var onCanceled;
35    function done() {
36      if (config.cancelToken) {
37        config.cancelToken.unsubscribe(onCanceled);
38      }
39
40      if (config.signal) {
41        config.signal.removeEventListener('abort', onCanceled);
42      }
43    }
44
45    if (utils.isFormData(requestData) && utils.isStandardBrowserEnv()) {
46      delete requestHeaders['Content-Type']; // Let the browser set it
47    }
48
49    var request = new XMLHttpRequest();
50
51    // HTTP basic authentication
52    if (config.auth) {
53      var username = config.auth.username || '';
54      var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : '';
55      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);
56    }
57
58    var fullPath = buildFullPath(config.baseURL, config.url);
59
60    request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
61
62    // Set the request timeout in MS
63    request.timeout = config.timeout;
64
65    function onloadend() {
66      if (!request) {
67        return;
68      }
69      // Prepare the response
70      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;
71      var responseData = !responseType || responseType === 'text' ||  responseType === 'json' ?
72        request.responseText : request.response;
73      var response = {
74        data: responseData,
75        status: request.status,
76        statusText: request.statusText,
77        headers: responseHeaders,
78        config: config,
79        request: request
80      };
81
82      settle(function _resolve(value) {
83        resolve(value);
84        done();
85      }, function _reject(err) {
86        reject(err);
87        done();
88      }, response);
89
90      // Clean up request
91      request = null;
92    }
93
94    if ('onloadend' in request) {
95      // Use onloadend if available
96      request.onloadend = onloadend;
97    } else {
98      // Listen for ready state to emulate onloadend
99      request.onreadystatechange = function handleLoad() {
100        if (!request || request.readyState !== 4) {
101          return;
102        }
103
104        // The request errored out and we didn't get a response, this will be
105        // handled by onerror instead
106        // With one exception: request that using file: protocol, most browsers
107        // will return status as 0 even though it's a successful request
108        if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {
109          return;
110        }
111        // readystate handler is calling before onerror or ontimeout handlers,
112        // so we should call onloadend on the next 'tick'
113        setTimeout(onloadend);
114      };
115    }
116
117    // Handle browser request cancellation (as opposed to a manual cancellation)
118    request.onabort = function handleAbort() {
119      if (!request) {
120        return;
121      }
122
123      reject(new AxiosError('Request aborted', AxiosError.ECONNABORTED, config, request));
124
125      // Clean up request
126      request = null;
127    };
128
129    // Handle low level network errors
130    request.onerror = function handleError() {
131      // Real errors are hidden from us by the browser
132      // onerror should only fire if it's a network error
133      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request, request));
134
135      // Clean up request
136      request = null;
137    };
138
139    // Handle timeout
140    request.ontimeout = function handleTimeout() {
141      var timeoutErrorMessage = config.timeout ? 'timeout of ' + config.timeout + 'ms exceeded' : 'timeout exceeded';
142      var transitional = config.transitional || transitionalDefaults;
143      if (config.timeoutErrorMessage) {
144        timeoutErrorMessage = config.timeoutErrorMessage;
145      }
146      reject(new AxiosError(
147        timeoutErrorMessage,
148        transitional.clarifyTimeoutError ? AxiosError.ETIMEDOUT : AxiosError.ECONNABORTED,
149        config,
150        request));
151
152      // Clean up request
153      request = null;
154    };
155
156    // Add xsrf header
157    // This is only done if running in a standard browser environment.
158    // Specifically not if we're in a web worker, or react-native.
159    if (utils.isStandardBrowserEnv()) {
160      // Add xsrf header
161      var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ?
162        cookies.read(config.xsrfCookieName) :
163        undefined;
164
165      if (xsrfValue) {
166        requestHeaders[config.xsrfHeaderName] = xsrfValue;
167      }
168    }
169
170    // Add headers to the request
171    if ('setRequestHeader' in request) {

172      utils.forEach(requestHeaders, function setRequestHeader(val, key) {
173        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
174          // Remove Content-Type if data is undefined
175          delete requestHeaders[key];
176        } else {
177          // Otherwise add header to the request
178          request.setRequestHeader(key, val);
179        }
180      });
181    }
182
183    // Add withCredentials to request if needed
184    if (!utils.isUndefined(config.withCredentials)) {
185      request.withCredentials = !!config.withCredentials;
186    }
187
188    // Add responseType to request if needed
189    if (responseType && responseType !== 'json') {
190      request.responseType = config.responseType;
191    }
192
193    // Handle progress if needed
194    if (typeof config.onDownloadProgress === 'function') {
195      request.addEventListener('progress', config.onDownloadProgress);
196    }
197
198    // Not all browsers support upload events
199    if (typeof config.onUploadProgress === 'function' && request.upload) {
200      request.upload.addEventListener('progress', config.onUploadProgress);
201    }
202
203    if (config.cancelToken || config.signal) {
204      // Handle cancellation
205      // eslint-disable-next-line func-names
206      onCanceled = function(cancel) {
207        if (!request) {
208          return;
209        }
210        reject(!cancel || (cancel && cancel.type) ? new CanceledError() : cancel);
211        request.abort();
212        request = null;
213      };
214
215      config.cancelToken && config.cancelToken.subscribe(onCanceled);
216      if (config.signal) {
217        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
218      }
219    }
220
221    if (!requestData) {
222      requestData = null;
223    }
224
225    var protocol = parseProtocol(fullPath);
226
227    if (protocol && [ 'http', 'https', 'file' ].indexOf(protocol) === -1) {
228      reject(new AxiosError('Unsupported protocol ' + protocol + ':', AxiosError.ERR_BAD_REQUEST, config));
229      return;
230    }
231
232
233    // Send the request
234    request.send(requestData);
235  });
236};
237
238
239/***/ }),
240
241/***/ 51609:
242/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
243
244"use strict";
245
246
247var utils = __webpack_require__(64867);
248var bind = __webpack_require__(91849);
249var Axios = __webpack_require__(30321);
250var mergeConfig = __webpack_require__(47185);
251var defaults = __webpack_require__(45546);
252
253/**
254 * Create an instance of Axios
255 *
256 * @param {Object} defaultConfig The default config for the instance
257 * @return {Axios} A new instance of Axios
258 */
259function createInstance(defaultConfig) {
260  var context = new Axios(defaultConfig);
261  var instance = bind(Axios.prototype.request, context);
262
263  // Copy axios.prototype to instance
264  utils.extend(instance, Axios.prototype, context);
265
266  // Copy context to instance
267  utils.extend(instance, context);
268
269  // Factory for creating new instances
270  instance.create = function create(instanceConfig) {
271    return createInstance(mergeConfig(defaultConfig, instanceConfig));
272  };
273
274  return instance;
275}
276
277// Create the default instance to be exported
278var axios = createInstance(defaults);
279
280// Expose Axios class to allow class inheritance
281axios.Axios = Axios;
282
283// Expose Cancel & CancelToken
284axios.CanceledError = __webpack_require__(60644);
285axios.CancelToken = __webpack_require__(14972);
286axios.isCancel = __webpack_require__(26502);
287axios.VERSION = (__webpack_require__(97288).version);
288axios.toFormData = __webpack_require__(47675);
289
290// Expose AxiosError class
291axios.AxiosError = __webpack_require__(82648);
292
293// alias for CanceledError for backward compatibility
294axios.Cancel = axios.CanceledError;
295
296// Expose all/spread
297axios.all = function all(promises) {
298  return Promise.all(promises);
299};
300axios.spread = __webpack_require__(8713);
301
302// Expose isAxiosError
303axios.isAxiosError = __webpack_require__(16268);
304
305module.exports = axios;
306
307// Allow use of default import syntax in TypeScript
308module.exports["default"] = axios;
309
310
311/***/ }),
312
313/***/ 14972:
314/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
315
316"use strict";
317
318
319var CanceledError = __webpack_require__(60644);
320
321/**
322 * A `CancelToken` is an object that can be used to request cancellation of an operation.
323 *
324 * @class
325 * @param {Function} executor The executor function.
326 */
327function CancelToken(executor) {
328  if (typeof executor !== 'function') {
329    throw new TypeError('executor must be a function.');
330  }
331
332  var resolvePromise;
333
334  this.promise = new Promise(function promiseExecutor(resolve) {
335    resolvePromise = resolve;
336  });
337
338  var token = this;
339
340  // eslint-disable-next-line func-names
341  this.promise.then(function(cancel) {
342    if (!token._listeners) return;
343
344    var i;
345    var l = token._listeners.length;
346
347    for (i = 0; i < l; i++) {
348      token._listeners[i](cancel);
349    }
350    token._listeners = null;
351  });
352
353  // eslint-disable-next-line func-names
354  this.promise.then = function(onfulfilled) {
355    var _resolve;
356    // eslint-disable-next-line func-names
357    var promise = new Promise(function(resolve) {
358      token.subscribe(resolve);
359      _resolve = resolve;
360    }).then(onfulfilled);
361
362    promise.cancel = function reject() {
363      token.unsubscribe(_resolve);
364    };
365
366    return promise;
367  };
368
369  executor(function cancel(message) {
370    if (token.reason) {
371      // Cancellation has already been requested
372      return;
373    }
374
375    token.reason = new CanceledError(message);
376    resolvePromise(token.reason);
377  });
378}
379
380/**
381 * Throws a `CanceledError` if cancellation has been requested.
382 */
383CancelToken.prototype.throwIfRequested = function throwIfRequested() {
384  if (this.reason) {
385    throw this.reason;
386  }
387};
388
389/**
390 * Subscribe to the cancel signal
391 */
392
393CancelToken.prototype.subscribe = function subscribe(listener) {
394  if (this.reason) {
395    listener(this.reason);
396    return;
397  }
398
399  if (this._listeners) {
400    this._listeners.push(listener);
401  } else {
402    this._listeners = [listener];
403  }
404};
405
406/**
407 * Unsubscribe from the cancel signal
408 */
409
410CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
411  if (!this._listeners) {
412    return;
413  }
414  var index = this._listeners.indexOf(listener);
415  if (index !== -1) {
416    this._listeners.splice(index, 1);
417  }
418};
419
420/**
421 * Returns an object that contains a new `CancelToken` and a function that, when called,
422 * cancels the `CancelToken`.
423 */
424CancelToken.source = function source() {
425  var cancel;
426  var token = new CancelToken(function executor(c) {
427    cancel = c;
428  });
429  return {
430    token: token,
431    cancel: cancel
432  };
433};
434
435module.exports = CancelToken;
436
437
438/***/ }),
439
440/***/ 60644:
441/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
442
443"use strict";
444
445
446var AxiosError = __webpack_require__(82648);
447var utils = __webpack_require__(64867);
448
449/**
450 * A `CanceledError` is an object that is thrown when an operation is canceled.
451 *
452 * @class
453 * @param {string=} message The message.
454 */
455function CanceledError(message) {
456  // eslint-disable-next-line no-eq-null,eqeqeq
457  AxiosError.call(this, message == null ? 'canceled' : message, AxiosError.ERR_CANCELED);
458  this.name = 'CanceledError';
459}
460
461utils.inherits(CanceledError, AxiosError, {
462  __CANCEL__: true
463});
464
465module.exports = CanceledError;
466
467
468/***/ }),
469
470/***/ 26502:
471/***/ ((module) => {
472
473"use strict";
474
475
476module.exports = function isCancel(value) {
477  return !!(value && value.__CANCEL__);
478};
479
480
481/***/ }),
482
483/***/ 30321:
484/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
485
486"use strict";
487
488
489var utils = __webpack_require__(64867);
490var buildURL = __webpack_require__(15327);
491var InterceptorManager = __webpack_require__(80782);
492var dispatchRequest = __webpack_require__(13572);
493var mergeConfig = __webpack_require__(47185);

494var buildFullPath = __webpack_require__(94097);
495var validator = __webpack_require__(54875);
496
497var validators = validator.validators;
498/**
499 * Create a new instance of Axios
500 *
501 * @param {Object} instanceConfig The default config for the instance
502 */
503function Axios(instanceConfig) {
504  this.defaults = instanceConfig;
505  this.interceptors = {
506    request: new InterceptorManager(),
507    response: new InterceptorManager()
508  };
509}
510
511/**
512 * Dispatch a request
513 *
514 * @param {Object} config The config specific for this request (merged with this.defaults)
515 */
516Axios.prototype.request = function request(configOrUrl, config) {
517  /*eslint no-param-reassign:0*/
518  // Allow for axios('example/url'[, config]) a la fetch API
519  if (typeof configOrUrl === 'string') {
520    config = config || {};
521    config.url = configOrUrl;
522  } else {
523    config = configOrUrl || {};
524  }
525
526  config = mergeConfig(this.defaults, config);
527
528  // Set config.method
529  if (config.method) {
530    config.method = config.method.toLowerCase();
531  } else if (this.defaults.method) {
532    config.method = this.defaults.method.toLowerCase();
533  } else {
534    config.method = 'get';
535  }
536
537  var transitional = config.transitional;
538
539  if (transitional !== undefined) {
540    validator.assertOptions(transitional, {
541      silentJSONParsing: validators.transitional(validators.boolean),
542      forcedJSONParsing: validators.transitional(validators.boolean),
543      clarifyTimeoutError: validators.transitional(validators.boolean)
544    }, false);
545  }
546
547  // filter out skipped interceptors
548  var requestInterceptorChain = [];
549  var synchronousRequestInterceptors = true;
550  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
551    if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
552      return;
553    }
554
555    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
556
557    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
558  });
559
560  var responseInterceptorChain = [];
561  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
562    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
563  });
564
565  var promise;
566
567  if (!synchronousRequestInterceptors) {
568    var chain = [dispatchRequest, undefined];
569
570    Array.prototype.unshift.apply(chain, requestInterceptorChain);
571    chain = chain.concat(responseInterceptorChain);
572
573    promise = Promise.resolve(config);
574    while (chain.length) {
575      promise = promise.then(chain.shift(), chain.shift());
576    }
577
578    return promise;
579  }
580
581
582  var newConfig = config;
583  while (requestInterceptorChain.length) {
584    var onFulfilled = requestInterceptorChain.shift();
585    var onRejected = requestInterceptorChain.shift();
586    try {
587      newConfig = onFulfilled(newConfig);
588    } catch (error) {
589      onRejected(error);
590      break;
591    }
592  }
593
594  try {
595    promise = dispatchRequest(newConfig);
596  } catch (error) {
597    return Promise.reject(error);
598  }
599
600  while (responseInterceptorChain.length) {
601    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
602  }
603
604  return promise;
605};
606
607Axios.prototype.getUri = function getUri(config) {
608  config = mergeConfig(this.defaults, config);
609  var fullPath = buildFullPath(config.baseURL, config.url);
610  return buildURL(fullPath, config.params, config.paramsSerializer);
611};
612
613// Provide aliases for supported request methods
614utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
615  /*eslint func-names:0*/
616  Axios.prototype[method] = function(url, config) {
617    return this.request(mergeConfig(config || {}, {
618      method: method,
619      url: url,
620      data: (config || {}).data
621    }));
622  };
623});
624
625utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
626  /*eslint func-names:0*/
627
628  function generateHTTPMethod(isForm) {
629    return function httpMethod(url, data, config) {
630      return this.request(mergeConfig(config || {}, {
631        method: method,
632        headers: isForm ? {
633          'Content-Type': 'multipart/form-data'
634        } : {},
635        url: url,
636        data: data
637      }));
638    };
639  }
640
641  Axios.prototype[method] = generateHTTPMethod();
642
643  Axios.prototype[method + 'Form'] = generateHTTPMethod(true);
644});
645
646module.exports = Axios;
647
648
649/***/ }),
650
651/***/ 82648:
652/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
653
654"use strict";
655
656
657var utils = __webpack_require__(64867);
658
659/**
660 * Create an Error with the specified message, config, error code, request and response.
661 *
662 * @param {string} message The error message.
663 * @param {string} [code] The error code (for example, 'ECONNABORTED').
664 * @param {Object} [config] The config.
665 * @param {Object} [request] The request.
666 * @param {Object} [response] The response.
667 * @returns {Error} The created error.
668 */
669function AxiosError(message, code, config, request, response) {
670  Error.call(this);
671  this.message = message;
672  this.name = 'AxiosError';
673  code && (this.code = code);
674  config && (this.config = config);
675  request && (this.request = request);
676  response && (this.response = response);
677}
678
679utils.inherits(AxiosError, Error, {
680  toJSON: function toJSON() {
681    return {
682      // Standard
683      message: this.message,
684      name: this.name,
685      // Microsoft
686      description: this.description,
687      number: this.number,
688      // Mozilla
689      fileName: this.fileName,
690      lineNumber: this.lineNumber,
691      columnNumber: this.columnNumber,
692      stack: this.stack,
693      // Axios
694      config: this.config,

695      code: this.code,
696      status: this.response && this.response.status ? this.response.status : null
697    };
698  }
699});
700
701var prototype = AxiosError.prototype;
702var descriptors = {};
703
704[
705  'ERR_BAD_OPTION_VALUE',
706  'ERR_BAD_OPTION',
707  'ECONNABORTED',
708  'ETIMEDOUT',
709  'ERR_NETWORK',
710  'ERR_FR_TOO_MANY_REDIRECTS',
711  'ERR_DEPRECATED',
712  'ERR_BAD_RESPONSE',
713  'ERR_BAD_REQUEST',
714  'ERR_CANCELED'
715// eslint-disable-next-line func-names
716].forEach(function(code) {
717  descriptors[code] = {value: code};
718});
719
720Object.defineProperties(AxiosError, descriptors);
721Object.defineProperty(prototype, 'isAxiosError', {value: true});
722
723// eslint-disable-next-line func-names
724AxiosError.from = function(error, code, config, request, response, customProps) {
725  var axiosError = Object.create(prototype);
726
727  utils.toFlatObject(error, axiosError, function filter(obj) {
728    return obj !== Error.prototype;
729  });
730
731  AxiosError.call(axiosError, error.message, code, config, request, response);
732
733  axiosError.name = error.name;
734
735  customProps && Object.assign(axiosError, customProps);
736
737  return axiosError;
738};
739
740module.exports = AxiosError;
741
742
743/***/ }),
744
745/***/ 80782:
746/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
747
748"use strict";
749
750
751var utils = __webpack_require__(64867);
752
753function InterceptorManager() {
754  this.handlers = [];
755}
756
757/**
758 * Add a new interceptor to the stack
759 *
760 * @param {Function} fulfilled The function to handle `then` for a `Promise`
761 * @param {Function} rejected The function to handle `reject` for a `Promise`
762 *
763 * @return {Number} An ID used to remove interceptor later
764 */
765InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
766  this.handlers.push({
767    fulfilled: fulfilled,
768    rejected: rejected,
769    synchronous: options ? options.synchronous : false,
770    runWhen: options ? options.runWhen : null
771  });
772  return this.handlers.length - 1;
773};
774
775/**
776 * Remove an interceptor from the stack
777 *
778 * @param {Number} id The ID that was returned by `use`
779 */
780InterceptorManager.prototype.eject = function eject(id) {
781  if (this.handlers[id]) {
782    this.handlers[id] = null;
783  }
784};
785
786/**
787 * Iterate over all the registered interceptors
788 *
789 * This method is particularly useful for skipping over any
790 * interceptors that may have become `null` calling `eject`.
791 *
792 * @param {Function} fn The function to call for each interceptor
793 */
794InterceptorManager.prototype.forEach = function forEach(fn) {
795  utils.forEach(this.handlers, function forEachHandler(h) {
796    if (h !== null) {
797      fn(h);
798    }
799  });
800};
801
802module.exports = InterceptorManager;
803
804
805/***/ }),
806
807/***/ 94097:
808/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
809
810"use strict";
811
812
813var isAbsoluteURL = __webpack_require__(91793);
814var combineURLs = __webpack_require__(7303);
815
816/**
817 * Creates a new URL by combining the baseURL with the requestedURL,
818 * only when the requestedURL is not already an absolute URL.
819 * If the requestURL is absolute, this function returns the requestedURL untouched.
820 *
821 * @param {string} baseURL The base URL
822 * @param {string} requestedURL Absolute or relative URL to combine
823 * @returns {string} The combined full path
824 */
825module.exports = function buildFullPath(baseURL, requestedURL) {
826  if (baseURL && !isAbsoluteURL(requestedURL)) {
827    return combineURLs(baseURL, requestedURL);
828  }
829  return requestedURL;
830};
831
832
833/***/ }),
834
835/***/ 13572:
836/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
837
838"use strict";
839
840
841var utils = __webpack_require__(64867);
842var transformData = __webpack_require__(18527);
843var isCancel = __webpack_require__(26502);
844var defaults = __webpack_require__(45546);
845var CanceledError = __webpack_require__(60644);
846
847/**
848 * Throws a `CanceledError` if cancellation has been requested.
849 */
850function throwIfCancellationRequested(config) {
851  if (config.cancelToken) {
852    config.cancelToken.throwIfRequested();
853  }
854
855  if (config.signal && config.signal.aborted) {
856    throw new CanceledError();
857  }
858}
859
860/**
861 * Dispatch a request to the server using the configured adapter.
862 *
863 * @param {object} config The config that is to be used for the request
864 * @returns {Promise} The Promise to be fulfilled
865 */
866module.exports = function dispatchRequest(config) {
867  throwIfCancellationRequested(config);
868
869  // Ensure headers exist
870  config.headers = config.headers || {};
871
872  // Transform request data
873  config.data = transformData.call(
874    config,
875    config.data,
876    config.headers,
877    config.transformRequest
878  );
879
880  // Flatten headers
881  config.headers = utils.merge(
882    config.headers.common || {},
883    config.headers[config.method] || {},
884    config.headers
885  );
886
887  utils.forEach(
888    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
889    function cleanHeaderConfig(method) {
890      delete config.headers[method];
891    }
892  );
893
894  var adapter = config.adapter || defaults.adapter;
895
896  return adapter(config).then(function onAdapterResolution(response) {
897    throwIfCancellationRequested(config);
898
899    // Transform response data
900    response.data = transformData.call(
901      config,
902      response.data,
903      response.headers,
904      config.transformResponse
905    );
906
907    return response;
908  }, function onAdapterRejection(reason) {
909    if (!isCancel(reason)) {
910      throwIfCancellationRequested(config);
911
912      // Transform response data
913      if (reason && reason.response) {
914        reason.response.data = transformData.call(
915          config,
916          reason.response.data,
917          reason.response.headers,
918          config.transformResponse
919        );
920      }
921    }
922
923    return Promise.reject(reason);
924  });
925};
926
927
928/***/ }),
929
930/***/ 47185:
931/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
932
933"use strict";
934
935
936var utils = __webpack_require__(64867);
937
938/**
939 * Config-specific merge-function which creates a new config-object
940 * by merging two configuration objects together.
941 *
942 * @param {Object} config1
943 * @param {Object} config2
944 * @returns {Object} New object resulting from merging config2 to config1
945 */
946module.exports = function mergeConfig(config1, config2) {
947  // eslint-disable-next-line no-param-reassign
948  config2 = config2 || {};
949  var config = {};
950
951  function getMergedValue(target, source) {
952    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
953      return utils.merge(target, source);
954    } else if (utils.isPlainObject(source)) {
955      return utils.merge({}, source);
956    } else if (utils.isArray(source)) {
957      return source.slice();
958    }
959    return source;
960  }
961
962  // eslint-disable-next-line consistent-return
963  function mergeDeepProperties(prop) {
964    if (!utils.isUndefined(config2[prop])) {
965      return getMergedValue(config1[prop], config2[prop]);
966    } else if (!utils.isUndefined(config1[prop])) {
967      return getMergedValue(undefined, config1[prop]);
968    }
969  }
970
971  // eslint-disable-next-line consistent-return
972  function valueFromConfig2(prop) {
973    if (!utils.isUndefined(config2[prop])) {
974      return getMergedValue(undefined, config2[prop]);
975    }
976  }
977
978  // eslint-disable-next-line consistent-return
979  function defaultToConfig2(prop) {
980    if (!utils.isUndefined(config2[prop])) {
981      return getMergedValue(undefined, config2[prop]);
982    } else if (!utils.isUndefined(config1[prop])) {
983      return getMergedValue(undefined, config1[prop]);
984    }
985  }
986
987  // eslint-disable-next-line consistent-return
988  function mergeDirectKeys(prop) {
989    if (prop in config2) {
990      return getMergedValue(config1[prop], config2[prop]);
991    } else if (prop in config1) {
992      return getMergedValue(undefined, config1[prop]);
993    }
994  }
995
996  var mergeMap = {
997    'url': valueFromConfig2,
998    'method': valueFromConfig2,
999    'data': valueFromConfig2,
1000    'baseURL': defaultToConfig2,
1001    'transformRequest': defaultToConfig2,
1002    'transformResponse': defaultToConfig2,
1003    'paramsSerializer': defaultToConfig2,
1004    'timeout': defaultToConfig2,
1005    'timeoutMessage': defaultToConfig2,
1006    'withCredentials': defaultToConfig2,
1007    'adapter': defaultToConfig2,
1008    'responseType': defaultToConfig2,
1009    'xsrfCookieName': defaultToConfig2,
1010    'xsrfHeaderName': defaultToConfig2,
1011    'onUploadProgress': defaultToConfig2,
1012    'onDownloadProgress': defaultToConfig2,
1013    'decompress': defaultToConfig2,
1014    'maxContentLength': defaultToConfig2,
1015    'maxBodyLength': defaultToConfig2,
1016    'beforeRedirect': defaultToConfig2,
1017    'transport': defaultToConfig2,
1018    'httpAgent': defaultToConfig2,
1019    'httpsAgent': defaultToConfig2,
1020    'cancelToken': defaultToConfig2,
1021    'socketPath': defaultToConfig2,
1022    'responseEncoding': defaultToConfig2,
1023    'validateStatus': mergeDirectKeys
1024  };
1025
1026  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
1027    var merge = mergeMap[prop] || mergeDeepProperties;
1028    var configValue = merge(prop);
1029    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
1030  });
1031
1032  return config;
1033};
1034
1035
1036/***/ }),
1037
1038/***/ 36026:
1039/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1040
1041"use strict";
1042
1043
1044var AxiosError = __webpack_require__(82648);
1045
1046/**
1047 * Resolve or reject a Promise based on response status.
1048 *
1049 * @param {Function} resolve A function that resolves the promise.
1050 * @param {Function} reject A function that rejects the promise.
1051 * @param {object} response The response.
1052 */
1053module.exports = function settle(resolve, reject, response) {

1054  var validateStatus = response.config.validateStatus;
1055  if (!response.status || !validateStatus || validateStatus(response.status)) {
1056    resolve(response);
1057  } else {
1058    reject(new AxiosError(
1059      'Request failed with status code ' + response.status,
1060      [AxiosError.ERR_BAD_REQUEST, AxiosError.ERR_BAD_RESPONSE][Math.floor(response.status / 100) - 4],
1061      response.config,
1062      response.request,
1063      response
1064    ));
1065  }
1066};
1067
1068
1069/***/ }),
1070
1071/***/ 18527:
1072/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1073
1074"use strict";
1075
1076
1077var utils = __webpack_require__(64867);
1078var defaults = __webpack_require__(45546);
1079
1080/**
1081 * Transform the data for a request or a response
1082 *
1083 * @param {Object|String} data The data to be transformed
1084 * @param {Array} headers The headers for the request or response
1085 * @param {Array|Function} fns A single function or Array of functions
1086 * @returns {*} The resulting transformed data
1087 */
1088module.exports = function transformData(data, headers, fns) {
1089  var context = this || defaults;
1090  /*eslint no-param-reassign:0*/
1091  utils.forEach(fns, function transform(fn) {
1092    data = fn.call(context, data, headers);
1093  });
1094
1095  return data;
1096};
1097
1098
1099/***/ }),
1100
1101/***/ 45546:
1102/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1103
1104"use strict";
1105
1106
1107var utils = __webpack_require__(64867);
1108var normalizeHeaderName = __webpack_require__(16016);
1109var AxiosError = __webpack_require__(82648);
1110var transitionalDefaults = __webpack_require__(77874);
1111var toFormData = __webpack_require__(47675);
1112
1113var DEFAULT_CONTENT_TYPE = {
1114  'Content-Type': 'application/x-www-form-urlencoded'
1115};
1116
1117function setContentTypeIfUnset(headers, value) {
1118  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
1119    headers['Content-Type'] = value;
1120  }
1121}
1122
1123function getDefaultAdapter() {
1124  var adapter;
1125  if (typeof XMLHttpRequest !== 'undefined') {
1126    // For browsers use XHR adapter
1127    adapter = __webpack_require__(55448);
1128  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
1129    // For node use HTTP adapter
1130    adapter = __webpack_require__(55448);
1131  }
1132  return adapter;
1133}
1134
1135function stringifySafely(rawValue, parser, encoder) {
1136  if (utils.isString(rawValue)) {
1137    try {
1138      (parser || JSON.parse)(rawValue);
1139      return utils.trim(rawValue);
1140    } catch (e) {
1141      if (e.name !== 'SyntaxError') {
1142        throw e;
1143      }
1144    }
1145  }
1146
1147  return (encoder || JSON.stringify)(rawValue);
1148}
1149
1150var defaults = {
1151
1152  transitional: transitionalDefaults,
1153
1154  adapter: getDefaultAdapter(),
1155
1156  transformRequest: [function transformRequest(data, headers) {
1157    normalizeHeaderName(headers, 'Accept');
1158    normalizeHeaderName(headers, 'Content-Type');
1159
1160    if (utils.isFormData(data) ||
1161      utils.isArrayBuffer(data) ||
1162      utils.isBuffer(data) ||
1163      utils.isStream(data) ||
1164      utils.isFile(data) ||
1165      utils.isBlob(data)
1166    ) {
1167      return data;
1168    }
1169    if (utils.isArrayBufferView(data)) {
1170      return data.buffer;
1171    }
1172    if (utils.isURLSearchParams(data)) {
1173      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
1174      return data.toString();
1175    }
1176
1177    var isObjectPayload = utils.isObject(data);
1178    var contentType = headers && headers['Content-Type'];
1179
1180    var isFileList;
1181
1182    if ((isFileList = utils.isFileList(data)) || (isObjectPayload && contentType === 'multipart/form-data')) {
1183      var _FormData = this.env && this.env.FormData;
1184      return toFormData(isFileList ? {'files[]': data} : data, _FormData && new _FormData());
1185    } else if (isObjectPayload || contentType === 'application/json') {
1186      setContentTypeIfUnset(headers, 'application/json');
1187      return stringifySafely(data);
1188    }
1189
1190    return data;
1191  }],
1192
1193  transformResponse: [function transformResponse(data) {
1194    var transitional = this.transitional || defaults.transitional;
1195    var silentJSONParsing = transitional && transitional.silentJSONParsing;
1196    var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
1197    var strictJSONParsing = !silentJSONParsing && this.responseType === 'json';
1198
1199    if (strictJSONParsing || (forcedJSONParsing && utils.isString(data) && data.length)) {

1200      try {
1201        return JSON.parse(data);
1202      } catch (e) {
1203        if (strictJSONParsing) {
1204          if (e.name === 'SyntaxError') {
1205            throw AxiosError.from(e, AxiosError.ERR_BAD_RESPONSE, this, null, this.response);
1206          }
1207          throw e;
1208        }
1209      }
1210    }
1211
1212    return data;
1213  }],
1214
1215  /**
1216   * A timeout in milliseconds to abort a request. If set to 0 (default) a
1217   * timeout is not created.
1218   */
1219  timeout: 0,
1220
1221  xsrfCookieName: 'XSRF-TOKEN',
1222  xsrfHeaderName: 'X-XSRF-TOKEN',
1223
1224  maxContentLength: -1,
1225  maxBodyLength: -1,
1226
1227  env: {
1228    FormData: __webpack_require__(91623)
1229  },
1230
1231  validateStatus: function validateStatus(status) {
1232    return status >= 200 && status < 300;
1233  },
1234
1235  headers: {
1236    common: {
1237      'Accept': 'application/json, text/plain, */*'
1238    }
1239  }
1240};
1241
1242utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
1243  defaults.headers[method] = {};
1244});
1245
1246utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
1247  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
1248});
1249
1250module.exports = defaults;
1251
1252
1253/***/ }),
1254
1255/***/ 77874:
1256/***/ ((module) => {
1257
1258"use strict";
1259
1260
1261module.exports = {
1262  silentJSONParsing: true,
1263  forcedJSONParsing: true,
1264  clarifyTimeoutError: false
1265};
1266
1267
1268/***/ }),
1269
1270/***/ 97288:
1271/***/ ((module) => {
1272
1273module.exports = {
1274  "version": "0.27.2"
1275};
1276
1277/***/ }),
1278
1279/***/ 91849:
1280/***/ ((module) => {
1281
1282"use strict";
1283
1284
1285module.exports = function bind(fn, thisArg) {
1286  return function wrap() {
1287    var args = new Array(arguments.length);
1288    for (var i = 0; i < args.length; i++) {
1289      args[i] = arguments[i];
1290    }
1291    return fn.apply(thisArg, args);
1292  };
1293};
1294
1295
1296/***/ }),
1297
1298/***/ 15327:
1299/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1300
1301"use strict";
1302
1303
1304var utils = __webpack_require__(64867);
1305
1306function encode(val) {
1307  return encodeURIComponent(val).
1308    replace(/%3A/gi, ':').
1309    replace(/%24/g, '$').
1310    replace(/%2C/gi, ',').
1311    replace(/%20/g, '+').
1312    replace(/%5B/gi, '[').
1313    replace(/%5D/gi, ']');
1314}
1315
1316/**
1317 * Build a URL by appending params to the end
1318 *
1319 * @param {string} url The base of the url (e.g., http://www.google.com)
1320 * @param {object} [params] The params to be appended
1321 * @returns {string} The formatted url
1322 */
1323module.exports = function buildURL(url, params, paramsSerializer) {
1324  /*eslint no-param-reassign:0*/
1325  if (!params) {
1326    return url;
1327  }
1328
1329  var serializedParams;
1330  if (paramsSerializer) {
1331    serializedParams = paramsSerializer(params);
1332  } else if (utils.isURLSearchParams(params)) {
1333    serializedParams = params.toString();
1334  } else {
1335    var parts = [];
1336
1337    utils.forEach(params, function serialize(val, key) {
1338      if (val === null || typeof val === 'undefined') {
1339        return;
1340      }
1341
1342      if (utils.isArray(val)) {
1343        key = key + '[]';
1344      } else {
1345        val = [val];
1346      }
1347
1348      utils.forEach(val, function parseValue(v) {
1349        if (utils.isDate(v)) {
1350          v = v.toISOString();
1351        } else if (utils.isObject(v)) {
1352          v = JSON.stringify(v);
1353        }
1354        parts.push(encode(key) + '=' + encode(v));
1355      });
1356    });
1357
1358    serializedParams = parts.join('&');
1359  }
1360
1361  if (serializedParams) {
1362    var hashmarkIndex = url.indexOf('#');
1363    if (hashmarkIndex !== -1) {
1364      url = url.slice(0, hashmarkIndex);
1365    }
1366
1367    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
1368  }
1369
1370  return url;
1371};
1372
1373
1374/***/ }),
1375
1376/***/ 7303:
1377/***/ ((module) => {
1378
1379"use strict";
1380
1381
1382/**
1383 * Creates a new URL by combining the specified URLs
1384 *
1385 * @param {string} baseURL The base URL
1386 * @param {string} relativeURL The relative URL
1387 * @returns {string} The combined URL
1388 */
1389module.exports = function combineURLs(baseURL, relativeURL) {
1390  return relativeURL
1391    ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
1392    : baseURL;
1393};
1394
1395
1396/***/ }),
1397
1398/***/ 4372:
1399/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1400
1401"use strict";
1402
1403
1404var utils = __webpack_require__(64867);
1405
1406module.exports = (
1407  utils.isStandardBrowserEnv() ?
1408
1409  // Standard browser envs support document.cookie
1410    (function standardBrowserEnv() {
1411      return {
1412        write: function write(name, value, expires, path, domain, secure) {
1413          var cookie = [];
1414          cookie.push(name + '=' + encodeURIComponent(value));
1415
1416          if (utils.isNumber(expires)) {
1417            cookie.push('expires=' + new Date(expires).toGMTString());
1418          }
1419
1420          if (utils.isString(path)) {
1421            cookie.push('path=' + path);
1422          }
1423
1424          if (utils.isString(domain)) {
1425            cookie.push('domain=' + domain);
1426          }
1427
1428          if (secure === true) {
1429            cookie.push('secure');
1430          }
1431
1432          document.cookie = cookie.join('; ');
1433        },
1434
1435        read: function read(name) {
1436          var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
1437          return (match ? decodeURIComponent(match[3]) : null);
1438        },
1439
1440        remove: function remove(name) {
1441          this.write(name, '', Date.now() - 86400000);
1442        }
1443      };
1444    })() :
1445
1446  // Non standard browser env (web workers, react-native) lack needed support.
1447    (function nonStandardBrowserEnv() {
1448      return {
1449        write: function write() {},
1450        read: function read() { return null; },
1451        remove: function remove() {}
1452      };
1453    })()
1454);
1455
1456
1457/***/ }),
1458
1459/***/ 91793:
1460/***/ ((module) => {
1461
1462"use strict";
1463
1464
1465/**
1466 * Determines whether the specified URL is absolute
1467 *
1468 * @param {string} url The URL to test
1469 * @returns {boolean} True if the specified URL is absolute, otherwise false
1470 */
1471module.exports = function isAbsoluteURL(url) {
1472  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
1473  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
1474  // by any combination of letters, digits, plus, period, or hyphen.
1475  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
1476};
1477
1478
1479/***/ }),
1480
1481/***/ 16268:
1482/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1483
1484"use strict";
1485
1486
1487var utils = __webpack_require__(64867);
1488
1489/**
1490 * Determines whether the payload is an error thrown by Axios
1491 *
1492 * @param {*} payload The value to test
1493 * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
1494 */
1495module.exports = function isAxiosError(payload) {
1496  return utils.isObject(payload) && (payload.isAxiosError === true);
1497};
1498
1499
1500/***/ }),
1501
1502/***/ 67985:
1503/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1504
1505"use strict";
1506
1507
1508var utils = __webpack_require__(64867);
1509
1510module.exports = (
1511  utils.isStandardBrowserEnv() ?
1512

1513  // Standard browser envs have full support of the APIs needed to test
1514  // whether the request URL is of the same origin as current location.
1515    (function standardBrowserEnv() {
1516      var msie = /(msie|trident)/i.test(navigator.userAgent);
1517      var urlParsingNode = document.createElement('a');
1518      var originURL;
1519
1520      /**
1521    * Parse a URL to discover it's components
1522    *
1523    * @param {String} url The URL to be parsed
1524    * @returns {Object}
1525    */
1526      function resolveURL(url) {
1527        var href = url;
1528
1529        if (msie) {
1530        // IE needs attribute set twice to normalize properties
1531          urlParsingNode.setAttribute('href', href);
1532          href = urlParsingNode.href;
1533        }
1534
1535        urlParsingNode.setAttribute('href', href);
1536
1537        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
1538        return {
1539          href: urlParsingNode.href,
1540          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
1541          host: urlParsingNode.host,
1542          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
1543          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
1544          hostname: urlParsingNode.hostname,
1545          port: urlParsingNode.port,
1546          pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
1547            urlParsingNode.pathname :
1548            '/' + urlParsingNode.pathname
1549        };
1550      }
1551
1552      originURL = resolveURL(window.location.href);
1553
1554      /**
1555    * Determine if a URL shares the same origin as the current location
1556    *
1557    * @param {String} requestURL The URL to test
1558    * @returns {boolean} True if URL shares the same origin, otherwise false
1559    */
1560      return function isURLSameOrigin(requestURL) {
1561        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
1562        return (parsed.protocol === originURL.protocol &&
1563            parsed.host === originURL.host);
1564      };
1565    })() :
1566
1567  // Non standard browser envs (web workers, react-native) lack needed support.
1568    (function nonStandardBrowserEnv() {
1569      return function isURLSameOrigin() {
1570        return true;
1571      };
1572    })()
1573);
1574
1575
1576/***/ }),
1577
1578/***/ 16016:
1579/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1580
1581"use strict";
1582
1583
1584var utils = __webpack_require__(64867);
1585
1586module.exports = function normalizeHeaderName(headers, normalizedName) {
1587  utils.forEach(headers, function processHeader(value, name) {
1588    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
1589      headers[normalizedName] = value;
1590      delete headers[name];
1591    }
1592  });
1593};
1594
1595
1596/***/ }),
1597
1598/***/ 91623:
1599/***/ ((module) => {
1600
1601// eslint-disable-next-line strict
1602module.exports = null;
1603
1604
1605/***/ }),
1606
1607/***/ 84109:
1608/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1609
1610"use strict";
1611
1612
1613var utils = __webpack_require__(64867);
1614
1615// Headers whose duplicates are ignored by node
1616// c.f. https://nodejs.org/api/http.html#http_message_headers
1617var ignoreDuplicateOf = [
1618  'age', 'authorization', 'content-length', 'content-type', 'etag',
1619  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
1620  'last-modified', 'location', 'max-forwards', 'proxy-authorization',
1621  'referer', 'retry-after', 'user-agent'
1622];
1623
1624/**
1625 * Parse headers into an object
1626 *
1627 * ```
1628 * Date: Wed, 27 Aug 2014 08:58:49 GMT
1629 * Content-Type: application/json
1630 * Connection: keep-alive
1631 * Transfer-Encoding: chunked
1632 * ```
1633 *
1634 * @param {String} headers Headers needing to be parsed
1635 * @returns {Object} Headers parsed into an object
1636 */
1637module.exports = function parseHeaders(headers) {
1638  var parsed = {};
1639  var key;
1640  var val;
1641  var i;
1642
1643  if (!headers) { return parsed; }
1644
1645  utils.forEach(headers.split('\n'), function parser(line) {
1646    i = line.indexOf(':');

1647    key = utils.trim(line.substr(0, i)).toLowerCase();
1648    val = utils.trim(line.substr(i + 1));
1649
1650    if (key) {
1651      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
1652        return;
1653      }
1654      if (key === 'set-cookie') {
1655        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
1656      } else {
1657        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
1658      }
1659    }
1660  });
1661
1662  return parsed;
1663};
1664
1665
1666/***/ }),
1667
1668/***/ 90205:
1669/***/ ((module) => {
1670
1671"use strict";
1672
1673
1674module.exports = function parseProtocol(url) {
1675  var match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
1676  return match && match[1] || '';
1677};
1678
1679
1680/***/ }),
1681
1682/***/ 8713:
1683/***/ ((module) => {
1684
1685"use strict";
1686
1687
1688/**
1689 * Syntactic sugar for invoking a function and expanding an array for arguments.
1690 *
1691 * Common use case would be to use `Function.prototype.apply`.
1692 *
1693 *  ```js
1694 *  function f(x, y, z) {}
1695 *  var args = [1, 2, 3];
1696 *  f.apply(null, args);
1697 *  ```
1698 *
1699 * With `spread` this example can be re-written.
1700 *
1701 *  ```js
1702 *  spread(function(x, y, z) {})([1, 2, 3]);
1703 *  ```
1704 *
1705 * @param {Function} callback
1706 * @returns {Function}
1707 */
1708module.exports = function spread(callback) {
1709  return function wrap(arr) {
1710    return callback.apply(null, arr);
1711  };
1712};
1713
1714
1715/***/ }),
1716
1717/***/ 47675:
1718/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1719
1720"use strict";
1721
1722
1723var utils = __webpack_require__(64867);
1724
1725/**
1726 * Convert a data object to FormData
1727 * @param {Object} obj
1728 * @param {?Object} [formData]
1729 * @returns {Object}
1730 **/
1731
1732function toFormData(obj, formData) {
1733  // eslint-disable-next-line no-param-reassign
1734  formData = formData || new FormData();
1735
1736  var stack = [];
1737
1738  function convertValue(value) {
1739    if (value === null) return '';
1740
1741    if (utils.isDate(value)) {
1742      return value.toISOString();
1743    }
1744
1745    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {
1746      return typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);
1747    }
1748
1749    return value;
1750  }
1751
1752  function build(data, parentKey) {
1753    if (utils.isPlainObject(data) || utils.isArray(data)) {
1754      if (stack.indexOf(data) !== -1) {
1755        throw Error('Circular reference detected in ' + parentKey);
1756      }
1757
1758      stack.push(data);
1759
1760      utils.forEach(data, function each(value, key) {
1761        if (utils.isUndefined(value)) return;
1762        var fullKey = parentKey ? parentKey + '.' + key : key;
1763        var arr;
1764
1765        if (value && !parentKey && typeof value === 'object') {
1766          if (utils.endsWith(key, '{}')) {
1767            // eslint-disable-next-line no-param-reassign
1768            value = JSON.stringify(value);
1769          } else if (utils.endsWith(key, '[]') && (arr = utils.toArray(value))) {
1770            // eslint-disable-next-line func-names
1771            arr.forEach(function(el) {
1772              !utils.isUndefined(el) && formData.append(fullKey, convertValue(el));
1773            });
1774            return;
1775          }
1776        }
1777
1778        build(value, fullKey);
1779      });
1780
1781      stack.pop();
1782    } else {
1783      formData.append(parentKey, convertValue(data));
1784    }
1785  }
1786
1787  build(obj);
1788
1789  return formData;
1790}
1791
1792module.exports = toFormData;
1793
1794
1795/***/ }),
1796
1797/***/ 54875:
1798/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1799
1800"use strict";
1801
1802
1803var VERSION = (__webpack_require__(97288).version);
1804var AxiosError = __webpack_require__(82648);
1805
1806var validators = {};
1807
1808// eslint-disable-next-line func-names
1809['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {
1810  validators[type] = function validator(thing) {
1811    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
1812  };
1813});
1814
1815var deprecatedWarnings = {};
1816
1817/**
1818 * Transitional option validator
1819 * @param {function|boolean?} validator - set to false if the transitional option has been removed
1820 * @param {string?} version - deprecated version / removed since version
1821 * @param {string?} message - some message with additional info
1822 * @returns {function}
1823 */
1824validators.transitional = function transitional(validator, version, message) {
1825  function formatMessage(opt, desc) {
1826    return '[Axios v' + VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
1827  }
1828
1829  // eslint-disable-next-line func-names
1830  return function(value, opt, opts) {
1831    if (validator === false) {
1832      throw new AxiosError(
1833        formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')),
1834        AxiosError.ERR_DEPRECATED
1835      );
1836    }
1837
1838    if (version && !deprecatedWarnings[opt]) {
1839      deprecatedWarnings[opt] = true;
1840      // eslint-disable-next-line no-console
1841      console.warn(
1842        formatMessage(
1843          opt,
1844          ' has been deprecated since v' + version + ' and will be removed in the near future'
1845        )
1846      );
1847    }
1848
1849    return validator ? validator(value, opt, opts) : true;
1850  };
1851};
1852
1853/**
1854 * Assert object's properties type
1855 * @param {object} options
1856 * @param {object} schema
1857 * @param {boolean?} allowUnknown
1858 */
1859
1860function assertOptions(options, schema, allowUnknown) {
1861  if (typeof options !== 'object') {
1862    throw new AxiosError('options must be an object', AxiosError.ERR_BAD_OPTION_VALUE);
1863  }
1864  var keys = Object.keys(options);
1865  var i = keys.length;
1866  while (i-- > 0) {
1867    var opt = keys[i];

1868    var validator = schema[opt];
1869    if (validator) {
1870      var value = options[opt];
1871      var result = value === undefined || validator(value, opt, options);
1872      if (result !== true) {
1873        throw new AxiosError('option ' + opt + ' must be ' + result, AxiosError.ERR_BAD_OPTION_VALUE);
1874      }
1875      continue;
1876    }
1877    if (allowUnknown !== true) {
1878      throw new AxiosError('Unknown option ' + opt, AxiosError.ERR_BAD_OPTION);
1879    }
1880  }
1881}
1882
1883module.exports = {
1884  assertOptions: assertOptions,
1885  validators: validators
1886};
1887
1888
1889/***/ }),
1890
1891/***/ 64867:
1892/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1893
1894"use strict";
1895
1896
1897var bind = __webpack_require__(91849);
1898
1899// utils is a library of generic helper functions non-specific to axios
1900
1901var toString = Object.prototype.toString;
1902
1903// eslint-disable-next-line func-names
1904var kindOf = (function(cache) {
1905  // eslint-disable-next-line func-names
1906  return function(thing) {
1907    var str = toString.call(thing);
1908    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
1909  };
1910})(Object.create(null));
1911
1912function kindOfTest(type) {
1913  type = type.toLowerCase();
1914  return function isKindOf(thing) {
1915    return kindOf(thing) === type;
1916  };
1917}
1918
1919/**
1920 * Determine if a value is an Array
1921 *
1922 * @param {Object} val The value to test
1923 * @returns {boolean} True if value is an Array, otherwise false
1924 */
1925function isArray(val) {
1926  return Array.isArray(val);
1927}
1928
1929/**
1930 * Determine if a value is undefined
1931 *
1932 * @param {Object} val The value to test
1933 * @returns {boolean} True if the value is undefined, otherwise false
1934 */
1935function isUndefined(val) {
1936  return typeof val === 'undefined';
1937}
1938
1939/**
1940 * Determine if a value is a Buffer
1941 *
1942 * @param {Object} val The value to test
1943 * @returns {boolean} True if value is a Buffer, otherwise false
1944 */
1945function isBuffer(val) {
1946  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
1947    && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
1948}
1949
1950/**
1951 * Determine if a value is an ArrayBuffer
1952 *
1953 * @function
1954 * @param {Object} val The value to test
1955 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
1956 */
1957var isArrayBuffer = kindOfTest('ArrayBuffer');
1958
1959
1960/**
1961 * Determine if a value is a view on an ArrayBuffer
1962 *
1963 * @param {Object} val The value to test
1964 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
1965 */
1966function isArrayBufferView(val) {
1967  var result;
1968  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
1969    result = ArrayBuffer.isView(val);
1970  } else {
1971    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
1972  }
1973  return result;
1974}
1975
1976/**
1977 * Determine if a value is a String
1978 *
1979 * @param {Object} val The value to test
1980 * @returns {boolean} True if value is a String, otherwise false
1981 */
1982function isString(val) {
1983  return typeof val === 'string';
1984}
1985
1986/**
1987 * Determine if a value is a Number
1988 *
1989 * @param {Object} val The value to test
1990 * @returns {boolean} True if value is a Number, otherwise false
1991 */
1992function isNumber(val) {
1993  return typeof val === 'number';
1994}
1995
1996/**
1997 * Determine if a value is an Object
1998 *
1999 * @param {Object} val The value to test
2000 * @returns {boolean} True if value is an Object, otherwise false
2001 */
2002function isObject(val) {
2003  return val !== null && typeof val === 'object';
2004}
2005
2006/**
2007 * Determine if a value is a plain Object
2008 *
2009 * @param {Object} val The value to test
2010 * @return {boolean} True if value is a plain Object, otherwise false
2011 */
2012function isPlainObject(val) {
2013  if (kindOf(val) !== 'object') {
2014    return false;
2015  }
2016
2017  var prototype = Object.getPrototypeOf(val);
2018  return prototype === null || prototype === Object.prototype;
2019}
2020
2021/**
2022 * Determine if a value is a Date
2023 *
2024 * @function
2025 * @param {Object} val The value to test
2026 * @returns {boolean} True if value is a Date, otherwise false
2027 */
2028var isDate = kindOfTest('Date');
2029
2030/**
2031 * Determine if a value is a File
2032 *
2033 * @function
2034 * @param {Object} val The value to test
2035 * @returns {boolean} True if value is a File, otherwise false
2036 */
2037var isFile = kindOfTest('File');
2038
2039/**
2040 * Determine if a value is a Blob
2041 *
2042 * @function
2043 * @param {Object} val The value to test
2044 * @returns {boolean} True if value is a Blob, otherwise false
2045 */
2046var isBlob = kindOfTest('Blob');
2047
2048/**
2049 * Determine if a value is a FileList
2050 *
2051 * @function
2052 * @param {Object} val The value to test
2053 * @returns {boolean} True if value is a File, otherwise false
2054 */
2055var isFileList = kindOfTest('FileList');
2056
2057/**
2058 * Determine if a value is a Function
2059 *
2060 * @param {Object} val The value to test
2061 * @returns {boolean} True if value is a Function, otherwise false
2062 */
2063function isFunction(val) {
2064  return toString.call(val) === '[object Function]';
2065}
2066
2067/**
2068 * Determine if a value is a Stream
2069 *
2070 * @param {Object} val The value to test
2071 * @returns {boolean} True if value is a Stream, otherwise false
2072 */
2073function isStream(val) {
2074  return isObject(val) && isFunction(val.pipe);
2075}
2076
2077/**
2078 * Determine if a value is a FormData
2079 *
2080 * @param {Object} thing The value to test
2081 * @returns {boolean} True if value is an FormData, otherwise false
2082 */
2083function isFormData(thing) {
2084  var pattern = '[object FormData]';
2085  return thing && (
2086    (typeof FormData === 'function' && thing instanceof FormData) ||
2087    toString.call(thing) === pattern ||
2088    (isFunction(thing.toString) && thing.toString() === pattern)
2089  );
2090}
2091
2092/**
2093 * Determine if a value is a URLSearchParams object
2094 * @function
2095 * @param {Object} val The value to test
2096 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
2097 */
2098var isURLSearchParams = kindOfTest('URLSearchParams');
2099
2100/**
2101 * Trim excess whitespace off the beginning and end of a string
2102 *
2103 * @param {String} str The String to trim
2104 * @returns {String} The String freed of excess whitespace
2105 */
2106function trim(str) {
2107  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
2108}
2109
2110/**
2111 * Determine if we're running in a standard browser environment
2112 *
2113 * This allows axios to run in a web worker, and react-native.
2114 * Both environments support XMLHttpRequest, but not fully standard globals.
2115 *
2116 * web workers:
2117 *  typeof window -> undefined
2118 *  typeof document -> undefined
2119 *
2120 * react-native:
2121 *  navigator.product -> 'ReactNative'
2122 * nativescript
2123 *  navigator.product -> 'NativeScript' or 'NS'
2124 */
2125function isStandardBrowserEnv() {
2126  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
2127                                           navigator.product === 'NativeScript' ||
2128                                           navigator.product === 'NS')) {
2129    return false;
2130  }
2131  return (
2132    typeof window !== 'undefined' &&
2133    typeof document !== 'undefined'
2134  );
2135}
2136
2137/**
2138 * Iterate over an Array or an Object invoking a function for each item.
2139 *
2140 * If `obj` is an Array callback will be called passing
2141 * the value, index, and complete array for each item.
2142 *
2143 * If 'obj' is an Object callback will be called passing
2144 * the value, key, and complete object for each property.
2145 *
2146 * @param {Object|Array} obj The object to iterate
2147 * @param {Function} fn The callback to invoke for each item
2148 */
2149function forEach(obj, fn) {
2150  // Don't bother if no value provided
2151  if (obj === null || typeof obj === 'undefined') {
2152    return;
2153  }
2154
2155  // Force an array if not already something iterable
2156  if (typeof obj !== 'object') {
2157    /*eslint no-param-reassign:0*/
2158    obj = [obj];
2159  }
2160
2161  if (isArray(obj)) {
2162    // Iterate over array values
2163    for (var i = 0, l = obj.length; i < l; i++) {
2164      fn.call(null, obj[i], i, obj);
2165    }
2166  } else {
2167    // Iterate over object keys
2168    for (var key in obj) {
2169      if (Object.prototype.hasOwnProperty.call(obj, key)) {
2170        fn.call(null, obj[key], key, obj);
2171      }
2172    }
2173  }
2174}
2175
2176/**
2177 * Accepts varargs expecting each argument to be an object, then
2178 * immutably merges the properties of each object and returns result.
2179 *
2180 * When multiple objects contain the same key the later object in
2181 * the arguments list will take precedence.
2182 *
2183 * Example:
2184 *
2185 * ```js
2186 * var result = merge({foo: 123}, {foo: 456});
2187 * console.log(result.foo); // outputs 456
2188 * ```
2189 *
2190 * @param {Object} obj1 Object to merge
2191 * @returns {Object} Result of all merge properties
2192 */
2193function merge(/* obj1, obj2, obj3, ... */) {
2194  var result = {};
2195  function assignValue(val, key) {
2196    if (isPlainObject(result[key]) && isPlainObject(val)) {
2197      result[key] = merge(result[key], val);
2198    } else if (isPlainObject(val)) {
2199      result[key] = merge({}, val);
2200    } else if (isArray(val)) {
2201      result[key] = val.slice();
2202    } else {
2203      result[key] = val;
2204    }
2205  }
2206
2207  for (var i = 0, l = arguments.length; i < l; i++) {
2208    forEach(arguments[i], assignValue);
2209  }
2210  return result;
2211}
2212
2213/**
2214 * Extends object a by mutably adding to it the properties of object b.
2215 *
2216 * @param {Object} a The object to be extended
2217 * @param {Object} b The object to copy properties from
2218 * @param {Object} thisArg The object to bind function to
2219 * @return {Object} The resulting value of object a
2220 */
2221function extend(a, b, thisArg) {
2222  forEach(b, function assignValue(val, key) {
2223    if (thisArg && typeof val === 'function') {
2224      a[key] = bind(val, thisArg);
2225    } else {
2226      a[key] = val;
2227    }
2228  });
2229  return a;
2230}
2231
2232/**
2233 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
2234 *
2235 * @param {string} content with BOM
2236 * @return {string} content value without BOM
2237 */
2238function stripBOM(content) {
2239  if (content.charCodeAt(0) === 0xFEFF) {
2240    content = content.slice(1);
2241  }
2242  return content;
2243}
2244

2245/**
2246 * Inherit the prototype methods from one constructor into another
2247 * @param {function} constructor
2248 * @param {function} superConstructor
2249 * @param {object} [props]
2250 * @param {object} [descriptors]
2251 */
2252
2253function inherits(constructor, superConstructor, props, descriptors) {
2254  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
2255  constructor.prototype.constructor = constructor;
2256  props && Object.assign(constructor.prototype, props);
2257}
2258
2259/**
2260 * Resolve object with deep prototype chain to a flat object
2261 * @param {Object} sourceObj source object
2262 * @param {Object} [destObj]
2263 * @param {Function} [filter]
2264 * @returns {Object}
2265 */
2266
2267function toFlatObject(sourceObj, destObj, filter) {
2268  var props;
2269  var i;
2270  var prop;
2271  var merged = {};
2272
2273  destObj = destObj || {};
2274
2275  do {
2276    props = Object.getOwnPropertyNames(sourceObj);
2277    i = props.length;
2278    while (i-- > 0) {
2279      prop = props[i];
2280      if (!merged[prop]) {
2281        destObj[prop] = sourceObj[prop];
2282        merged[prop] = true;
2283      }
2284    }
2285    sourceObj = Object.getPrototypeOf(sourceObj);
2286  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
2287
2288  return destObj;
2289}
2290
2291/*
2292 * determines whether a string ends with the characters of a specified string
2293 * @param {String} str
2294 * @param {String} searchString
2295 * @param {Number} [position= 0]
2296 * @returns {boolean}
2297 */
2298function endsWith(str, searchString, position) {
2299  str = String(str);
2300  if (position === undefined || position > str.length) {
2301    position = str.length;
2302  }
2303  position -= searchString.length;
2304  var lastIndex = str.indexOf(searchString, position);
2305  return lastIndex !== -1 && lastIndex === position;
2306}
2307
2308
2309/**
2310 * Returns new array from array like object
2311 * @param {*} [thing]
2312 * @returns {Array}
2313 */
2314function toArray(thing) {
2315  if (!thing) return null;
2316  var i = thing.length;
2317  if (isUndefined(i)) return null;
2318  var arr = new Array(i);
2319  while (i-- > 0) {
2320    arr[i] = thing[i];
2321  }
2322  return arr;
2323}
2324
2325// eslint-disable-next-line func-names
2326var isTypedArray = (function(TypedArray) {
2327  // eslint-disable-next-line func-names
2328  return function(thing) {
2329    return TypedArray && thing instanceof TypedArray;
2330  };
2331})(typeof Uint8Array !== 'undefined' && Object.getPrototypeOf(Uint8Array));
2332
2333module.exports = {
2334  isArray: isArray,
2335  isArrayBuffer: isArrayBuffer,
2336  isBuffer: isBuffer,
2337  isFormData: isFormData,
2338  isArrayBufferView: isArrayBufferView,
2339  isString: isString,
2340  isNumber: isNumber,
2341  isObject: isObject,
2342  isPlainObject: isPlainObject,
2343  isUndefined: isUndefined,
2344  isDate: isDate,
2345  isFile: isFile,
2346  isBlob: isBlob,
2347  isFunction: isFunction,
2348  isStream: isStream,
2349  isURLSearchParams: isURLSearchParams,
2350  isStandardBrowserEnv: isStandardBrowserEnv,
2351  forEach: forEach,
2352  merge: merge,
2353  extend: extend,
2354  trim: trim,
2355  stripBOM: stripBOM,
2356  inherits: inherits,
2357  toFlatObject: toFlatObject,
2358  kindOf: kindOf,
2359  kindOfTest: kindOfTest,
2360  endsWith: endsWith,
2361  toArray: toArray,
2362  isTypedArray: isTypedArray,
2363  isFileList: isFileList
2364};
2365
2366
2367/***/ }),
2368
2369/***/ 94713:
2370/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
2371
2372"use strict";
2373/* harmony export */ __webpack_require__.d(__webpack_exports__, {
2374/* harmony export */   "N": () => (/* binding */ ReinosMaps)
2375/* harmony export */ });
2376/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(76386);
2377function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
2378
2379function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
2380
2381function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
2382
2383function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
2384
2385
2386var ReinosMaps = /*#__PURE__*/function () {
2387  function ReinosMaps() {
2388    _classCallCheck(this, ReinosMaps);
2389
2390    _defineProperty(this, "author_url", 'https://addons.reinos.nl/maps/');
2391
2392    _defineProperty(this, "def", {
2393      lat: 34.5133,
2394      lng: -94.1629,
2395      circle: {
2396        'fit_circle': true,
2397        'stroke_color': '#BBD8E9',
2398        'stroke_opacity': 1,
2399        'stroke_weight': 3,
2400        'fill_color': '#BBD8E9',
2401        'fill_opacity': 0.6,

2402        'radius': 1000
2403      }
2404    });
2405
2406    _defineProperty(this, "maps", new Map());
2407
2408    _defineProperty(this, "positions", ['topleft', 'topright', 'bottomleft', 'bottomright']);
2409
2410    _defineProperty(this, "_firedEvents", {});
2411
2412    _defineProperty(this, "latlngs", new Set());
2413
2414    _defineProperty(this, "markers", new Map());
2415
2416    _defineProperty(this, "polygons", new Map());
2417
2418    _defineProperty(this, "polylines", new Map());
2419
2420    _defineProperty(this, "rectangles", new Map());
2421
2422    _defineProperty(this, "circles", new Map());
2423
2424    _defineProperty(this, "apiLog", new Set());
2425
2426    _defineProperty(this, "crs", _utils__WEBPACK_IMPORTED_MODULE_0__/* .crsCollection */ .gY);
2427
2428    _defineProperty(this, "_geojson", {
2429      style: {}
2430    });
2431
2432    _defineProperty(this, "leaflet", window.L);
2433  }
2434
2435  _createClass(ReinosMaps, [{
2436    key: "setConfig",
2437    value: function setConfig() {
2438      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
2439      var _options$version = options.version;
2440      this.version = _options$version === void 0 ? '0.0.0' : _options$version;
2441      this.api_path = options.api_path;
2442      this.theme_path = options.theme_path;
2443      var _options$dev_mode = options.dev_mode;
2444      this.isDevMode = _options$dev_mode === void 0 ? false : _options$dev_mode;
2445      this.isDevMode = this.isDevMode === '1' || location.hash === '#maps_debug';
2446    }
2447  }]);
2448
2449  return ReinosMaps;
2450}();
2451
2452/***/ }),
2453
2454/***/ 99161:
2455/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
2456
2457"use strict";
2458/* harmony import */ var _map__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(66534);
2459/* harmony import */ var _marker__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(67174);
2460/* harmony import */ var _circle__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(83623);
2461/* harmony import */ var _rectangle__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(22048);
2462/* harmony import */ var _polygon__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(68354);
2463/* harmony import */ var _polyline__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(28612);
2464/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(57112);
2465/* harmony import */ var _core__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(94713);
2466/* harmony import */ var _map_zoomOut__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(70644);
2467/* harmony import */ var _map_zoomIn__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(20566);
2468/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(76386);
2469function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
2470
2471function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
2472
2473function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
2474
2475function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
2476
2477function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
2478
2479function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
2480
2481function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
2482
2483function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {};

2483 i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
2484
2485function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
2486
2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499_core__WEBPACK_IMPORTED_MODULE_7__/* .ReinosMaps.prototype.api */ .N.prototype.api = function (type, options, callback) {
2500  var self = this; //no type
2501
2502  if (type === '') {
2503    (0,_utils__WEBPACK_IMPORTED_MODULE_8__/* .throwError */ ._y)('Type not defined');
2504    return false;
2505  } //options
2506
2507
2508  options = _objectSpread({
2509    mapID: '',
2510    key: ''
2511  }, options);
2512  Object.entries(options).forEach(function (_ref) {
2513    var _ref2 = _slicedToArray(_ref, 2),
2514        index = _ref2[0],
2515        v = _ref2[1];
2516
2517    if (typeof v === 'string' && v.match('function:')) {
2518      var value = v;
2519
2520      options[index] = function () {
2521        eval(value.replace('function:', ''));
2522      };
2523    }
2524  }); //set the vars
2525
2526  var mapID;
2527  var map; //set a default return value
2528
2529  var __returnValue; //set the mapID
2530
2531
2532  if (options.mapID !== '') {
2533    //set the mapID
2534    mapID = options.mapID; //delete options.mapID;
2535    //get the map
2536
2537    map = self.getMap(mapID);
2538  } //default callback function
2539
2540
2541  var executeCallback = function executeCallback(callback) {
2542    if (typeof callback === 'function') {
2543      callback();
2544    }
2545  }; // log API Call in DEV mode
2546
2547
2548  if (self.isDevMode) {
2549    var stack = new Error();
2550    self.apiLog.add({
2551      method: type,
2552      options: _objectSpread({}, options),
2553      mapId: mapID,
2554      mapExists: !!map,
2555      code: "REINOS.api('".concat(type, "', ").concat(JSON.stringify(_objectSpread({}, options)), ")"),
2556      stack: stack.stack
2557    });
2558  } //what do we do
2559
2560
2561  switch (type) {
2562    //------------------------------------------------------------------------
2563    // Global map api
2564    //------------------------------------------------------------------------
2565    // refresh the map
2566    case 'refresh':
2567    case 'redraw':
2568      (0,_map__WEBPACK_IMPORTED_MODULE_0__/* .apiRefresh */ .Xe)(map);
2569      break;
2570    // set Zoom level
2571
2572    case 'setZoom':
2573      //is there a map
2574      (0,_map__WEBPACK_IMPORTED_MODULE_0__/* .apiSetZoom */ .QP)(map, options);
2575      break;
2576    // ZoomOut
2577
2578    case 'zoomOut':
2579      //is there a map
2580      (0,_map_zoomOut__WEBPACK_IMPORTED_MODULE_9__/* .apiZoomOut */ .J)(map, options);
2581      break;
2582    // ZoomOut
2583
2584    case 'zoomIn':
2585      //is there a map
2586      (0,_map_zoomIn__WEBPACK_IMPORTED_MODULE_10__/* .apiZoomIn */ .q)(map, options);
2587      break;
2588    // set Zoom level
2589
2590    case 'fitMap':
2591      //is there a map
2592      (0,_map__WEBPACK_IMPORTED_MODULE_0__/* .apiFitMap */ .Fg)(map, options);
2593      break;
2594    // Center a map
2595
2596    case 'center':
2597      //is there a map
2598      (0,_map__WEBPACK_IMPORTED_MODULE_0__/* .apiCenter */ .X6)(map, options);
2599      break;
2600    // Get the map object
2601
2602    case 'getMap':
2603      //is there a map
2604      if (map) {
2605        __returnValue = map;
2606      }
2607
2608      break;
2609    // Get the map object
2610
2611    case 'removeMap':
2612      __returnValue = (0,_map__WEBPACK_IMPORTED_MODULE_0__/* .apiRemoveMap */ .qq)(map, options);
2613      break;
2614    // Update a map with new settings
2615
2616    case 'updateMap':
2617      (0,_map__WEBPACK_IMPORTED_MODULE_0__/* .apiUpdateMap */ .C2)(map, options);
2618      break;
2619    //------------------------------------------------------------------------
2620    // End Global map api
2621    //------------------------------------------------------------------------
2622    //------------------------------------------------------------------------
2623    // Marker api
2624    //------------------------------------------------------------------------
2625    // add Marker, and return the marker numbers
2626
2627    case 'addMarker':
2628      //is there a map
2629      __returnValue = (0,_marker__WEBPACK_IMPORTED_MODULE_1__/* .apiAddMarker */ ._A)(map, options, mapID);
2630      break;
2631    // Update a marker
2632
2633    case 'updateMarker':
2634      __returnValue = (0,_marker__WEBPACK_IMPORTED_MODULE_1__/* .apiUpdateMarker */ .EL)(map, options, mapID);
2635      break;
2636    //Get the marker array
2637
2638    case 'getAllMarkers':
2639      __returnValue = self.markers;
2640      break;
2641    //Get the marker array
2642
2643    case 'getMarkers':
2644      __returnValue = self.markers[mapID];
2645      break;
2646    // Get the marker
2647
2648    case 'getMarker':
2649      __returnValue = (0,_marker__WEBPACK_IMPORTED_MODULE_1__/* .apiGetMarker */ ._p)(map, options, mapID);
2650      break;
2651    //remove marker
2652
2653    case 'removeMarker':
2654      (0,_marker__WEBPACK_IMPORTED_MODULE_1__/* .apiRemoveMarker */ .xn)(map, options, mapID);
2655      break;
2656    // hide existing Marker
2657
2658    case 'hideMarker':
2659      (0,_marker__WEBPACK_IMPORTED_MODULE_1__/* .apiHideMarker */ .Xi)(map, options, mapID);
2660      break;
2661    // show existing Marker
2662
2663    case 'showMarker':
2664      (0,_marker__WEBPACK_IMPORTED_MODULE_1__/* .apiShowMarker */ .qW)(map, options, mapID);
2665      break;
2666    // Remove all markers
2667
2668    case 'removeMarkers':
2669      (0,_marker__WEBPACK_IMPORTED_MODULE_1__/* .apiRemoveMarkers */ .pZ)(map, mapID);
2670      break;
2671    // Hide all markers
2672
2673    case 'hideMarkers':
2674      (0,_marker__WEBPACK_IMPORTED_MODULE_1__/* .apiHideMarkers */ .Gx)(ma