define("axios", [], function() { return /******/ (function(modules) { // webpackBootstrap

/******/ // 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] = {

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

/******/ id: moduleId,

/******/ loaded: false

/******/ };

/******/

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

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

/******/

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

/******/ module.loaded = 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;

/******/

/******/ // __webpack_public_path__

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

/******/

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

/******/ return __webpack_require__(0);

/******/ })

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

/******/ ([

/* 0 */

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

module.exports = __webpack_require__(1);

/***/ },

/* 1 */

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

/* WEBPACK VAR INJECTION */(function(process) {var Promise = __webpack_require__(13).Promise;

var defaults = __webpack_require__(2);

var utils = __webpack_require__(3);

var spread = __webpack_require__(4);

var axios = module.exports = function axios(config) {

config = utils.merge({

method: 'get',

transformRequest: defaults.transformRequest,

transformResponse: defaults.transformResponse

}, config);

// Don't allow overriding defaults.withCredentials

config.withCredentials = config.withCredentials || defaults.withCredentials;

var promise = new Promise(function (resolve, reject) {

try {

// For browsers use XHR adapter

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

__webpack_require__(5)(resolve, reject, config);

}

// For node use HTTP adapter

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

__webpack_require__(6)(resolve, reject, config);

}

} catch (e) {

reject(e);

}

});

// Provide alias for success

promise.success = function success(fn) {

promise.then(function(response) {

fn(response);

});

return promise;

};

// Provide alias for error

promise.error = function error(fn) {

promise.then(null, function(response) {

fn(response);

});

return promise;

};

return promise;

};

// Expose defaults

axios.defaults = defaults;

// Expose all/spread

axios.all = Promise.all;

axios.spread = spread;

// Provide aliases for supported request methods

createShortMethods('delete', 'get', 'head');

createShortMethodsWithData('post', 'put', 'patch');

function createShortMethods() {

utils.forEach(arguments, function (method) {

axios[method] = function (url, config) {

return axios(utils.merge(config || {}, {

method: method,

url: url

}));

};

});

}

function createShortMethodsWithData() {

utils.forEach(arguments, function (method) {

axios[method] = function (url, data, config) {

return axios(utils.merge(config || {}, {

method: method,

url: url,

data: data

}));

};

});

}

/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(7)))

/***/ },

/* 2 */

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

'use strict';

var utils = __webpack_require__(3);

var JSON_START = /^\s*(\[|\{[^\{])/;

var JSON_END = /[\}\]]\s*$/;

var PROTECTION_PREFIX = /^\)\]\}',?\n/;

var CONTENT_TYPE_APPLICATION_JSON = {

'Content-Type': 'application/json;charset=utf-8'

};

module.exports = {

transformRequest: [function (data) {

return utils.isObject(data) &&

!utils.isFile(data) &&

!utils.isBlob(data) ?

JSON.stringify(data) : null;

}],

transformResponse: [function (data) {

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

data = data.replace(PROTECTION_PREFIX, '');

if (JSON_START.test(data) && JSON_END.test(data)) {

data = JSON.parse(data);

}

}

return data;

}],

headers: {

common: {

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

},

patch: utils.merge(CONTENT_TYPE_APPLICATION_JSON),

post: utils.merge(CONTENT_TYPE_APPLICATION_JSON),

put: utils.merge(CONTENT_TYPE_APPLICATION_JSON)

},

xsrfCookieName: 'XSRF-TOKEN',

xsrfHeaderName: 'X-XSRF-TOKEN'

};

/***/ },

/* 3 */

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

// utils is a library of generic helper functions non-specific to axios

var toString = Object.prototype.toString;

/**

* Determine if a value is an Array

*

* @param {Object} val The value to test

* @returns {boolean} True if value is an Array, otherwise false

*/

function isArray(val) {

return toString.call(val) === '[object Array]';

}

/**

* Determine if a value is a String

*

* @param {Object} val The value to test

* @returns {boolean} True if value is a String, otherwise false

*/

function isString(val) {

return typeof val === 'string';

}

/**

* Determine if a value is a Number

*

* @param {Object} val The value to test

* @returns {boolean} True if value is a Number, otherwise false

*/

function isNumber(val) {

return typeof val === 'number';

}

