axios_rails 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4dbace6993e18b9590f6161d6a05e5f9d3224bd7
-  data.tar.gz: 6010c861f6ce174c7b61022ccfc274419c77c306
+  metadata.gz: d0fbfbdccbe169763d3d14319a927cc31cc5c461
+  data.tar.gz: e148afdfcd3d93f8aca0a1ca9cf9b36358692658
 SHA512:
-  metadata.gz: 714499c8a2e23eb178e5b3a948ef1b3ee68897c85374d6d667177f6297229078df28e85c8099632c5e887ccd66cf82e52d14ac2d8e7f6d9e8cb3d764b5500316
-  data.tar.gz: 905cfaf1b7a93def915fdbb6f24774196730e0fceeedd33fc61d6947fcb7062e6b9c201a2c481c76ac6c0a6a2496565db951e0617af9621b11ddbe146491dfa7
+  metadata.gz: 2c97361748c4f5d47bda79129c01db8d9be6ad3d02cc7e336a4af5ea4d5bfb1479dc43d85ff47e49226ef65f2fa6733a62cdd6f2070a9b24396e8058cdfd9ac4
+  data.tar.gz: c256ce996c74b6fe9bc02a57cde7dd171482b806454a6d6603414668e3c822cdf260dd670859a42f4baf6358e291636df89d32836574181eea7e698631a7d170

data/app/assets/javascripts/axios.js

@@ -1,3 +1,4 @@
+
 var axios =
 /******/ (function(modules) { // webpackBootstrap
 /******/  // The module cache
@@ -51,9 +52,14 @@ var axios =
 /* 1 */
 /***/ function(module, exports, __webpack_require__) {
 
-  /* WEBPACK VAR INJECTION */(function(process) {var Promise = __webpack_require__(13).Promise;
-  var defaults = __webpack_require__(3);
-  var utils = __webpack_require__(4);
+  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 axios = module.exports = function axios(config) {
     config = utils.merge({
@@ -66,32 +72,20 @@ var axios =
     // 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__(2)(resolve, reject, config);
-        }
-      } catch (e) {
-        reject(e);
-      }
+    // Hook up interceptors middleware
+    var chain = [dispatchRequest, undefined];
+    var promise = Promise.resolve(config);
+
+    axios.interceptors.request.forEach(function (interceptor) {
+      chain.unshift(interceptor.fulfilled, interceptor.rejected);
     });
 
-    function deprecatedMethod(method, instead, docs) {
-      try {
-        console.warn(
-          'DEPRECATED method `' + method + '`.' +
-          (instead ? ' Use `' + instead + '` instead.' : '') +
-          ' This method will be removed in a future release.');
+    axios.interceptors.response.forEach(function (interceptor) {
+      chain.push(interceptor.fulfilled, interceptor.rejected);
+    });
 
-        if (docs) {
-          console.warn('For more information about usage see ' + docs);
-        }
-      } catch (e) {}
+    while (chain.length) {
+      promise = promise.then(chain.shift(), chain.shift());
     }
 
     // Provide alias for success
@@ -124,7 +118,13 @@ var axios =
   axios.all = function (promises) {
     return Promise.all(promises);
   };
-  axios.spread = __webpack_require__(6);
+  axios.spread = __webpack_require__(7);
+
+  // Expose interceptors
+  axios.interceptors = {
+    request: new InterceptorManager(),
+    response: new InterceptorManager()
+  };
 
   // Provide aliases for supported request methods
   createShortMethods('delete', 'get', 'head');
@@ -152,22 +152,16 @@ var axios =
       };
     });
   }
-  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(7)))
 
-/***/ },
-/* 2 */
-/***/ function(module, exports, __webpack_require__) {
 
-  if(typeof undefined === 'undefined') {var e = new Error("Cannot find module \"undefined\""); e.code = 'MODULE_NOT_FOUND'; throw e;}
-  module.exports = undefined;
 
 /***/ },
-/* 3 */
+/* 2 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
 
-  var utils = __webpack_require__(4);
+  var utils = __webpack_require__(3);
 
   var JSON_START = /^\s*(\[|\{[^\{])/;
   var JSON_END = /[\}\]]\s*$/;
@@ -218,7 +212,7 @@ var axios =
   };
 
 /***/ },
