selectly/dist/selectly.js

Build custom, accessible, select menus for React.

/*!
 * Selectly 0.5.0
 * https://github.com/souporserious/selectly
 * Copyright (c) 2017 Selectly Authors
 */
(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("react-aria"), require("react"), require("react-dom"), require("react-measure"), require("tabbable"));
	else if(typeof define === 'function' && define.amd)
		define(["react-aria", "react", "react-dom", "react-measure", "tabbable"], factory);
	else if(typeof exports === 'object')
		exports["Selectly"] = factory(require("react-aria"), require("react"), require("react-dom"), require("react-measure"), require("tabbable"));
	else
		root["Selectly"] = factory(root["ReactARIA"], root["React"], root["ReactDOM"], root["Measure"], root["tabbable"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_1__, __WEBPACK_EXTERNAL_MODULE_3__, __WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_13__, __WEBPACK_EXTERNAL_MODULE_16__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

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

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

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

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

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

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.Option = exports.OptionList = exports.Trigger = exports.Select = exports.utils = undefined;

	var _reactAria = __webpack_require__(1);

	var _Select = __webpack_require__(2);

	var _Select2 = _interopRequireDefault(_Select);

	var _buildOptionsLookup = __webpack_require__(18);

	var _buildOptionsLookup2 = _interopRequireDefault(_buildOptionsLookup);

	var _getCurrentOptions = __webpack_require__(19);

	var _getCurrentOptions2 = _interopRequireDefault(_getCurrentOptions);

	var _getToggledValues = __webpack_require__(20);

	var _getToggledValues2 = _interopRequireDefault(_getToggledValues);

	var _getAllValues = __webpack_require__(21);

	var _getAllValues2 = _interopRequireDefault(_getAllValues);

	var _isOptionSelected = __webpack_require__(22);

	var _isOptionSelected2 = _interopRequireDefault(_isOptionSelected);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	var OptionList = _reactAria.Select.OptionList,
	    Option = _reactAria.Select.Option;
	var utils = exports.utils = {
	  buildOptionsLookup: _buildOptionsLookup2.default,
	  getCurrentOptions: _getCurrentOptions2.default,
	  getToggledValues: _getToggledValues2.default,
	  getAllValues: _getAllValues2.default,
	  isOptionSelected: _isOptionSelected2.default
	};

	exports.Select = _Select2.default;
	exports.Trigger = _reactAria.Trigger;
	exports.OptionList = OptionList;
	exports.Option = Option;

/***/ },
/* 1 */
/***/ function(module, exports) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_1__;

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

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});

	var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

	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 _react = __webpack_require__(3);

	var _react2 = _interopRequireDefault(_react);

	var _reactDom = __webpack_require__(4);

	var _reactDom2 = _interopRequireDefault(_reactDom);

	var _reactAria = __webpack_require__(1);

	var _reactPopper = __webpack_require__(5);

	var _reactMeasure = __webpack_require__(13);

	var _reactMeasure2 = _interopRequireDefault(_reactMeasure);

	var _reactTravel = __webpack_require__(14);

	var _reactTravel2 = _interopRequireDefault(_reactTravel);

	var _tabbable = __webpack_require__(16);

	var _tabbable2 = _interopRequireDefault(_tabbable);

	var _childrenPropType = __webpack_require__(17);

	var _childrenPropType2 = _interopRequireDefault(_childrenPropType);

	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; }

	var SelectManager = _reactAria.Select.Manager;

	var Select = function (_Component) {
	  _inherits(Select, _Component);

	  function Select() {
	    var _ref;

	    var _temp, _this, _ret;

	    _classCallCheck(this, Select);

	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Select.__proto__ || Object.getPrototypeOf(Select)).call.apply(_ref, [this].concat(args))), _this), _this.state = {
	      isOpen: false,
	      width: null,
	      currentOption: {}
	    }, _this._handleMeasure = function (_ref2) {
	      var width = _ref2.width;

	      if (_this.props.autoWidth) {
	        _this.setState({ width: width });
	      }
	    }, _this._handleTrigger = function (firstChild, event) {
	      _this.setState(function (state) {
	        return { isOpen: !state.isOpen };
	      });

	      if (typeof firstChild.props.onTrigger === 'function') {
	        firstChild.props.onTrigger(event);
	      }
	    }, _this._handleTriggerKeyDown = function (firstChild, event) {
	      // determine if we need to move focus to the options menu when pressing tab
	      // while the menu is open
	      if (event.key === 'Tab' && _this.state.isOpen) {
	        // without setTimeout it will focus the second tabbable item, need to figure
	        // out why this is happening
	        setTimeout(function () {
	          var tabbableChildren = (0, _tabbable2.default)((0, _reactDom.findDOMNode)(_this._optionsList));
	          if (tabbableChildren.length) {
	            tabbableChildren[0].focus();
	          } else {
	            _this.setOpen(false);
	          }
	        });
	      }

	      if (typeof firstChild.props.onKeyDown === 'function') {
	        firstChild.props.onKeyDown(event);
	      }
	    }, _temp), _possibleConstructorReturn(_this, _ret);
	  }

	  _createClass(Select, [{
	    key: 'componentWillReceiveProps',
	    value: function componentWillReceiveProps(nextProps) {
	      // if there is an incoming disabled prop we need to make sure the options get closed
	      if (this.props.disabled !== nextProps.disabled && nextProps.disabled === true) {
	        this.setOpen(false);
	      }
	    }
	  }, {
	    key: 'setOpen',
	    value: function setOpen(isOpen) {
	      var cb = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {
	        return null;
	      };

	      this.setState({ isOpen: isOpen }, cb);
	    }
	  }, {
	    key: '_handleRequestClose',
	    value: function _handleRequestClose(secondChild) {
	      this.setOpen(false);

	      if (typeof secondChild.props.onRequestClose === 'function') {
	        secondChild.props.onRequestClose();
	      }
	    }
	  }, {
	    key: '_handleOptionSelection',
	    value: function _handleOptionSelection(secondChild, option, event) {
	      if (!this.props.multiple) {
	        this.setOpen(false);
	      }

	      // fire our own "onChange" when an option has been selected
	      this.props.onChange(option);

	      // store current option for initialFocus
	      this.setState({ currentOption: option });

	      if (typeof secondChild.props.onOptionSelection === 'function') {
	        secondChild.props.onOptionSelection(option, event);
	      }
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _this2 = this;

	      var _props = this.props,
	          autoWidth = _props.autoWidth,
	          renderOverlayTo = _props.renderOverlayTo,
	          placement = _props.placement,
	          children = _props.children;
	      var _state = this.state,
	          isOpen = _state.isOpen,
	          width = _state.width,
	          currentOption = _state.currentOption;

	      var _Children$toArray = _react.Children.toArray(children),
	          _Children$toArray2 = _slicedToArray(_Children$toArray, 2),
	          firstChild = _Children$toArray2[0],
	          secondChild = _Children$toArray2[1];

	      return _react2.default.createElement(
	        SelectManager,
	        null,
	        _react2.default.createElement(
	          _reactPopper.Manager,
	          null,
	          _react2.default.createElement(
	            _reactMeasure2.default,
	            { onMeasure: this._handleMeasure },
	            _react2.default.createElement(
	              _reactPopper.Target,
	              { component: false },
	              (0, _react.cloneElement)(firstChild, {
	                isOpen: isOpen,
	                keybindings: [' '],
	                onTrigger: this._handleTrigger.bind(this, firstChild),
	                onKeyDown: this._handleTriggerKeyDown.bind(this, firstChild)
	              })
	            )
	          ),
	          isOpen && _react2.default.createElement(
	            _reactTravel2.default,
	            { renderTo: renderOverlayTo },
	            _react2.default.createElement(
	              _reactPopper.Popper,
	              {
	                placement: placement,
	                style: { width: width ? width + 'px' : '' }
	              },
	              (0, _react.cloneElement)(secondChild, {
	                ref: function ref(c) {
	                  return _this2._optionsList = c;
	                },
	                initialFocus: currentOption.index,
	                closeOnOutsideClick: true,
	                onOptionSelection: this._handleOptionSelection.bind(this, secondChild),
	                onRequestClose: this._handleRequestClose.bind(this, secondChild)
	              })
	            )
	          )
	        )
	      );
	    }
	  }, {
	    key: 'isOpen',
	    get: function get() {
	      return this.state.isOpen;
	    }
	  }]);

	  return Select;
	}(_react.Component);

	Select.propTypes = {
	  multiple: _react.PropTypes.bool,
	  disabled: _react.PropTypes.bool,
	  autoWidth: _react.PropTypes.bool,
	  placement: _react.PropTypes.any,
	  renderOverlayTo: _react.PropTypes.any,
	  onChange: _react.PropTypes.func,
	  children: _childrenPropType2.default
	};
	Select.defaultProps = {
	  multiple: false,
	  disabled: false,
	  autoWidth: true,
	  onChange: function onChange() {
	    return null;
	  }
	};
	exports.default = Select;
	module.exports = exports['default'];