/**

* Determine if a value is an Object

*

* @param {Object} val The value to test

* @returns {boolean} True if value is an Object, otherwise false

*/

function isObject(val) {

return val !== null && typeof val === 'object';

}

/**

* Determine if a value is a Date

*

* @param {Object} val The value to test

* @returns {boolean} True if value is a Date, otherwise false

*/

function isDate(val) {

return toString.call(val) === '[object Date]';

}

/**

* Determine if a value is a File

*

* @param {Object} val The value to test

* @returns {boolean} True if value is a File, otherwise false

*/

function isFile(val) {

return toString.call(val) === '[object File]';

}

/**

* Determine if a value is a Blob

*

* @param {Object} val The value to test

* @returns {boolean} True if value is a Blob, otherwise false

*/

function isBlob(val) {

return toString.call(val) === '[object Blob]';

}

/**

* Trim excess whitespace off the beginning and end of a string

*

* @param {String} str The String to trim

* @returns {String} The String freed of excess whitespace

*/

function trim(str) {

return str.replace(/^\s*/, '').replace(/\s*$/, '');

}

/**

* Iterate over an Array or an Object invoking a function for each item.

*

* If `obj` is an Array or arguments callback will be called passing

* the value, index, and complete array for each item.

*

* If 'obj' is an Object callback will be called passing

* the value, key, and complete object for each property.

*

* @param {Object|Array} obj The object to iterate

* @param {Function} fn The callback to invoke for each item

*/

function forEach(obj, fn) {

// Don't bother if no value provided

if (obj === null || typeof obj === 'undefined') {

return;

}

// Check if obj is array-like

var isArray = obj.constructor === Array || typeof obj.callee === 'function';

// Force an array if not already something iterable

if (typeof obj !== 'object' && !isArray) {

obj = [obj];

}

// Iterate over array values

if (isArray) {

for (var i=0, l=obj.length; i<l; i++) {

fn.call(null, obj[i], i, obj);

}

}

// Iterate over object keys

else {

for (var key in obj) {

if (obj.hasOwnProperty(key)) {

fn.call(null, obj[key], key, obj);

}

}

}

}

/**

* Accepts varargs expecting each argument to be an object, then

* immutably merges the properties of each object and returns result.

*

* When multiple objects contain the same key the later object in

* the arguments list will take precedence.

*

* Example:

*

* ```js

* var result = merge({foo: 123}, {foo: 456});

* console.log(result.foo); // outputs 456

* ```

*

* @param {Object} obj1 Object to merge

* @returns {Object} Result of all merge properties

*/

function merge(obj1/*, obj2, obj3, ...*/) {

var result = {};

forEach(arguments, function (obj) {

forEach(obj, function (val, key) {

result[key] = val;

});

});

return result;

}

module.exports = {

isArray: isArray,

isString: isString,

isNumber: isNumber,

isObject: isObject,

isDate: isDate,

isFile: isFile,

isBlob: isBlob,

forEach: forEach,

merge: merge,

trim: trim

};

/***/ },

/* 4 */

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

/**

* Syntactic sugar for invoking a function and expanding an array for arguments.

*

* Common use case would be to use `Function.prototype.apply`.

*

* ```js

* function f(x, y, z) {}

* var args = [1, 2, 3];

* f.apply(null, args);

* ```

*

* With `spread` this example can be re-written.

*

* ```js

* spread(function(x, y, z) {})([1, 2, 3]);

* ```

*

* @param {Function} callback

* @returns {Function}

*/

module.exports = function spread(callback) {

return function (arr) {

callback.apply(null, arr);

};

};

/***/ },

/* 5 */

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

var buildUrl = __webpack_require__(8);

var cookies = __webpack_require__(9);

var defaults = __webpack_require__(2);

var parseHeaders = __webpack_require__(10);

var transformData = __webpack_require__(11);

var urlIsSameOrigin = __webpack_require__(12);

var utils = __webpack_require__(3);

