https://axis.ausiex.com.au/core/modules/v1/core_assets/js/mura.js?v=7.5.5

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

180      utils.forEach(requestHeaders, function setRequestHeader(val, key) {
181        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {
182          // Remove Content-Type if data is undefined
183          delete requestHeaders[key];
184        } else {
185          // Otherwise add header to the request
186          request.setRequestHeader(key, val);
187        }
188      });
189    }
190
191    // Add withCredentials to request if needed
192    if (!utils.isUndefined(config.withCredentials)) {
193      request.withCredentials = !!config.withCredentials;
194    }
195
196    // Add responseType to request if needed
197    if (responseType && responseType !== 'json') {
198      request.responseType = config.responseType;
199    }
200
201    // Handle progress if needed
202    if (typeof config.onDownloadProgress === 'function') {
203      request.addEventListener('progress', config.onDownloadProgress);
204    }
205
206    // Not all browsers support upload events
207    if (typeof config.onUploadProgress === 'function' && request.upload) {
208      request.upload.addEventListener('progress', config.onUploadProgress);
209    }
210
211    if (config.cancelToken || config.signal) {
212      // Handle cancellation
213      // eslint-disable-next-line func-names
214      onCanceled = function(cancel) {
215        if (!request) {
216          return;
217        }
218        reject(!cancel || (cancel && cancel.type) ? new Cancel('canceled') : cancel);
219        request.abort();
220        request = null;
221      };
222
223      config.cancelToken && config.cancelToken.subscribe(onCanceled);
224      if (config.signal) {
225        config.signal.aborted ? onCanceled() : config.signal.addEventListener('abort', onCanceled);
226      }
227    }
228
229    if (!requestData) {
230      requestData = null;
231    }
232
233    // Send the request
234    request.send(requestData);
235  });
236};
237
238
239/***/ }),
240
241/***/ 1609:
242/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
243
244"use strict";
245
246
247var utils = __webpack_require__(4867);
248var bind = __webpack_require__(1849);
249var Axios = __webpack_require__(321);
250var mergeConfig = __webpack_require__(7185);
251var defaults = __webpack_require__(5655);
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.Cancel = __webpack_require__(5263);
285axios.CancelToken = __webpack_require__(4972);
286axios.isCancel = __webpack_require__(6502);
287axios.VERSION = (__webpack_require__(7288).version);
288
289// Expose all/spread
290axios.all = function all(promises) {
291  return Promise.all(promises);
292};
293axios.spread = __webpack_require__(8713);
294
295// Expose isAxiosError
296axios.isAxiosError = __webpack_require__(6268);
297
298module.exports = axios;
299
300// Allow use of default import syntax in TypeScript
301module.exports["default"] = axios;
302
303
304/***/ }),
305
306/***/ 5263:
307/***/ (function(module) {
308
309"use strict";
310
311
312/**
313 * A `Cancel` is an object that is thrown when an operation is canceled.
314 *
315 * @class
316 * @param {string=} message The message.
317 */
318function Cancel(message) {
319  this.message = message;
320}
321
322Cancel.prototype.toString = function toString() {
323  return 'Cancel' + (this.message ? ': ' + this.message : '');
324};
325
326Cancel.prototype.__CANCEL__ = true;
327
328module.exports = Cancel;
329
330
331/***/ }),
332
333/***/ 4972:
334/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
335
336"use strict";
337
338
339var Cancel = __webpack_require__(5263);
340
341/**
342 * A `CancelToken` is an object that can be used to request cancellation of an operation.
343 *
344 * @class
345 * @param {Function} executor The executor function.
346 */
347function CancelToken(executor) {
348  if (typeof executor !== 'function') {
349    throw new TypeError('executor must be a function.');
350  }
351
352  var resolvePromise;
353
354  this.promise = new Promise(function promiseExecutor(resolve) {
355    resolvePromise = resolve;
356  });
357
358  var token = this;
359
360  // eslint-disable-next-line func-names
361  this.promise.then(function(cancel) {
362    if (!token._listeners) return;
363
364    var i;
365    var l = token._listeners.length;
366
367    for (i = 0; i < l; i++) {
368      token._listeners[i](cancel);
369    }
370    token._listeners = null;
371  });
372
373  // eslint-disable-next-line func-names
374  this.promise.then = function(onfulfilled) {
375    var _resolve;
376    // eslint-disable-next-line func-names
377    var promise = new Promise(function(resolve) {
378      token.subscribe(resolve);
379      _resolve = resolve;
380    }).then(onfulfilled);
381
382    promise.cancel = function reject() {
383      token.unsubscribe(_resolve);
384    };
385
386    return promise;
387  };
388
389  executor(function cancel(message) {
390    if (token.reason) {
391      // Cancellation has already been requested
392      return;
393    }
394
395    token.reason = new Cancel(message);
396    resolvePromise(token.reason);
397  });
398}
399
400/**
401 * Throws a `Cancel` if cancellation has been requested.
402 */
403CancelToken.prototype.throwIfRequested = function throwIfRequested() {
404  if (this.reason) {
405    throw this.reason;
406  }
407};
408
409/**
410 * Subscribe to the cancel signal
411 */
412
413CancelToken.prototype.subscribe = function subscribe(listener) {
414  if (this.reason) {
415    listener(this.reason);
416    return;
417  }
418
419  if (this._listeners) {
420    this._listeners.push(listener);
421  } else {
422    this._listeners = [listener];
423  }
424};
425
426/**
427 * Unsubscribe from the cancel signal
428 */
429
430CancelToken.prototype.unsubscribe = function unsubscribe(listener) {
431  if (!this._listeners) {
432    return;
433  }
434  var index = this._listeners.indexOf(listener);
435  if (index !== -1) {
436    this._listeners.splice(index, 1);
437  }
438};
439
440/**
441 * Returns an object that contains a new `CancelToken` and a function that, when called,
442 * cancels the `CancelToken`.
443 */
444CancelToken.source = function source() {
445  var cancel;
446  var token = new CancelToken(function executor(c) {
447    cancel = c;
448  });
449  return {
450    token: token,
451    cancel: cancel
452  };
453};
454
455module.exports = CancelToken;
456
457
458/***/ }),
459
460/***/ 6502:
461/***/ (function(module) {
462
463"use strict";
464
465
466module.exports = function isCancel(value) {
467  return !!(value && value.__CANCEL__);
468};
469
470
471/***/ }),
472
473/***/ 321:
474/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
475
476"use strict";
477
478
479var utils = __webpack_require__(4867);
480var buildURL = __webpack_require__(5327);
481var InterceptorManager = __webpack_require__(782);
482var dispatchRequest = __webpack_require__(3572);
483var mergeConfig = __webpack_require__(7185);

