react-bootstrap/dist/react-bootstrap.js

Bootstrap 3 components build with React

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory(require("react"));
	else if(typeof define === 'function' && define.amd)
		define(["react"], factory);
	else if(typeof exports === 'object')
		exports["ReactBootstrap"] = factory(require("react"));
	else
		root["ReactBootstrap"] = factory(root["React"]);
})(this, function(__WEBPACK_EXTERNAL_MODULE_2__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

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

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

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

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

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

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


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

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

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

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

	'use strict';

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

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

	var _Accordion = __webpack_require__(4);

	var _Accordion2 = _interopRequireDefault(_Accordion);

	var _Affix = __webpack_require__(10);

	var _Affix2 = _interopRequireDefault(_Affix);

	var _AffixMixin = __webpack_require__(11);

	var _AffixMixin2 = _interopRequireDefault(_AffixMixin);

	var _Alert = __webpack_require__(14);

	var _Alert2 = _interopRequireDefault(_Alert);

	var _BootstrapMixin = __webpack_require__(6);

	var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin);

	var _Badge = __webpack_require__(15);

	var _Badge2 = _interopRequireDefault(_Badge);

	var _Button = __webpack_require__(16);

	var _Button2 = _interopRequireDefault(_Button);

	var _ButtonGroup = __webpack_require__(17);

	var _ButtonGroup2 = _interopRequireDefault(_ButtonGroup);

	var _ButtonInput = __webpack_require__(18);

	var _ButtonInput2 = _interopRequireDefault(_ButtonInput);

	var _ButtonToolbar = __webpack_require__(22);

	var _ButtonToolbar2 = _interopRequireDefault(_ButtonToolbar);

	var _CollapsibleNav = __webpack_require__(23);

	var _CollapsibleNav2 = _interopRequireDefault(_CollapsibleNav);

	var _Carousel = __webpack_require__(27);

	var _Carousel2 = _interopRequireDefault(_Carousel);

	var _CarouselItem = __webpack_require__(29);

	var _CarouselItem2 = _interopRequireDefault(_CarouselItem);

	var _Col = __webpack_require__(30);

	var _Col2 = _interopRequireDefault(_Col);

	var _CollapsibleMixin = __webpack_require__(24);

	var _CollapsibleMixin2 = _interopRequireDefault(_CollapsibleMixin);

	var _DropdownButton = __webpack_require__(31);

	var _DropdownButton2 = _interopRequireDefault(_DropdownButton);

	var _DropdownMenu = __webpack_require__(33);

	var _DropdownMenu2 = _interopRequireDefault(_DropdownMenu);

	var _DropdownStateMixin = __webpack_require__(32);

	var _DropdownStateMixin2 = _interopRequireDefault(_DropdownStateMixin);

	var _FadeMixin = __webpack_require__(34);

	var _FadeMixin2 = _interopRequireDefault(_FadeMixin);

	var _FormControls = __webpack_require__(35);

	var _FormControls2 = _interopRequireDefault(_FormControls);

	var _Glyphicon = __webpack_require__(28);

	var _Glyphicon2 = _interopRequireDefault(_Glyphicon);

	var _Grid = __webpack_require__(37);

	var _Grid2 = _interopRequireDefault(_Grid);

	var _Input = __webpack_require__(38);

	var _Input2 = _interopRequireDefault(_Input);

	var _Interpolate = __webpack_require__(40);

	var _Interpolate2 = _interopRequireDefault(_Interpolate);

	var _Jumbotron = __webpack_require__(41);

	var _Jumbotron2 = _interopRequireDefault(_Jumbotron);

	var _Label = __webpack_require__(42);

	var _Label2 = _interopRequireDefault(_Label);

	var _ListGroup = __webpack_require__(43);

	var _ListGroup2 = _interopRequireDefault(_ListGroup);

	var _ListGroupItem = __webpack_require__(44);

	var _ListGroupItem2 = _interopRequireDefault(_ListGroupItem);

	var _MenuItem = __webpack_require__(45);

	var _MenuItem2 = _interopRequireDefault(_MenuItem);

	var _Modal = __webpack_require__(46);

	var _Modal2 = _interopRequireDefault(_Modal);

	var _ModalHeader = __webpack_require__(50);

	var _ModalHeader2 = _interopRequireDefault(_ModalHeader);

	var _ModalTitle = __webpack_require__(1);

	var _ModalTitle2 = _interopRequireDefault(_ModalTitle);

	var _ModalBody = __webpack_require__(49);

	var _ModalBody2 = _interopRequireDefault(_ModalBody);

	var _ModalFooter = __webpack_require__(51);

	var _ModalFooter2 = _interopRequireDefault(_ModalFooter);

	var _Nav = __webpack_require__(52);

	var _Nav2 = _interopRequireDefault(_Nav);

	var _Navbar = __webpack_require__(53);

	var _Navbar2 = _interopRequireDefault(_Navbar);

	var _NavItem = __webpack_require__(54);

	var _NavItem2 = _interopRequireDefault(_NavItem);

	var _ModalTrigger = __webpack_require__(55);

	var _ModalTrigger2 = _interopRequireDefault(_ModalTrigger);

	var _OverlayTrigger = __webpack_require__(57);

	var _OverlayTrigger2 = _interopRequireDefault(_OverlayTrigger);

	var _OverlayMixin = __webpack_require__(48);

	var _OverlayMixin2 = _interopRequireDefault(_OverlayMixin);

	var _Overlay = __webpack_require__(58);

	var _Overlay2 = _interopRequireDefault(_Overlay);

	var _PageHeader = __webpack_require__(64);

	var _PageHeader2 = _interopRequireDefault(_PageHeader);

	var _Pagination = __webpack_require__(65);

	var _Pagination2 = _interopRequireDefault(_Pagination);

	var _Panel = __webpack_require__(68);

	var _Panel2 = _interopRequireDefault(_Panel);

	var _PanelGroup = __webpack_require__(5);

	var _PanelGroup2 = _interopRequireDefault(_PanelGroup);

	var _PageItem = __webpack_require__(69);

	var _PageItem2 = _interopRequireDefault(_PageItem);

	var _Pager = __webpack_require__(70);

	var _Pager2 = _interopRequireDefault(_Pager);

	var _Popover = __webpack_require__(71);

	var _Popover2 = _interopRequireDefault(_Popover);

	var _ProgressBar = __webpack_require__(72);

	var _ProgressBar2 = _interopRequireDefault(_ProgressBar);

	var _Row = __webpack_require__(73);

	var _Row2 = _interopRequireDefault(_Row);

	var _SplitButton = __webpack_require__(74);

	var _SplitButton2 = _interopRequireDefault(_SplitButton);

	var _SubNav = __webpack_require__(75);

	var _SubNav2 = _interopRequireDefault(_SubNav);

	var _TabbedArea = __webpack_require__(76);

	var _TabbedArea2 = _interopRequireDefault(_TabbedArea);

	var _Table = __webpack_require__(77);

	var _Table2 = _interopRequireDefault(_Table);

	var _TabPane = __webpack_require__(78);

	var _TabPane2 = _interopRequireDefault(_TabPane);

	var _Thumbnail = __webpack_require__(79);

	var _Thumbnail2 = _interopRequireDefault(_Thumbnail);

	var _Tooltip = __webpack_require__(80);

	var _Tooltip2 = _interopRequireDefault(_Tooltip);

	var _utils = __webpack_require__(81);

	var _utils2 = _interopRequireDefault(_utils);

	var _Well = __webpack_require__(82);

	var _Well2 = _interopRequireDefault(_Well);

	var _styleMaps = __webpack_require__(7);

	var _styleMaps2 = _interopRequireDefault(_styleMaps);

	var _Portal = __webpack_require__(47);

	var _Portal2 = _interopRequireDefault(_Portal);

	var _Position = __webpack_require__(59);

	var _Position2 = _interopRequireDefault(_Position);

	exports['default'] = {
	  Accordion: _Accordion2['default'],
	  Affix: _Affix2['default'],
	  AffixMixin: _AffixMixin2['default'],
	  Alert: _Alert2['default'],
	  BootstrapMixin: _BootstrapMixin2['default'],
	  Badge: _Badge2['default'],
	  Button: _Button2['default'],
	  ButtonGroup: _ButtonGroup2['default'],
	  ButtonInput: _ButtonInput2['default'],
	  ButtonToolbar: _ButtonToolbar2['default'],
	  CollapsibleNav: _CollapsibleNav2['default'],
	  Carousel: _Carousel2['default'],
	  CarouselItem: _CarouselItem2['default'],
	  Col: _Col2['default'],
	  CollapsibleMixin: _CollapsibleMixin2['default'],
	  DropdownButton: _DropdownButton2['default'],
	  DropdownMenu: _DropdownMenu2['default'],
	  DropdownStateMixin: _DropdownStateMixin2['default'],
	  FadeMixin: _FadeMixin2['default'],
	  FormControls: _FormControls2['default'],
	  Glyphicon: _Glyphicon2['default'],
	  Grid: _Grid2['default'],
	  Input: _Input2['default'],
	  Interpolate: _Interpolate2['default'],
	  Jumbotron: _Jumbotron2['default'],
	  Label: _Label2['default'],
	  ListGroup: _ListGroup2['default'],
	  ListGroupItem: _ListGroupItem2['default'],
	  MenuItem: _MenuItem2['default'],
	  Modal: _Modal2['default'],
	  ModalHeader: _ModalHeader2['default'],
	  ModalTitle: _ModalTitle2['default'],
	  ModalBody: _ModalBody2['default'],
	  ModalFooter: _ModalFooter2['default'],
	  Nav: _Nav2['default'],
	  Navbar: _Navbar2['default'],
	  NavItem: _NavItem2['default'],
	  ModalTrigger: _ModalTrigger2['default'],
	  Overlay: _Overlay2['default'],
	  OverlayTrigger: _OverlayTrigger2['default'],
	  OverlayMixin: _OverlayMixin2['default'],
	  PageHeader: _PageHeader2['default'],
	  Panel: _Panel2['default'],
	  PanelGroup: _PanelGroup2['default'],
	  PageItem: _PageItem2['default'],
	  Pager: _Pager2['default'],
	  Pagination: _Pagination2['default'],
	  Popover: _Popover2['default'],
	  Portal: _Portal2['default'],
	  Position: _Position2['default'],
	  ProgressBar: _ProgressBar2['default'],
	  Row: _Row2['default'],
	  SplitButton: _SplitButton2['default'],
	  SubNav: _SubNav2['default'],
	  TabbedArea: _TabbedArea2['default'],
	  Table: _Table2['default'],
	  TabPane: _TabPane2['default'],
	  Thumbnail: _Thumbnail2['default'],
	  Tooltip: _Tooltip2['default'],
	  utils: _utils2['default'],
	  Well: _Well2['default'],
	  styleMaps: _styleMaps2['default']
	};
	module.exports = exports['default'];

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

	'use strict';

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

	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 _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) subClass.__proto__ = superClass; }

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	var _classnames = __webpack_require__(3);

	var _classnames2 = _interopRequireDefault(_classnames);

	var ModalTitle = (function (_React$Component) {
	  function ModalTitle() {
	    _classCallCheck(this, ModalTitle);

	    if (_React$Component != null) {
	      _React$Component.apply(this, arguments);
	    }
	  }

	  _inherits(ModalTitle, _React$Component);

	  _createClass(ModalTitle, [{
	    key: 'render',
	    value: function render() {
	      return _react2['default'].createElement(
	        'h4',
	        _extends({}, this.props, { className: (0, _classnames2['default'])(this.props.className, 'modal-title') }),
	        this.props.children
	      );
	    }
	  }]);

	  return ModalTitle;
	})(_react2['default'].Component);

	ModalTitle.propTypes = {
	  /**
	   * A css class applied to the Component
	   */
	  modalClassName: _react2['default'].PropTypes.string
	};

	ModalTitle.defaultProps = {
	  modalClassName: 'modal-title'
	};

	exports['default'] = ModalTitle;
	module.exports = exports['default'];

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

	module.exports = __WEBPACK_EXTERNAL_MODULE_2__;

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

	var __WEBPACK_AMD_DEFINE_RESULT__;/*!
	  Copyright (c) 2015 Jed Watson.
	  Licensed under the MIT License (MIT), see
	  http://jedwatson.github.io/classnames
	*/

	(function () {
		'use strict';

		function classNames () {

			var classes = '';

			for (var i = 0; i < arguments.length; i++) {
				var arg = arguments[i];
				if (!arg) continue;

				var argType = typeof arg;

				if ('string' === argType || 'number' === argType) {
					classes += ' ' + arg;

				} else if (Array.isArray(arg)) {
					classes += ' ' + classNames.apply(null, arg);

				} else if ('object' === argType) {
					for (var key in arg) {
						if (arg.hasOwnProperty(key) && arg[key]) {
							classes += ' ' + key;
						}
					}
				}
			}

			return classes.substr(1);
		}

		if (true) {
			// AMD. Register as an anonymous module.
			!(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
				return classNames;
			}.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
		} else if (typeof module !== 'undefined' && module.exports) {
			module.exports = classNames;
		} else {
			window.classNames = classNames;
		}

	}());


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

	'use strict';

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

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

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	var _PanelGroup = __webpack_require__(5);

	var _PanelGroup2 = _interopRequireDefault(_PanelGroup);

	var Accordion = _react2['default'].createClass({
	  displayName: 'Accordion',

	  render: function render() {
	    return _react2['default'].createElement(
	      _PanelGroup2['default'],
	      _extends({}, this.props, { accordion: true }),
	      this.props.children
	    );
	  }
	});

	exports['default'] = Accordion;
	module.exports = exports['default'];

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

	/* eslint react/prop-types: [2, {ignore: "bsStyle"}] */
	/* BootstrapMixin contains `bsStyle` type validation */

	'use strict';

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

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

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	var _classnames = __webpack_require__(3);

	var _classnames2 = _interopRequireDefault(_classnames);

	var _BootstrapMixin = __webpack_require__(6);

	var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin);

	var _utilsValidComponentChildren = __webpack_require__(9);

	var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren);

	var PanelGroup = _react2['default'].createClass({
	  displayName: 'PanelGroup',

	  mixins: [_BootstrapMixin2['default']],

	  propTypes: {
	    accordion: _react2['default'].PropTypes.bool,
	    activeKey: _react2['default'].PropTypes.any,
	    className: _react2['default'].PropTypes.string,
	    children: _react2['default'].PropTypes.node,
	    defaultActiveKey: _react2['default'].PropTypes.any,
	    onSelect: _react2['default'].PropTypes.func
	  },

	  getDefaultProps: function getDefaultProps() {
	    return {
	      bsClass: 'panel-group'
	    };
	  },

	  getInitialState: function getInitialState() {
	    var defaultActiveKey = this.props.defaultActiveKey;

	    return {
	      activeKey: defaultActiveKey
	    };
	  },

	  render: function render() {
	    var classes = this.getBsClassSet();
	    return _react2['default'].createElement(
	      'div',
	      _extends({}, this.props, { className: (0, _classnames2['default'])(this.props.className, classes), onSelect: null }),
	      _utilsValidComponentChildren2['default'].map(this.props.children, this.renderPanel)
	    );
	  },

	  renderPanel: function renderPanel(child, index) {
	    var activeKey = this.props.activeKey != null ? this.props.activeKey : this.state.activeKey;

	    var props = {
	      bsStyle: child.props.bsStyle || this.props.bsStyle,
	      key: child.key ? child.key : index,
	      ref: child.ref
	    };

	    if (this.props.accordion) {
	      props.collapsible = true;
	      props.expanded = child.props.eventKey === activeKey;
	      props.onSelect = this.handleSelect;
	    }

	    return (0, _react.cloneElement)(child, props);
	  },

	  shouldComponentUpdate: function shouldComponentUpdate() {
	    // Defer any updates to this component during the `onSelect` handler.
	    return !this._isChanging;
	  },

	  handleSelect: function handleSelect(e, key) {
	    e.preventDefault();

	    if (this.props.onSelect) {
	      this._isChanging = true;
	      this.props.onSelect(key);
	      this._isChanging = false;
	    }

	    if (this.state.activeKey === key) {
	      key = null;
	    }

	    this.setState({
	      activeKey: key
	    });
	  }
	});

	exports['default'] = PanelGroup;
	module.exports = exports['default'];

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

	'use strict';

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

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

	var _styleMaps = __webpack_require__(7);

	var _styleMaps2 = _interopRequireDefault(_styleMaps);

	var _utilsCustomPropTypes = __webpack_require__(8);

	var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes);

	var BootstrapMixin = {
	  propTypes: {
	    /**
	     * bootstrap className
	     * @private
	     */
	    bsClass: _utilsCustomPropTypes2['default'].keyOf(_styleMaps2['default'].CLASSES),
	    /**
	     * Style variants
	     * @type {("default"|"primary"|"success"|"info"|"warning"|"danger"|"link")}
	     */
	    bsStyle: _utilsCustomPropTypes2['default'].keyOf(_styleMaps2['default'].STYLES),
	    /**
	     * Size variants
	     * @type {("xsmall"|"small"|"medium"|"large")}
	     */
	    bsSize: _utilsCustomPropTypes2['default'].keyOf(_styleMaps2['default'].SIZES)
	  },

	  getBsClassSet: function getBsClassSet() {
	    var classes = {};

	    var bsClass = this.props.bsClass && _styleMaps2['default'].CLASSES[this.props.bsClass];
	    if (bsClass) {
	      classes[bsClass] = true;

	      var prefix = bsClass + '-';

	      var bsSize = this.props.bsSize && _styleMaps2['default'].SIZES[this.props.bsSize];
	      if (bsSize) {
	        classes[prefix + bsSize] = true;
	      }

	      var bsStyle = this.props.bsStyle && _styleMaps2['default'].STYLES[this.props.bsStyle];
	      if (this.props.bsStyle) {
	        classes[prefix + bsStyle] = true;
	      }
	    }

	    return classes;
	  },

	  prefixClass: function prefixClass(subClass) {
	    return _styleMaps2['default'].CLASSES[this.props.bsClass] + '-' + subClass;
	  }
	};

	exports['default'] = BootstrapMixin;
	module.exports = exports['default'];

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

	'use strict';

	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	var styleMaps = {
	  CLASSES: {
	    'alert': 'alert',
	    'button': 'btn',
	    'button-group': 'btn-group',
	    'button-toolbar': 'btn-toolbar',
	    'column': 'col',
	    'input-group': 'input-group',
	    'form': 'form',
	    'glyphicon': 'glyphicon',
	    'label': 'label',
	    'thumbnail': 'thumbnail',
	    'list-group-item': 'list-group-item',
	    'panel': 'panel',
	    'panel-group': 'panel-group',
	    'pagination': 'pagination',
	    'progress-bar': 'progress-bar',
	    'nav': 'nav',
	    'navbar': 'navbar',
	    'modal': 'modal',
	    'row': 'row',
	    'well': 'well'
	  },
	  STYLES: {
	    'default': 'default',
	    'primary': 'primary',
	    'success': 'success',
	    'info': 'info',
	    'warning': 'warning',
	    'danger': 'danger',
	    'link': 'link',
	    'inline': 'inline',
	    'tabs': 'tabs',
	    'pills': 'pills'
	  },
	  addStyle: function addStyle(name) {
	    styleMaps.STYLES[name] = name;
	  },
	  SIZES: {
	    'large': 'lg',
	    'medium': 'md',
	    'small': 'sm',
	    'xsmall': 'xs'
	  },
	  GLYPHS: ['asterisk', 'plus', 'euro', 'eur', 'minus', 'cloud', 'envelope', 'pencil', 'glass', 'music', 'search', 'heart', 'star', 'star-empty', 'user', 'film', 'th-large', 'th', 'th-list', 'ok', 'remove', 'zoom-in', 'zoom-out', 'off', 'signal', 'cog', 'trash', 'home', 'file', 'time', 'road', 'download-alt', 'download', 'upload', 'inbox', 'play-circle', 'repeat', 'refresh', 'list-alt', 'lock', 'flag', 'headphones', 'volume-off', 'volume-down', 'volume-up', 'qrcode', 'barcode', 'tag', 'tags', 'book', 'bookmark', 'print', 'camera', 'font', 'bold', 'italic', 'text-height', 'text-width', 'align-left', 'align-center', 'align-right', 'align-justify', 'list', 'indent-left', 'indent-right', 'facetime-video', 'picture', 'map-marker', 'adjust', 'tint', 'edit', 'share', 'check', 'move', 'step-backward', 'fast-backward', 'backward', 'play', 'pause', 'stop', 'forward', 'fast-forward', 'step-forward', 'eject', 'chevron-left', 'chevron-right', 'plus-sign', 'minus-sign', 'remove-sign', 'ok-sign', 'question-sign', 'info-sign', 'screenshot', 'remove-circle', 'ok-circle', 'ban-circle', 'arrow-left', 'arrow-right', 'arrow-up', 'arrow-down', 'share-alt', 'resize-full', 'resize-small', 'exclamation-sign', 'gift', 'leaf', 'fire', 'eye-open', 'eye-close', 'warning-sign', 'plane', 'calendar', 'random', 'comment', 'magnet', 'chevron-up', 'chevron-down', 'retweet', 'shopping-cart', 'folder-close', 'folder-open', 'resize-vertical', 'resize-horizontal', 'hdd', 'bullhorn', 'bell', 'certificate', 'thumbs-up', 'thumbs-down', 'hand-right', 'hand-left', 'hand-up', 'hand-down', 'circle-arrow-right', 'circle-arrow-left', 'circle-arrow-up', 'circle-arrow-down', 'globe', 'wrench', 'tasks', 'filter', 'briefcase', 'fullscreen', 'dashboard', 'paperclip', 'heart-empty', 'link', 'phone', 'pushpin', 'usd', 'gbp', 'sort', 'sort-by-alphabet', 'sort-by-alphabet-alt', 'sort-by-order', 'sort-by-order-alt', 'sort-by-attributes', 'sort-by-attributes-alt', 'unchecked', 'expand', 'collapse-down', 'collapse-up', 'log-in', 'flash', 'log-out', 'new-window', 'record', 'save', 'open', 'saved', 'import', 'export', 'send', 'floppy-disk', 'floppy-saved', 'floppy-remove', 'floppy-save', 'floppy-open', 'credit-card', 'transfer', 'cutlery', 'header', 'compressed', 'earphone', 'phone-alt', 'tower', 'stats', 'sd-video', 'hd-video', 'subtitles', 'sound-stereo', 'sound-dolby', 'sound-5-1', 'sound-6-1', 'sound-7-1', 'copyright-mark', 'registration-mark', 'cloud-download', 'cloud-upload', 'tree-conifer', 'tree-deciduous', 'cd', 'save-file', 'open-file', 'level-up', 'copy', 'paste', 'alert', 'equalizer', 'king', 'queen', 'pawn', 'bishop', 'knight', 'baby-formula', 'tent', 'blackboard', 'bed', 'apple', 'erase', 'hourglass', 'lamp', 'duplicate', 'piggy-bank', 'scissors', 'bitcoin', 'yen', 'ruble', 'scale', 'ice-lolly', 'ice-lolly-tasted', 'education', 'option-horizontal', 'option-vertical', 'menu-hamburger', 'modal-window', 'oil', 'grain', 'sunglasses', 'text-size', 'text-color', 'text-background', 'object-align-top', 'object-align-bottom', 'object-align-horizontal', 'object-align-left', 'object-align-vertical', 'object-align-right', 'triangle-right', 'triangle-left', 'triangle-bottom', 'triangle-top', 'console', 'superscript', 'subscript', 'menu-left', 'menu-right', 'menu-down', 'menu-up']
	};

	exports['default'] = styleMaps;
	module.exports = exports['default'];

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

	'use strict';

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

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

	function _toArray(arr) { return Array.isArray(arr) ? arr : Array.from(arr); }

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	var ANONYMOUS = '<<anonymous>>';

	var CustomPropTypes = {

	  isRequiredForA11y: function isRequiredForA11y(propType) {
	    return function (props, propName, componentName) {
	      if (props[propName] === null) {
	        return new Error('The prop `' + propName + '` is required to make ' + componentName + ' accessible ' + 'for users using assistive technologies such as screen readers `');
	      }

	      return propType(props, propName, componentName);
	    };
	  },

	  /**
	   * Checks whether a prop provides a DOM element
	   *
	   * The element can be provided in two forms:
	   * - Directly passed
	   * - Or passed an object that has a `render` method
	   *
	   * @param props
	   * @param propName
	   * @param componentName
	   * @returns {Error|undefined}
	   */
	  mountable: createMountableChecker(),

	  /**
	   * Checks whether a prop provides a type of element.
	   *
	   * The type of element can be provided in two forms:
	   * - tag name (string)
	   * - a return value of React.createClass(...)
	   *
	   * @param props
	   * @param propName
	   * @param componentName
	   * @returns {Error|undefined}
	   */
	  elementType: createElementTypeChecker(),

	  /**
	   * Checks whether a prop matches a key of an associated object
	   *
	   * @param props
	   * @param propName
	   * @param componentName
	   * @returns {Error|undefined}
	   */
	  keyOf: createKeyOfChecker,
	  /**
	   * Checks if only one of the listed properties is in use. An error is given
	   * if multiple have a value
	   *
	   * @param props
	   * @param propName
	   * @param componentName
	   * @returns {Error|undefined}
	   */
	  singlePropFrom: createSinglePropFromChecker,

	  all: all
	};

	function errMsg(props, propName, componentName, msgContinuation) {
	  return 'Invalid prop \'' + propName + '\' of value \'' + props[propName] + '\'' + (' supplied to \'' + componentName + '\'' + msgContinuation);
	}

	/**
	 * Create chain-able isRequired validator
	 *
	 * Largely copied directly from:
	 *  https://github.com/facebook/react/blob/0.11-stable/src/core/ReactPropTypes.js#L94
	 */
	function createChainableTypeChecker(validate) {
	  function checkType(isRequired, props, propName, componentName) {
	    componentName = componentName || ANONYMOUS;
	    if (props[propName] == null) {
	      if (isRequired) {
	        return new Error('Required prop \'' + propName + '\' was not specified in \'' + componentName + '\'.');
	      }
	    } else {
	      return validate(props, propName, componentName);
	    }
	  }

	  var chainedCheckType = checkType.bind(null, false);
	  chainedCheckType.isRequired = checkType.bind(null, true);

	  return chainedCheckType;
	}

	function createMountableChecker() {
	  function validate(props, propName, componentName) {
	    if (typeof props[propName] !== 'object' || typeof props[propName].render !== 'function' && props[propName].nodeType !== 1) {
	      return new Error(errMsg(props, propName, componentName, ', expected a DOM element or an object that has a `render` method'));
	    }
	  }

	  return createChainableTypeChecker(validate);
	}

	function createKeyOfChecker(obj) {
	  function validate(props, propName, componentName) {
	    var propValue = props[propName];
	    if (!obj.hasOwnProperty(propValue)) {
	      var valuesString = JSON.stringify(Object.keys(obj));
	      return new Error(errMsg(props, propName, componentName, ', expected one of ' + valuesString + '.'));
	    }
	  }
	  return createChainableTypeChecker(validate);
	}

	function createSinglePropFromChecker(arrOfProps) {
	  function validate(props, propName, componentName) {
	    var usedPropCount = arrOfProps.map(function (listedProp) {
	      return props[listedProp];
	    }).reduce(function (acc, curr) {
	      return acc + (curr !== undefined ? 1 : 0);
	    }, 0);

	    if (usedPropCount > 1) {
	      var _arrOfProps = _toArray(arrOfProps);

	      var first = _arrOfProps[0];

	      var others = _arrOfProps.slice(1);

	      var message = '' + others.join(', ') + ' and ' + first;
	      return new Error('Invalid prop \'' + propName + '\', only one of the following ' + ('may be provided: ' + message));
	    }
	  }
	  return validate;
	}

	function all(propTypes) {
	  if (propTypes === undefined) {
	    throw new Error('No validations provided');
	  }

	  if (!(propTypes instanceof Array)) {
	    throw new Error('Invalid argument must be an array');
	  }

	  if (propTypes.length === 0) {
	    throw new Error('No validations provided');
	  }

	  return function (props, propName, componentName) {
	    for (var i = 0; i < propTypes.length; i++) {
	      var result = propTypes[i](props, propName, componentName);

	      if (result !== undefined && result !== null) {
	        return result;
	      }
	    }
	  };
	}

	function createElementTypeChecker() {
	  function validate(props, propName, componentName) {
	    var errBeginning = errMsg(props, propName, componentName, '. Expected an Element `type`');

	    if (typeof props[propName] !== 'function') {
	      if (_react2['default'].isValidElement(props[propName])) {
	        return new Error(errBeginning + ', not an actual Element');
	      }

	      if (typeof props[propName] !== 'string') {
	        return new Error(errBeginning + ' such as a tag name or return value of React.createClass(...)');
	      }
	    }
	  }

	  return createChainableTypeChecker(validate);
	}

	exports['default'] = CustomPropTypes;
	module.exports = exports['default'];

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

	'use strict';

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

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

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	/**
	 * Maps children that are typically specified as `props.children`,
	 * but only iterates over children that are "valid components".
	 *
	 * The mapFunction provided index will be normalised to the components mapped,
	 * so an invalid component would not increase the index.
	 *
	 * @param {?*} children Children tree container.
	 * @param {function(*, int)} mapFunction.
	 * @param {*} mapContext Context for mapFunction.
	 * @return {object} Object containing the ordered map of results.
	 */
	function mapValidComponents(children, func, context) {
	  var index = 0;

	  return _react2['default'].Children.map(children, function (child) {
	    if (_react2['default'].isValidElement(child)) {
	      var lastIndex = index;
	      index++;
	      return func.call(context, child, lastIndex);
	    }

	    return child;
	  });
	}

	/**
	 * Iterates through children that are typically specified as `props.children`,
	 * but only iterates over children that are "valid components".
	 *
	 * The provided forEachFunc(child, index) will be called for each
	 * leaf child with the index reflecting the position relative to "valid components".
	 *
	 * @param {?*} children Children tree container.
	 * @param {function(*, int)} forEachFunc.
	 * @param {*} forEachContext Context for forEachContext.
	 */
	function forEachValidComponents(children, func, context) {
	  var index = 0;

	  return _react2['default'].Children.forEach(children, function (child) {
	    if (_react2['default'].isValidElement(child)) {
	      func.call(context, child, index);
	      index++;
	    }
	  });
	}

	/**
	 * Count the number of "valid components" in the Children container.
	 *
	 * @param {?*} children Children tree container.
	 * @returns {number}
	 */
	function numberOfValidComponents(children) {
	  var count = 0;

	  _react2['default'].Children.forEach(children, function (child) {
	    if (_react2['default'].isValidElement(child)) {
	      count++;
	    }
	  });

	  return count;
	}

	/**
	 * Determine if the Child container has one or more "valid components".
	 *
	 * @param {?*} children Children tree container.
	 * @returns {boolean}
	 */
	function hasValidComponent(children) {
	  var hasValid = false;

	  _react2['default'].Children.forEach(children, function (child) {
	    if (!hasValid && _react2['default'].isValidElement(child)) {
	      hasValid = true;
	    }
	  });

	  return hasValid;
	}

	exports['default'] = {
	  map: mapValidComponents,
	  forEach: forEachValidComponents,
	  numberOf: numberOfValidComponents,
	  hasValidComponent: hasValidComponent
	};
	module.exports = exports['default'];

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

	'use strict';

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

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

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	var _classnames = __webpack_require__(3);

	var _classnames2 = _interopRequireDefault(_classnames);

	var _AffixMixin = __webpack_require__(11);

	var _AffixMixin2 = _interopRequireDefault(_AffixMixin);

	var _utilsDomUtils = __webpack_require__(12);

	var _utilsDomUtils2 = _interopRequireDefault(_utilsDomUtils);

	var Affix = _react2['default'].createClass({
	  displayName: 'Affix',

	  statics: {
	    domUtils: _utilsDomUtils2['default']
	  },

	  mixins: [_AffixMixin2['default']],

	  render: function render() {
	    var holderStyle = { top: this.state.affixPositionTop };

	    return _react2['default'].createElement(
	      'div',
	      _extends({}, this.props, {
	        className: (0, _classnames2['default'])(this.props.className, this.state.affixClass),
	        style: holderStyle }),
	      this.props.children
	    );
	  }
	});

	exports['default'] = Affix;
	module.exports = exports['default'];

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

	'use strict';

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

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

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	var _utilsDomUtils = __webpack_require__(12);

	var _utilsDomUtils2 = _interopRequireDefault(_utilsDomUtils);

	var _utilsEventListener = __webpack_require__(13);

	var _utilsEventListener2 = _interopRequireDefault(_utilsEventListener);

	var AffixMixin = {
	  propTypes: {
	    offset: _react2['default'].PropTypes.number,
	    offsetTop: _react2['default'].PropTypes.number,
	    offsetBottom: _react2['default'].PropTypes.number
	  },

	  getInitialState: function getInitialState() {
	    return {
	      affixClass: 'affix-top'
	    };
	  },

	  getPinnedOffset: function getPinnedOffset(DOMNode) {
	    if (this.pinnedOffset) {
	      return this.pinnedOffset;
	    }

	    DOMNode.className = DOMNode.className.replace(/affix-top|affix-bottom|affix/, '');
	    DOMNode.className += DOMNode.className.length ? ' affix' : 'affix';

	    this.pinnedOffset = _utilsDomUtils2['default'].getOffset(DOMNode).top - window.pageYOffset;

	    return this.pinnedOffset;
	  },

	  checkPosition: function checkPosition() {
	    var DOMNode = undefined,
	        scrollHeight = undefined,
	        scrollTop = undefined,
	        position = undefined,
	        offsetTop = undefined,
	        offsetBottom = undefined,
	        affix = undefined,
	        affixType = undefined,
	        affixPositionTop = undefined;

	    // TODO: or not visible
	    if (!this.isMounted()) {
	      return;
	    }

	    DOMNode = _react2['default'].findDOMNode(this);
	    scrollHeight = document.documentElement.offsetHeight;
	    scrollTop = window.pageYOffset;
	    position = _utilsDomUtils2['default'].getOffset(DOMNode);

	    if (this.affixed === 'top') {
	      position.top += scrollTop;
	    }

	    offsetTop = this.props.offsetTop != null ? this.props.offsetTop : this.props.offset;
	    offsetBottom = this.props.offsetBottom != null ? this.props.offsetBottom : this.props.offset;

	    if (offsetTop == null && offsetBottom == null) {
	      return;
	    }
	    if (offsetTop == null) {
	      offsetTop = 0;
	    }
	    if (offsetBottom == null) {
	      offsetBottom = 0;
	    }

	    if (this.unpin != null && scrollTop + this.unpin <= position.top) {
	      affix = false;
	    } else if (offsetBottom != null && position.top + DOMNode.offsetHeight >= scrollHeight - offsetBottom) {
	      affix = 'bottom';
	    } else if (offsetTop != null && scrollTop <= offsetTop) {
	      affix = 'top';
	    } else {
	      affix = false;
	    }

	    if (this.affixed === affix) {
	      return;
	    }

	    if (this.unpin != null) {
	      DOMNode.style.top = '';
	    }

	    affixType = 'affix' + (affix ? '-' + affix : '');

	    this.affixed = affix;
	    this.unpin = affix === 'bottom' ? this.getPinnedOffset(DOMNode) : null;

	    if (affix === 'bottom') {
	      DOMNode.className = DOMNode.className.replace(/affix-top|affix-bottom|affix/, 'affix-bottom');
	      affixPositionTop = scrollHeight - offsetBottom - DOMNode.offsetHeight - _utilsDomUtils2['default'].getOffset(DOMNode).top;
	    }

	    this.setState({
	      affixClass: affixType,
	      affixPositionTop: affixPositionTop
	    });
	  },

	  checkPositionWithEventLoop: function checkPositionWithEventLoop() {
	    setTimeout(this.checkPosition, 0);
	  },

	  componentDidMount: function componentDidMount() {
	    this._onWindowScrollListener = _utilsEventListener2['default'].listen(window, 'scroll', this.checkPosition);
	    this._onDocumentClickListener = _utilsEventListener2['default'].listen(_utilsDomUtils2['default'].ownerDocument(this), 'click', this.checkPositionWithEventLoop);
	  },

	  componentWillUnmount: function componentWillUnmount() {
	    if (this._onWindowScrollListener) {
	      this._onWindowScrollListener.remove();
	    }

	    if (this._onDocumentClickListener) {
	      this._onDocumentClickListener.remove();
	    }
	  },

	  componentDidUpdate: function componentDidUpdate(prevProps, prevState) {
	    if (prevState.affixClass === this.state.affixClass) {
	      this.checkPositionWithEventLoop();
	    }
	  }
	};

	exports['default'] = AffixMixin;
	module.exports = exports['default'];

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

	'use strict';

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

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

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	var canUseDom = !!(typeof window !== 'undefined' && window.document && window.document.createElement);

	/**
	 * Get elements owner document
	 *
	 * @param {ReactComponent|HTMLElement} componentOrElement
	 * @returns {HTMLElement}
	 */
	function ownerDocument(componentOrElement) {
	  var elem = _react2['default'].findDOMNode(componentOrElement);
	  return elem && elem.ownerDocument || document;
	}

	function ownerWindow(componentOrElement) {
	  var doc = ownerDocument(componentOrElement);
	  return doc.defaultView ? doc.defaultView : doc.parentWindow;
	}

	/**
	 * get the active element, safe in IE
	 * @return {HTMLElement}
	 */
	function getActiveElement(componentOrElement) {
	  var doc = ownerDocument(componentOrElement);

	  try {
	    return doc.activeElement || doc.body;
	  } catch (e) {
	    return doc.body;
	  }
	}

	/**
	 * Shortcut to compute element style
	 *
	 * @param {HTMLElement} elem
	 * @returns {CssStyle}
	 */
	function getComputedStyles(elem) {
	  return ownerDocument(elem).defaultView.getComputedStyle(elem, null);
	}

	/**
	 * Get elements offset
	 *
	 * TODO: REMOVE JQUERY!
	 *
	 * @param {HTMLElement} DOMNode
	 * @returns {{top: number, left: number}}
	 */
	function getOffset(DOMNode) {
	  if (window.jQuery) {
	    return window.jQuery(DOMNode).offset();
	  }

	  var docElem = ownerDocument(DOMNode).documentElement;
	  var box = { top: 0, left: 0 };

	  // If we don't have gBCR, just use 0,0 rather than error
	  // BlackBerry 5, iOS 3 (original iPhone)
	  if (typeof DOMNode.getBoundingClientRect !== 'undefined') {
	    box = DOMNode.getBoundingClientRect();
	  }

	  return {
	    top: box.top + window.pageYOffset - docElem.clientTop,
	    left: box.left + window.pageXOffset - docElem.clientLeft
	  };
	}

	/**
	 * Get elements position
	 *
	 * TODO: REMOVE JQUERY!
	 *
	 * @param {HTMLElement} elem
	 * @param {HTMLElement?} offsetParent
	 * @returns {{top: number, left: number}}
	 */
	function getPosition(elem, offsetParent) {
	  var offset = undefined,
	      parentOffset = undefined;

	  if (window.jQuery) {
	    if (!offsetParent) {
	      return window.jQuery(elem).position();
	    }

	    offset = window.jQuery(elem).offset();
	    parentOffset = window.jQuery(offsetParent).offset();

	    // Get element offset relative to offsetParent
	    return {
	      top: offset.top - parentOffset.top,
	      left: offset.left - parentOffset.left
	    };
	  }

	  parentOffset = { top: 0, left: 0 };

	  // Fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent
	  if (getComputedStyles(elem).position === 'fixed') {
	    // We assume that getBoundingClientRect is available when computed position is fixed
	    offset = elem.getBoundingClientRect();
	  } else {
	    if (!offsetParent) {
	      // Get *real* offsetParent
	      offsetParent = offsetParentFunc(elem);
	    }

	    // Get correct offsets
	    offset = getOffset(elem);
	    if (offsetParent.nodeName !== 'HTML') {
	      parentOffset = getOffset(offsetParent);
	    }

	    // Add offsetParent borders
	    parentOffset.top += parseInt(getComputedStyles(offsetParent).borderTopWidth, 10);
	    parentOffset.left += parseInt(getComputedStyles(offsetParent).borderLeftWidth, 10);
	  }

	  // Subtract parent offsets and element margins
	  return {
	    top: offset.top - parentOffset.top - parseInt(getComputedStyles(elem).marginTop, 10),
	    left: offset.left - parentOffset.left - parseInt(getComputedStyles(elem).marginLeft, 10)
	  };
	}

	/**
	 * Get parent element
	 *
	 * @param {HTMLElement?} elem
	 * @returns {HTMLElement}
	 */
	function offsetParentFunc(elem) {
	  var docElem = ownerDocument(elem).documentElement;
	  var offsetParent = elem.offsetParent || docElem;

	  while (offsetParent && (offsetParent.nodeName !== 'HTML' && getComputedStyles(offsetParent).position === 'static')) {
	    offsetParent = offsetParent.offsetParent;
	  }

	  return offsetParent || docElem;
	}

	/**
	 * Cross browser .contains() polyfill
	 * @param  {HTMLElement} elem
	 * @param  {HTMLElement} inner
	 * @return {bool}
	 */
	function contains(elem, inner) {
	  function ie8Contains(root, node) {
	    while (node) {
	      if (node === root) {
	        return true;
	      }
	      node = node.parentNode;
	    }
	    return false;
	  }

	  return elem && elem.contains ? elem.contains(inner) : elem && elem.compareDocumentPosition ? elem === inner || !!(elem.compareDocumentPosition(inner) & 16) : ie8Contains(elem, inner);
	}

	exports['default'] = {
	  canUseDom: canUseDom,
	  contains: contains,
	  ownerWindow: ownerWindow,
	  ownerDocument: ownerDocument,
	  getComputedStyles: getComputedStyles,
	  getOffset: getOffset,
	  getPosition: getPosition,
	  activeElement: getActiveElement,
	  offsetParent: offsetParentFunc
	};
	module.exports = exports['default'];

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

	/**
	 * Copyright 2013-2014 Facebook, Inc.
	 *
	 * This file contains a modified version of:
	 * https://github.com/facebook/react/blob/v0.12.0/src/vendor/stubs/EventListener.js
	 *
	 * Licensed under the Apache License, Version 2.0 (the "License");
	 * you may not use this file except in compliance with the License.
	 * You may obtain a copy of the License at
	 *
	 * http://www.apache.org/licenses/LICENSE-2.0
	 *
	 * Unless required by applicable law or agreed to in writing, software
	 * distributed under the License is distributed on an "AS IS" BASIS,
	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	 * See the License for the specific language governing permissions and
	 * limitations under the License.
	 *
	 * TODO: remove in favour of solution provided by:
	 *  https://github.com/facebook/react/issues/285
	 */

	/**
	 * Does not take into account specific nature of platform.
	 */
	'use strict';

	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	var EventListener = {
	  /**
	   * Listen to DOM events during the bubble phase.
	   *
	   * @param {DOMEventTarget} target DOM element to register listener on.
	   * @param {string} eventType Event type, e.g. 'click' or 'mouseover'.
	   * @param {function} callback Callback function.
	   * @return {object} Object with a `remove` method.
	   */
	  listen: function listen(target, eventType, callback) {
	    if (target.addEventListener) {
	      target.addEventListener(eventType, callback, false);
	      return {
	        remove: function remove() {
	          target.removeEventListener(eventType, callback, false);
	        }
	      };
	    } else if (target.attachEvent) {
	      target.attachEvent('on' + eventType, callback);
	      return {
	        remove: function remove() {
	          target.detachEvent('on' + eventType, callback);
	        }
	      };
	    }
	  }
	};

	exports['default'] = EventListener;
	module.exports = exports['default'];

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

	'use strict';

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

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

	var _react = __webpack_require__(2);

	var _react2 = _interopRequireDefault(_react);

	var _classnames = __webpack_require__(3);

	var _classnames2 = _interopRequireDefault(_classnames);

	var _BootstrapMixin = __webpack_require__(6);

	var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin);

	var Alert = _react2['default'].createClass({
	  displayName: 'Alert',

	  mixins: [_BootstrapMixin2['default']],

	  propTypes: {
	    onDismiss: _react2['default'].PropTypes.func,
	    dismissAfter: _react2['default'].PropTypes.number,
	    closeLabel: _react2['default'].PropTypes.string
	  },

	  getDefaultProps: function getDefaultProps() {
	    return {
	      bsClass: 'alert',
	      bsStyle: 'info',
	      closeLabel: 'Close Alert'
	    };
	  },

	  renderDismissButton: function renderDismissButton() {
	    return _react2['default'].createElement(
	      'button',
	      {
	        type: 'button',
	        className: 'close',
	        'aria-label': this.props.closeLabel,
	        onClick: this.props.onDismiss },
	      _react2['default'].createElement(
	        'span',
	        { 'aria-hidden': 'true' },
	        '×'
	      )
	    );
	  },

	  render: function render() {
	    var classes = this.getBsClassSet();
	    var isDismissable = !!this.props.onDismiss;

	    classes['alert-dismissable'] = isDismissable;

	    return _react2['default'].createElement(
	      'div',
	      _extends({}, this.props, { role: 'alert', className: (0, _classnames2['default'])(this.props.className, classes) }),
	      isDismissable ? this.renderDismissButton() : null,
	      this.props.children
	    );
	  },

	  componentDidMount: function componentDidMount() {
	    if (this.props.dismissAfter && this.props.onDismiss) {
	      this.dismissTimer = setTimeout(this.props.onDismiss, this.props.dismissAfter);
	    }
	  },

	  componentWillUnmount: function componentWillUnmount() {
	    cl