/***/ },
/* 3 */
/***/ function(module, exports) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_3__;

/***/ },
/* 4 */
/***/ function(module, exports) {

	module.exports = __WEBPACK_EXTERNAL_MODULE_4__;

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

	'use strict';

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports.Arrow = exports.Popper = exports.Target = exports.Manager = undefined;

	var _Manager2 = __webpack_require__(6);

	var _Manager3 = _interopRequireDefault(_Manager2);

	var _Target2 = __webpack_require__(7);

	var _Target3 = _interopRequireDefault(_Target2);

	var _Popper2 = __webpack_require__(8);

	var _Popper3 = _interopRequireDefault(_Popper2);

	var _Arrow2 = __webpack_require__(12);

	var _Arrow3 = _interopRequireDefault(_Arrow2);

	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { default: obj };
	}

	exports.Manager = _Manager3.default;
	exports.Target = _Target3.default;
	exports.Popper = _Popper3.default;
	exports.Arrow = _Arrow3.default;

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

	'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});

	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 _react = __webpack_require__(3);

	var _react2 = _interopRequireDefault(_react);

	var _reactDom = __webpack_require__(4);

	var _reactDom2 = _interopRequireDefault(_reactDom);

	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { default: obj };
	}

	function _objectWithoutProperties(obj, keys) {
	  var target = {};for (var i in obj) {
	    if (keys.indexOf(i) >= 0) continue;if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;target[i] = obj[i];
	  }return target;
	}

	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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
	}

	var Manager = function (_Component) {
	  _inherits(Manager, _Component);

	  function Manager() {
	    var _ref;

	    var _temp, _this, _ret;

	    _classCallCheck(this, Manager);

	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Manager.__proto__ || Object.getPrototypeOf(Manager)).call.apply(_ref, [this].concat(args))), _this), _this._setTargetNode = function (node) {
	      _this._targetNode = node;
	    }, _this._getTargetNode = function () {
	      return _this._targetNode;
	    }, _temp), _possibleConstructorReturn(_this, _ret);
	  }

	  _createClass(Manager, [{
	    key: 'getChildContext',
	    value: function getChildContext() {
	      return {
	        popperManager: {
	          setTargetNode: this._setTargetNode,
	          getTargetNode: this._getTargetNode
	        }
	      };
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          component = _props.component,
	          children = _props.children,
	          restProps = _objectWithoutProperties(_props, ['component', 'children']);

	      if (component) {
	        return (0, _react.createElement)(component, restProps, children);
	      } else {
	        return children;
	      }
	    }
	  }]);

	  return Manager;
	}(_react.Component);

	Manager.childContextTypes = {
	  popperManager: _react.PropTypes.object.isRequired
	};
	Manager.propTypes = {
	  component: _react.PropTypes.any
	};
	Manager.defaultProps = {
	  component: 'div'
	};
	exports.default = Manager;

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

	'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});

	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 _react = __webpack_require__(3);

	var _react2 = _interopRequireDefault(_react);

	var _reactDom = __webpack_require__(4);

	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { default: obj };
	}

	function _objectWithoutProperties(obj, keys) {
	  var target = {};for (var i in obj) {
	    if (keys.indexOf(i) >= 0) continue;if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;target[i] = obj[i];
	  }return target;
	}

	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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
	}

	var Target = function (_Component) {
	  _inherits(Target, _Component);

	  function Target() {
	    _classCallCheck(this, Target);

	    return _possibleConstructorReturn(this, (Target.__proto__ || Object.getPrototypeOf(Target)).apply(this, arguments));
	  }

	  _createClass(Target, [{
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this.context.popperManager.setTargetNode((0, _reactDom.findDOMNode)(this));
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props,
	          component = _props.component,
	          children = _props.children,
	          restProps = _objectWithoutProperties(_props, ['component', 'children']);

	      if (component) {
	        return (0, _react.createElement)(component, restProps, children);
	      } else {
	        return children;
	      }
	    }
	  }]);

	  return Target;
	}(_react.Component);

	Target.contextTypes = {
	  popperManager: _react.PropTypes.object.isRequired
	};
	Target.propTypes = {
	  component: _react.PropTypes.any
	};
	Target.defaultProps = {
	  component: 'div'
	};
	exports.default = Target;

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

	'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});

	var _extends = Object.assign || function (target) {
	  for (var i = 1; i < arguments.length; i++) {
	    var source = arguments[i];for (var key in source) {
	      if (Object.prototype.hasOwnProperty.call(source, key)) {
	        target[key] = source[key];
	      }
	    }
	  }return target;
	};

	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 _react = __webpack_require__(3);

	var _react2 = _interopRequireDefault(_react);

	var _reactDom = __webpack_require__(4);

	var _reactDom2 = _interopRequireDefault(_reactDom);

	var _popper = __webpack_require__(9);

	var _popper2 = _interopRequireDefault(_popper);

	var _lodash = __webpack_require__(10);

	var _lodash2 = _interopRequireDefault(_lodash);

	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { default: obj };
	}

	function _objectWithoutProperties(obj, keys) {
	  var target = {};for (var i in obj) {
	    if (keys.indexOf(i) >= 0) continue;if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;target[i] = obj[i];
	  }return target;
	}

	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 === "undefined" ? "undefined" : _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 === "undefined" ? "undefined" : _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;
	}

	var noop = function noop() {
	  return null;
	};

	var Popper = function (_Component) {
	  _inherits(Popper, _Component);

	  function Popper() {
	    var _ref;

	    var _temp, _this, _ret;

	    _classCallCheck(this, Popper);

	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	      args[_key] = arguments[_key];
	    }

	    return _ret = (_temp = (_this = _possibleConstructorReturn(this, (_ref = Popper.__proto__ || Object.getPrototypeOf(Popper)).call.apply(_ref, [this].concat(args))), _this), _this.state = {}, _this._setArrowNode = function (node) {
	      _this._arrowNode = node;
	    }, _this._getTargetNode = function () {
	      return _this.context.popperManager.getTargetNode();
	    }, _this._updateStateModifier = {
	      enabled: true,
	      order: 900,
	      function: function _function(data) {
	        if (_this.state.data && !(0, _lodash2.default)(data.offsets, _this.state.data.offsets) || !_this.state.data) {
	          _this.setState({ data: data });
	        }
	      }
	    }, _this._getPopperStyle = function () {
	      var data = _this.state.data;

	      // If Popper isn't instantiated, hide the popperElement
	      // to avoid flash of unstyled content

	      if (!_this._popper || !data) {
	        return {
	          position: 'absolute',
	          pointerEvents: 'none',
	          opacity: 0
	        };
	      }

	      var _data$offsets$popper = data.offsets.popper,
	          top = _data$offsets$popper.top,
	          left = _data$offsets$popper.left,
	          position = _data$offsets$popper.position;

	      return _extends({
	        position: position,
	        top: 0,
	        left: 0,
	        transform: 'translate3d(' + Math.round(left) + 'px, ' + Math.round(top) + 'px, 0px)',
	        willChange: 'transform'
	      }, data.styles);
	    }, _this._getPopperPlacement = function () {
	      return !!_this.state.data ? _this.state.data.placement : undefined;
	    }, _this._getArrowStyle = function () {
	      if (!_this.state.data || !_this.state.data.offsets.arrow) {
	        return {};
	      } else {
	        var _this$state$data$offs = _this.state.data.offsets.arrow,
	            top = _this$state$data$offs.top,
	            left = _this$state$data$offs.left;

	        if (!left) {
	          return { top: +top };
	        } else {
	          return { left: +left };
	        }
	      }
	    }, _temp), _possibleConstructorReturn(_this, _ret);
	  }

	  _createClass(Popper, [{
	    key: 'getChildContext',
	    value: function getChildContext() {
	      return {
	        popper: {
	          setArrowNode: this._setArrowNode,
	          getArrowStyle: this._getArrowStyle
	        }
	      };
	    }
	  }, {
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this._updatePopper();
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate(lastProps) {
	      if (lastProps.placement !== this.props.placement || lastProps.eventsEnabled !== this.props.eventsEnabled) {
	        this._updatePopper();
	      }
	    }
	  }, {
	    key: 'componentWillUnmount',
	    value: function componentWillUnmount() {
	      this._destroyPopper();
	    }
	  }, {
	    key: '_updatePopper',
	    value: function _updatePopper() {
	      this._destroyPopper();
	      this._createPopper();
	    }
	  }, {
	    key: '_createPopper',
	    value: function _createPopper() {
	      var _props = this.props,
	          placement = _props.placement,
	          eventsEnabled = _props.eventsEnabled;

	      var modifiers = _extends({}, this.props.modifiers, {
	        applyStyle: { enabled: false },
	        updateState: this._updateStateModifier
	      });

	      if (this._arrowNode) {
	        modifiers.arrow = {
	          element: this._arrowNode
	        };
	      }

	      this._popper = new _popper2.default(this._getTargetNode(), (0, _reactDom.findDOMNode)(this), {
	        placement: placement,
	        eventsEnabled: eventsEnabled,
	        modifiers: modifiers
	      });

	      // schedule an update to make sure everything gets positioned correct
	      // after being instantiated
	      this._popper.scheduleUpdate();
	    }
	  }, {
	    key: '_destroyPopper',
	    value: function _destroyPopper() {
	      if (this._popper) {
	        this._popper.destroy();
	      }
	    }
	  }, {
	    key: '_getProps',
	    value: function _getProps() {
	      var _props2 = this.props,
	          component = _props2.component,
	          placement = _props2.placement,
	          eventsEnabled = _props2.eventsEnabled,
	          modifiers = _props2.modifiers,
	          style = _props2.style,
	          children = _props2.children,
	          restProps = _objectWithoutProperties(_props2, ['component', 'placement', 'eventsEnabled', 'modifiers', 'style', 'children']);

	      return _extends({
	        style: _extends({}, this._getPopperStyle(), style),
	        'data-placement': this._getPopperPlacement()
	      }, restProps);
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props3 = this.props,
	          component = _props3.component,
	          children = _props3.children;

	      var props = this._getProps();
	      if (typeof children === 'function') {
	        return children(props);
	      } else {
	        return (0, _react.createElement)(component, props, children);
	      }
	    }
	  }]);

	  return Popper;
	}(_react.Component);

	Popper.contextTypes = {
	  popperManager: _react.PropTypes.object.isRequired
	};
	Popper.childContextTypes = {
	  popper: _react.PropTypes.object.isRequired
	};
	Popper.propTypes = {
	  component: _react.PropTypes.any,
	  placement: _react.PropTypes.oneOf(_popper2.default.placements),
	  eventsEnabled: _react.PropTypes.bool,
	  modifiers: _react.PropTypes.object
	};
	Popper.defaultProps = {
	  component: 'div',
	  placement: 'bottom',
	  eventsEnabled: true,
	  modifiers: {},
	  className: 'popper'
	};
	exports.default = Popper;

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

	var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;'use strict';

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

	/**!
	 * @fileOverview Kickass library to create and place poppers near their reference elements.
	 * @version 1.0.8
	 * @license
	 * Copyright (c) 2016 Federico Zivolo and contributors
	 *
	 * Permission is hereby granted, free of charge, to any person obtaining a copy
	 * of this software and associated documentation files (the "Software"), to deal
	 * in the Software without restriction, including without limitation the rights
	 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	 * copies of the Software, and to permit persons to whom the Software is
	 * furnished to do so, subject to the following conditions:
	 *
	 * The above copyright notice and this permission notice shall be included in all
	 * copies or substantial portions of the Software.
	 *
	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	 * SOFTWARE.
	 */
	(function (global, factory) {
	    ( false ? 'undefined' : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() :  true ? !(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)) : global.Popper = factory();
	})(undefined, function () {
	    'use strict';

	    /**
	     * Returns the offset parent of the given element
	     * @method
	     * @memberof Popper.Utils
	     * @argument {Element} element
	     * @returns {Element} offset parent
	     */

	    function getOffsetParent(element) {
	        // NOTE: 1 DOM access here
	        var offsetParent = element.offsetParent;
	        var nodeName = offsetParent && offsetParent.nodeName;

	        if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
	            return window.document.documentElement;
	        }

	        return offsetParent;
	    }

	    /**
	     * Get CSS computed property of the given element
	     * @method
	     * @memberof Popper.Utils
	     * @argument {Eement} element
	     * @argument {String} property
	     */
	    function getStyleComputedProperty(element, property) {
	        if (element.nodeType !== 1) {
	            return [];
	        }
	        // NOTE: 1 DOM access here
	        var css = window.getComputedStyle(element, null);
	        return property ? css[property] : css;
	    }

	    /**
	     * Returns the parentNode or the host of the element
	     * @method
	     * @memberof Popper.Utils
	     * @argument {Element} element
	     * @returns {Element} parent
	     */
	    function getParentNode(element) {
	        if (element.nodeName === 'HTML') {
	            return element;
	        }
	        return element.parentNode || element.host;
	    }

	    /**
	     * Returns the scrolling parent of the given element
	     * @method
	     * @memberof Popper.Utils
	     * @argument {Element} element
	     * @returns {Element} scroll parent
	     */
	    function getScrollParent(element) {
	        // Return body, `getScroll` will take care to get the correct `scrollTop` from it
	        if (!element || ['HTML', 'BODY', '#document'].indexOf(element.nodeName) !== -1) {
	            return window.document.body;
	        }

	        // Firefox want us to check `-x` and `-y` variations as well

	        var _getStyleComputedProp = getStyleComputedProperty(element),
	            overflow = _getStyleComputedProp.overflow,
	            overflowX = _getStyleComputedProp.overflowX,
	            overflowY = _getStyleComputedProp.overflowY;

	        if (/(auto|scroll)/.test(overflow + overflowY + overflowX)) {
	            return element;
	        }

	        return getScrollParent(getParentNode(element));
	    }

	    /**
	     * Check if the given element is fixed or is inside a fixed parent
	     * @method
	     * @memberof Popper.Utils
	     * @argument {Element} element
	     * @argument {Element} customContainer
	     * @returns {Boolean} answer to "isFixed?"
	     */
	    function isFixed(element) {
	        var nodeName = element.nodeName;
	        if (nodeName === 'BODY' || nodeName === 'HTML') {
	            return false;
	        }
	        if (getStyleComputedProperty(element, 'position') === 'fixed') {
	            return true;
	        }
	        return isFixed(getParentNode(element));
	    }

	    /**
	     * Helper used to get the position which will be applied to the popper
	     * @method
	     * @memberof Popper.Utils
	     * @param {HTMLElement} element - popper element
	     * @returns {String} position
	     */
	    function getPosition(element) {
	        var container = getOffsetParent(element);

	        // Decide if the popper will be fixed
	        // If the reference element is inside a fixed context, the popper will be fixed as well to allow them to scroll together
	        var isParentFixed = isFixed(container);
	        return isParentFixed ? 'fixed' : 'absolute';
	    }

	    /*
	     * Helper to detect borders of a given element
	     * @method
	     * @memberof Popper.Utils
	     * @param {CSSStyleDeclaration} styles - result of `getStyleComputedProperty` on the given element
	     * @param {String} axis - `x` or `y`
	     * @return {Number} borders - the borders size of the given axis
	     */

	    function getBordersSize(styles, axis) {
	        var sideA = axis === 'x' ? 'Left' : 'Top';
	        var sideB = sideA === 'Left' ? 'Right' : 'Bottom';

	        return Number(styles['border' + sideA + 'Width'].split('px')[0]) + Number(styles['border' + sideB + 'Width'].split('px')[0]);
	    }

	    /**
	     * Get bounding client rect of given element
	     * @method
	     * @memberof Popper.Utils
	     * @param {HTMLElement} element
	     * @return {Object} client rect
	     */
	    function getBoundingClientRect(element) {
	        var isIE10 = navigator.appVersion.indexOf('MSIE 10') !== -1;
	        var rect = void 0;

	        // IE10 10 FIX: Please, don't ask, the element isn't
	        // considered in DOM in some circumstances...
	        // This isn't reproducible in IE10 compatibility mode of IE11
	        if (isIE10) {
	            try {
	                rect = element.getBoundingClientRect();
	            } catch (err) {
	                rect = {};
	            }
	        } else {
	            rect = element.getBoundingClientRect();
	        }

	        var result = {
	            left: rect.left,
	            top: rect.top,
	            right: rect.right,
	            bottom: rect.bottom,
	            width: rect.right - rect.left,
	            height: rect.bottom - rect.top
	        };

	        // IE10 FIX: `getBoundingClientRect`, when executed on `documentElement`
	        // will not take in account the `scrollTop` and `scrollLeft`
	        if (element.nodeName === 'HTML' && isIE10) {
	            var _window$document$docu = window.document.documentElement,
	                scrollTop = _window$document$docu.scrollTop,
	                scrollLeft = _window$document$docu.scrollLeft;

	            result.top -= scrollTop;
	            result.bottom -= scrollTop;
	            result.left -= scrollLeft;
	            result.right -= scrollLeft;
	        }

	        // subtract scrollbar size from sizes
	        var horizScrollbar = rect.width - (element.clientWidth || rect.right - rect.left);
	        var vertScrollbar = rect.height - (element.clientHeight || rect.bottom - rect.top);

	        // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
	        // we make this check conditional for performance reasons
	        if (horizScrollbar || vertScrollbar) {
	            var styles = getStyleComputedProperty(element);
	            horizScrollbar -= getBordersSize(styles, 'x');
	            vertScrollbar -= getBordersSize(styles, 'y');
	        }

	        result.right -= horizScrollbar;
	        result.width -= horizScrollbar;
	        result.bottom -= vertScrollbar;
	        result.height -= vertScrollbar;

	        return result;
	    }

	    function getScroll(element) {
	        var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';

	        var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
	        var nodeName = element.nodeName;

	        if (nodeName === 'BODY' || nodeName === 'HTML') {
	            var html = window.document.documentElement;
	            var scrollingElement = window.document.scrollingElement || html;
	            return scrollingElement[upperSide];
	        }

	        return element[upperSide];
	    }

	    /*
	     * Sum or subtract the element scroll values (left and top) from a given rect object
	     * @method
	     * @memberof Popper.Utils
	     * @param {Object} rect - Rect object you want to change
	     * @param {HTMLElement} element - The element from the function reads the scroll values
	     * @param {Boolean} subtract - set to true if you want to subtract the scroll values
	     * @return {Object} rect - The modifier rect object
	     */
	    function includeScroll(rect, element) {
	        var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

	        var scrollTop = getScroll(element, 'top');
	        var scrollLeft = getScroll(element, 'left');
	        var modifier = subtract ? -1 : 1;
	        rect.top += scrollTop * modifier;
	        rect.bottom += scrollTop * modifier;
	        rect.left += scrollLeft * modifier;
	        rect.right += scrollLeft * modifier;
	        return rect;
	    }

	    /**
	     * Given an element and one of its parents, return the offset
	     * @method
	     * @memberof Popper.Utils
	     * @param {HTMLElement} element
	     * @param {HTMLElement} parent
	     * @return {Object} rect
	     */
	    function getOffsetRectRelativeToCustomParent(element, parent) {
	        var fixed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
	        var transformed = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;

	        var scrollParent = getScrollParent(parent);
	        var elementRect = getBoundingClientRect(element);
	        var parentRect = getBoundingClientRect(parent);

	        var rect = {
	            top: elementRect.top - parentRect.top,
	            left: elementRect.left - parentRect.left,
	            bottom: elementRect.top - parentRect.top + elementRect.height,
	            right: elementRect.left - parentRect.left + elementRect.width,
	            width: elementRect.width,
	            height: elementRect.height
	        };

	        if (fixed && !transformed) {
	            rect = includeScroll(rect, scrollParent, true);
	        }
	        // When a popper doesn't have any positioned or scrollable parents, `offsetParent.contains(scrollParent)`
	        // will return a "false positive". This is happening because `getOffsetParent` returns `html` node,
	        // and `scrollParent` is the `body` node. Hence the additional check.
	        else if (getOffsetParent(element).contains(scrollParent) && scrollParent.nodeName !== 'BODY') {
	                rect = includeScroll(rect, parent);
	            }

	        // subtract borderTopWidth and borderTopWidth from final result
	        var styles = getStyleComputedProperty(parent);
	        var borderTopWidth = Number(styles.borderTopWidth.split('px')[0]);
	        var borderLeftWidth = Number(styles.borderLeftWidth.split('px')[0]);

	        rect.top -= borderTopWidth;
	        rect.bottom -= borderTopWidth;
	        rect.left -= borderLeftWidth;
	        rect.right -= borderLeftWidth;

	        return rect;
	    }

	    function getWindowSizes() {
	        var body = window.document.body;
	        var html = window.document.documentElement;
	        return {
	            height: Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight),
	            width: Math.max(body.scrollWidth, body.offsetWidth, html.clientWidth, html.scrollWidth, html.offsetWidth)
	        };
	    }

	    /**
	     * Get the position of the given element, relative to its offset parent
	     * @method
	     * @memberof Popper.Utils
	     * @param {Element} element
	     * @return {Object} position - Coordinates of the element and its `scrollTop`
	     */
	    function getOffsetRect(element) {
	        var elementRect = void 0;
	        if (element.nodeName === 'HTML') {
	            var _getWindowSizes = getWindowSizes(),
	                width = _getWindowSizes.width,
	                height = _getWindowSizes.height;

	            elementRect = {
	                width: width,
	                height: height,
	                left: 0,
	                top: 0
	            };
	        } else {
	            elementRect = {
	                width: element.offsetWidth,
	                height: element.offsetHeight,
	                left: element.offsetLeft,
	                top: element.offsetTop
	            };
	        }

	        elementRect.right = elementRect.left + elementRect.width;
	        elementRect.bottom = elementRect.top + elementRect.height;

	        // position
	        return elementRect;
	    }

	    function getOffsetRectRelativeToViewport(element) {
	        // Offset relative to offsetParent
	        var relativeOffset = getOffsetRect(element);

	        if (element.nodeName !== 'HTML') {
	            var offsetParent = getOffsetParent(element);
	            var parentOffset = getOffsetRectRelativeToViewport(offsetParent);
	            var offset = {
	                width: relativeOffset.offsetWidth,
	                height: relativeOffset.offsetHeight,
	                left: relativeOffset.left + parentOffset.left,
	                top: relativeOffset.top + parentOffset.top,
	                right: relativeOffset.right - parentOffset.right,
	                bottom: relativeOffset.bottom - parentOffset.bottom
	            };
	            return offset;
	        }

	        return relativeOffset;
	    }

	    function getTotalScroll(element) {
	        var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';

	        var scrollParent = getScrollParent(element);
	        var scroll = getScroll(scrollParent, side);

	        if (['BODY', 'HTML'].indexOf(scrollParent.nodeName) === -1) {
	            return scroll + getTotalScroll(getParentNode(scrollParent), side);
	        }
	        return scroll;
	    }

	    /**
	     * Computed the boundaries limits and return them
	     * @method
	     * @memberof Popper.Utils
	     * @param {Object} data - Object containing the property "offsets" generated by `_getOffsets`
	     * @param {Number} padding - Boundaries padding
	     * @param {Element} boundariesElement - Element used to define the boundaries
	     * @returns {Object} Coordinates of the boundaries
	     */
	    function getBoundaries(popper, padding, boundariesElement) {
	        // NOTE: 1 DOM access here
	        var boundaries = { top: 0, left: 0 };
	        var offsetParent = getOffsetParent(popper);

	        // Handle viewport case
	        if (boundariesElement === 'viewport') {
	            var _getOffsetRectRelativ = getOffsetRectRelativeToViewport(offsetParent),
	                left = _getOffsetRectRelativ.left,
	                top = _getOffsetRectRelativ.top;

	            var _window$document$docu = window.document.documentElement,
	                width = _window$document$docu.clientWidth,
	                height = _window$document$docu.clientHeight;

	            if (getPosition(popper) === 'fixed') {
	                boundaries.right = width;
	                boundaries.bottom = height;
	            } else {
	                var scrollLeft = getTotalScroll(popper, 'left');
	                var scrollTop = getTotalScroll(popper, 'top');

	                boundaries = {
	                    top: 0 - top,
	                    right: width - left + scrollLeft,
	                    bottom: height - top + scrollTop,
	                    left: 0 - left
	                };
	            }
	        }
	        // Handle other cases based on DOM element used as boundaries
	        else {
	                var boundariesNode = void 0;
	                if (boundariesElement === 'scrollParent') {
	                    boundariesNode = getScrollParent(getParentNode(popper));
	                } else if (boundariesElement === 'window') {
	                    boundariesNode = window.document.body;
	                } else {
	                    boundariesNode = boundariesElement;
	                }

	                // In case of BODY, we need a different computation
	                if (boundariesNode.nodeName === 'BODY') {
	                    var _getWindowSizes = getWindowSizes(),
	                        _height = _getWindowSizes.height,
	                        _width = _getWindowSizes.width;

	                    boundaries.right = _width;
	                    boundaries.bottom = _height;
	                }
	                // for all the other DOM elements, this one is good
	                else {
	                        boundaries = getOffsetRectRelativeToCustomParent(boundariesNode, offsetParent, isFixed(popper));
	                    }
	            }

	        // Add paddings
	        boundaries.left += padding;
	        boundaries.top += padding;
	        boundaries.right -= padding;
	        boundaries.bottom -= padding;

	        return boundaries;
	    }

	    /**
	     * Utility used to transform the `auto` placement to the placement with more
	     * available space.
	     * @method
	     * @memberof Popper.Utils
	     * @argument {Object} data - The data object generated by update method
	     * @argum