axios_rails 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0fbfbdccbe169763d3d14319a927cc31cc5c461
-  data.tar.gz: e148afdfcd3d93f8aca0a1ca9cf9b36358692658
+  metadata.gz: 506f0982f33d5feb794bcb0d6fd2914a00bc6534
+  data.tar.gz: 660ab47c44260b3c6d77dc59f5dfe61bafd9adaf
 SHA512:
-  metadata.gz: 2c97361748c4f5d47bda79129c01db8d9be6ad3d02cc7e336a4af5ea4d5bfb1479dc43d85ff47e49226ef65f2fa6733a62cdd6f2070a9b24396e8058cdfd9ac4
-  data.tar.gz: c256ce996c74b6fe9bc02a57cde7dd171482b806454a6d6603414668e3c822cdf260dd670859a42f4baf6358e291636df89d32836574181eea7e698631a7d170
+  metadata.gz: f936fee724dfb4d35cf65d18ba184660bb36569b6c7fecfe86f521de3c12066fb3468128fdd41b244200ac65a5ed1563bc34ca50cbc553a85e4c237176297540
+  data.tar.gz: a1a342c7672c58e306ca310a2e99986840dc7fe7f61fefb667f55760c545465724ad6f55926e07120100cb1cf69a56990fa2c812d9f46544d909debe9adb6b24

data/app/assets/javascripts/axios.js

@@ -1,6 +1,14 @@
-
-var axios =
-/******/ (function(modules) { // webpackBootstrap
+(function webpackUniversalModuleDefinition(root, factory) {
+  if(typeof exports === 'object' && typeof module === 'object')
+    module.exports = factory();
+  else if(typeof define === 'function' && define.amd)
+    define([], factory);
+  else if(typeof exports === 'object')
+    exports["axios"] = factory();
+  else
+    root["axios"] = factory();
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
 /******/  // The module cache
 /******/  var installedModules = {};
 /******/
@@ -52,14 +60,12 @@ var axios =
 /* 1 */
 /***/ function(module, exports, __webpack_require__) {
 
+  'use strict';
+
   var defaults = __webpack_require__(2);
   var utils = __webpack_require__(3);
-  var deprecatedMethod = __webpack_require__(4);
-  var dispatchRequest = __webpack_require__(5);
-  var InterceptorManager = __webpack_require__(6);
-
-  // Polyfill ES6 Promise if needed
-  __webpack_require__(9).polyfill();
+  var dispatchRequest = __webpack_require__(4);
+  var InterceptorManager = __webpack_require__(12);
 
   var axios = module.exports = function axios(config) {
     config = utils.merge({
@@ -88,26 +94,6 @@ var axios =
       promise = promise.then(chain.shift(), chain.shift());
     }
 
-    // Provide alias for success
-    promise.success = function success(fn) {
-      deprecatedMethod('success', 'then', 'https://github.com/mzabriskie/axios/blob/master/README.md#response-api');
-
-      promise.then(function(response) {
-        fn(response.data, response.status, response.headers, response.config);
-      });
-      return promise;
-    };
-
-    // Provide alias for error
-    promise.error = function error(fn) {
-      deprecatedMethod('error', 'catch', 'https://github.com/mzabriskie/axios/blob/master/README.md#response-api');
-
-      promise.then(null, function(response) {
-        fn(response.data, response.status, response.headers, response.config);
-      });
-      return promise;
-    };
-
     return promise;
   };
 
@@ -118,7 +104,7 @@ var axios =
   axios.all = function (promises) {
     return Promise.all(promises);
   };
-  axios.spread = __webpack_require__(7);
+  axios.spread = __webpack_require__(13);
 
   // Expose interceptors
   axios.interceptors = {
@@ -127,32 +113,33 @@ var axios =
   };
 
   // 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 () {
+    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
-        }));
-      };
-    });
-  }
+    function createShortMethodsWithData() {
+      utils.forEach(arguments, function (method) {
+        axios[method] = function (url, data, config) {
+          return axios(utils.merge(config || {}, {
+            method: method,
+            url: url,
+            data: data
+          }));
+        };
+      });
+    }
 
+    createShortMethods('delete', 'get', 'head');
+    createShortMethodsWithData('post', 'put', 'patch');
+  })();
 
 
 /***/ },
@@ -163,8 +150,6 @@ var axios =
 
   var utils = __webpack_require__(3);
 
