GCTC-NTGC / TalentCloud

/******/ 	// The module cache

/******/ 	var installedModules = {};

/******/

/******/ 	// The require function

/******/ 	function __webpack_require__(moduleId) {

/******/

/******/ 		// Check if module is in cache

/******/ 		if(installedModules[moduleId]) {

/******/ 			return installedModules[moduleId].exports;

/******/ 		}

/******/ 		// Create a new module (and put it into the cache)

/******/ 		var module = installedModules[moduleId] = {

/******/ 			i: moduleId,

/******/ 			l: false,

/******/ 			exports: {}

/******/ 		};

/******/

/******/ 		// Execute the module function

/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/

/******/ 		// Flag the module as loaded

/******/ 		module.l = true;

/******/

/******/ 		// Return the exports of the module

/******/ 		return module.exports;

/******/ 	}

/******/

/******/

/******/ 	// expose the modules object (__webpack_modules__)

/******/ 	__webpack_require__.m = modules;

/******/

/******/ 	// expose the module cache

/******/ 	__webpack_require__.c = installedModules;

/******/

/******/ 	// define getter function for harmony exports

/******/ 	__webpack_require__.d = function(exports, name, getter) {

/******/ 		if(!__webpack_require__.o(exports, name)) {

/******/ 			Object.defineProperty(exports, name, {

/******/ 				configurable: false,

/******/ 				enumerable: true,

/******/ 				get: getter

/******/ 			});

/******/ 		}

/******/ 	};

/******/

/******/ 	// getDefaultExport function for compatibility with non-harmony modules

/******/ 	__webpack_require__.n = function(module) {

/******/ 		var getter = module && module.__esModule ?

/******/ 			function getDefault() { return module['default']; } :

/******/ 			function getModuleExports() { return module; };

/******/ 		__webpack_require__.d(getter, 'a', getter);

/******/ 		return getter;

/******/ 	};

/******/

/******/ 	// Object.prototype.hasOwnProperty.call

/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };

/******/

/******/ 	// __webpack_public_path__

/******/ 	__webpack_require__.p = "/";

/******/

/******/ 	// Load entry module and return exports

/******/ 	return __webpack_require__(__webpack_require__.s = 0);

/******/ })

/************************************************************************/

/******/ ({

/***/ "./node_modules/axios/index.js":

/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__("./node_modules/axios/lib/axios.js");

/***/ }),

/***/ "./node_modules/axios/lib/adapters/xhr.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = __webpack_require__("./node_modules/axios/lib/utils.js");

var settle = __webpack_require__("./node_modules/axios/lib/core/settle.js");

var buildURL = __webpack_require__("./node_modules/axios/lib/helpers/buildURL.js");

var parseHeaders = __webpack_require__("./node_modules/axios/lib/helpers/parseHeaders.js");

var isURLSameOrigin = __webpack_require__("./node_modules/axios/lib/helpers/isURLSameOrigin.js");

var createError = __webpack_require__("./node_modules/axios/lib/core/createError.js");

var btoa = (typeof window !== 'undefined' && window.btoa && window.btoa.bind(window)) || __webpack_require__("./node_modules/axios/lib/helpers/btoa.js");

