text: exports["Addon"] =
  /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  /******/
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  /******/
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId]) {
  /******/ 			return installedModules[moduleId].exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  /******/
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  /******/
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  /******/
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/
  /******/
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  /******/
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  /******/
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
  /******/ 		}
  /******/ 	};
  /******/
  /******/ 	// define __esModule on exports
  /******/ 	__webpack_require__.r = function(exports) {
  /******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
  /******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
  /******/ 		}
  /******/ 		Object.defineProperty(exports, '__esModule', { value: true });
  /******/ 	};
  /******/
  /******/ 	// create a fake namespace object
  /******/ 	// mode & 1: value is a module id, require it
  /******/ 	// mode & 2: merge all properties of value into the ns
  /******/ 	// mode & 4: return value when already ns object
  /******/ 	// mode & 8|1: behave like require
  /******/ 	__webpack_require__.t = function(value, mode) {
  /******/ 		if(mode & 1) value = __webpack_require__(value);
  /******/ 		if(mode & 8) return value;
  /******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
  /******/ 		var ns = Object.create(null);
  /******/ 		__webpack_require__.r(ns);
  /******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
  /******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
  /******/ 		return ns;
  /******/ 	};
  /******/
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  /******/
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  /******/
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  /******/
  /******/
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 0);
  /******/ })
  /************************************************************************/
  /******/ ([
  /* 0 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _isUndefined2 = __webpack_require__(1);
  
  var _isUndefined3 = _interopRequireDefault(_isUndefined2);
  
  var _isString2 = __webpack_require__(2);
  
  var _isString3 = _interopRequireDefault(_isString2);
  
  var _isPlainObject2 = __webpack_require__(12);
  
  var _isPlainObject3 = _interopRequireDefault(_isPlainObject2);
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  var _jsChannel = __webpack_require__(15);
  
  var _jsChannel2 = _interopRequireDefault(_jsChannel);
  
  var _eventemitter = __webpack_require__(16);
  
  var _eventemitter2 = _interopRequireDefault(_eventemitter);
  
  var _es6Promise = __webpack_require__(17);
  
  var _api = __webpack_require__(20);
  
  var _api2 = _interopRequireDefault(_api);
  
  var _iframeResizerOptions = __webpack_require__(21);
  
  var _iframeResizerOptions2 = _interopRequireDefault(_iframeResizerOptions);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
  
  window.iFrameResizer = {
    heightCalculationMethod: function heightCalculationMethod() {
      var body = document.body;
      var html = document.documentElement;
  
      return Math.max.apply(null, [body.scrollHeight, body.offsetHeight, html.offsetHeight]);
    }
  };
  
  var Addon = function (_EventEmitter) {
    _inherits(Addon, _EventEmitter);
  
    function Addon() {
      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  
      _classCallCheck(this, Addon);
  
      var _this = _possibleConstructorReturn(this, (Addon.__proto__ || Object.getPrototypeOf(Addon)).call(this));
  
      _this.options = options;
      _this.api = new _api2.default(_this);
  
      _this.channel = _jsChannel2.default.build({
        window: options.window || window.parent,
        origin: "*",
        scope: options.id || location.origin,
        postMessageObserver: function postMessageObserver(origin, message) {
          _this.emit("postMessage", origin, message);
        },
        gotMessageObserver: function gotMessageObserver(origin, message) {
          _this.emit("gotMessage", origin, message);
        }
      });
  
      var _arr = ["init", "update", "reload", "_event"];
  
      var _loop = function _loop() {
        var event = _arr[_i];
        _this.channel.bind(event, function (tx, data) {
          var eventName = event,
              eventData = data;
  
          if (event === "_event") {
            eventName = data.eventName;
            eventData = data.eventData;
          }
          _this.emit(eventName, eventData);
  
          return "success";
        });
      };
  
      for (var _i = 0; _i < _arr.length; _i++) {
        _loop();
      }
      return _this;
    }
  
    _createClass(Addon, [{
      key: "request",
      value: function request(params) {
        var _this2 = this;
  
        return new _es6Promise.Promise(function (resolve, reject) {
          if (!(0, _isPlainObject3.default)(params)) throw new Error("Params must be an object");
  
          var method = void 0,
              endpoint = void 0,
              query = void 0,
              body = void 0;
          method = params.method;
          endpoint = params.endpoint;
          query = params.query;
          body = params.body;
  
  
          if (!method || !endpoint || !(0, _isString3.default)(method) || !(0, _isString3.default)(endpoint)) throw new Error("Invalid method or endpoint");
  
          if (!(0, _isUndefined3.default)(query) && !(0, _isPlainObject3.default)(query)) throw new Error("Query must be an object");
  
          if (!(0, _isUndefined3.default)(body) && !(0, _isPlainObject3.default)(body)) throw new Error("Body must be an object");
  
          _this2.channel.call({
            method: "request",
            params: params,
            success: function success(response) {
              resolve(response);
            },
            error: function error(err) {
              reject(err);
            }
          });
        });
      }
    }, {
      key: "saveData",
      value: function saveData(data) {
        var _this3 = this;
  
        return new _es6Promise.Promise(function (resolve, reject) {
          if (!(0, _isPlainObject3.default)(data)) throw new Error("Data must be an object");
  
          _this3.channel.call({
            method: "saveData",
            params: data,
            success: function success() {
              resolve();
            },
            error: function error(err) {
              reject(err);
            }
          });
        });
      }
    }, {
      key: "addTransaction",
      value: function addTransaction(attrs) {
        var _this4 = this;
  
        return new _es6Promise.Promise(function (resolve, reject) {
          if (!(0, _isUndefined3.default)(attrs) && !(0, _isPlainObject3.default)(attrs)) throw new Error("Attrs must be an object");
  
          _this4.channel.call({
            method: "addTransaction",
            params: attrs,
            success: function success(transaction) {
              resolve(transaction);
            },
            error: function error(err) {
              reject(err);
            }
          });
        });
      }
    }, {
      key: "editTransaction",
      value: function editTransaction(id) {
        var _this5 = this;
  
        return new _es6Promise.Promise(function (resolve, reject) {
          if (!id || !(0, _isString3.default)(id)) throw new Error("Invalid id");
  
          _this5.channel.call({
            method: "editTransaction",
            params: id,
            success: function success(transaction) {
              resolve(transaction);
            },
            error: function error(err) {
              reject(err);
            }
          });
        });
      }
    }, {
      key: "addInstitution",
      value: function addInstitution(attrs) {
        var _this6 = this;
  
        return new _es6Promise.Promise(function (resolve, reject) {
          if (!(0, _isUndefined3.default)(attrs) && !(0, _isPlainObject3.default)(attrs)) throw new Error("Attrs must be an object");
  
          _this6.channel.call({
            method: "addInstitution",
            params: attrs,
            success: function success(institution) {
              resolve(institution);
            },
            error: function error(err) {
              reject(err);
            }
          });
        });
      }
    }, {
      key: "downloadDocument",
      value: function downloadDocument(id) {
        var _this7 = this;
  
        return new _es6Promise.Promise(function (resolve, reject) {
          if (!id || !(0, _isString3.default)(id)) throw new Error("Invalid id");
  
          _this7.channel.call({
            method: "downloadDocument",
            params: id,
            success: function success() {
              resolve();
            },
            error: function error(err) {
              reject(err);
            }
          });
        });
      }
    }, {
      key: "upgradePremium",
      value: function upgradePremium() {
        var _this8 = this;
  
        return new _es6Promise.Promise(function (resolve, reject) {
          _this8.channel.call({
            method: "upgradePremium",
            success: function success() {
              resolve();
            },
            error: function error(err) {
              reject(err);
            }
          });
        });
      }
    }, {
      key: "destroy",
      value: function destroy() {
        this.channel.destroy();
      }
    }]);
  
    return Addon;
  }(_eventemitter2.default);
  
  module.exports = Addon;
  
  /***/ }),
  /* 1 */
  /***/ (function(module, exports) {
  
  /**
   * Checks if `value` is `undefined`.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.
   * @example
   *
   * _.isUndefined(void 0);
   * // => true
   *
   * _.isUndefined(null);
   * // => false
   */
  function isUndefined(value) {
    return value === undefined;
  }
  
  module.exports = isUndefined;
  
  
  /***/ }),
  /* 2 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var baseGetTag = __webpack_require__(3),
      isArray = __webpack_require__(10),
      isObjectLike = __webpack_require__(11);
  
  /** `Object#toString` result references. */
  var stringTag = '[object String]';
  
  /**
   * Checks if `value` is classified as a `String` primitive or object.
   *
   * @static
   * @since 0.1.0
   * @memberOf _
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a string, else `false`.
   * @example
   *
   * _.isString('abc');
   * // => true
   *
   * _.isString(1);
   * // => false
   */
  function isString(value) {
    return typeof value == 'string' ||
      (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);
  }
  
  module.exports = isString;
  
  
  /***/ }),
  /* 3 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var Symbol = __webpack_require__(4),
      getRawTag = __webpack_require__(8),
      objectToString = __webpack_require__(9);
  
  /** `Object#toString` result references. */
  var nullTag = '[object Null]',
      undefinedTag = '[object Undefined]';
  
  /** Built-in value references. */
  var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
  
  /**
   * The base implementation of `getTag` without fallbacks for buggy environments.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the `toStringTag`.
   */
  function baseGetTag(value) {
    if (value == null) {
      return value === undefined ? undefinedTag : nullTag;
    }
    return (symToStringTag && symToStringTag in Object(value))
      ? getRawTag(value)
      : objectToString(value);
  }
  
  module.exports = baseGetTag;
  
  
  /***/ }),
  /* 4 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var root = __webpack_require__(5);
  
  /** Built-in value references. */
  var Symbol = root.Symbol;
  
  module.exports = Symbol;
  
  
  /***/ }),
  /* 5 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var freeGlobal = __webpack_require__(6);
  
  /** Detect free variable `self`. */
  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
  
  /** Used as a reference to the global object. */
  var root = freeGlobal || freeSelf || Function('return this')();
  
  module.exports = root;
  
  
  /***/ }),
  /* 6 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* WEBPACK VAR INJECTION */(function(global) {/** Detect free variable `global` from Node.js. */
  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  
  module.exports = freeGlobal;
  
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(7)))
  
  /***/ }),
  /* 7 */
  /***/ (function(module, exports) {
  
  var g;
  
  // This works in non-strict mode
  g = (function() {
  	return this;
  })();
  
  try {
  	// This works if eval is allowed (see CSP)
  	g = g || new Function("return this")();
  } catch (e) {
  	// This works if the window reference is available
  	if (typeof window === "object") g = window;
  }
  
  // g can still be undefined, but nothing to do about it...
  // We return undefined, instead of nothing here, so it's
  // easier to handle this case. if(!global) { ...}
  
  module.exports = g;
  
  
  /***/ }),
  /* 8 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var Symbol = __webpack_require__(4);
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var nativeObjectToString = objectProto.toString;
  
  /** Built-in value references. */
  var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
  
  /**
   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
   *
   * @private
   * @param {*} value The value to query.
   * @returns {string} Returns the raw `toStringTag`.
   */
  function getRawTag(value) {
    var isOwn = hasOwnProperty.call(value, symToStringTag),
        tag = value[symToStringTag];
  
    try {
      value[symToStringTag] = undefined;
      var unmasked = true;
    } catch (e) {}
  
    var result = nativeObjectToString.call(value);
    if (unmasked) {
      if (isOwn) {
        value[symToStringTag] = tag;
      } else {
        delete value[symToStringTag];
      }
    }
    return result;
  }
  
  module.exports = getRawTag;
  
  
  /***/ }),
  /* 9 */
  /***/ (function(module, exports) {
  
  /** Used for built-in method references. */
  var objectProto = Object.prototype;
  
  /**
   * Used to resolve the
   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
   * of values.
   */
  var nativeObjectToString = objectProto.toString;
  
  /**
   * Converts `value` to a string using `Object.prototype.toString`.
   *
   * @private
   * @param {*} value The value to convert.
   * @returns {string} Returns the converted string.
   */
  function objectToString(value) {
    return nativeObjectToString.call(value);
  }
  
  module.exports = objectToString;
  
  
  /***/ }),
  /* 10 */
  /***/ (function(module, exports) {
  
  /**
   * Checks if `value` is classified as an `Array` object.
   *
   * @static
   * @memberOf _
   * @since 0.1.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
   * @example
   *
   * _.isArray([1, 2, 3]);
   * // => true
   *
   * _.isArray(document.body.children);
   * // => false
   *
   * _.isArray('abc');
   * // => false
   *
   * _.isArray(_.noop);
   * // => false
   */
  var isArray = Array.isArray;
  
  module.exports = isArray;
  
  
  /***/ }),
  /* 11 */
  /***/ (function(module, exports) {
  
  /**
   * Checks if `value` is object-like. A value is object-like if it's not `null`
   * and has a `typeof` result of "object".
   *
   * @static
   * @memberOf _
   * @since 4.0.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
   * @example
   *
   * _.isObjectLike({});
   * // => true
   *
   * _.isObjectLike([1, 2, 3]);
   * // => true
   *
   * _.isObjectLike(_.noop);
   * // => false
   *
   * _.isObjectLike(null);
   * // => false
   */
  function isObjectLike(value) {
    return value != null && typeof value == 'object';
  }
  
  module.exports = isObjectLike;
  
  
  /***/ }),
  /* 12 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var baseGetTag = __webpack_require__(3),
      getPrototype = __webpack_require__(13),
      isObjectLike = __webpack_require__(11);
  
  /** `Object#toString` result references. */
  var objectTag = '[object Object]';
  
  /** Used for built-in method references. */
  var funcProto = Function.prototype,
      objectProto = Object.prototype;
  
  /** Used to resolve the decompiled source of functions. */
  var funcToString = funcProto.toString;
  
  /** Used to check objects for own properties. */
  var hasOwnProperty = objectProto.hasOwnProperty;
  
  /** Used to infer the `Object` constructor. */
  var objectCtorString = funcToString.call(Object);
  
  /**
   * Checks if `value` is a plain object, that is, an object created by the
   * `Object` constructor or one with a `[[Prototype]]` of `null`.
   *
   * @static
   * @memberOf _
   * @since 0.8.0
   * @category Lang
   * @param {*} value The value to check.
   * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
   * @example
   *
   * function Foo() {
   *   this.a = 1;
   * }
   *
   * _.isPlainObject(new Foo);
   * // => false
   *
   * _.isPlainObject([1, 2, 3]);
   * // => false
   *
   * _.isPlainObject({ 'x': 0, 'y': 0 });
   * // => true
   *
   * _.isPlainObject(Object.create(null));
   * // => true
   */
  function isPlainObject(value) {
    if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
      return false;
    }
    var proto = getPrototype(value);
    if (proto === null) {
      return true;
    }
    var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
    return typeof Ctor == 'function' && Ctor instanceof Ctor &&
      funcToString.call(Ctor) == objectCtorString;
  }
  
  module.exports = isPlainObject;
  
  
  /***/ }),
  /* 13 */
  /***/ (function(module, exports, __webpack_require__) {
  
  var overArg = __webpack_require__(14);
  
  /** Built-in value references. */
  var getPrototype = overArg(Object.getPrototypeOf, Object);
  
  module.exports = getPrototype;
  
  
  /***/ }),
  /* 14 */
  /***/ (function(module, exports) {
  
  /**
   * Creates a unary function that invokes `func` with its argument transformed.
   *
   * @private
   * @param {Function} func The function to wrap.
   * @param {Function} transform The argument transform.
   * @returns {Function} Returns the new function.
   */
  function overArg(func, transform) {
    return function(arg) {
      return func(transform(arg));
    };
  }
  
  module.exports = overArg;
  
  
  /***/ }),
  /* 15 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /*
   * js_channel is a very lightweight abstraction on top of
   * postMessage which defines message formats and semantics
   * to support interactions more rich than just message passing
   * js_channel supports:
   *  + query/response - traditional rpc
   *  + query/update/response - incremental async return of results
   *    to a query
   *  + notifications - fire and forget
   *  + error handling
   *
   * js_channel is based heavily on json-rpc, but is focused at the
   * problem of inter-iframe RPC.
   *
   * Message types:
   *  There are 5 types of messages that can flow over this channel,
   *  and you may determine what type of message an object is by
   *  examining its parameters:
   *  1. Requests
   *    + integer id
   *    + string method
   *    + (optional) any params
   *  2. Callback Invocations (or just "Callbacks")
   *    + integer id
   *    + string callback
   *    + (optional) params
   *  3. Error Responses (or just "Errors)
   *    + integer id
   *    + string error
   *    + (optional) string message
   *  4. Responses
   *    + integer id
   *    + (optional) any result
   *  5. Notifications
   *    + string method
   *    + (optional) any params
   */
  
  ;var Channel = (function() {
      "use strict";
  
      // current transaction id, start out at a random *odd* number between 1 and a million
      // There is one current transaction counter id per page, and it's shared between
      // channel instances.  That means of all messages posted from a single javascript
      // evaluation context, we'll never have two with the same id.
      var s_curTranId = Math.floor(Math.random()*1000001);
  
      // no two bound channels in the same javascript evaluation context may have the same origin, scope, and window.
      // futher if two bound channels have the same window and scope, they may not have *overlapping* origins
      // (either one or both support '*').  This restriction allows a single onMessage handler to efficiently
      // route messages based on origin and scope.  The s_boundChans maps origins to scopes, to message
      // handlers.  Request and Notification messages are routed using this table.
      // Finally, channels are inserted into this table when built, and removed when destroyed.
      var s_boundChans = { };
  
      // add a channel to s_boundChans, throwing if a dup exists
      function s_addBoundChan(win, origin, scope, handler) {
          function hasWin(arr) {
              for (var i = 0; i < arr.length; i++) if (arr[i].win === win) return true;
              return false;
          }
  
          // does she exist?
          var exists = false;
  
  
          if (origin === '*') {
              // we must check all other origins, sadly.
              for (var k in s_boundChans) {
                  if (!s_boundChans.hasOwnProperty(k)) continue;
                  if (k === '*') continue;
                  if (typeof s_boundChans[k][scope] === 'object') {
                      exists = hasWin(s_boundChans[k][scope]);
                      if (exists) break;
                  }
              }
          } else {
              // we must check only '*'
              if ((s_boundChans['*'] && s_boundChans['*'][scope])) {
                  exists = hasWin(s_boundChans['*'][scope]);
              }
              if (!exists && s_boundChans[origin] && s_boundChans[origin][scope])
              {
                  exists = hasWin(s_boundChans[origin][scope]);
              }
          }
          if (exists) throw "A channel is already bound to the same window which overlaps with origin '"+ origin +"' and has scope '"+scope+"'";
  
          if (typeof s_boundChans[origin] != 'object') s_boundChans[origin] = { };
          if (typeof s_boundChans[origin][scope] != 'object') s_boundChans[origin][scope] = [ ];
          s_boundChans[origin][scope].push({win: win, handler: handler});
      }
  
      function s_removeBoundChan(win, origin, scope) {
          var arr = s_boundChans[origin][scope];
          for (var i = 0; i < arr.length; i++) {
              if (arr[i].win === win) {
                  arr.splice(i,1);
              }
          }
          if (s_boundChans[origin][scope].length === 0) {
              delete s_boundChans[origin][scope];
          }
      }
  
      function s_isArray(obj) {
          if (Array.isArray) return Array.isArray(obj);
          else {
              return (obj.constructor.toString().indexOf("Array") != -1);
          }
      }
  
      // No two outstanding outbound messages may have the same id, period.  Given that, a single table
      // mapping "transaction ids" to message handlers, allows efficient routing of Callback, Error, and
      // Response messages.  Entries are added to this table when requests are sent, and removed when
      // responses are received.
      var s_transIds = { };
  
      // class singleton onMessage handler
      // this function is registered once and all incoming messages route through here.  This
      // arrangement allows certain efficiencies, message data is only parsed once and dispatch
      // is more efficient, especially for large numbers of simultaneous channels.
      var s_onMessage = function(e) {
          try {
            var m = JSON.parse(e.data);
            if (typeof m !== 'object' || m === null) throw "malformed";
          } catch(e) {
            // just ignore any posted messages that do not consist of valid JSON
            return;
          }
  
          var w = e.source;
          var o = e.origin;
          var s, i, meth;
  
          if (typeof m.method === 'string') {
              var ar = m.method.split('::');
              if (ar.length == 2) {
                  s = ar[0];
                  meth = ar[1];
              } else {
                  meth = m.method;
              }
          }
  
          if (typeof m.id !== 'undefined') i = m.id;
  
          // w is message source window
          // o is message origin
          // m is parsed message
          // s is message scope
          // i is message id (or undefined)
          // meth is unscoped method name
          // ^^ based on these factors we can route the message
  
          // if it has a method it's either a notification or a request,
          // route using s_boundChans
          if (typeof meth === 'string') {
              var delivered = false;
              if (s_boundChans[o] && s_boundChans[o][s]) {
                  for (var j = 0; j < s_boundChans[o][s].length; j++) {
                      if (s_boundChans[o][s][j].win === w) {
                          s_boundChans[o][s][j].handler(o, meth, m);
                          delivered = true;
                          break;
                      }
                  }
              }
  
              if (!delivered && s_boundChans['*'] && s_boundChans['*'][s]) {
                  for (var j = 0; j < s_boundChans['*'][s].length; j++) {
                      if (s_boundChans['*'][s][j].win === w) {
                          s_boundChans['*'][s][j].handler(o, meth, m);
                          break;
                      }
                  }
              }
          }
          // otherwise it must have an id (or be poorly formed
          else if (typeof i != 'undefined') {
              if (s_transIds[i]) s_transIds[i](o, meth, m);
          }
      };
  
      // Setup postMessage event listeners
      if (window.addEventListener) window.addEventListener('message', s_onMessage, false);
      else if(window.attachEvent) window.attachEvent('onmessage', s_onMessage);
  
      /* a messaging channel is constructed from a window and an origin.
       * the channel will assert that all messages received over the
       * channel match the origin
       *
       * Arguments to Channel.build(cfg):
       *
       *   cfg.window - the remote window with which we'll communicate
       *   cfg.origin - the expected origin of the remote window, may be '*'
       *                which matches any origin
       *   cfg.scope  - the 'scope' of messages.  a scope string that is
       *                prepended to message names.  local and remote endpoints
       *                of a single channel must agree upon scope. Scope may
       *                not contain double colons ('::').
       *   cfg.debugOutput - A boolean value.  If true and window.console.log is
       *                a function, then debug strings will be emitted to that
       *                function.
       *   cfg.debugOutput - A boolean value.  If true and window.console.log is
       *                a function, then debug strings will be emitted to that
       *                function.
       *   cfg.postMessageObserver - A function that will be passed two arguments,
       *                an origin and a message.  It will be passed these immediately
       *                before messages are posted.
       *   cfg.gotMessageObserver - A function that will be passed two arguments,
       *                an origin and a message.  It will be passed these arguments
       *                immediately after they pass scope and origin checks, but before
       *                they are processed.
       *   cfg.onReady - A function that will be invoked when a channel becomes "ready",
       *                this occurs once both sides of the channel have been
       *                instantiated and an application level handshake is exchanged.
       *                the onReady function will be passed a single argument which is
       *                the channel object that was returned from build().
       */
      return {
          build: function(cfg) {
              var debug = function(m) {
                  if (cfg.debugOutput && window.console && window.console.log) {
                      // try to stringify, if it doesn't work we'll let javascript's built in toString do its magic
                      try { if (typeof m !== 'string') m = JSON.stringify(m); } catch(e) { }
                      console.log("["+chanId+"] " + m);
                  }
              };
  
              /* browser capabilities check */
              if (!window.postMessage) throw("jschannel cannot run this browser, no postMessage");
              if (!window.JSON || !window.JSON.stringify || ! window.JSON.parse) {
                  throw("jschannel cannot run this browser, no JSON parsing/serialization");
              }
  
              /* basic argument validation */
              if (typeof cfg != 'object') throw("Channel build invoked without a proper object argument");
  
              if (!cfg.window || !cfg.window.postMessage) throw("Channel.build() called without a valid window argument");
  
              /* we'd have to do a little more work to be able to run multiple channels that intercommunicate the same
               * window...  Not sure if we care to support that */
              if (window === cfg.window) throw("target window is same as present window -- not allowed");
  
              // let's require that the client specify an origin.  if we just assume '*' we'll be
              // propagating unsafe practices.  that would be lame.
              var validOrigin = false;
              if (typeof cfg.origin === 'string') {
                  var oMatch;
                  if (cfg.origin === "*") validOrigin = true;
                  // allow valid domains under http and https.  Also, trim paths off otherwise valid origins.
                  else if (null !== (oMatch = cfg.origin.match(/^https?:\/\/(?:[-a-zA-Z0-9_\.])+(?::\d+)?/))) {
                      cfg.origin = oMatch[0].toLowerCase();
                      validOrigin = true;
                  }
              }
  
              if (!validOrigin) throw ("Channel.build() called with an invalid origin");
  
              if (typeof cfg.scope !== 'undefined') {
                  if (typeof cfg.scope !== 'string') throw 'scope, when specified, must be a string';
                  if (cfg.scope.split('::').length > 1) throw "scope may not contain double colons: '::'";
              }
  
              /* private variables */
              // generate a random and psuedo unique id for this channel
              var chanId = (function () {
                  var text = "";
                  var alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
                  for(var i=0; i < 5; i++) text += alpha.charAt(Math.floor(Math.random() * alpha.length));
                  return text;
              })();
  
              // registrations: mapping method names to call objects
              var regTbl = { };
              // current oustanding sent requests
              var outTbl = { };
              // current oustanding received requests
              var inTbl = { };
              // are we ready yet?  when false we will block outbound messages.
              var ready = false;
              var pendingQueue = [ ];
  
              var createTransaction = function(id,origin,callbacks) {
                  var shouldDelayReturn = false;
                  var completed = false;
  
                  return {
                      origin: origin,
                      invoke: function(cbName, v) {
                          // verify in table
                          if (!inTbl[id]) throw "attempting to invoke a callback of a nonexistent transaction: " + id;
                          // verify that the callback name is valid
                          var valid = false;
                          for (var i = 0; i < callbacks.length; i++) if (cbName === callbacks[i]) { valid = true; break; }
                          if (!valid) throw "request supports no such callback '" + cbName + "'";
  
                          // send callback invocation
                          postMessage({ id: id, callback: cbName, params: v});
                      },
                      error: function(error, message) {
                          completed = true;
                          // verify in table
                          if (!inTbl[id]) throw "error called for nonexistent message: " + id;
  
                          // remove transaction from table
                          delete inTbl[id];
  
                          // send error
                          postMessage({ id: id, error: error, message: message });
                      },
                      complete: function(v) {
                          completed = true;
                          // verify in table
                          if (!inTbl[id]) throw "complete called for nonexistent message: " + id;
                          // remove transaction from table
                          delete inTbl[id];
                          // send complete
                          postMessage({ id: id, result: v });
                      },
                      delayReturn: function(delay) {
                          if (typeof delay === 'boolean') {
                              shouldDelayReturn = (delay === true);
                          }
                          return shouldDelayReturn;
                      },
                      completed: function() {
                          return completed;
                      }
                  };
              };
  
              var setTransactionTimeout = function(transId, timeout, method) {
                return window.setTimeout(function() {
                  if (outTbl[transId]) {
                    // XXX: what if client code raises an exception here?
                    var msg = "timeout (" + timeout + "ms) exceeded on method '" + method + "'";
                    (1,outTbl[transId].error)("timeout_error", msg);
                    delete outTbl[transId];
                    delete s_transIds[transId];
                  }
                }, timeout);
              };
  
              var onMessage = function(origin, method, m) {
                  // if an observer was specified at allocation time, invoke it
                  if (typeof cfg.gotMessageObserver === 'function') {
                      // pass observer a clone of the object so that our
                      // manipulations are not visible (i.e. method unscoping).
                      // This is not particularly efficient, but then we expect
                      // that message observers are primarily for debugging anyway.
                      try {
                          cfg.gotMessageObserver(origin, m);
                      } catch (e) {
                          debug("gotMessageObserver() raised an exception: " + e.toString());
                      }
                  }
  
                  // now, what type of message is this?
                  if (m.id && method) {
                      // a request!  do we have a registered handler for this request?
                      if (regTbl[method]) {
                          var trans = createTransaction(m.id, origin, m.callbacks ? m.callbacks : [ ]);
                          inTbl[m.id] = { };
                          try {
                              // callback handling.  we'll magically create functions inside the parameter list for each
                              // callback
                              if (m.callbacks && s_isArray(m.callbacks) && m.callbacks.length > 0) {
                                  for (var i = 0; i < m.callbacks.length; i++) {
                                      var path = m.callbacks[i];
                                      var obj = m.params;
                                      var pathItems = path.split('/');
                                      for (var j = 0; j < pathItems.length - 1; j++) {
                                          var cp = pathItems[j];
                                          if (typeof obj[cp] !== 'object') obj[cp] = { };
                                          obj = obj[cp];
                                      }
                                      obj[pathItems[pathItems.length - 1]] = (function() {
                                          var cbName = path;
                                          return function(params) {
                                              return trans.invoke(cbName, params);
                                          };
                                      })();
                                  }
                              }
                              var resp = regTbl[method](trans, m.params);
                              if (!trans.delayReturn() && !trans.completed()) trans.complete(resp);
                          } catch(e) {
                              // automagic handling of exceptions:
                              var error = "runtime_error";
                              var message = null;
                              // * if it's a string then it gets an error code of 'runtime_error' and string is the message
                              if (typeof e === 'string') {
                                  message = e;
                              } else if (typeof e === 'object') {
                                  // either an array or an object
                                  // * if it's an array of length two, then  array[0] is the code, array[1] is the error message
                                  if (e && s_isArray(e) && e.length == 2) {
                                      error = e[0];
                                      message = e[1];
                                  }
                                  // * if it's an object then we'll look form error and message parameters
                                  else if (typeof e.error === 'string') {
                                      error = e.error;
                                      if (!e.message) message = "";
                                      else if (typeof e.message === 'string') message = e.message;
                                      else e = e.message; // let the stringify/toString message give us a reasonable verbose error string
                                  }
                              }
  
                              // message is *still* null, let's try harder
                              if (message === null) {
                                  try {
                                      message = JSON.stringify(e);
                                      /* On MSIE8, this can result in 'out of memory', which
                                       * leaves message undefined. */
                                      if (typeof(message) == 'undefined')
                                        message = e.toString();
                                  } catch (e2) {
                                      message = e.toString();
                                  }
                              }
  
                              trans.error(error,message);
                          }
                      }
                  } else if (m.id && m.callback) {
                      if (!outTbl[m.id] ||!outTbl[m.id].callbacks || !outTbl[m.id].callbacks[m.callback])
                      {
                          debug("ignoring invalid callback, id:"+m.id+ " (" + m.callback +")");
                      } else {
                          // XXX: what if client code raises an exception here?
                          outTbl[m.id].callbacks[m.callback](m.params);
                      }
                  } else if (m.id) {
                      if (!outTbl[m.id]) {
                          debug("ignoring invalid response: " + m.id);
                      } else {
                          // XXX: what if client code raises an exception here?
                          if (m.error) {
                              (1,outTbl[m.id].error)(m.error, m.message);
                          } else {
                              if (m.result !== undefined) (1,outTbl[m.id].success)(m.result);
                              else (1,outTbl[m.id].success)();
                          }
                          delete outTbl[m.id];
                          delete s_transIds[m.id];
                      }
                  } else if (method) {
                      // tis a notification.
                      if (regTbl[method]) {
                          // yep, there's a handler for that.
                          // transaction has only origin for notifications.
                          regTbl[method]({ origin: origin }, m.params);
                          // if the client throws, we'll just let it bubble out
                          // what can we do?  Also, here we'll ignore return values
                      }
                  }
              };
  
              // now register our bound channel for msg routing
              s_addBoundChan(cfg.window, cfg.origin, ((typeof cfg.scope === 'string') ? cfg.scope : ''), onMessage);
  
              // scope method names based on cfg.scope specified when the Channel was instantiated
              var scopeMethod = function(m) {
                  if (typeof cfg.scope === 'string' && cfg.scope.length) m = [cfg.scope, m].join("::");
                  return m;
              };
  
              // a small wrapper around postmessage whose primary function is to handle the
              // case that clients start sending messages before the other end is "ready"
              var postMessage = function(msg, force) {
                  if (!msg) throw "postMessage called with null message";
  
                  // delay posting if we're not ready yet.
                  var verb = (ready ? "post  " : "queue ");
                  debug(verb + " message: " + JSON.stringify(msg));
                  if (!force && !ready) {
                      pendingQueue.push(msg);
                  } else {
                      if (typeof cfg.postMessageObserver === 'function') {
                          try {
                              cfg.postMessageObserver(cfg.origin, msg);
                          } catch (e) {
                              debug("postMessageObserver() raised an exception: " + e.toString());
                          }
                      }
  
                      cfg.window.postMessage(JSON.stringify(msg), cfg.origin);
                  }
              };
  
              var onReady = function(trans, type) {
                  debug('ready msg received');
                  if (ready) throw "received ready message while in ready state.  help!";
  
                  if (type === 'ping') {
                      chanId += '-R';
                  } else {
                      chanId += '-L';
                  }
  
                  obj.unbind('__ready'); // now this handler isn't needed any more.
                  ready = true;
                  debug('ready msg accepted.');
  
                  if (type === 'ping') {
                      obj.notify({ method: '__ready', params: 'pong' });
                  }
  
                  // flush queue
                  while (pendingQueue.length) {
                      postMessage(pendingQueue.pop());
                  }
  
                  // invoke onReady observer if provided
                  if (typeof cfg.onReady === 'function') cfg.onReady(obj);
              };
  
              var obj = {
                  // tries to unbind a bound message handler.  returns false if not possible
                  unbind: function (method) {
                      if (regTbl[method]) {
                          if (!(delete regTbl[method])) throw ("can't delete method: " + method);
                          return true;
                      }
                      return false;
                  },
                  bind: function (method, cb) {
                      if (!method || typeof method !== 'string') throw "'method' argument to bind must be string";
                      if (!cb || typeof cb !== 'function') throw "callback missing from bind params";
  
                      if (regTbl[method]) throw "method '"+method+"' is already bound!";
                      regTbl[method] = cb;
                      return this;
                  },
                  call: function(m) {
                      if (!m) throw 'missing arguments to call function';
                      if (!m.method || typeof m.method !== 'string') throw "'method' argument to call must be string";
                      if (!m.success || typeof m.success !== 'function') throw "'success' callback missing from call";
  
                      // now it's time to support the 'callback' feature of jschannel.  We'll traverse the argument
                      // object and pick out all of the functions that were passed as arguments.
                      var callbacks = { };
                      var callbackNames = [ ];
                      var seen = [ ];
  
                      var pruneFunctions = function (path, obj) {
                          if (seen.indexOf(obj) >= 0) {
                              throw "params cannot be a recursive data structure"
                          }
                          seen.push(obj);
                         
                          if (typeof obj === 'object') {
                              for (var k in obj) {
                                  if (!obj.hasOwnProperty(k)) continue;
                                  var np = path + (path.length ? '/' : '') + k;
                                  if (typeof obj[k] === 'function') {
                                      callbacks[np] = obj[k];
                                      callbackNames.push(np);
                                      delete obj[k];
                                  } else if (typeof obj[k] === 'object' && obj[k] !== null) {
                                      pruneFunctions(np, obj[k]);
                                  }
                              }
                          }
                      };
                      pruneFunctions("", m.params);
  
                      // build a 'request' message and send it
                      var msg = { id: s_curTranId, method: scopeMethod(m.method), params: m.params };
                      if (callbackNames.length) msg.callbacks = callbackNames;
  
                      if (m.timeout)
                        // XXX: This function returns a timeout ID, but we don't do anything with it.
                        // We might want to keep track of it so we can cancel it using clearTimeout()
                        // when the transaction completes.
                        setTransactionTimeout(s_curTranId, m.timeout, scopeMethod(m.method));
  
                      // insert into the transaction table
                      outTbl[s_curTranId] = { callbacks: callbacks, error: m.error, success: m.success };
                      s_transIds[s_curTranId] = onMessage;
  
                      // increment current id
                      s_curTranId++;
  
                      postMessage(msg);
                  },
                  notify: function(m) {
                      if (!m) throw 'missing arguments to notify function';
                      if (!m.method || typeof m.method !== 'string') throw "'method' argument to notify must be string";
  
                      // no need to go into any transaction table
                      postMessage({ method: scopeMethod(m.method), params: m.params });
                  },
                  destroy: function () {
                      s_removeBoundChan(cfg.window, cfg.origin, ((typeof cfg.scope === 'string') ? cfg.scope : ''));
                      if (window.removeEventListener) window.removeEventListener('message', onMessage, false);
                      else if(window.detachEvent) window.detachEvent('onmessage', onMessage);
                      ready = false;
                      regTbl = { };
                      inTbl = { };
                      outTbl = { };
                      cfg.origin = null;
                      pendingQueue = [ ];
                      debug("channel destroyed");
                      chanId = "";
                  }
              };
  
              obj.bind('__ready', onReady);
              setTimeout(function() {
                  postMessage({ method: scopeMethod('__ready'), params: "ping" }, true);
              }, 0);
  
              return obj;
          }
      };
  })();
  if (true) {
      module.exports = Channel;
  }
  
  
  /***/ }),
  /* 16 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var has = Object.prototype.hasOwnProperty
    , prefix = '~';
  
  /**
   * Constructor to create a storage for our `EE` objects.
   * An `Events` instance is a plain object whose properties are event names.
   *
   * @constructor
   * @private
   */
  function Events() {}
  
  //
  // We try to not inherit from `Object.prototype`. In some engines creating an
  // instance in this way is faster than calling `Object.create(null)` directly.
  // If `Object.create(null)` is not supported we prefix the event names with a
  // character to make sure that the built-in object properties are not
  // overridden or used as an attack vector.
  //
  if (Object.create) {
    Events.prototype = Object.create(null);
  
    //
    // This hack is needed because the `__proto__` property is still inherited in
    // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.
    //
    if (!new Events().__proto__) prefix = false;
  }
  
  /**
   * Representation of a single event listener.
   *
   * @param {Function} fn The listener function.
   * @param {*} context The context to invoke the listener with.
   * @param {Boolean} [once=false] Specify if the listener is a one-time listener.
   * @constructor
   * @private
   */
  function EE(fn, context, once) {
    this.fn = fn;
    this.context = context;
    this.once = once || false;
  }
  
  /**
   * Add a listener for a given event.
   *
   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} context The context to invoke the listener with.
   * @param {Boolean} once Specify if the listener is a one-time listener.
   * @returns {EventEmitter}
   * @private
   */
  function addListener(emitter, event, fn, context, once) {
    if (typeof fn !== 'function') {
      throw new TypeError('The listener must be a function');
    }
  
    var listener = new EE(fn, context || emitter, once)
      , evt = prefix ? prefix + event : event;
  
    if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
    else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
    else emitter._events[evt] = [emitter._events[evt], listener];
  
    return emitter;
  }
  
  /**
   * Clear event by name.
   *
   * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.
   * @param {(String|Symbol)} evt The Event name.
   * @private
   */
  function clearEvent(emitter, evt) {
    if (--emitter._eventsCount === 0) emitter._events = new Events();
    else delete emitter._events[evt];
  }
  
  /**
   * Minimal `EventEmitter` interface that is molded against the Node.js
   * `EventEmitter` interface.
   *
   * @constructor
   * @public
   */
  function EventEmitter() {
    this._events = new Events();
    this._eventsCount = 0;
  }
  
  /**
   * Return an array listing the events for which the emitter has registered
   * listeners.
   *
   * @returns {Array}
   * @public
   */
  EventEmitter.prototype.eventNames = function eventNames() {
    var names = []
      , events
      , name;
  
    if (this._eventsCount === 0) return names;
  
    for (name in (events = this._events)) {
      if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
    }
  
    if (Object.getOwnPropertySymbols) {
      return names.concat(Object.getOwnPropertySymbols(events));
    }
  
    return names;
  };
  
  /**
   * Return the listeners registered for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Array} The registered listeners.
   * @public
   */
  EventEmitter.prototype.listeners = function listeners(event) {
    var evt = prefix ? prefix + event : event
      , handlers = this._events[evt];
  
    if (!handlers) return [];
    if (handlers.fn) return [handlers.fn];
  
    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
      ee[i] = handlers[i].fn;
    }
  
    return ee;
  };
  
  /**
   * Return the number of listeners listening to a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Number} The number of listeners.
   * @public
   */
  EventEmitter.prototype.listenerCount = function listenerCount(event) {
    var evt = prefix ? prefix + event : event
      , listeners = this._events[evt];
  
    if (!listeners) return 0;
    if (listeners.fn) return 1;
    return listeners.length;
  };
  
  /**
   * Calls each of the listeners registered for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @returns {Boolean} `true` if the event had listeners, else `false`.
   * @public
   */
  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
    var evt = prefix ? prefix + event : event;
  
    if (!this._events[evt]) return false;
  
    var listeners = this._events[evt]
      , len = arguments.length
      , args
      , i;
  
    if (listeners.fn) {
      if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);
  
      switch (len) {
        case 1: return listeners.fn.call(listeners.context), true;
        case 2: return listeners.fn.call(listeners.context, a1), true;
        case 3: return listeners.fn.call(listeners.context, a1, a2), true;
        case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;
        case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
        case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
      }
  
      for (i = 1, args = new Array(len -1); i < len; i++) {
        args[i - 1] = arguments[i];
      }
  
      listeners.fn.apply(listeners.context, args);
    } else {
      var length = listeners.length
        , j;
  
      for (i = 0; i < length; i++) {
        if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);
  
        switch (len) {
          case 1: listeners[i].fn.call(listeners[i].context); break;
          case 2: listeners[i].fn.call(listeners[i].context, a1); break;
          case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;
          case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;
          default:
            if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {
              args[j - 1] = arguments[j];
            }
  
            listeners[i].fn.apply(listeners[i].context, args);
        }
      }
    }
  
    return true;
  };
  
  /**
   * Add a listener for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} [context=this] The context to invoke the listener with.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.on = function on(event, fn, context) {
    return addListener(this, event, fn, context, false);
  };
  
  /**
   * Add a one-time listener for a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn The listener function.
   * @param {*} [context=this] The context to invoke the listener with.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.once = function once(event, fn, context) {
    return addListener(this, event, fn, context, true);
  };
  
  /**
   * Remove the listeners of a given event.
   *
   * @param {(String|Symbol)} event The event name.
   * @param {Function} fn Only remove the listeners that match this function.
   * @param {*} context Only remove the listeners that have this context.
   * @param {Boolean} once Only remove one-time listeners.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
    var evt = prefix ? prefix + event : event;
  
    if (!this._events[evt]) return this;
    if (!fn) {
      clearEvent(this, evt);
      return this;
    }
  
    var listeners = this._events[evt];
  
    if (listeners.fn) {
      if (
        listeners.fn === fn &&
        (!once || listeners.once) &&
        (!context || listeners.context === context)
      ) {
        clearEvent(this, evt);
      }
    } else {
      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
        if (
          listeners[i].fn !== fn ||
          (once && !listeners[i].once) ||
          (context && listeners[i].context !== context)
        ) {
          events.push(listeners[i]);
        }
      }
  
      //
      // Reset the array, or remove it completely if we have no more listeners.
      //
      if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
      else clearEvent(this, evt);
    }
  
    return this;
  };
  
  /**
   * Remove all listeners, or those of the specified event.
   *
   * @param {(String|Symbol)} [event] The event name.
   * @returns {EventEmitter} `this`.
   * @public
   */
  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
    var evt;
  
    if (event) {
      evt = prefix ? prefix + event : event;
      if (this._events[evt]) clearEvent(this, evt);
    } else {
      this._events = new Events();
      this._eventsCount = 0;
    }
  
    return this;
  };
  
  //
  // Alias methods names because people roll like that.
  //
  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
  
  //
  // Expose the prefix.
  //
  EventEmitter.prefixed = prefix;
  
  //
  // Allow `EventEmitter` to be imported as module namespace.
  //
  EventEmitter.EventEmitter = EventEmitter;
  
  //
  // Expose the module.
  //
  if (true) {
    module.exports = EventEmitter;
  }
  
  
  /***/ }),
  /* 17 */
  /***/ (function(module, exports, __webpack_require__) {
  
  /* WEBPACK VAR INJECTION */(function(process, global) {var require;/*!
   * @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/stefanpenner/es6-promise/master/LICENSE
   * @version   v4.2.2+97478eb6
   */
  
  (function (global, factory) {
  	 true ? module.exports = factory() :
  	undefined;
  }(this, (function () { 'use strict';
  
  function objectOrFunction(x) {
    var type = typeof x;
    return x !== null && (type === 'object' || type === 'function');
  }
  
  function isFunction(x) {
    return typeof x === 'function';
  }
  
  
  
  var _isArray = void 0;
  if (Array.isArray) {
    _isArray = Array.isArray;
  } else {
    _isArray = function (x) {
      return Object.prototype.toString.call(x) === '[object Array]';
    };
  }
  
  var isArray = _isArray;
  
  var len = 0;
  var vertxNext = void 0;
  var customSchedulerFn = void 0;
  
  var asap = function asap(callback, arg) {
    queue[len] = callback;
    queue[len + 1] = arg;
    len += 2;
    if (len === 2) {
      // If len is 2, 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.
      if (customSchedulerFn) {
        customSchedulerFn(flush);
      } else {
        scheduleFlush();
      }
    }
  };
  
  function setScheduler(scheduleFn) {
    customSchedulerFn = scheduleFn;
  }
  
  function setAsap(asapFn) {
    asap = asapFn;
  }
  
  var browserWindow = typeof window !== 'undefined' ? window : undefined;
  var browserGlobal = browserWindow || {};
  var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver;
  var isNode = typeof self === 'undefined' && typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';
  
  // test for web worker but not in IE10
  var isWorker = typeof Uint8ClampedArray !== 'undefined' && typeof importScripts !== 'undefined' && typeof MessageChannel !== 'undefined';
  
  // node
  function useNextTick() {
    // node version 0.10.x displays a deprecation warning when nextTick is used recursively
    // see https://github.com/cujojs/when/issues/410 for details
    return function () {
      return process.nextTick(flush);
    };
  }
  
  // vertx
  function useVertxTimer() {
    if (typeof vertxNext !== 'undefined') {
      return function () {
        vertxNext(flush);
      };
    }
  
    return useSetTimeout();
  }
  
  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;
    };
  }
  
  // web worker
  function useMessageChannel() {
    var channel = new MessageChannel();
    channel.port1.onmessage = flush;
    return function () {
      return channel.port2.postMessage(0);
    };
  }
  
  function useSetTimeout() {
    // Store setTimeout reference so es6-promise will be unaffected by
    // other code modifying setTimeout (like sinon.useFakeTimers())
    var globalSetTimeout = setTimeout;
    return function () {
      return globalSetTimeout(flush, 1);
    };
  }
  
  var queue = new Array(1000);
  function flush() {
    for (var i = 0; i < len; i += 2) {
      var callback = queue[i];
      var arg = queue[i + 1];
  
      callback(arg);
  
      queue[i] = undefined;
      queue[i + 1] = undefined;
    }
  
    len = 0;
  }
  
  function attemptVertx() {
    try {
      var r = require;
      var vertx = __webpack_require__(19);
      vertxNext = vertx.runOnLoop || vertx.runOnContext;
      return useVertxTimer();
    } catch (e) {
      return useSetTimeout();
    }
  }
  
  var scheduleFlush = void 0;
  // Decide what async method to use to triggering processing of queued callbacks:
  if (isNode) {
    scheduleFlush = useNextTick();
  } else if (BrowserMutationObserver) {
    scheduleFlush = useMutationObserver();
  } else if (isWorker) {
    scheduleFlush = useMessageChannel();
  } else if (browserWindow === undefined && "function" === 'function') {
    scheduleFlush = attemptVertx();
  } else {
    scheduleFlush = useSetTimeout();
  }
  
  function then(onFulfillment, onRejection) {
    var parent = this;
  
    var child = new this.constructor(noop);
  
    if (child[PROMISE_ID] === undefined) {
      makePromise(child);
    }
  
    var _state = parent._state;
  
  
    if (_state) {
      var callback = arguments[_state - 1];
      asap(function () {
        return invokeCallback(_state, child, callback, parent._result);
      });
    } else {
      subscribe(parent, child, onFulfillment, onRejection);
    }
  
    return child;
  }
  
  /**
    `Promise.resolve` returns a promise that will become resolved with the
    passed `value`. It is shorthand for the following:
  
    ```javascript
    let promise = new Promise(function(resolve, reject){
      resolve(1);
    });
  
    promise.then(function(value){
      // value === 1
    });
    ```
  
    Instead of writing the above, your code now simply becomes the following:
  
    ```javascript
    let promise = Promise.resolve(1);
  
    promise.then(function(value){
      // value === 1
    });
    ```
  
    @method resolve
    @static
    @param {Any} value value that the returned promise will be resolved with
    Useful for tooling.
    @return {Promise} a promise that will become fulfilled with the given
    `value`
  */
  function resolve$1(object) {
    /*jshint validthis:true */
    var Constructor = this;
  
    if (object && typeof object === 'object' && object.constructor === Constructor) {
      return object;
    }
  
    var promise = new Constructor(noop);
    resolve(promise, object);
    return promise;
  }
  
  var PROMISE_ID = Math.random().toString(36).substring(16);
  
  function noop() {}
  
  var PENDING = void 0;
  var FULFILLED = 1;
  var REJECTED = 2;
  
  var GET_THEN_ERROR = new ErrorObject();
  
  function selfFulfillment() {
    return new TypeError("You cannot resolve a promise with itself");
  }
  
  function cannotReturnOwn() {
    return new TypeError('A promises callback cannot return that same promise.');
  }
  
  function getThen(promise) {
    try {
      return promise.then;
    } catch (error) {
      GET_THEN_ERROR.error = error;
      return GET_THEN_ERROR;
    }
  }
  
  function tryThen(then$$1, value, fulfillmentHandler, rejectionHandler) {
    try {
      then$$1.call(value, fulfillmentHandler, rejectionHandler);
    } catch (e) {
      return e;
    }
  }
  
  function handleForeignThenable(promise, thenable, then$$1) {
    asap(function (promise) {
      var sealed = false;
      var error = tryThen(then$$1, thenable, function (value) {
        if (sealed) {
          return;
        }
        sealed = true;
        if (thenable !== value) {
          resolve(promise, value);
        } else {
          fulfill(promise, value);
        }
      }, function (reason) {
        if (sealed) {
          return;
        }
        sealed = true;
  
        reject(promise, reason);
      }, 'Settle: ' + (promise._label || ' unknown promise'));
  
      if (!sealed && error) {
        sealed = true;
        reject(promise, error);
      }
    }, promise);
  }
  
  function handleOwnThenable(promise, thenable) {
    if (thenable._state === FULFILLED) {
      fulfill(promise, thenable._result);
    } else if (thenable._state === REJECTED) {
      reject(promise, thenable._result);
    } else {
      subscribe(thenable, undefined, function (value) {
        return resolve(promise, value);
      }, function (reason) {
        return reject(promise, reason);
      });
    }
  }
  
  function handleMaybeThenable(promise, maybeThenable, then$$1) {
    if (maybeThenable.constructor === promise.constructor && then$$1 === then && maybeThenable.constructor.resolve === resolve$1) {
      handleOwnThenable(promise, maybeThenable);
    } else {
      if (then$$1 === GET_THEN_ERROR) {
        reject(promise, GET_THEN_ERROR.error);
        GET_THEN_ERROR.error = null;
      } else if (then$$1 === undefined) {
        fulfill(promise, maybeThenable);
      } else if (isFunction(then$$1)) {
        handleForeignThenable(promise, maybeThenable, then$$1);
      } else {
        fulfill(promise, maybeThenable);
      }
    }
  }
  
  function resolve(promise, value) {
    if (promise === value) {
      reject(promise, selfFulfillment());
    } else if (objectOrFunction(value)) {
      handleMaybeThenable(promise, value, getThen(value));
    } else {
      fulfill(promise, value);
    }
  }
  
  function publishRejection(promise) {
    if (promise._onerror) {
      promise._onerror(promise._result);
    }
  
    publish(promise);
  }
  
  function fulfill(promise, value) {
    if (promise._state !== PENDING) {
      return;
    }
  
    promise._result = value;
    promise._state = FULFILLED;
  
    if (promise._subscribers.length !== 0) {
      asap(publish, promise);
    }
  }
  
  function reject(promise, reason) {
    if (promise._state !== PENDING) {
      return;
    }
    promise._state = REJECTED;
    promise._result = reason;
  
    asap(publishRejection, promise);
  }
  
  function subscribe(parent, child, onFulfillment, onRejection) {
    var _subscribers = parent._subscribers;
    var length = _subscribers.length;
  
  
    parent._onerror = null;
  
    _subscribers[length] = child;
    _subscribers[length + FULFILLED] = onFulfillment;
    _subscribers[length + REJECTED] = onRejection;
  
    if (length === 0 && parent._state) {
      asap(publish, parent);
    }
  }
  
  function publish(promise) {
    var subscribers = promise._subscribers;
    var settled = promise._state;
  
    if (subscribers.length === 0) {
      return;
    }
  
    var child = void 0,
        callback = void 0,
        detail = promise._result;
  
    for (var i = 0; i < subscribers.length; i += 3) {
      child = subscribers[i];
      callback = subscribers[i + settled];
  
      if (child) {
        invokeCallback(settled, child, callback, detail);
      } else {
        callback(detail);
      }
    }
  
    promise._subscribers.length = 0;
  }
  
  function ErrorObject() {
    this.error = null;
  }
  
  var TRY_CATCH_ERROR = new ErrorObject();
  
  function tryCatch(callback, detail) {
    try {
      return callback(detail);
    } catch (e) {
      TRY_CATCH_ERROR.error = e;
      return TRY_CATCH_ERROR;
    }
  }
  
  function invokeCallback(settled, promise, callback, detail) {
    var hasCallback = isFunction(callback),
        value = void 0,
        error = void 0,
        succeeded = void 0,
        failed = void 0;
  
    if (hasCallback) {
      value = tryCatch(callback, detail);
  
      if (value === TRY_CATCH_ERROR) {
        failed = true;
        error = value.error;
        value.error = null;
      } else {
        succeeded = true;
      }
  
      if (promise === value) {
        reject(promise, cannotReturnOwn());
        return;
      }
    } else {
      value = detail;
      succeeded = true;
    }
  
    if (promise._state !== PENDING) {
      // noop
    } else if (hasCallback && succeeded) {
      resolve(promise, value);
    } else if (failed) {
      reject(promise, error);
    } else if (settled === FULFILLED) {
      fulfill(promise, value);
    } else if (settled === REJECTED) {
      reject(promise, value);
    }
  }
  
  function initializePromise(promise, resolver) {
    try {
      resolver(function resolvePromise(value) {
        resolve(promise, value);
      }, function rejectPromise(reason) {
        reject(promise, reason);
      });
    } catch (e) {
      reject(promise, e);
    }
  }
  
  var id = 0;
  function nextId() {
    return id++;
  }
  
  function makePromise(promise) {
    promise[PROMISE_ID] = id++;
    promise._state = undefined;
    promise._result = undefined;
    promise._subscribers = [];
  }
  
  function validationError() {
    return new Error('Array Methods must be provided an Array');
  }
  
  function validationError() {
    return new Error('Array Methods must be provided an Array');
  }
  
  var Enumerator = function () {
    function Enumerator(Constructor, input) {
      this._instanceConstructor = Constructor;
      this.promise = new Constructor(noop);
  
      if (!this.promise[PROMISE_ID]) {
        makePromise(this.promise);
      }
  
      if (isArray(input)) {
        this.length = input.length;
        this._remaining = input.length;
  
        this._result = new Array(this.length);
  
        if (this.length === 0) {
          fulfill(this.promise, this._result);
        } else {
          this.length = this.length || 0;
          this._enumerate(input);
          if (this._remaining === 0) {
            fulfill(this.promise, this._result);
          }
        }
      } else {
        reject(this.promise, validationError());
      }
    }
  
    Enumerator.prototype._enumerate = function _enumerate(input) {
      for (var i = 0; this._state === PENDING && i < input.length; i++) {
        this._eachEntry(input[i], i);
      }
    };
  
    Enumerator.prototype._eachEntry = function _eachEntry(entry, i) {
      var c = this._instanceConstructor;
      var resolve$$1 = c.resolve;
  
  
      if (resolve$$1 === resolve$1) {
        var _then = getThen(entry);
  
        if (_then === then && entry._state !== PENDING) {
          this._settledAt(entry._state, i, entry._result);
        } else if (typeof _then !== 'function') {
          this._remaining--;
          this._result[i] = entry;
        } else if (c === Promise$1) {
          var promise = new c(noop);
          handleMaybeThenable(promise, entry, _then);
          this._willSettleAt(promise, i);
        } else {
          this._willSettleAt(new c(function (resolve$$1) {
            return resolve$$1(entry);
          }), i);
        }
      } else {
        this._willSettleAt(resolve$$1(entry), i);
      }
    };
  
    Enumerator.prototype._settledAt = function _settledAt(state, i, value) {
      var promise = this.promise;
  
  
      if (promise._state === PENDING) {
        this._remaining--;
  
        if (state === REJECTED) {
          reject(promise, value);
        } else {
          this._result[i] = value;
        }
      }
  
      if (this._remaining === 0) {
        fulfill(promise, this._result);
      }
    };
  
    Enumerator.prototype._willSettleAt = function _willSettleAt(promise, i) {
      var enumerator = this;
  
      subscribe(promise, undefined, function (value) {
        return enumerator._settledAt(FULFILLED, i, value);
      }, function (reason) {
        return enumerator._settledAt(REJECTED, i, reason);
      });
    };
  
    return Enumerator;
  }();
  
  /**
    `Promise.all` accepts an array of promises, and returns a new promise which
    is fulfilled with an array of fulfillment values for the passed promises, or
    rejected with the reason of the first passed promise to be rejected. It casts all
    elements of the passed iterable to promises as it runs this algorithm.
  
    Example:
  
    ```javascript
    let promise1 = resolve(1);
    let promise2 = resolve(2);
    let promise3 = resolve(3);
    let promises = [ promise1, promise2, promise3 ];
  
    Promise.all(promises).then(function(array){
      // The array here would be [ 1, 2, 3 ];
    });
    ```
  
    If any of the `promises` given to `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
    let promise1 = resolve(1);
    let promise2 = reject(new Error("2"));
    let promise3 = reject(new Error("3"));
    let promises = [ promise1, promise2, promise3 ];
  
    Promise.all(promises).then(function(array){
      // Code here never runs because there are rejected promises!
    }, function(error) {
      // error.message === "2"
    });
    ```
  
    @method all
    @static
    @param {Array} entries array of promises
    @param {String} label optional string for labeling the promise.
    Useful for tooling.
    @return {Promise} promise that is fulfilled when all `promises` have been
    fulfilled, or rejected if any of them become rejected.
    @static
  */
  function all(entries) {
    return new Enumerator(this, entries).promise;
  }
  
  /**
    `Promise.race` returns a new promise which is settled in the same way as the
    first passed promise to settle.
  
    Example:
  
    ```javascript
    let promise1 = new Promise(function(resolve, reject){
      setTimeout(function(){
        resolve('promise 1');
      }, 200);
    });
  
    let promise2 = new Promise(function(resolve, reject){
      setTimeout(function(){
        resolve('promise 2');
      }, 100);
    });
  
    Promise.race([promise1, promise2]).then(function(result){
      // result === 'promise 2' because it was resolved before promise1
      // was resolved.
    });
    ```
  
    `Promise.race` is deterministic in that only the state of the first
    settled promise matters. For example, even if other promises given to the
    `promises` array argument are resolved, but the first settled promise has
    become rejected before the other promises became fulfilled, the returned
    promise will become rejected:
  
    ```javascript
    let promise1 = new Promise(function(resolve, reject){
      setTimeout(function(){
        resolve('promise 1');
      }, 200);
    });
  
    let promise2 = new Promise(function(resolve, reject){
      setTimeout(function(){
        reject(new Error('promise 2'));
      }, 100);
    });
  
    Promise.race([promise1, promise2]).then(function(result){
      // Code here never runs
    }, function(reason){
      // reason.message === 'promise 2' because promise 2 became rejected before
      // promise 1 became fulfilled
    });
    ```
  
    An example real-world use case is implementing timeouts:
  
    ```javascript
    Promise.race([ajax('foo.json'), timeout(5000)])
    ```
  
    @method race
    @static
    @param {Array} promises array of promises to observe
    Useful for tooling.
    @return {Promise} a promise which settles in the same way as the first passed
    promise to settle.
  */
  function race(entries) {
    /*jshint validthis:true */
    var Constructor = this;
  
    if (!isArray(entries)) {
      return new Constructor(function (_, reject) {
        return reject(new TypeError('You must pass an array to race.'));
      });
    } else {
      return new Constructor(function (resolve, reject) {
        var length = entries.length;
        for (var i = 0; i < length; i++) {
          Constructor.resolve(entries[i]).then(resolve, reject);
        }
      });
    }
  }
  
  /**
    `Promise.reject` returns a promise rejected with the passed `reason`.
    It is shorthand for the following:
  
    ```javascript
    let promise = new 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
    let promise = Promise.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
    @static
    @param {Any} reason value that the returned promise will be rejected with.
    Useful for tooling.
    @return {Promise} a promise rejected with the given `reason`.
  */
  function reject$1(reason) {
    /*jshint validthis:true */
    var Constructor = this;
    var promise = new Constructor(noop);
    reject(promise, reason);
    return promise;
  }
  
  function needsResolver() {
    throw new TypeError('You must pass a resolver function as the first argument to the promise constructor');
  }
  
  function needsNew() {
    throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function.");
  }
  
  /**
    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
    let 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){
        let 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
  */
  
  var Promise$1 = function () {
    function Promise(resolver) {
      this[PROMISE_ID] = nextId();
      this._result = this._state = undefined;
      this._subscribers = [];
  
      if (noop !== resolver) {
        typeof resolver !== 'function' && needsResolver();
        this instanceof Promise ? initializePromise(this, resolver) : needsNew();
      }
    }
  
    /**
    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
    let 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
    let 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}
    */
  
    /**
    `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}
    */
  
  
    Promise.prototype.catch = function _catch(onRejection) {
      return this.then(null, onRejection);
    };
  
    /**
      `finally` will be invoked regardless of the promise's fate just as native
      try/catch/finally behaves
    
      Synchronous example:
    
      ```js
      findAuthor() {
        if (Math.random() > 0.5) {
          throw new Error();
        }
        return new Author();
      }
    
      try {
        return findAuthor(); // succeed or fail
      } catch(error) {
        return findOtherAuther();
      } finally {
        // always runs
        // doesn't affect the return value
      }
      ```
    
      Asynchronous example:
    
      ```js
      findAuthor().catch(function(reason){
        return findOtherAuther();
      }).finally(function(){
        // author was either found, or not
      });
      ```
    
      @method finally
      @param {Function} callback
      @return {Promise}
    */
  
  
    Promise.prototype.finally = function _finally(callback) {
      var promise = this;
      var constructor = promise.constructor;
  
      return promise.then(function (value) {
        return constructor.resolve(callback()).then(function () {
          return value;
        });
      }, function (reason) {
        return constructor.resolve(callback()).then(function () {
          throw reason;
        });
      });
    };
  
    return Promise;
  }();
  
  Promise$1.prototype.then = then;
  Promise$1.all = all;
  Promise$1.race = race;
  Promise$1.resolve = resolve$1;
  Promise$1.reject = reject$1;
  Promise$1._setScheduler = setScheduler;
  Promise$1._setAsap = setAsap;
  Promise$1._asap = asap;
  
  /*global self*/
  function polyfill() {
      var local = void 0;
  
      if (typeof global !== 'undefined') {
          local = global;
      } else if (typeof self !== 'undefined') {
          local = self;
      } else {
          try {
              local = Function('return this')();
          } catch (e) {
              throw new Error('polyfill failed because global object is unavailable in this environment');
          }
      }
  
      var P = local.Promise;
  
      if (P) {
          var promiseToString = null;
          try {
              promiseToString = Object.prototype.toString.call(P.resolve());
          } catch (e) {
              // silently ignored
          }
  
          if (promiseToString === '[object Promise]' && !P.cast) {
              return;
          }
      }
  
      local.Promise = Promise$1;
  }
  
  // Strange compat..
  Promise$1.polyfill = polyfill;
  Promise$1.Promise = Promise$1;
  
  return Promise$1;
  
  })));
  
  
  
  //# sourceMappingURL=es6-promise.map
  
  /* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(18), __webpack_require__(7)))
  
  /***/ }),
  /* 18 */
  /***/ (function(module, exports) {
  
  // shim for using process in browser
  var process = module.exports = {};
  
  // cached from whatever global is present so that test runners that stub it
  // don't break things.  But we need to wrap it in a try catch in case it is
  // wrapped in strict mode code which doesn't define any globals.  It's inside a
  // function because try/catches deoptimize in certain engines.
  
  var cachedSetTimeout;
  var cachedClearTimeout;
  
  function defaultSetTimout() {
      throw new Error('setTimeout has not been defined');
  }
  function defaultClearTimeout () {
      throw new Error('clearTimeout has not been defined');
  }
  (function () {
      try {
          if (typeof setTimeout === 'function') {
              cachedSetTimeout = setTimeout;
          } else {
              cachedSetTimeout = defaultSetTimout;
          }
      } catch (e) {
          cachedSetTimeout = defaultSetTimout;
      }
      try {
          if (typeof clearTimeout === 'function') {
              cachedClearTimeout = clearTimeout;
          } else {
              cachedClearTimeout = defaultClearTimeout;
          }
      } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
      }
  } ())
  function runTimeout(fun) {
      if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
      }
      // if setTimeout wasn't available but was latter defined
      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
      } catch(e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
              return cachedSetTimeout.call(null, fun, 0);
          } catch(e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
              return cachedSetTimeout.call(this, fun, 0);
          }
      }
  
  
  }
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }
  
  
  
  }
  var queue = [];
  var draining = false;
  var currentQueue;
  var queueIndex = -1;
  
  function cleanUpNextTick() {
      if (!draining || !currentQueue) {
          return;
      }
      draining = false;
      if (currentQueue.length) {
          queue = currentQueue.concat(queue);
      } else {
          queueIndex = -1;
      }
      if (queue.length) {
          drainQueue();
      }
  }
  
  function drainQueue() {
      if (draining) {
          return;
      }
      var timeout = runTimeout(cleanUpNextTick);
      draining = true;
  
      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;
      runClearTimeout(timeout);
  }
  
  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) {
          runTimeout(drainQueue);
      }
  };
  
  // 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;
  process.prependListener = noop;
  process.prependOnceListener = noop;
  
  process.listeners = function (name) { return [] }
  
  process.binding = function (name) {
      throw new Error('process.binding is not supported');
  };
  
  process.cwd = function () { return '/' };
  process.chdir = function (dir) {
      throw new Error('process.chdir is not supported');
  };
  process.umask = function() { return 0; };
  
  
  /***/ }),
  /* 19 */
  /***/ (function(module, exports) {
  
  /* (ignored) */
  
  /***/ }),
  /* 20 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
  
  var _es6Promise = __webpack_require__(17);
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  var API = function () {
    function API(addon) {
      _classCallCheck(this, API);
  
      this.addon = addon;
    }
  
    // Assets
  
  
    _createClass(API, [{
      key: 'getAssets',
      value: function getAssets(query) {
        return this.addon.request({
          method: 'GET',
          endpoint: 'assets',
          query: query
        });
      }
  
      // Currencies
  
    }, {
      key: 'getCurrencies',
      value: function getCurrencies(query) {
        return this.addon.request({
          method: 'GET',
          endpoint: 'currencies',
          query: query
        });
      }
  
      // Institutions
  
    }, {
      key: 'getInstitutions',
      value: function getInstitutions(query) {
        return this.addon.request({
          method: 'GET',
          endpoint: 'institutions',
          query: query
        });
      }
    }, {
      key: 'getInstitution',
      value: function getInstitution(id) {
        return this.addon.request({
          method: 'GET',
          endpoint: 'institutions/' + id
        });
      }
    }, {
      key: 'pollInstitution',
      value: function pollInstitution(id, v) {
        return this.addon.request({
          method: 'GET',
          endpoint: 'institutions/' + id + '/poll?v=' + v
        });
      }
    }, {
      key: 'syncInstitution',
      value: function syncInstitution(id) {
        return this.addon.request({
          method: 'POST',
          endpoint: 'institutions/' + id + '/sync'
        });
      }
  
      /**
       * @deprecated Since version 0.0.12. Will be removed in version 0.1.x. Use `addon.addInstitution` instead
       */
  
    }, {
      key: 'addInstitution',
      value: function addInstitution(data) {
        console.warn('DEPRECATED: `addon.api.addInstitution`. Use `addon.addInstitution instead.`');
  
        return this.addon.request({
          method: 'POST',
          endpoint: 'institutions',
          body: data
        });
      }
  
      // liabilities
  
    }, {
      key: 'getLiabilities',
      value: function getLiabilities(query) {
        return this.addon.request({
          method: 'GET',
          endpoint: 'liabilities',
          query: query
        });
      }
  
      // Positions
  
    }, {
      key: 'getPositions',
      value: function getPositions(query) {
        return this.addon.request({
          method: 'GET',
          endpoint: 'positions',
          query: query
        });
      }
  
      // Transactions
  
    }, {
      key: 'getTransactions',
      value: function getTransactions(query) {
        return this.addon.request({
          method: 'GET',
          endpoint: 'transactions',
          query: query
        });
      }
    }, {
      key: 'updateTransaction',
      value: function updateTransaction(id) {
        var body = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
        return this.addon.request({
          method: 'PUT',
          endpoint: 'transactions/' + id,
          body: body
        });
      }
  
      // User
  
    }, {
      key: 'getUser',
      value: function getUser() {
        return this.addon.request({
          method: 'GET',
          endpoint: 'users/me'
        });
      }
    }]);
  
    return API;
  }();
  
  module.exports = API;
  
  /***/ }),
  /* 21 */
  /***/ (function(module, exports, __webpack_require__) {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = {
    heightCalculationMethod: function heightCalculationMethod() {
      var body = document.body;
      var html = document.documentElement;
  
      return Math.max.apply(null, [body.scrollHeight, body.offsetHeight, html.offsetHeight]);
    }
  };
  
  /***/ })
  /******/ ]);