-  var JSON_START = /^\s*(\[|\{[^\{])/;
-  var JSON_END = /[\}\]]\s*$/;
   var PROTECTION_PREFIX = /^\)\]\}',?\n/;
   var DEFAULT_CONTENT_TYPE = {
     'Content-Type': 'application/x-www-form-urlencoded'
@@ -172,6 +157,9 @@ var axios =
 
   module.exports = {
     transformRequest: [function (data, headers) {
+      if(utils.isFormData(data)) {
+        return data;
+      }
       if (utils.isArrayBuffer(data)) {
         return data;
       }
@@ -180,8 +168,16 @@ var axios =
       }
       if (utils.isObject(data) && !utils.isFile(data) && !utils.isBlob(data)) {
         // Set application/json if no Content-Type has been specified
-        if (!utils.isUndefined(headers) && utils.isUndefined(headers['Content-Type'])) {
-          headers['Content-Type'] = 'application/json;charset=utf-8';
+        if (!utils.isUndefined(headers)) {
+          utils.forEach(headers, function (val, key) {
+            if (key.toLowerCase() === 'content-type') {
+              headers['Content-Type'] = val;
+            }
+          });
+
+          if (utils.isUndefined(headers['Content-Type'])) {
+            headers['Content-Type'] = 'application/json;charset=utf-8';
+          }
         }
         return JSON.stringify(data);
       }
@@ -191,9 +187,9 @@ var axios =
     transformResponse: [function (data) {
       if (typeof data === 'string') {
         data = data.replace(PROTECTION_PREFIX, '');
-        if (JSON_START.test(data) && JSON_END.test(data)) {
+        try {
           data = JSON.parse(data);
-        }
+        } catch (e) { /* Ignore */ }
       }
       return data;
     }],
@@ -207,13 +203,20 @@ var axios =
       put: utils.merge(DEFAULT_CONTENT_TYPE)
     },
 
+    timeout: 0,
+
     xsrfCookieName: 'XSRF-TOKEN',
     xsrfHeaderName: 'X-XSRF-TOKEN'
   };
 
+
 /***/ },
 /* 3 */
-/***/ function(module, exports, __webpack_require__) {
+/***/ function(module, exports) {
+
+  'use strict';
+
+  /*global toString:true*/
 
   // utils is a library of generic helper functions non-specific to axios
 
@@ -343,6 +346,16 @@ var axios =
     return str.replace(/^\s*/, '').replace(/\s*$/, '');
   }
 
+  /**
+   * Determine if a value is an Arguments object
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is an Arguments object, otherwise false
+   */
+  function isArguments(val) {
+    return toString.call(val) === '[object Arguments]';
+  }
+
   /**
    * Iterate over an Array or an Object invoking a function for each item.
    *
@@ -362,16 +375,16 @@ var axios =
     }
 
     // Check if obj is array-like
-    var isArray = obj.constructor === Array || typeof obj.callee === 'function';
+    var isArrayLike = isArray(obj) || isArguments(obj);
 
     // Force an array if not already something iterable
-    if (typeof obj !== 'object' && !isArray) {
+    if (typeof obj !== 'object' && !isArrayLike) {
       obj = [obj];
     }
 
     // Iterate over array values
-    if (isArray) {
-      for (var i=0, l=obj.length; i<l; i++) {
+    if (isArrayLike) {
+      for (var i = 0, l = obj.length; i < l; i++) {
         fn.call(null, obj[i], i, obj);
       }
     }
@@ -402,7 +415,7 @@ var axios =
    * @param {Object} obj1 Object to merge
    * @returns {Object} Result of all merge properties
    */
-  function merge(obj1/*, obj2, obj3, ...*/) {
+  function merge(/*obj1, obj2, obj3, ...*/) {
     var result = {};
     forEach(arguments, function (obj) {
       forEach(obj, function (val, key) {
@@ -429,42 +442,13 @@ var axios =
     trim: trim
   };
 
-/***/ },
-/* 4 */
-/***/ function(module, exports, __webpack_require__) {
-
-  'use strict';
-
-  /**
-   * Supply a warning to the developer that a method they are using
-   * has been deprecated.
-   *
-   * @param {string} method The name of the deprecated method
-   * @param {string} [instead] The alternate method to use if applicable
-   * @param {string} [docs] The documentation URL to get further details
-   */
-  module.exports = function deprecatedMethod(method, instead, docs) {
-    try {
-      console.warn(
-        'DEPRECATED method `' + method + '`.' +
-        (instead ? ' Use `' + instead + '` instead.' : '') +
-        ' This method will be removed in a future release.');
-
-      if (docs) {
-        console.warn('For more information about usage see ' + docs);
-      }
-    } catch (e) {}
-  };
-
 
 /***/ },
-/* 5 */
+/* 4 */
 /***/ function(module, exports, __webpack_require__) {
 
   /* WEBPACK VAR INJECTION */(function(process) {'use strict';
 
-  var Promise = __webpack_require__(9).Promise;
-
   /**
    * Dispatch a request to the server using whichever adapter
    * is supported by the current environment.
@@ -476,12 +460,12 @@ var axios =
     return new Promise(function (resolve, reject) {
       try {
         // For browsers use XHR adapter
-        if (typeof window !== 'undefined') {
-          __webpack_require__(8)(resolve, reject, config);
+        if ((typeof XMLHttpRequest !== 'undefined') || (typeof ActiveXObject !== 'undefined')) {
+          __webpack_require__(6)(resolve, reject, config);
         }
         // For node use HTTP adapter
         else if (typeof process !== 'undefined') {
-          __webpack_require__(8)(resolve, reject, config);
+          __webpack_require__(6)(resolve, reject, config);
         }
       } catch (e) {
         reject(e);
@@ -490,108 +474,120 @@ var axios =
   };
 
 
-  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(10)))
+  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5)))
 
 /***/ },
-/* 6 */
-/***/ function(module, exports, __webpack_require__) {
-
-  'use strict';
+/* 5 */
+/***/ function(module, exports) {
 
-  var utils = __webpack_require__(3);
+  // shim for using process in browser
 
-  function InterceptorManager() {
-    this.handlers = [];
-  };
+  var process = module.exports = {};
+  var queue = [];
+  var draining = false;
+  var currentQueue;
+  var queueIndex = -1;
+
+  function cleanUpNextTick() {
+      draining = false;
+      if (currentQueue.length) {
+          queue = currentQueue.concat(queue);
+      } else {
+          queueIndex = -1;
+      }
+      if (queue.length) {
+          drainQueue();
+      }
+  }
 
-  /**
-   * 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 (fulfilled, rejected) {
-    this.handlers.push({
-      fulfilled: fulfilled,
-      rejected: rejected
-    });
-    return this.handlers.length - 1;
-  };
+  function drainQueue() {
+      if (draining) {
+          return;
+      }
+      var timeout = setTimeout(cleanUpNextTick);
+      draining = true;
 
-  /**
-   * Remove an interceptor from the stack
-   *
-   * @param {Number} id The ID that was returned by `use`
-   */
-  InterceptorManager.prototype.eject = function (id) {
-    if (this.handlers[id]) {
-      this.handlers[id] = null;
-    }
-  };
+      var len = queue.length;
+      while(len) {
+          currentQueue = queue;
+          queue = [];
+          while (++queueIndex < len) {
+              if (currentQueue) {
+                  currentQueue[queueIndex].run();
+              }
+          }
+          queueIndex = -1;
+          len = queue.length;
+      }
+      currentQueue = null;
+      draining = false;
+      clearTimeout(timeout);
+  }
 
-  /**
-   * Iterate over all the registered interceptors
-   *
-   * This method is particularly useful for skipping over any
-   * interceptors that may have become `null` calling `remove`.
-   *
-   * @param {Function} fn The function to call for each interceptor
-   */
-  InterceptorManager.prototype.forEach = function (fn) {
-    utils.forEach(this.handlers, function (h) {
-      if (h !== null) {
-        fn(h);
+  process.nextTick = function (fun) {
+      var args = new Array(arguments.length - 1);
+      if (arguments.length > 1) {
+          for (var i = 1; i < arguments.length; i++) {
+              args[i - 1] = arguments[i];
+          }
+      }
+      queue.push(new Item(fun, args));
+      if (queue.length === 1 && !draining) {
+          setTimeout(drainQueue, 0);
       }
-    });
   };
 
-  module.exports = InterceptorManager;
+  // v8 likes predictible objects
+  function Item(fun, array) {
+      this.fun = fun;
+      this.array = array;
+  }
+  Item.prototype.run = function () {
+      this.fun.apply(null, this.array);
+  };
+  process.title = 'browser';
+  process.browser = true;
+  process.env = {};
+  process.argv = [];
+  process.version = ''; // empty string to avoid regexp issues
+  process.versions = {};
 
+  function noop() {}
 
+  process.on = noop;
+  process.addListener = noop;
+  process.once = noop;
+  process.off = noop;
+  process.removeListener = noop;
+  process.removeAllListeners = noop;
+  process.emit = noop;
 
-/***/ },
-/* 7 */
-/***/ function(module, exports, __webpack_require__) {
+  process.binding = function (name) {
+      throw new Error('process.binding is not supported');
+  };
 
-  /**
-   * 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);
-    };
+  process.cwd = function () { return '/' };
+  process.chdir = function (dir) {
+      throw new Error('process.chdir is not supported');
   };
+  process.umask = function() { return 0; };
+
 
 /***/ },
-/* 8 */
+/* 6 */
 /***/ function(module, exports, __webpack_require__) {
 
+  'use strict';
+
+  /*global ActiveXObject:true*/
+
   var defaults = __webpack_require__(2);
   var utils = __webpack_require__(3);
-  var buildUrl = __webpack_require__(11);
-  var cookies = __webpack_require__(12);
-  var parseHeaders = __webpack_require__(13);
-  var transformData = __webpack_require__(14);
-  var urlIsSameOrigin = __webpack_require__(15);
+  var buildUrl = __webpack_require__(7);
+  var cookies = __webpack_require__(8);
+  var parseHeaders = __webpack_require__(9);
+  var transformData = __webpack_require__(10);
+  var urlIsSameOrigin = __webpack_require__(11);
 
   module.exports = function xhrAdapter(resolve, reject, config) {
     // Transform request data
@@ -602,40 +598,45 @@ var axios =
     );
 
     // Merge headers
-    var headers = utils.merge(
+    var requestHeaders = utils.merge(
       defaults.headers.common,
       defaults.headers[config.method] || {},
       config.headers || {}
     );
 
     if (utils.isFormData(data)) {
-      delete headers['Content-Type']; // Let the browser set it
+      delete requestHeaders['Content-Type']; // Let the browser set it
     }
 
     // Create the request
-    var request = new(XMLHttpRequest || ActiveXObject)('Microsoft.XMLHTTP');
+    var request = new (XMLHttpRequest || ActiveXObject)('Microsoft.XMLHTTP');
     request.open(config.method.toUpperCase(), buildUrl(config.url, config.params), true);
 
+    // Set the request timeout in MS
+    request.timeout = config.timeout;
+
     // Listen for ready state
     request.onreadystatechange = function () {
       if (request && request.readyState === 4) {
         // Prepare the response
-        var headers = parseHeaders(request.getAllResponseHeaders());
+        var responseHeaders = parseHeaders(request.getAllResponseHeaders());
+        var responseData = ['text', ''].indexOf(config.responseType || '') !== -1 ? request.responseText : request.response;
         var response = {
           data: transformData(
-            request.responseText,
-            headers,
+            responseData,
+            responseHeaders,
             config.transformResponse
           ),
           status: request.status,
-          headers: headers,
+          statusText: request.statusText,
+          headers: responseHeaders,
           config: config
         };
 
         // Resolve or reject the Promise based on the status
-        (request.status >= 200 && request.status < 300
-          ? resolve
-          : reject)(response);
+        (request.status >= 200 && request.status < 300 ?
+          resolve :
+          reject)(response);
 
         // Clean up request
         request = null;
@@ -643,18 +644,18 @@ var axios =
     };
 
     // Add xsrf header
-    var xsrfValue = urlIsSameOrigin(config.url)
-      ? cookies.read(config.xsrfCookieName || defaults.xsrfCookieName)
-      : undefined;
+    var xsrfValue = urlIsSameOrigin(config.url) ?
+        cookies.read(config.xsrfCookieName || defaults.xsrfCookieName) :
+        undefined;
     if (xsrfValue) {
-      headers[config.xsrfHeaderName || defaults.xsrfHeaderName] = xsrfValue;
+      requestHeaders[config.xsrfHeaderName || defaults.xsrfHeaderName] = xsrfValue;
     }
 
     // Add headers to the request
-    utils.forEach(headers, function (val, key) {
+    utils.forEach(requestHeaders, function (val, key) {
       // Remove Content-Type if data is undefined
       if (!data && key.toLowerCase() === 'content-type') {
-        delete headers[key];
+        delete requestHeaders[key];
       }
       // Otherwise add header to the request
       else {
@@ -686,1149 +687,99 @@ var axios =
     request.send(data);
   };
 
+
 /***/ },
-/* 9 */
+/* 7 */
 /***/ function(module, exports, __webpack_require__) {
 
-  var __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(process, global, module) {/*!
-   * @overview es6-promise - a tiny implementation of Promises/A+.
-   * @copyright Copyright (c) 2014 Yehuda Katz, Tom Dale, Stefan Penner and contributors (Conversion to ES6 API by Jake Archibald)
-   * @license   Licensed under MIT license
-   *            See https://raw.githubusercontent.com/jakearchibald/es6-promise/master/LICENSE
-   * @version   2.0.1
-   */
+  'use strict';
 
-  (function() {
-      "use strict";
+  var utils = __webpack_require__(3);
 
-      function $$utils$$objectOrFunction(x) {
-        return typeof x === 'function' || (typeof x === 'object' && x !== null);
-      }
+  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, ']');
+  }
 
-      function $$utils$$isFunction(x) {
-        return typeof x === 'function';
-      }
+  /**
+   * 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) {
+    if (!params) {
+      return url;
+    }
 
-      function $$utils$$isMaybeThenable(x) {
-        return typeof x === 'object' && x !== null;
-      }
+    var parts = [];
 
-      var $$utils$$_isArray;
+    utils.forEach(params, function (val, key) {
+      if (val === null || typeof val === 'undefined') {
+        return;
+      }
 
-      if (!Array.isArray) {
-        $$utils$$_isArray = function (x) {
-          return Object.prototype.toString.call(x) === '[object Array]';
-        };
-      } else {
-        $$utils$$_isArray = Array.isArray;
+      if (utils.isArray(val)) {
+        key = key + '[]';
       }
 
-      var $$utils$$isArray = $$utils$$_isArray;
-      var $$utils$$now = Date.now || function() { return new Date().getTime(); };
-      function $$utils$$F() { }
+      if (!utils.isArray(val)) {
+        val = [val];
+      }
 
-      var $$utils$$o_create = (Object.create || function (o) {
-        if (arguments.length > 1) {
-          throw new Error('Second argument not supported');
+      utils.forEach(val, function (v) {
+        if (utils.isDate(v)) {
+          v = v.toISOString();
         }
-        if (typeof o !== 'object') {
-          throw new TypeError('Argument must be an object');
+        else if (utils.isObject(v)) {
+          v = JSON.stringify(v);
         }
-        $$utils$$F.prototype = o;
-        return new $$utils$$F();
+        parts.push(encode(key) + '=' + encode(v));
       });
+    });
 
-      var $$asap$$len = 0;
-
-      var $$asap$$default = function asap(callback, arg) {
-        $$asap$$queue[$$asap$$len] = callback;
-        $$asap$$queue[$$asap$$len + 1] = arg;
-        $$asap$$len += 2;
-        if ($$asap$$len === 2) {
-          // If len is 1, that means that we need to schedule an async flush.
-          // If additional callbacks are queued before the queue is flushed, they
-          // will be processed by this flush that we are scheduling.
-          $$asap$$scheduleFlush();
-        }
-      };
+    if (parts.length > 0) {
+      url += (url.indexOf('?') === -1 ? '?' : '&') + parts.join('&');
+    }
 
-      var $$asap$$browserGlobal = (typeof window !== 'undefined') ? window : {};
-      var $$asap$$BrowserMutationObserver = $$asap$$browserGlobal.MutationObserver || $$asap$$browserGlobal.WebKitMutationObserver;
+    return url;
+  };
 
-      // test for web worker but not in IE10
-      var $$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&
-        typeof importScripts !== 'undefined' &&
-        typeof MessageChannel !== 'undefined';
 
-      // node
-      function $$asap$$useNextTick() {
-        return function() {
-          process.nextTick($$asap$$flush);
-        };
-      }
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
 
-      function $$asap$$useMutationObserver() {
-        var iterations = 0;
-        var observer = new $$asap$$BrowserMutationObserver($$asap$$flush);
-        var node = document.createTextNode('');
-        observer.observe(node, { characterData: true });
+  'use strict';
 
-        return function() {
-          node.data = (iterations = ++iterations % 2);
-        };
-      }
+  var utils = __webpack_require__(3);
 
-      // web worker
-      function $$asap$$useMessageChannel() {
-        var channel = new MessageChannel();
-        channel.port1.onmessage = $$asap$$flush;
-        return function () {
-          channel.port2.postMessage(0);
-        };
-      }
+  module.exports = {
+    write: function write(name, value, expires, path, domain, secure) {
+      var cookie = [];
+      cookie.push(name + '=' + encodeURIComponent(value));
 
-      function $$asap$$useSetTimeout() {
-        return function() {
-          setTimeout($$asap$$flush, 1);
-        };
+      if (utils.isNumber(expires)) {
+        cookie.push('expires=' + new Date(expires).toGMTString());
       }
 
-      var $$asap$$queue = new Array(1000);
-
-      function $$asap$$flush() {
-        for (var i = 0; i < $$asap$$len; i+=2) {
-          var callback = $$asap$$queue[i];
-          var arg = $$asap$$queue[i+1];
-
-          callback(arg);
-
-          $$asap$$queue[i] = undefined;
-          $$asap$$queue[i+1] = undefined;
-        }
-
-        $$asap$$len = 0;
+      if (utils.isString(path)) {
+        cookie.push('path=' + path);
       }
 
-      var $$asap$$scheduleFlush;
-
-      // Decide what async method to use to triggering processing of queued callbacks:
-      if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
-        $$asap$$scheduleFlush = $$asap$$useNextTick();
-      } else if ($$asap$$BrowserMutationObserver) {
-        $$asap$$scheduleFlush = $$asap$$useMutationObserver();
-      } else if ($$asap$$isWorker) {
-        $$asap$$scheduleFlush = $$asap$$useMessageChannel();
-      } else {
-        $$asap$$scheduleFlush = $$asap$$useSetTimeout();
+      if (utils.isString(domain)) {
+        cookie.push('domain=' + domain);
       }
 
-      function $$$internal$$noop() {}
-      var $$$internal$$PENDING   = void 0;
-      var $$$internal$$FULFILLED = 1;
-      var $$$internal$$REJECTED  = 2;
-      var $$$internal$$GET_THEN_ERROR = new $$$internal$$ErrorObject();
-
-      function $$$internal$$selfFullfillment() {
-        return new TypeError("You cannot resolve a promise with itself");
-      }
-
-      function $$$internal$$cannotReturnOwn() {
-        return new TypeError('A promises callback cannot return that same promise.')
-      }
-
-      function $$$internal$$getThen(promise) {
-        try {
-          return promise.then;
-        } catch(error) {
-          $$$internal$$GET_THEN_ERROR.error = error;
-          return $$$internal$$GET_THEN_ERROR;
-        }
-      }
-
-      function $$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) {
-        try {
-          then.call(value, fulfillmentHandler, rejectionHandler);
-        } catch(e) {
-          return e;
-        }
-      }
-
-      function $$$internal$$handleForeignThenable(promise, thenable, then) {
-         $$asap$$default(function(promise) {
-          var sealed = false;
-          var error = $$$internal$$tryThen(then, thenable, function(value) {
-            if (sealed) { return; }
-            sealed = true;
-            if (thenable !== value) {
-              $$$internal$$resolve(promise, value);
-            } else {
-              $$$internal$$fulfill(promise, value);
-            }
-          }, function(reason) {
-            if (sealed) { return; }
-            sealed = true;
-
-            $$$internal$$reject(promise, reason);
-          }, 'Settle: ' + (promise._label || ' unknown promise'));
-
-          if (!sealed && error) {
-            sealed = true;
-            $$$internal$$reject(promise, error);
-          }
-        }, promise);
-      }
-
-      function $$$internal$$handleOwnThenable(promise, thenable) {
-        if (thenable._state === $$$internal$$FULFILLED) {
-          $$$internal$$fulfill(promise, thenable._result);
-        } else if (promise._state === $$$internal$$REJECTED) {
-          $$$internal$$reject(promise, thenable._result);
-        } else {
-          $$$internal$$subscribe(thenable, undefined, function(value) {
-            $$$internal$$resolve(promise, value);
-          }, function(reason) {
-            $$$internal$$reject(promise, reason);
-          });
-        }
-      }
-
-      function $$$internal$$handleMaybeThenable(promise, maybeThenable) {
-        if (maybeThenable.constructor === promise.constructor) {
-          $$$internal$$handleOwnThenable(promise, maybeThenable);
-        } else {
-          var then = $$$internal$$getThen(maybeThenable);
-
-          if (then === $$$internal$$GET_THEN_ERROR) {
-            $$$internal$$reject(promise, $$$internal$$GET_THEN_ERROR.error);
-          } else if (then === undefined) {
-            $$$internal$$fulfill(promise, maybeThenable);
-          } else if ($$utils$$isFunction(then)) {
-            $$$internal$$handleForeignThenable(promise, maybeThenable, then);
-          } else {
-            $$$internal$$fulfill(promise, maybeThenable);
-          }
-        }
-      }
-
-      function $$$internal$$resolve(promise, value) {
-        if (promise === value) {
-          $$$internal$$reject(promise, $$$internal$$selfFullfillment());
-        } else if ($$utils$$objectOrFunction(value)) {
-          $$$internal$$handleMaybeThenable(promise, value);
-        } else {
-          $$$internal$$fulfill(promise, value);
-        }
-      }
-
-      function $$$internal$$publishRejection(promise) {
-        if (promise._onerror) {
-          promise._onerror(promise._result);
-        }
-
-        $$$internal$$publish(promise);
-      }
-
-      function $$$internal$$fulfill(promise, value) {
-        if (promise._state !== $$$internal$$PENDING) { return; }
-
-        promise._result = value;
-        promise._state = $$$internal$$FULFILLED;
-
-        if (promise._subscribers.length === 0) {
-        } else {
-          $$asap$$default($$$internal$$publish, promise);
-        }
-      }
-
-      function $$$internal$$reject(promise, reason) {
-        if (promise._state !== $$$internal$$PENDING) { return; }
-        promise._state = $$$internal$$REJECTED;
-        promise._result = reason;
-
-        $$asap$$default($$$internal$$publishRejection, promise);
-      }
-
-      function $$$internal$$subscribe(parent, child, onFulfillment, onRejection) {
-        var subscribers = parent._subscribers;
-        var length = subscribers.length;
-
-        parent._onerror = null;
-
-        subscribers[length] = child;
-        subscribers[length + $$$internal$$FULFILLED] = onFulfillment;
-        subscribers[length + $$$internal$$REJECTED]  = onRejection;
-
-        if (length === 0 && parent._state) {
-          $$asap$$default($$$internal$$publish, parent);
-        }
-      }
-
-      function $$$internal$$publish(promise) {
-        var subscribers = promise._subscribers;
-        var settled = promise._state;
-
-        if (subscribers.length === 0) { return; }
-
-        var child, callback, detail = promise._result;
-
-        for (var i = 0; i < subscribers.length; i += 3) {
-          child = subscribers[i];
-          callback = subscribers[i + settled];
-
-          if (child) {
-            $$$internal$$invokeCallback(settled, child, callback, detail);
-          } else {
-            callback(detail);
-          }
-        }
-
-        promise._subscribers.length = 0;
-      }
-
-      function $$$internal$$ErrorObject() {
-        this.error = null;
-      }
-
-      var $$$internal$$TRY_CATCH_ERROR = new $$$internal$$ErrorObject();
-
-      function $$$internal$$tryCatch(callback, detail) {
-        try {
-          return callback(detail);
-        } catch(e) {
-          $$$internal$$TRY_CATCH_ERROR.error = e;
-          return $$$internal$$TRY_CATCH_ERROR;
-        }
-      }
-
-      function $$$internal$$invokeCallback(settled, promise, callback, detail) {
-        var hasCallback = $$utils$$isFunction(callback),
-            value, error, succeeded, failed;
-
-        if (hasCallback) {
-          value = $$$internal$$tryCatch(callback, detail);
-
-          if (value === $$$internal$$TRY_CATCH_ERROR) {
-            failed = true;
-            error = value.error;
-            value = null;
-          } else {
-            succeeded = true;
-          }
-
-          if (promise === value) {
-            $$$internal$$reject(promise, $$$internal$$cannotReturnOwn());
-            return;
-          }
-
-        } else {
-          value = detail;
-          succeeded = true;
-        }
-
-        if (promise._state !== $$$internal$$PENDING) {
-          // noop
-        } else if (hasCallback && succeeded) {
-          $$$internal$$resolve(promise, value);
-        } else if (failed) {
-          $$$internal$$reject(promise, error);
-        } else if (settled === $$$internal$$FULFILLED) {
-          $$$internal$$fulfill(promise, value);
-        } else if (settled === $$$internal$$REJECTED) {
-          $$$internal$$reject(promise, value);
-        }
-      }
-
-      function $$$internal$$initializePromise(promise, resolver) {
-        try {
-          resolver(function resolvePromise(value){
-            $$$internal$$resolve(promise, value);
-          }, function rejectPromise(reason) {
-            $$$internal$$reject(promise, reason);
-          });
-        } catch(e) {
-          $$$internal$$reject(promise, e);
-        }
-      }
-
-      function $$$enumerator$$makeSettledResult(state, position, value) {
-        if (state === $$$internal$$FULFILLED) {
-          return {
-            state: 'fulfilled',
-            value: value
-          };
-        } else {
-          return {
-            state: 'rejected',
-            reason: value
-          };
-        }
-      }
-
-      function $$$enumerator$$Enumerator(Constructor, input, abortOnReject, label) {
-        this._instanceConstructor = Constructor;
-        this.promise = new Constructor($$$internal$$noop, label);
-        this._abortOnReject = abortOnReject;
-
-        if (this._validateInput(input)) {
-          this._input     = input;
-          this.length     = input.length;
-          this._remaining = input.length;
-
-          this._init();
-
-          if (this.length === 0) {
-            $$$internal$$fulfill(this.promise, this._result);
-          } else {
-            this.length = this.length || 0;
-            this._enumerate();
-            if (this._remaining === 0) {
-              $$$internal$$fulfill(this.promise, this._result);
-            }
-          }
-        } else {
-          $$$internal$$reject(this.promise, this._validationError());
-        }
-      }
-
-      $$$enumerator$$Enumerator.prototype._validateInput = function(input) {
-        return $$utils$$isArray(input);
-      };
-
-      $$$enumerator$$Enumerator.prototype._validationError = function() {
-        return new Error('Array Methods must be provided an Array');
-      };
-
-      $$$enumerator$$Enumerator.prototype._init = function() {
-        this._result = new Array(this.length);
-      };
-
-      var $$$enumerator$$default = $$$enumerator$$Enumerator;
-
-      $$$enumerator$$Enumerator.prototype._enumerate = function() {
-        var length  = this.length;
-        var promise = this.promise;
-        var input   = this._input;
-
-        for (var i = 0; promise._state === $$$internal$$PENDING && i < length; i++) {
-          this._eachEntry(input[i], i);
-        }
-      };
-
-      $$$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) {
-        var c = this._instanceConstructor;
-        if ($$utils$$isMaybeThenable(entry)) {
-          if (entry.constructor === c && entry._state !== $$$internal$$PENDING) {
-            entry._onerror = null;
-            this._settledAt(entry._state, i, entry._result);
-          } else {
-            this._willSettleAt(c.resolve(entry), i);
-          }
-        } else {
-          this._remaining--;
-          this._result[i] = this._makeResult($$$internal$$FULFILLED, i, entry);
-        }
-      };
-
-      $$$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) {
-        var promise = this.promise;
-
-        if (promise._state === $$$internal$$PENDING) {
-          this._remaining--;
-
-          if (this._abortOnReject && state === $$$internal$$REJECTED) {
-            $$$internal$$reject(promise, value);
-          } else {
-            this._result[i] = this._makeResult(state, i, value);
-          }
-        }
-
-        if (this._remaining === 0) {
-          $$$internal$$fulfill(promise, this._result);
-        }
-      };
-
-      $$$enumerator$$Enumerator.prototype._makeResult = function(state, i, value) {
-        return value;
-      };
-
-      $$$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) {
-        var enumerator = this;
-
-        $$$internal$$subscribe(promise, undefined, function(value) {
-          enumerator._settledAt($$$internal$$FULFILLED, i, value);
-        }, function(reason) {
-          enumerator._settledAt($$$internal$$REJECTED, i, reason);
-        });
-      };
-
-      var $$promise$all$$default = function all(entries, label) {
-        return new $$$enumerator$$default(this, entries, true /* abort on reject */, label).promise;
-      };
-
-      var $$promise$race$$default = function race(entries, label) {
-        /*jshint validthis:true */
-        var Constructor = this;
-
-        var promise = new Constructor($$$internal$$noop, label);
-
-        if (!$$utils$$isArray(entries)) {
-          $$$internal$$reject(promise, new TypeError('You must pass an array to race.'));
-          return promise;
-        }
-
-        var length = entries.length;
-
-        function onFulfillment(value) {
-          $$$internal$$resolve(promise, value);
-        }
-
-        function onRejection(reason) {
-          $$$internal$$reject(promise, reason);
-        }
-
-        for (var i = 0; promise._state === $$$internal$$PENDING && i < length; i++) {
-          $$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection);
-        }
-
-        return promise;
-      };
-
-      var $$promise$resolve$$default = function resolve(object, label) {
-        /*jshint validthis:true */
-        var Constructor = this;
-
-        if (object && typeof object === 'object' && object.constructor === Constructor) {
-          return object;
-        }
-
-        var promise = new Constructor($$$internal$$noop, label);
-        $$$internal$$resolve(promise, object);
-        return promise;
-      };
-
-      var $$promise$reject$$default = function reject(reason, label) {
-        /*jshint validthis:true */
-        var Constructor = this;
-        var promise = new Constructor($$$internal$$noop, label);
-        $$$internal$$reject(promise, reason);
-        return promise;
-      };
-
-      var $$es6$promise$promise$$counter = 0;
-
-      function $$es6$promise$promise$$needsResolver() {
-        throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
-      }
-
-      function $$es6$promise$promise$$needsNew() {
-        throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
-      }
-
-      var $$es6$promise$promise$$default = $$es6$promise$promise$$Promise;
-
-      /**
-        Promise objects represent the eventual result of an asynchronous operation. The
-        primary way of interacting with a promise is through its `then` method, which
-        registers callbacks to receive either a promise’s eventual value or the reason
-        why the promise cannot be fulfilled.
-
-        Terminology
-        -----------
-
-        - `promise` is an object or function with a `then` method whose behavior conforms to this specification.
-        - `thenable` is an object or function that defines a `then` method.
-        - `value` is any legal JavaScript value (including undefined, a thenable, or a promise).
-        - `exception` is a value that is thrown using the throw statement.
-        - `reason` is a value that indicates why a promise was rejected.
-        - `settled` the final resting state of a promise, fulfilled or rejected.
-
-        A promise can be in one of three states: pending, fulfilled, or rejected.
-
-        Promises that are fulfilled have a fulfillment value and are in the fulfilled
-        state.  Promises that are rejected have a rejection reason and are in the
-        rejected state.  A fulfillment value is never a thenable.
-
-        Promises can also be said to *resolve* a value.  If this value is also a
-        promise, then the original promise's settled state will match the value's
-        settled state.  So a promise that *resolves* a promise that rejects will
-        itself reject, and a promise that *resolves* a promise that fulfills will
-        itself fulfill.
-
-
-        Basic Usage:
-        ------------
-
-        ```js
-        var promise = new Promise(function(resolve, reject) {
-          // on success
-          resolve(value);
-
-          // on failure
-          reject(reason);
-        });
-
-        promise.then(function(value) {
-          // on fulfillment
-        }, function(reason) {
-          // on rejection
-        });
-        ```
-
-        Advanced Usage:
-        ---------------
-
-        Promises shine when abstracting away asynchronous interactions such as
-        `XMLHttpRequest`s.
-
-        ```js
-        function getJSON(url) {
-          return new Promise(function(resolve, reject){
-            var xhr = new XMLHttpRequest();
-
-            xhr.open('GET', url);
-            xhr.onreadystatechange = handler;
-            xhr.responseType = 'json';
-            xhr.setRequestHeader('Accept', 'application/json');
-            xhr.send();
-
-            function handler() {
-              if (this.readyState === this.DONE) {
-                if (this.status === 200) {
-                  resolve(this.response);
-                } else {
-                  reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']'));
-                }
-              }
-            };
-          });
-        }
-
-        getJSON('/posts.json').then(function(json) {
-          // on fulfillment
-        }, function(reason) {
-          // on rejection
-        });
-        ```
-
-        Unlike callbacks, promises are great composable primitives.
-
-        ```js
-        Promise.all([
-          getJSON('/posts'),
-          getJSON('/comments')
-        ]).then(function(values){
-          values[0] // => postsJSON
-          values[1] // => commentsJSON
-
-          return values;
-        });
-        ```
-
-        @class Promise
-        @param {function} resolver
-        Useful for tooling.
-        @constructor
-      */
-      function $$es6$promise$promise$$Promise(resolver) {
-        this._id = $$es6$promise$promise$$counter++;
-        this._state = undefined;
-        this._result = undefined;
-        this._subscribers = [];
-
-        if ($$$internal$$noop !== resolver) {
-          if (!$$utils$$isFunction(resolver)) {
-            $$es6$promise$promise$$needsResolver();
-          }
-
-          if (!(this instanceof $$es6$promise$promise$$Promise)) {
-            $$es6$promise$promise$$needsNew();
-          }
-
-          $$$internal$$initializePromise(this, resolver);
-        }
-      }
-
-      $$es6$promise$promise$$Promise.all = $$promise$all$$default;
-      $$es6$promise$promise$$Promise.race = $$promise$race$$default;
-      $$es6$promise$promise$$Promise.resolve = $$promise$resolve$$default;
-      $$es6$promise$promise$$Promise.reject = $$promise$reject$$default;
-
-      $$es6$promise$promise$$Promise.prototype = {
-        constructor: $$es6$promise$promise$$Promise,
-
-      /**
-        The primary way of interacting with a promise is through its `then` method,
-        which registers callbacks to receive either a promise's eventual value or the
-        reason why the promise cannot be fulfilled.
-
-        ```js
-        findUser().then(function(user){
-          // user is available
-        }, function(reason){
-          // user is unavailable, and you are given the reason why
-        });
-        ```
-
-        Chaining
-        --------
-
-        The return value of `then` is itself a promise.  This second, 'downstream'
-        promise is resolved with the return value of the first promise's fulfillment
-        or rejection handler, or rejected if the handler throws an exception.
-
-        ```js
-        findUser().then(function (user) {
-          return user.name;
-        }, function (reason) {
-          return 'default name';
-        }).then(function (userName) {
-          // If `findUser` fulfilled, `userName` will be the user's name, otherwise it
-          // will be `'default name'`
-        });
-
-        findUser().then(function (user) {
-          throw new Error('Found user, but still unhappy');
-        }, function (reason) {
-          throw new Error('`findUser` rejected and we're unhappy');
-        }).then(function (value) {
-          // never reached
-        }, function (reason) {
-          // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'.
-          // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'.
-        });
-        ```
-        If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream.
-
-        ```js
-        findUser().then(function (user) {
-          throw new PedagogicalException('Upstream error');
-        }).then(function (value) {
-          // never reached
-        }).then(function (value) {
-          // never reached
-        }, function (reason) {
-          // The `PedgagocialException` is propagated all the way down to here
-        });
-        ```
-
-        Assimilation
-        ------------
-
-        Sometimes the value you want to propagate to a downstream promise can only be
-        retrieved asynchronously. This can be achieved by returning a promise in the
-        fulfillment or rejection handler. The downstream promise will then be pending
-        until the returned promise is settled. This is called *assimilation*.
-
-        ```js
-        findUser().then(function (user) {
-          return findCommentsByAuthor(user);
-        }).then(function (comments) {
-          // The user's comments are now available
-        });
-        ```
-
-        If the assimliated promise rejects, then the downstream promise will also reject.
-
-        ```js
-        findUser().then(function (user) {
-          return findCommentsByAuthor(user);
-        }).then(function (comments) {
-          // If `findCommentsByAuthor` fulfills, we'll have the value here
-        }, function (reason) {
-          // If `findCommentsByAuthor` rejects, we'll have the reason here
-        });
-        ```
-
-        Simple Example
-        --------------
-
-        Synchronous Example
-
-        ```javascript
-        var result;
-
-        try {
-          result = findResult();
-          // success
-        } catch(reason) {
-          // failure
-        }
-        ```
-
-        Errback Example
-
-        ```js
-        findResult(function(result, err){
-          if (err) {
-            // failure
-          } else {
-            // success
-          }
-        });
-        ```
-
-        Promise Example;
-
-        ```javascript
-        findResult().then(function(result){
-          // success
-        }, function(reason){
-          // failure
-        });
-        ```
-
-        Advanced Example
-        --------------
-
-        Synchronous Example
-
-        ```javascript
-        var author, books;
-
-        try {
-          author = findAuthor();
-          books  = findBooksByAuthor(author);
-          // success
-        } catch(reason) {
-          // failure
-        }
-        ```
-
-        Errback Example
-
-        ```js
-
-        function foundBooks(books) {
-
-        }
-
-        function failure(reason) {
-
-        }
-
-        findAuthor(function(author, err){
-          if (err) {
-            failure(err);
-            // failure
-          } else {
-            try {
-              findBoooksByAuthor(author, function(books, err) {
-                if (err) {
-                  failure(err);
-                } else {
-                  try {
-                    foundBooks(books);
-                  } catch(reason) {
-                    failure(reason);
-                  }
-                }
-              });
-            } catch(error) {
-              failure(err);
-            }
-            // success
-          }
-        });
-        ```
-
-        Promise Example;
-
-        ```javascript
-        findAuthor().
-          then(findBooksByAuthor).
-          then(function(books){
-            // found books
-        }).catch(function(reason){
-          // something went wrong
-        });
-        ```
-
-        @method then
-        @param {Function} onFulfilled
-        @param {Function} onRejected
-        Useful for tooling.
-        @return {Promise}
-      */
-        then: function(onFulfillment, onRejection) {
-          var parent = this;
-          var state = parent._state;
-
-          if (state === $$$internal$$FULFILLED && !onFulfillment || state === $$$internal$$REJECTED && !onRejection) {
-            return this;
-          }
-
-          var child = new this.constructor($$$internal$$noop);
-          var result = parent._result;
-
-          if (state) {
-            var callback = arguments[state - 1];
-            $$asap$$default(function(){
-              $$$internal$$invokeCallback(state, child, callback, result);
-            });
-          } else {
-            $$$internal$$subscribe(parent, child, onFulfillment, onRejection);
-          }
-
-          return child;
-        },
-
-      /**
-        `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same
-        as the catch block of a try/catch statement.
-
-        ```js
-        function findAuthor(){
-          throw new Error('couldn't find that author');
-        }
-
-        // synchronous
-        try {
-          findAuthor();
-        } catch(reason) {
-          // something went wrong
-        }
-
-        // async with promises
-        findAuthor().catch(function(reason){
-          // something went wrong
-        });
-        ```
-
-        @method catch
-        @param {Function} onRejection
-        Useful for tooling.
-        @return {Promise}
-      */
-        'catch': function(onRejection) {
-          return this.then(null, onRejection);
-        }
-      };
-
-      var $$es6$promise$polyfill$$default = function polyfill() {
-        var local;
-
-        if (typeof global !== 'undefined') {
-          local = global;
-        } else if (typeof window !== 'undefined' && window.document) {
-          local = window;
-        } else {
-          local = self;
-        }
-
-        var es6PromiseSupport =
-          "Promise" in local &&
-          // Some of these methods are missing from
-          // Firefox/Chrome experimental implementations
-          "resolve" in local.Promise &&
-          "reject" in local.Promise &&
-          "all" in local.Promise &&
-          "race" in local.Promise &&
-          // Older version of the spec had a resolver object
-          // as the arg rather than a function
-          (function() {
-            var resolve;
-            new local.Promise(function(r) { resolve = r; });
-            return $$utils$$isFunction(resolve);
-          }());
-
-        if (!es6PromiseSupport) {
-          local.Promise = $$es6$promise$promise$$default;
-        }
-      };
-
-      var es6$promise$umd$$ES6Promise = {
-        'Promise': $$es6$promise$promise$$default,
-        'polyfill': $$es6$promise$polyfill$$default
-      };
-
-      /* global define:true module:true window: true */
-      if ("function" === 'function' && __webpack_require__(16)['amd']) {
-        !(__WEBPACK_AMD_DEFINE_RESULT__ = function() { return es6$promise$umd$$ES6Promise; }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
-      } else if (typeof module !== 'undefined' && module['exports']) {
-        module['exports'] = es6$promise$umd$$ES6Promise;
-      } else if (typeof this !== 'undefined') {
-        this['ES6Promise'] = es6$promise$umd$$ES6Promise;
-      }
-  }).call(this);
-  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(10), (function() { return this; }()), __webpack_require__(17)(module)))
-
-/***/ },
-/* 10 */
-/***/ 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 canMutationObserver = typeof window !== 'undefined'
-      && window.MutationObserver;
-      var canPost = typeof window !== 'undefined'
-      && window.postMessage && window.addEventListener
-      ;
-
-      if (canSetImmediate) {
-          return function (f) { return window.setImmediate(f) };
-      }
-
-      var queue = [];
-
-      if (canMutationObserver) {
-          var hiddenDiv = document.createElement("div");
-          var observer = new MutationObserver(function () {
-              var queueList = queue.slice();
-              queue.length = 0;
-              queueList.forEach(function (fn) {
-                  fn();
-              });
-          });
-
-          observer.observe(hiddenDiv, { attributes: true });
-
-          return function nextTick(fn) {
-              if (!queue.length) {
-                  hiddenDiv.setAttribute('yes', 'no');
-              }
-              queue.push(fn);
-          };
-      }
-
-      if (canPost) {
-          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');
-  };
-
-
-/***/ },
-/* 11 */
-/***/ 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, '+');
-  }
-
-  /**
-   * 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) {
-    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;
-  };
-
-
-/***/ },
-/* 12 */
-/***/ 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');
+      if (secure === true) {
+        cookie.push('secure');
       }
 
       document.cookie = cookie.join('; ');
@@ -1844,8 +795,9 @@ var axios =
     }
   };
 
+
 /***/ },
-/* 13 */
+/* 9 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -1868,7 +820,7 @@ var axios =
   module.exports = function parseHeaders(headers) {
     var parsed = {}, key, val, i;
 
-    if (!headers) return parsed;
+    if (!headers) { return parsed; }
 
     utils.forEach(headers.split('\n'), function(line) {
       i = line.indexOf(':');
@@ -1883,8 +835,9 @@ var axios =
     return parsed;
   };
 
+
 /***/ },
-/* 14 */
+/* 10 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
@@ -1907,16 +860,17 @@ var axios =
     return data;
   };
 
+
 /***/ },
-/* 15 */
+/* 11 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
 
-  var msie = /(msie|trident)/i.test(navigator.userAgent);
   var utils = __webpack_require__(3);
+  var msie = /(msie|trident)/i.test(navigator.userAgent);
   var urlParsingNode = document.createElement('a');
-  var originUrl = urlResolve(window.location.href);
+  var originUrl;
 
   /**
    * Parse a URL to discover it's components
@@ -1944,12 +898,14 @@ var axios =
       hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
       hostname: urlParsingNode.hostname,
       port: urlParsingNode.port,
-      pathname: (urlParsingNode.pathname.charAt(0) === '/')
-        ? urlParsingNode.pathname
-        : '/' + urlParsingNode.pathname
+      pathname: (urlParsingNode.pathname.charAt(0) === '/') ?
+                urlParsingNode.pathname :
+                '/' + urlParsingNode.pathname
     };
   }
 
+  originUrl = urlResolve(window.location.href);
+
   /**
    * Determine if a URL shares the same origin as the current location
    *
@@ -1962,29 +918,100 @@ var axios =
           parsed.host === originUrl.host);
   };
 
+
 /***/ },
-/* 16 */
+/* 12 */
 /***/ function(module, exports, __webpack_require__) {
 
-  module.exports = function() { throw new Error("define cannot be used indirect"); };
+  'use strict';
 
+  var utils = __webpack_require__(3);
 
-/***/ },
-/* 17 */
-/***/ function(module, exports, __webpack_require__) {
+  function InterceptorManager() {
+    this.handlers = [];
+  }
 
-  module.exports = function(module) {
-    if(!module.webpackPolyfill) {
-      module.deprecate = function() {};
-      module.paths = [];
-      // module.parent = undefined by default
-      module.children = [];
-      module.webpackPolyfill = 1;
+  /**
+   * 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 (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 (id) {
+    if (this.handlers[id]) {
+      this.handlers[id] = null;
     }
-    return module;
-  }
+  };
+
+  /**
+   * Iterate over all the registered interceptors
+   *
+   * This method is particularly useful for skipping over any
+   * interceptors that may have become `null` calling `remove`.
+   *
+   * @param {Function} fn The function to call for each interceptor
+   */
+  InterceptorManager.prototype.forEach = function (fn) {
+    utils.forEach(this.handlers, function (h) {
+      if (h !== null) {
+        fn(h);
+      }
+    });
+  };
+
+  module.exports = InterceptorManager;
+
+
+/***/ },
+/* 13 */
+/***/ function(module, exports) {
+
+  'use strict';
+
+  /**
+   * 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);
+    };
+  };
 
 
 /***/ }
 /******/ ])
+});
+;
 //# sourceMappingURL=axios.map