module.exports = function xhrAdapter(config) {

  return new Promise(function dispatchXhrRequest(resolve, reject) {

    var requestData = config.data;

    var requestHeaders = config.headers;

    if (utils.isFormData(requestData)) {

      delete requestHeaders['Content-Type']; // Let the browser set it

    }

    var request = new XMLHttpRequest();

    var loadEvent = 'onreadystatechange';

    var xDomain = false;

    // For IE 8/9 CORS support

    // Only supports POST and GET calls and doesn't returns the response headers.

    // DON'T do this for testing b/c XMLHttpRequest is mocked, not XDomainRequest.

    if ("development" !== 'test' &&

        typeof window !== 'undefined' &&

        window.XDomainRequest && !('withCredentials' in request) &&

        !isURLSameOrigin(config.url)) {

      request = new window.XDomainRequest();

      loadEvent = 'onload';

      xDomain = true;

      request.onprogress = function handleProgress() {};

      request.ontimeout = function handleTimeout() {};

    }

    // HTTP basic authentication

    if (config.auth) {

      var username = config.auth.username || '';

      var password = config.auth.password || '';

      requestHeaders.Authorization = 'Basic ' + btoa(username + ':' + password);

    }

    request.open(config.method.toUpperCase(), buildURL(config.url, config.params, config.paramsSerializer), true);

    // Set the request timeout in MS

    request.timeout = config.timeout;

    // Listen for ready state

    request[loadEvent] = function handleLoad() {

      if (!request || (request.readyState !== 4 && !xDomain)) {

        return;

      }

      // The request errored out and we didn't get a response, this will be

      // handled by onerror instead

      // With one exception: request that using file: protocol, most browsers

      // will return status as 0 even though it's a successful request

      if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf('file:') === 0)) {

        return;

      }

      // Prepare the response

      var responseHeaders = 'getAllResponseHeaders' in request ? parseHeaders(request.getAllResponseHeaders()) : null;

      var responseData = !config.responseType || config.responseType === 'text' ? request.responseText : request.response;

      var response = {

        data: responseData,

        // IE sends 1223 instead of 204 (https://github.com/axios/axios/issues/201)

        status: request.status === 1223 ? 204 : request.status,

        statusText: request.status === 1223 ? 'No Content' : request.statusText,

        headers: responseHeaders,

        config: config,

        request: request

      };

      settle(resolve, reject, response);

      // Clean up request

      request = null;

    };

    // Handle low level network errors

    request.onerror = function handleError() {

      // Real errors are hidden from us by the browser

      // onerror should only fire if it's a network error

      reject(createError('Network Error', config, null, request));

      // Clean up request

      request = null;

    };

    // Handle timeout

    request.ontimeout = function handleTimeout() {

      reject(createError('timeout of ' + config.timeout + 'ms exceeded', config, 'ECONNABORTED',

        request));

      // Clean up request

      request = null;

    };

    // Add xsrf header

    // This is only done if running in a standard browser environment.

    // Specifically not if we're in a web worker, or react-native.

    if (utils.isStandardBrowserEnv()) {

      var cookies = __webpack_require__("./node_modules/axios/lib/helpers/cookies.js");

      // Add xsrf header

      var xsrfValue = (config.withCredentials || isURLSameOrigin(config.url)) && config.xsrfCookieName ?

          cookies.read(config.xsrfCookieName) :

          undefined;

      if (xsrfValue) {

        requestHeaders[config.xsrfHeaderName] = xsrfValue;

      }

    }

    // Add headers to the request

    if ('setRequestHeader' in request) {

      utils.forEach(requestHeaders, function setRequestHeader(val, key) {

        if (typeof requestData === 'undefined' && key.toLowerCase() === 'content-type') {

          // Remove Content-Type if data is undefined

          delete requestHeaders[key];

        } else {

          // Otherwise add header to the request

          request.setRequestHeader(key, val);

        }

      });

    }

    // Add withCredentials to request if needed

    if (config.withCredentials) {

      request.withCredentials = true;

    }

    // Add responseType to request if needed

    if (config.responseType) {

      try {

        request.responseType = config.responseType;

      } catch (e) {

        // Expected DOMException thrown by browsers not compatible XMLHttpRequest Level 2.

        // But, this can be suppressed for 'json' type as it can be parsed by default 'transformResponse' function.

        if (config.responseType !== 'json') {

          throw e;

        }

      }

    }

    // Handle progress if needed

    if (typeof config.onDownloadProgress === 'function') {

      request.addEventListener('progress', config.onDownloadProgress);

    }

    // Not all browsers support upload events

    if (typeof config.onUploadProgress === 'function' && request.upload) {

      request.upload.addEventListener('progress', config.onUploadProgress);

    }

    if (config.cancelToken) {

      // Handle cancellation

      config.cancelToken.promise.then(function onCanceled(cancel) {

        if (!request) {

          return;

        }

        request.abort();

        reject(cancel);

        // Clean up request

        request = null;

      });

    }

    if (requestData === undefined) {

      requestData = null;

    }

    // Send the request

    request.send(requestData);

  });

};

/***/ }),

/***/ "./node_modules/axios/lib/axios.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = __webpack_require__("./node_modules/axios/lib/utils.js");

var bind = __webpack_require__("./node_modules/axios/lib/helpers/bind.js");

var Axios = __webpack_require__("./node_modules/axios/lib/core/Axios.js");