-/* 4 */
+/* 3 */
 /***/ function(module, exports, __webpack_require__) {
 
   // utils is a library of generic helper functions non-specific to axios
@@ -245,6 +239,16 @@ var axios =
     return toString.call(val) === '[object ArrayBuffer]';
   }
 
+  /**
+   * Determine if a value is a FormData
+   *
+   * @param {Object} val The value to test
+   * @returns {boolean} True if value is an FormData, otherwise false
+   */
+  function isFormData(val) {
+    return toString.call(val) === '[object FormData]';
+  }
+
   /**
    * Determine if a value is a view on an ArrayBuffer
    *
@@ -411,6 +415,7 @@ var axios =
   module.exports = {
     isArray: isArray,
     isArrayBuffer: isArrayBuffer,
+    isFormData: isFormData,
     isArrayBufferView: isArrayBufferView,
     isString: isString,
     isNumber: isNumber,
@@ -424,17 +429,169 @@ 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 */
 /***/ function(module, exports, __webpack_require__) {
 
-  var defaults = __webpack_require__(3);
-  var utils = __webpack_require__(4);
-  var buildUrl = __webpack_require__(8);
-  var cookies = __webpack_require__(9);
-  var parseHeaders = __webpack_require__(10);
-  var transformData = __webpack_require__(11);
-  var urlIsSameOrigin = __webpack_require__(12);
+  /* 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.
+   *
+   * @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) {
+    return new Promise(function (resolve, reject) {
+      try {
+        // For browsers use XHR adapter
+        if (typeof window !== 'undefined') {
+          __webpack_require__(8)(resolve, reject, config);
+        }
+        // For node use HTTP adapter
+        else if (typeof process !== 'undefined') {
+          __webpack_require__(8)(resolve, reject, config);
+        }
+      } catch (e) {
+        reject(e);
+      }
+    });
+  };
+
+
+  /* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(10)))
+
+/***/ },
+/* 6 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var utils = __webpack_require__(3);
+
+  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 (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;
+    }
+  };
+
+  /**
+   * 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;
+
+
+
+/***/ },
+/* 7 */
+/***/ 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);
+    };
+  };
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+  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);
 
   module.exports = function xhrAdapter(resolve, reject, config) {
     // Transform request data
@@ -451,9 +608,13 @@ var axios =
       config.headers || {}
     );
 
+    if (utils.isFormData(data)) {
+      delete headers['Content-Type']; // Let the browser set it
+    }
+
     // Create the request
     var request = new(XMLHttpRequest || ActiveXObject)('Microsoft.XMLHTTP');
-    request.open(config.method, buildUrl(config.url, config.params), true);
+    request.open(config.method.toUpperCase(), buildUrl(config.url, config.params), true);
 
     // Listen for ready state
     request.onreadystatechange = function () {
@@ -526,131 +687,1097 @@ var axios =
   };
 
 /***/ },
-/* 6 */
+/* 9 */
 /***/ 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}
+  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
    */