484var validator = __webpack_require__(4875);
485
486var validators = validator.validators;
487/**
488 * Create a new instance of Axios
489 *
490 * @param {Object} instanceConfig The default config for the instance
491 */
492function Axios(instanceConfig) {
493  this.defaults = instanceConfig;
494  this.interceptors = {
495    request: new InterceptorManager(),
496    response: new InterceptorManager()
497  };
498}
499
500/**
501 * Dispatch a request
502 *
503 * @param {Object} config The config specific for this request (merged with this.defaults)
504 */
505Axios.prototype.request = function request(configOrUrl, config) {
506  /*eslint no-param-reassign:0*/
507  // Allow for axios('example/url'[, config]) a la fetch API
508  if (typeof configOrUrl === 'string') {
509    config = config || {};
510    config.url = configOrUrl;
511  } else {
512    config = configOrUrl || {};
513  }
514
515  config = mergeConfig(this.defaults, config);
516
517  // Set config.method
518  if (config.method) {
519    config.method = config.method.toLowerCase();
520  } else if (this.defaults.method) {
521    config.method = this.defaults.method.toLowerCase();
522  } else {
523    config.method = 'get';
524  }
525
526  var transitional = config.transitional;
527
528  if (transitional !== undefined) {
529    validator.assertOptions(transitional, {
530      silentJSONParsing: validators.transitional(validators.boolean),
531      forcedJSONParsing: validators.transitional(validators.boolean),
532      clarifyTimeoutError: validators.transitional(validators.boolean)
533    }, false);
534  }
535
536  // filter out skipped interceptors
537  var requestInterceptorChain = [];
538  var synchronousRequestInterceptors = true;
539  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
540    if (typeof interceptor.runWhen === 'function' && interceptor.runWhen(config) === false) {
541      return;
542    }
543
544    synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
545
546    requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
547  });
548
549  var responseInterceptorChain = [];
550  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
551    responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
552  });
553
554  var promise;
555
556  if (!synchronousRequestInterceptors) {
557    var chain = [dispatchRequest, undefined];
558
559    Array.prototype.unshift.apply(chain, requestInterceptorChain);
560    chain = chain.concat(responseInterceptorChain);
561
562    promise = Promise.resolve(config);
563    while (chain.length) {
564      promise = promise.then(chain.shift(), chain.shift());
565    }
566
567    return promise;
568  }
569
570
571  var newConfig = config;
572  while (requestInterceptorChain.length) {
573    var onFulfilled = requestInterceptorChain.shift();
574    var onRejected = requestInterceptorChain.shift();
575    try {
576      newConfig = onFulfilled(newConfig);
577    } catch (error) {
578      onRejected(error);
579      break;
580    }
581  }
582
583  try {
584    promise = dispatchRequest(newConfig);
585  } catch (error) {
586    return Promise.reject(error);
587  }
588
589  while (responseInterceptorChain.length) {
590    promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
591  }
592
593  return promise;
594};
595
596Axios.prototype.getUri = function getUri(config) {
597  config = mergeConfig(this.defaults, config);
598  return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, '');
599};
600
601// Provide aliases for supported request methods
602utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {
603  /*eslint func-names:0*/
604  Axios.prototype[method] = function(url, config) {
605    return this.request(mergeConfig(config || {}, {
606      method: method,
607      url: url,
608      data: (config || {}).data
609    }));
610  };
611});
612
613utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
614  /*eslint func-names:0*/
615  Axios.prototype[method] = function(url, data, config) {
616    return this.request(mergeConfig(config || {}, {
617      method: method,
618      url: url,
619      data: data
620    }));
621  };
622});
623
624module.exports = Axios;
625
626
627/***/ }),
628
629/***/ 782:
630/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
631
632"use strict";
633
634
635var utils = __webpack_require__(4867);
636
637function InterceptorManager() {
638  this.handlers = [];
639}
640
641/**
642 * Add a new interceptor to the stack
643 *
644 * @param {Function} fulfilled The function to handle `then` for a `Promise`
645 * @param {Function} rejected The function to handle `reject` for a `Promise`
646 *
647 * @return {Number} An ID used to remove interceptor later
648 */
649InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
650  this.handlers.push({
651    fulfilled: fulfilled,
652    rejected: rejected,
653    synchronous: options ? options.synchronous : false,
654    runWhen: options ? options.runWhen : null
655  });
656  return this.handlers.length - 1;
657};
658
659/**
660 * Remove an interceptor from the stack
661 *
662 * @param {Number} id The ID that was returned by `use`
663 */
664InterceptorManager.prototype.eject = function eject(id) {
665  if (this.handlers[id]) {
666    this.handlers[id] = null;
667  }
668};
669
670/**
671 * Iterate over all the registered interceptors
672 *
673 * This method is particularly useful for skipping over any
674 * interceptors that may have become `null` calling `eject`.
675 *
676 * @param {Function} fn The function to call for each interceptor
677 */
678InterceptorManager.prototype.forEach = function forEach(fn) {

679  utils.forEach(this.handlers, function forEachHandler(h) {
680    if (h !== null) {
681      fn(h);
682    }
683  });
684};
685
686module.exports = InterceptorManager;
687
688
689/***/ }),
690
691/***/ 4097:
692/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
693
694"use strict";
695
696
697var isAbsoluteURL = __webpack_require__(1793);
698var combineURLs = __webpack_require__(7303);
699
700/**
701 * Creates a new URL by combining the baseURL with the requestedURL,
702 * only when the requestedURL is not already an absolute URL.
703 * If the requestURL is absolute, this function returns the requestedURL untouched.
704 *
705 * @param {string} baseURL The base URL
706 * @param {string} requestedURL Absolute or relative URL to combine
707 * @returns {string} The combined full path
708 */
709module.exports = function buildFullPath(baseURL, requestedURL) {
710  if (baseURL && !isAbsoluteURL(requestedURL)) {
711    return combineURLs(baseURL, requestedURL);
712  }
713  return requestedURL;
714};
715
716
717/***/ }),
718
719/***/ 5061:
720/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
721
722"use strict";
723
724
725var enhanceError = __webpack_require__(481);
726
727/**
728 * Create an Error with the specified message, config, error code, request and response.
729 *
730 * @param {string} message The error message.
731 * @param {Object} config The config.
732 * @param {string} [code] The error code (for example, 'ECONNABORTED').
733 * @param {Object} [request] The request.
734 * @param {Object} [response] The response.
735 * @returns {Error} The created error.
736 */
737module.exports = function createError(message, config, code, request, response) {
738  var error = new Error(message);
739  return enhanceError(error, config, code, request, response);
740};
741
742
743/***/ }),
744
745/***/ 3572:
746/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
747
748"use strict";
749
750
751var utils = __webpack_require__(4867);
752var transformData = __webpack_require__(8527);
753var isCancel = __webpack_require__(6502);
754var defaults = __webpack_require__(5655);
755var Cancel = __webpack_require__(5263);
756
757/**
758 * Throws a `Cancel` if cancellation has been requested.
759 */
760function throwIfCancellationRequested(config) {
761  if (config.cancelToken) {
762    config.cancelToken.throwIfRequested();
763  }
764
765  if (config.signal && config.signal.aborted) {
766    throw new Cancel('canceled');
767  }
768}
769
770/**
771 * Dispatch a request to the server using the configured adapter.
772 *
773 * @param {object} config The config that is to be used for the request
774 * @returns {Promise} The Promise to be fulfilled
775 */
776module.exports = function dispatchRequest(config) {
777  throwIfCancellationRequested(config);
778
779  // Ensure headers exist
780  config.headers = config.headers || {};
781
782  // Transform request data
783  config.data = transformData.call(
784    config,
785    config.data,
786    config.headers,
787    config.transformRequest
788  );
789
790  // Flatten headers
791  config.headers = utils.merge(
792    config.headers.common || {},
793    config.headers[config.method] || {},
794    config.headers
795  );
796
797  utils.forEach(
798    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],
799    function cleanHeaderConfig(method) {
800      delete config.headers[method];
801    }
802  );
803
804  var adapter = config.adapter || defaults.adapter;
805
806  return adapter(config).then(function onAdapterResolution(response) {
807    throwIfCancellationRequested(config);
808
809    // Transform response data
810    response.data = transformData.call(
811      config,
812      response.data,
813      response.headers,
814      config.transformResponse
815    );
816
817    return response;
818  }, function onAdapterRejection(reason) {
819    if (!isCancel(reason)) {
820      throwIfCancellationRequested(config);
821
822      // Transform response data
823      if (reason && reason.response) {
824        reason.response.data = transformData.call(
825          config,
826          reason.response.data,
827          reason.response.headers,
828          config.transformResponse
829        );
830      }
831    }
832
833    return Promise.reject(reason);
834  });
835};
836
837
838/***/ }),
839
840/***/ 481:
841/***/ (function(module) {
842
843"use strict";
844
845
846/**
847 * Update an Error with the specified config, error code, and response.
848 *
849 * @param {Error} error The error to update.
850 * @param {Object} config The config.
851 * @param {string} [code] The error code (for example, 'ECONNABORTED').
852 * @param {Object} [request] The request.
853 * @param {Object} [response] The response.
854 * @returns {Error} The error.
855 */
856module.exports = function enhanceError(error, config, code, request, response) {
857  error.config = config;
858  if (code) {
859    error.code = code;
860  }
861
862  error.request = request;
863  error.response = response;
864  error.isAxiosError = true;
865
866  error.toJSON = function toJSON() {
867    return {
868      // Standard
869      message: this.message,
870      name: this.name,
871      // Microsoft
872      description: this.description,
873      number: this.number,
874      // Mozilla
875      fileName: this.fileName,
876      lineNumber: this.lineNumber,
877      columnNumber: this.columnNumber,
878      stack: this.stack,
879      // Axios
880      config: this.config,

881      code: this.code,
882      status: this.response && this.response.status ? this.response.status : null
883    };
884  };
885  return error;
886};
887
888
889/***/ }),
890
891/***/ 7185:
892/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
893
894"use strict";
895
896
897var utils = __webpack_require__(4867);
898
899/**
900 * Config-specific merge-function which creates a new config-object
901 * by merging two configuration objects together.
902 *
903 * @param {Object} config1
904 * @param {Object} config2
905 * @returns {Object} New object resulting from merging config2 to config1
906 */
907module.exports = function mergeConfig(config1, config2) {
908  // eslint-disable-next-line no-param-reassign
909  config2 = config2 || {};
910  var config = {};
911
912  function getMergedValue(target, source) {
913    if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
914      return utils.merge(target, source);
915    } else if (utils.isPlainObject(source)) {
916      return utils.merge({}, source);
917    } else if (utils.isArray(source)) {
918      return source.slice();
919    }
920    return source;
921  }
922
923  // eslint-disable-next-line consistent-return
924  function mergeDeepProperties(prop) {
925    if (!utils.isUndefined(config2[prop])) {
926      return getMergedValue(config1[prop], config2[prop]);
927    } else if (!utils.isUndefined(config1[prop])) {
928      return getMergedValue(undefined, config1[prop]);
929    }
930  }
931
932  // eslint-disable-next-line consistent-return
933  function valueFromConfig2(prop) {
934    if (!utils.isUndefined(config2[prop])) {
935      return getMergedValue(undefined, config2[prop]);
936    }
937  }
938
939  // eslint-disable-next-line consistent-return
940  function defaultToConfig2(prop) {
941    if (!utils.isUndefined(config2[prop])) {
942      return getMergedValue(undefined, config2[prop]);
943    } else if (!utils.isUndefined(config1[prop])) {
944      return getMergedValue(undefined, config1[prop]);
945    }
946  }
947
948  // eslint-disable-next-line consistent-return
949  function mergeDirectKeys(prop) {
950    if (prop in config2) {
951      return getMergedValue(config1[prop], config2[prop]);
952    } else if (prop in config1) {
953      return getMergedValue(undefined, config1[prop]);
954    }
955  }
956
957  var mergeMap = {
958    'url': valueFromConfig2,
959    'method': valueFromConfig2,
960    'data': valueFromConfig2,
961    'baseURL': defaultToConfig2,
962    'transformRequest': defaultToConfig2,
963    'transformResponse': defaultToConfig2,
964    'paramsSerializer': defaultToConfig2,
965    'timeout': defaultToConfig2,
966    'timeoutMessage': defaultToConfig2,
967    'withCredentials': defaultToConfig2,
968    'adapter': defaultToConfig2,
969    'responseType': defaultToConfig2,
970    'xsrfCookieName': defaultToConfig2,
971    'xsrfHeaderName': defaultToConfig2,
972    'onUploadProgress': defaultToConfig2,
973    'onDownloadProgress': defaultToConfig2,
974    'decompress': defaultToConfig2,
975    'maxContentLength': defaultToConfig2,
976    'maxBodyLength': defaultToConfig2,
977    'transport': defaultToConfig2,
978    'httpAgent': defaultToConfig2,
979    'httpsAgent': defaultToConfig2,
980    'cancelToken': defaultToConfig2,
981    'socketPath': defaultToConfig2,
982    'responseEncoding': defaultToConfig2,
983    'validateStatus': mergeDirectKeys
984  };
985
986  utils.forEach(Object.keys(config1).concat(Object.keys(config2)), function computeConfigValue(prop) {
987    var merge = mergeMap[prop] || mergeDeepProperties;
988    var configValue = merge(prop);
989    (utils.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
990  });
991
992  return config;
993};
994
995
996/***/ }),
997
998/***/ 6026:
999/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1000
1001"use strict";
1002
1003
1004var createError = __webpack_require__(5061);
1005
1006/**
1007 * Resolve or reject a Promise based on response status.
1008 *
1009 * @param {Function} resolve A function that resolves the promise.
1010 * @param {Function} reject A function that rejects the promise.
1011 * @param {object} response The response.
1012 */
1013module.exports = function settle(resolve, reject, response) {
1014  var validateStatus = response.config.validateStatus;
1015  if (!response.status || !validateStatus || validateStatus(response.status)) {
1016    resolve(response);
1017  } else {
1018    reject(createError(
1019      'Request failed with status code ' + response.status,
1020      response.config,
1021      null,
1022      response.request,
1023      response
1024    ));
1025  }
1026};
1027
1028
1029/***/ }),
1030
1031/***/ 8527:
1032/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1033
1034"use strict";
1035
1036
1037var utils = __webpack_require__(4867);
1038var defaults = __webpack_require__(5655);
1039
1040/**
1041 * Transform the data for a request or a response
1042 *
1043 * @param {Object|String} data The data to be transformed
1044 * @param {Array} headers The headers for the request or response
1045 * @param {Array|Function} fns A single function or Array of functions
1046 * @returns {*} The resulting transformed data
1047 */
1048module.exports = function transformData(data, headers, fns) {
1049  var context = this || defaults;
1050  /*eslint no-param-reassign:0*/

1051  utils.forEach(fns, function transform(fn) {
1052    data = fn.call(context, data, headers);
1053  });
1054
1055  return data;
1056};
1057
1058
1059/***/ }),
1060
1061/***/ 5655:
1062/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1063
1064"use strict";
1065
1066
1067var utils = __webpack_require__(4867);
1068var normalizeHeaderName = __webpack_require__(6016);
1069var enhanceError = __webpack_require__(481);
1070
1071var DEFAULT_CONTENT_TYPE = {
1072  'Content-Type': 'application/x-www-form-urlencoded'
1073};
1074
1075function setContentTypeIfUnset(headers, value) {
1076  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
1077    headers['Content-Type'] = value;
1078  }
1079}
1080
1081function getDefaultAdapter() {
1082  var adapter;
1083  if (typeof XMLHttpRequest !== 'undefined') {
1084    // For browsers use XHR adapter
1085    adapter = __webpack_require__(5448);
1086  } else if (typeof process !== 'undefined' && Object.prototype.toString.call(process) === '[object process]') {
1087    // For node use HTTP adapter
1088    adapter = __webpack_require__(5448);
1089  }
1090  return adapter;
1091}
1092
1093function stringifySafely(rawValue, parser, encoder) {
1094  if (utils.isString(rawValue)) {
1095    try {
1096      (parser || JSON.parse)(rawValue);
1097      return utils.trim(rawValue);
1098    } catch (e) {
1099      if (e.name !== 'SyntaxError') {
1100        throw e;
1101      }
1102    }
1103  }
1104
1105  return (encoder || JSON.stringify)(rawValue);
1106}
1107
1108var defaults = {
1109
1110  transitional: {
1111    silentJSONParsing: true,
1112    forcedJSONParsing: true,
1113    clarifyTimeoutError: false
1114  },
1115
1116  adapter: getDefaultAdapter(),
1117
1118  transformRequest: [function transformRequest(data, headers) {
1119    normalizeHeaderName(headers, 'Accept');
1120    normalizeHeaderName(headers, 'Content-Type');
1121
1122    if (utils.isFormData(data) ||
1123      utils.isArrayBuffer(data) ||
1124      utils.isBuffer(data) ||
1125      utils.isStream(data) ||
1126      utils.isFile(data) ||
1127      utils.isBlob(data)
1128    ) {
1129      return data;
1130    }
1131    if (utils.isArrayBufferView(data)) {
1132      return data.buffer;
1133    }
1134    if (utils.isURLSearchParams(data)) {
1135      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');
1136      return data.toString();
1137    }
1138    if (utils.isObject(data) || (headers && headers['Content-Type'] === 'application/json')) {
1139      setContentTypeIfUnset(headers, 'application/json');
1140      return stringifySafely(data);
1141    }
1142    return data;
1143  }],
1144
1145  transformResponse: [function transformResponse(data) {
1146    var transitional = this.transitional || defaults.transitional;
1147    var silentJSONParsing = transitional && transitional.silentJSONParsing;
1148    var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
1149    var strictJSONParsing = !silentJSONParsing && this.responseType === 'json';
1150
1151    if (strictJSONParsing || (forcedJSONParsing && utils.isString(data) && data.length)) {
1152      try {
1153        return JSON.parse(data);
1154      } catch (e) {
1155        if (strictJSONParsing) {
1156          if (e.name === 'SyntaxError') {
1157            throw enhanceError(e, this, 'E_JSON_PARSE');
1158          }
1159          throw e;
1160        }
1161      }
1162    }
1163
1164    return data;
1165  }],
1166
1167  /**
1168   * A timeout in milliseconds to abort a request. If set to 0 (default) a
1169   * timeout is not created.
1170   */
1171  timeout: 0,
1172
1173  xsrfCookieName: 'XSRF-TOKEN',
1174  xsrfHeaderName: 'X-XSRF-TOKEN',
1175
1176  maxContentLength: -1,
1177  maxBodyLength: -1,
1178
1179  validateStatus: function validateStatus(status) {
1180    return status >= 200 && status < 300;
1181  },
1182
1183  headers: {
1184    common: {
1185      'Accept': 'application/json, text/plain, */*'
1186    }
1187  }
1188};
1189
1190utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {
1191  defaults.headers[method] = {};
1192});
1193
1194utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
1195  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
1196});
1197
1198module.exports = defaults;
1199
1200
1201/***/ }),
1202
1203/***/ 7288:
1204/***/ (function(module) {
1205
1206module.exports = {
1207  "version": "0.26.0"
1208};
1209
1210/***/ }),
1211
1212/***/ 1849:
1213/***/ (function(module) {
1214
1215"use strict";
1216
1217
1218module.exports = function bind(fn, thisArg) {
1219  return function wrap() {
1220    var args = new Array(arguments.length);
1221    for (var i = 0; i < args.length; i++) {
1222      args[i] = arguments[i];
1223    }
1224    return fn.apply(thisArg, args);
1225  };
1226};
1227
1228
1229/***/ }),
1230
1231/***/ 5327:
1232/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1233
1234"use strict";
1235
1236
1237var utils = __webpack_require__(4867);
1238
1239function encode(val) {
1240  return encodeURIComponent(val).
1241    replace(/%3A/gi, ':').
1242    replace(/%24/g, '$').
1243    replace(/%2C/gi, ',').
1244    replace(/%20/g, '+').
1245    replace(/%5B/gi, '[').
1246    replace(/%5D/gi, ']');
1247}
1248
1249/**

1250 * Build a URL by appending params to the end
1251 *
1252 * @param {string} url The base of the url (e.g., http://www.google.com)
1253 * @param {object} [params] The params to be appended
1254 * @returns {string} The formatted url
1255 */
1256module.exports = function buildURL(url, params, paramsSerializer) {
1257  /*eslint no-param-reassign:0*/
1258  if (!params) {
1259    return url;
1260  }
1261
1262  var serializedParams;
1263  if (paramsSerializer) {
1264    serializedParams = paramsSerializer(params);
1265  } else if (utils.isURLSearchParams(params)) {
1266    serializedParams = params.toString();
1267  } else {
1268    var parts = [];
1269
1270    utils.forEach(params, function serialize(val, key) {
1271      if (val === null || typeof val === 'undefined') {
1272        return;
1273      }
1274
1275      if (utils.isArray(val)) {
1276        key = key + '[]';
1277      } else {
1278        val = [val];
1279      }
1280
1281      utils.forEach(val, function parseValue(v) {
1282        if (utils.isDate(v)) {
1283          v = v.toISOString();
1284        } else if (utils.isObject(v)) {
1285          v = JSON.stringify(v);
1286        }
1287        parts.push(encode(key) + '=' + encode(v));
1288      });
1289    });
1290
1291    serializedParams = parts.join('&');
1292  }
1293
1294  if (serializedParams) {
1295    var hashmarkIndex = url.indexOf('#');
1296    if (hashmarkIndex !== -1) {
1297      url = url.slice(0, hashmarkIndex);
1298    }
1299
1300    url += (url.indexOf('?') === -1 ? '?' : '&') + serializedParams;
1301  }
1302
1303  return url;
1304};
1305
1306
1307/***/ }),
1308
1309/***/ 7303:
1310/***/ (function(module) {
1311
1312"use strict";
1313
1314
1315/**
1316 * Creates a new URL by combining the specified URLs
1317 *
1318 * @param {string} baseURL The base URL
1319 * @param {string} relativeURL The relative URL
1320 * @returns {string} The combined URL
1321 */
1322module.exports = function combineURLs(baseURL, relativeURL) {
1323  return relativeURL
1324    ? baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '')
1325    : baseURL;
1326};
1327
1328
1329/***/ }),
1330
1331/***/ 4372:
1332/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1333
1334"use strict";
1335
1336
1337var utils = __webpack_require__(4867);
1338
1339module.exports = (
1340  utils.isStandardBrowserEnv() ?
1341
1342  // Standard browser envs support document.cookie
1343    (function standardBrowserEnv() {
1344      return {
1345        write: function write(name, value, expires, path, domain, secure) {
1346          var cookie = [];
1347          cookie.push(name + '=' + encodeURIComponent(value));
1348
1349          if (utils.isNumber(expires)) {
1350            cookie.push('expires=' + new Date(expires).toGMTString());
1351          }
1352
1353          if (utils.isString(path)) {
1354            cookie.push('path=' + path);
1355          }
1356
1357          if (utils.isString(domain)) {
1358            cookie.push('domain=' + domain);
1359          }
1360
1361          if (secure === true) {
1362            cookie.push('secure');
1363          }
1364
1365          document.cookie = cookie.join('; ');
1366        },
1367
1368        read: function read(name) {
1369          var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
1370          return (match ? decodeURIComponent(match[3]) : null);
1371        },
1372
1373        remove: function remove(name) {
1374          this.write(name, '', Date.now() - 86400000);
1375        }
1376      };
1377    })() :
1378
1379  // Non standard browser env (web workers, react-native) lack needed support.
1380    (function nonStandardBrowserEnv() {
1381      return {
1382        write: function write() {},
1383        read: function read() { return null; },
1384        remove: function remove() {}
1385      };
1386    })()
1387);
1388
1389
1390/***/ }),
1391
1392/***/ 1793:
1393/***/ (function(module) {
1394
1395"use strict";
1396
1397
1398/**
1399 * Determines whether the specified URL is absolute
1400 *
1401 * @param {string} url The URL to test
1402 * @returns {boolean} True if the specified URL is absolute, otherwise false
1403 */
1404module.exports = function isAbsoluteURL(url) {
1405  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
1406  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
1407  // by any combination of letters, digits, plus, period, or hyphen.
1408  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
1409};
1410
1411
1412/***/ }),
1413
1414/***/ 6268:
1415/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1416
1417"use strict";
1418
1419
1420var utils = __webpack_require__(4867);
1421
1422/**
1423 * Determines whether the payload is an error thrown by Axios
1424 *
1425 * @param {*} payload The value to test
1426 * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
1427 */
1428module.exports = function isAxiosError(payload) {
1429  return utils.isObject(payload) && (payload.isAxiosError === true);
1430};
1431
1432
1433/***/ }),
1434
1435/***/ 7985:
1436/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1437
1438"use strict";
1439
1440
1441var utils = __webpack_require__(4867);
1442
1443module.exports = (
1444  utils.isStandardBrowserEnv() ?
1445
1446  // Standard browser envs have full support of the APIs needed to test
1447  // whether the request URL is of the same origin as current location.
1448    (function standardBrowserEnv() {
1449      var msie = /(msie|trident)/i.test(navigator.userAgent);
1450      var urlParsingNode = document.createElement('a');
1451      var originURL;
1452
1453      /**
1454    * Parse a URL to discover it's components
1455    *
1456    * @param {String} url The URL to be parsed
1457    * @returns {Object}
1458    */
1459      function resolveURL(url) {
1460        var href = url;
1461
1462        if (msie) {
1463        // IE needs attribute set twice to normalize properties
1464          urlParsingNode.setAttribute('href', href);
1465          href = urlParsingNode.href;
1466        }
1467
1468        urlParsingNode.setAttribute('href', href);
1469
1470        // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
1471        return {
1472          href: urlParsingNode.href,
1473          protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
1474          host: urlParsingNode.host,
1475          search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
1476          hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
1477          hostname: urlParsingNode.hostname,
1478          port: urlParsingNode.port,
1479          pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
1480            urlParsingNode.pathname :
1481            '/' + urlParsingNode.pathname
1482        };
1483      }
1484
1485      originURL = resolveURL(window.location.href);
1486
1487      /**
1488    * Determine if a URL shares the same origin as the current location
1489    *
1490    * @param {String} requestURL The URL to test
1491    * @returns {boolean} True if URL shares the same origin, otherwise false
1492    */
1493      return function isURLSameOrigin(requestURL) {
1494        var parsed = (utils.isString(requestURL)) ? resolveURL(requestURL) : requestURL;
1495        return (parsed.protocol === originURL.protocol &&
1496            parsed.host === originURL.host);
1497      };
1498    })() :
1499
1500  // Non standard browser envs (web workers, react-native) lack needed support.
1501    (function nonStandardBrowserEnv() {
1502      return function isURLSameOrigin() {
1503        return true;
1504      };
1505    })()
1506);
1507
1508
1509/***/ }),
1510
1511/***/ 6016:
1512/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1513
1514"use strict";
1515
1516
1517var utils = __webpack_require__(4867);
1518
1519module.exports = function normalizeHeaderName(headers, normalizedName) {
1520  utils.forEach(headers, function processHeader(value, name) {
1521    if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
1522      headers[normalizedName] = value;
1523      delete headers[name];
1524    }
1525  });
1526};
1527
1528
1529/***/ }),
1530
1531/***/ 4109:
1532/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1533
1534"use strict";
1535
1536
1537var utils = __webpack_require__(4867);
1538
1539// Headers whose duplicates are ignored by node
1540// c.f. https://nodejs.org/api/http.html#http_message_headers
1541var ignoreDuplicateOf = [
1542  'age', 'authorization', 'content-length', 'content-type', 'etag',
1543  'expires', 'from', 'host', 'if-modified-since', 'if-unmodified-since',
1544  'last-modified', 'location', 'max-forwards', 'proxy-authorization',
1545  'referer', 'retry-after', 'user-agent'
1546];
1547
1548/**
1549 * Parse headers into an object
1550 *
1551 * ```
1552 * Date: Wed, 27 Aug 2014 08:58:49 GMT
1553 * Content-Type: application/json
1554 * Connection: keep-alive
1555 * Transfer-Encoding: chunked
1556 * ```
1557 *
1558 * @param {String} headers Headers needing to be parsed
1559 * @returns {Object} Headers parsed into an object
1560 */
1561module.exports = function parseHeaders(headers) {
1562  var parsed = {};
1563  var key;
1564  var val;
1565  var i;
1566
1567  if (!headers) { return parsed; }
1568
1569  utils.forEach(headers.split('\n'), function parser(line) {
1570    i = line.indexOf(':');

1571    key = utils.trim(line.substr(0, i)).toLowerCase();
1572    val = utils.trim(line.substr(i + 1));
1573
1574    if (key) {
1575      if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
1576        return;
1577      }
1578      if (key === 'set-cookie') {
1579        parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
1580      } else {
1581        parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;
1582      }
1583    }
1584  });
1585
1586  return parsed;
1587};
1588
1589
1590/***/ }),
1591
1592/***/ 8713:
1593/***/ (function(module) {
1594
1595"use strict";
1596
1597
1598/**
1599 * Syntactic sugar for invoking a function and expanding an array for arguments.
1600 *
1601 * Common use case would be to use `Function.prototype.apply`.
1602 *
1603 *  ```js
1604 *  function f(x, y, z) {}
1605 *  var args = [1, 2, 3];
1606 *  f.apply(null, args);
1607 *  ```
1608 *
1609 * With `spread` this example can be re-written.
1610 *
1611 *  ```js
1612 *  spread(function(x, y, z) {})([1, 2, 3]);
1613 *  ```
1614 *
1615 * @param {Function} callback
1616 * @returns {Function}
1617 */
1618module.exports = function spread(callback) {
1619  return function wrap(arr) {
1620    return callback.apply(null, arr);
1621  };
1622};
1623
1624
1625/***/ }),
1626
1627/***/ 4875:
1628/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1629
1630"use strict";
1631
1632
1633var VERSION = (__webpack_require__(7288).version);
1634
1635var validators = {};
1636
1637// eslint-disable-next-line func-names
1638['object', 'boolean', 'number', 'function', 'string', 'symbol'].forEach(function(type, i) {
1639  validators[type] = function validator(thing) {
1640    return typeof thing === type || 'a' + (i < 1 ? 'n ' : ' ') + type;
1641  };
1642});
1643
1644var deprecatedWarnings = {};
1645
1646/**
1647 * Transitional option validator
1648 * @param {function|boolean?} validator - set to false if the transitional option has been removed
1649 * @param {string?} version - deprecated version / removed since version
1650 * @param {string?} message - some message with additional info
1651 * @returns {function}
1652 */
1653validators.transitional = function transitional(validator, version, message) {
1654  function formatMessage(opt, desc) {
1655    return '[Axios v' + VERSION + '] Transitional option \'' + opt + '\'' + desc + (message ? '. ' + message : '');
1656  }
1657
1658  // eslint-disable-next-line func-names
1659  return function(value, opt, opts) {
1660    if (validator === false) {
1661      throw new Error(formatMessage(opt, ' has been removed' + (version ? ' in ' + version : '')));
1662    }
1663
1664    if (version && !deprecatedWarnings[opt]) {
1665      deprecatedWarnings[opt] = true;
1666      // eslint-disable-next-line no-console
1667      console.warn(
1668        formatMessage(
1669          opt,
1670          ' has been deprecated since v' + version + ' and will be removed in the near future'
1671        )
1672      );
1673    }
1674
1675    return validator ? validator(value, opt, opts) : true;
1676  };
1677};
1678
1679/**
1680 * Assert object's properties type
1681 * @param {object} options
1682 * @param {object} schema
1683 * @param {boolean?} allowUnknown
1684 */
1685
1686function assertOptions(options, schema, allowUnknown) {
1687  if (typeof options !== 'object') {
1688    throw new TypeError('options must be an object');
1689  }
1690  var keys = Object.keys(options);
1691  var i = keys.length;
1692  while (i-- > 0) {
1693    var opt = keys[i];
1694    var validator = schema[opt];
1695    if (validator) {
1696      var value = options[opt];
1697      var result = value === undefined || validator(value, opt, options);
1698      if (result !== true) {
1699        throw new TypeError('option ' + opt + ' must be ' + result);
1700      }
1701      continue;
1702    }
1703    if (allowUnknown !== true) {
1704      throw Error('Unknown option ' + opt);
1705    }
1706  }
1707}
1708
1709module.exports = {
1710  assertOptions: assertOptions,
1711  validators: validators
1712};
1713
1714
1715/***/ }),
1716
1717/***/ 4867:
1718/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
1719
1720"use strict";
1721
1722
1723var bind = __webpack_require__(1849);
1724
1725// utils is a library of generic helper functions non-specific to axios
1726
1727var toString = Object.prototype.toString;
1728
1729/**
1730 * Determine if a value is an Array
1731 *
1732 * @param {Object} val The value to test
1733 * @returns {boolean} True if value is an Array, otherwise false
1734 */
1735function isArray(val) {
1736  return Array.isArray(val);
1737}
1738
1739/**
1740 * Determine if a value is undefined
1741 *
1742 * @param {Object} val The value to test
1743 * @returns {boolean} True if the value is undefined, otherwise false
1744 */
1745function isUndefined(val) {
1746  return typeof val === 'undefined';
1747}
1748
1749/**
1750 * Determine if a value is a Buffer
1751 *
1752 * @param {Object} val The value to test
1753 * @returns {boolean} True if value is a Buffer, otherwise false
1754 */
1755function isBuffer(val) {
1756  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
1757    && typeof val.constructor.isBuffer === 'function' && val.constructor.isBuffer(val);
1758}
1759
1760/**
1761 * Determine if a value is an ArrayBuffer
1762 *
1763 * @param {Object} val The value to test
1764 * @returns {boolean} True if value is an ArrayBuffer, otherwise false
1765 */
1766function isArrayBuffer(val) {
1767  return toString.call(val) === '[object ArrayBuffer]';
1768}
1769
1770/**
1771 * Determine if a value is a FormData
1772 *
1773 * @param {Object} val The value to test
1774 * @returns {boolean} True if value is an FormData, otherwise false
1775 */
1776function isFormData(val) {
1777  return toString.call(val) === '[object FormData]';
1778}
1779