var defaults = __webpack_require__("./node_modules/axios/lib/defaults.js");

/**

 * Create an instance of Axios

 *

 * @param {Object} defaultConfig The default config for the instance

 * @return {Axios} A new instance of Axios

 */

function createInstance(defaultConfig) {

  var context = new Axios(defaultConfig);

  var instance = bind(Axios.prototype.request, context);

  // Copy axios.prototype to instance

  utils.extend(instance, Axios.prototype, context);

  // Copy context to instance

  utils.extend(instance, context);

  return instance;

}

// Create the default instance to be exported

var axios = createInstance(defaults);

// Expose Axios class to allow class inheritance

axios.Axios = Axios;

// Factory for creating new instances

axios.create = function create(instanceConfig) {

  return createInstance(utils.merge(defaults, instanceConfig));

};

// Expose Cancel & CancelToken

axios.Cancel = __webpack_require__("./node_modules/axios/lib/cancel/Cancel.js");

axios.CancelToken = __webpack_require__("./node_modules/axios/lib/cancel/CancelToken.js");

axios.isCancel = __webpack_require__("./node_modules/axios/lib/cancel/isCancel.js");

// Expose all/spread

axios.all = function all(promises) {

  return Promise.all(promises);

};

axios.spread = __webpack_require__("./node_modules/axios/lib/helpers/spread.js");

module.exports = axios;

// Allow use of default import syntax in TypeScript

module.exports.default = axios;

/***/ }),

/***/ "./node_modules/axios/lib/cancel/Cancel.js":

"use strict";

/**

 * A `Cancel` is an object that is thrown when an operation is canceled.

 *

 * @class

 * @param {string=} message The message.

 */

function Cancel(message) {

  this.message = message;

}

Cancel.prototype.toString = function toString() {

  return 'Cancel' + (this.message ? ': ' + this.message : '');

};

Cancel.prototype.__CANCEL__ = true;

module.exports = Cancel;

/***/ }),

/***/ "./node_modules/axios/lib/cancel/CancelToken.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var Cancel = __webpack_require__("./node_modules/axios/lib/cancel/Cancel.js");

/**

 * A `CancelToken` is an object that can be used to request cancellation of an operation.

 *

 * @class

 * @param {Function} executor The executor function.

 */

function CancelToken(executor) {

  if (typeof executor !== 'function') {

    throw new TypeError('executor must be a function.');

  }

  var resolvePromise;

  this.promise = new Promise(function promiseExecutor(resolve) {

    resolvePromise = resolve;

  });

  var token = this;

  executor(function cancel(message) {

    if (token.reason) {

      // Cancellation has already been requested

      return;

    }

    token.reason = new Cancel(message);

    resolvePromise(token.reason);

  });

}

/**

 * Throws a `Cancel` if cancellation has been requested.

 */

CancelToken.prototype.throwIfRequested = function throwIfRequested() {

  if (this.reason) {

    throw this.reason;

  }

};

/**

 * Returns an object that contains a new `CancelToken` and a function that, when called,

 * cancels the `CancelToken`.

 */

CancelToken.source = function source() {

  var cancel;

  var token = new CancelToken(function executor(c) {

    cancel = c;

  });

  return {

    token: token,

    cancel: cancel

  };

};

module.exports = CancelToken;

/***/ }),

/***/ "./node_modules/axios/lib/cancel/isCancel.js":

"use strict";

module.exports = function isCancel(value) {

  return !!(value && value.__CANCEL__);

};

/***/ }),

/***/ "./node_modules/axios/lib/core/Axios.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var defaults = __webpack_require__("./node_modules/axios/lib/defaults.js");

var utils = __webpack_require__("./node_modules/axios/lib/utils.js");

var InterceptorManager = __webpack_require__("./node_modules/axios/lib/core/InterceptorManager.js");

var dispatchRequest = __webpack_require__("./node_modules/axios/lib/core/dispatchRequest.js");

/**

 * Create a new instance of Axios

 *

 * @param {Object} instanceConfig The default config for the instance

 */

function Axios(instanceConfig) {

  this.defaults = instanceConfig;

  this.interceptors = {

    request: new InterceptorManager(),

    response: new InterceptorManager()

  };

}

/**

 * Dispatch a request

 *

 * @param {Object} config The config specific for this request (merged with this.defaults)

 */