-  module.exports = function spread(callback) {
-    return function (arr) {
-      callback.apply(null, arr);
-    };
-  };
-
-/***/ },
-/* 7 */
-/***/ function(module, exports, __webpack_require__) {
 
-  // shim for using process in browser
+  (function() {
+      "use strict";
 
-  var process = module.exports = {};
+      function $$utils$$objectOrFunction(x) {
+        return typeof x === 'function' || (typeof x === 'object' && x !== null);
+      }
 
-  process.nextTick = (function () {
-      var canSetImmediate = typeof window !== 'undefined'
-      && window.setImmediate;
-      var canPost = typeof window !== 'undefined'
-      && window.postMessage && window.addEventListener
-      ;
+      function $$utils$$isFunction(x) {
+        return typeof x === 'function';
+      }
 
-      if (canSetImmediate) {
-          return function (f) { return window.setImmediate(f) };
+      function $$utils$$isMaybeThenable(x) {
+        return typeof x === 'object' && x !== null;
       }
 
-      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);
+      var $$utils$$_isArray;
 
-          return function nextTick(fn) {
-              queue.push(fn);
-              window.postMessage('process-tick', '*');
-          };
+      if (!Array.isArray) {
+        $$utils$$_isArray = function (x) {
+          return Object.prototype.toString.call(x) === '[object Array]';
+        };
+      } else {
+        $$utils$$_isArray = Array.isArray;
       }
 
-      return function nextTick(fn) {
-          setTimeout(fn, 0);
+      var $$utils$$isArray = $$utils$$_isArray;
+      var $$utils$$now = Date.now || function() { return new Date().getTime(); };
+      function $$utils$$F() { }
+
+      var $$utils$$o_create = (Object.create || function (o) {
+        if (arguments.length > 1) {
+          throw new Error('Second argument not supported');
+        }
+        if (typeof o !== 'object') {
+          throw new TypeError('Argument must be an object');
+        }
+        $$utils$$F.prototype = o;
+        return new $$utils$$F();
+      });
+
+      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();
+        }
       };
-  })();
 
-  process.title = 'browser';
-  process.browser = true;
-  process.env = {};
-  process.argv = [];
+      var $$asap$$browserGlobal = (typeof window !== 'undefined') ? window : {};
+      var $$asap$$BrowserMutationObserver = $$asap$$browserGlobal.MutationObserver || $$asap$$browserGlobal.WebKitMutationObserver;
 
-  function noop() {}
+      // test for web worker but not in IE10
+      var $$asap$$isWorker = typeof Uint8ClampedArray !== 'undefined' &&
+        typeof importScripts !== 'undefined' &&
+        typeof MessageChannel !== 'undefined';
 
-  process.on = noop;
-  process.addListener = noop;
-  process.once = noop;
-  process.off = noop;
-  process.removeListener = noop;
-  process.removeAllListeners = noop;
-  process.emit = noop;
+      // node
+      function $$asap$$useNextTick() {
+        return function() {
+          process.nextTick($$asap$$flush);
+        };
+      }
 
-  process.binding = function (name) {
-      throw new Error('process.binding is not supported');
-  }
+      function $$asap$$useMutationObserver() {
+        var iterations = 0;
+        var observer = new $$asap$$BrowserMutationObserver($$asap$$flush);
+        var node = document.createTextNode('');
+        observer.observe(node, { characterData: true });
 
-  // TODO(shtylman)
-  process.cwd = function () { return '/' };
-  process.chdir = function (dir) {
-      throw new Error('process.chdir is not supported');
-  };
+        return function() {
+          node.data = (iterations = ++iterations % 2);
+        };
+      }
 
+      // web worker
+      function $$asap$$useMessageChannel() {
+        var channel = new MessageChannel();
+        channel.port1.onmessage = $$asap$$flush;
+        return function () {
+          channel.port2.postMessage(0);
+        };
+      }
 
-/***/ },
-/* 8 */
-/***/ function(module, exports, __webpack_require__) {
+      function $$asap$$useSetTimeout() {
+        return function() {
+          setTimeout($$asap$$flush, 1);
+        };
+      }
 
-  'use strict';
+      var $$asap$$queue = new Array(1000);
 
-  var utils = __webpack_require__(4);
+      function $$asap$$flush() {
+        for (var i = 0; i < $$asap$$len; i+=2) {
+          var callback = $$asap$$queue[i];
+          var arg = $$asap$$queue[i+1];
 
-  function encode(val) {
-    return encodeURIComponent(val).
-      replace(/%40/gi, '@').
-      replace(/%3A/gi, ':').
-      replace(/%24/g, '$').
-      replace(/%2C/gi, ',').
-      replace(/%20/g, '+');
-  }
+          callback(arg);
 
-  module.exports = function buildUrl(url, params) {
-    if (!params) {
-      return url;
-    }
+          $$asap$$queue[i] = undefined;
+          $$asap$$queue[i+1] = undefined;
+        }
 
-    var parts = [];
+        $$asap$$len = 0;
+      }
 
-    utils.forEach(params, function (val, key) {
-      if (val === null || typeof val === 'undefined') {
-        return;
+      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();
+      }
+
+      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];
@@ -674,13 +1801,14 @@ var axios =
     return url;
   };
 
+
 /***/ },
-/* 9 */
+/* 12 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
 
-  var utils = __webpack_require__(4);
+  var utils = __webpack_require__(3);
 
   module.exports = {
     write: function write(name, value, expires, path, domain, secure) {
@@ -717,12 +1845,12 @@ var axios =
   };
 
 /***/ },
-/* 10 */
+/* 13 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
 
-  var utils = __webpack_require__(4);
+  var utils = __webpack_require__(3);
 
   /**
    * Parse headers into an object
@@ -756,12 +1884,12 @@ var axios =
   };
 
 /***/ },