module.exports = function xhrAdapter(resolve, reject, config) {

// Transform request data

var data = transformData(

config.data,

config.headers,

config.transformRequest

);

// Merge headers

var headers = utils.merge(

defaults.headers.common,

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

config.headers || {}

);

// Create the request

var request = new(XMLHttpRequest || ActiveXObject)('Microsoft.XMLHTTP');

request.open(config.method, buildUrl(config.url, config.params), true);

// Listen for ready state

request.onreadystatechange = function () {

if (request && request.readyState === 4) {

// Prepare the response

var headers = parseHeaders(request.getAllResponseHeaders());

var response = {

data: transformData(

request.responseText,

headers,

config.transformResponse

),

status: request.status,

headers: headers,

config: config

};

// Resolve or reject the Promise based on the status

(request.status >= 200 && request.status < 300

? resolve

: reject)(

response.data,

response.status,

response.headers,

response.config

);

// Clean up request

request = null;

}

};

// Add xsrf header

var xsrfValue = urlIsSameOrigin(config.url)

? cookies.read(config.xsrfCookieName || defaults.xsrfCookieName)

: undefined;

if (xsrfValue) {

headers[config.xsrfHeaderName || defaults.xsrfHeaderName] = xsrfValue;

}

// Add headers to the request

utils.forEach(headers, function (val, key) {

// Remove Content-Type if data is undefined

if (!data && key.toLowerCase() === 'content-type') {

delete headers[key];

}

// Otherwise add header to the request

else {

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) {

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

throw e;

}

}

}

// Send the request

request.send(data);

};

/***/ },

/* 6 */

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

var buildUrl = __webpack_require__(8);

var defaults = __webpack_require__(2);

var transformData = __webpack_require__(11);

var utils = __webpack_require__(3);

var http = __webpack_require__(14);

var url = __webpack_require__(15);

module.exports = function httpAdapter(resolve, reject, config) {

// Transform request data

var data = transformData(

config.data,

config.headers,

config.transformRequest

);

// Merge headers

var headers = utils.merge(

defaults.headers.common,

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

config.headers || {}

);

// Parse url

var parsed = url.parse(config.url);

var options = {

host: parsed.hostname,

port: parsed.port,

path: buildUrl(parsed.path, config.params).replace(/^\?/, ''),

method: config.method,

headers: headers

};

// Create the request

var req = http.request(options, function (res) {

var responseText = '';

res.on('data', function (chunk) {

responseText += chunk;

});

res.on('end', function () {

var response = {

data: transformData(

responseText,

res.headers,

config.transformResponse

),

status: res.statusCode,

headers: res.headers,

config: config

};

// Resolve or reject the Promise based on the status

(res.statusCode >= 200 && res.statusCode < 300

? resolve

: reject)(

response.data,

response.status,

response.headers,

response.config

);

});

});

// Send the request

req.end(data);

};

/***/ },

/* 7 */

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

// shim for using process in browser

var process = module.exports = {};

process.nextTick = (function () {

var canSetImmediate = typeof window !== 'undefined'

&& window.setImmediate;

var canPost = typeof window !== 'undefined'

&& window.postMessage && window.addEventListener

;

if (canSetImmediate) {

return function (f) { return window.setImmediate(f) };

}

if (canPost) {

var queue = [];

window.addEventListener('message', function (ev) {

var source = ev.source;

if ((source === window || source === null) && ev.data === 'process-tick') {

ev.stopPropagation();

if (queue.length > 0) {

var fn = queue.shift();

fn();

}

}

}, true);

return function nextTick(fn) {

queue.push(fn);

window.postMessage('process-tick', '*');

};

}

return function nextTick(fn) {

setTimeout(fn, 0);

};

})();

process.title = 'browser';

process.browser = true;

process.env = {};

process.argv = [];

function noop() {}

process.on = noop;

process.addListener = noop;

process.once = noop;

process.off = noop;

process.removeListener = noop;

process.removeAllListeners = noop;

process.emit = noop;

process.binding = function (name) {

throw new Error('process.binding is not supported');

}

// TODO(shtylman)

process.cwd = function () { return '/' };

process.chdir = function (dir) {

throw new Error('process.chdir is not supported');

};

/***/ },

/* 8 */

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

'use strict';

var utils = __webpack_require__(3);

function encode(val) {

return encodeURIComponent(val).

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

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

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

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

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

}