Axios.prototype.request = function request(config) {

  /*eslint no-param-reassign:0*/

  // Allow for axios('example/url'[, config]) a la fetch API

  if (typeof config === 'string') {

    config = utils.merge({

      url: arguments[0]

    }, arguments[1]);

  }

  config = utils.merge(defaults, this.defaults, { method: 'get' }, config);

  config.method = config.method.toLowerCase();

  // Hook up interceptors middleware

  var chain = [dispatchRequest, undefined];

  var promise = Promise.resolve(config);

  this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {

    chain.unshift(interceptor.fulfilled, interceptor.rejected);

  });

  this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {

    chain.push(interceptor.fulfilled, interceptor.rejected);

  });

  while (chain.length) {

    promise = promise.then(chain.shift(), chain.shift());

  }

  return promise;

};

// Provide aliases for supported request methods

utils.forEach(['delete', 'get', 'head', 'options'], function forEachMethodNoData(method) {

  /*eslint func-names:0*/

  Axios.prototype[method] = function(url, config) {

    return this.request(utils.merge(config || {}, {

      method: method,

      url: url

    }));

  };

});

utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {

  /*eslint func-names:0*/

  Axios.prototype[method] = function(url, data, config) {

    return this.request(utils.merge(config || {}, {

      method: method,

      url: url,

      data: data

    }));

  };

});

module.exports = Axios;

/***/ }),

/***/ "./node_modules/axios/lib/core/InterceptorManager.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = __webpack_require__("./node_modules/axios/lib/utils.js");

function InterceptorManager() {

  this.handlers = [];

}

/**

 * Add a new interceptor to the stack

 *

 * @param {Function} fulfilled The function to handle `then` for a `Promise`

 * @param {Function} rejected The function to handle `reject` for a `Promise`

 *

 * @return {Number} An ID used to remove interceptor later

 */

InterceptorManager.prototype.use = function use(fulfilled, rejected) {

  this.handlers.push({

    fulfilled: fulfilled,

    rejected: rejected

  });

  return this.handlers.length - 1;

};

/**

 * Remove an interceptor from the stack

 *

 * @param {Number} id The ID that was returned by `use`

 */

InterceptorManager.prototype.eject = function eject(id) {

  if (this.handlers[id]) {

    this.handlers[id] = null;

  }

};

/**

 * Iterate over all the registered interceptors

 *

 * This method is particularly useful for skipping over any

 * interceptors that may have become `null` calling `eject`.

 *

 * @param {Function} fn The function to call for each interceptor

 */

InterceptorManager.prototype.forEach = function forEach(fn) {

  utils.forEach(this.handlers, function forEachHandler(h) {

    if (h !== null) {

      fn(h);

    }

  });

};

module.exports = InterceptorManager;

/***/ }),

/***/ "./node_modules/axios/lib/core/createError.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var enhanceError = __webpack_require__("./node_modules/axios/lib/core/enhanceError.js");

/**

 * Create an Error with the specified message, config, error code, request and response.

 *

 * @param {string} message The error message.

 * @param {Object} config The config.

 * @param {string} [code] The error code (for example, 'ECONNABORTED').

 * @param {Object} [request] The request.

 * @param {Object} [response] The response.

 * @returns {Error} The created error.

 */

module.exports = function createError(message, config, code, request, response) {

  var error = new Error(message);

  return enhanceError(error, config, code, request, response);

};

/***/ }),

/***/ "./node_modules/axios/lib/core/dispatchRequest.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = __webpack_require__("./node_modules/axios/lib/utils.js");

var transformData = __webpack_require__("./node_modules/axios/lib/core/transformData.js");

var isCancel = __webpack_require__("./node_modules/axios/lib/cancel/isCancel.js");

var defaults = __webpack_require__("./node_modules/axios/lib/defaults.js");

var isAbsoluteURL = __webpack_require__("./node_modules/axios/lib/helpers/isAbsoluteURL.js");

var combineURLs = __webpack_require__("./node_modules/axios/lib/helpers/combineURLs.js");

/**

 * Throws a `Cancel` if cancellation has been requested.

 */

function throwIfCancellationRequested(config) {

  if (config.cancelToken) {

    config.cancelToken.throwIfRequested();

  }

}