1780/**
1781 * Determine if a value is a view on an ArrayBuffer
1782 *
1783 * @param {Object} val The value to test
1784 * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false
1785 */
1786function isArrayBufferView(val) {
1787  var result;
1788  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {
1789    result = ArrayBuffer.isView(val);
1790  } else {
1791    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));
1792  }
1793  return result;
1794}
1795
1796/**
1797 * Determine if a value is a String
1798 *
1799 * @param {Object} val The value to test
1800 * @returns {boolean} True if value is a String, otherwise false
1801 */
1802function isString(val) {
1803  return typeof val === 'string';
1804}
1805
1806/**
1807 * Determine if a value is a Number
1808 *
1809 * @param {Object} val The value to test
1810 * @returns {boolean} True if value is a Number, otherwise false
1811 */
1812function isNumber(val) {
1813  return typeof val === 'number';
1814}
1815
1816/**
1817 * Determine if a value is an Object
1818 *
1819 * @param {Object} val The value to test
1820 * @returns {boolean} True if value is an Object, otherwise false
1821 */
1822function isObject(val) {
1823  return val !== null && typeof val === 'object';
1824}
1825
1826/**
1827 * Determine if a value is a plain Object
1828 *
1829 * @param {Object} val The value to test
1830 * @return {boolean} True if value is a plain Object, otherwise false
1831 */
1832function isPlainObject(val) {
1833  if (toString.call(val) !== '[object Object]') {
1834    return false;
1835  }
1836
1837  var prototype = Object.getPrototypeOf(val);
1838  return prototype === null || prototype === Object.prototype;
1839}
1840
1841/**
1842 * Determine if a value is a Date
1843 *
1844 * @param {Object} val The value to test
1845 * @returns {boolean} True if value is a Date, otherwise false
1846 */
1847function isDate(val) {
1848  return toString.call(val) === '[object Date]';
1849}
1850
1851/**
1852 * Determine if a value is a File
1853 *
1854 * @param {Object} val The value to test
1855 * @returns {boolean} True if value is a File, otherwise false
1856 */
1857function isFile(val) {
1858  return toString.call(val) === '[object File]';
1859}
1860
1861/**
1862 * Determine if a value is a Blob
1863 *
1864 * @param {Object} val The value to test
1865 * @returns {boolean} True if value is a Blob, otherwise false
1866 */
1867function isBlob(val) {
1868  return toString.call(val) === '[object Blob]';
1869}
1870
1871/**
1872 * Determine if a value is a Function
1873 *
1874 * @param {Object} val The value to test
1875 * @returns {boolean} True if value is a Function, otherwise false
1876 */
1877function isFunction(val) {
1878  return toString.call(val) === '[object Function]';
1879}
1880
1881/**
1882 * Determine if a value is a Stream
1883 *
1884 * @param {Object} val The value to test
1885 * @returns {boolean} True if value is a Stream, otherwise false
1886 */
1887function isStream(val) {
1888  return isObject(val) && isFunction(val.pipe);
1889}
1890
1891/**
1892 * Determine if a value is a URLSearchParams object
1893 *
1894 * @param {Object} val The value to test
1895 * @returns {boolean} True if value is a URLSearchParams object, otherwise false
1896 */
1897function isURLSearchParams(val) {
1898  return toString.call(val) === '[object URLSearchParams]';
1899}
1900
1901/**
1902 * Trim excess whitespace off the beginning and end of a string
1903 *
1904 * @param {String} str The String to trim
1905 * @returns {String} The String freed of excess whitespace
1906 */
1907function trim(str) {
1908  return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, '');
1909}
1910
1911/**
1912 * Determine if we're running in a standard browser environment
1913 *
1914 * This allows axios to run in a web worker, and react-native.
1915 * Both environments support XMLHttpRequest, but not fully standard globals.
1916 *
1917 * web workers:
1918 *  typeof window -> undefined
1919 *  typeof document -> undefined
1920 *
1921 * react-native:
1922 *  navigator.product -> 'ReactNative'
1923 * nativescript
1924 *  navigator.product -> 'NativeScript' or 'NS'
1925 */
1926function isStandardBrowserEnv() {
1927  if (typeof navigator !== 'undefined' && (navigator.product === 'ReactNative' ||
1928                                           navigator.product === 'NativeScript' ||
1929                                           navigator.product === 'NS')) {
1930    return false;
1931  }
1932  return (
1933    typeof window !== 'undefined' &&
1934    typeof document !== 'undefined'
1935  );
1936}
1937
1938/**
1939 * Iterate over an Array or an Object invoking a function for each item.
1940 *
1941 * If `obj` is an Array callback will be called passing
1942 * the value, index, and complete array for each item.
1943 *
1944 * If 'obj' is an Object callback will be called passing
1945 * the value, key, and complete object for each property.
1946 *
1947 * @param {Object|Array} obj The object to iterate
1948 * @param {Function} fn The callback to invoke for each item
1949 */
1950function forEach(obj, fn) {
1951  // Don't bother if no value provided
1952  if (obj === null || typeof obj === 'undefined') {
1953    return;
1954  }
1955
1956  // Force an array if not already something iterable
1957  if (typeof obj !== 'object') {
1958    /*eslint no-param-reassign:0*/
1959    obj = [obj];
1960  }
1961
1962  if (isArray(obj)) {
1963    // Iterate over array values
1964    for (var i = 0, l = obj.length; i < l; i++) {
1965      fn.call(null, obj[i], i, obj);
1966    }
1967  } else {
1968    // Iterate over object keys
1969    for (var key in obj) {
1970      if (Object.prototype.hasOwnProperty.call(obj, key)) {
1971        fn.call(null, obj[key], key, obj);
1972      }
1973    }
1974  }
1975}
1976
1977/**
1978 * Accepts varargs expecting each argument to be an object, then
1979 * immutably merges the properties of each object and returns result.
1980 *
1981 * When multiple objects contain the same key the later object in
1982 * the arguments list will take precedence.
1983 *
1984 * Example:
1985 *
1986 * ```js
1987 * var result = merge({foo: 123}, {foo: 456});
1988 * console.log(result.foo); // outputs 456
1989 * ```
1990 *
1991 * @param {Object} obj1 Object to merge
1992 * @returns {Object} Result of all merge properties
1993 */
1994function merge(/* obj1, obj2, obj3, ... */) {
1995  var result = {};
1996  function assignValue(val, key) {
1997    if (isPlainObject(result[key]) && isPlainObject(val)) {
1998      result[key] = merge(result[key], val);
1999    } else if (isPlainObject(val)) {
2000      result[key] = merge({}, val);
2001    } else if (isArray(val)) {
2002      result[key] = val.slice();
2003    } else {
2004      result[key] = val;
2005    }
2006  }
2007
2008  for (var i = 0, l = arguments.length; i < l; i++) {

2009    forEach(arguments[i], assignValue);
2010  }
2011  return result;
2012}
2013
2014/**
2015 * Extends object a by mutably adding to it the properties of object b.
2016 *
2017 * @param {Object} a The object to be extended
2018 * @param {Object} b The object to copy properties from
2019 * @param {Object} thisArg The object to bind function to
2020 * @return {Object} The resulting value of object a
2021 */
2022function extend(a, b, thisArg) {
2023  forEach(b, function assignValue(val, key) {
2024    if (thisArg && typeof val === 'function') {
2025      a[key] = bind(val, thisArg);
2026    } else {
2027      a[key] = val;
2028    }
2029  });
2030  return a;
2031}
2032
2033/**
2034 * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
2035 *
2036 * @param {string} content with BOM
2037 * @return {string} content value without BOM
2038 */
2039function stripBOM(content) {
2040  if (content.charCodeAt(0) === 0xFEFF) {
2041    content = content.slice(1);
2042  }
2043  return content;
2044}
2045
2046module.exports = {
2047  isArray: isArray,
2048  isArrayBuffer: isArrayBuffer,
2049  isBuffer: isBuffer,
2050  isFormData: isFormData,
2051  isArrayBufferView: isArrayBufferView,
2052  isString: isString,
2053  isNumber: isNumber,
2054  isObject: isObject,
2055  isPlainObject: isPlainObject,
2056  isUndefined: isUndefined,
2057  isDate: isDate,
2058  isFile: isFile,
2059  isBlob: isBlob,
2060  isFunction: isFunction,
2061  isStream: isStream,
2062  isURLSearchParams: isURLSearchParams,
2063  isStandardBrowserEnv: isStandardBrowserEnv,
2064  forEach: forEach,
2065  merge: merge,
2066  extend: extend,
2067  trim: trim,
2068  stripBOM: stripBOM
2069};
2070
2071
2072/***/ }),
2073
2074/***/ 2147:
2075/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
2076
2077var Mura = __webpack_require__(791);
2078/**
2079 * Creates a new Mura.Cache
2080 * @name Mura.Cache
2081 * @class
2082 * @extends Mura.Core
2083 * @memberof	Mura
2084 * @return {Mura.Cache}
2085 */
2086
2087
2088Mura.Cache = Mura.Core.extend(
2089/** @lends Mura.Cache.prototype */
2090{
2091  init: function init() {
2092    this.cache = {};
2093    return this;
2094  },
2095
2096  /**
2097   * getKey - Returns Key value associated with key Name
2098   *
2099   * @param	{string} keyName Key Name
2100   * @return {*}				 Key Value
2101   */
2102  getKey: function getKey(keyName) {
2103    return Mura.hashCode(keyName);
2104  },
2105
2106  /**
2107   * get - Returns the value associated with key name
2108   *
2109   * @param	{string} keyName	description
2110   * @param	{*} keyValue Default Value
2111   * @return {*}
2112   */
2113  get: function get(keyName, keyValue) {
2114    var key = this.getKey(keyName);
2115
2116    if (typeof this.cache[key] != 'undefined') {
2117      return this.cache[key].keyValue;
2118    } else if (typeof keyValue != 'undefined') {
2119      this.set(keyName, keyValue, key);
2120      return this.cache[key].keyValue;
2121    } else {
2122      return;
2123    }
2124  },
2125
2126  /**
2127   * set - Sets and returns key value
2128   *
2129   * @param	{string} keyName	Key Name
2130   * @param	{*} keyValue Key Value
2131   * @param	{string} key			Key
2132   * @return {*}
2133   */
2134  set: function set(keyName, keyValue, key) {
2135    key = key || this.getKey(keyName);
2136    this.cache[key] = {
2137      name: keyName,
2138      value: keyValue
2139    };
2140    return keyValue;
2141  },
2142
2143  /**
2144   * has - Returns if the key name has a value in the cache
2145   *
2146   * @param	{string} keyName Key Name
2147   * @return {boolean}
2148   */
2149  has: function has(keyName) {
2150    return typeof this.cache[getKey(keyName)] != 'undefined';
2151  },
2152
2153  /**
2154   * getAll - Returns object containing all key and key values
2155   *
2156   * @return {object}
2157   */
2158  getAll: function getAll() {
2159    return this.cache;
2160  },
2161
2162  /**
2163   * purgeAll - Purges all key/value pairs from cache
2164   *
2165   * @return {object}	Self
2166   */
2167  purgeAll: function purgeAll() {
2168    this.cache = {};
2169    return this;
2170  },
2171
2172  /**
2173   * purge - Purges specific key name from cache
2174   *
2175   * @param	{string} keyName Key Name
2176   * @return {object}				 Self
2177   */
2178  purge: function purge(keyName) {
2179    var key = this.getKey(keyName);
2180    if (typeof this.cache[key] != 'undefined') delete this.cache[key];
2181    return this;
2182  }
2183});
2184Mura.datacache = new Mura.Cache();
2185
2186/***/ }),
2187
2188/***/ 4506:
2189/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
2190
2191function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
2192
2193var Mura = __webpack_require__(791);
2194/**
2195* Creates a new Mura.entities.Content
2196* @name Mura.entities.Content
2197* @class
2198* @extends Mura.Entity
2199* @memberof Mura
2200* @param	{object} properties Object containing values to set into object
2201* @return {Mura.entities.Content}
2202*/
2203
2204
2205Mura.entities.Content = Mura.Entity.extend(
2206/** @lends Mura.entities.Content.prototype */
2207{
2208  /**
2209   * hasParent - Returns true if content has a parent.
2210   *
2211   * @return {boolean}
2212   */
2213  hasParent: function hasParent() {
2214    var parentid = this.get('parentid');
2215    return !(!parentid || ['00000000000000000000000000000000END', '00000000000000000000000000000000003', '00000000000000000000000000000000004', '00000000000000000000000000000000099'].find(function (value) {
2216      return value === parentid;
2217    }));
2218  },
2219
2220  /**

2221   * updateFromDom - Updates editable data from what's in the DOM.
2222   *
2223   * @return {string}
2224   */
2225  updateFromDom: function updateFromDom() {
2226    var regions = this.get('displayregions');
2227
2228    if (regions && _typeof(regions) === 'object') {
2229      Object.keys(regions).forEach(function (key) {
2230        var region = regions[key];
2231
2232        if (region) {
2233          var items = [];
2234          Mura('.mura-region-local[data-regionid="' + region.regionid + '"]').forEach(function () {
2235            Mura(this).children('.mura-object[data-object]').forEach(function () {
2236              var obj = Mura(this);
2237
2238              if (typeof Mura.displayObjectInstances[obj.data('instanceid')] != 'undefined') {
2239                Mura.displayObjectInstances[obj.data('instanceid')].reset(obj, false);
2240              }
2241
2242              items.push(Mura.cleanModuleProps(obj.data()));
2243            });
2244          });
2245          region.local.items = items;
2246        }
2247      });
2248    }
2249
2250    var self = this;
2251    Mura('div.mura-object[data-targetattr]').each(function () {
2252      var obj = Mura(this);
2253
2254      if (typeof Mura.displayObjectInstances[obj.data('instanceid')] != 'undefined') {
2255        Mura.displayObjectInstances[obj.data('instanceid')].reset(obj, false);
2256      }
2257
2258      self.set(obj.data('targetattr'), Mura.cleanModuleProps(Mura(this).data()));
2259    });
2260    Mura('.mura-editable-attribute.inline').forEach(function () {
2261      var editable = Mura(this);
2262      var attributeName = editable.data('attribute');
2263      self.set(attributeName, editable.html());
2264    });
2265    return this;
2266  },
2267
2268  /**
2269   * renderDisplayRegion - Returns a string with display region markup.
2270   *
2271   * @return {string}
2272   */
2273  renderDisplayRegion: function renderDisplayRegion(region) {
2274    return Mura.buildDisplayRegion(this.get('displayregions')[region]);
2275  },
2276
2277  /**
2278   * dspRegion - Appends a display region to a element.
2279   *
2280   * @return {self}
2281   */
2282  dspRegion: function dspRegion(selector, region, label) {
2283    if (Mura.isNumeric(region) && region <= this.get('displayregionnames').length) {
2284      region = this.get('displayregionnames')[region - 1];
2285    }
2286
2287    Mura(selector).processDisplayRegion(this.get('displayregions')[region], label);
2288    return this;
2289  },
2290
2291  /**
2292   * getRelatedContent - Gets related content sets by name
2293   *
2294   * @param	{string} relatedContentSetName
2295   * @param	{object} params
2296   * @return {Mura.EntityCollection}
2297   */
2298  getRelatedContent: function getRelatedContent(relatedContentSetName, params) {
2299    var self = this;
2300    relatedContentSetName = relatedContentSetName || '';
2301    return new Promise(function (resolve, reject) {
2302      var query = [];
2303      params = params || {};
2304      params.siteid = self.get('siteid') || Mura.siteid;
2305
2306      if (self.has('contenthistid') && self.get('contenthistid')) {
2307        params.contenthistid = self.get('contenthistid');
2308      }
2309
2310      for (var key in params) {
2311        if (key != 'entityname' && key != 'filename' && key != 'siteid' && key != 'method') {
2312          query.push(encodeURIComponent(key) + '=' + encodeURIComponent(params[key]));
2313        }
2314      }
2315
2316      self._requestcontext.request({
2317        type: 'get',
2318        url: self._requestcontext.getAPIEndpoint() + '/content/' + self.get('contentid') + '/relatedcontent/' + relatedContentSetName + '?' + query.join('&'),
2319        params: params,
2320        success: function success(resp) {
2321          if (typeof resp.data.items != 'undefined') {
2322            var returnObj = new Mura.EntityCollection(resp.data, self._requestcontext);
2323          } else {
2324            var returnObj = new Mura.Entity({
2325              siteid: Mura.siteid
2326            }, self._requestcontext);
2327
2328            for (var p in resp.data) {
2329              if (resp.data.hasOwnProperty(p)) {
2330                returnObj.set(p, new Mura.EntityCollection(resp.data[p], self._requestcontext));
2331              }
2332            }
2333          }
2334
2335          if (typeof resolve == 'function') {
2336            resolve(returnObj);
2337          }
2338        },
2339        error: reject
2340      });
2341    });
2342  }
2343});
2344
2345/***/ }),
2346
2347/***/ 791:
2348/***/ (function(module) {
2349
2350"use strict";

2351//require("babel-polyfill");
2352//require("./polyfill");
2353
2354/**
2355 * login - Logs user into Mura
2356 *
2357 * @param	{string} username Username
2358 * @param	{string} password Password
2359 * @param	{string} siteid	 Siteid
2360 * @return {Promise}
2361 * @memberof {class} Mura
2362 */
2363
2364function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
2365
2366function login(username, password, siteid) {
2367  return Mura.getRequestContext().login(username, password, siteid);
2368}
2369/**
2370 * logout - Logs user out
2371 *
2372 * @param	{type} siteid Siteid
2373 * @return {Promise}
2374 * @memberof {class} Mura
2375 */
2376
2377
2378function logout(siteid) {
2379  return Mura.getRequestContext().logout(siteid);
2380}
2381/**
2382 * trackEvent - This is for Mura Experience Platform. It has no use with Mura standard
2383 *
2384 * @param	{object} data event data
2385 * @return {Promise}
2386 * @memberof {class} Mura
2387 */
2388
2389
2390function trackEvent(eventData) {
2391  if (typeof Mura.editing != 'undefined' && Mura.editing) {
2392    return new Promise(function (resolve, reject) {
2393      resolve = resolve || function () {};
2394
2395      resolve();
2396    });
2397  }
2398
2399  var data = {};
2400  var isMXP = typeof Mura.MXP != 'undefined';
2401  var trackingVars = {
2402    ga: {
2403      trackingvars: {}
2404    }
2405  };
2406  var gaFound = false;
2407  var gtagFound = false;
2408  var trackingComplete = false;
2409  var attempt = 0;
2410  data.category = eventData.event_category || eventData.eventCategory || eventData.category || '';
2411  data.action = eventData.event_action || eventData.eventAction || eventData.action || '';
2412  data.label = eventData.event_label || eventData.eventLabel || eventData.label || '';
2413  data.type = eventData.hit_ype || eventData.hitType || eventData.type || 'event';
2414  data.value = eventData.event_value || eventData.eventValue || eventData.value || undefined;
2415
2416  if (typeof eventData.nonInteraction == 'undefined') {
2417    data.nonInteraction = false;
2418  } else {
2419    data.nonInteraction = eventData.nonInteraction;
2420  }
2421
2422  data.contentid = eventData.contentid || Mura.contentid;
2423  data.objectid = eventData.objectid || '';
2424
2425  function track() {
2426    if (!attempt) {
2427      trackingVars.ga.trackingvars.eventCategory = data.category;
2428      trackingVars.ga.trackingvars.eventAction = data.action;
2429      trackingVars.ga.trackingvars.nonInteraction = data.nonInteraction;
2430      trackingVars.ga.trackingvars.hitType = data.type;
2431
2432      if (typeof data.value != 'undefined' && Mura.isNumeric(data.value)) {
2433        trackingVars.ga.trackingvars.eventValue = data.value;
2434      }
2435
2436      if (data.label) {
2437        trackingVars.ga.trackingvars.eventLabel = data.label;
2438      } else if (isMXP) {
2439        if (typeof trackingVars.object != 'undefined') {
2440          trackingVars.ga.trackingvars.eventLabel = trackingVars.object.title;
2441        } else {
2442          trackingVars.ga.trackingvars.eventLabel = trackingVars.content.title;
2443        }
2444
2445        data.label = trackingVars.object.title;
2446      }
2447
2448      Mura(document).trigger('muraTrackEvent', trackingVars);
2449      Mura(document).trigger('muraRecordEvent', trackingVars);
2450    }
2451
2452    if (typeof gtag != 'undefined') {
2453      trackingVars.ga.trackingvars.event_category = trackingVars.ga.trackingvars.eventCategory;
2454      trackingVars.ga.trackingvars.event_action = trackingVars.ga.trackingvars.eventAction;
2455      trackingVars.ga.trackingvars.non_interaction = trackingVars.ga.trackingvars.nonInteraction;
2456      trackingVars.ga.trackingvars.hit_type = trackingVars.ga.trackingvars.hitType;
2457      trackingVars.ga.trackingvars.event_value = trackingVars.ga.trackingvars.eventValue;
2458      trackingVars.ga.trackingvars.event_label = trackingVars.ga.trackingvars.eventLabel;
2459      delete trackingVars.ga.trackingvars.eventCategory;
2460      delete trackingVars.ga.trackingvars.eventAction;
2461      delete trackingVars.ga.trackingvars.nonInteraction;
2462      delete trackingVars.ga.trackingvars.hitType;
2463      delete trackingVars.ga.trackingvars.eventValue;
2464      delete trackingVars.ga.trackingvars.eventLabel;
2465
2466      if (isMXP) {

2467        trackingVars.ga.trackingvars.send_to = Mura.trackingVars.ga.trackingid;
2468      }
2469
2470      gtag('event', data.type, trackingVars.ga.trackingvars);
2471      gaFound = true;
2472      trackingComplete = true;
2473    } else if (typeof ga != 'undefined') {
2474      if (isMXP) {
2475        ga('mxpGATracker.send', data.type, trackingVars.ga.trackingvars);
2476      } else {
2477        ga('send', data.type, trackingVars.ga.trackingvars);
2478      }
2479
2480      gaFound = true;
2481      trackingComplete = true;
2482    }
2483
2484    attempt++;
2485
2486    if (!gaFound && attempt < 250) {
2487      setTimeout(track, 1);
2488    } else {
2489      trackingComplete = true;
2490    }
2491  }
2492
2493  if (isMXP) {
2494    var trackingID = data.contentid + data.objectid;
2495
2496    if (typeof Mura.trackingMetadata[trackingID] != 'undefined') {
2497      Mura.deepExtend(trackingVars, Mura.trackingMetadata[trackingID]);
2498      trackingVars.eventData = data;
2499      track();
2500    } else {
2501      Mura.get(Mura.getAPIEndpoint(), {
2502        method: 'findTrackingProps',
2503        siteid: Mura.siteid,
2504        contentid: data.contentid,
2505        objectid: data.objectid
2506      }).then(function (response) {
2507        Mura.deepExtend(trackingVars, response.data);
2508        trackingVars.eventData = data;
2509
2510        for (var p in trackingVars.ga.trackingprops) {
2511          if (trackingVars.ga.trackingprops.hasOwnProperty(p) && p.substring(0, 1) == 'd' && typeof trackingVars.ga.trackingprops[p] != 'string') {
2512            trackingVars.ga.trackingprops[p] = new String(trackingVars.ga[p]);
2513          }
2514        }
2515
2516        Mura.trackingMetadata[trackingID] = {};
2517        Mura.deepExtend(Mura.trackingMetadata[trackingID], response.data);
2518        track();
2519      });
2520    }
2521  } else {
2522    track();
2523  }
2524
2525  return new Promise(function (resolve, reject) {
2526    resolve = resolve || function () {};
2527
2528    function checkComplete() {
2529      if (trackingComplete) {
2530        resolve();
2531      } else {
2532        setTimeout(checkComplete, 1);
2533      }
2534    }
2535
2536    checkComplete();
2537  });
2538}
2539/**
2540* renderFilename - Returns "Rendered" JSON object of content
2541*
2542* @param	{type} filename Mura content filename
2543* @param	{type} params Object
2544* @return {Promise}
2545* @memberof {class} Mura
2546*/
2547
2548
2549function renderFilename(filename, params) {
2550  return Mura.getRequestContext().renderFilename(filename, params);
2551}
2552/**
2553 * declareEntity - Declare Entity with in service factory
2554 *
2555 * @param	{object} entityConfig Entity config object
2556 * @return {Promise}
2557 * @memberof {class} Mura
2558 */
2559
2560
2561function declareEntity(entityConfig) {
2562  return Mura.getRequestContext().declareEntity(entityConfig);
2563}
2564/**
2565 * undeclareEntity - Deletes entity class from Mura
2566 *
2567 * @param	{object} entityName
2568 * @return {Promise}
2569 * @memberof {class} Mura
2570 */
2571
2572
2573function undeclareEntity(entityName, deleteSchema) {
2574  deleteSchema = deleteSchema || false;
2575  return Mura.getRequestContext().undeclareEntity(entityName, deleteSchema);
2576}
2577/**
2578 * openGate - Open's content gate when using MXP
2579 *
2580 * @param	{string} contentid Optional: default's to Mura.contentid
2581 * @return {Promise}
2582 * @memberof {class} Mura
2583 */
2584
2585
2586function openGate(contentid) {
2587  return Mura.getRequestContext().openGate(contentid);
2588}
2589/**
2590 * getEntity - Returns Mura.Entity instance
2591 *
2592 * @param	{string} entityname Entity Name
2593 * @param	{string} siteid		 Siteid
2594 * @return {Mura.Entity}
2595 * @memberof {class} Mura
2596 */
2597
2598
2599function getEntity(entityname, siteid) {
2600  siteid = siteid || Mura.siteid;
2601  return Mura.getRequestContext().getEntity(entityname, siteid);
2602}
2603/**
2604 * getFeed - Return new instance of Mura.Feed
2605 *
2606 * @param	{type} entityname Entity name
2607 * @return {Mura.Feed}
2608 * @memberof {class} Mura
2609 */
2610
2611
2612function getFeed(entityname, siteid) {
2613  siteid = siteid || Mura.siteid;
2614  return Mura.getRequestContext().getFeed(entityname, siteid);
2615}
2616/**
2617 * getCurrentUser - Return Mura.Entity for current user
2618 *
2619 * @param	{object} params Load parameters, fields:list of fields
2620 * @return {Promise}
2621 * @memberof {class} Mura
2622 */
2623
2624
2625function getCurrentUser(params) {
2626  return Mura.getRequestContext().getCurrentUser(params);
2627}
2628/**
2629 * findText - Return Mura.Collection for content with text
2630 *
2631 * @param	{object} params Load parameters
2632 * @return {Promise}
2633 * @memberof {class} Mura
2634 */
2635
2636
2637function findText(text, params) {
2638  return Mura.getRequestContext().findText(text, params);
2639}
2640/**
2641 * findQuery - Returns Mura.EntityCollection with properties that match params
2642 *
2643 * @param	{object} params Object of matching params
2644 * @return {Promise}
2645 * @memberof {class} Mura
2646 */
2647
2648
2649function findQuery(params) {
2650  return Mura.getRequestContext().findQuery(params);
2651}
2652
2653function evalScripts(el) {
2654  if (typeof el == 'string') {
2655    el = parseHTML(el);
2656  }
2657
2658  var scripts = [];
2659  var ret = el.childNodes;
2660
2661  for (var i = 0; ret[i]; i++) {
2662    if (scripts && nodeName(ret[i], "script") && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript")) {
2663      if (ret[i].src) {
2664        scripts.push(ret[i]);
2665      } else {
2666        scripts.push(ret[i].parentNode ? ret[i].parentNode.removeChild(ret[i]) : ret[i]);
2667      }
2668    } else if (ret[i].nodeType == 1 || ret[i].nodeType == 9 || ret[i].nodeType == 11) {
2669      evalScripts(ret[i]);
2670    }
2671  }
2672
2673  for (var $script in scripts) {
2674    evalScript(scripts[$script]);
2675  }
2676}
2677
2678function evalScript(el) {
2679  if (el.src) {
2680    Mura.loader().load(el.src);
2681    Mura(el).remove();
2682  } else {
2683    var data = el.text || el.textContent || el.innerHTML || "";
2684    var head = document.getElementsByTagName("head")[0] || document.documentElement,
2685        script = document.createElement("script");
2686    script.type = "text/javascript"; //script.appendChild( document.createTextNode( data ) );
2687
2688    script.text = data;
2689    head.insertBefore(script, head.firstChild);
2690    head.removeChild(script);
2691
2692    if (el.parentNode) {
2693      el.parentNode.removeChild(el);
2694    }
2695  }
2696}
2697
2698function nodeName(el, name) {
2699  return el.nodeName && el.nodeName.toUpperCase() === name.toUpperCase();
2700}
2701
2702function changeElementType(el, to) {
2703  var newEl = document.createElement(to); // Try to copy attributes across
2704
2705  for (var i = 0, a = el.attributes, n = a.length; i < n; ++i) {
2706    el.setAttribute(a[i].name, a[i].value);
2707  } // Try to move children across
2708
2709
2710  while (el.hasChildNodes()) {
2711    newEl.appendChild(el.firstChild);
2712  } // Replace the old element with the new one
2713
2714
2715  el.parentNode.replaceChild(newEl, el); // Return the new element, for good measure.
2716
2717  return newEl;
2718}
2719/*
2720Defaults to holdReady is true so that everything
2721is queued up until the DOMContentLoaded is fired
2722*/
2723
2724
2725var holdingReady = true;
2726var holdingReadyAltered = false;