-/* 11 */
+/* 14 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
 
-  var utils = __webpack_require__(4);
+  var utils = __webpack_require__(3);
 
   /**
    * Transform the data for a request or a response
@@ -780,13 +1908,13 @@ var axios =
   };
 
 /***/ },
-/* 12 */
+/* 15 */
 /***/ function(module, exports, __webpack_require__) {
 
   'use strict';
 
   var msie = /(msie|trident)/i.test(navigator.userAgent);
-  var utils = __webpack_require__(4);
+  var utils = __webpack_require__(3);
   var urlParsingNode = document.createElement('a');
   var originUrl = urlResolve(window.location.href);
 
@@ -834,653 +1962,28 @@ var axios =
           parsed.host === originUrl.host);
   };
 
-/***/ },
-/* 13 */
-/***/ function(module, exports, __webpack_require__) {
-
-  "use strict";
-  var Promise = __webpack_require__(14).Promise;
-  var polyfill = __webpack_require__(15).polyfill;
-  exports.Promise = Promise;
-  exports.polyfill = polyfill;
-
-/***/ },
-/* 14 */
-/***/ function(module, exports, __webpack_require__) {
-
-  "use strict";
-  var config = __webpack_require__(16).config;
-  var configure = __webpack_require__(16).configure;
-  var objectOrFunction = __webpack_require__(17).objectOrFunction;
-  var isFunction = __webpack_require__(17).isFunction;
-  var now = __webpack_require__(17).now;
-  var all = __webpack_require__(18).all;
-  var race = __webpack_require__(19).race;
-  var staticResolve = __webpack_require__(20).resolve;
-  var staticReject = __webpack_require__(21).reject;
-  var asap = __webpack_require__(22).asap;
-
-  var counter = 0;
-
-  config.async = asap; // default async is asap;
-
-  function Promise(resolver) {
-    if (!isFunction(resolver)) {
-      throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
-    }
-
-    if (!(this instanceof Promise)) {
-      throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
-    }
-
-    this._subscribers = [];
-
-    invokeResolver(resolver, this);
-  }
-
-  function invokeResolver(resolver, promise) {
-    function resolvePromise(value) {
-      resolve(promise, value);
-    }
-
-    function rejectPromise(reason) {
-      reject(promise, reason);
-    }
-
-    try {
-      resolver(resolvePromise, rejectPromise);
-    } catch(e) {
-      rejectPromise(e);
-    }
-  }
-
-  function invokeCallback(settled, promise, callback, detail) {
-    var hasCallback = isFunction(callback),
-        value, error, succeeded, failed;
-
-    if (hasCallback) {
-      try {
-        value = callback(detail);
-        succeeded = true;
-      } catch(e) {
-        failed = true;
-        error = e;
-      }
-    } else {
-      value = detail;
-      succeeded = true;
-    }
-
-    if (handleThenable(promise, value)) {
-      return;
-    } else if (hasCallback && succeeded) {
-      resolve(promise, value);
-    } else if (failed) {
-      reject(promise, error);
-    } else if (settled === FULFILLED) {
-      resolve(promise, value);
-    } else if (settled === REJECTED) {
-      reject(promise, value);
-    }
-  }
-
-  var PENDING   = void 0;
-  var SEALED    = 0;
-  var FULFILLED = 1;
-  var REJECTED  = 2;
-
-  function subscribe(parent, child, onFulfillment, onRejection) {
-    var subscribers = parent._subscribers;
-    var length = subscribers.length;
-
-    subscribers[length] = child;
-    subscribers[length + FULFILLED] = onFulfillment;
-    subscribers[length + REJECTED]  = onRejection;
-  }
-
-  function publish(promise, settled) {
-    var child, callback, subscribers = promise._subscribers, detail = promise._detail;
-
-    for (var i = 0; i < subscribers.length; i += 3) {
-      child = subscribers[i];
-      callback = subscribers[i + settled];
-
-      invokeCallback(settled, child, callback, detail);
-    }
-
-    promise._subscribers = null;
-  }
-
-  Promise.prototype = {
-    constructor: Promise,
-
-    _state: undefined,
-    _detail: undefined,
-    _subscribers: undefined,
-
-    then: function(onFulfillment, onRejection) {
-      var promise = this;
-
-      var thenPromise = new this.constructor(function() {});
-
-      if (this._state) {
-        var callbacks = arguments;
-        config.async(function invokePromiseCallback() {
-          invokeCallback(promise._state, thenPromise, callbacks[promise._state - 1], promise._detail);
-        });
-      } else {
-        subscribe(this, thenPromise, onFulfillment, onRejection);
-      }
-
-      return thenPromise;
-    },
-
-    'catch': function(onRejection) {
-      return this.then(null, onRejection);
-    }
-  };
-
-  Promise.all = all;
-  Promise.race = race;
-  Promise.resolve = staticResolve;
-  Promise.reject = staticReject;
-
-  function handleThenable(promise, value) {
-    var then = null,
-    resolved;
-
-    try {
-      if (promise === value) {
-        throw new TypeError("A promises callback cannot return that same promise.");
-      }
-
-      if (objectOrFunction(value)) {
-        then = value.then;
-
-        if (isFunction(then)) {
-          then.call(value, function(val) {
-            if (resolved) { return true; }
-            resolved = true;
-
-            if (value !== val) {
-              resolve(promise, val);
-            } else {
-              fulfill(promise, val);
-            }
-          }, function(val) {
-            if (resolved) { return true; }
-            resolved = true;
-
-            reject(promise, val);
-          });
-
-          return true;
-        }
-      }
-    } catch (error) {
-      if (resolved) { return true; }
-      reject(promise, error);
-      return true;
-    }
-
-    return false;
-  }
-
-  function resolve(promise, value) {
-    if (promise === value) {
-      fulfill(promise, value);
-    } else if (!handleThenable(promise, value)) {
-      fulfill(promise, value);
-    }
-  }
-
-  function fulfill(promise, value) {
-    if (promise._state !== PENDING) { return; }
-    promise._state = SEALED;
-    promise._detail = value;
-
-    config.async(publishFulfillment, promise);
-  }
-
-  function reject(promise, reason) {
-    if (promise._state !== PENDING) { return; }
-    promise._state = SEALED;
-    promise._detail = reason;
-
-    config.async(publishRejection, promise);
-  }
-
-  function publishFulfillment(promise) {
-    publish(promise, promise._state = FULFILLED);
-  }
-
-  function publishRejection(promise) {
-    publish(promise, promise._state = REJECTED);
-  }
-
-  exports.Promise = Promise;
-
-/***/ },
-/* 15 */
-/***/ function(module, exports, __webpack_require__) {
-
-  /* WEBPACK VAR INJECTION */(function(global) {"use strict";
-  /*global self*/
-  var RSVPPromise = __webpack_require__(14).Promise;
-  var isFunction = __webpack_require__(17).isFunction;
-
-  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 isFunction(resolve);
-      }());
-
-    if (!es6PromiseSupport) {
-      local.Promise = RSVPPromise;
-    }
-  }
-
-  exports.polyfill = polyfill;
-  /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))
-
 /***/ },
 /* 16 */
 /***/ function(module, exports, __webpack_require__) {
 
-  "use strict";
-  var config = {
-    instrument: false
-  };
-
-  function configure(name, value) {
-    if (arguments.length === 2) {
-      config[name] = value;
-    } else {
-      return config[name];
-    }
-  }
+  module.exports = function() { throw new Error("define cannot be used indirect"); };
 
-  exports.config = config;
-  exports.configure = configure;
 
 /***/ },
 /* 17 */
 /***/ function(module, exports, __webpack_require__) {
 
-  "use strict";
-  function objectOrFunction(x) {
-    return isFunction(x) || (typeof x === "object" && x !== null);
-  }
-
-  function isFunction(x) {
-    return typeof x === "function";
-  }
-
-  function isArray(x) {
-    return Object.prototype.toString.call(x) === "[object Array]";
-  }
-
-  // Date.now is not available in browsers < IE9
-  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/now#Compatibility
-  var now = Date.now || function() { return new Date().getTime(); };
-
-
-  exports.objectOrFunction = objectOrFunction;
-  exports.isFunction = isFunction;
-  exports.isArray = isArray;
-  exports.now = now;
-
-/***/ },
-/* 18 */
-/***/ function(module, exports, __webpack_require__) {
-
-  "use strict";
-  /* global toString */
-
-  var isArray = __webpack_require__(17).isArray;
-  var isFunction = __webpack_require__(17).isFunction;
-
-  /**
-    Returns a promise that is fulfilled when all the given promises have been
-    fulfilled, or rejected if any of them become rejected. The return promise
-    is fulfilled with an array that gives all the values in the order they were
-    passed in the `promises` array argument.
-
-    Example:
-
-    ```javascript
-    var promise1 = RSVP.resolve(1);
-    var promise2 = RSVP.resolve(2);
-    var promise3 = RSVP.resolve(3);
-    var promises = [ promise1, promise2, promise3 ];
-
-    RSVP.all(promises).then(function(array){
-      // The array here would be [ 1, 2, 3 ];
-    });
-    ```
-
-    If any of the `promises` given to `RSVP.all` are rejected, the first promise
-    that is rejected will be given as an argument to the returned promises's
-    rejection handler. For example:
-
-    Example:
-
-    ```javascript
-    var promise1 = RSVP.resolve(1);
-    var promise2 = RSVP.reject(new Error("2"));
-    var promise3 = RSVP.reject(new Error("3"));
-    var promises = [ promise1, promise2, promise3 ];
-
-    RSVP.all(promises).then(function(array){
-      // Code here never runs because there are rejected promises!
-    }, function(error) {
-      // error.message === "2"
-    });
-    ```
-
-    @method all
-    @for RSVP
-    @param {Array} promises
-    @param {String} label
-    @return {Promise} promise that is fulfilled when all `promises` have been
-    fulfilled, or rejected if any of them become rejected.
-  */
-  function all(promises) {
-    /*jshint validthis:true */
-    var Promise = this;
-
-    if (!isArray(promises)) {
-      throw new TypeError('You must pass an array to all.');
-    }
-
-    return new Promise(function(resolve, reject) {
-      var results = [], remaining = promises.length,
-      promise;
-
-      if (remaining === 0) {
-        resolve([]);
-      }
-
-      function resolver(index) {
-        return function(value) {
-          resolveAll(index, value);
-        };
-      }
-
-      function resolveAll(index, value) {
-        results[index] = value;
-        if (--remaining === 0) {
-          resolve(results);
-        }
-      }
-
-      for (var i = 0; i < promises.length; i++) {
-        promise = promises[i];
-
-        if (promise && isFunction(promise.then)) {
-          promise.then(resolver(i), reject);
-        } else {
-          resolveAll(i, promise);
-        }
-      }
-    });
-  }
-
-  exports.all = all;
-
-/***/ },
-/* 19 */
-/***/ function(module, exports, __webpack_require__) {
-
-  "use strict";
-  /* global toString */
-  var isArray = __webpack_require__(17).isArray;
-
-  /**
-    `RSVP.race` allows you to watch a series of promises and act as soon as the
-    first promise given to the `promises` argument fulfills or rejects.
-
-    Example:
-
-    ```javascript
-    var promise1 = new RSVP.Promise(function(resolve, reject){
-      setTimeout(function(){
-        resolve("promise 1");
-      }, 200);
-    });
-
-    var promise2 = new RSVP.Promise(function(resolve, reject){
-      setTimeout(function(){
-        resolve("promise 2");
-      }, 100);
-    });
-
-    RSVP.race([promise1, promise2]).then(function(result){
-      // result === "promise 2" because it was resolved before promise1
-      // was resolved.
-    });
-    ```
-
-    `RSVP.race` is deterministic in that only the state of the first completed
-    promise matters. For example, even if other promises given to the `promises`
-    array argument are resolved, but the first completed promise has become
-    rejected before the other promises became fulfilled, the returned promise
-    will become rejected:
-
-    ```javascript
-    var promise1 = new RSVP.Promise(function(resolve, reject){
-      setTimeout(function(){
-        resolve("promise 1");
-      }, 200);
-    });
-
-    var promise2 = new RSVP.Promise(function(resolve, reject){
-      setTimeout(function(){
-        reject(new Error("promise 2"));
-      }, 100);
-    });
-
-    RSVP.race([promise1, promise2]).then(function(result){
-      // Code here never runs because there are rejected promises!
-    }, function(reason){
-      // reason.message === "promise2" because promise 2 became rejected before
-      // promise 1 became fulfilled
-    });
-    ```
-
-    @method race
-    @for RSVP
-    @param {Array} promises array of promises to observe
-    @param {String} label optional string for describing the promise returned.
-    Useful for tooling.
-    @return {Promise} a promise that becomes fulfilled with the value the first
-    completed promises is resolved with if the first completed promise was
-    fulfilled, or rejected with the reason that the first completed promise
-    was rejected with.
-  */
-  function race(promises) {
-    /*jshint validthis:true */
-    var Promise = this;
-
-    if (!isArray(promises)) {
-      throw new TypeError('You must pass an array to race.');
-    }
-    return new Promise(function(resolve, reject) {
-      var results = [], promise;
-
-      for (var i = 0; i < promises.length; i++) {
-        promise = promises[i];
-
-        if (promise && typeof promise.then === 'function') {
-          promise.then(resolve, reject);
-        } else {
-          resolve(promise);
-        }
-      }
-    });
-  }
-
-  exports.race = race;
-
-/***/ },
-/* 20 */
-/***/ function(module, exports, __webpack_require__) {
-
-  "use strict";
-  function resolve(value) {
-    /*jshint validthis:true */
-    if (value && typeof value === 'object' && value.constructor === this) {
-      return value;
-    }
-
-    var Promise = this;
-
-    return new Promise(function(resolve) {
-      resolve(value);
-    });
-  }
-
-  exports.resolve = resolve;
-
-/***/ },
-/* 21 */
-/***/ function(module, exports, __webpack_require__) {
-
-  "use strict";
-  /**
-    `RSVP.reject` returns a promise that will become rejected with the passed
-    `reason`. `RSVP.reject` is essentially shorthand for the following:
-
-    ```javascript
-    var promise = new RSVP.Promise(function(resolve, reject){
-      reject(new Error('WHOOPS'));
-    });
-
-    promise.then(function(value){
-      // Code here doesn't run because the promise is rejected!
-    }, function(reason){
-      // reason.message === 'WHOOPS'
-    });
-    ```
-
-    Instead of writing the above, your code now simply becomes the following:
-
-    ```javascript
-    var promise = RSVP.reject(new Error('WHOOPS'));
-
-    promise.then(function(value){
-      // Code here doesn't run because the promise is rejected!
-    }, function(reason){
-      // reason.message === 'WHOOPS'
-    });
-    ```
-
-    @method reject
-    @for RSVP
-    @param {Any} reason value that the returned promise will be rejected with.
-    @param {String} label optional string for identifying the returned promise.
-    Useful for tooling.
-    @return {Promise} a promise that will become rejected with the given
-    `reason`.
-  */
-  function reject(reason) {
-    /*jshint validthis:true */
-    var Promise = this;
-
-    return new Promise(function (resolve, reject) {
-      reject(reason);
-    });
-  }
-
-  exports.reject = reject;
-
-/***/ },
-/* 22 */
-/***/ function(module, exports, __webpack_require__) {
-
-  /* WEBPACK VAR INJECTION */(function(global, process) {"use strict";
-  var browserGlobal = (typeof window !== 'undefined') ? window : {};
-  var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
-  var local = (typeof global !== 'undefined') ? global : (this === undefined? window:this);
-
-  // node
-  function useNextTick() {
-    return function() {
-      process.nextTick(flush);
-    };
-  }
-
-  function useMutationObserver() {
-    var iterations = 0;
-    var observer = new BrowserMutationObserver(flush);
-    var node = document.createTextNode('');
-    observer.observe(node, { characterData: true });
-
-    return function() {
-      node.data = (iterations = ++iterations % 2);
-    };
-  }
-
-  function useSetTimeout() {
-    return function() {
-      local.setTimeout(flush, 1);
-    };
-  }
-
-  var queue = [];
-  function flush() {
-    for (var i = 0; i < queue.length; i++) {
-      var tuple = queue[i];
-      var callback = tuple[0], arg = tuple[1];
-      callback(arg);
-    }
-    queue = [];
-  }
-
-  var scheduleFlush;
-
-  // Decide what async method to use to triggering processing of queued callbacks:
-  if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') {
-    scheduleFlush = useNextTick();
-  } else if (BrowserMutationObserver) {
-    scheduleFlush = useMutationObserver();
-  } else {
-    scheduleFlush = useSetTimeout();
-  }
-
-  function asap(callback, arg) {
-    var length = queue.push([callback, arg]);
-    if (length === 1) {
-      // If length 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.
-      scheduleFlush();
+  module.exports = function(module) {
+    if(!module.webpackPolyfill) {
+      module.deprecate = function() {};
+      module.paths = [];
+      // module.parent = undefined by default
+      module.children = [];
+      module.webpackPolyfill = 1;
     }
+    return module;
   }
 
-  exports.asap = asap;
-  /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(7)))
 
 /***/ }
 /******/ ])