/**

 * Dispatch a request to the server using the configured adapter.

 *

 * @param {object} config The config that is to be used for the request

 * @returns {Promise} The Promise to be fulfilled

 */

module.exports = function dispatchRequest(config) {

  throwIfCancellationRequested(config);

  // Support baseURL config

  if (config.baseURL && !isAbsoluteURL(config.url)) {

    config.url = combineURLs(config.baseURL, config.url);

  }

  // Ensure headers exist

  config.headers = config.headers || {};

  // Transform request data

  config.data = transformData(

    config.data,

    config.headers,

    config.transformRequest

  );

  // Flatten headers

  config.headers = utils.merge(

    config.headers.common || {},

    config.headers[config.method] || {},

    config.headers || {}

  );

  utils.forEach(

    ['delete', 'get', 'head', 'post', 'put', 'patch', 'common'],

    function cleanHeaderConfig(method) {

      delete config.headers[method];

    }

  );

  var adapter = config.adapter || defaults.adapter;

  return adapter(config).then(function onAdapterResolution(response) {

    throwIfCancellationRequested(config);

    // Transform response data

    response.data = transformData(

      response.data,

      response.headers,

      config.transformResponse

    );

    return response;

  }, function onAdapterRejection(reason) {

    if (!isCancel(reason)) {

      throwIfCancellationRequested(config);

      // Transform response data

      if (reason && reason.response) {

        reason.response.data = transformData(

          reason.response.data,

          reason.response.headers,

          config.transformResponse

        );

      }

    }

    return Promise.reject(reason);

  });

};

/***/ }),

/***/ "./node_modules/axios/lib/core/enhanceError.js":

"use strict";

/**

 * Update an Error with the specified config, error code, and response.

 *

 * @param {Error} error The error to update.

 * @param {Object} config The config.

 * @param {string} [code] The error code (for example, 'ECONNABORTED').

 * @param {Object} [request] The request.

 * @param {Object} [response] The response.

 * @returns {Error} The error.

 */

module.exports = function enhanceError(error, config, code, request, response) {

  error.config = config;

  if (code) {

    error.code = code;

  }

  error.request = request;

  error.response = response;

  return error;

};

/***/ }),

/***/ "./node_modules/axios/lib/core/settle.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var createError = __webpack_require__("./node_modules/axios/lib/core/createError.js");

/**

 * Resolve or reject a Promise based on response status.

 *

 * @param {Function} resolve A function that resolves the promise.

 * @param {Function} reject A function that rejects the promise.

 * @param {object} response The response.

 */

module.exports = function settle(resolve, reject, response) {

  var validateStatus = response.config.validateStatus;

  // Note: status is not exposed by XDomainRequest

  if (!response.status || !validateStatus || validateStatus(response.status)) {

    resolve(response);

  } else {

    reject(createError(

      'Request failed with status code ' + response.status,

      response.config,

      null,

      response.request,

      response

    ));

  }

};

/***/ }),

/***/ "./node_modules/axios/lib/core/transformData.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = __webpack_require__("./node_modules/axios/lib/utils.js");

/**

 * Transform the data for a request or a response

 *

 * @param {Object|String} data The data to be transformed

 * @param {Array} headers The headers for the request or response

 * @param {Array|Function} fns A single function or Array of functions

 * @returns {*} The resulting transformed data

 */

module.exports = function transformData(data, headers, fns) {

  /*eslint no-param-reassign:0*/

  utils.forEach(fns, function transform(fn) {

    data = fn(data, headers);

  });

  return data;

};

/***/ }),

/***/ "./node_modules/axios/lib/defaults.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