module.exports = function buildUrl(url, params) {

if (!params) {

return url;

}

var parts = [];

utils.forEach(params, function (val, key) {

if (val === null || typeof val === 'undefined') {

return;

}

if (!utils.isArray(val)) {

val = [val];

}

utils.forEach(val, function (v) {

if (utils.isDate(v)) {

v = v.toISOString();

}

else if (utils.isObject(v)) {

v = JSON.stringify(v);

}

parts.push(encode(key) + '=' + encode(v));

});

});

if (parts.length > 0) {

url += (url.indexOf('?') === -1 ? '?' : '&') + parts.join('&');

}

return url;

};

/***/ },

/* 9 */

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

'use strict';

var utils = __webpack_require__(3);

module.exports = {

write: function write(name, value, expires, path, domain, secure) {

var cookie = [];

cookie.push(name + '=' + encodeURIComponent(value));

if (utils.isNumber(expires)) {

cookie.push('expires=' + new Date(expires).toGMTString());

}

if (utils.isString(path)) {

cookie.push('path=' + path);

}

if (utils.isString(domain)) {

cookie.push('domain=' + domain);

}

if (secure === true) {

cookie.push('secure');

}

document.cookie = cookie.join('; ');

},

read: function read(name) {

var match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));

return (match ? decodeURIComponent(match[3]) : null);

},

remove: function remove(name) {

this.write(name, '', Date.now() - 86400000);

}

};

/***/ },

/* 10 */

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

'use strict';

var utils = __webpack_require__(3);

/**

* Parse headers into an object

*

* ```

* Date: Wed, 27 Aug 2014 08:58:49 GMT

* Content-Type: application/json

* Connection: keep-alive

* Transfer-Encoding: chunked

* ```

*

* @param {String} headers Headers needing to be parsed

* @returns {Object} Headers parsed into an object

*/

module.exports = function parseHeaders(headers) {

var parsed = {}, key, val, i;

if (!headers) return parsed;

utils.forEach(headers.split('\n'), function(line) {

i = line.indexOf(':');

key = utils.trim(line.substr(0, i)).toLowerCase();

val = utils.trim(line.substr(i + 1));

if (key) {

parsed[key] = parsed[key] ? parsed[key] + ', ' + val : val;

}

});

return parsed;

};

/***/ },

/* 11 */

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

'use strict';

var utils = __webpack_require__(3);

/**

* 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) {

utils.forEach(fns, function (fn) {

data = fn(data, headers);

});

return data;

};

/***/ },

/* 12 */

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

'use strict';

var msie = /(msie|trident)/i.test(navigator.userAgent);

var utils = __webpack_require__(3);

var urlParsingNode = document.createElement('a');

var originUrl = urlResolve(window.location.href);

/**

* Parse a URL to discover it's components

*

* @param {String} url The URL to be parsed

* @returns {Object}

*/

function urlResolve(url) {

var href = url;

if (msie) {

// IE needs attribute set twice to normalize properties

urlParsingNode.setAttribute('href', href);

href = urlParsingNode.href;

}

urlParsingNode.setAttribute('href', href);

// urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils

return {

href: urlParsingNode.href,

protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',

host: urlParsingNode.host,

search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',

hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',

hostname: urlParsingNode.hostname,

port: urlParsingNode.port,

pathname: (urlParsingNode.pathname.charAt(0) === '/')

? urlParsingNode.pathname

: '/' + urlParsingNode.pathname

};

}

/**

* Determine if a URL shares the same origin as the current location

*

* @param {String} requestUrl The URL to test

* @returns {boolean} True if URL shares the same origin, otherwise false

*/

module.exports = function urlIsSameOrigin(requestUrl) {

var parsed = (utils.isString(requestUrl)) ? urlResolve(requestUrl) : requestUrl;

return (parsed.protocol === originUrl.protocol &&

parsed.host === originUrl.host);

};

/***/ },

/* 13 */

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

"use strict";

var Promise = __webpack_require__(16).Promise;

var polyfill = __webpack_require__(17).polyfill;

exports.Promise = Promise;

exports.polyfill = polyfill;

/***/ },

/* 14 */

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

var http = module.exports;

var EventEmitter = __webpack_require__(26).EventEmitter;

var Request = __webpack_require__(18);

var url = __webpack_require__(15)

http.request = function (params, cb) {

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

params = url.parse(params)

}

if (!params) params = {};

if (!params.host && !params.port) {

params.port = parseInt(window.location.port, 10);

}