/* WEBPACK VAR INJECTION */(function(process) {

var utils = __webpack_require__("./node_modules/axios/lib/utils.js");

var normalizeHeaderName = __webpack_require__("./node_modules/axios/lib/helpers/normalizeHeaderName.js");

var DEFAULT_CONTENT_TYPE = {

  'Content-Type': 'application/x-www-form-urlencoded'

};

function setContentTypeIfUnset(headers, value) {

  if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {

    headers['Content-Type'] = value;

  }

}

function getDefaultAdapter() {

  var adapter;

  if (typeof XMLHttpRequest !== 'undefined') {

    // For browsers use XHR adapter

    adapter = __webpack_require__("./node_modules/axios/lib/adapters/xhr.js");

  } else if (typeof process !== 'undefined') {

    // For node use HTTP adapter

    adapter = __webpack_require__("./node_modules/axios/lib/adapters/xhr.js");

  }

}

var defaults = {

  adapter: getDefaultAdapter(),

  transformRequest: [function transformRequest(data, headers) {

    normalizeHeaderName(headers, 'Content-Type');

    if (utils.isFormData(data) ||

      utils.isArrayBuffer(data) ||

      utils.isBuffer(data) ||

      utils.isStream(data) ||

      utils.isFile(data) ||

      utils.isBlob(data)

    ) {

      return data;

    }

    if (utils.isArrayBufferView(data)) {

      return data.buffer;

    }

    if (utils.isURLSearchParams(data)) {

      setContentTypeIfUnset(headers, 'application/x-www-form-urlencoded;charset=utf-8');

      return data.toString();

    }

    if (utils.isObject(data)) {

      setContentTypeIfUnset(headers, 'application/json;charset=utf-8');

      return JSON.stringify(data);

    }

    return data;

  }],

  transformResponse: [function transformResponse(data) {

    /*eslint no-param-reassign:0*/

    if (typeof data === 'string') {

      try {

        data = JSON.parse(data);

    }

    return data;

  }],

  timeout: 0,

  xsrfCookieName: 'XSRF-TOKEN',

  xsrfHeaderName: 'X-XSRF-TOKEN',

  maxContentLength: -1,

  validateStatus: function validateStatus(status) {

    return status >= 200 && status < 300;

  }

};

defaults.headers = {

  common: {

    'Accept': 'application/json, text/plain, */*'

  }

};

utils.forEach(['delete', 'get', 'head'], function forEachMethodNoData(method) {

  defaults.headers[method] = {};

});

utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {

  defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);

});

module.exports = defaults;

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__("./node_modules/process/browser.js")))

/***/ }),

/***/ "./node_modules/axios/lib/helpers/bind.js":

"use strict";

module.exports = function bind(fn, thisArg) {

  return function wrap() {

    var args = new Array(arguments.length);

    for (var i = 0; i < args.length; i++) {

      args[i] = arguments[i];

    }

    return fn.apply(thisArg, args);

  };

};

/***/ }),

/***/ "./node_modules/axios/lib/helpers/btoa.js":

"use strict";

// btoa polyfill for IE<10 courtesy https://github.com/davidchambers/Base64.js

var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

function E() {

  this.message = 'String contains an invalid character';

}

E.prototype = new Error;

E.prototype.code = 5;

E.prototype.name = 'InvalidCharacterError';

function btoa(input) {

  var str = String(input);

  var output = '';

  for (

    // initialize result and counter

    var block, charCode, idx = 0, map = chars;

    // if the next str index does not exist:

    //   change the mapping table to "="

    //   check if d has no fractional digits

    // "8 - idx % 1 * 8" generates the sequence 2, 4, 6, 8

    output += map.charAt(63 & block >> 8 - idx % 1 * 8)

  ) {

    charCode = str.charCodeAt(idx += 3 / 4);

    if (charCode > 0xFF) {

      throw new E();

    }

  }

  return output;

}

module.exports = btoa;

/***/ }),

/***/ "./node_modules/axios/lib/helpers/buildURL.js":

/***/ (function(module, exports, __webpack_require__) {

"use strict";

var utils = __webpack_require__("./node_modules/axios/lib/utils.js");

function encode(val) {

  return encodeURIComponent(val).

    replace(/%40/gi, '@').

    replace(/%3A/gi, ':').

    replace(/%24/g, '$').

    replace(/%2C/gi, ',').

    replace(/%20/g, '+').

    replace(/%5B/gi, '[').

    replace(/%5D/gi, ']');

}

/**

 * Build a URL by appending params to the end

 *

 * @param {string} url The base of the url (e.g., http://www.google.com)

 * @param {object} [params] The params to be appended

 * @returns {string} The formatted url

 */

module.exports = function buildURL(url, params, paramsSerializer) {

  /*eslint no-param-reassign:0*/

  if (!params) {

    return url;

  }

  var serializedParams;

  if (paramsSerializer) {

    serializedParams = paramsSerializer(params);

  } else if (utils.isURLSearchParams(params)) {

    serializedParams = params.toString();

  } else {

    var parts = [];