if (!params.host && params.hostname) {

params.host = params.hostname;

}

if (!params.scheme) params.scheme = window.location.protocol.split(':')[0];

if (!params.host) {

params.host = window.location.hostname || window.location.host;

}

if (/:/.test(params.host)) {

if (!params.port) {

params.port = params.host.split(':')[1];

}

params.host = params.host.split(':')[0];

}

if (!params.port) params.port = params.scheme == 'https' ? 443 : 80;

var req = new Request(new xhrHttp, params);

if (cb) req.on('response', cb);

return req;

};

http.get = function (params, cb) {

params.method = 'GET';

var req = http.request(params, cb);

req.end();

return req;

};

http.Agent = function () {};

http.Agent.defaultMaxSockets = 4;

var xhrHttp = (function () {

if (typeof window === 'undefined') {

throw new Error('no window object present');

}

else if (window.XMLHttpRequest) {

return window.XMLHttpRequest;

}

else if (window.ActiveXObject) {

var axs = [

'Msxml2.XMLHTTP.6.0',

'Msxml2.XMLHTTP.3.0',

'Microsoft.XMLHTTP'

];

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

try {

var ax = new(window.ActiveXObject)(axs[i]);

return function () {

if (ax) {

var ax_ = ax;

ax = null;

return ax_;

}

else {

return new(window.ActiveXObject)(axs[i]);

}

};

}

catch (e) {}

}

throw new Error('ajax not supported in this browser')

}

else {

throw new Error('ajax not supported in this browser');

}

})();

http.STATUS_CODES = {

100 : 'Continue',

101 : 'Switching Protocols',

102 : 'Processing', // RFC 2518, obsoleted by RFC 4918

200 : 'OK',

201 : 'Created',

202 : 'Accepted',

203 : 'Non-Authoritative Information',

204 : 'No Content',

205 : 'Reset Content',

206 : 'Partial Content',

207 : 'Multi-Status', // RFC 4918

300 : 'Multiple Choices',

301 : 'Moved Permanently',

302 : 'Moved Temporarily',

303 : 'See Other',

304 : 'Not Modified',

305 : 'Use Proxy',

307 : 'Temporary Redirect',

400 : 'Bad Request',

401 : 'Unauthorized',

402 : 'Payment Required',

403 : 'Forbidden',

404 : 'Not Found',

405 : 'Method Not Allowed',

406 : 'Not Acceptable',

407 : 'Proxy Authentication Required',

408 : 'Request Time-out',

409 : 'Conflict',

410 : 'Gone',

411 : 'Length Required',

412 : 'Precondition Failed',

413 : 'Request Entity Too Large',

414 : 'Request-URI Too Large',

415 : 'Unsupported Media Type',

416 : 'Requested Range Not Satisfiable',

417 : 'Expectation Failed',

418 : 'I\'m a teapot', // RFC 2324

422 : 'Unprocessable Entity', // RFC 4918

423 : 'Locked', // RFC 4918

424 : 'Failed Dependency', // RFC 4918

425 : 'Unordered Collection', // RFC 4918

426 : 'Upgrade Required', // RFC 2817

428 : 'Precondition Required', // RFC 6585

429 : 'Too Many Requests', // RFC 6585

431 : 'Request Header Fields Too Large',// RFC 6585

500 : 'Internal Server Error',

501 : 'Not Implemented',

502 : 'Bad Gateway',

503 : 'Service Unavailable',

504 : 'Gateway Time-out',

505 : 'HTTP Version Not Supported',

506 : 'Variant Also Negotiates', // RFC 2295

507 : 'Insufficient Storage', // RFC 4918

509 : 'Bandwidth Limit Exceeded',

510 : 'Not Extended', // RFC 2774

511 : 'Network Authentication Required' // RFC 6585

};

/***/ },

/* 15 */

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

// Copyright Joyent, Inc. and other Node contributors.

//

// Permission is hereby granted, free of charge, to any person obtaining a

// copy of this software and associated documentation files (the

// "Software"), to deal in the Software without restriction, including

// without limitation the rights to use, copy, modify, merge, publish,

// distribute, sublicense, and/or sell copies of the Software, and to permit

// persons to whom the Software is furnished to do so, subject to the

// following conditions: