From e8fbeb5b70f62abece393c3f91df0c28faa7d35c Mon Sep 17 00:00:00 2001 From: Christopher Speller Date: Tue, 24 Nov 2015 09:19:27 -0500 Subject: Updating client dependancies (non-npm) --- web/static/js/react-bootstrap-0.28.1.js | 16997 ++++++++++++++++++++++++++++++ 1 file changed, 16997 insertions(+) create mode 100644 web/static/js/react-bootstrap-0.28.1.js (limited to 'web/static/js/react-bootstrap-0.28.1.js') diff --git a/web/static/js/react-bootstrap-0.28.1.js b/web/static/js/react-bootstrap-0.28.1.js new file mode 100644 index 000000000..bfc5c4285 --- /dev/null +++ b/web/static/js/react-bootstrap-0.28.1.js @@ -0,0 +1,16997 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("react"), require("react-dom")); + else if(typeof define === 'function' && define.amd) + define(["react", "react-dom"], factory); + else if(typeof exports === 'object') + exports["ReactBootstrap"] = factory(require("react"), require("react-dom")); + else + root["ReactBootstrap"] = factory(root["React"], root["ReactDOM"]); +})(this, function(__WEBPACK_EXTERNAL_MODULE_4__, __WEBPACK_EXTERNAL_MODULE_63__) { +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'; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + var _interopRequireWildcard = __webpack_require__(2)['default']; + + exports.__esModule = true; + + var _utilsChildrenValueInputValidation = __webpack_require__(3); + + var _utilsChildrenValueInputValidation2 = _interopRequireDefault(_utilsChildrenValueInputValidation); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _Accordion2 = __webpack_require__(34); + + var _Accordion3 = _interopRequireDefault(_Accordion2); + + exports.Accordion = _Accordion3['default']; + + var _Alert2 = __webpack_require__(38); + + var _Alert3 = _interopRequireDefault(_Alert2); + + exports.Alert = _Alert3['default']; + + var _Badge2 = __webpack_require__(39); + + var _Badge3 = _interopRequireDefault(_Badge2); + + exports.Badge = _Badge3['default']; + + var _Breadcrumb2 = __webpack_require__(40); + + var _Breadcrumb3 = _interopRequireDefault(_Breadcrumb2); + + exports.Breadcrumb = _Breadcrumb3['default']; + + var _BreadcrumbItem2 = __webpack_require__(41); + + var _BreadcrumbItem3 = _interopRequireDefault(_BreadcrumbItem2); + + exports.BreadcrumbItem = _BreadcrumbItem3['default']; + + var _Button2 = __webpack_require__(51); + + var _Button3 = _interopRequireDefault(_Button2); + + exports.Button = _Button3['default']; + + var _ButtonGroup2 = __webpack_require__(54); + + var _ButtonGroup3 = _interopRequireDefault(_ButtonGroup2); + + exports.ButtonGroup = _ButtonGroup3['default']; + + var _ButtonInput2 = __webpack_require__(56); + + var _ButtonInput3 = _interopRequireDefault(_ButtonInput2); + + exports.ButtonInput = _ButtonInput3['default']; + + var _ButtonToolbar2 = __webpack_require__(60); + + var _ButtonToolbar3 = _interopRequireDefault(_ButtonToolbar2); + + exports.ButtonToolbar = _ButtonToolbar3['default']; + + var _Carousel2 = __webpack_require__(61); + + var _Carousel3 = _interopRequireDefault(_Carousel2); + + exports.Carousel = _Carousel3['default']; + + var _CarouselItem2 = __webpack_require__(62); + + var _CarouselItem3 = _interopRequireDefault(_CarouselItem2); + + exports.CarouselItem = _CarouselItem3['default']; + + var _Col2 = __webpack_require__(65); + + var _Col3 = _interopRequireDefault(_Col2); + + exports.Col = _Col3['default']; + + var _CollapsibleNav2 = __webpack_require__(66); + + var _CollapsibleNav3 = _interopRequireDefault(_CollapsibleNav2); + + exports.CollapsibleNav = _CollapsibleNav3['default']; + + var _Dropdown2 = __webpack_require__(82); + + var _Dropdown3 = _interopRequireDefault(_Dropdown2); + + exports.Dropdown = _Dropdown3['default']; + + var _DropdownButton2 = __webpack_require__(168); + + var _DropdownButton3 = _interopRequireDefault(_DropdownButton2); + + exports.DropdownButton = _DropdownButton3['default']; + + var _Glyphicon2 = __webpack_require__(59); + + var _Glyphicon3 = _interopRequireDefault(_Glyphicon2); + + exports.Glyphicon = _Glyphicon3['default']; + + var _Grid2 = __webpack_require__(170); + + var _Grid3 = _interopRequireDefault(_Grid2); + + exports.Grid = _Grid3['default']; + + var _Image2 = __webpack_require__(171); + + var _Image3 = _interopRequireDefault(_Image2); + + exports.Image = _Image3['default']; + + var _Input2 = __webpack_require__(172); + + var _Input3 = _interopRequireDefault(_Input2); + + exports.Input = _Input3['default']; + + var _Interpolate2 = __webpack_require__(175); + + var _Interpolate3 = _interopRequireDefault(_Interpolate2); + + exports.Interpolate = _Interpolate3['default']; + + var _Jumbotron2 = __webpack_require__(176); + + var _Jumbotron3 = _interopRequireDefault(_Jumbotron2); + + exports.Jumbotron = _Jumbotron3['default']; + + var _Label2 = __webpack_require__(177); + + var _Label3 = _interopRequireDefault(_Label2); + + exports.Label = _Label3['default']; + + var _ListGroup2 = __webpack_require__(178); + + var _ListGroup3 = _interopRequireDefault(_ListGroup2); + + exports.ListGroup = _ListGroup3['default']; + + var _ListGroupItem2 = __webpack_require__(179); + + var _ListGroupItem3 = _interopRequireDefault(_ListGroupItem2); + + exports.ListGroupItem = _ListGroupItem3['default']; + + var _MenuItem2 = __webpack_require__(180); + + var _MenuItem3 = _interopRequireDefault(_MenuItem2); + + exports.MenuItem = _MenuItem3['default']; + + var _Modal2 = __webpack_require__(181); + + var _Modal3 = _interopRequireDefault(_Modal2); + + exports.Modal = _Modal3['default']; + + var _ModalBody2 = __webpack_require__(188); + + var _ModalBody3 = _interopRequireDefault(_ModalBody2); + + exports.ModalBody = _ModalBody3['default']; + + var _ModalFooter2 = __webpack_require__(191); + + var _ModalFooter3 = _interopRequireDefault(_ModalFooter2); + + exports.ModalFooter = _ModalFooter3['default']; + + var _ModalHeader2 = __webpack_require__(189); + + var _ModalHeader3 = _interopRequireDefault(_ModalHeader2); + + exports.ModalHeader = _ModalHeader3['default']; + + var _ModalTitle2 = __webpack_require__(190); + + var _ModalTitle3 = _interopRequireDefault(_ModalTitle2); + + exports.ModalTitle = _ModalTitle3['default']; + + var _Nav2 = __webpack_require__(207); + + var _Nav3 = _interopRequireDefault(_Nav2); + + exports.Nav = _Nav3['default']; + + var _Navbar2 = __webpack_require__(208); + + var _Navbar3 = _interopRequireDefault(_Navbar2); + + exports.Navbar = _Navbar3['default']; + + var _NavBrand2 = __webpack_require__(210); + + var _NavBrand3 = _interopRequireDefault(_NavBrand2); + + exports.NavBrand = _NavBrand3['default']; + + var _NavbarBrand2 = __webpack_require__(211); + + var _NavbarBrand3 = _interopRequireDefault(_NavbarBrand2); + + exports.NavbarBrand = _NavbarBrand3['default']; + + var _NavDropdown2 = __webpack_require__(215); + + var _NavDropdown3 = _interopRequireDefault(_NavDropdown2); + + exports.NavDropdown = _NavDropdown3['default']; + + var _NavItem2 = __webpack_require__(216); + + var _NavItem3 = _interopRequireDefault(_NavItem2); + + exports.NavItem = _NavItem3['default']; + + var _Overlay2 = __webpack_require__(217); + + var _Overlay3 = _interopRequireDefault(_Overlay2); + + exports.Overlay = _Overlay3['default']; + + var _OverlayTrigger2 = __webpack_require__(226); + + var _OverlayTrigger3 = _interopRequireDefault(_OverlayTrigger2); + + exports.OverlayTrigger = _OverlayTrigger3['default']; + + var _PageHeader2 = __webpack_require__(227); + + var _PageHeader3 = _interopRequireDefault(_PageHeader2); + + exports.PageHeader = _PageHeader3['default']; + + var _PageItem2 = __webpack_require__(228); + + var _PageItem3 = _interopRequireDefault(_PageItem2); + + exports.PageItem = _PageItem3['default']; + + var _Pager2 = __webpack_require__(229); + + var _Pager3 = _interopRequireDefault(_Pager2); + + exports.Pager = _Pager3['default']; + + var _Pagination2 = __webpack_require__(230); + + var _Pagination3 = _interopRequireDefault(_Pagination2); + + exports.Pagination = _Pagination3['default']; + + var _Panel2 = __webpack_require__(233); + + var _Panel3 = _interopRequireDefault(_Panel2); + + exports.Panel = _Panel3['default']; + + var _PanelGroup2 = __webpack_require__(35); + + var _PanelGroup3 = _interopRequireDefault(_PanelGroup2); + + exports.PanelGroup = _PanelGroup3['default']; + + var _Popover2 = __webpack_require__(234); + + var _Popover3 = _interopRequireDefault(_Popover2); + + exports.Popover = _Popover3['default']; + + var _ProgressBar2 = __webpack_require__(235); + + var _ProgressBar3 = _interopRequireDefault(_ProgressBar2); + + exports.ProgressBar = _ProgressBar3['default']; + + var _ResponsiveEmbed2 = __webpack_require__(236); + + var _ResponsiveEmbed3 = _interopRequireDefault(_ResponsiveEmbed2); + + exports.ResponsiveEmbed = _ResponsiveEmbed3['default']; + + var _Row2 = __webpack_require__(237); + + var _Row3 = _interopRequireDefault(_Row2); + + exports.Row = _Row3['default']; + + var _SafeAnchor2 = __webpack_require__(42); + + var _SafeAnchor3 = _interopRequireDefault(_SafeAnchor2); + + exports.SafeAnchor = _SafeAnchor3['default']; + + var _SplitButton3 = __webpack_require__(238); + + var _SplitButton4 = _interopRequireDefault(_SplitButton3); + + exports.SplitButton = _SplitButton4['default']; + + var _SplitButton5 = _interopRequireDefault(_SplitButton3); + + exports.SplitButton = _SplitButton5['default']; + + var _Tab2 = __webpack_require__(240); + + var _Tab3 = _interopRequireDefault(_Tab2); + + exports.Tab = _Tab3['default']; + + var _Table2 = __webpack_require__(241); + + var _Table3 = _interopRequireDefault(_Table2); + + exports.Table = _Table3['default']; + + var _Tabs2 = __webpack_require__(242); + + var _Tabs3 = _interopRequireDefault(_Tabs2); + + exports.Tabs = _Tabs3['default']; + + var _Thumbnail2 = __webpack_require__(243); + + var _Thumbnail3 = _interopRequireDefault(_Thumbnail2); + + exports.Thumbnail = _Thumbnail3['default']; + + var _Tooltip2 = __webpack_require__(244); + + var _Tooltip3 = _interopRequireDefault(_Tooltip2); + + exports.Tooltip = _Tooltip3['default']; + + var _Well2 = __webpack_require__(245); + + var _Well3 = _interopRequireDefault(_Well2); + + exports.Well = _Well3['default']; + + var _Collapse2 = __webpack_require__(67); + + var _Collapse3 = _interopRequireDefault(_Collapse2); + + exports.Collapse = _Collapse3['default']; + + var _Fade2 = __webpack_require__(186); + + var _Fade3 = _interopRequireDefault(_Fade2); + + exports.Fade = _Fade3['default']; + + var _FormControls2 = __webpack_require__(173); + + var _FormControls = _interopRequireWildcard(_FormControls2); + + exports.FormControls = _FormControls; + var utils = { + bootstrapUtils: _utilsBootstrapUtils2['default'], + childrenValueInputValidation: _utilsChildrenValueInputValidation2['default'], + createChainedFunction: _utilsCreateChainedFunction2['default'], + ValidComponentChildren: _utilsValidComponentChildren2['default'] + }; + exports.utils = utils; + +/***/ }, +/* 1 */ +/***/ function(module, exports) { + + "use strict"; + + exports["default"] = function (obj) { + return obj && obj.__esModule ? obj : { + "default": obj + }; + }; + + exports.__esModule = true; + +/***/ }, +/* 2 */ +/***/ function(module, exports) { + + "use strict"; + + exports["default"] = function (obj) { + if (obj && obj.__esModule) { + return obj; + } else { + var newObj = {}; + + if (obj != null) { + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; + } + } + + newObj["default"] = obj; + return newObj; + } + }; + + exports.__esModule = true; + +/***/ }, +/* 3 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + exports['default'] = valueValidation; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _reactPropTypesLibSinglePropFrom = __webpack_require__(5); + + var _reactPropTypesLibSinglePropFrom2 = _interopRequireDefault(_reactPropTypesLibSinglePropFrom); + + function valueValidation(props, propName, componentName) { + var error = _reactPropTypesLibSinglePropFrom2['default']('children', 'value')(props, propName, componentName); + + if (!error) { + error = _react2['default'].PropTypes.node(props, propName, componentName); + } + + return error; + } + + module.exports = exports['default']; + +/***/ }, +/* 4 */ +/***/ function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_4__; + +/***/ }, +/* 5 */ +/***/ function(module, exports) { + + /** + * 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} + */ + 'use strict'; + + exports.__esModule = true; + exports['default'] = createSinglePropFromChecker; + + function createSinglePropFromChecker() { + for (var _len = arguments.length, arrOfProps = Array(_len), _key = 0; _key < _len; _key++) { + arrOfProps[_key] = arguments[_key]; + } + + 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 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; + } + + module.exports = exports['default']; + +/***/ }, +/* 6 */ +/***/ function(module, exports) { + + /** + * Safe chained function + * + * Will only create a new function if needed, + * otherwise will pass back existing functions or null. + * + * @param {function} functions to chain + * @returns {function|null} + */ + 'use strict'; + + exports.__esModule = true; + function createChainedFunction() { + for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) { + funcs[_key] = arguments[_key]; + } + + return funcs.filter(function (f) { + return f != null; + }).reduce(function (acc, f) { + if (typeof f !== 'function') { + throw new Error('Invalid Argument Type, must only provide functions, undefined, or null.'); + } + + if (acc === null) { + return f; + } + + return function chainedFunction() { + for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + acc.apply(this, args); + f.apply(this, args); + }; + }, null); + } + + exports['default'] = createChainedFunction; + module.exports = exports['default']; + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + 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; + } + + function find(children, finder) { + var child = undefined; + + forEachValidComponents(children, function (c, idx) { + if (!child && finder(c, idx, children)) { + child = c; + } + }); + + return child; + } + + /** + * Finds 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)} findFunc. + * @param {*} findContext Context for findContext. + * @returns {array} of children that meet the findFunc return statement + */ + function findValidComponents(children, func, context) { + var index = 0; + var returnChildren = []; + + _react2['default'].Children.forEach(children, function (child) { + if (_react2['default'].isValidElement(child)) { + if (func.call(context, child, index)) { + returnChildren.push(child); + } + index++; + } + }); + + return returnChildren; + } + + exports['default'] = { + map: mapValidComponents, + forEach: forEachValidComponents, + numberOf: numberOfValidComponents, + find: find, + findValidComponents: findValidComponents, + hasValidComponent: hasValidComponent + }; + module.exports = exports['default']; + +/***/ }, +/* 8 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _styleMaps = __webpack_require__(25); + + var _styleMaps2 = _interopRequireDefault(_styleMaps); + + var _invariant = __webpack_require__(32); + + var _invariant2 = _interopRequireDefault(_invariant); + + var _warning = __webpack_require__(33); + + var _warning2 = _interopRequireDefault(_warning); + + function curry(fn) { + return function () { + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + var last = args[args.length - 1]; + if (typeof last === 'function') { + return fn.apply(undefined, args); + } + return function (Component) { + return fn.apply(undefined, args.concat([Component])); + }; + }; + } + + function prefix(props, variant) { + if (props === undefined) props = {}; + + !(props.bsClass || '').trim() ? true ? _invariant2['default'](false, 'A `bsClass` prop is required for this component') : _invariant2['default'](false) : undefined; + return props.bsClass + (variant ? '-' + variant : ''); + } + + var bsClass = curry(function (defaultClass, Component) { + var propTypes = Component.propTypes || (Component.propTypes = {}); + var defaultProps = Component.defaultProps || (Component.defaultProps = {}); + + propTypes.bsClass = _react.PropTypes.string; + defaultProps.bsClass = defaultClass; + + return Component; + }); + + exports.bsClass = bsClass; + var bsStyles = curry(function (styles, defaultStyle, Component) { + if (typeof defaultStyle !== 'string') { + Component = defaultStyle; + defaultStyle = undefined; + } + + var existing = Component.STYLES || []; + var propTypes = Component.propTypes || {}; + + styles.forEach(function (style) { + if (existing.indexOf(style) === -1) { + existing.push(style); + } + }); + + var propType = _react.PropTypes.oneOf(existing); + + // expose the values on the propType function for documentation + Component.STYLES = propType._values = existing; + + Component.propTypes = _extends({}, propTypes, { + bsStyle: propType + }); + + if (defaultStyle !== undefined) { + var defaultProps = Component.defaultProps || (Component.defaultProps = {}); + defaultProps.bsStyle = defaultStyle; + } + + return Component; + }); + + exports.bsStyles = bsStyles; + var bsSizes = curry(function (sizes, defaultSize, Component) { + if (typeof defaultSize !== 'string') { + Component = defaultSize; + defaultSize = undefined; + } + + var existing = Component.SIZES || []; + var propTypes = Component.propTypes || {}; + + sizes.forEach(function (size) { + if (existing.indexOf(size) === -1) { + existing.push(size); + } + }); + + var values = existing.reduce(function (result, size) { + if (_styleMaps2['default'].SIZES[size] && _styleMaps2['default'].SIZES[size] !== size) { + result.push(_styleMaps2['default'].SIZES[size]); + } + return result.concat(size); + }, []); + + var propType = _react.PropTypes.oneOf(values); + + propType._values = values; + + // expose the values on the propType function for documentation + Component.SIZES = existing; + + Component.propTypes = _extends({}, propTypes, { + bsSize: propType + }); + + if (defaultSize !== undefined) { + var defaultProps = Component.defaultProps || (Component.defaultProps = {}); + defaultProps.bsSize = defaultSize; + } + + return Component; + }); + + exports.bsSizes = bsSizes; + exports['default'] = { + + prefix: prefix, + + getClassSet: function getClassSet(props) { + var classes = {}; + var bsClassName = prefix(props); + + if (bsClassName) { + var bsSize = undefined; + + classes[bsClassName] = true; + + if (props.bsSize) { + bsSize = _styleMaps2['default'].SIZES[props.bsSize] || bsSize; + } + + if (bsSize) { + classes[prefix(props, bsSize)] = true; + } + + if (props.bsStyle) { + if (props.bsStyle.indexOf(prefix(props)) === 0) { + true ? _warning2['default'](false, // small migration convenience, since the old method required manual prefixing + 'bsStyle will automatically prefix custom values with the bsClass, so there is no ' + 'need to append it manually. (bsStyle: ' + props.bsStyle + ', bsClass: ' + prefix(props) + ')') : undefined; + classes[props.bsStyle] = true; + } else { + classes[prefix(props, props.bsStyle)] = true; + } + } + } + + return classes; + }, + + /** + * Add a style variant to a Component. Mutates the propTypes of the component + * in order to validate the new variant. + */ + addStyle: function addStyle(Component, styleVariant) { + bsStyles(styleVariant, Component); + } + }; + var _curry = curry; + exports._curry = _curry; + +/***/ }, +/* 9 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + + var _Object$assign = __webpack_require__(10)["default"]; + + exports["default"] = _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; + }; + + exports.__esModule = true; + +/***/ }, +/* 10 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(11), __esModule: true }; + +/***/ }, +/* 11 */ +/***/ function(module, exports, __webpack_require__) { + + __webpack_require__(12); + module.exports = __webpack_require__(15).Object.assign; + +/***/ }, +/* 12 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.3.1 Object.assign(target, source) + var $export = __webpack_require__(13); + + $export($export.S + $export.F, 'Object', {assign: __webpack_require__(18)}); + +/***/ }, +/* 13 */ +/***/ function(module, exports, __webpack_require__) { + + var global = __webpack_require__(14) + , core = __webpack_require__(15) + , ctx = __webpack_require__(16) + , PROTOTYPE = 'prototype'; + + var $export = function(type, name, source){ + var IS_FORCED = type & $export.F + , IS_GLOBAL = type & $export.G + , IS_STATIC = type & $export.S + , IS_PROTO = type & $export.P + , IS_BIND = type & $export.B + , IS_WRAP = type & $export.W + , exports = IS_GLOBAL ? core : core[name] || (core[name] = {}) + , target = IS_GLOBAL ? global : IS_STATIC ? global[name] : (global[name] || {})[PROTOTYPE] + , key, own, out; + if(IS_GLOBAL)source = name; + for(key in source){ + // contains in native + own = !IS_FORCED && target && key in target; + if(own && key in exports)continue; + // export native or passed + out = own ? target[key] : source[key]; + // prevent global pollution for namespaces + exports[key] = IS_GLOBAL && typeof target[key] != 'function' ? source[key] + // bind timers to global for call from export context + : IS_BIND && own ? ctx(out, global) + // wrap global constructors for prevent change them in library + : IS_WRAP && target[key] == out ? (function(C){ + var F = function(param){ + return this instanceof C ? new C(param) : C(param); + }; + F[PROTOTYPE] = C[PROTOTYPE]; + return F; + // make static versions for prototype methods + })(out) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out; + if(IS_PROTO)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out; + } + }; + // type bitmap + $export.F = 1; // forced + $export.G = 2; // global + $export.S = 4; // static + $export.P = 8; // proto + $export.B = 16; // bind + $export.W = 32; // wrap + module.exports = $export; + +/***/ }, +/* 14 */ +/***/ function(module, exports) { + + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); + if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef + +/***/ }, +/* 15 */ +/***/ function(module, exports) { + + var core = module.exports = {version: '1.2.6'}; + if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef + +/***/ }, +/* 16 */ +/***/ function(module, exports, __webpack_require__) { + + // optional / simple context binding + var aFunction = __webpack_require__(17); + module.exports = function(fn, that, length){ + aFunction(fn); + if(that === undefined)return fn; + switch(length){ + case 1: return function(a){ + return fn.call(that, a); + }; + case 2: return function(a, b){ + return fn.call(that, a, b); + }; + case 3: return function(a, b, c){ + return fn.call(that, a, b, c); + }; + } + return function(/* ...args */){ + return fn.apply(that, arguments); + }; + }; + +/***/ }, +/* 17 */ +/***/ function(module, exports) { + + module.exports = function(it){ + if(typeof it != 'function')throw TypeError(it + ' is not a function!'); + return it; + }; + +/***/ }, +/* 18 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.2.1 Object.assign(target, source, ...) + var $ = __webpack_require__(19) + , toObject = __webpack_require__(20) + , IObject = __webpack_require__(22); + + // should work with symbols and should have deterministic property order (V8 bug) + module.exports = __webpack_require__(24)(function(){ + var a = Object.assign + , A = {} + , B = {} + , S = Symbol() + , K = 'abcdefghijklmnopqrst'; + A[S] = 7; + K.split('').forEach(function(k){ B[k] = k; }); + return a({}, A)[S] != 7 || Object.keys(a({}, B)).join('') != K; + }) ? function assign(target, source){ // eslint-disable-line no-unused-vars + var T = toObject(target) + , $$ = arguments + , $$len = $$.length + , index = 1 + , getKeys = $.getKeys + , getSymbols = $.getSymbols + , isEnum = $.isEnum; + while($$len > index){ + var S = IObject($$[index++]) + , keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S) + , length = keys.length + , j = 0 + , key; + while(length > j)if(isEnum.call(S, key = keys[j++]))T[key] = S[key]; + } + return T; + } : Object.assign; + +/***/ }, +/* 19 */ +/***/ function(module, exports) { + + var $Object = Object; + module.exports = { + create: $Object.create, + getProto: $Object.getPrototypeOf, + isEnum: {}.propertyIsEnumerable, + getDesc: $Object.getOwnPropertyDescriptor, + setDesc: $Object.defineProperty, + setDescs: $Object.defineProperties, + getKeys: $Object.keys, + getNames: $Object.getOwnPropertyNames, + getSymbols: $Object.getOwnPropertySymbols, + each: [].forEach + }; + +/***/ }, +/* 20 */ +/***/ function(module, exports, __webpack_require__) { + + // 7.1.13 ToObject(argument) + var defined = __webpack_require__(21); + module.exports = function(it){ + return Object(defined(it)); + }; + +/***/ }, +/* 21 */ +/***/ function(module, exports) { + + // 7.2.1 RequireObjectCoercible(argument) + module.exports = function(it){ + if(it == undefined)throw TypeError("Can't call method on " + it); + return it; + }; + +/***/ }, +/* 22 */ +/***/ function(module, exports, __webpack_require__) { + + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var cof = __webpack_require__(23); + module.exports = Object('z').propertyIsEnumerable(0) ? Object : function(it){ + return cof(it) == 'String' ? it.split('') : Object(it); + }; + +/***/ }, +/* 23 */ +/***/ function(module, exports) { + + var toString = {}.toString; + + module.exports = function(it){ + return toString.call(it).slice(8, -1); + }; + +/***/ }, +/* 24 */ +/***/ function(module, exports) { + + module.exports = function(exec){ + try { + return !!exec(); + } catch(e){ + return true; + } + }; + +/***/ }, +/* 25 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _Object$assign = __webpack_require__(10)['default']; + + var _Object$create = __webpack_require__(26)['default']; + + var _Object$keys = __webpack_require__(28)['default']; + + exports.__esModule = true; + + var constant = function constant(obj) { + return _Object$assign(_Object$create({ + values: function values() { + var _this = this; + + return _Object$keys(this).map(function (k) { + return _this[k]; + }); + } + }), obj); + }; + + var styleMaps = { + + SIZES: { + 'large': 'lg', + 'medium': 'md', + 'small': 'sm', + 'xsmall': 'xs', + 'lg': 'lg', + 'md': 'md', + 'sm': 'sm', + 'xs': 'xs' + }, + GRID_COLUMNS: 12 + }; + + var Sizes = constant({ + LARGE: 'large', + MEDIUM: 'medium', + SMALL: 'small', + XSMALL: 'xsmall' + }); + + exports.Sizes = Sizes; + var State = constant({ + SUCCESS: 'success', + WARNING: 'warning', + DANGER: 'danger', + INFO: 'info' + }); + + exports.State = State; + var DEFAULT = 'default'; + exports.DEFAULT = DEFAULT; + var PRIMARY = 'primary'; + exports.PRIMARY = PRIMARY; + var LINK = 'link'; + exports.LINK = LINK; + var INVERSE = 'inverse'; + + exports.INVERSE = INVERSE; + exports['default'] = styleMaps; + +/***/ }, +/* 26 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(27), __esModule: true }; + +/***/ }, +/* 27 */ +/***/ function(module, exports, __webpack_require__) { + + var $ = __webpack_require__(19); + module.exports = function create(P, D){ + return $.create(P, D); + }; + +/***/ }, +/* 28 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(29), __esModule: true }; + +/***/ }, +/* 29 */ +/***/ function(module, exports, __webpack_require__) { + + __webpack_require__(30); + module.exports = __webpack_require__(15).Object.keys; + +/***/ }, +/* 30 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.2.14 Object.keys(O) + var toObject = __webpack_require__(20); + + __webpack_require__(31)('keys', function($keys){ + return function keys(it){ + return $keys(toObject(it)); + }; + }); + +/***/ }, +/* 31 */ +/***/ function(module, exports, __webpack_require__) { + + // most Object methods by ES6 should accept primitives + var $export = __webpack_require__(13) + , core = __webpack_require__(15) + , fails = __webpack_require__(24); + module.exports = function(KEY, exec){ + var fn = (core.Object || {})[KEY] || Object[KEY] + , exp = {}; + exp[KEY] = exec(fn); + $export($export.S + $export.F * fails(function(){ fn(1); }), 'Object', exp); + }; + +/***/ }, +/* 32 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Copyright 2013-2015, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + * + * @providesModule invariant + */ + + 'use strict'; + + /** + * Use invariant() to assert state which your program assumes to be true. + * + * Provide sprintf-style format (only %s is supported) and arguments + * to provide information about what broke and what you were + * expecting. + * + * The invariant message will be stripped in production, but the invariant + * will remain to ensure logic does not differ in production. + */ + + var invariant = function(condition, format, a, b, c, d, e, f) { + if (true) { + if (format === undefined) { + throw new Error('invariant requires an error message argument'); + } + } + + if (!condition) { + var error; + if (format === undefined) { + error = new Error( + 'Minified exception occurred; use the non-minified dev environment ' + + 'for the full error message and additional helpful warnings.' + ); + } else { + var args = [a, b, c, d, e, f]; + var argIndex = 0; + error = new Error( + 'Invariant Violation: ' + + format.replace(/%s/g, function() { return args[argIndex++]; }) + ); + } + + error.framesToPop = 1; // we don't care about invariant's own frame + throw error; + } + }; + + module.exports = invariant; + + +/***/ }, +/* 33 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Copyright 2014-2015, Facebook, Inc. + * All rights reserved. + * + * This source code is licensed under the BSD-style license found in the + * LICENSE file in the root directory of this source tree. An additional grant + * of patent rights can be found in the PATENTS file in the same directory. + */ + + 'use strict'; + + /** + * Similar to invariant but only logs a warning if the condition is not met. + * This can be used to log issues in development environments in critical + * paths. Removing the logging code for production environments will keep the + * same logic and follow the same code paths. + */ + + var warning = function() {}; + + if (true) { + warning = function(condition, format, args) { + var len = arguments.length; + args = new Array(len > 2 ? len - 2 : 0); + for (var key = 2; key < len; key++) { + args[key - 2] = arguments[key]; + } + if (format === undefined) { + throw new Error( + '`warning(condition, format, ...args)` requires a warning ' + + 'message argument' + ); + } + + if (format.length < 10 || (/^[s\W]*$/).test(format)) { + throw new Error( + 'The warning format should be able to uniquely identify this ' + + 'warning. Please, use a more descriptive format than: ' + format + ); + } + + if (!condition) { + var argIndex = 0; + var message = 'Warning: ' + + format.replace(/%s/g, function() { + return args[argIndex++]; + }); + if (typeof console !== 'undefined') { + console.error(message); + } + try { + // This error was thrown as a convenience so that you can use this stack + // to find the callsite that caused this warning to fire. + throw new Error(message); + } catch(x) {} + } + }; + } + + module.exports = warning; + + +/***/ }, +/* 34 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _PanelGroup = __webpack_require__(35); + + 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']; + +/***/ }, +/* 35 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var PanelGroup = _react2['default'].createClass({ + displayName: 'PanelGroup', + + 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 { + accordion: false + }; + }, + + getInitialState: function getInitialState() { + var defaultActiveKey = this.props.defaultActiveKey; + + return { + activeKey: defaultActiveKey + }; + }, + + render: function render() { + var classes = _utilsBootstrapUtils2['default'].getClassSet(this.props); + var _props = this.props; + var className = _props.className; + + var props = _objectWithoutProperties(_props, ['className']); + + if (this.props.accordion) { + props.role = 'tablist'; + } + return _react2['default'].createElement( + 'div', + _extends({}, props, { className: _classnames2['default'](className, classes), onSelect: null }), + _utilsValidComponentChildren2['default'].map(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.headerRole = 'tab'; + props.panelRole = 'tabpanel'; + props.collapsible = true; + props.expanded = child.props.eventKey === activeKey; + props.onSelect = this.handleSelect; + } + + return _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'] = _utilsBootstrapUtils.bsClass('panel-group', PanelGroup); + module.exports = exports['default']; + +/***/ }, +/* 36 */ +/***/ function(module, exports) { + + "use strict"; + + exports["default"] = function (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; + }; + + exports.__esModule = true; + +/***/ }, +/* 37 */ +/***/ 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 + */ + /* global define */ + + (function () { + 'use strict'; + + var hasOwn = {}.hasOwnProperty; + + function classNames () { + var classes = ''; + + for (var i = 0; i < arguments.length; i++) { + var arg = arguments[i]; + if (!arg) continue; + + var argType = typeof arg; + + if (argType === 'string' || argType === 'number') { + classes += ' ' + arg; + } else if (Array.isArray(arg)) { + classes += ' ' + classNames.apply(null, arg); + } else if (argType === 'object') { + for (var key in arg) { + if (hasOwn.call(arg, key) && arg[key]) { + classes += ' ' + key; + } + } + } + } + + return classes.substr(1); + } + + if (typeof module !== 'undefined' && module.exports) { + module.exports = classNames; + } else if (true) { + // register as 'classnames', consistent with npm package name + !(__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 { + window.classNames = classNames; + } + }()); + + +/***/ }, +/* 38 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _styleMaps = __webpack_require__(25); + + var Alert = _react2['default'].createClass({ + displayName: 'Alert', + + propTypes: { + onDismiss: _react2['default'].PropTypes.func, + dismissAfter: _react2['default'].PropTypes.number, + closeLabel: _react2['default'].PropTypes.string + }, + + getDefaultProps: function getDefaultProps() { + return { + closeLabel: 'Close Alert' + }; + }, + + renderDismissButton: function renderDismissButton() { + return _react2['default'].createElement( + 'button', + { + type: 'button', + className: 'close', + onClick: this.props.onDismiss, + 'aria-hidden': 'true' }, + _react2['default'].createElement( + 'span', + null, + '×' + ) + ); + }, + + renderSrOnlyDismissButton: function renderSrOnlyDismissButton() { + return _react2['default'].createElement( + 'button', + { + type: 'button', + className: 'close sr-only', + onClick: this.props.onDismiss }, + this.props.closeLabel + ); + }, + + render: function render() { + var classes = _utilsBootstrapUtils2['default'].getClassSet(this.props); + var isDismissable = !!this.props.onDismiss; + + classes[_utilsBootstrapUtils2['default'].prefix(this.props, 'dismissable')] = isDismissable; + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { role: 'alert', className: _classnames2['default'](this.props.className, classes) }), + isDismissable ? this.renderDismissButton() : null, + this.props.children, + isDismissable ? this.renderSrOnlyDismissButton() : null + ); + }, + + componentDidMount: function componentDidMount() { + if (this.props.dismissAfter && this.props.onDismiss) { + this.dismissTimer = setTimeout(this.props.onDismiss, this.props.dismissAfter); + } + }, + + componentWillUnmount: function componentWillUnmount() { + clearTimeout(this.dismissTimer); + } + }); + + exports['default'] = _utilsBootstrapUtils.bsStyles(_styleMaps.State.values(), _styleMaps.State.INFO, _utilsBootstrapUtils.bsClass('alert', Alert)); + module.exports = exports['default']; + +/***/ }, +/* 39 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var Badge = _react2['default'].createClass({ + displayName: 'Badge', + + propTypes: { + pullRight: _react2['default'].PropTypes.bool + }, + + getDefaultProps: function getDefaultProps() { + return { + pullRight: false, + bsClass: 'badge' + }; + }, + + hasContent: function hasContent() { + return _utilsValidComponentChildren2['default'].hasValidComponent(this.props.children) || _react2['default'].Children.count(this.props.children) > 1 || typeof this.props.children === 'string' || typeof this.props.children === 'number'; + }, + + render: function render() { + var _classes; + + var classes = (_classes = { + 'pull-right': this.props.pullRight + }, _classes[_utilsBootstrapUtils2['default'].prefix(this.props)] = this.hasContent(), _classes); + return _react2['default'].createElement( + 'span', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + } + }); + + exports['default'] = Badge; + module.exports = exports['default']; + +/***/ }, +/* 40 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var Breadcrumb = _react2['default'].createClass({ + displayName: 'Breadcrumb', + + propTypes: { + /** + * bootstrap className + * @private + */ + bsClass: _react2['default'].PropTypes.string + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'breadcrumb' + }; + }, + + render: function render() { + var _props = this.props; + var className = _props.className; + + var props = _objectWithoutProperties(_props, ['className']); + + return _react2['default'].createElement( + 'ol', + _extends({}, props, { + role: 'navigation', + 'aria-label': 'breadcrumbs', + className: _classnames2['default'](className, this.props.bsClass) }), + _utilsValidComponentChildren2['default'].map(this.props.children, this.renderBreadcrumbItem) + ); + }, + + renderBreadcrumbItem: function renderBreadcrumbItem(child, index) { + return _react.cloneElement(child, { key: child.key ? child.key : index }); + } + }); + + exports['default'] = Breadcrumb; + module.exports = exports['default']; + +/***/ }, +/* 41 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _warning = __webpack_require__(33); + + var _warning2 = _interopRequireDefault(_warning); + + var _SafeAnchor = __webpack_require__(42); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + var BreadcrumbItem = _react2['default'].createClass({ + displayName: 'BreadcrumbItem', + + propTypes: { + /** + * If set to true, renders `span` instead of `a` + */ + active: _react2['default'].PropTypes.bool, + /** + * HTML id for the wrapper `li` element + */ + id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + /** + * HTML id for the inner `a` element + */ + linkId: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + /** + * `href` attribute for the inner `a` element + */ + href: _react2['default'].PropTypes.string, + /** + * `title` attribute for the inner `a` element + */ + title: _react2['default'].PropTypes.node, + /** + * `target` attribute for the inner `a` element + */ + target: _react2['default'].PropTypes.string + }, + + getDefaultProps: function getDefaultProps() { + return { + active: false + }; + }, + + render: function render() { + var _props = this.props; + var active = _props.active; + var className = _props.className; + var id = _props.id; + var linkId = _props.linkId; + var children = _props.children; + var href = _props.href; + var title = _props.title; + var target = _props.target; + + var props = _objectWithoutProperties(_props, ['active', 'className', 'id', 'linkId', 'children', 'href', 'title', 'target']); + + true ? _warning2['default'](!(href && active), '[react-bootstrap] `href` and `active` properties cannot be set at the same time') : undefined; + + var linkProps = { + href: href, + title: title, + target: target, + id: linkId + }; + + return _react2['default'].createElement( + 'li', + { id: id, className: _classnames2['default'](className, { active: active }) }, + active ? _react2['default'].createElement( + 'span', + props, + children + ) : _react2['default'].createElement( + _SafeAnchor2['default'], + _extends({}, props, linkProps), + children + ) + ); + } + }); + + exports['default'] = BreadcrumbItem; + module.exports = exports['default']; + +/***/ }, +/* 42 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + /** + * Note: This is intended as a stop-gap for accessibility concerns that the + * Bootstrap CSS does not address as they have styled anchors and not buttons + * in many cases. + */ + + var SafeAnchor = (function (_React$Component) { + _inherits(SafeAnchor, _React$Component); + + function SafeAnchor(props) { + _classCallCheck(this, SafeAnchor); + + _React$Component.call(this, props); + + this.handleClick = this.handleClick.bind(this); + } + + SafeAnchor.prototype.handleClick = function handleClick(event) { + if (this.props.href === undefined) { + event.preventDefault(); + } + }; + + SafeAnchor.prototype.render = function render() { + return _react2['default'].createElement('a', _extends({ role: this.props.href ? undefined : 'button' + }, this.props, { + onClick: _utilsCreateChainedFunction2['default'](this.props.onClick, this.handleClick), + href: this.props.href || '' })); + }; + + return SafeAnchor; + })(_react2['default'].Component); + + exports['default'] = SafeAnchor; + + SafeAnchor.propTypes = { + href: _react2['default'].PropTypes.string, + onClick: _react2['default'].PropTypes.func + }; + module.exports = exports['default']; + +/***/ }, +/* 43 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + + var _Object$create = __webpack_require__(26)["default"]; + + var _Object$setPrototypeOf = __webpack_require__(44)["default"]; + + exports["default"] = function (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; + }; + + exports.__esModule = true; + +/***/ }, +/* 44 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(45), __esModule: true }; + +/***/ }, +/* 45 */ +/***/ function(module, exports, __webpack_require__) { + + __webpack_require__(46); + module.exports = __webpack_require__(15).Object.setPrototypeOf; + +/***/ }, +/* 46 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.3.19 Object.setPrototypeOf(O, proto) + var $export = __webpack_require__(13); + $export($export.S, 'Object', {setPrototypeOf: __webpack_require__(47).set}); + +/***/ }, +/* 47 */ +/***/ function(module, exports, __webpack_require__) { + + // Works with __proto__ only. Old v8 can't work with null proto objects. + /* eslint-disable no-proto */ + var getDesc = __webpack_require__(19).getDesc + , isObject = __webpack_require__(48) + , anObject = __webpack_require__(49); + var check = function(O, proto){ + anObject(O); + if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!"); + }; + module.exports = { + set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line + function(test, buggy, set){ + try { + set = __webpack_require__(16)(Function.call, getDesc(Object.prototype, '__proto__').set, 2); + set(test, []); + buggy = !(test instanceof Array); + } catch(e){ buggy = true; } + return function setPrototypeOf(O, proto){ + check(O, proto); + if(buggy)O.__proto__ = proto; + else set(O, proto); + return O; + }; + }({}, false) : undefined), + check: check + }; + +/***/ }, +/* 48 */ +/***/ function(module, exports) { + + module.exports = function(it){ + return typeof it === 'object' ? it !== null : typeof it === 'function'; + }; + +/***/ }, +/* 49 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(48); + module.exports = function(it){ + if(!isObject(it))throw TypeError(it + ' is not an object!'); + return it; + }; + +/***/ }, +/* 50 */ +/***/ function(module, exports) { + + "use strict"; + + exports["default"] = function (instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + }; + + exports.__esModule = true; + +/***/ }, +/* 51 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _reactPropTypesLibElementType = __webpack_require__(52); + + var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _styleMaps = __webpack_require__(25); + + var types = ['button', 'reset', 'submit']; + + var ButtonStyles = _styleMaps.State.values().concat(_styleMaps.DEFAULT, _styleMaps.PRIMARY, _styleMaps.LINK); + + var Button = _react2['default'].createClass({ + displayName: 'Button', + + propTypes: { + active: _react2['default'].PropTypes.bool, + disabled: _react2['default'].PropTypes.bool, + block: _react2['default'].PropTypes.bool, + navItem: _react2['default'].PropTypes.bool, + navDropdown: _react2['default'].PropTypes.bool, + /** + * You can use a custom element for this component + */ + componentClass: _reactPropTypesLibElementType2['default'], + href: _react2['default'].PropTypes.string, + target: _react2['default'].PropTypes.string, + /** + * Defines HTML button type Attribute + * @type {("button"|"reset"|"submit")} + * @defaultValue 'button' + */ + type: _react2['default'].PropTypes.oneOf(types) + }, + + getDefaultProps: function getDefaultProps() { + return { + active: false, + block: false, + disabled: false, + navItem: false, + navDropdown: false + }; + }, + + render: function render() { + var _extends2; + + var classes = this.props.navDropdown ? {} : _utilsBootstrapUtils2['default'].getClassSet(this.props); + var renderFuncName = undefined; + + var blockClass = _utilsBootstrapUtils2['default'].prefix(this.props, 'block'); + + classes = _extends((_extends2 = { + active: this.props.active + }, _extends2[blockClass] = this.props.block, _extends2), classes); + + if (this.props.navItem) { + return this.renderNavItem(classes); + } + + renderFuncName = this.props.href || this.props.target || this.props.navDropdown ? 'renderAnchor' : 'renderButton'; + + return this[renderFuncName](classes); + }, + + renderAnchor: function renderAnchor(classes) { + var Component = this.props.componentClass || 'a'; + var href = this.props.href || '#'; + classes.disabled = this.props.disabled; + + return _react2['default'].createElement( + Component, + _extends({}, this.props, { + href: href, + className: _classnames2['default'](this.props.className, classes), + role: 'button' }), + this.props.children + ); + }, + + renderButton: function renderButton(classes) { + var Component = this.props.componentClass || 'button'; + + return _react2['default'].createElement( + Component, + _extends({}, this.props, { + type: this.props.type || 'button', + className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + }, + + renderNavItem: function renderNavItem(classes) { + var liClasses = { + active: this.props.active + }; + + return _react2['default'].createElement( + 'li', + { className: _classnames2['default'](liClasses) }, + this.renderAnchor(classes) + ); + } + }); + + Button.types = types; + + exports['default'] = _utilsBootstrapUtils.bsStyles(ButtonStyles, _styleMaps.DEFAULT, _utilsBootstrapUtils.bsSizes([_styleMaps.Sizes.LARGE, _styleMaps.Sizes.SMALL, _styleMaps.Sizes.XSMALL], _utilsBootstrapUtils.bsClass('btn', Button))); + module.exports = exports['default']; + +/***/ }, +/* 52 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _common = __webpack_require__(53); + + /** + * 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} + */ + + function validate(props, propName, componentName) { + var errBeginning = _common.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(...)'); + } + } + } + + exports['default'] = _common.createChainableTypeChecker(validate); + module.exports = exports['default']; + +/***/ }, +/* 53 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + exports.errMsg = errMsg; + exports.createChainableTypeChecker = createChainableTypeChecker; + + 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 || '<>'; + 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; + } + +/***/ }, +/* 54 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _reactPropTypesLibAll = __webpack_require__(55); + + var _reactPropTypesLibAll2 = _interopRequireDefault(_reactPropTypesLibAll); + + var _Button = __webpack_require__(51); + + var _Button2 = _interopRequireDefault(_Button); + + var ButtonGroup = _react2['default'].createClass({ + displayName: 'ButtonGroup', + + propTypes: { + vertical: _react2['default'].PropTypes.bool, + justified: _react2['default'].PropTypes.bool, + /** + * Display block buttons, only useful when used with the "vertical" prop. + * @type {bool} + */ + block: _reactPropTypesLibAll2['default'](_react2['default'].PropTypes.bool, function (props) { + if (props.block && !props.vertical) { + return new Error('The block property requires the vertical property to be set to have any effect'); + } + }) + }, + + getDefaultProps: function getDefaultProps() { + return { + block: false, + justified: false, + vertical: false + }; + }, + + render: function render() { + var classes = _utilsBootstrapUtils2['default'].getClassSet(this.props); + + classes[_utilsBootstrapUtils2['default'].prefix(this.props)] = !this.props.vertical; + classes[_utilsBootstrapUtils2['default'].prefix(this.props, 'vertical')] = this.props.vertical; + classes[_utilsBootstrapUtils2['default'].prefix(this.props, 'justified')] = this.props.justified; + + // this is annoying, since the class is `btn-block` not `btn-group-block` + classes[_utilsBootstrapUtils2['default'].prefix(_Button2['default'].defaultProps, 'block')] = this.props.block; + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + } + }); + + exports['default'] = _utilsBootstrapUtils.bsClass('btn-group', ButtonGroup); + module.exports = exports['default']; + +/***/ }, +/* 55 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = all; + + function all() { + for (var _len = arguments.length, propTypes = Array(_len), _key = 0; _key < _len; _key++) { + propTypes[_key] = arguments[_key]; + } + + if (propTypes === undefined) { + throw new Error('No validations provided'); + } + + if (propTypes.some(function (propType) { + return typeof propType !== 'function'; + })) { + throw new Error('Invalid arguments, must be functions'); + } + + if (propTypes.length === 0) { + throw new Error('No validations provided'); + } + + return function validate(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; + } + } + }; + } + + module.exports = exports['default']; + +/***/ }, +/* 56 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _Button = __webpack_require__(51); + + var _Button2 = _interopRequireDefault(_Button); + + var _FormGroup = __webpack_require__(57); + + var _FormGroup2 = _interopRequireDefault(_FormGroup); + + var _InputBase2 = __webpack_require__(58); + + var _InputBase3 = _interopRequireDefault(_InputBase2); + + var _utilsChildrenValueInputValidation = __webpack_require__(3); + + var _utilsChildrenValueInputValidation2 = _interopRequireDefault(_utilsChildrenValueInputValidation); + + var ButtonInput = (function (_InputBase) { + _inherits(ButtonInput, _InputBase); + + function ButtonInput() { + _classCallCheck(this, ButtonInput); + + _InputBase.apply(this, arguments); + } + + ButtonInput.prototype.renderFormGroup = function renderFormGroup(children) { + var _props = this.props; + var bsStyle = _props.bsStyle; + var value = _props.value; + + var other = _objectWithoutProperties(_props, ['bsStyle', 'value']); + + return _react2['default'].createElement( + _FormGroup2['default'], + other, + children + ); + }; + + ButtonInput.prototype.renderInput = function renderInput() { + var _props2 = this.props; + var children = _props2.children; + var value = _props2.value; + + var other = _objectWithoutProperties(_props2, ['children', 'value']); + + var val = children ? children : value; + return _react2['default'].createElement(_Button2['default'], _extends({}, other, { componentClass: 'input', ref: 'input', key: 'input', value: val })); + }; + + return ButtonInput; + })(_InputBase3['default']); + + ButtonInput.types = _Button2['default'].types; + + ButtonInput.defaultProps = { + type: 'button' + }; + + ButtonInput.propTypes = { + type: _react2['default'].PropTypes.oneOf(ButtonInput.types), + bsStyle: function bsStyle() { + // defer to Button propTypes of bsStyle + return null; + }, + children: _utilsChildrenValueInputValidation2['default'], + value: _utilsChildrenValueInputValidation2['default'] + }; + + exports['default'] = ButtonInput; + module.exports = exports['default']; + +/***/ }, +/* 57 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var FormGroup = (function (_React$Component) { + _inherits(FormGroup, _React$Component); + + function FormGroup() { + _classCallCheck(this, FormGroup); + + _React$Component.apply(this, arguments); + } + + FormGroup.prototype.render = function render() { + var classes = { + 'form-group': !this.props.standalone, + 'form-group-lg': !this.props.standalone && this.props.bsSize === 'large', + 'form-group-sm': !this.props.standalone && this.props.bsSize === 'small', + 'has-feedback': this.props.hasFeedback, + 'has-success': this.props.bsStyle === 'success', + 'has-warning': this.props.bsStyle === 'warning', + 'has-error': this.props.bsStyle === 'error' + }; + + return _react2['default'].createElement( + 'div', + { className: _classnames2['default'](classes, this.props.groupClassName) }, + this.props.children + ); + }; + + return FormGroup; + })(_react2['default'].Component); + + FormGroup.defaultProps = { + hasFeedback: false, + standalone: false + }; + + FormGroup.propTypes = { + standalone: _react2['default'].PropTypes.bool, + hasFeedback: _react2['default'].PropTypes.bool, + bsSize: function bsSize(props) { + if (props.standalone && props.bsSize !== undefined) { + return new Error('bsSize will not be used when `standalone` is set.'); + } + + return _react2['default'].PropTypes.oneOf(['small', 'medium', 'large']).apply(null, arguments); + }, + bsStyle: _react2['default'].PropTypes.oneOf(['success', 'warning', 'error']), + groupClassName: _react2['default'].PropTypes.string + }; + + exports['default'] = FormGroup; + module.exports = exports['default']; + +/***/ }, +/* 58 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _FormGroup = __webpack_require__(57); + + var _FormGroup2 = _interopRequireDefault(_FormGroup); + + var _Glyphicon = __webpack_require__(59); + + var _Glyphicon2 = _interopRequireDefault(_Glyphicon); + + var InputBase = (function (_React$Component) { + _inherits(InputBase, _React$Component); + + function InputBase() { + _classCallCheck(this, InputBase); + + _React$Component.apply(this, arguments); + } + + InputBase.prototype.getInputDOMNode = function getInputDOMNode() { + return this.refs.input; + }; + + InputBase.prototype.getValue = function getValue() { + if (this.props.type === 'static') { + return this.props.value; + } else if (this.props.type) { + if (this.props.type === 'select' && this.props.multiple) { + return this.getSelectedOptions(); + } + return this.getInputDOMNode().value; + } + throw new Error('Cannot use getValue without specifying input type.'); + }; + + InputBase.prototype.getChecked = function getChecked() { + return this.getInputDOMNode().checked; + }; + + InputBase.prototype.getSelectedOptions = function getSelectedOptions() { + var values = []; + + Array.prototype.forEach.call(this.getInputDOMNode().getElementsByTagName('option'), function (option) { + if (option.selected) { + var value = option.getAttribute('value') || option.innerHtml; + values.push(value); + } + }); + + return values; + }; + + InputBase.prototype.isCheckboxOrRadio = function isCheckboxOrRadio() { + return this.props.type === 'checkbox' || this.props.type === 'radio'; + }; + + InputBase.prototype.isFile = function isFile() { + return this.props.type === 'file'; + }; + + InputBase.prototype.renderInputGroup = function renderInputGroup(children) { + var addonBefore = this.props.addonBefore ? _react2['default'].createElement( + 'span', + { className: 'input-group-addon', key: 'addonBefore' }, + this.props.addonBefore + ) : null; + + var addonAfter = this.props.addonAfter ? _react2['default'].createElement( + 'span', + { className: 'input-group-addon', key: 'addonAfter' }, + this.props.addonAfter + ) : null; + + var buttonBefore = this.props.buttonBefore ? _react2['default'].createElement( + 'span', + { className: 'input-group-btn' }, + this.props.buttonBefore + ) : null; + + var buttonAfter = this.props.buttonAfter ? _react2['default'].createElement( + 'span', + { className: 'input-group-btn' }, + this.props.buttonAfter + ) : null; + + var inputGroupClassName = undefined; + switch (this.props.bsSize) { + case 'small': + inputGroupClassName = 'input-group-sm';break; + case 'large': + inputGroupClassName = 'input-group-lg';break; + default: + } + + return addonBefore || addonAfter || buttonBefore || buttonAfter ? _react2['default'].createElement( + 'div', + { className: _classnames2['default'](inputGroupClassName, 'input-group'), key: 'input-group' }, + addonBefore, + buttonBefore, + children, + addonAfter, + buttonAfter + ) : children; + }; + + InputBase.prototype.renderIcon = function renderIcon() { + if (this.props.hasFeedback) { + if (this.props.feedbackIcon) { + return _react2['default'].cloneElement(this.props.feedbackIcon, { formControlFeedback: true }); + } + + switch (this.props.bsStyle) { + case 'success': + return _react2['default'].createElement(_Glyphicon2['default'], { formControlFeedback: true, glyph: 'ok', key: 'icon' }); + case 'warning': + return _react2['default'].createElement(_Glyphicon2['default'], { formControlFeedback: true, glyph: 'warning-sign', key: 'icon' }); + case 'error': + return _react2['default'].createElement(_Glyphicon2['default'], { formControlFeedback: true, glyph: 'remove', key: 'icon' }); + default: + return _react2['default'].createElement('span', { className: 'form-control-feedback', key: 'icon' }); + } + } else { + return null; + } + }; + + InputBase.prototype.renderHelp = function renderHelp() { + return this.props.help ? _react2['default'].createElement( + 'span', + { className: 'help-block', key: 'help' }, + this.props.help + ) : null; + }; + + InputBase.prototype.renderCheckboxAndRadioWrapper = function renderCheckboxAndRadioWrapper(children) { + var classes = { + 'checkbox': this.props.type === 'checkbox', + 'radio': this.props.type === 'radio' + }; + + return _react2['default'].createElement( + 'div', + { className: _classnames2['default'](classes), key: 'checkboxRadioWrapper' }, + children + ); + }; + + InputBase.prototype.renderWrapper = function renderWrapper(children) { + return this.props.wrapperClassName ? _react2['default'].createElement( + 'div', + { className: this.props.wrapperClassName, key: 'wrapper' }, + children + ) : children; + }; + + InputBase.prototype.renderLabel = function renderLabel(children) { + var classes = { + 'control-label': !this.isCheckboxOrRadio() + }; + classes[this.props.labelClassName] = this.props.labelClassName; + + return this.props.label ? _react2['default'].createElement( + 'label', + { htmlFor: this.props.id, className: _classnames2['default'](classes), key: 'label' }, + children, + this.props.label + ) : children; + }; + + InputBase.prototype.renderInput = function renderInput() { + if (!this.props.type) { + return this.props.children; + } + + switch (this.props.type) { + case 'select': + return _react2['default'].createElement( + 'select', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, 'form-control'), ref: 'input', key: 'input' }), + this.props.children + ); + case 'textarea': + return _react2['default'].createElement('textarea', _extends({}, this.props, { className: _classnames2['default'](this.props.className, 'form-control'), ref: 'input', key: 'input' })); + case 'static': + return _react2['default'].createElement( + 'p', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, 'form-control-static'), ref: 'input', key: 'input' }), + this.props.value + ); + default: + var className = this.isCheckboxOrRadio() || this.isFile() ? '' : 'form-control'; + return _react2['default'].createElement('input', _extends({}, this.props, { className: _classnames2['default'](this.props.className, className), ref: 'input', key: 'input' })); + } + }; + + InputBase.prototype.renderFormGroup = function renderFormGroup(children) { + return _react2['default'].createElement( + _FormGroup2['default'], + this.props, + children + ); + }; + + InputBase.prototype.renderChildren = function renderChildren() { + return !this.isCheckboxOrRadio() ? [this.renderLabel(), this.renderWrapper([this.renderInputGroup(this.renderInput()), this.renderIcon(), this.renderHelp()])] : this.renderWrapper([this.renderCheckboxAndRadioWrapper(this.renderLabel(this.renderInput())), this.renderHelp()]); + }; + + InputBase.prototype.render = function render() { + var children = this.renderChildren(); + return this.renderFormGroup(children); + }; + + return InputBase; + })(_react2['default'].Component); + + InputBase.propTypes = { + type: _react2['default'].PropTypes.string, + label: _react2['default'].PropTypes.node, + help: _react2['default'].PropTypes.node, + addonBefore: _react2['default'].PropTypes.node, + addonAfter: _react2['default'].PropTypes.node, + buttonBefore: _react2['default'].PropTypes.node, + buttonAfter: _react2['default'].PropTypes.node, + bsSize: _react2['default'].PropTypes.oneOf(['small', 'medium', 'large']), + bsStyle: _react2['default'].PropTypes.oneOf(['success', 'warning', 'error']), + hasFeedback: _react2['default'].PropTypes.bool, + feedbackIcon: _react2['default'].PropTypes.node, + id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + groupClassName: _react2['default'].PropTypes.string, + wrapperClassName: _react2['default'].PropTypes.string, + labelClassName: _react2['default'].PropTypes.string, + multiple: _react2['default'].PropTypes.bool, + disabled: _react2['default'].PropTypes.bool, + value: _react2['default'].PropTypes.any + }; + + InputBase.defaultProps = { + disabled: false, + hasFeedback: false, + multiple: false + }; + + exports['default'] = InputBase; + module.exports = exports['default']; + +/***/ }, +/* 59 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var Glyphicon = _react2['default'].createClass({ + displayName: 'Glyphicon', + + propTypes: { + /** + * bootstrap className + * @private + */ + bsClass: _react2['default'].PropTypes.string, + /** + * An icon name. See e.g. http://getbootstrap.com/components/#glyphicons + */ + glyph: _react2['default'].PropTypes.string.isRequired, + /** + * Adds 'form-control-feedback' class + * @private + */ + formControlFeedback: _react2['default'].PropTypes.bool + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'glyphicon', + formControlFeedback: false + }; + }, + + render: function render() { + var _classNames; + + var className = _classnames2['default'](this.props.className, (_classNames = {}, _classNames[this.props.bsClass] = true, _classNames['glyphicon-' + this.props.glyph] = true, _classNames['form-control-feedback'] = this.props.formControlFeedback, _classNames)); + + return _react2['default'].createElement( + 'span', + _extends({}, this.props, { className: className }), + this.props.children + ); + } + }); + + exports['default'] = Glyphicon; + module.exports = exports['default']; + +/***/ }, +/* 60 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _Button = __webpack_require__(51); + + var _Button2 = _interopRequireDefault(_Button); + + var ButtonToolbar = _react2['default'].createClass({ + displayName: 'ButtonToolbar', + + propTypes: { + bsSize: _Button2['default'].propTypes.bsSize + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'btn-toolbar' + }; + }, + + render: function render() { + var classes = _utilsBootstrapUtils2['default'].getClassSet(this.props); + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + role: 'toolbar', + className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + } + }); + + exports['default'] = ButtonToolbar; + module.exports = exports['default']; + +/***/ }, +/* 61 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _Glyphicon = __webpack_require__(59); + + var _Glyphicon2 = _interopRequireDefault(_Glyphicon); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var Carousel = _react2['default'].createClass({ + displayName: 'Carousel', + + propTypes: { + slide: _react2['default'].PropTypes.bool, + indicators: _react2['default'].PropTypes.bool, + interval: _react2['default'].PropTypes.number, + controls: _react2['default'].PropTypes.bool, + pauseOnHover: _react2['default'].PropTypes.bool, + wrap: _react2['default'].PropTypes.bool, + onSelect: _react2['default'].PropTypes.func, + onSlideEnd: _react2['default'].PropTypes.func, + activeIndex: _react2['default'].PropTypes.number, + defaultActiveIndex: _react2['default'].PropTypes.number, + direction: _react2['default'].PropTypes.oneOf(['prev', 'next']), + prevIcon: _react2['default'].PropTypes.node, + nextIcon: _react2['default'].PropTypes.node + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'carousel', + slide: true, + interval: 5000, + pauseOnHover: true, + wrap: true, + indicators: true, + controls: true, + prevIcon: _react2['default'].createElement(_Glyphicon2['default'], { glyph: 'chevron-left' }), + nextIcon: _react2['default'].createElement(_Glyphicon2['default'], { glyph: 'chevron-right' }) + }; + }, + + getInitialState: function getInitialState() { + return { + activeIndex: this.props.defaultActiveIndex == null ? 0 : this.props.defaultActiveIndex, + previousActiveIndex: null, + direction: null + }; + }, + + getDirection: function getDirection(prevIndex, index) { + if (prevIndex === index) { + return null; + } + + return prevIndex > index ? 'prev' : 'next'; + }, + + componentWillReceiveProps: function componentWillReceiveProps(nextProps) { + var activeIndex = this.getActiveIndex(); + + if (nextProps.activeIndex != null && nextProps.activeIndex !== activeIndex) { + clearTimeout(this.timeout); + this.setState({ + previousActiveIndex: activeIndex, + direction: nextProps.direction != null ? nextProps.direction : this.getDirection(activeIndex, nextProps.activeIndex) + }); + } + }, + + componentDidMount: function componentDidMount() { + this.waitForNext(); + }, + + componentWillUnmount: function componentWillUnmount() { + clearTimeout(this.timeout); + }, + + next: function next(e) { + if (e) { + e.preventDefault(); + } + + var index = this.getActiveIndex() + 1; + var count = _utilsValidComponentChildren2['default'].numberOf(this.props.children); + + if (index > count - 1) { + if (!this.props.wrap) { + return; + } + index = 0; + } + + this.handleSelect(index, 'next'); + }, + + prev: function prev(e) { + if (e) { + e.preventDefault(); + } + + var index = this.getActiveIndex() - 1; + + if (index < 0) { + if (!this.props.wrap) { + return; + } + index = _utilsValidComponentChildren2['default'].numberOf(this.props.children) - 1; + } + + this.handleSelect(index, 'prev'); + }, + + pause: function pause() { + this.isPaused = true; + clearTimeout(this.timeout); + }, + + play: function play() { + this.isPaused = false; + this.waitForNext(); + }, + + waitForNext: function waitForNext() { + if (!this.isPaused && this.props.slide && this.props.interval && this.props.activeIndex == null) { + this.timeout = setTimeout(this.next, this.props.interval); + } + }, + + handleMouseOver: function handleMouseOver() { + if (this.props.pauseOnHover) { + this.pause(); + } + }, + + handleMouseOut: function handleMouseOut() { + if (this.isPaused) { + this.play(); + } + }, + + render: function render() { + var _classes; + + var classes = (_classes = {}, _classes[_utilsBootstrapUtils2['default'].prefix(this.props)] = true, _classes.slide = this.props.slide, _classes); + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, classes), + onMouseOver: this.handleMouseOver, + onMouseOut: this.handleMouseOut }), + this.props.indicators ? this.renderIndicators() : null, + _react2['default'].createElement( + 'div', + { + ref: 'inner', + className: _utilsBootstrapUtils2['default'].prefix(this.props, 'inner') + }, + _utilsValidComponentChildren2['default'].map(this.props.children, this.renderItem) + ), + this.props.controls ? this.renderControls() : null + ); + }, + + renderPrev: function renderPrev() { + var classes = 'left ' + _utilsBootstrapUtils2['default'].prefix(this.props, 'control'); + + return _react2['default'].createElement( + 'a', + { className: classes, href: '#prev', key: 0, onClick: this.prev }, + this.props.prevIcon + ); + }, + + renderNext: function renderNext() { + var classes = 'right ' + _utilsBootstrapUtils2['default'].prefix(this.props, 'control'); + + return _react2['default'].createElement( + 'a', + { className: classes, href: '#next', key: 1, onClick: this.next }, + this.props.nextIcon + ); + }, + + renderControls: function renderControls() { + if (!this.props.wrap) { + var activeIndex = this.getActiveIndex(); + var count = _utilsValidComponentChildren2['default'].numberOf(this.props.children); + + return [activeIndex !== 0 ? this.renderPrev() : null, activeIndex !== count - 1 ? this.renderNext() : null]; + } + + return [this.renderPrev(), this.renderNext()]; + }, + + renderIndicator: function renderIndicator(child, index) { + var className = index === this.getActiveIndex() ? 'active' : null; + + return _react2['default'].createElement('li', { + key: index, + className: className, + onClick: this.handleSelect.bind(this, index, null) }); + }, + + renderIndicators: function renderIndicators() { + var _this = this; + + var indicators = []; + _utilsValidComponentChildren2['default'].forEach(this.props.children, function (child, index) { + indicators.push(_this.renderIndicator(child, index), + + // Force whitespace between indicator elements, bootstrap + // requires this for correct spacing of elements. + ' '); + }, this); + + return _react2['default'].createElement( + 'ol', + { className: _utilsBootstrapUtils2['default'].prefix(this.props, 'indicators') }, + indicators + ); + }, + + getActiveIndex: function getActiveIndex() { + return this.props.activeIndex != null ? this.props.activeIndex : this.state.activeIndex; + }, + + handleItemAnimateOutEnd: function handleItemAnimateOutEnd() { + var _this2 = this; + + this.setState({ + previousActiveIndex: null, + direction: null + }, function () { + _this2.waitForNext(); + + if (_this2.props.onSlideEnd) { + _this2.props.onSlideEnd(); + } + }); + }, + + renderItem: function renderItem(child, index) { + var activeIndex = this.getActiveIndex(); + var isActive = index === activeIndex; + var isPreviousActive = this.state.previousActiveIndex != null && this.state.previousActiveIndex === index && this.props.slide; + + return _react.cloneElement(child, { + active: isActive, + ref: child.ref, + key: child.key ? child.key : index, + index: index, + animateOut: isPreviousActive, + animateIn: isActive && this.state.previousActiveIndex != null && this.props.slide, + direction: this.state.direction, + onAnimateOutEnd: isPreviousActive ? this.handleItemAnimateOutEnd : null + }); + }, + + handleSelect: function handleSelect(index, direction) { + clearTimeout(this.timeout); + + if (this.isMounted()) { + var previousActiveIndex = this.getActiveIndex(); + direction = direction || this.getDirection(previousActiveIndex, index); + + if (this.props.onSelect) { + this.props.onSelect(index, direction); + } + + if (this.props.activeIndex == null && index !== previousActiveIndex) { + if (this.state.previousActiveIndex != null) { + // If currently animating don't activate the new index. + // TODO: look into queuing this canceled call and + // animating after the current animation has ended. + return; + } + + this.setState({ + activeIndex: index, + previousActiveIndex: previousActiveIndex, + direction: direction + }); + } + } + } + }); + + exports['default'] = Carousel; + module.exports = exports['default']; + +/***/ }, +/* 62 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + var _utilsTransitionEvents = __webpack_require__(64); + + var _utilsTransitionEvents2 = _interopRequireDefault(_utilsTransitionEvents); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var CarouselItem = _react2['default'].createClass({ + displayName: 'CarouselItem', + + propTypes: { + direction: _react2['default'].PropTypes.oneOf(['prev', 'next']), + onAnimateOutEnd: _react2['default'].PropTypes.func, + active: _react2['default'].PropTypes.bool, + animateIn: _react2['default'].PropTypes.bool, + animateOut: _react2['default'].PropTypes.bool, + caption: _react2['default'].PropTypes.node, + index: _react2['default'].PropTypes.number + }, + + getInitialState: function getInitialState() { + return { + direction: null + }; + }, + + getDefaultProps: function getDefaultProps() { + return { + bsStyle: 'carousel', + active: false, + animateIn: false, + animateOut: false + }; + }, + + handleAnimateOutEnd: function handleAnimateOutEnd() { + if (this.props.onAnimateOutEnd && this.isMounted()) { + this.props.onAnimateOutEnd(this.props.index); + } + }, + + componentWillReceiveProps: function componentWillReceiveProps(nextProps) { + if (this.props.active !== nextProps.active) { + this.setState({ + direction: null + }); + } + }, + + componentDidUpdate: function componentDidUpdate(prevProps) { + if (!this.props.active && prevProps.active) { + _utilsTransitionEvents2['default'].addEndEventListener(_reactDom2['default'].findDOMNode(this), this.handleAnimateOutEnd); + } + + if (this.props.active !== prevProps.active) { + setTimeout(this.startAnimation, 20); + } + }, + + startAnimation: function startAnimation() { + if (!this.isMounted()) { + return; + } + + this.setState({ + direction: this.props.direction === 'prev' ? 'right' : 'left' + }); + }, + + render: function render() { + var classes = { + item: true, + active: this.props.active && !this.props.animateIn || this.props.animateOut, + next: this.props.active && this.props.animateIn && this.props.direction === 'next', + prev: this.props.active && this.props.animateIn && this.props.direction === 'prev' + }; + + if (this.state.direction && (this.props.animateIn || this.props.animateOut)) { + classes[this.state.direction] = true; + } + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.props.children, + this.props.caption ? this.renderCaption() : null + ); + }, + + renderCaption: function renderCaption() { + var classes = _utilsBootstrapUtils2['default'].prefix(this.props, 'caption'); + + return _react2['default'].createElement( + 'div', + { className: classes }, + this.props.caption + ); + } + }); + + exports['default'] = CarouselItem; + module.exports = exports['default']; + +/***/ }, +/* 63 */ +/***/ function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_63__; + +/***/ }, +/* 64 */ +/***/ function(module, exports) { + + /** + * Copyright 2013-2014, Facebook, Inc. + * All rights reserved. + * + * This file contains a modified version of: + * https://github.com/facebook/react/blob/v0.12.0/src/addons/transitions/ReactTransitionEvents.js + * + * This source code is licensed under the BSD-style license found here: + * https://github.com/facebook/react/blob/v0.12.0/LICENSE + * An additional grant of patent rights can be found here: + * https://github.com/facebook/react/blob/v0.12.0/PATENTS + */ + + 'use strict'; + + exports.__esModule = true; + var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement); + + /** + * EVENT_NAME_MAP is used to determine which event fired when a + * transition/animation ends, based on the style property used to + * define that event. + */ + var EVENT_NAME_MAP = { + transitionend: { + 'transition': 'transitionend', + 'WebkitTransition': 'webkitTransitionEnd', + 'MozTransition': 'mozTransitionEnd', + 'OTransition': 'oTransitionEnd', + 'msTransition': 'MSTransitionEnd' + }, + + animationend: { + 'animation': 'animationend', + 'WebkitAnimation': 'webkitAnimationEnd', + 'MozAnimation': 'mozAnimationEnd', + 'OAnimation': 'oAnimationEnd', + 'msAnimation': 'MSAnimationEnd' + } + }; + + var endEvents = []; + + function detectEvents() { + var testEl = document.createElement('div'); + var style = testEl.style; + + // On some platforms, in particular some releases of Android 4.x, + // the un-prefixed "animation" and "transition" properties are defined on the + // style object but the events that fire will still be prefixed, so we need + // to check if the un-prefixed events are useable, and if not remove them + // from the map + if (!('AnimationEvent' in window)) { + delete EVENT_NAME_MAP.animationend.animation; + } + + if (!('TransitionEvent' in window)) { + delete EVENT_NAME_MAP.transitionend.transition; + } + + for (var baseEventName in EVENT_NAME_MAP) { + // eslint-disable-line guard-for-in + var baseEvents = EVENT_NAME_MAP[baseEventName]; + for (var styleName in baseEvents) { + if (styleName in style) { + endEvents.push(baseEvents[styleName]); + break; + } + } + } + } + + if (canUseDOM) { + detectEvents(); + } + + // We use the raw {add|remove}EventListener() call because EventListener + // does not know how to remove event listeners and we really should + // clean up. Also, these events are not triggered in older browsers + // so we should be A-OK here. + + function addEventListener(node, eventName, eventListener) { + node.addEventListener(eventName, eventListener, false); + } + + function removeEventListener(node, eventName, eventListener) { + node.removeEventListener(eventName, eventListener, false); + } + + var ReactTransitionEvents = { + addEndEventListener: function addEndEventListener(node, eventListener) { + if (endEvents.length === 0) { + // If CSS transitions are not supported, trigger an "end animation" + // event immediately. + window.setTimeout(eventListener, 0); + return; + } + endEvents.forEach(function (endEvent) { + addEventListener(node, endEvent, eventListener); + }); + }, + + removeEndEventListener: function removeEndEventListener(node, eventListener) { + if (endEvents.length === 0) { + return; + } + endEvents.forEach(function (endEvent) { + removeEventListener(node, endEvent, eventListener); + }); + } + }; + + exports['default'] = ReactTransitionEvents; + module.exports = exports['default']; + +/***/ }, +/* 65 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _Object$keys = __webpack_require__(28)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _styleMaps = __webpack_require__(25); + + var _styleMaps2 = _interopRequireDefault(_styleMaps); + + var _reactPropTypesLibElementType = __webpack_require__(52); + + var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType); + + var Col = _react2['default'].createClass({ + displayName: 'Col', + + propTypes: { + /** + * The number of columns you wish to span + * + * for Extra small devices Phones (<768px) + * + * class-prefix `col-xs-` + */ + xs: _react2['default'].PropTypes.number, + /** + * The number of columns you wish to span + * + * for Small devices Tablets (≥768px) + * + * class-prefix `col-sm-` + */ + sm: _react2['default'].PropTypes.number, + /** + * The number of columns you wish to span + * + * for Medium devices Desktops (≥992px) + * + * class-prefix `col-md-` + */ + md: _react2['default'].PropTypes.number, + /** + * The number of columns you wish to span + * + * for Large devices Desktops (≥1200px) + * + * class-prefix `col-lg-` + */ + lg: _react2['default'].PropTypes.number, + /** + * Move columns to the right + * + * for Extra small devices Phones + * + * class-prefix `col-xs-offset-` + */ + xsOffset: _react2['default'].PropTypes.number, + /** + * Move columns to the right + * + * for Small devices Tablets + * + * class-prefix `col-sm-offset-` + */ + smOffset: _react2['default'].PropTypes.number, + /** + * Move columns to the right + * + * for Medium devices Desktops + * + * class-prefix `col-md-offset-` + */ + mdOffset: _react2['default'].PropTypes.number, + /** + * Move columns to the right + * + * for Large devices Desktops + * + * class-prefix `col-lg-offset-` + */ + lgOffset: _react2['default'].PropTypes.number, + /** + * Change the order of grid columns to the right + * + * for Extra small devices Phones + * + * class-prefix `col-xs-push-` + */ + xsPush: _react2['default'].PropTypes.number, + /** + * Change the order of grid columns to the right + * + * for Small devices Tablets + * + * class-prefix `col-sm-push-` + */ + smPush: _react2['default'].PropTypes.number, + /** + * Change the order of grid columns to the right + * + * for Medium devices Desktops + * + * class-prefix `col-md-push-` + */ + mdPush: _react2['default'].PropTypes.number, + /** + * Change the order of grid columns to the right + * + * for Large devices Desktops + * + * class-prefix `col-lg-push-` + */ + lgPush: _react2['default'].PropTypes.number, + /** + * Change the order of grid columns to the left + * + * for Extra small devices Phones + * + * class-prefix `col-xs-pull-` + */ + xsPull: _react2['default'].PropTypes.number, + /** + * Change the order of grid columns to the left + * + * for Small devices Tablets + * + * class-prefix `col-sm-pull-` + */ + smPull: _react2['default'].PropTypes.number, + /** + * Change the order of grid columns to the left + * + * for Medium devices Desktops + * + * class-prefix `col-md-pull-` + */ + mdPull: _react2['default'].PropTypes.number, + /** + * Change the order of grid columns to the left + * + * for Large devices Desktops + * + * class-prefix `col-lg-pull-` + */ + lgPull: _react2['default'].PropTypes.number, + /** + * You can use a custom element for this component + */ + componentClass: _reactPropTypesLibElementType2['default'] + }, + + getDefaultProps: function getDefaultProps() { + return { + componentClass: 'div' + }; + }, + + render: function render() { + var _this = this; + + var ComponentClass = this.props.componentClass; + var classes = {}; + + _Object$keys(_styleMaps2['default'].SIZES).forEach(function (key) { + var size = _styleMaps2['default'].SIZES[key]; + var prop = size; + var classPart = size + '-'; + + if (_this.props[prop]) { + classes['col-' + classPart + _this.props[prop]] = true; + } + + prop = size + 'Offset'; + classPart = size + '-offset-'; + if (_this.props[prop] >= 0) { + classes['col-' + classPart + _this.props[prop]] = true; + } + + prop = size + 'Push'; + classPart = size + '-push-'; + if (_this.props[prop] >= 0) { + classes['col-' + classPart + _this.props[prop]] = true; + } + + prop = size + 'Pull'; + classPart = size + '-pull-'; + if (_this.props[prop] >= 0) { + classes['col-' + classPart + _this.props[prop]] = true; + } + }, this); + + return _react2['default'].createElement( + ComponentClass, + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + } + }); + + exports['default'] = Col; + module.exports = exports['default']; + +/***/ }, +/* 66 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _Collapse = __webpack_require__(67); + + var _Collapse2 = _interopRequireDefault(_Collapse); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsDeprecationWarning = __webpack_require__(81); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var CollapsibleNav = _react2['default'].createClass({ + displayName: 'CollapsibleNav', + + propTypes: { + onSelect: _react2['default'].PropTypes.func, + activeHref: _react2['default'].PropTypes.string, + activeKey: _react2['default'].PropTypes.any, + collapsible: _react2['default'].PropTypes.bool, + expanded: _react2['default'].PropTypes.bool, + eventKey: _react2['default'].PropTypes.any + }, + + getDefaultProps: function getDefaultProps() { + return { + collapsible: false, + expanded: false + }; + }, + + render: function render() { + /* + * this.props.collapsible is set in NavBar when an eventKey is supplied. + */ + var classes = this.props.collapsible ? 'navbar-collapse' : null; + var renderChildren = this.props.collapsible ? this.renderCollapsibleNavChildren : this.renderChildren; + + var nav = _react2['default'].createElement( + 'div', + { eventKey: this.props.eventKey, className: _classnames2['default'](this.props.className, classes) }, + _utilsValidComponentChildren2['default'].map(this.props.children, renderChildren) + ); + + if (this.props.collapsible) { + return _react2['default'].createElement( + _Collapse2['default'], + { 'in': this.props.expanded }, + nav + ); + } + return nav; + }, + + getChildActiveProp: function getChildActiveProp(child) { + if (child.props.active) { + return true; + } + if (this.props.activeKey != null) { + if (child.props.eventKey === this.props.activeKey) { + return true; + } + } + if (this.props.activeHref != null) { + if (child.props.href === this.props.activeHref) { + return true; + } + } + + return child.props.active; + }, + + renderChildren: function renderChildren(child, index) { + var key = child.key ? child.key : index; + return _react.cloneElement(child, { + activeKey: this.props.activeKey, + activeHref: this.props.activeHref, + ref: 'nocollapse_' + key, + key: key, + navItem: true + }); + }, + + renderCollapsibleNavChildren: function renderCollapsibleNavChildren(child, index) { + var key = child.key ? child.key : index; + return _react.cloneElement(child, { + active: this.getChildActiveProp(child), + activeKey: this.props.activeKey, + activeHref: this.props.activeHref, + onSelect: _utilsCreateChainedFunction2['default'](child.props.onSelect, this.props.onSelect), + ref: 'collapsible_' + key, + key: key, + navItem: true + }); + } + }); + + exports['default'] = _utilsDeprecationWarning2['default'].wrapper(CollapsibleNav, 'CollapsibleNav', 'Navbar.Collapse', 'http://react-bootstrap.github.io/components.html#navbars'); + module.exports = exports['default']; + +/***/ }, +/* 67 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _domHelpersStyle = __webpack_require__(68); + + var _domHelpersStyle2 = _interopRequireDefault(_domHelpersStyle); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _reactOverlaysLibTransition = __webpack_require__(76); + + var _reactOverlaysLibTransition2 = _interopRequireDefault(_reactOverlaysLibTransition); + + var _reactPropTypesLibDeprecated = __webpack_require__(80); + + var _reactPropTypesLibDeprecated2 = _interopRequireDefault(_reactPropTypesLibDeprecated); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var capitalize = function capitalize(str) { + return str[0].toUpperCase() + str.substr(1); + }; + + // reading a dimension prop will cause the browser to recalculate, + // which will let our animations work + var triggerBrowserReflow = function triggerBrowserReflow(node) { + return node.offsetHeight; + }; + + var MARGINS = { + height: ['marginTop', 'marginBottom'], + width: ['marginLeft', 'marginRight'] + }; + + function getDimensionValue(dimension, elem) { + var value = elem['offset' + capitalize(dimension)]; + var margins = MARGINS[dimension]; + + return value + parseInt(_domHelpersStyle2['default'](elem, margins[0]), 10) + parseInt(_domHelpersStyle2['default'](elem, margins[1]), 10); + } + + var Collapse = (function (_React$Component) { + _inherits(Collapse, _React$Component); + + function Collapse(props, context) { + _classCallCheck(this, Collapse); + + _React$Component.call(this, props, context); + + this.onEnterListener = this.handleEnter.bind(this); + this.onEnteringListener = this.handleEntering.bind(this); + this.onEnteredListener = this.handleEntered.bind(this); + this.onExitListener = this.handleExit.bind(this); + this.onExitingListener = this.handleExiting.bind(this); + } + + // Explicitly copied from Transition for doc generation. + // TODO: Remove duplication once #977 is resolved. + + Collapse.prototype.render = function render() { + var enter = _utilsCreateChainedFunction2['default'](this.onEnterListener, this.props.onEnter); + var entering = _utilsCreateChainedFunction2['default'](this.onEnteringListener, this.props.onEntering); + var entered = _utilsCreateChainedFunction2['default'](this.onEnteredListener, this.props.onEntered); + var exit = _utilsCreateChainedFunction2['default'](this.onExitListener, this.props.onExit); + var exiting = _utilsCreateChainedFunction2['default'](this.onExitingListener, this.props.onExiting); + + return _react2['default'].createElement( + _reactOverlaysLibTransition2['default'], + _extends({ + ref: 'transition' + }, this.props, { + 'aria-expanded': this.props.role ? this.props['in'] : null, + className: _classnames2['default'](this.props.className, { width: this._dimension() === 'width' }), + exitedClassName: 'collapse', + exitingClassName: 'collapsing', + enteredClassName: 'collapse in', + enteringClassName: 'collapsing', + onEnter: enter, + onEntering: entering, + onEntered: entered, + onExit: exit, + onExiting: exiting, + onExited: this.props.onExited + }), + this.props.children + ); + }; + + /* -- Expanding -- */ + + Collapse.prototype.handleEnter = function handleEnter(elem) { + var dimension = this._dimension(); + elem.style[dimension] = '0'; + }; + + Collapse.prototype.handleEntering = function handleEntering(elem) { + var dimension = this._dimension(); + + elem.style[dimension] = this._getScrollDimensionValue(elem, dimension); + }; + + Collapse.prototype.handleEntered = function handleEntered(elem) { + var dimension = this._dimension(); + elem.style[dimension] = null; + }; + + /* -- Collapsing -- */ + + Collapse.prototype.handleExit = function handleExit(elem) { + var dimension = this._dimension(); + + elem.style[dimension] = this.props.getDimensionValue(dimension, elem) + 'px'; + }; + + Collapse.prototype.handleExiting = function handleExiting(elem) { + var dimension = this._dimension(); + + triggerBrowserReflow(elem); + elem.style[dimension] = '0'; + }; + + Collapse.prototype._dimension = function _dimension() { + return typeof this.props.dimension === 'function' ? this.props.dimension() : this.props.dimension; + }; + + // for testing + + Collapse.prototype._getTransitionInstance = function _getTransitionInstance() { + return this.refs.transition; + }; + + Collapse.prototype._getScrollDimensionValue = function _getScrollDimensionValue(elem, dimension) { + return elem['scroll' + capitalize(dimension)] + 'px'; + }; + + return Collapse; + })(_react2['default'].Component); + + Collapse.propTypes = { + /** + * Show the component; triggers the expand or collapse animation + */ + 'in': _react2['default'].PropTypes.bool, + + /** + * Unmount the component (remove it from the DOM) when it is collapsed + */ + unmountOnExit: _react2['default'].PropTypes.bool, + + /** + * Run the expand animation when the component mounts, if it is initially + * shown + */ + transitionAppear: _react2['default'].PropTypes.bool, + + /** + * Duration of the collapse animation in milliseconds, to ensure that + * finishing callbacks are fired even if the original browser transition end + * events are canceled + */ + timeout: _react2['default'].PropTypes.number, + + /** + * duration + * @private + */ + duration: _reactPropTypesLibDeprecated2['default'](_react2['default'].PropTypes.number, 'Use `timeout`.'), + + /** + * Callback fired before the component expands + */ + onEnter: _react2['default'].PropTypes.func, + /** + * Callback fired after the component starts to expand + */ + onEntering: _react2['default'].PropTypes.func, + /** + * Callback fired after the component has expanded + */ + onEntered: _react2['default'].PropTypes.func, + /** + * Callback fired before the component collapses + */ + onExit: _react2['default'].PropTypes.func, + /** + * Callback fired after the component starts to collapse + */ + onExiting: _react2['default'].PropTypes.func, + /** + * Callback fired after the component has collapsed + */ + onExited: _react2['default'].PropTypes.func, + + /** + * The dimension used when collapsing, or a function that returns the + * dimension + * + * _Note: Bootstrap only partially supports 'width'! + * You will need to supply your own CSS animation for the `.width` CSS class._ + */ + dimension: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.oneOf(['height', 'width']), _react2['default'].PropTypes.func]), + + /** + * Function that returns the height or width of the animating DOM node + * + * Allows for providing some custom logic for how much the Collapse component + * should animate in its specified dimension. Called with the current + * dimension prop value and the DOM node. + */ + getDimensionValue: _react2['default'].PropTypes.func, + + /** + * ARIA role of collapsible element + */ + role: _react2['default'].PropTypes.string + }; + + Collapse.defaultProps = { + 'in': false, + timeout: 300, + unmountOnExit: false, + transitionAppear: false, + + dimension: 'height', + getDimensionValue: getDimensionValue + }; + + exports['default'] = Collapse; + module.exports = exports['default']; + +/***/ }, +/* 68 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var camelize = __webpack_require__(69), + hyphenate = __webpack_require__(71), + _getComputedStyle = __webpack_require__(73), + removeStyle = __webpack_require__(75); + + var has = Object.prototype.hasOwnProperty; + + module.exports = function style(node, property, value) { + var css = '', + props = property; + + if (typeof property === 'string') { + + if (value === undefined) return node.style[camelize(property)] || _getComputedStyle(node).getPropertyValue(hyphenate(property));else (props = {})[property] = value; + } + + for (var key in props) if (has.call(props, key)) { + !props[key] && props[key] !== 0 ? removeStyle(node, hyphenate(key)) : css += hyphenate(key) + ':' + props[key] + ';'; + } + + node.style.cssText += ';' + css; + }; + +/***/ }, +/* 69 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Copyright 2014-2015, Facebook, Inc. + * All rights reserved. + * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/camelizeStyleName.js + */ + + 'use strict'; + var camelize = __webpack_require__(70); + var msPattern = /^-ms-/; + + module.exports = function camelizeStyleName(string) { + return camelize(string.replace(msPattern, 'ms-')); + }; + +/***/ }, +/* 70 */ +/***/ function(module, exports) { + + "use strict"; + + var rHyphen = /-(.)/g; + + module.exports = function camelize(string) { + return string.replace(rHyphen, function (_, chr) { + return chr.toUpperCase(); + }); + }; + +/***/ }, +/* 71 */ +/***/ function(module, exports, __webpack_require__) { + + /** + * Copyright 2013-2014, Facebook, Inc. + * All rights reserved. + * https://github.com/facebook/react/blob/2aeb8a2a6beb00617a4217f7f8284924fa2ad819/src/vendor/core/hyphenateStyleName.js + */ + + "use strict"; + + var hyphenate = __webpack_require__(72); + var msPattern = /^ms-/; + + module.exports = function hyphenateStyleName(string) { + return hyphenate(string).replace(msPattern, "-ms-"); + }; + +/***/ }, +/* 72 */ +/***/ function(module, exports) { + + 'use strict'; + + var rUpper = /([A-Z])/g; + + module.exports = function hyphenate(string) { + return string.replace(rUpper, '-$1').toLowerCase(); + }; + +/***/ }, +/* 73 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var babelHelpers = __webpack_require__(74); + + var _utilCamelizeStyle = __webpack_require__(69); + + var _utilCamelizeStyle2 = babelHelpers.interopRequireDefault(_utilCamelizeStyle); + + var rposition = /^(top|right|bottom|left)$/; + var rnumnonpx = /^([+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|))(?!px)[a-z%]+$/i; + + module.exports = function _getComputedStyle(node) { + if (!node) throw new TypeError('No Element passed to `getComputedStyle()`'); + var doc = node.ownerDocument; + + return 'defaultView' in doc ? doc.defaultView.opener ? node.ownerDocument.defaultView.getComputedStyle(node, null) : window.getComputedStyle(node, null) : { //ie 8 "magic" from: https://github.com/jquery/jquery/blob/1.11-stable/src/css/curCSS.js#L72 + getPropertyValue: function getPropertyValue(prop) { + var style = node.style; + + prop = (0, _utilCamelizeStyle2['default'])(prop); + + if (prop == 'float') prop = 'styleFloat'; + + var current = node.currentStyle[prop] || null; + + if (current == null && style && style[prop]) current = style[prop]; + + if (rnumnonpx.test(current) && !rposition.test(prop)) { + // Remember the original values + var left = style.left; + var runStyle = node.runtimeStyle; + var rsLeft = runStyle && runStyle.left; + + // Put in the new values to get a computed value out + if (rsLeft) runStyle.left = node.currentStyle.left; + + style.left = prop === 'fontSize' ? '1em' : current; + current = style.pixelLeft + 'px'; + + // Revert the changed values + style.left = left; + if (rsLeft) runStyle.left = rsLeft; + } + + return current; + } + }; + }; + +/***/ }, +/* 74 */ +/***/ function(module, exports, __webpack_require__) { + + var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function (root, factory) { + if (true) { + !(__WEBPACK_AMD_DEFINE_ARRAY__ = [exports], __WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + } else if (typeof exports === "object") { + factory(exports); + } else { + factory(root.babelHelpers = {}); + } + })(this, function (global) { + var babelHelpers = global; + + babelHelpers.interopRequireDefault = function (obj) { + return obj && obj.__esModule ? obj : { + "default": obj + }; + }; + + babelHelpers._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; + }; + }) + +/***/ }, +/* 75 */ +/***/ function(module, exports) { + + 'use strict'; + + module.exports = function removeStyle(node, key) { + return 'removeProperty' in node.style ? node.style.removeProperty(key) : node.style.removeAttribute(key); + }; + +/***/ }, +/* 76 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = 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 }; } + + 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 _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__(4); + + var _react2 = _interopRequireDefault(_react); + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + var _domHelpersTransitionProperties = __webpack_require__(77); + + var _domHelpersTransitionProperties2 = _interopRequireDefault(_domHelpersTransitionProperties); + + var _domHelpersEventsOn = __webpack_require__(79); + + var _domHelpersEventsOn2 = _interopRequireDefault(_domHelpersEventsOn); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var transitionEndEvent = _domHelpersTransitionProperties2['default'].end; + + var UNMOUNTED = 0; + exports.UNMOUNTED = UNMOUNTED; + var EXITED = 1; + exports.EXITED = EXITED; + var ENTERING = 2; + exports.ENTERING = ENTERING; + var ENTERED = 3; + exports.ENTERED = ENTERED; + var EXITING = 4; + + exports.EXITING = EXITING; + /** + * The Transition component lets you define and run css transitions with a simple declarative api. + * It works similar to React's own [CSSTransitionGroup](http://facebook.github.io/react/docs/animation.html#high-level-api-reactcsstransitiongroup) + * but is specifically optimized for transitioning a single child "in" or "out". + * + * You don't even need to use class based css transitions if you don't want to (but it is easiest). + * The extensive set of lifecyle callbacks means you have control over + * the transitioning now at each step of the way. + */ + + var Transition = (function (_React$Component) { + function Transition(props, context) { + _classCallCheck(this, Transition); + + _React$Component.call(this, props, context); + + var initialStatus = undefined; + if (props['in']) { + // Start enter transition in componentDidMount. + initialStatus = props.transitionAppear ? EXITED : ENTERED; + } else { + initialStatus = props.unmountOnExit ? UNMOUNTED : EXITED; + } + this.state = { status: initialStatus }; + + this.nextCallback = null; + } + + _inherits(Transition, _React$Component); + + Transition.prototype.componentDidMount = function componentDidMount() { + if (this.props.transitionAppear && this.props['in']) { + this.performEnter(this.props); + } + }; + + Transition.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) { + var status = this.state.status; + if (nextProps['in']) { + if (status === EXITING) { + this.performEnter(nextProps); + } else if (this.props.unmountOnExit) { + if (status === UNMOUNTED) { + // Start enter transition in componentDidUpdate. + this.setState({ status: EXITED }); + } + } else if (status === EXITED) { + this.performEnter(nextProps); + } + + // Otherwise we're already entering or entered. + } else { + if (status === ENTERING || status === ENTERED) { + this.performExit(nextProps); + } + + // Otherwise we're already exited or exiting. + } + }; + + Transition.prototype.componentDidUpdate = function componentDidUpdate() { + if (this.props.unmountOnExit && this.state.status === EXITED) { + // EXITED is always a transitional state to either ENTERING or UNMOUNTED + // when using unmountOnExit. + if (this.props['in']) { + this.performEnter(this.props); + } else { + this.setState({ status: UNMOUNTED }); + } + } + }; + + Transition.prototype.componentWillUnmount = function componentWillUnmount() { + this.cancelNextCallback(); + }; + + Transition.prototype.performEnter = function performEnter(props) { + var _this = this; + + this.cancelNextCallback(); + var node = _reactDom2['default'].findDOMNode(this); + + // Not this.props, because we might be about to receive new props. + props.onEnter(node); + + this.safeSetState({ status: ENTERING }, function () { + _this.props.onEntering(node); + + _this.onTransitionEnd(node, function () { + _this.safeSetState({ status: ENTERED }, function () { + _this.props.onEntered(node); + }); + }); + }); + }; + + Transition.prototype.performExit = function performExit(props) { + var _this2 = this; + + this.cancelNextCallback(); + var node = _reactDom2['default'].findDOMNode(this); + + // Not this.props, because we might be about to receive new props. + props.onExit(node); + + this.safeSetState({ status: EXITING }, function () { + _this2.props.onExiting(node); + + _this2.onTransitionEnd(node, function () { + _this2.safeSetState({ status: EXITED }, function () { + _this2.props.onExited(node); + }); + }); + }); + }; + + Transition.prototype.cancelNextCallback = function cancelNextCallback() { + if (this.nextCallback !== null) { + this.nextCallback.cancel(); + this.nextCallback = null; + } + }; + + Transition.prototype.safeSetState = function safeSetState(nextState, callback) { + // This shouldn't be necessary, but there are weird race conditions with + // setState callbacks and unmounting in testing, so always make sure that + // we can cancel any pending setState callbacks after we unmount. + this.setState(nextState, this.setNextCallback(callback)); + }; + + Transition.prototype.setNextCallback = function setNextCallback(callback) { + var _this3 = this; + + var active = true; + + this.nextCallback = function (event) { + if (active) { + active = false; + _this3.nextCallback = null; + + callback(event); + } + }; + + this.nextCallback.cancel = function () { + active = false; + }; + + return this.nextCallback; + }; + + Transition.prototype.onTransitionEnd = function onTransitionEnd(node, handler) { + this.setNextCallback(handler); + + if (node) { + _domHelpersEventsOn2['default'](node, transitionEndEvent, this.nextCallback); + setTimeout(this.nextCallback, this.props.timeout); + } else { + setTimeout(this.nextCallback, 0); + } + }; + + Transition.prototype.render = function render() { + var status = this.state.status; + if (status === UNMOUNTED) { + return null; + } + + var _props = this.props; + var children = _props.children; + var className = _props.className; + + var childProps = _objectWithoutProperties(_props, ['children', 'className']); + + Object.keys(Transition.propTypes).forEach(function (key) { + return delete childProps[key]; + }); + + var transitionClassName = undefined; + if (status === EXITED) { + transitionClassName = this.props.exitedClassName; + } else if (status === ENTERING) { + transitionClassName = this.props.enteringClassName; + } else if (status === ENTERED) { + transitionClassName = this.props.enteredClassName; + } else if (status === EXITING) { + transitionClassName = this.props.exitingClassName; + } + + var child = _react2['default'].Children.only(children); + return _react2['default'].cloneElement(child, _extends({}, childProps, { + className: _classnames2['default'](child.props.className, className, transitionClassName) + })); + }; + + return Transition; + })(_react2['default'].Component); + + Transition.propTypes = { + /** + * Show the component; triggers the enter or exit animation + */ + 'in': _react2['default'].PropTypes.bool, + + /** + * Unmount the component (remove it from the DOM) when it is not shown + */ + unmountOnExit: _react2['default'].PropTypes.bool, + + /** + * Run the enter animation when the component mounts, if it is initially + * shown + */ + transitionAppear: _react2['default'].PropTypes.bool, + + /** + * A Timeout for the animation, in milliseconds, to ensure that a node doesn't + * transition indefinately if the browser transitionEnd events are + * canceled or interrupted. + * + * By default this is set to a high number (5 seconds) as a failsafe. You should consider + * setting this to the duration of your animation (or a bit above it). + */ + timeout: _react2['default'].PropTypes.number, + + /** + * CSS class or classes applied when the component is exited + */ + exitedClassName: _react2['default'].PropTypes.string, + /** + * CSS class or classes applied while the component is exiting + */ + exitingClassName: _react2['default'].PropTypes.string, + /** + * CSS class or classes applied when the component is entered + */ + enteredClassName: _react2['default'].PropTypes.string, + /** + * CSS class or classes applied while the component is entering + */ + enteringClassName: _react2['default'].PropTypes.string, + + /** + * Callback fired before the "entering" classes are applied + */ + onEnter: _react2['default'].PropTypes.func, + /** + * Callback fired after the "entering" classes are applied + */ + onEntering: _react2['default'].PropTypes.func, + /** + * Callback fired after the "enter" classes are applied + */ + onEntered: _react2['default'].PropTypes.func, + /** + * Callback fired before the "exiting" classes are applied + */ + onExit: _react2['default'].PropTypes.func, + /** + * Callback fired after the "exiting" classes are applied + */ + onExiting: _react2['default'].PropTypes.func, + /** + * Callback fired after the "exited" classes are applied + */ + onExited: _react2['default'].PropTypes.func + }; + + // Name the function so it is clearer in the documentation + function noop() {} + + Transition.displayName = 'Transition'; + + Transition.defaultProps = { + 'in': false, + unmountOnExit: false, + transitionAppear: false, + + timeout: 5000, + + onEnter: noop, + onEntering: noop, + onEntered: noop, + + onExit: noop, + onExiting: noop, + onExited: noop + }; + + exports['default'] = Transition; + +/***/ }, +/* 77 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var canUseDOM = __webpack_require__(78); + + var has = Object.prototype.hasOwnProperty, + transform = 'transform', + transition = {}, + transitionTiming, + transitionDuration, + transitionProperty, + transitionDelay; + + if (canUseDOM) { + transition = getTransitionProperties(); + + transform = transition.prefix + transform; + + transitionProperty = transition.prefix + 'transition-property'; + transitionDuration = transition.prefix + 'transition-duration'; + transitionDelay = transition.prefix + 'transition-delay'; + transitionTiming = transition.prefix + 'transition-timing-function'; + } + + module.exports = { + transform: transform, + end: transition.end, + property: transitionProperty, + timing: transitionTiming, + delay: transitionDelay, + duration: transitionDuration + }; + + function getTransitionProperties() { + var endEvent, + prefix = '', + transitions = { + O: 'otransitionend', + Moz: 'transitionend', + Webkit: 'webkitTransitionEnd', + ms: 'MSTransitionEnd' + }; + + var element = document.createElement('div'); + + for (var vendor in transitions) if (has.call(transitions, vendor)) { + if (element.style[vendor + 'TransitionProperty'] !== undefined) { + prefix = '-' + vendor.toLowerCase() + '-'; + endEvent = transitions[vendor]; + break; + } + } + + if (!endEvent && element.style.transitionProperty !== undefined) endEvent = 'transitionend'; + + return { end: endEvent, prefix: prefix }; + } + +/***/ }, +/* 78 */ +/***/ function(module, exports) { + + 'use strict'; + module.exports = !!(typeof window !== 'undefined' && window.document && window.document.createElement); + +/***/ }, +/* 79 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var canUseDOM = __webpack_require__(78); + var on = function on() {}; + + if (canUseDOM) { + on = (function () { + + if (document.addEventListener) return function (node, eventName, handler, capture) { + return node.addEventListener(eventName, handler, capture || false); + };else if (document.attachEvent) return function (node, eventName, handler) { + return node.attachEvent('on' + eventName, handler); + }; + })(); + } + + module.exports = on; + +/***/ }, +/* 80 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = deprecated; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _warning = __webpack_require__(33); + + var _warning2 = _interopRequireDefault(_warning); + + function deprecated(propType, explanation) { + return function validate(props, propName, componentName) { + if (props[propName] != null) { + _warning2['default'](false, '"' + propName + '" property of "' + componentName + '" has been deprecated.\n' + explanation); + } + + return propType(props, propName, componentName); + }; + } + + module.exports = exports['default']; + +/***/ }, +/* 81 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _warning = __webpack_require__(33); + + var _warning2 = _interopRequireDefault(_warning); + + var warned = {}; + + function deprecationWarning(oldname, newname, link) { + var message = undefined; + + if (typeof oldname === 'object') { + message = oldname.message; + } else { + message = oldname + ' is deprecated. Use ' + newname + ' instead.'; + + if (link) { + message += '\nYou can read more about it at ' + link; + } + } + + if (warned[message]) { + return; + } + + true ? _warning2['default'](false, message) : undefined; + warned[message] = true; + } + + deprecationWarning.wrapper = function (Component) { + for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return (function (_Component) { + _inherits(DeprecatedComponent, _Component); + + function DeprecatedComponent() { + _classCallCheck(this, DeprecatedComponent); + + _Component.apply(this, arguments); + } + + DeprecatedComponent.prototype.componentWillMount = function componentWillMount() { + deprecationWarning.apply(undefined, args); + + if (_Component.prototype.componentWillMount) { + var _Component$prototype$componentWillMount; + + for (var _len2 = arguments.length, methodArgs = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + methodArgs[_key2] = arguments[_key2]; + } + + (_Component$prototype$componentWillMount = _Component.prototype.componentWillMount).call.apply(_Component$prototype$componentWillMount, [this].concat(methodArgs)); + } + }; + + return DeprecatedComponent; + })(Component); + }; + + exports['default'] = deprecationWarning; + module.exports = exports['default']; + +/***/ }, +/* 82 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _domHelpersActiveElement = __webpack_require__(83); + + var _domHelpersActiveElement2 = _interopRequireDefault(_domHelpersActiveElement); + + var _domHelpersQueryContains = __webpack_require__(85); + + var _domHelpersQueryContains2 = _interopRequireDefault(_domHelpersQueryContains); + + var _keycode = __webpack_require__(86); + + var _keycode2 = _interopRequireDefault(_keycode); + + var _lodashCompatCollectionFind = __webpack_require__(87); + + var _lodashCompatCollectionFind2 = _interopRequireDefault(_lodashCompatCollectionFind); + + var _lodashCompatObjectOmit = __webpack_require__(140); + + var _lodashCompatObjectOmit2 = _interopRequireDefault(_lodashCompatObjectOmit); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + var _reactPropTypesLibAll = __webpack_require__(55); + + var _reactPropTypesLibAll2 = _interopRequireDefault(_reactPropTypesLibAll); + + var _reactPropTypesLibElementType = __webpack_require__(52); + + var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType); + + var _reactPropTypesLibIsRequiredForA11y = __webpack_require__(155); + + var _reactPropTypesLibIsRequiredForA11y2 = _interopRequireDefault(_reactPropTypesLibIsRequiredForA11y); + + var _uncontrollable = __webpack_require__(156); + + var _uncontrollable2 = _interopRequireDefault(_uncontrollable); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _ButtonGroup = __webpack_require__(54); + + var _ButtonGroup2 = _interopRequireDefault(_ButtonGroup); + + var _DropdownMenu = __webpack_require__(159); + + var _DropdownMenu2 = _interopRequireDefault(_DropdownMenu); + + var _DropdownToggle = __webpack_require__(165); + + var _DropdownToggle2 = _interopRequireDefault(_DropdownToggle); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _utilsCustomPropTypes = __webpack_require__(166); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var TOGGLE_REF = 'toggle-btn'; + var TOGGLE_ROLE = _DropdownToggle2['default'].defaultProps.bsRole; + var MENU_ROLE = _DropdownMenu2['default'].defaultProps.bsRole; + + var Dropdown = (function (_React$Component) { + _inherits(Dropdown, _React$Component); + + function Dropdown(props) { + _classCallCheck(this, Dropdown); + + _React$Component.call(this, props); + + this.Toggle = _DropdownToggle2['default']; + + this.toggleOpen = this.toggleOpen.bind(this); + this.handleClick = this.handleClick.bind(this); + this.handleKeyDown = this.handleKeyDown.bind(this); + this.handleClose = this.handleClose.bind(this); + this.extractChildren = this.extractChildren.bind(this); + + this.refineMenu = this.refineMenu.bind(this); + this.refineToggle = this.refineToggle.bind(this); + + this.childExtractors = [{ + key: 'toggle', + matches: function matches(child) { + return child.props.bsRole === TOGGLE_ROLE; + }, + refine: this.refineToggle + }, { + key: 'menu', + exclusive: true, + matches: function matches(child) { + return child.props.bsRole === MENU_ROLE; + }, + refine: this.refineMenu + }]; + + this.state = {}; + + this.lastOpenEventType = null; + } + + Dropdown.prototype.componentDidMount = function componentDidMount() { + this.focusNextOnOpen(); + }; + + Dropdown.prototype.componentWillUpdate = function componentWillUpdate(nextProps) { + if (!nextProps.open && this.props.open) { + this._focusInDropdown = _domHelpersQueryContains2['default'](_reactDom2['default'].findDOMNode(this.refs.menu), _domHelpersActiveElement2['default'](document)); + } + }; + + Dropdown.prototype.componentDidUpdate = function componentDidUpdate(prevProps) { + if (this.props.open && !prevProps.open) { + this.focusNextOnOpen(); + } + + if (!this.props.open && prevProps.open) { + // if focus hasn't already moved from the menu lets return it + // to the toggle + if (this._focusInDropdown) { + this._focusInDropdown = false; + this.focus(); + } + } + }; + + Dropdown.prototype.render = function render() { + var _rootClasses; + + var children = this.extractChildren(); + var Component = this.props.componentClass; + + var props = _lodashCompatObjectOmit2['default'](this.props, ['id', 'bsClass', 'role']); + var className = _utilsBootstrapUtils2['default'].prefix(this.props); + + var rootClasses = (_rootClasses = { + open: this.props.open, + disabled: this.props.disabled + }, _rootClasses[className] = !this.props.dropup, _rootClasses.dropup = this.props.dropup, _rootClasses); + + return _react2['default'].createElement( + Component, + _extends({}, props, { + tabIndex: '-1', + className: _classnames2['default'](this.props.className, rootClasses) + }), + children + ); + }; + + Dropdown.prototype.toggleOpen = function toggleOpen() { + var eventType = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0]; + + var open = !this.props.open; + + if (open) { + this.lastOpenEventType = eventType; + } + + if (this.props.onToggle) { + this.props.onToggle(open); + } + }; + + Dropdown.prototype.handleClick = function handleClick() { + if (this.props.disabled) { + return; + } + + this.toggleOpen('click'); + }; + + Dropdown.prototype.handleKeyDown = function handleKeyDown(event) { + if (this.props.disabled) { + return; + } + + switch (event.keyCode) { + case _keycode2['default'].codes.down: + if (!this.props.open) { + this.toggleOpen('keydown'); + } else if (this.refs.menu.focusNext) { + this.refs.menu.focusNext(); + } + event.preventDefault(); + break; + case _keycode2['default'].codes.esc: + case _keycode2['default'].codes.tab: + this.handleClose(event); + break; + default: + } + }; + + Dropdown.prototype.handleClose = function handleClose() { + if (!this.props.open) { + return; + } + + this.toggleOpen(); + }; + + Dropdown.prototype.focusNextOnOpen = function focusNextOnOpen() { + var menu = this.refs.menu; + + if (!menu.focusNext) { + return; + } + + if (this.lastOpenEventType === 'keydown' || this.props.role === 'menuitem') { + menu.focusNext(); + } + }; + + Dropdown.prototype.focus = function focus() { + var toggle = _reactDom2['default'].findDOMNode(this.refs[TOGGLE_REF]); + + if (toggle && toggle.focus) { + toggle.focus(); + } + }; + + Dropdown.prototype.extractChildren = function extractChildren() { + var _this = this; + + var open = !!this.props.open; + var seen = {}; + + return _utilsValidComponentChildren2['default'].map(this.props.children, function (child) { + var extractor = _lodashCompatCollectionFind2['default'](_this.childExtractors, function (x) { + return x.matches(child); + }); + + if (extractor) { + if (seen[extractor.key]) { + return false; + } + + seen[extractor.key] = extractor.exclusive; + child = extractor.refine(child, open); + } + + return child; + }); + }; + + Dropdown.prototype.refineMenu = function refineMenu(menu, open) { + var menuProps = { + ref: 'menu', + open: open, + labelledBy: this.props.id, + pullRight: this.props.pullRight, + bsClass: this.props.bsClass + }; + + menuProps.onClose = _utilsCreateChainedFunction2['default'](menu.props.onClose, this.props.onClose, this.handleClose); + + menuProps.onSelect = _utilsCreateChainedFunction2['default'](menu.props.onSelect, this.props.onSelect, this.handleClose); + + return _react.cloneElement(menu, menuProps, menu.props.children); + }; + + Dropdown.prototype.refineToggle = function refineToggle(toggle, open) { + var toggleProps = { + open: open, + id: this.props.id, + ref: TOGGLE_REF, + role: this.props.role + }; + + toggleProps.onClick = _utilsCreateChainedFunction2['default'](toggle.props.onClick, this.handleClick); + + toggleProps.onKeyDown = _utilsCreateChainedFunction2['default'](toggle.props.onKeyDown, this.handleKeyDown); + + return _react.cloneElement(toggle, toggleProps, toggle.props.children); + }; + + return Dropdown; + })(_react2['default'].Component); + + Dropdown.Toggle = _DropdownToggle2['default']; + + Dropdown.TOGGLE_REF = TOGGLE_REF; + Dropdown.TOGGLE_ROLE = TOGGLE_ROLE; + Dropdown.MENU_ROLE = MENU_ROLE; + + Dropdown.defaultProps = { + componentClass: _ButtonGroup2['default'], + bsClass: 'dropdown' + }; + + Dropdown.propTypes = { + + bsClass: _react2['default'].PropTypes.string, + + /** + * The menu will open above the dropdown button, instead of below it. + */ + dropup: _react2['default'].PropTypes.bool, + + /** + * An html id attribute, necessary for assistive technologies, such as screen readers. + * @type {string|number} + * @required + */ + id: _reactPropTypesLibIsRequiredForA11y2['default'](_react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number])), + + componentClass: _reactPropTypesLibElementType2['default'], + + /** + * The children of a Dropdown may be a `` or a ``. + * @type {node} + */ + children: _reactPropTypesLibAll2['default'](_utilsCustomPropTypes2['default'].requiredRoles(TOGGLE_ROLE, MENU_ROLE), _utilsCustomPropTypes2['default'].exclusiveRoles(MENU_ROLE)), + + /** + * Whether or not component is disabled. + */ + disabled: _react2['default'].PropTypes.bool, + + /** + * Align the menu to the right side of the Dropdown toggle + */ + pullRight: _react2['default'].PropTypes.bool, + + /** + * Whether or not the Dropdown is visible. + * + * @controllable onToggle + */ + open: _react2['default'].PropTypes.bool, + + /** + * A callback fired when the Dropdown closes. + */ + onClose: _react2['default'].PropTypes.func, + + /** + * A callback fired when the Dropdown wishes to change visibility. Called with the requested + * `open` value. + * + * ```js + * function(Boolean isOpen) {} + * ``` + * @controllable open + */ + onToggle: _react2['default'].PropTypes.func, + + /** + * A callback fired when a menu item is selected. + * + * ```js + * function(Object event, Any eventKey) + * ``` + */ + onSelect: _react2['default'].PropTypes.func, + + /** + * If `'menuitem'`, causes the dropdown to behave like a menu item rather than + * a menu button. + */ + role: _react2['default'].PropTypes.string + }; + + Dropdown = _uncontrollable2['default'](Dropdown, { open: 'onToggle' }); + + Dropdown.Toggle = _DropdownToggle2['default']; + Dropdown.Menu = _DropdownMenu2['default']; + + exports['default'] = Dropdown; + module.exports = exports['default']; + +/***/ }, +/* 83 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var babelHelpers = __webpack_require__(74); + + exports.__esModule = true; + + /** + * document.activeElement + */ + exports['default'] = activeElement; + + var _ownerDocument = __webpack_require__(84); + + var _ownerDocument2 = babelHelpers.interopRequireDefault(_ownerDocument); + + function activeElement() { + var doc = arguments[0] === undefined ? document : arguments[0]; + + try { + return doc.activeElement; + } catch (e) {} + } + + module.exports = exports['default']; + +/***/ }, +/* 84 */ +/***/ function(module, exports) { + + "use strict"; + + exports.__esModule = true; + exports["default"] = ownerDocument; + + function ownerDocument(node) { + return node && node.ownerDocument || document; + } + + module.exports = exports["default"]; + +/***/ }, +/* 85 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var canUseDOM = __webpack_require__(78); + + var contains = (function () { + var root = canUseDOM && document.documentElement; + + return root && root.contains ? function (context, node) { + return context.contains(node); + } : root && root.compareDocumentPosition ? function (context, node) { + return context === node || !!(context.compareDocumentPosition(node) & 16); + } : function (context, node) { + if (node) do { + if (node === context) return true; + } while (node = node.parentNode); + + return false; + }; + })(); + + module.exports = contains; + +/***/ }, +/* 86 */ +/***/ function(module, exports) { + + // Source: http://jsfiddle.net/vWx8V/ + // http://stackoverflow.com/questions/5603195/full-list-of-javascript-keycodes + + + + /** + * Conenience method returns corresponding value for given keyName or keyCode. + * + * @param {Mixed} keyCode {Number} or keyName {String} + * @return {Mixed} + * @api public + */ + + exports = module.exports = function(searchInput) { + // Keyboard Events + if (searchInput && 'object' === typeof searchInput) { + var hasKeyCode = searchInput.which || searchInput.keyCode || searchInput.charCode + if (hasKeyCode) searchInput = hasKeyCode + } + + // Numbers + if ('number' === typeof searchInput) return names[searchInput] + + // Everything else (cast to string) + var search = String(searchInput) + + // check codes + var foundNamedKey = codes[search.toLowerCase()] + if (foundNamedKey) return foundNamedKey + + // check aliases + var foundNamedKey = aliases[search.toLowerCase()] + if (foundNamedKey) return foundNamedKey + + // weird character? + if (search.length === 1) return search.charCodeAt(0) + + return undefined + } + + /** + * Get by name + * + * exports.code['enter'] // => 13 + */ + + var codes = exports.code = exports.codes = { + 'backspace': 8, + 'tab': 9, + 'enter': 13, + 'shift': 16, + 'ctrl': 17, + 'alt': 18, + 'pause/break': 19, + 'caps lock': 20, + 'esc': 27, + 'space': 32, + 'page up': 33, + 'page down': 34, + 'end': 35, + 'home': 36, + 'left': 37, + 'up': 38, + 'right': 39, + 'down': 40, + 'insert': 45, + 'delete': 46, + 'command': 91, + 'right click': 93, + 'numpad *': 106, + 'numpad +': 107, + 'numpad -': 109, + 'numpad .': 110, + 'numpad /': 111, + 'num lock': 144, + 'scroll lock': 145, + 'my computer': 182, + 'my calculator': 183, + ';': 186, + '=': 187, + ',': 188, + '-': 189, + '.': 190, + '/': 191, + '`': 192, + '[': 219, + '\\': 220, + ']': 221, + "'": 222, + } + + // Helper aliases + + var aliases = exports.aliases = { + 'windows': 91, + '⇧': 16, + '⌥': 18, + '⌃': 17, + '⌘': 91, + 'ctl': 17, + 'control': 17, + 'option': 18, + 'pause': 19, + 'break': 19, + 'caps': 20, + 'return': 13, + 'escape': 27, + 'spc': 32, + 'pgup': 33, + 'pgdn': 33, + 'ins': 45, + 'del': 46, + 'cmd': 91 + } + + + /*! + * Programatically add the following + */ + + // lower case chars + for (i = 97; i < 123; i++) codes[String.fromCharCode(i)] = i - 32 + + // numbers + for (var i = 48; i < 58; i++) codes[i - 48] = i + + // function keys + for (i = 1; i < 13; i++) codes['f'+i] = i + 111 + + // numpad keys + for (i = 0; i < 10; i++) codes['numpad '+i] = i + 96 + + /** + * Get by code + * + * exports.name[13] // => 'Enter' + */ + + var names = exports.names = exports.title = {} // title for backward compat + + // Create reverse mapping + for (i in codes) names[codes[i]] = i + + // Add aliases + for (var alias in aliases) { + codes[alias] = aliases[alias] + } + + +/***/ }, +/* 87 */ +/***/ function(module, exports, __webpack_require__) { + + var baseEach = __webpack_require__(88), + createFind = __webpack_require__(113); + + /** + * Iterates over elements of `collection`, returning the first element + * `predicate` returns truthy for. The predicate is bound to `thisArg` and + * invoked with three arguments: (value, index|key, collection). + * + * If a property name is provided for `predicate` the created `_.property` + * style callback returns the property value of the given element. + * + * If a value is also provided for `thisArg` the created `_.matchesProperty` + * style callback returns `true` for elements that have a matching property + * value, else `false`. + * + * If an object is provided for `predicate` the created `_.matches` style + * callback returns `true` for elements that have the properties of the given + * object, else `false`. + * + * @static + * @memberOf _ + * @alias detect + * @category Collection + * @param {Array|Object|string} collection The collection to search. + * @param {Function|Object|string} [predicate=_.identity] The function invoked + * per iteration. + * @param {*} [thisArg] The `this` binding of `predicate`. + * @returns {*} Returns the matched element, else `undefined`. + * @example + * + * var users = [ + * { 'user': 'barney', 'age': 36, 'active': true }, + * { 'user': 'fred', 'age': 40, 'active': false }, + * { 'user': 'pebbles', 'age': 1, 'active': true } + * ]; + * + * _.result(_.find(users, function(chr) { + * return chr.age < 40; + * }), 'user'); + * // => 'barney' + * + * // using the `_.matches` callback shorthand + * _.result(_.find(users, { 'age': 1, 'active': true }), 'user'); + * // => 'pebbles' + * + * // using the `_.matchesProperty` callback shorthand + * _.result(_.find(users, 'active', false), 'user'); + * // => 'fred' + * + * // using the `_.property` callback shorthand + * _.result(_.find(users, 'active'), 'user'); + * // => 'barney' + */ + var find = createFind(baseEach); + + module.exports = find; + + +/***/ }, +/* 88 */ +/***/ function(module, exports, __webpack_require__) { + + var baseForOwn = __webpack_require__(89), + createBaseEach = __webpack_require__(112); + + /** + * The base implementation of `_.forEach` without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Array|Object|string} collection The collection to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array|Object|string} Returns `collection`. + */ + var baseEach = createBaseEach(baseForOwn); + + module.exports = baseEach; + + +/***/ }, +/* 89 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFor = __webpack_require__(90), + keys = __webpack_require__(97); + + /** + * The base implementation of `_.forOwn` without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForOwn(object, iteratee) { + return baseFor(object, iteratee, keys); + } + + module.exports = baseForOwn; + + +/***/ }, +/* 90 */ +/***/ function(module, exports, __webpack_require__) { + + var createBaseFor = __webpack_require__(91); + + /** + * The base implementation of `baseForIn` and `baseForOwn` which iterates + * over `object` properties returned by `keysFunc` invoking `iteratee` for + * each property. Iteratee functions may exit iteration early by explicitly + * returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + var baseFor = createBaseFor(); + + module.exports = baseFor; + + +/***/ }, +/* 91 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(92); + + /** + * Creates a base function for `_.forIn` or `_.forInRight`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var iterable = toObject(object), + props = keysFunc(object), + length = props.length, + index = fromRight ? length : -1; + + while ((fromRight ? index-- : ++index < length)) { + var key = props[index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; + } + + module.exports = createBaseFor; + + +/***/ }, +/* 92 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(93), + isString = __webpack_require__(94), + support = __webpack_require__(96); + + /** + * Converts `value` to an object if it's not one. + * + * @private + * @param {*} value The value to process. + * @returns {Object} Returns the object. + */ + function toObject(value) { + if (support.unindexedChars && isString(value)) { + var index = -1, + length = value.length, + result = Object(value); + + while (++index < length) { + result[index] = value.charAt(index); + } + return result; + } + return isObject(value) ? value : Object(value); + } + + module.exports = toObject; + + +/***/ }, +/* 93 */ +/***/ function(module, exports) { + + /** + * Checks if `value` is the [language type](https://es5.github.io/#x8) of `Object`. + * (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(1); + * // => false + */ + function isObject(value) { + // Avoid a V8 JIT bug in Chrome 19-20. + // See https://code.google.com/p/v8/issues/detail?id=2291 for more details. + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); + } + + module.exports = isObject; + + +/***/ }, +/* 94 */ +/***/ function(module, exports, __webpack_require__) { + + var isObjectLike = __webpack_require__(95); + + /** `Object#toString` result references. */ + var stringTag = '[object String]'; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ + function isString(value) { + return typeof value == 'string' || (isObjectLike(value) && objToString.call(value) == stringTag); + } + + module.exports = isString; + + +/***/ }, +/* 95 */ +/***/ function(module, exports) { + + /** + * Checks if `value` is object-like. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + */ + function isObjectLike(value) { + return !!value && typeof value == 'object'; + } + + module.exports = isObjectLike; + + +/***/ }, +/* 96 */ +/***/ function(module, exports) { + + /** Used for native method references. */ + var arrayProto = Array.prototype, + errorProto = Error.prototype, + objectProto = Object.prototype; + + /** Native method references. */ + var propertyIsEnumerable = objectProto.propertyIsEnumerable, + splice = arrayProto.splice; + + /** + * An object environment feature flags. + * + * @static + * @memberOf _ + * @type Object + */ + var support = {}; + + (function(x) { + var Ctor = function() { this.x = x; }, + object = { '0': x, 'length': x }, + props = []; + + Ctor.prototype = { 'valueOf': x, 'y': x }; + for (var key in new Ctor) { props.push(key); } + + /** + * Detect if `name` or `message` properties of `Error.prototype` are + * enumerable by default (IE < 9, Safari < 5.1). + * + * @memberOf _.support + * @type boolean + */ + support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || + propertyIsEnumerable.call(errorProto, 'name'); + + /** + * Detect if `prototype` properties are enumerable by default. + * + * Firefox < 3.6, Opera > 9.50 - Opera < 11.60, and Safari < 5.1 + * (if the prototype or a property on the prototype has been set) + * incorrectly set the `[[Enumerable]]` value of a function's `prototype` + * property to `true`. + * + * @memberOf _.support + * @type boolean + */ + support.enumPrototypes = propertyIsEnumerable.call(Ctor, 'prototype'); + + /** + * Detect if properties shadowing those on `Object.prototype` are non-enumerable. + * + * In IE < 9 an object's own properties, shadowing non-enumerable ones, + * are made non-enumerable as well (a.k.a the JScript `[[DontEnum]]` bug). + * + * @memberOf _.support + * @type boolean + */ + support.nonEnumShadows = !/valueOf/.test(props); + + /** + * Detect if own properties are iterated after inherited properties (IE < 9). + * + * @memberOf _.support + * @type boolean + */ + support.ownLast = props[0] != 'x'; + + /** + * Detect if `Array#shift` and `Array#splice` augment array-like objects + * correctly. + * + * Firefox < 10, compatibility modes of IE 8, and IE < 9 have buggy Array + * `shift()` and `splice()` functions that fail to remove the last element, + * `value[0]`, of array-like objects even though the "length" property is + * set to `0`. The `shift()` method is buggy in compatibility modes of IE 8, + * while `splice()` is buggy regardless of mode in IE < 9. + * + * @memberOf _.support + * @type boolean + */ + support.spliceObjects = (splice.call(object, 0, 1), !object[0]); + + /** + * Detect lack of support for accessing string characters by index. + * + * IE < 8 can't access characters by index. IE 8 can only access characters + * by index on string literals, not string objects. + * + * @memberOf _.support + * @type boolean + */ + support.unindexedChars = ('x'[0] + Object('x')[0]) != 'xx'; + }(1, 0)); + + module.exports = support; + + +/***/ }, +/* 97 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(98), + isArrayLike = __webpack_require__(102), + isObject = __webpack_require__(93), + shimKeys = __webpack_require__(106), + support = __webpack_require__(96); + + /* Native method references for those with the same name as other `lodash` methods. */ + var nativeKeys = getNative(Object, 'keys'); + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/6.0/#sec-object.keys) + * for more details. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + var keys = !nativeKeys ? shimKeys : function(object) { + var Ctor = object == null ? undefined : object.constructor; + if ((typeof Ctor == 'function' && Ctor.prototype === object) || + (typeof object == 'function' ? support.enumPrototypes : isArrayLike(object))) { + return shimKeys(object); + } + return isObject(object) ? nativeKeys(object) : []; + }; + + module.exports = keys; + + +/***/ }, +/* 98 */ +/***/ function(module, exports, __webpack_require__) { + + var isNative = __webpack_require__(99); + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = object == null ? undefined : object[key]; + return isNative(value) ? value : undefined; + } + + module.exports = getNative; + + +/***/ }, +/* 99 */ +/***/ function(module, exports, __webpack_require__) { + + var isFunction = __webpack_require__(100), + isHostObject = __webpack_require__(101), + isObjectLike = __webpack_require__(95); + + /** Used to detect host constructors (Safari > 5). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to resolve the decompiled source of functions. */ + var fnToString = Function.prototype.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + fnToString.call(hasOwnProperty).replace(/[\\^$.*+?()[\]{}|]/g, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); + + /** + * Checks if `value` is a native function. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, else `false`. + * @example + * + * _.isNative(Array.prototype.push); + * // => true + * + * _.isNative(_); + * // => false + */ + function isNative(value) { + if (value == null) { + return false; + } + if (isFunction(value)) { + return reIsNative.test(fnToString.call(value)); + } + return isObjectLike(value) && (isHostObject(value) ? reIsNative : reIsHostCtor).test(value); + } + + module.exports = isNative; + + +/***/ }, +/* 100 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(93); + + /** `Object#toString` result references. */ + var funcTag = '[object Function]'; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in older versions of Chrome and Safari which return 'function' for regexes + // and Safari 8 which returns 'object' for typed array constructors. + return isObject(value) && objToString.call(value) == funcTag; + } + + module.exports = isFunction; + + +/***/ }, +/* 101 */ +/***/ function(module, exports) { + + /** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ + var isHostObject = (function() { + try { + Object({ 'toString': 0 } + ''); + } catch(e) { + return function() { return false; }; + } + return function(value) { + // IE < 9 presents many host objects as `Object` objects that can coerce + // to strings despite having improperly defined `toString` methods. + return typeof value.toString != 'function' && typeof (value + '') == 'string'; + }; + }()); + + module.exports = isHostObject; + + +/***/ }, +/* 102 */ +/***/ function(module, exports, __webpack_require__) { + + var getLength = __webpack_require__(103), + isLength = __webpack_require__(105); + + /** + * Checks if `value` is array-like. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + */ + function isArrayLike(value) { + return value != null && isLength(getLength(value)); + } + + module.exports = isArrayLike; + + +/***/ }, +/* 103 */ +/***/ function(module, exports, __webpack_require__) { + + var baseProperty = __webpack_require__(104); + + /** + * Gets the "length" property value of `object`. + * + * **Note:** This function is used to avoid a [JIT bug](https://bugs.webkit.org/show_bug.cgi?id=142792) + * that affects Safari on at least iOS 8.1-8.3 ARM64. + * + * @private + * @param {Object} object The object to query. + * @returns {*} Returns the "length" value. + */ + var getLength = baseProperty('length'); + + module.exports = getLength; + + +/***/ }, +/* 104 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(92); + + /** + * The base implementation of `_.property` without support for deep paths. + * + * @private + * @param {string} key The key of the property to get. + * @returns {Function} Returns the new function. + */ + function baseProperty(key) { + return function(object) { + return object == null ? undefined : toObject(object)[key]; + }; + } + + module.exports = baseProperty; + + +/***/ }, +/* 105 */ +/***/ function(module, exports) { + + /** + * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer) + * of an array-like value. + */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This function is based on [`ToLength`](http://ecma-international.org/ecma-262/6.0/#sec-tolength). + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + */ + function isLength(value) { + return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; + } + + module.exports = isLength; + + +/***/ }, +/* 106 */ +/***/ function(module, exports, __webpack_require__) { + + var isArguments = __webpack_require__(107), + isArray = __webpack_require__(108), + isIndex = __webpack_require__(109), + isLength = __webpack_require__(105), + isString = __webpack_require__(94), + keysIn = __webpack_require__(110); + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * A fallback implementation of `Object.keys` which creates an array of the + * own enumerable property names of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function shimKeys(object) { + var props = keysIn(object), + propsLength = props.length, + length = propsLength && object.length; + + var allowIndexes = !!length && isLength(length) && + (isArray(object) || isArguments(object) || isString(object)); + + var index = -1, + result = []; + + while (++index < propsLength) { + var key = props[index]; + if ((allowIndexes && isIndex(key, length)) || hasOwnProperty.call(object, key)) { + result.push(key); + } + } + return result; + } + + module.exports = shimKeys; + + +/***/ }, +/* 107 */ +/***/ function(module, exports, __webpack_require__) { + + var isArrayLike = __webpack_require__(102), + isObjectLike = __webpack_require__(95); + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** Native method references. */ + var propertyIsEnumerable = objectProto.propertyIsEnumerable; + + /** + * Checks if `value` is classified as an `arguments` object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + function isArguments(value) { + return isObjectLike(value) && isArrayLike(value) && + hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee'); + } + + module.exports = isArguments; + + +/***/ }, +/* 108 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(98), + isLength = __webpack_require__(105), + isObjectLike = __webpack_require__(95); + + /** `Object#toString` result references. */ + var arrayTag = '[object Array]'; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /* Native method references for those with the same name as other `lodash` methods. */ + var nativeIsArray = getNative(Array, 'isArray'); + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(function() { return arguments; }()); + * // => false + */ + var isArray = nativeIsArray || function(value) { + return isObjectLike(value) && isLength(value.length) && objToString.call(value) == arrayTag; + }; + + module.exports = isArray; + + +/***/ }, +/* 109 */ +/***/ function(module, exports) { + + /** Used to detect unsigned integer values. */ + var reIsUint = /^\d+$/; + + /** + * Used as the [maximum length](http://ecma-international.org/ecma-262/6.0/#sec-number.max_safe_integer) + * of an array-like value. + */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + value = (typeof value == 'number' || reIsUint.test(value)) ? +value : -1; + length = length == null ? MAX_SAFE_INTEGER : length; + return value > -1 && value % 1 == 0 && value < length; + } + + module.exports = isIndex; + + +/***/ }, +/* 110 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayEach = __webpack_require__(111), + isArguments = __webpack_require__(107), + isArray = __webpack_require__(108), + isFunction = __webpack_require__(100), + isIndex = __webpack_require__(109), + isLength = __webpack_require__(105), + isObject = __webpack_require__(93), + isString = __webpack_require__(94), + support = __webpack_require__(96); + + /** `Object#toString` result references. */ + var arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + numberTag = '[object Number]', + objectTag = '[object Object]', + regexpTag = '[object RegExp]', + stringTag = '[object String]'; + + /** Used to fix the JScript `[[DontEnum]]` bug. */ + var shadowProps = [ + 'constructor', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', + 'toLocaleString', 'toString', 'valueOf' + ]; + + /** Used for native method references. */ + var errorProto = Error.prototype, + objectProto = Object.prototype, + stringProto = String.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** Used to avoid iterating over non-enumerable properties in IE < 9. */ + var nonEnumProps = {}; + nonEnumProps[arrayTag] = nonEnumProps[dateTag] = nonEnumProps[numberTag] = { 'constructor': true, 'toLocaleString': true, 'toString': true, 'valueOf': true }; + nonEnumProps[boolTag] = nonEnumProps[stringTag] = { 'constructor': true, 'toString': true, 'valueOf': true }; + nonEnumProps[errorTag] = nonEnumProps[funcTag] = nonEnumProps[regexpTag] = { 'constructor': true, 'toString': true }; + nonEnumProps[objectTag] = { 'constructor': true }; + + arrayEach(shadowProps, function(key) { + for (var tag in nonEnumProps) { + if (hasOwnProperty.call(nonEnumProps, tag)) { + var props = nonEnumProps[tag]; + props[key] = hasOwnProperty.call(props, key); + } + } + }); + + /** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */ + function keysIn(object) { + if (object == null) { + return []; + } + if (!isObject(object)) { + object = Object(object); + } + var length = object.length; + + length = (length && isLength(length) && + (isArray(object) || isArguments(object) || isString(object)) && length) || 0; + + var Ctor = object.constructor, + index = -1, + proto = (isFunction(Ctor) && Ctor.prototype) || objectProto, + isProto = proto === object, + result = Array(length), + skipIndexes = length > 0, + skipErrorProps = support.enumErrorProps && (object === errorProto || object instanceof Error), + skipProto = support.enumPrototypes && isFunction(object); + + while (++index < length) { + result[index] = (index + ''); + } + // lodash skips the `constructor` property when it infers it's iterating + // over a `prototype` object because IE < 9 can't set the `[[Enumerable]]` + // attribute of an existing property and the `constructor` property of a + // prototype defaults to non-enumerable. + for (var key in object) { + if (!(skipProto && key == 'prototype') && + !(skipErrorProps && (key == 'message' || key == 'name')) && + !(skipIndexes && isIndex(key, length)) && + !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { + result.push(key); + } + } + if (support.nonEnumShadows && object !== objectProto) { + var tag = object === stringProto ? stringTag : (object === errorProto ? errorTag : objToString.call(object)), + nonEnums = nonEnumProps[tag] || nonEnumProps[objectTag]; + + if (tag == objectTag) { + proto = objectProto; + } + length = shadowProps.length; + while (length--) { + key = shadowProps[length]; + var nonEnum = nonEnums[key]; + if (!(isProto && nonEnum) && + (nonEnum ? hasOwnProperty.call(object, key) : object[key] !== proto[key])) { + result.push(key); + } + } + } + return result; + } + + module.exports = keysIn; + + +/***/ }, +/* 111 */ +/***/ function(module, exports) { + + /** + * A specialized version of `_.forEach` for arrays without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns `array`. + */ + function arrayEach(array, iteratee) { + var index = -1, + length = array.length; + + while (++index < length) { + if (iteratee(array[index], index, array) === false) { + break; + } + } + return array; + } + + module.exports = arrayEach; + + +/***/ }, +/* 112 */ +/***/ function(module, exports, __webpack_require__) { + + var getLength = __webpack_require__(103), + isLength = __webpack_require__(105), + toObject = __webpack_require__(92); + + /** + * Creates a `baseEach` or `baseEachRight` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseEach(eachFunc, fromRight) { + return function(collection, iteratee) { + var length = collection ? getLength(collection) : 0; + if (!isLength(length)) { + return eachFunc(collection, iteratee); + } + var index = fromRight ? length : -1, + iterable = toObject(collection); + + while ((fromRight ? index-- : ++index < length)) { + if (iteratee(iterable[index], index, iterable) === false) { + break; + } + } + return collection; + }; + } + + module.exports = createBaseEach; + + +/***/ }, +/* 113 */ +/***/ function(module, exports, __webpack_require__) { + + var baseCallback = __webpack_require__(114), + baseFind = __webpack_require__(138), + baseFindIndex = __webpack_require__(139), + isArray = __webpack_require__(108); + + /** + * Creates a `_.find` or `_.findLast` function. + * + * @private + * @param {Function} eachFunc The function to iterate over a collection. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new find function. + */ + function createFind(eachFunc, fromRight) { + return function(collection, predicate, thisArg) { + predicate = baseCallback(predicate, thisArg, 3); + if (isArray(collection)) { + var index = baseFindIndex(collection, predicate, fromRight); + return index > -1 ? collection[index] : undefined; + } + return baseFind(collection, predicate, eachFunc); + }; + } + + module.exports = createFind; + + +/***/ }, +/* 114 */ +/***/ function(module, exports, __webpack_require__) { + + var baseMatches = __webpack_require__(115), + baseMatchesProperty = __webpack_require__(127), + bindCallback = __webpack_require__(134), + identity = __webpack_require__(135), + property = __webpack_require__(136); + + /** + * The base implementation of `_.callback` which supports specifying the + * number of arguments to provide to `func`. + * + * @private + * @param {*} [func=_.identity] The value to convert to a callback. + * @param {*} [thisArg] The `this` binding of `func`. + * @param {number} [argCount] The number of arguments to provide to `func`. + * @returns {Function} Returns the callback. + */ + function baseCallback(func, thisArg, argCount) { + var type = typeof func; + if (type == 'function') { + return thisArg === undefined + ? func + : bindCallback(func, thisArg, argCount); + } + if (func == null) { + return identity; + } + if (type == 'object') { + return baseMatches(func); + } + return thisArg === undefined + ? property(func) + : baseMatchesProperty(func, thisArg); + } + + module.exports = baseCallback; + + +/***/ }, +/* 115 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsMatch = __webpack_require__(116), + getMatchData = __webpack_require__(124), + toObject = __webpack_require__(92); + + /** + * The base implementation of `_.matches` which does not clone `source`. + * + * @private + * @param {Object} source The object of property values to match. + * @returns {Function} Returns the new function. + */ + function baseMatches(source) { + var matchData = getMatchData(source); + if (matchData.length == 1 && matchData[0][2]) { + var key = matchData[0][0], + value = matchData[0][1]; + + return function(object) { + if (object == null) { + return false; + } + object = toObject(object); + return object[key] === value && (value !== undefined || (key in object)); + }; + } + return function(object) { + return baseIsMatch(object, matchData); + }; + } + + module.exports = baseMatches; + + +/***/ }, +/* 116 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsEqual = __webpack_require__(117), + toObject = __webpack_require__(92); + + /** + * The base implementation of `_.isMatch` without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Object} object The object to inspect. + * @param {Array} matchData The propery names, values, and compare flags to match. + * @param {Function} [customizer] The function to customize comparing objects. + * @returns {boolean} Returns `true` if `object` is a match, else `false`. + */ + function baseIsMatch(object, matchData, customizer) { + var index = matchData.length, + length = index, + noCustomizer = !customizer; + + if (object == null) { + return !length; + } + object = toObject(object); + while (index--) { + var data = matchData[index]; + if ((noCustomizer && data[2]) + ? data[1] !== object[data[0]] + : !(data[0] in object) + ) { + return false; + } + } + while (++index < length) { + data = matchData[index]; + var key = data[0], + objValue = object[key], + srcValue = data[1]; + + if (noCustomizer && data[2]) { + if (objValue === undefined && !(key in object)) { + return false; + } + } else { + var result = customizer ? customizer(objValue, srcValue, key) : undefined; + if (!(result === undefined ? baseIsEqual(srcValue, objValue, customizer, true) : result)) { + return false; + } + } + } + return true; + } + + module.exports = baseIsMatch; + + +/***/ }, +/* 117 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsEqualDeep = __webpack_require__(118), + isObject = __webpack_require__(93), + isObjectLike = __webpack_require__(95); + + /** + * The base implementation of `_.isEqual` without support for `this` binding + * `customizer` functions. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {Function} [customizer] The function to customize comparing values. + * @param {boolean} [isLoose] Specify performing partial comparisons. + * @param {Array} [stackA] Tracks traversed `value` objects. + * @param {Array} [stackB] Tracks traversed `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ + function baseIsEqual(value, other, customizer, isLoose, stackA, stackB) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObject(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, baseIsEqual, customizer, isLoose, stackA, stackB); + } + + module.exports = baseIsEqual; + + +/***/ }, +/* 118 */ +/***/ function(module, exports, __webpack_require__) { + + var equalArrays = __webpack_require__(119), + equalByTag = __webpack_require__(121), + equalObjects = __webpack_require__(122), + isArray = __webpack_require__(108), + isHostObject = __webpack_require__(101), + isTypedArray = __webpack_require__(123); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + objectTag = '[object Object]'; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Function} [customizer] The function to customize comparing objects. + * @param {boolean} [isLoose] Specify performing partial comparisons. + * @param {Array} [stackA=[]] Tracks traversed `value` objects. + * @param {Array} [stackB=[]] Tracks traversed `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function baseIsEqualDeep(object, other, equalFunc, customizer, isLoose, stackA, stackB) { + var objIsArr = isArray(object), + othIsArr = isArray(other), + objTag = arrayTag, + othTag = arrayTag; + + if (!objIsArr) { + objTag = objToString.call(object); + if (objTag == argsTag) { + objTag = objectTag; + } else if (objTag != objectTag) { + objIsArr = isTypedArray(object); + } + } + if (!othIsArr) { + othTag = objToString.call(other); + if (othTag == argsTag) { + othTag = objectTag; + } else if (othTag != objectTag) { + othIsArr = isTypedArray(other); + } + } + var objIsObj = objTag == objectTag && !isHostObject(object), + othIsObj = othTag == objectTag && !isHostObject(other), + isSameTag = objTag == othTag; + + if (isSameTag && !(objIsArr || objIsObj)) { + return equalByTag(object, other, objTag); + } + if (!isLoose) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + return equalFunc(objIsWrapped ? object.value() : object, othIsWrapped ? other.value() : other, customizer, isLoose, stackA, stackB); + } + } + if (!isSameTag) { + return false; + } + // Assume cyclic values are equal. + // For more information on detecting circular references see https://es5.github.io/#JO. + stackA || (stackA = []); + stackB || (stackB = []); + + var length = stackA.length; + while (length--) { + if (stackA[length] == object) { + return stackB[length] == other; + } + } + // Add `object` and `other` to the stack of traversed objects. + stackA.push(object); + stackB.push(other); + + var result = (objIsArr ? equalArrays : equalObjects)(object, other, equalFunc, customizer, isLoose, stackA, stackB); + + stackA.pop(); + stackB.pop(); + + return result; + } + + module.exports = baseIsEqualDeep; + + +/***/ }, +/* 119 */ +/***/ function(module, exports, __webpack_require__) { + + var arraySome = __webpack_require__(120); + + /** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Function} [customizer] The function to customize comparing arrays. + * @param {boolean} [isLoose] Specify performing partial comparisons. + * @param {Array} [stackA] Tracks traversed `value` objects. + * @param {Array} [stackB] Tracks traversed `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ + function equalArrays(array, other, equalFunc, customizer, isLoose, stackA, stackB) { + var index = -1, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isLoose && othLength > arrLength)) { + return false; + } + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index], + result = customizer ? customizer(isLoose ? othValue : arrValue, isLoose ? arrValue : othValue, index) : undefined; + + if (result !== undefined) { + if (result) { + continue; + } + return false; + } + // Recursively compare arrays (susceptible to call stack limits). + if (isLoose) { + if (!arraySome(other, function(othValue) { + return arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB); + })) { + return false; + } + } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, customizer, isLoose, stackA, stackB))) { + return false; + } + } + return true; + } + + module.exports = equalArrays; + + +/***/ }, +/* 120 */ +/***/ function(module, exports) { + + /** + * A specialized version of `_.some` for arrays without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + function arraySome(array, predicate) { + var index = -1, + length = array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; + } + + module.exports = arraySome; + + +/***/ }, +/* 121 */ +/***/ function(module, exports) { + + /** `Object#toString` result references. */ + var boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + numberTag = '[object Number]', + regexpTag = '[object RegExp]', + stringTag = '[object String]'; + + /** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalByTag(object, other, tag) { + switch (tag) { + case boolTag: + case dateTag: + // Coerce dates and booleans to numbers, dates to milliseconds and booleans + // to `1` or `0` treating invalid dates coerced to `NaN` as not equal. + return +object == +other; + + case errorTag: + return object.name == other.name && object.message == other.message; + + case numberTag: + // Treat `NaN` vs. `NaN` as equal. + return (object != +object) + ? other != +other + : object == +other; + + case regexpTag: + case stringTag: + // Coerce regexes to strings and treat strings primitives and string + // objects as equal. See https://es5.github.io/#x15.10.6.4 for more details. + return object == (other + ''); + } + return false; + } + + module.exports = equalByTag; + + +/***/ }, +/* 122 */ +/***/ function(module, exports, __webpack_require__) { + + var keys = __webpack_require__(97); + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Function} [customizer] The function to customize comparing values. + * @param {boolean} [isLoose] Specify performing partial comparisons. + * @param {Array} [stackA] Tracks traversed `value` objects. + * @param {Array} [stackB] Tracks traversed `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalObjects(object, other, equalFunc, customizer, isLoose, stackA, stackB) { + var objProps = keys(object), + objLength = objProps.length, + othProps = keys(other), + othLength = othProps.length; + + if (objLength != othLength && !isLoose) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isLoose ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } + var skipCtor = isLoose; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key], + result = customizer ? customizer(isLoose ? othValue : objValue, isLoose? objValue : othValue, key) : undefined; + + // Recursively compare objects (susceptible to call stack limits). + if (!(result === undefined ? equalFunc(objValue, othValue, customizer, isLoose, stackA, stackB) : result)) { + return false; + } + skipCtor || (skipCtor = key == 'constructor'); + } + if (!skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; + + // Non `Object` object instances with different constructors are not equal. + if (objCtor != othCtor && + ('constructor' in object && 'constructor' in other) && + !(typeof objCtor == 'function' && objCtor instanceof objCtor && + typeof othCtor == 'function' && othCtor instanceof othCtor)) { + return false; + } + } + return true; + } + + module.exports = equalObjects; + + +/***/ }, +/* 123 */ +/***/ function(module, exports, __webpack_require__) { + + var isLength = __webpack_require__(105), + isObjectLike = __webpack_require__(95); + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + mapTag = '[object Map]', + numberTag = '[object Number]', + objectTag = '[object Object]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + weakMapTag = '[object WeakMap]'; + + var arrayBufferTag = '[object ArrayBuffer]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** Used to identify `toStringTag` values of typed arrays. */ + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = + typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = + typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = + typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = + typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag] = typedArrayTags[arrayTag] = + typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = + typedArrayTags[dateTag] = typedArrayTags[errorTag] = + typedArrayTags[funcTag] = typedArrayTags[mapTag] = + typedArrayTags[numberTag] = typedArrayTags[objectTag] = + typedArrayTags[regexpTag] = typedArrayTags[setTag] = + typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false; + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** + * Used to resolve the [`toStringTag`](http://ecma-international.org/ecma-262/6.0/#sec-object.prototype.tostring) + * of values. + */ + var objToString = objectProto.toString; + + /** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is correctly classified, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ + function isTypedArray(value) { + return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[objToString.call(value)]; + } + + module.exports = isTypedArray; + + +/***/ }, +/* 124 */ +/***/ function(module, exports, __webpack_require__) { + + var isStrictComparable = __webpack_require__(125), + pairs = __webpack_require__(126); + + /** + * Gets the propery names, values, and compare flags of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the match data of `object`. + */ + function getMatchData(object) { + var result = pairs(object), + length = result.length; + + while (length--) { + result[length][2] = isStrictComparable(result[length][1]); + } + return result; + } + + module.exports = getMatchData; + + +/***/ }, +/* 125 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(93); + + /** + * Checks if `value` is suitable for strict equality comparisons, i.e. `===`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` if suitable for strict + * equality comparisons, else `false`. + */ + function isStrictComparable(value) { + return value === value && !isObject(value); + } + + module.exports = isStrictComparable; + + +/***/ }, +/* 126 */ +/***/ function(module, exports, __webpack_require__) { + + var keys = __webpack_require__(97), + toObject = __webpack_require__(92); + + /** + * Creates a two dimensional array of the key-value pairs for `object`, + * e.g. `[[key1, value1], [key2, value2]]`. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the new array of key-value pairs. + * @example + * + * _.pairs({ 'barney': 36, 'fred': 40 }); + * // => [['barney', 36], ['fred', 40]] (iteration order is not guaranteed) + */ + function pairs(object) { + object = toObject(object); + + var index = -1, + props = keys(object), + length = props.length, + result = Array(length); + + while (++index < length) { + var key = props[index]; + result[index] = [key, object[key]]; + } + return result; + } + + module.exports = pairs; + + +/***/ }, +/* 127 */ +/***/ function(module, exports, __webpack_require__) { + + var baseGet = __webpack_require__(128), + baseIsEqual = __webpack_require__(117), + baseSlice = __webpack_require__(129), + isArray = __webpack_require__(108), + isKey = __webpack_require__(130), + isStrictComparable = __webpack_require__(125), + last = __webpack_require__(131), + toObject = __webpack_require__(92), + toPath = __webpack_require__(132); + + /** + * The base implementation of `_.matchesProperty` which does not clone `srcValue`. + * + * @private + * @param {string} path The path of the property to get. + * @param {*} srcValue The value to compare. + * @returns {Function} Returns the new function. + */ + function baseMatchesProperty(path, srcValue) { + var isArr = isArray(path), + isCommon = isKey(path) && isStrictComparable(srcValue), + pathKey = (path + ''); + + path = toPath(path); + return function(object) { + if (object == null) { + return false; + } + var key = pathKey; + object = toObject(object); + if ((isArr || !isCommon) && !(key in object)) { + object = path.length == 1 ? object : baseGet(object, baseSlice(path, 0, -1)); + if (object == null) { + return false; + } + key = last(path); + object = toObject(object); + } + return object[key] === srcValue + ? (srcValue !== undefined || (key in object)) + : baseIsEqual(srcValue, object[key], undefined, true); + }; + } + + module.exports = baseMatchesProperty; + + +/***/ }, +/* 128 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(92); + + /** + * The base implementation of `get` without support for string paths + * and default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array} path The path of the property to get. + * @param {string} [pathKey] The key representation of path. + * @returns {*} Returns the resolved value. + */ + function baseGet(object, path, pathKey) { + if (object == null) { + return; + } + object = toObject(object); + if (pathKey !== undefined && pathKey in object) { + path = [pathKey]; + } + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = toObject(object)[path[index++]]; + } + return (index && index == length) ? object : undefined; + } + + module.exports = baseGet; + + +/***/ }, +/* 129 */ +/***/ function(module, exports) { + + /** + * The base implementation of `_.slice` without an iteratee call guard. + * + * @private + * @param {Array} array The array to slice. + * @param {number} [start=0] The start position. + * @param {number} [end=array.length] The end position. + * @returns {Array} Returns the slice of `array`. + */ + function baseSlice(array, start, end) { + var index = -1, + length = array.length; + + start = start == null ? 0 : (+start || 0); + if (start < 0) { + start = -start > length ? 0 : (length + start); + } + end = (end === undefined || end > length) ? length : (+end || 0); + if (end < 0) { + end += length; + } + length = start > end ? 0 : ((end - start) >>> 0); + start >>>= 0; + + var result = Array(length); + while (++index < length) { + result[index] = array[index + start]; + } + return result; + } + + module.exports = baseSlice; + + +/***/ }, +/* 130 */ +/***/ function(module, exports, __webpack_require__) { + + var isArray = __webpack_require__(108), + toObject = __webpack_require__(92); + + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\n\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; + + /** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ + function isKey(value, object) { + var type = typeof value; + if ((type == 'string' && reIsPlainProp.test(value)) || type == 'number') { + return true; + } + if (isArray(value)) { + return false; + } + var result = !reIsDeepProp.test(value); + return result || (object != null && value in toObject(object)); + } + + module.exports = isKey; + + +/***/ }, +/* 131 */ +/***/ function(module, exports) { + + /** + * Gets the last element of `array`. + * + * @static + * @memberOf _ + * @category Array + * @param {Array} array The array to query. + * @returns {*} Returns the last element of `array`. + * @example + * + * _.last([1, 2, 3]); + * // => 3 + */ + function last(array) { + var length = array ? array.length : 0; + return length ? array[length - 1] : undefined; + } + + module.exports = last; + + +/***/ }, +/* 132 */ +/***/ function(module, exports, __webpack_require__) { + + var baseToString = __webpack_require__(133), + isArray = __webpack_require__(108); + + /** Used to match property names within property paths. */ + var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\n\\]|\\.)*?)\2)\]/g; + + /** Used to match backslashes in property paths. */ + var reEscapeChar = /\\(\\)?/g; + + /** + * Converts `value` to property path array if it's not one. + * + * @private + * @param {*} value The value to process. + * @returns {Array} Returns the property path array. + */ + function toPath(value) { + if (isArray(value)) { + return value; + } + var result = []; + baseToString(value).replace(rePropName, function(match, number, quote, string) { + result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; + } + + module.exports = toPath; + + +/***/ }, +/* 133 */ +/***/ function(module, exports) { + + /** + * Converts `value` to a string if it's not one. An empty string is returned + * for `null` or `undefined` values. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + function baseToString(value) { + return value == null ? '' : (value + ''); + } + + module.exports = baseToString; + + +/***/ }, +/* 134 */ +/***/ function(module, exports, __webpack_require__) { + + var identity = __webpack_require__(135); + + /** + * A specialized version of `baseCallback` which only supports `this` binding + * and specifying the number of arguments to provide to `func`. + * + * @private + * @param {Function} func The function to bind. + * @param {*} thisArg The `this` binding of `func`. + * @param {number} [argCount] The number of arguments to provide to `func`. + * @returns {Function} Returns the callback. + */ + function bindCallback(func, thisArg, argCount) { + if (typeof func != 'function') { + return identity; + } + if (thisArg === undefined) { + return func; + } + switch (argCount) { + case 1: return function(value) { + return func.call(thisArg, value); + }; + case 3: return function(value, index, collection) { + return func.call(thisArg, value, index, collection); + }; + case 4: return function(accumulator, value, index, collection) { + return func.call(thisArg, accumulator, value, index, collection); + }; + case 5: return function(value, other, key, object, source) { + return func.call(thisArg, value, other, key, object, source); + }; + } + return function() { + return func.apply(thisArg, arguments); + }; + } + + module.exports = bindCallback; + + +/***/ }, +/* 135 */ +/***/ function(module, exports) { + + /** + * This method returns the first argument provided to it. + * + * @static + * @memberOf _ + * @category Utility + * @param {*} value Any value. + * @returns {*} Returns `value`. + * @example + * + * var object = { 'user': 'fred' }; + * + * _.identity(object) === object; + * // => true + */ + function identity(value) { + return value; + } + + module.exports = identity; + + +/***/ }, +/* 136 */ +/***/ function(module, exports, __webpack_require__) { + + var baseProperty = __webpack_require__(104), + basePropertyDeep = __webpack_require__(137), + isKey = __webpack_require__(130); + + /** + * Creates a function that returns the property value at `path` on a + * given object. + * + * @static + * @memberOf _ + * @category Utility + * @param {Array|string} path The path of the property to get. + * @returns {Function} Returns the new function. + * @example + * + * var objects = [ + * { 'a': { 'b': { 'c': 2 } } }, + * { 'a': { 'b': { 'c': 1 } } } + * ]; + * + * _.map(objects, _.property('a.b.c')); + * // => [2, 1] + * + * _.pluck(_.sortBy(objects, _.property(['a', 'b', 'c'])), 'a.b.c'); + * // => [1, 2] + */ + function property(path) { + return isKey(path) ? baseProperty(path) : basePropertyDeep(path); + } + + module.exports = property; + + +/***/ }, +/* 137 */ +/***/ function(module, exports, __webpack_require__) { + + var baseGet = __webpack_require__(128), + toPath = __webpack_require__(132); + + /** + * A specialized version of `baseProperty` which supports deep paths. + * + * @private + * @param {Array|string} path The path of the property to get. + * @returns {Function} Returns the new function. + */ + function basePropertyDeep(path) { + var pathKey = (path + ''); + path = toPath(path); + return function(object) { + return baseGet(object, path, pathKey); + }; + } + + module.exports = basePropertyDeep; + + +/***/ }, +/* 138 */ +/***/ function(module, exports) { + + /** + * The base implementation of `_.find`, `_.findLast`, `_.findKey`, and `_.findLastKey`, + * without support for callback shorthands and `this` binding, which iterates + * over `collection` using the provided `eachFunc`. + * + * @private + * @param {Array|Object|string} collection The collection to search. + * @param {Function} predicate The function invoked per iteration. + * @param {Function} eachFunc The function to iterate over `collection`. + * @param {boolean} [retKey] Specify returning the key of the found element + * instead of the element itself. + * @returns {*} Returns the found element or its key, else `undefined`. + */ + function baseFind(collection, predicate, eachFunc, retKey) { + var result; + eachFunc(collection, function(value, key, collection) { + if (predicate(value, key, collection)) { + result = retKey ? key : value; + return false; + } + }); + return result; + } + + module.exports = baseFind; + + +/***/ }, +/* 139 */ +/***/ function(module, exports) { + + /** + * The base implementation of `_.findIndex` and `_.findLastIndex` without + * support for callback shorthands and `this` binding. + * + * @private + * @param {Array} array The array to search. + * @param {Function} predicate The function invoked per iteration. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function baseFindIndex(array, predicate, fromRight) { + var length = array.length, + index = fromRight ? length : -1; + + while ((fromRight ? index-- : ++index < length)) { + if (predicate(array[index], index, array)) { + return index; + } + } + return -1; + } + + module.exports = baseFindIndex; + + +/***/ }, +/* 140 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayMap = __webpack_require__(141), + baseDifference = __webpack_require__(142), + baseFlatten = __webpack_require__(149), + bindCallback = __webpack_require__(134), + keysIn = __webpack_require__(110), + pickByArray = __webpack_require__(151), + pickByCallback = __webpack_require__(152), + restParam = __webpack_require__(154); + + /** + * The opposite of `_.pick`; this method creates an object composed of the + * own and inherited enumerable properties of `object` that are not omitted. + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {Function|...(string|string[])} [predicate] The function invoked per + * iteration or property names to omit, specified as individual property + * names or arrays of property names. + * @param {*} [thisArg] The `this` binding of `predicate`. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'user': 'fred', 'age': 40 }; + * + * _.omit(object, 'age'); + * // => { 'user': 'fred' } + * + * _.omit(object, _.isNumber); + * // => { 'user': 'fred' } + */ + var omit = restParam(function(object, props) { + if (object == null) { + return {}; + } + if (typeof props[0] != 'function') { + var props = arrayMap(baseFlatten(props), String); + return pickByArray(object, baseDifference(keysIn(object), props)); + } + var predicate = bindCallback(props[0], props[1], 3); + return pickByCallback(object, function(value, key, object) { + return !predicate(value, key, object); + }); + }); + + module.exports = omit; + + +/***/ }, +/* 141 */ +/***/ function(module, exports) { + + /** + * A specialized version of `_.map` for arrays without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Array} array The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function arrayMap(array, iteratee) { + var index = -1, + length = array.length, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; + } + + module.exports = arrayMap; + + +/***/ }, +/* 142 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIndexOf = __webpack_require__(143), + cacheIndexOf = __webpack_require__(145), + createCache = __webpack_require__(146); + + /** Used as the size to enable large array optimizations. */ + var LARGE_ARRAY_SIZE = 200; + + /** + * The base implementation of `_.difference` which accepts a single array + * of values to exclude. + * + * @private + * @param {Array} array The array to inspect. + * @param {Array} values The values to exclude. + * @returns {Array} Returns the new array of filtered values. + */ + function baseDifference(array, values) { + var length = array ? array.length : 0, + result = []; + + if (!length) { + return result; + } + var index = -1, + indexOf = baseIndexOf, + isCommon = true, + cache = (isCommon && values.length >= LARGE_ARRAY_SIZE) ? createCache(values) : null, + valuesLength = values.length; + + if (cache) { + indexOf = cacheIndexOf; + isCommon = false; + values = cache; + } + outer: + while (++index < length) { + var value = array[index]; + + if (isCommon && value === value) { + var valuesIndex = valuesLength; + while (valuesIndex--) { + if (values[valuesIndex] === value) { + continue outer; + } + } + result.push(value); + } + else if (indexOf(values, value, 0) < 0) { + result.push(value); + } + } + return result; + } + + module.exports = baseDifference; + + +/***/ }, +/* 143 */ +/***/ function(module, exports, __webpack_require__) { + + var indexOfNaN = __webpack_require__(144); + + /** + * The base implementation of `_.indexOf` without support for binary searches. + * + * @private + * @param {Array} array The array to search. + * @param {*} value The value to search for. + * @param {number} fromIndex The index to search from. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function baseIndexOf(array, value, fromIndex) { + if (value !== value) { + return indexOfNaN(array, fromIndex); + } + var index = fromIndex - 1, + length = array.length; + + while (++index < length) { + if (array[index] === value) { + return index; + } + } + return -1; + } + + module.exports = baseIndexOf; + + +/***/ }, +/* 144 */ +/***/ function(module, exports) { + + /** + * Gets the index at which the first occurrence of `NaN` is found in `array`. + * + * @private + * @param {Array} array The array to search. + * @param {number} fromIndex The index to search from. + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {number} Returns the index of the matched `NaN`, else `-1`. + */ + function indexOfNaN(array, fromIndex, fromRight) { + var length = array.length, + index = fromIndex + (fromRight ? 0 : -1); + + while ((fromRight ? index-- : ++index < length)) { + var other = array[index]; + if (other !== other) { + return index; + } + } + return -1; + } + + module.exports = indexOfNaN; + + +/***/ }, +/* 145 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(93); + + /** + * Checks if `value` is in `cache` mimicking the return signature of + * `_.indexOf` by returning `0` if the value is found, else `-1`. + * + * @private + * @param {Object} cache The cache to search. + * @param {*} value The value to search for. + * @returns {number} Returns `0` if `value` is found, else `-1`. + */ + function cacheIndexOf(cache, value) { + var data = cache.data, + result = (typeof value == 'string' || isObject(value)) ? data.set.has(value) : data.hash[value]; + + return result ? 0 : -1; + } + + module.exports = cacheIndexOf; + + +/***/ }, +/* 146 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {var SetCache = __webpack_require__(147), + getNative = __webpack_require__(98); + + /** Native method references. */ + var Set = getNative(global, 'Set'); + + /* Native method references for those with the same name as other `lodash` methods. */ + var nativeCreate = getNative(Object, 'create'); + + /** + * Creates a `Set` cache object to optimize linear searches of large arrays. + * + * @private + * @param {Array} [values] The values to cache. + * @returns {null|Object} Returns the new cache object if `Set` is supported, else `null`. + */ + function createCache(values) { + return (nativeCreate && Set) ? new SetCache(values) : null; + } + + module.exports = createCache; + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }, +/* 147 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {var cachePush = __webpack_require__(148), + getNative = __webpack_require__(98); + + /** Native method references. */ + var Set = getNative(global, 'Set'); + + /* Native method references for those with the same name as other `lodash` methods. */ + var nativeCreate = getNative(Object, 'create'); + + /** + * + * Creates a cache object to store unique values. + * + * @private + * @param {Array} [values] The values to cache. + */ + function SetCache(values) { + var length = values ? values.length : 0; + + this.data = { 'hash': nativeCreate(null), 'set': new Set }; + while (length--) { + this.push(values[length]); + } + } + + // Add functions to the `Set` cache. + SetCache.prototype.push = cachePush; + + module.exports = SetCache; + + /* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()))) + +/***/ }, +/* 148 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(93); + + /** + * Adds `value` to the cache. + * + * @private + * @name push + * @memberOf SetCache + * @param {*} value The value to cache. + */ + function cachePush(value) { + var data = this.data; + if (typeof value == 'string' || isObject(value)) { + data.set.add(value); + } else { + data.hash[value] = true; + } + } + + module.exports = cachePush; + + +/***/ }, +/* 149 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayPush = __webpack_require__(150), + isArguments = __webpack_require__(107), + isArray = __webpack_require__(108), + isArrayLike = __webpack_require__(102), + isObjectLike = __webpack_require__(95); + + /** + * The base implementation of `_.flatten` with added support for restricting + * flattening and specifying the start index. + * + * @private + * @param {Array} array The array to flatten. + * @param {boolean} [isDeep] Specify a deep flatten. + * @param {boolean} [isStrict] Restrict flattening to arrays-like objects. + * @param {Array} [result=[]] The initial result value. + * @returns {Array} Returns the new flattened array. + */ + function baseFlatten(array, isDeep, isStrict, result) { + result || (result = []); + + var index = -1, + length = array.length; + + while (++index < length) { + var value = array[index]; + if (isObjectLike(value) && isArrayLike(value) && + (isStrict || isArray(value) || isArguments(value))) { + if (isDeep) { + // Recursively flatten arrays (susceptible to call stack limits). + baseFlatten(value, isDeep, isStrict, result); + } else { + arrayPush(result, value); + } + } else if (!isStrict) { + result[result.length] = value; + } + } + return result; + } + + module.exports = baseFlatten; + + +/***/ }, +/* 150 */ +/***/ function(module, exports) { + + /** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ + function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; + } + + module.exports = arrayPush; + + +/***/ }, +/* 151 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(92); + + /** + * A specialized version of `_.pick` which picks `object` properties specified + * by `props`. + * + * @private + * @param {Object} object The source object. + * @param {string[]} props The property names to pick. + * @returns {Object} Returns the new object. + */ + function pickByArray(object, props) { + object = toObject(object); + + var index = -1, + length = props.length, + result = {}; + + while (++index < length) { + var key = props[index]; + if (key in object) { + result[key] = object[key]; + } + } + return result; + } + + module.exports = pickByArray; + + +/***/ }, +/* 152 */ +/***/ function(module, exports, __webpack_require__) { + + var baseForIn = __webpack_require__(153); + + /** + * A specialized version of `_.pick` which picks `object` properties `predicate` + * returns truthy for. + * + * @private + * @param {Object} object The source object. + * @param {Function} predicate The function invoked per iteration. + * @returns {Object} Returns the new object. + */ + function pickByCallback(object, predicate) { + var result = {}; + baseForIn(object, function(value, key, object) { + if (predicate(value, key, object)) { + result[key] = value; + } + }); + return result; + } + + module.exports = pickByCallback; + + +/***/ }, +/* 153 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFor = __webpack_require__(90), + keysIn = __webpack_require__(110); + + /** + * The base implementation of `_.forIn` without support for callback + * shorthands and `this` binding. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Object} Returns `object`. + */ + function baseForIn(object, iteratee) { + return baseFor(object, iteratee, keysIn); + } + + module.exports = baseForIn; + + +/***/ }, +/* 154 */ +/***/ function(module, exports) { + + /** Used as the `TypeError` message for "Functions" methods. */ + var FUNC_ERROR_TEXT = 'Expected a function'; + + /* Native method references for those with the same name as other `lodash` methods. */ + var nativeMax = Math.max; + + /** + * Creates a function that invokes `func` with the `this` binding of the + * created function and arguments from `start` and beyond provided as an array. + * + * **Note:** This method is based on the [rest parameter](https://developer.mozilla.org/Web/JavaScript/Reference/Functions/rest_parameters). + * + * @static + * @memberOf _ + * @category Function + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + * @example + * + * var say = _.restParam(function(what, names) { + * return what + ' ' + _.initial(names).join(', ') + + * (_.size(names) > 1 ? ', & ' : '') + _.last(names); + * }); + * + * say('hello', 'fred', 'barney', 'pebbles'); + * // => 'hello fred, barney, & pebbles' + */ + function restParam(func, start) { + if (typeof func != 'function') { + throw new TypeError(FUNC_ERROR_TEXT); + } + start = nativeMax(start === undefined ? (func.length - 1) : (+start || 0), 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + rest = Array(length); + + while (++index < length) { + rest[index] = args[start + index]; + } + switch (start) { + case 0: return func.call(this, rest); + case 1: return func.call(this, args[0], rest); + case 2: return func.call(this, args[0], args[1], rest); + } + var otherArgs = Array(start + 1); + index = -1; + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = rest; + return func.apply(this, otherArgs); + }; + } + + module.exports = restParam; + + +/***/ }, +/* 155 */ +/***/ function(module, exports) { + + "use strict"; + + exports.__esModule = true; + exports["default"] = isRequiredForA11y; + + function isRequiredForA11y(propType) { + return function validate(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); + }; + } + + module.exports = exports["default"]; + +/***/ }, +/* 156 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _createUncontrollable = __webpack_require__(157); + + var _createUncontrollable2 = _interopRequireDefault(_createUncontrollable); + + var mixin = { + shouldComponentUpdate: function shouldComponentUpdate() { + //let the forceUpdate trigger the update + return !this._notifying; + } + }; + + function set(component, propName, handler, value, args) { + if (handler) { + component._notifying = true; + handler.call.apply(handler, [component, value].concat(args)); + component._notifying = false; + } + + component._values[propName] = value; + component.forceUpdate(); + } + + exports['default'] = _createUncontrollable2['default']([mixin], set); + module.exports = exports['default']; + +/***/ }, +/* 157 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = 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; }; + + exports['default'] = createUncontrollable; + + function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj['default'] = obj; return newObj; } } + + 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; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _utils = __webpack_require__(158); + + var utils = _interopRequireWildcard(_utils); + + function createUncontrollable(mixins, set) { + + return uncontrollable; + + function uncontrollable(Component, controlledValues) { + var methods = arguments.length <= 2 || arguments[2] === undefined ? [] : arguments[2]; + + var displayName = Component.displayName || Component.name || 'Component', + basePropTypes = utils.getType(Component).propTypes, + propTypes; + + propTypes = utils.uncontrolledPropTypes(controlledValues, basePropTypes, displayName); + + methods = utils.transform(methods, function (obj, method) { + obj[method] = function () { + var _refs$inner; + + return (_refs$inner = this.refs.inner)[method].apply(_refs$inner, arguments); + }; + }, {}); + + var component = _react2['default'].createClass(_extends({ + + displayName: 'Uncontrolled(' + displayName + ')', + + mixins: mixins, + + propTypes: propTypes + + }, methods, { + + componentWillMount: function componentWillMount() { + var props = this.props, + keys = Object.keys(controlledValues); + + this._values = utils.transform(keys, function (values, key) { + values[key] = props[utils.defaultKey(key)]; + }, {}); + }, + + /** + * If a prop switches from controlled to Uncontrolled + * reset its value to the defaultValue + */ + componentWillReceiveProps: function componentWillReceiveProps(nextProps) { + var _this = this; + + var props = this.props, + keys = Object.keys(controlledValues); + + keys.forEach(function (key) { + if (utils.getValue(nextProps, key) === undefined && utils.getValue(props, key) !== undefined) { + _this._values[key] = nextProps[utils.defaultKey(key)]; + } + }); + }, + + render: function render() { + var _this2 = this; + + var newProps = {}; + var _props = this.props; + var valueLink = _props.valueLink; + var checkedLink = _props.checkedLink; + + var props = _objectWithoutProperties(_props, ['valueLink', 'checkedLink']); + + utils.each(controlledValues, function (handle, propName) { + var linkPropName = utils.getLinkName(propName), + prop = _this2.props[propName]; + + if (linkPropName && !isProp(_this2.props, propName) && isProp(_this2.props, linkPropName)) { + prop = _this2.props[linkPropName].value; + } + + newProps[propName] = prop !== undefined ? prop : _this2._values[propName]; + + newProps[handle] = setAndNotify.bind(_this2, propName); + }); + + newProps = _extends({}, props, newProps, { ref: 'inner' }); + + return _react2['default'].createElement(Component, newProps); + } + + })); + + component.ControlledComponent = Component; + + return component; + + function setAndNotify(propName, value) { + var linkName = utils.getLinkName(propName), + handler = this.props[controlledValues[propName]]; + + if (linkName && isProp(this.props, linkName) && !handler) { + handler = this.props[linkName].requestChange; + } + + for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { + args[_key - 2] = arguments[_key]; + } + + set(this, propName, handler, value, args); + } + + function isProp(props, prop) { + return props[prop] !== undefined; + } + } + } + + module.exports = exports['default']; + +/***/ }, +/* 158 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports.customPropType = customPropType; + exports.uncontrolledPropTypes = uncontrolledPropTypes; + exports.getType = getType; + exports.getValue = getValue; + exports.getLinkName = getLinkName; + exports.defaultKey = defaultKey; + exports.chain = chain; + exports.transform = transform; + exports.each = each; + exports.has = has; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _invariant = __webpack_require__(32); + + var _invariant2 = _interopRequireDefault(_invariant); + + function customPropType(handler, propType, name) { + + return function (props, propName) { + + if (props[propName] !== undefined) { + if (!props[handler]) { + return new Error('You have provided a `' + propName + '` prop to ' + '`' + name + '` without an `' + handler + '` handler. This will render a read-only field. ' + 'If the field should be mutable use `' + defaultKey(propName) + '`. Otherwise, set `' + handler + '`'); + } + + return propType && propType(props, propName, name); + } + }; + } + + function uncontrolledPropTypes(controlledValues, basePropTypes, displayName) { + var propTypes = {}; + + if (("development") !== 'production' && basePropTypes) { + transform(controlledValues, function (obj, handler, prop) { + var type = basePropTypes[prop]; + + _invariant2['default'](typeof handler === 'string' && handler.trim().length, 'Uncontrollable - [%s]: the prop `%s` needs a valid handler key name in order to make it uncontrollable', displayName, prop); + + obj[prop] = customPropType(handler, type, displayName); + + if (type !== undefined) obj[defaultKey(prop)] = type; + }, propTypes); + } + + return propTypes; + } + + var version = _react2['default'].version.split('.').map(parseFloat); + + exports.version = version; + + function getType(component) { + if (version[0] === 0 && version[1] >= 13) return component; + + return component.type; + } + + function getValue(props, name) { + var linkPropName = getLinkName(name); + + if (linkPropName && !isProp(props, name) && isProp(props, linkPropName)) return props[linkPropName].value; + + return props[name]; + } + + function isProp(props, prop) { + return props[prop] !== undefined; + } + + function getLinkName(name) { + return name === 'value' ? 'valueLink' : name === 'checked' ? 'checkedLink' : null; + } + + function defaultKey(key) { + return 'default' + key.charAt(0).toUpperCase() + key.substr(1); + } + + function chain(thisArg, a, b) { + return function chainedFunction() { + for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + a && a.call.apply(a, [thisArg].concat(args)); + b && b.call.apply(b, [thisArg].concat(args)); + }; + } + + function transform(obj, cb, seed) { + each(obj, cb.bind(null, seed = seed || (Array.isArray(obj) ? [] : {}))); + return seed; + } + + function each(obj, cb, thisArg) { + if (Array.isArray(obj)) return obj.forEach(cb, thisArg); + + for (var key in obj) if (has(obj, key)) cb.call(thisArg, obj[key], key, obj); + } + + function has(o, k) { + return o ? Object.prototype.hasOwnProperty.call(o, k) : false; + } + +/***/ }, +/* 159 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _keycode = __webpack_require__(86); + + var _keycode2 = _interopRequireDefault(_keycode); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _reactOverlaysLibRootCloseWrapper = __webpack_require__(160); + + var _reactOverlaysLibRootCloseWrapper2 = _interopRequireDefault(_reactOverlaysLibRootCloseWrapper); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var DropdownMenu = (function (_React$Component) { + _inherits(DropdownMenu, _React$Component); + + function DropdownMenu(props) { + _classCallCheck(this, DropdownMenu); + + _React$Component.call(this, props); + + this.focusNext = this.focusNext.bind(this); + this.focusPrevious = this.focusPrevious.bind(this); + this.getFocusableMenuItems = this.getFocusableMenuItems.bind(this); + this.getItemsAndActiveIndex = this.getItemsAndActiveIndex.bind(this); + + this.handleKeyDown = this.handleKeyDown.bind(this); + } + + DropdownMenu.prototype.handleKeyDown = function handleKeyDown(event) { + switch (event.keyCode) { + case _keycode2['default'].codes.down: + this.focusNext(); + event.preventDefault(); + break; + case _keycode2['default'].codes.up: + this.focusPrevious(); + event.preventDefault(); + break; + case _keycode2['default'].codes.esc: + case _keycode2['default'].codes.tab: + this.props.onClose(event); + break; + default: + } + }; + + DropdownMenu.prototype.focusNext = function focusNext() { + var _getItemsAndActiveIndex = this.getItemsAndActiveIndex(); + + var items = _getItemsAndActiveIndex.items; + var activeItemIndex = _getItemsAndActiveIndex.activeItemIndex; + + if (items.length === 0) { + return; + } + + if (activeItemIndex === items.length - 1) { + items[0].focus(); + return; + } + + items[activeItemIndex + 1].focus(); + }; + + DropdownMenu.prototype.focusPrevious = function focusPrevious() { + var _getItemsAndActiveIndex2 = this.getItemsAndActiveIndex(); + + var items = _getItemsAndActiveIndex2.items; + var activeItemIndex = _getItemsAndActiveIndex2.activeItemIndex; + + if (activeItemIndex === 0) { + items[items.length - 1].focus(); + return; + } + + items[activeItemIndex - 1].focus(); + }; + + DropdownMenu.prototype.getItemsAndActiveIndex = function getItemsAndActiveIndex() { + var items = this.getFocusableMenuItems(); + var activeElement = document.activeElement; + var activeItemIndex = items.indexOf(activeElement); + + return { items: items, activeItemIndex: activeItemIndex }; + }; + + DropdownMenu.prototype.getFocusableMenuItems = function getFocusableMenuItems() { + var menuNode = _reactDom2['default'].findDOMNode(this); + + if (menuNode === undefined) { + return []; + } + + return [].slice.call(menuNode.querySelectorAll('[tabIndex="-1"]'), 0); + }; + + DropdownMenu.prototype.render = function render() { + var _classes, + _this = this; + + var _props = this.props; + var children = _props.children; + var onSelect = _props.onSelect; + var pullRight = _props.pullRight; + var className = _props.className; + var labelledBy = _props.labelledBy; + var open = _props.open; + var onClose = _props.onClose; + + var props = _objectWithoutProperties(_props, ['children', 'onSelect', 'pullRight', 'className', 'labelledBy', 'open', 'onClose']); + + var items = _utilsValidComponentChildren2['default'].map(children, function (child) { + var childProps = child.props || {}; + + return _react2['default'].cloneElement(child, { + onKeyDown: _utilsCreateChainedFunction2['default'](childProps.onKeyDown, _this.handleKeyDown), + onSelect: _utilsCreateChainedFunction2['default'](childProps.onSelect, onSelect) + }, childProps.children); + }); + + var classes = (_classes = {}, _classes[_utilsBootstrapUtils2['default'].prefix(this.props, 'menu')] = true, _classes[_utilsBootstrapUtils2['default'].prefix(this.props, 'menu-right')] = pullRight, _classes); + + var list = _react2['default'].createElement( + 'ul', + _extends({ + className: _classnames2['default'](className, classes), + role: 'menu', + 'aria-labelledby': labelledBy + }, props), + items + ); + + if (open) { + list = _react2['default'].createElement( + _reactOverlaysLibRootCloseWrapper2['default'], + { noWrap: true, onRootClose: onClose }, + list + ); + } + + return list; + }; + + return DropdownMenu; + })(_react2['default'].Component); + + DropdownMenu.defaultProps = { + bsRole: 'menu', + bsClass: 'dropdown', + pullRight: false + }; + + DropdownMenu.propTypes = { + open: _react2['default'].PropTypes.bool, + pullRight: _react2['default'].PropTypes.bool, + onClose: _react2['default'].PropTypes.func, + labelledBy: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + onSelect: _react2['default'].PropTypes.func + }; + + exports['default'] = DropdownMenu; + module.exports = exports['default']; + +/***/ }, +/* 160 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + 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__(4); + + var _react2 = _interopRequireDefault(_react); + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + var _utilsAddEventListener = __webpack_require__(161); + + var _utilsAddEventListener2 = _interopRequireDefault(_utilsAddEventListener); + + var _utilsCreateChainedFunction = __webpack_require__(163); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _utilsOwnerDocument = __webpack_require__(164); + + var _utilsOwnerDocument2 = _interopRequireDefault(_utilsOwnerDocument); + + // TODO: Consider using an ES6 symbol here, once we use babel-runtime. + var CLICK_WAS_INSIDE = '__click_was_inside'; + + var counter = 0; + + function getSuppressRootClose() { + var id = CLICK_WAS_INSIDE + '_' + counter++; + return { + id: id, + suppressRootClose: function suppressRootClose(event) { + // Tag the native event to prevent the root close logic on document click. + // This seems safer than using event.nativeEvent.stopImmediatePropagation(), + // which is only supported in IE >= 9. + event.nativeEvent[id] = true; + } + }; + } + + var RootCloseWrapper = (function (_React$Component) { + function RootCloseWrapper(props) { + _classCallCheck(this, RootCloseWrapper); + + _React$Component.call(this, props); + + this.handleDocumentClick = this.handleDocumentClick.bind(this); + this.handleDocumentKeyUp = this.handleDocumentKeyUp.bind(this); + + var _getSuppressRootClose = getSuppressRootClose(); + + var id = _getSuppressRootClose.id; + var suppressRootClose = _getSuppressRootClose.suppressRootClose; + + this._suppressRootId = id; + + this._suppressRootCloseHandler = suppressRootClose; + } + + _inherits(RootCloseWrapper, _React$Component); + + RootCloseWrapper.prototype.bindRootCloseHandlers = function bindRootCloseHandlers() { + var doc = _utilsOwnerDocument2['default'](this); + + this._onDocumentClickListener = _utilsAddEventListener2['default'](doc, 'click', this.handleDocumentClick); + + this._onDocumentKeyupListener = _utilsAddEventListener2['default'](doc, 'keyup', this.handleDocumentKeyUp); + }; + + RootCloseWrapper.prototype.handleDocumentClick = function handleDocumentClick(e) { + // This is now the native event. + if (e[this._suppressRootId]) { + return; + } + + this.props.onRootClose(); + }; + + RootCloseWrapper.prototype.handleDocumentKeyUp = function handleDocumentKeyUp(e) { + if (e.keyCode === 27) { + this.props.onRootClose(); + } + }; + + RootCloseWrapper.prototype.unbindRootCloseHandlers = function unbindRootCloseHandlers() { + if (this._onDocumentClickListener) { + this._onDocumentClickListener.remove(); + } + + if (this._onDocumentKeyupListener) { + this._onDocumentKeyupListener.remove(); + } + }; + + RootCloseWrapper.prototype.componentDidMount = function componentDidMount() { + this.bindRootCloseHandlers(); + }; + + RootCloseWrapper.prototype.render = function render() { + var _props = this.props; + var noWrap = _props.noWrap; + var children = _props.children; + + var child = _react2['default'].Children.only(children); + + if (noWrap) { + return _react2['default'].cloneElement(child, { + onClick: _utilsCreateChainedFunction2['default'](this._suppressRootCloseHandler, child.props.onClick) + }); + } + + // Wrap the child in a new element, so the child won't have to handle + // potentially combining multiple onClick listeners. + return _react2['default'].createElement( + 'div', + { onClick: this._suppressRootCloseHandler }, + child + ); + }; + + RootCloseWrapper.prototype.getWrappedDOMNode = function getWrappedDOMNode() { + // We can't use a ref to identify the wrapped child, since we might be + // stealing the ref from the owner, but we know exactly the DOM structure + // that will be rendered, so we can just do this to get the child's DOM + // node for doing size calculations in OverlayMixin. + var node = _reactDom2['default'].findDOMNode(this); + return this.props.noWrap ? node : node.firstChild; + }; + + RootCloseWrapper.prototype.componentWillUnmount = function componentWillUnmount() { + this.unbindRootCloseHandlers(); + }; + + return RootCloseWrapper; + })(_react2['default'].Component); + + exports['default'] = RootCloseWrapper; + + RootCloseWrapper.displayName = 'RootCloseWrapper'; + + RootCloseWrapper.propTypes = { + onRootClose: _react2['default'].PropTypes.func.isRequired, + + /** + * Passes the suppress click handler directly to the child component instead + * of placing it on a wrapping div. Only use when you can be sure the child + * properly handle the click event. + */ + noWrap: _react2['default'].PropTypes.bool + }; + module.exports = exports['default']; + +/***/ }, +/* 161 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _domHelpersEventsOn = __webpack_require__(79); + + var _domHelpersEventsOn2 = _interopRequireDefault(_domHelpersEventsOn); + + var _domHelpersEventsOff = __webpack_require__(162); + + var _domHelpersEventsOff2 = _interopRequireDefault(_domHelpersEventsOff); + + exports['default'] = function (node, event, handler) { + _domHelpersEventsOn2['default'](node, event, handler); + return { + remove: function remove() { + _domHelpersEventsOff2['default'](node, event, handler); + } + }; + }; + + module.exports = exports['default']; + +/***/ }, +/* 162 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var canUseDOM = __webpack_require__(78); + var off = function off() {}; + + if (canUseDOM) { + + off = (function () { + + if (document.addEventListener) return function (node, eventName, handler, capture) { + return node.removeEventListener(eventName, handler, capture || false); + };else if (document.attachEvent) return function (node, eventName, handler) { + return node.detachEvent('on' + eventName, handler); + }; + })(); + } + + module.exports = off; + +/***/ }, +/* 163 */ +/***/ function(module, exports) { + + /** + * Safe chained function + * + * Will only create a new function if needed, + * otherwise will pass back existing functions or null. + * + * @param {function} functions to chain + * @returns {function|null} + */ + 'use strict'; + + exports.__esModule = true; + function createChainedFunction() { + for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) { + funcs[_key] = arguments[_key]; + } + + return funcs.filter(function (f) { + return f != null; + }).reduce(function (acc, f) { + if (typeof f !== 'function') { + throw new Error('Invalid Argument Type, must only provide functions, undefined, or null.'); + } + + if (acc === null) { + return f; + } + + return function chainedFunction() { + for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + acc.apply(this, args); + f.apply(this, args); + }; + }, null); + } + + exports['default'] = createChainedFunction; + module.exports = exports['default']; + +/***/ }, +/* 164 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + var _domHelpersOwnerDocument = __webpack_require__(84); + + var _domHelpersOwnerDocument2 = _interopRequireDefault(_domHelpersOwnerDocument); + + exports['default'] = function (componentOrElement) { + return _domHelpersOwnerDocument2['default'](_reactDom2['default'].findDOMNode(componentOrElement)); + }; + + module.exports = exports['default']; + +/***/ }, +/* 165 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _Button = __webpack_require__(51); + + var _Button2 = _interopRequireDefault(_Button); + + var _SafeAnchor = __webpack_require__(42); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + var CARET = _react2['default'].createElement( + 'span', + null, + ' ', + _react2['default'].createElement('span', { className: 'caret' }) + ); + + var DropdownToggle = (function (_React$Component) { + _inherits(DropdownToggle, _React$Component); + + function DropdownToggle() { + _classCallCheck(this, DropdownToggle); + + _React$Component.apply(this, arguments); + } + + DropdownToggle.prototype.render = function render() { + var caret = this.props.noCaret ? null : CARET; + + var classes = { + 'dropdown-toggle': true + }; + + var Component = this.props.useAnchor ? _SafeAnchor2['default'] : _Button2['default']; + + return _react2['default'].createElement( + Component, + _extends({}, this.props, { + className: _classnames2['default'](classes, this.props.className), + type: 'button', + 'aria-haspopup': true, + 'aria-expanded': this.props.open }), + this.props.children || this.props.title, + caret + ); + }; + + return DropdownToggle; + })(_react2['default'].Component); + + exports['default'] = DropdownToggle; + + DropdownToggle.defaultProps = { + open: false, + useAnchor: false, + bsRole: 'toggle' + }; + + DropdownToggle.propTypes = { + bsRole: _react2['default'].PropTypes.string, + noCaret: _react2['default'].PropTypes.bool, + open: _react2['default'].PropTypes.bool, + title: _react2['default'].PropTypes.string, + useAnchor: _react2['default'].PropTypes.bool + }; + + DropdownToggle.isToggle = true; + DropdownToggle.titleProp = 'title'; + DropdownToggle.onClickProp = 'onClick'; + module.exports = exports['default']; + +/***/ }, +/* 166 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _reactPropTypesLibCommon = __webpack_require__(53); + + var _childrenToArray = __webpack_require__(167); + + var _childrenToArray2 = _interopRequireDefault(_childrenToArray); + + exports['default'] = { + + requiredRoles: function requiredRoles() { + for (var _len = arguments.length, roles = Array(_len), _key = 0; _key < _len; _key++) { + roles[_key] = arguments[_key]; + } + + return _reactPropTypesLibCommon.createChainableTypeChecker(function requiredRolesValidator(props, propName, component) { + var missing = undefined; + var children = _childrenToArray2['default'](props.children); + + var inRole = function inRole(role, child) { + return role === child.props.bsRole; + }; + + roles.every(function (role) { + if (!children.some(function (child) { + return inRole(role, child); + })) { + missing = role; + return false; + } + return true; + }); + + if (missing) { + return new Error('(children) ' + component + ' - Missing a required child with bsRole: ' + missing + '. ' + (component + ' must have at least one child of each of the following bsRoles: ' + roles.join(', '))); + } + }); + }, + + exclusiveRoles: function exclusiveRoles() { + for (var _len2 = arguments.length, roles = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + roles[_key2] = arguments[_key2]; + } + + return _reactPropTypesLibCommon.createChainableTypeChecker(function exclusiveRolesValidator(props, propName, component) { + var children = _childrenToArray2['default'](props.children); + var duplicate = undefined; + + roles.every(function (role) { + var childrenWithRole = children.filter(function (child) { + return child.props.bsRole === role; + }); + + if (childrenWithRole.length > 1) { + duplicate = role; + return false; + } + return true; + }); + + if (duplicate) { + return new Error('(children) ' + component + ' - Duplicate children detected of bsRole: ' + duplicate + '. ' + ('Only one child each allowed with the following bsRoles: ' + roles.join(', '))); + } + }); + } + }; + module.exports = exports['default']; + +/***/ }, +/* 167 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + exports['default'] = childrenAsArray; + + var _ValidComponentChildren = __webpack_require__(7); + + var _ValidComponentChildren2 = _interopRequireDefault(_ValidComponentChildren); + + function childrenAsArray(children) { + var result = []; + + if (children === undefined) { + return result; + } + + _ValidComponentChildren2['default'].forEach(children, function (child) { + result.push(child); + }); + + return result; + } + + module.exports = exports['default']; + +/***/ }, +/* 168 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _Object$keys = __webpack_require__(28)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _Dropdown = __webpack_require__(82); + + var _Dropdown2 = _interopRequireDefault(_Dropdown); + + var _lodashCompatObjectOmit = __webpack_require__(140); + + var _lodashCompatObjectOmit2 = _interopRequireDefault(_lodashCompatObjectOmit); + + var _lodashCompatObjectPick = __webpack_require__(169); + + var _lodashCompatObjectPick2 = _interopRequireDefault(_lodashCompatObjectPick); + + var _Button = __webpack_require__(51); + + var _Button2 = _interopRequireDefault(_Button); + + var DropdownButton = (function (_React$Component) { + _inherits(DropdownButton, _React$Component); + + function DropdownButton() { + _classCallCheck(this, DropdownButton); + + _React$Component.apply(this, arguments); + } + + DropdownButton.prototype.render = function render() { + var _props = this.props; + var bsStyle = _props.bsStyle; + var bsSize = _props.bsSize; + var disabled = _props.disabled; + var _props2 = this.props; + var title = _props2.title; + var children = _props2.children; + + var props = _objectWithoutProperties(_props2, ['title', 'children']); + + var dropdownProps = _lodashCompatObjectPick2['default'](props, _Object$keys(_Dropdown2['default'].ControlledComponent.propTypes)); + var toggleProps = _lodashCompatObjectOmit2['default'](props, _Object$keys(_Dropdown2['default'].ControlledComponent.propTypes)); + + return _react2['default'].createElement( + _Dropdown2['default'], + _extends({}, dropdownProps, { + bsSize: bsSize, + bsStyle: bsStyle + }), + _react2['default'].createElement( + _Dropdown2['default'].Toggle, + _extends({}, toggleProps, { + disabled: disabled + }), + title + ), + _react2['default'].createElement( + _Dropdown2['default'].Menu, + null, + children + ) + ); + }; + + return DropdownButton; + })(_react2['default'].Component); + + DropdownButton.propTypes = _extends({ + disabled: _react2['default'].PropTypes.bool, + bsStyle: _Button2['default'].propTypes.bsStyle, + bsSize: _Button2['default'].propTypes.bsSize, + + /** + * When used with the `title` prop, the noCaret option will not render a caret icon, in the toggle element. + */ + noCaret: _react2['default'].PropTypes.bool, + title: _react2['default'].PropTypes.node.isRequired + + }, _Dropdown2['default'].propTypes); + + DropdownButton.defaultProps = { + disabled: false, + pullRight: false, + dropup: false, + navItem: false, + noCaret: false + }; + + exports['default'] = DropdownButton; + module.exports = exports['default']; + +/***/ }, +/* 169 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFlatten = __webpack_require__(149), + bindCallback = __webpack_require__(134), + pickByArray = __webpack_require__(151), + pickByCallback = __webpack_require__(152), + restParam = __webpack_require__(154); + + /** + * Creates an object composed of the picked `object` properties. Property + * names may be specified as individual arguments or as arrays of property + * names. If `predicate` is provided it's invoked for each property of `object` + * picking the properties `predicate` returns truthy for. The predicate is + * bound to `thisArg` and invoked with three arguments: (value, key, object). + * + * @static + * @memberOf _ + * @category Object + * @param {Object} object The source object. + * @param {Function|...(string|string[])} [predicate] The function invoked per + * iteration or property names to pick, specified as individual property + * names or arrays of property names. + * @param {*} [thisArg] The `this` binding of `predicate`. + * @returns {Object} Returns the new object. + * @example + * + * var object = { 'user': 'fred', 'age': 40 }; + * + * _.pick(object, 'user'); + * // => { 'user': 'fred' } + * + * _.pick(object, _.isString); + * // => { 'user': 'fred' } + */ + var pick = restParam(function(object, props) { + if (object == null) { + return {}; + } + return typeof props[0] == 'function' + ? pickByCallback(object, bindCallback(props[0], props[1], 3)) + : pickByArray(object, baseFlatten(props)); + }); + + module.exports = pick; + + +/***/ }, +/* 170 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _reactPropTypesLibElementType = __webpack_require__(52); + + var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType); + + var Grid = _react2['default'].createClass({ + displayName: 'Grid', + + propTypes: { + /** + * Turn any fixed-width grid layout into a full-width layout by this property. + * + * Adds `container-fluid` class. + */ + fluid: _react2['default'].PropTypes.bool, + /** + * You can use a custom element for this component + */ + componentClass: _reactPropTypesLibElementType2['default'] + }, + + getDefaultProps: function getDefaultProps() { + return { + componentClass: 'div', + fluid: false + }; + }, + + render: function render() { + var ComponentClass = this.props.componentClass; + var className = this.props.fluid ? 'container-fluid' : 'container'; + + return _react2['default'].createElement( + ComponentClass, + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, className) }), + this.props.children + ); + } + }); + + exports['default'] = Grid; + module.exports = exports['default']; + +/***/ }, +/* 171 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var Image = _react2['default'].createClass({ + displayName: 'Image', + + propTypes: { + + /** + * Sets image as responsive image + */ + responsive: _react2['default'].PropTypes.bool, + + /** + * Sets image shape as rounded + */ + rounded: _react2['default'].PropTypes.bool, + + /** + * Sets image shape as circle + */ + circle: _react2['default'].PropTypes.bool, + + /** + * Sets image shape as thumbnail + */ + thumbnail: _react2['default'].PropTypes.bool + }, + + getDefaultProps: function getDefaultProps() { + return { + responsive: false, + rounded: false, + circle: false, + thumbnail: false + }; + }, + + render: function render() { + var classes = { + 'img-responsive': this.props.responsive, + 'img-rounded': this.props.rounded, + 'img-circle': this.props.circle, + 'img-thumbnail': this.props.thumbnail + }; + + return _react2['default'].createElement('img', _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) })); + } + }); + + exports['default'] = Image; + module.exports = exports['default']; + +/***/ }, +/* 172 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + var _interopRequireWildcard = __webpack_require__(2)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _InputBase2 = __webpack_require__(58); + + var _InputBase3 = _interopRequireDefault(_InputBase2); + + var _FormControls = __webpack_require__(173); + + var FormControls = _interopRequireWildcard(_FormControls); + + var _utilsDeprecationWarning = __webpack_require__(81); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var Input = (function (_InputBase) { + _inherits(Input, _InputBase); + + function Input() { + _classCallCheck(this, Input); + + _InputBase.apply(this, arguments); + } + + Input.prototype.render = function render() { + if (this.props.type === 'static') { + _utilsDeprecationWarning2['default']('Input type=static', 'FormControls.Static'); + return _react2['default'].createElement(FormControls.Static, this.props); + } + + return _InputBase.prototype.render.call(this); + }; + + return Input; + })(_InputBase3['default']); + + Input.propTypes = { + type: _react2['default'].PropTypes.string + }; + + exports['default'] = Input; + module.exports = exports['default']; + +/***/ }, +/* 173 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _Static2 = __webpack_require__(174); + + var _Static3 = _interopRequireDefault(_Static2); + + exports.Static = _Static3['default']; + +/***/ }, +/* 174 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _InputBase2 = __webpack_require__(58); + + var _InputBase3 = _interopRequireDefault(_InputBase2); + + var _utilsChildrenValueInputValidation = __webpack_require__(3); + + var _utilsChildrenValueInputValidation2 = _interopRequireDefault(_utilsChildrenValueInputValidation); + + var Static = (function (_InputBase) { + _inherits(Static, _InputBase); + + function Static() { + _classCallCheck(this, Static); + + _InputBase.apply(this, arguments); + } + + Static.prototype.getValue = function getValue() { + var _props = this.props; + var children = _props.children; + var value = _props.value; + + return children ? children : value; + }; + + Static.prototype.renderInput = function renderInput() { + return _react2['default'].createElement( + 'p', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, 'form-control-static'), ref: 'input', key: 'input' }), + this.getValue() + ); + }; + + return Static; + })(_InputBase3['default']); + + Static.propTypes = { + value: _utilsChildrenValueInputValidation2['default'], + children: _utilsChildrenValueInputValidation2['default'] + }; + + exports['default'] = Static; + module.exports = exports['default']; + +/***/ }, +/* 175 */ +/***/ function(module, exports, __webpack_require__) { + + // https://www.npmjs.org/package/react-interpolate-component + // TODO: Drop this in favor of es6 string interpolation + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var REGEXP = /\%\((.+?)\)s/; + + var Interpolate = _react2['default'].createClass({ + displayName: 'Interpolate', + + propTypes: { + component: _react2['default'].PropTypes.node, + format: _react2['default'].PropTypes.string, + unsafe: _react2['default'].PropTypes.bool + }, + + getDefaultProps: function getDefaultProps() { + return { + component: 'span', + unsafe: false + }; + }, + + render: function render() { + var format = _utilsValidComponentChildren2['default'].hasValidComponent(this.props.children) || typeof this.props.children === 'string' ? this.props.children : this.props.format; + var parent = this.props.component; + var unsafe = this.props.unsafe === true; + var props = _extends({}, this.props); + + delete props.children; + delete props.format; + delete props.component; + delete props.unsafe; + + if (unsafe) { + var content = format.split(REGEXP).reduce(function (memo, match, index) { + var html = undefined; + + if (index % 2 === 0) { + html = match; + } else { + html = props[match]; + delete props[match]; + } + + if (_react2['default'].isValidElement(html)) { + throw new Error('cannot interpolate a React component into unsafe text'); + } + + memo += html; + + return memo; + }, ''); + + props.dangerouslySetInnerHTML = { __html: content }; + + return _react2['default'].createElement(parent, props); + } + var kids = format.split(REGEXP).reduce(function (memo, match, index) { + var child = undefined; + + if (index % 2 === 0) { + if (match.length === 0) { + return memo; + } + + child = match; + } else { + child = props[match]; + delete props[match]; + } + + memo.push(child); + + return memo; + }, []); + + return _react2['default'].createElement(parent, props, kids); + } + }); + + exports['default'] = Interpolate; + module.exports = exports['default']; + +/***/ }, +/* 176 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _reactPropTypesLibElementType = __webpack_require__(52); + + var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType); + + var Jumbotron = _react2['default'].createClass({ + displayName: 'Jumbotron', + + propTypes: { + /** + * You can use a custom element for this component + */ + componentClass: _reactPropTypesLibElementType2['default'] + }, + + getDefaultProps: function getDefaultProps() { + return { componentClass: 'div' }; + }, + + render: function render() { + var ComponentClass = this.props.componentClass; + + return _react2['default'].createElement( + ComponentClass, + _extends({}, this.props, { className: _classnames2['default'](this.props.className, 'jumbotron') }), + this.props.children + ); + } + }); + + exports['default'] = Jumbotron; + module.exports = exports['default']; + +/***/ }, +/* 177 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _styleMaps = __webpack_require__(25); + + var Label = (function (_React$Component) { + _inherits(Label, _React$Component); + + function Label() { + _classCallCheck(this, _Label); + + _React$Component.apply(this, arguments); + } + + Label.prototype.render = function render() { + var classes = _utilsBootstrapUtils2['default'].getClassSet(this.props); + + return _react2['default'].createElement( + 'span', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + }; + + var _Label = Label; + Label = _utilsBootstrapUtils.bsStyles(_styleMaps.State.values().concat(_styleMaps.DEFAULT, _styleMaps.PRIMARY), _styleMaps.DEFAULT)(Label) || Label; + Label = _utilsBootstrapUtils.bsClass('label')(Label) || Label; + return Label; + })(_react2['default'].Component); + + exports['default'] = Label; + module.exports = exports['default']; + +/***/ }, +/* 178 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _ListGroupItem = __webpack_require__(179); + + var _ListGroupItem2 = _interopRequireDefault(_ListGroupItem); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var ListGroup = (function (_React$Component) { + _inherits(ListGroup, _React$Component); + + function ListGroup() { + _classCallCheck(this, ListGroup); + + _React$Component.apply(this, arguments); + } + + ListGroup.prototype.render = function render() { + var _this = this; + + var items = _utilsValidComponentChildren2['default'].map(this.props.children, function (item, index) { + return _react.cloneElement(item, { key: item.key ? item.key : index }); + }); + + if (this.areCustomChildren(items)) { + var Component = this.props.componentClass; + return _react2['default'].createElement( + Component, + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, 'list-group') }), + items + ); + } + + var shouldRenderDiv = false; + + if (!this.props.children) { + shouldRenderDiv = true; + } else { + _utilsValidComponentChildren2['default'].forEach(this.props.children, function (child) { + if (_this.isAnchorOrButton(child.props)) { + shouldRenderDiv = true; + } + }); + } + + return shouldRenderDiv ? this.renderDiv(items) : this.renderUL(items); + }; + + ListGroup.prototype.isAnchorOrButton = function isAnchorOrButton(props) { + return props.href || props.onClick; + }; + + ListGroup.prototype.areCustomChildren = function areCustomChildren(children) { + var customChildren = false; + + _utilsValidComponentChildren2['default'].forEach(children, function (child) { + if (child.type !== _ListGroupItem2['default']) { + customChildren = true; + } + }, this); + + return customChildren; + }; + + ListGroup.prototype.renderUL = function renderUL(items) { + var listItems = _utilsValidComponentChildren2['default'].map(items, function (item) { + return _react.cloneElement(item, { listItem: true }); + }); + + return _react2['default'].createElement( + 'ul', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, 'list-group') }), + listItems + ); + }; + + ListGroup.prototype.renderDiv = function renderDiv(items) { + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, 'list-group') }), + items + ); + }; + + return ListGroup; + })(_react2['default'].Component); + + ListGroup.defaultProps = { + componentClass: 'div' + }; + + ListGroup.propTypes = { + className: _react2['default'].PropTypes.string, + /** + * The element for ListGroup if children are + * user-defined custom components. + * @type {("ul"|"div")} + */ + componentClass: _react2['default'].PropTypes.oneOf(['ul', 'div']), + id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]) + }; + + exports['default'] = ListGroup; + module.exports = exports['default']; + +/***/ }, +/* 179 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _styleMaps = __webpack_require__(25); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var ListGroupItem = (function (_React$Component) { + _inherits(ListGroupItem, _React$Component); + + function ListGroupItem() { + _classCallCheck(this, ListGroupItem); + + _React$Component.apply(this, arguments); + } + + ListGroupItem.prototype.render = function render() { + var classes = _utilsBootstrapUtils2['default'].getClassSet(this.props); + + classes.active = this.props.active; + classes.disabled = this.props.disabled; + + if (this.props.href) { + return this.renderAnchor(classes); + } else if (this.props.onClick) { + return this.renderButton(classes); + } else if (this.props.listItem) { + return this.renderLi(classes); + } + + return this.renderSpan(classes); + }; + + ListGroupItem.prototype.renderLi = function renderLi(classes) { + return _react2['default'].createElement( + 'li', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.props.header ? this.renderStructuredContent() : this.props.children + ); + }; + + ListGroupItem.prototype.renderAnchor = function renderAnchor(classes) { + return _react2['default'].createElement( + 'a', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, classes) + }), + this.props.header ? this.renderStructuredContent() : this.props.children + ); + }; + + ListGroupItem.prototype.renderButton = function renderButton(classes) { + return _react2['default'].createElement( + 'button', + _extends({ + type: 'button' + }, this.props, { + className: _classnames2['default'](this.props.className, classes) }), + this.props.header ? this.renderStructuredContent() : this.props.children + ); + }; + + ListGroupItem.prototype.renderSpan = function renderSpan(classes) { + return _react2['default'].createElement( + 'span', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.props.header ? this.renderStructuredContent() : this.props.children + ); + }; + + ListGroupItem.prototype.renderStructuredContent = function renderStructuredContent() { + var header = undefined; + var headingClass = _utilsBootstrapUtils2['default'].prefix(this.props, 'heading'); + + if (_react2['default'].isValidElement(this.props.header)) { + header = _react.cloneElement(this.props.header, { + key: 'header', + className: _classnames2['default'](this.props.header.props.className, headingClass) + }); + } else { + header = _react2['default'].createElement( + 'h4', + { key: 'header', className: headingClass }, + this.props.header + ); + } + + var content = _react2['default'].createElement( + 'p', + { key: 'content', className: _utilsBootstrapUtils2['default'].prefix(this.props, 'text') }, + this.props.children + ); + + return [header, content]; + }; + + return ListGroupItem; + })(_react2['default'].Component); + + ListGroupItem.propTypes = { + className: _react2['default'].PropTypes.string, + active: _react2['default'].PropTypes.any, + disabled: _react2['default'].PropTypes.any, + header: _react2['default'].PropTypes.node, + listItem: _react2['default'].PropTypes.bool, + onClick: _react2['default'].PropTypes.func, + eventKey: _react2['default'].PropTypes.any, + href: _react2['default'].PropTypes.string, + target: _react2['default'].PropTypes.string + }; + + ListGroupItem.defaultTypes = { + listItem: false + }; + + exports['default'] = _utilsBootstrapUtils.bsStyles(_styleMaps.State.values(), _utilsBootstrapUtils.bsClass('list-group-item', ListGroupItem)); + module.exports = exports['default']; + +/***/ }, +/* 180 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _reactPropTypesLibAll = __webpack_require__(55); + + var _reactPropTypesLibAll2 = _interopRequireDefault(_reactPropTypesLibAll); + + var _SafeAnchor = __webpack_require__(42); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var MenuItem = (function (_React$Component) { + _inherits(MenuItem, _React$Component); + + function MenuItem(props) { + _classCallCheck(this, MenuItem); + + _React$Component.call(this, props); + + this.handleClick = this.handleClick.bind(this); + } + + MenuItem.prototype.handleClick = function handleClick(event) { + if (!this.props.href || this.props.disabled) { + event.preventDefault(); + } + + if (this.props.disabled) { + return; + } + + if (this.props.onSelect) { + this.props.onSelect(event, this.props.eventKey); + } + }; + + MenuItem.prototype.render = function render() { + var headerClass = _utilsBootstrapUtils2['default'].prefix(this.props, 'header'); + + if (this.props.divider) { + return _react2['default'].createElement('li', { role: 'separator', className: 'divider' }); + } + + if (this.props.header) { + return _react2['default'].createElement( + 'li', + { role: 'heading', className: headerClass }, + this.props.children + ); + } + + var _props = this.props; + var className = _props.className; + var style = _props.style; + var onClick = _props.onClick; + + var props = _objectWithoutProperties(_props, ['className', 'style', 'onClick']); + + var classes = { + disabled: this.props.disabled, + active: this.props.active + }; + + return _react2['default'].createElement( + 'li', + { role: 'presentation', + className: _classnames2['default'](className, classes), + style: style + }, + _react2['default'].createElement(_SafeAnchor2['default'], _extends({}, props, { + role: 'menuitem', + tabIndex: '-1', + onClick: _utilsCreateChainedFunction2['default'](onClick, this.handleClick) + })) + ); + }; + + return MenuItem; + })(_react2['default'].Component); + + MenuItem.propTypes = { + active: _react2['default'].PropTypes.bool, + disabled: _react2['default'].PropTypes.bool, + divider: _reactPropTypesLibAll2['default'](_react2['default'].PropTypes.bool, function (props) { + if (props.divider && props.children) { + return new Error('Children will not be rendered for dividers'); + } + }), + eventKey: _react2['default'].PropTypes.any, + header: _react2['default'].PropTypes.bool, + href: _react2['default'].PropTypes.string, + target: _react2['default'].PropTypes.string, + title: _react2['default'].PropTypes.string, + onClick: _react2['default'].PropTypes.func, + onKeyDown: _react2['default'].PropTypes.func, + onSelect: _react2['default'].PropTypes.func, + id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]) + }; + + MenuItem.defaultProps = { + divider: false, + disabled: false, + header: false + }; + + exports['default'] = _utilsBootstrapUtils.bsClass('dropdown', MenuItem); + module.exports = exports['default']; + +/***/ }, +/* 181 */ +/***/ function(module, exports, __webpack_require__) { + + + /* eslint-disable react/prop-types */ + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _Object$keys = __webpack_require__(28)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _styleMaps = __webpack_require__(25); + + var _domHelpersUtilScrollbarSize = __webpack_require__(182); + + var _domHelpersUtilScrollbarSize2 = _interopRequireDefault(_domHelpersUtilScrollbarSize); + + var _domHelpersUtilInDOM = __webpack_require__(78); + + var _domHelpersUtilInDOM2 = _interopRequireDefault(_domHelpersUtilInDOM); + + var _domHelpersOwnerDocument = __webpack_require__(84); + + var _domHelpersOwnerDocument2 = _interopRequireDefault(_domHelpersOwnerDocument); + + var _domHelpersEvents = __webpack_require__(183); + + var _domHelpersEvents2 = _interopRequireDefault(_domHelpersEvents); + + var _reactPropTypesLibElementType = __webpack_require__(52); + + var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType); + + var _Fade = __webpack_require__(186); + + var _Fade2 = _interopRequireDefault(_Fade); + + var _ModalDialog = __webpack_require__(187); + + var _ModalDialog2 = _interopRequireDefault(_ModalDialog); + + var _ModalBody = __webpack_require__(188); + + var _ModalBody2 = _interopRequireDefault(_ModalBody); + + var _ModalHeader = __webpack_require__(189); + + var _ModalHeader2 = _interopRequireDefault(_ModalHeader); + + var _ModalTitle = __webpack_require__(190); + + var _ModalTitle2 = _interopRequireDefault(_ModalTitle); + + var _ModalFooter = __webpack_require__(191); + + var _ModalFooter2 = _interopRequireDefault(_ModalFooter); + + var _reactOverlaysLibModal = __webpack_require__(192); + + var _reactOverlaysLibModal2 = _interopRequireDefault(_reactOverlaysLibModal); + + var _reactOverlaysLibUtilsIsOverflowing = __webpack_require__(203); + + var _reactOverlaysLibUtilsIsOverflowing2 = _interopRequireDefault(_reactOverlaysLibUtilsIsOverflowing); + + var _lodashCompatObjectPick = __webpack_require__(169); + + var _lodashCompatObjectPick2 = _interopRequireDefault(_lodashCompatObjectPick); + + var Modal = _react2['default'].createClass({ + displayName: 'Modal', + + propTypes: _extends({}, _reactOverlaysLibModal2['default'].propTypes, _ModalDialog2['default'].propTypes, { + + /** + * Include a backdrop component. Specify 'static' for a backdrop that doesn't trigger an "onHide" when clicked. + */ + backdrop: _react2['default'].PropTypes.oneOf(['static', true, false]), + + /** + * Close the modal when escape key is pressed + */ + keyboard: _react2['default'].PropTypes.bool, + + /** + * Open and close the Modal with a slide and fade animation. + */ + animation: _react2['default'].PropTypes.bool, + + /** + * A Component type that provides the modal content Markup. This is a useful prop when you want to use your own + * styles and markup to create a custom modal component. + */ + dialogComponent: _reactPropTypesLibElementType2['default'], + + /** + * When `true` The modal will automatically shift focus to itself when it opens, and replace it to the last focused element when it closes. + * Generally this should never be set to false as it makes the Modal less accessible to assistive technologies, like screen-readers. + */ + autoFocus: _react2['default'].PropTypes.bool, + + /** + * When `true` The modal will prevent focus from leaving the Modal while open. + * Consider leaving the default value here, as it is necessary to make the Modal work well with assistive technologies, + * such as screen readers. + */ + enforceFocus: _react2['default'].PropTypes.bool, + + /** + * Hide this from automatic props documentation generation. + * @private + */ + bsStyle: _react2['default'].PropTypes.string, + + /** + * When `true` The modal will show itself. + */ + show: _react2['default'].PropTypes.bool, + + /** + * A callback fired when the header closeButton or non-static backdrop is + * clicked. Required if either are specified. + */ + onHide: _react2['default'].PropTypes.func + }), + + childContextTypes: { + '$bs_onModalHide': _react2['default'].PropTypes.func + }, + + getDefaultProps: function getDefaultProps() { + return _extends({}, _reactOverlaysLibModal2['default'].defaultProps, { + bsClass: 'modal', + animation: true, + dialogComponent: _ModalDialog2['default'] + }); + }, + + getInitialState: function getInitialState() { + return { + modalStyles: {} + }; + }, + + getChildContext: function getChildContext() { + return { + $bs_onModalHide: this.props.onHide + }; + }, + + render: function render() { + var _this = this; + + var _props = this.props; + var className = _props.className; + var children = _props.children; + var dialogClassName = _props.dialogClassName; + var animation = _props.animation; + + var props = _objectWithoutProperties(_props, ['className', 'children', 'dialogClassName', 'animation']); + + var modalStyles = this.state.modalStyles; + + var inClass = { 'in': props.show && !animation }; + var Dialog = props.dialogComponent; + + var parentProps = _lodashCompatObjectPick2['default'](props, _Object$keys(_reactOverlaysLibModal2['default'].propTypes).concat(['onExit', 'onExiting', 'onEnter', 'onEntered']) // the rest are fired in _onHide() and _onShow() + ); + + var modal = _react2['default'].createElement( + Dialog, + _extends({ + key: 'modal', + ref: function (ref) { + return _this._modal = ref; + } + }, props, { + style: modalStyles, + className: _classnames2['default'](className, inClass), + dialogClassName: dialogClassName, + onClick: props.backdrop === true ? this.handleDialogClick : null + }), + this.props.children + ); + + return _react2['default'].createElement( + _reactOverlaysLibModal2['default'], + _extends({}, parentProps, { + show: props.show, + ref: function (ref) { + _this._wrapper = ref && ref.refs.modal; + _this._backdrop = ref && ref.refs.backdrop; + }, + onEntering: this._onShow, + onExited: this._onHide, + backdropClassName: _classnames2['default'](_utilsBootstrapUtils2['default'].prefix(props, 'backdrop'), inClass), + containerClassName: _utilsBootstrapUtils2['default'].prefix(props, 'open'), + transition: animation ? _Fade2['default'] : undefined, + dialogTransitionTimeout: Modal.TRANSITION_DURATION, + backdropTransitionTimeout: Modal.BACKDROP_TRANSITION_DURATION + }), + modal + ); + }, + + _onShow: function _onShow() { + _domHelpersEvents2['default'].on(window, 'resize', this.handleWindowResize); + + this.setState(this._getStyles()); + + if (this.props.onEntering) { + var _props2; + + (_props2 = this.props).onEntering.apply(_props2, arguments); + } + }, + + _onHide: function _onHide() { + _domHelpersEvents2['default'].off(window, 'resize', this.handleWindowResize); + + if (this.props.onExited) { + var _props3; + + (_props3 = this.props).onExited.apply(_props3, arguments); + } + }, + + handleDialogClick: function handleDialogClick(e) { + if (e.target !== e.currentTarget) { + return; + } + + this.props.onHide(); + }, + + handleWindowResize: function handleWindowResize() { + this.setState(this._getStyles()); + }, + + _getStyles: function _getStyles() { + if (!_domHelpersUtilInDOM2['default']) { + return {}; + } + + var node = _reactDom2['default'].findDOMNode(this._modal); + var doc = _domHelpersOwnerDocument2['default'](node); + + var scrollHt = node.scrollHeight; + var bodyIsOverflowing = _reactOverlaysLibUtilsIsOverflowing2['default'](_reactDom2['default'].findDOMNode(this.props.container || doc.body)); + var modalIsOverflowing = scrollHt > doc.documentElement.clientHeight; + + return { + modalStyles: { + paddingRight: bodyIsOverflowing && !modalIsOverflowing ? _domHelpersUtilScrollbarSize2['default']() : void 0, + paddingLeft: !bodyIsOverflowing && modalIsOverflowing ? _domHelpersUtilScrollbarSize2['default']() : void 0 + } + }; + } + }); + + Modal.Body = _ModalBody2['default']; + Modal.Header = _ModalHeader2['default']; + Modal.Title = _ModalTitle2['default']; + Modal.Footer = _ModalFooter2['default']; + + Modal.Dialog = _ModalDialog2['default']; + + Modal.TRANSITION_DURATION = 300; + Modal.BACKDROP_TRANSITION_DURATION = 150; + + exports['default'] = _utilsBootstrapUtils.bsSizes([_styleMaps.Sizes.LARGE, _styleMaps.Sizes.SMALL], _utilsBootstrapUtils.bsClass('modal', Modal)); + module.exports = exports['default']; + +/***/ }, +/* 182 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var canUseDOM = __webpack_require__(78); + + var size; + + module.exports = function (recalc) { + if (!size || recalc) { + if (canUseDOM) { + var scrollDiv = document.createElement('div'); + + scrollDiv.style.position = 'absolute'; + scrollDiv.style.top = '-9999px'; + scrollDiv.style.width = '50px'; + scrollDiv.style.height = '50px'; + scrollDiv.style.overflow = 'scroll'; + + document.body.appendChild(scrollDiv); + size = scrollDiv.offsetWidth - scrollDiv.clientWidth; + document.body.removeChild(scrollDiv); + } + } + + return size; + }; + +/***/ }, +/* 183 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var on = __webpack_require__(79), + off = __webpack_require__(162), + filter = __webpack_require__(184); + + module.exports = { on: on, off: off, filter: filter }; + +/***/ }, +/* 184 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var contains = __webpack_require__(85), + qsa = __webpack_require__(185); + + module.exports = function (selector, handler) { + return function (e) { + var top = e.currentTarget, + target = e.target, + matches = qsa(top, selector); + + if (matches.some(function (match) { + return contains(match, target); + })) handler.call(this, e); + }; + }; + +/***/ }, +/* 185 */ +/***/ function(module, exports) { + + 'use strict'; + // Zepto.js + // (c) 2010-2015 Thomas Fuchs + // Zepto.js may be freely distributed under the MIT license. + var simpleSelectorRE = /^[\w-]*$/, + toArray = Function.prototype.bind.call(Function.prototype.call, [].slice); + + module.exports = function qsa(element, selector) { + var maybeID = selector[0] === '#', + maybeClass = selector[0] === '.', + nameOnly = maybeID || maybeClass ? selector.slice(1) : selector, + isSimple = simpleSelectorRE.test(nameOnly), + found; + + if (isSimple) { + if (maybeID) { + element = element.getElementById ? element : document; + return (found = element.getElementById(nameOnly)) ? [found] : []; + } + + if (element.getElementsByClassName && maybeClass) return toArray(element.getElementsByClassName(nameOnly)); + + return toArray(element.getElementsByTagName(selector)); + } + + return toArray(element.querySelectorAll(selector)); + }; + +/***/ }, +/* 186 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _reactOverlaysLibTransition = __webpack_require__(76); + + var _reactOverlaysLibTransition2 = _interopRequireDefault(_reactOverlaysLibTransition); + + var _reactPropTypesLibDeprecated = __webpack_require__(80); + + var _reactPropTypesLibDeprecated2 = _interopRequireDefault(_reactPropTypesLibDeprecated); + + var Fade = (function (_React$Component) { + _inherits(Fade, _React$Component); + + function Fade() { + _classCallCheck(this, Fade); + + _React$Component.apply(this, arguments); + } + + // Explicitly copied from Transition for doc generation. + // TODO: Remove duplication once #977 is resolved. + + Fade.prototype.render = function render() { + var timeout = this.props.timeout || this.props.duration; + + return _react2['default'].createElement( + _reactOverlaysLibTransition2['default'], + _extends({}, this.props, { + timeout: timeout, + className: _classnames2['default'](this.props.className, 'fade'), + enteredClassName: 'in', + enteringClassName: 'in' + }), + this.props.children + ); + }; + + return Fade; + })(_react2['default'].Component); + + Fade.propTypes = { + /** + * Show the component; triggers the fade in or fade out animation + */ + 'in': _react2['default'].PropTypes.bool, + + /** + * Unmount the component (remove it from the DOM) when it is faded out + */ + unmountOnExit: _react2['default'].PropTypes.bool, + + /** + * Run the fade in animation when the component mounts, if it is initially + * shown + */ + transitionAppear: _react2['default'].PropTypes.bool, + + /** + * Duration of the fade animation in milliseconds, to ensure that finishing + * callbacks are fired even if the original browser transition end events are + * canceled + */ + timeout: _react2['default'].PropTypes.number, + + /** + * duration + * @private + */ + duration: _reactPropTypesLibDeprecated2['default'](_react2['default'].PropTypes.number, 'Use `timeout`.'), + + /** + * Callback fired before the component fades in + */ + onEnter: _react2['default'].PropTypes.func, + /** + * Callback fired after the component starts to fade in + */ + onEntering: _react2['default'].PropTypes.func, + /** + * Callback fired after the has component faded in + */ + onEntered: _react2['default'].PropTypes.func, + /** + * Callback fired before the component fades out + */ + onExit: _react2['default'].PropTypes.func, + /** + * Callback fired after the component starts to fade out + */ + onExiting: _react2['default'].PropTypes.func, + /** + * Callback fired after the component has faded out + */ + onExited: _react2['default'].PropTypes.func + }; + + Fade.defaultProps = { + 'in': false, + timeout: 300, + unmountOnExit: false, + transitionAppear: false + }; + + exports['default'] = Fade; + module.exports = exports['default']; + +/***/ }, +/* 187 */ +/***/ function(module, exports, __webpack_require__) { + + /* eslint-disable react/prop-types */ + 'use strict'; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _styleMaps = __webpack_require__(25); + + var ModalDialog = _react2['default'].createClass({ + displayName: 'ModalDialog', + + propTypes: { + /** + * A css class to apply to the Modal dialog DOM node. + */ + dialogClassName: _react2['default'].PropTypes.string + }, + + render: function render() { + var modalStyle = _extends({ + display: 'block' + }, this.props.style); + var prefix = _utilsBootstrapUtils2['default'].prefix(this.props); + var dialogClasses = _utilsBootstrapUtils2['default'].getClassSet(this.props); + + delete dialogClasses[prefix]; + dialogClasses[_utilsBootstrapUtils2['default'].prefix(this.props, 'dialog')] = true; + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + title: null, + tabIndex: '-1', + role: 'dialog', + style: modalStyle, + className: _classnames2['default'](this.props.className, prefix) + }), + _react2['default'].createElement( + 'div', + { className: _classnames2['default'](this.props.dialogClassName, dialogClasses) }, + _react2['default'].createElement( + 'div', + { className: _utilsBootstrapUtils2['default'].prefix(this.props, 'content'), role: 'document' }, + this.props.children + ) + ) + ); + } + }); + + exports['default'] = _utilsBootstrapUtils.bsSizes([_styleMaps.Sizes.LARGE, _styleMaps.Sizes.SMALL], _utilsBootstrapUtils.bsClass('modal', ModalDialog)); + module.exports = exports['default']; + +/***/ }, +/* 188 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var ModalBody = (function (_React$Component) { + _inherits(ModalBody, _React$Component); + + function ModalBody() { + _classCallCheck(this, ModalBody); + + _React$Component.apply(this, arguments); + } + + ModalBody.prototype.render = function render() { + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, _utilsBootstrapUtils2['default'].prefix(this.props, 'body')) }), + this.props.children + ); + }; + + return ModalBody; + })(_react2['default'].Component); + + exports['default'] = _utilsBootstrapUtils.bsClass('modal', ModalBody); + module.exports = exports['default']; + +/***/ }, +/* 189 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _objectWithoutProperties = __webpack_require__(36)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var ModalHeader = (function (_React$Component) { + _inherits(ModalHeader, _React$Component); + + function ModalHeader() { + _classCallCheck(this, ModalHeader); + + _React$Component.apply(this, arguments); + } + + ModalHeader.prototype.render = function render() { + var _props = this.props; + var label = _props['aria-label']; + + var props = _objectWithoutProperties(_props, ['aria-label']); + + var onHide = _utilsCreateChainedFunction2['default'](this.context.$bs_onModalHide, this.props.onHide); + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, _utilsBootstrapUtils2['default'].prefix(this.props, 'header')) + }), + this.props.closeButton && _react2['default'].createElement( + 'button', + { + type: 'button', + className: 'close', + 'aria-label': label, + onClick: onHide }, + _react2['default'].createElement( + 'span', + { 'aria-hidden': 'true' }, + '×' + ) + ), + this.props.children + ); + }; + + return ModalHeader; + })(_react2['default'].Component); + + ModalHeader.propTypes = { + /** + * The 'aria-label' attribute provides an accessible label for the close button. + * It is used for Assistive Technology when the label text is not readable. + */ + 'aria-label': _react2['default'].PropTypes.string, + + bsClass: _react2['default'].PropTypes.string, + + /** + * Specify whether the Component should contain a close button + */ + closeButton: _react2['default'].PropTypes.bool, + + /** + * A Callback fired when the close button is clicked. If used directly inside a Modal component, the onHide will automatically + * be propagated up to the parent Modal `onHide`. + */ + onHide: _react2['default'].PropTypes.func + }; + + ModalHeader.contextTypes = { + '$bs_onModalHide': _react2['default'].PropTypes.func + }; + + ModalHeader.defaultProps = { + 'aria-label': 'Close', + closeButton: false + }; + + exports['default'] = _utilsBootstrapUtils.bsClass('modal', ModalHeader); + module.exports = exports['default']; + +/***/ }, +/* 190 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var ModalTitle = (function (_React$Component) { + _inherits(ModalTitle, _React$Component); + + function ModalTitle() { + _classCallCheck(this, ModalTitle); + + _React$Component.apply(this, arguments); + } + + ModalTitle.prototype.render = function render() { + return _react2['default'].createElement( + 'h4', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, _utilsBootstrapUtils2['default'].prefix(this.props, 'title')) }), + this.props.children + ); + }; + + return ModalTitle; + })(_react2['default'].Component); + + exports['default'] = _utilsBootstrapUtils.bsClass('modal', ModalTitle); + module.exports = exports['default']; + +/***/ }, +/* 191 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var ModalFooter = (function (_React$Component) { + _inherits(ModalFooter, _React$Component); + + function ModalFooter() { + _classCallCheck(this, ModalFooter); + + _React$Component.apply(this, arguments); + } + + ModalFooter.prototype.render = function render() { + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, _utilsBootstrapUtils2['default'].prefix(this.props, 'footer')) }), + this.props.children + ); + }; + + return ModalFooter; + })(_react2['default'].Component); + + ModalFooter.propTypes = { + /** + * A css class applied to the Component + */ + bsClass: _react2['default'].PropTypes.string + }; + + ModalFooter.defaultProps = { + bsClass: 'modal' + }; + + exports['default'] = _utilsBootstrapUtils.bsClass('modal', ModalFooter); + module.exports = exports['default']; + +/***/ }, +/* 192 */ +/***/ function(module, exports, __webpack_require__) { + + /*eslint-disable react/prop-types */ + 'use strict'; + + exports.__esModule = 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 }; } + + 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; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _warning = __webpack_require__(33); + + var _warning2 = _interopRequireDefault(_warning); + + var _reactPropTypesLibMountable = __webpack_require__(193); + + var _reactPropTypesLibMountable2 = _interopRequireDefault(_reactPropTypesLibMountable); + + var _reactPropTypesLibElementType = __webpack_require__(195); + + var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType); + + var _Portal = __webpack_require__(196); + + var _Portal2 = _interopRequireDefault(_Portal); + + var _ModalManager = __webpack_require__(198); + + var _ModalManager2 = _interopRequireDefault(_ModalManager); + + var _utilsOwnerDocument = __webpack_require__(164); + + var _utilsOwnerDocument2 = _interopRequireDefault(_utilsOwnerDocument); + + var _utilsAddEventListener = __webpack_require__(161); + + var _utilsAddEventListener2 = _interopRequireDefault(_utilsAddEventListener); + + var _utilsAddFocusListener = __webpack_require__(206); + + var _utilsAddFocusListener2 = _interopRequireDefault(_utilsAddFocusListener); + + var _domHelpersUtilInDOM = __webpack_require__(78); + + var _domHelpersUtilInDOM2 = _interopRequireDefault(_domHelpersUtilInDOM); + + var _domHelpersActiveElement = __webpack_require__(83); + + var _domHelpersActiveElement2 = _interopRequireDefault(_domHelpersActiveElement); + + var _domHelpersQueryContains = __webpack_require__(85); + + var _domHelpersQueryContains2 = _interopRequireDefault(_domHelpersQueryContains); + + var _utilsGetContainer = __webpack_require__(197); + + var _utilsGetContainer2 = _interopRequireDefault(_utilsGetContainer); + + var modalManager = new _ModalManager2['default'](); + + /** + * Love them or hate them, `` provides a solid foundation for creating dialogs, lightboxes, or whatever else. + * The Modal component renders its `children` node in front of a backdrop component. + * + * The Modal offers a few helpful features over using just a `` component and some styles: + * + * - Manages dialog stacking when one-at-a-time just isn't enough. + * - Creates a backdrop, for disabling interaction below the modal. + * - It properly manages focus; moving to the modal content, and keeping it there until the modal is closed. + * - It disables scrolling of the page content while open. + * - Adds the appropriate ARIA roles are automatically. + * - Easily pluggable animations via a `` component. + * + */ + var Modal = _react2['default'].createClass({ + displayName: 'Modal', + + propTypes: _extends({}, _Portal2['default'].propTypes, { + + /** + * A Node, Component instance, or function that returns either. The Modal is appended to it's container element. + * + * For the sake of assistive technologies, the container should usually be the document body, so that the rest of the + * page content can be placed behind a virtual backdrop as well as a visual one. + */ + container: _react2['default'].PropTypes.oneOfType([_reactPropTypesLibMountable2['default'], _react2['default'].PropTypes.func]), + + /** + * A callback fired when the Modal is opening. + */ + onShow: _react2['default'].PropTypes.func, + + /** + * A callback fired when either the backdrop is clicked, or the escape key is pressed. + */ + onHide: _react2['default'].PropTypes.func, + + /** + * Include a backdrop component. + */ + backdrop: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.bool, _react2['default'].PropTypes.oneOf(['static'])]), + + /** + * A callback fired when the escape key, if specified in `keyboard`, is pressed. + */ + onEscapeKeyUp: _react2['default'].PropTypes.func, + + /** + * A callback fired when the backdrop, if specified, is clicked. + */ + onBackdropClick: _react2['default'].PropTypes.func, + + /** + * A style object for the backdrop component. + */ + backdropStyle: _react2['default'].PropTypes.object, + + /** + * A css class or classes for the backdrop component. + */ + backdropClassName: _react2['default'].PropTypes.string, + + /** + * A css class or set of classes applied to the modal container when the modal is open, + * and removed when it is closed. + */ + containerClassName: _react2['default'].PropTypes.string, + + /** + * Close the modal when escape key is pressed + */ + keyboard: _react2['default'].PropTypes.bool, + + /** + * A `` component to use for the dialog and backdrop components. + */ + transition: _reactPropTypesLibElementType2['default'], + + /** + * The `timeout` of the dialog transition if specified. This number is used to ensure that transition callbacks are always + * fired, even if browser transition events are canceled. + * + * See the Transition `timeout` prop for more infomation. + */ + dialogTransitionTimeout: _react2['default'].PropTypes.number, + + /** + * The `timeout` of the backdrop transition if specified. This number is used to ensure that transition callbacks are always + * fired, even if browser transition events are canceled. + * + * See the Transition `timeout` prop for more infomation. + */ + backdropTransitionTimeout: _react2['default'].PropTypes.number, + + /** + * When `true` The modal will automatically shift focus to itself when it opens, and replace it to the last focused element when it closes. + * Generally this should never be set to false as it makes the Modal less accessible to assistive technologies, like screen readers. + */ + autoFocus: _react2['default'].PropTypes.bool, + + /** + * When `true` The modal will prevent focus from leaving the Modal while open. + * Generally this should never be set to false as it makes the Modal less accessible to assistive technologies, like screen readers. + */ + enforceFocus: _react2['default'].PropTypes.bool + + }), + + getDefaultProps: function getDefaultProps() { + var noop = function noop() {}; + + return { + show: false, + backdrop: true, + keyboard: true, + autoFocus: true, + enforceFocus: true, + onHide: noop + }; + }, + + getInitialState: function getInitialState() { + return { exited: !this.props.show }; + }, + + render: function render() { + var _this = this; + + var _props = this.props; + var children = _props.children; + var Transition = _props.transition; + var backdrop = _props.backdrop; + var dialogTransitionTimeout = _props.dialogTransitionTimeout; + + var props = _objectWithoutProperties(_props, ['children', 'transition', 'backdrop', 'dialogTransitionTimeout']); + + var onExit = props.onExit; + var onExiting = props.onExiting; + var onEnter = props.onEnter; + var onEntering = props.onEntering; + var onEntered = props.onEntered; + + var show = !!props.show; + var dialog = _react2['default'].Children.only(this.props.children); + + var setMountNode = function setMountNode(ref) { + return _this.mountNode = !ref || ref.getMountNode(); + }; + + var mountModal = show || Transition && !this.state.exited; + + if (!mountModal) { + return null; + } + + var _dialog$props = dialog.props; + var role = _dialog$props.role; + var tabIndex = _dialog$props.tabIndex; + + if (role === undefined || tabIndex === undefined) { + dialog = _react.cloneElement(dialog, { + role: role === undefined ? 'document' : role, + tabIndex: tabIndex == null ? '-1' : tabIndex + }); + } + + if (Transition) { + dialog = _react2['default'].createElement( + Transition, + { + transitionAppear: true, + unmountOnExit: true, + 'in': show, + timeout: dialogTransitionTimeout, + onExit: onExit, + onExiting: onExiting, + onExited: this.handleHidden, + onEnter: onEnter, + onEntering: onEntering, + onEntered: onEntered + }, + dialog + ); + } + + return _react2['default'].createElement( + _Portal2['default'], + { + ref: setMountNode, + container: props.container + }, + _react2['default'].createElement( + 'div', + { + ref: 'modal', + role: props.role || 'dialog', + style: props.style, + className: props.className + }, + backdrop && this.renderBackdrop(), + dialog + ) + ); + }, + + renderBackdrop: function renderBackdrop() { + var _props2 = this.props; + var Transition = _props2.transition; + var backdropTransitionTimeout = _props2.backdropTransitionTimeout; + + var backdrop = _react2['default'].createElement('div', { ref: 'backdrop', + style: this.props.backdropStyle, + className: this.props.backdropClassName, + onClick: this.handleBackdropClick + }); + + if (Transition) { + backdrop = _react2['default'].createElement( + Transition, + { transitionAppear: true, + 'in': this.props.show, + timeout: backdropTransitionTimeout + }, + backdrop + ); + } + + return backdrop; + }, + + componentWillReceiveProps: function componentWillReceiveProps(nextProps) { + if (nextProps.show) { + this.setState({ exited: false }); + } else if (!nextProps.transition) { + // Otherwise let handleHidden take care of marking exited. + this.setState({ exited: true }); + } + }, + + componentWillUpdate: function componentWillUpdate(nextProps) { + if (nextProps.show) { + this.checkForFocus(); + } + }, + + componentDidMount: function componentDidMount() { + if (this.props.show) { + this.onShow(); + } + }, + + componentDidUpdate: function componentDidUpdate(prevProps) { + var transition = this.props.transition; + + if (prevProps.show && !this.props.show && !transition) { + // Otherwise handleHidden will call this. + this.onHide(); + } else if (!prevProps.show && this.props.show) { + this.onShow(); + } + }, + + componentWillUnmount: function componentWillUnmount() { + var _props3 = this.props; + var show = _props3.show; + var transition = _props3.transition; + + if (show || transition && !this.state.exited) { + this.onHide(); + } + }, + + onShow: function onShow() { + var doc = _utilsOwnerDocument2['default'](this); + var container = _utilsGetContainer2['default'](this.props.container, doc.body); + + modalManager.add(this, container, this.props.containerClassName); + + this._onDocumentKeyupListener = _utilsAddEventListener2['default'](doc, 'keyup', this.handleDocumentKeyUp); + + this._onFocusinListener = _utilsAddFocusListener2['default'](this.enforceFocus); + + this.focus(); + }, + + onHide: function onHide() { + modalManager.remove(this); + + this._onDocumentKeyupListener.remove(); + + this._onFocusinListener.remove(); + + this.restoreLastFocus(); + }, + + handleHidden: function handleHidden() { + this.setState({ exited: true }); + this.onHide(); + + if (this.props.onExited) { + var _props4; + + (_props4 = this.props).onExited.apply(_props4, arguments); + } + }, + + handleBackdropClick: function handleBackdropClick(e) { + if (e.target !== e.currentTarget) { + return; + } + + if (this.props.onBackdropClick) { + this.props.onBackdropClick(e); + } + + if (this.props.backdrop === true) { + this.props.onHide(); + } + }, + + handleDocumentKeyUp: function handleDocumentKeyUp(e) { + if (this.props.keyboard && e.keyCode === 27 && this.isTopModal()) { + if (this.props.onEscapeKeyUp) { + this.props.onEscapeKeyUp(e); + } + this.props.onHide(); + } + }, + + checkForFocus: function checkForFocus() { + if (_domHelpersUtilInDOM2['default']) { + this.lastFocus = _domHelpersActiveElement2['default'](); + } + }, + + focus: function focus() { + var autoFocus = this.props.autoFocus; + var modalContent = this.getDialogElement(); + var current = _domHelpersActiveElement2['default'](_utilsOwnerDocument2['default'](this)); + var focusInModal = current && _domHelpersQueryContains2['default'](modalContent, current); + + if (modalContent && autoFocus && !focusInModal) { + this.lastFocus = current; + + if (!modalContent.hasAttribute('tabIndex')) { + modalContent.setAttribute('tabIndex', -1); + _warning2['default'](false, 'The modal content node does not accept focus. ' + 'For the benefit of assistive technologies, the tabIndex of the node is being set to "-1".'); + } + + modalContent.focus(); + } + }, + + restoreLastFocus: function restoreLastFocus() { + // Support: <=IE11 doesn't support `focus()` on svg elements (RB: #917) + if (this.lastFocus && this.lastFocus.focus) { + this.lastFocus.focus(); + this.lastFocus = null; + } + }, + + enforceFocus: function enforceFocus() { + var enforceFocus = this.props.enforceFocus; + + if (!enforceFocus || !this.isMounted() || !this.isTopModal()) { + return; + } + + var active = _domHelpersActiveElement2['default'](_utilsOwnerDocument2['default'](this)); + var modal = this.getDialogElement(); + + if (modal && modal !== active && !_domHelpersQueryContains2['default'](modal, active)) { + modal.focus(); + } + }, + + //instead of a ref, which might conflict with one the parent applied. + getDialogElement: function getDialogElement() { + var node = this.refs.modal; + return node && node.lastChild; + }, + + isTopModal: function isTopModal() { + return modalManager.isTopModal(this); + } + + }); + + Modal.manager = modalManager; + + exports['default'] = Modal; + module.exports = exports['default']; + +/***/ }, +/* 193 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + var _common = __webpack_require__(194); + + /** + * 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} + */ + + function validate(props, propName, componentName) { + if (typeof props[propName] !== 'object' || typeof props[propName].render !== 'function' && props[propName].nodeType !== 1) { + return new Error(_common.errMsg(props, propName, componentName, ', expected a DOM element or an object that has a `render` method')); + } + } + + exports['default'] = _common.createChainableTypeChecker(validate); + module.exports = exports['default']; + +/***/ }, +/* 194 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + exports.errMsg = errMsg; + exports.createChainableTypeChecker = createChainableTypeChecker; + + 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 || '<>'; + 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; + } + +/***/ }, +/* 195 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _common = __webpack_require__(194); + + /** + * 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} + */ + + function validate(props, propName, componentName) { + var errBeginning = _common.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(...)'); + } + } + } + + exports['default'] = _common.createChainableTypeChecker(validate); + module.exports = exports['default']; + +/***/ }, +/* 196 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + var _reactPropTypesLibMountable = __webpack_require__(193); + + var _reactPropTypesLibMountable2 = _interopRequireDefault(_reactPropTypesLibMountable); + + var _utilsOwnerDocument = __webpack_require__(164); + + var _utilsOwnerDocument2 = _interopRequireDefault(_utilsOwnerDocument); + + var _utilsGetContainer = __webpack_require__(197); + + var _utilsGetContainer2 = _interopRequireDefault(_utilsGetContainer); + + /** + * The `` component renders its children into a new "subtree" outside of current component hierarchy. + * You can think of it as a declarative `appendChild()`, or jQuery's `$.fn.appendTo()`. + * The children of `` component will be appended to the `container` specified. + */ + var Portal = _react2['default'].createClass({ + + displayName: 'Portal', + + propTypes: { + /** + * A Node, Component instance, or function that returns either. The `container` will have the Portal children + * appended to it. + */ + container: _react2['default'].PropTypes.oneOfType([_reactPropTypesLibMountable2['default'], _react2['default'].PropTypes.func]) + }, + + componentDidMount: function componentDidMount() { + this._renderOverlay(); + }, + + componentDidUpdate: function componentDidUpdate() { + this._renderOverlay(); + }, + + componentWillUnmount: function componentWillUnmount() { + this._unrenderOverlay(); + this._unmountOverlayTarget(); + }, + + _mountOverlayTarget: function _mountOverlayTarget() { + if (!this._overlayTarget) { + this._overlayTarget = document.createElement('div'); + this.getContainerDOMNode().appendChild(this._overlayTarget); + } + }, + + _unmountOverlayTarget: function _unmountOverlayTarget() { + if (this._overlayTarget) { + this.getContainerDOMNode().removeChild(this._overlayTarget); + this._overlayTarget = null; + } + }, + + _renderOverlay: function _renderOverlay() { + + var overlay = !this.props.children ? null : _react2['default'].Children.only(this.props.children); + + // Save reference for future access. + if (overlay !== null) { + this._mountOverlayTarget(); + this._overlayInstance = _reactDom2['default'].unstable_renderSubtreeIntoContainer(this, overlay, this._overlayTarget); + } else { + // Unrender if the component is null for transitions to null + this._unrenderOverlay(); + this._unmountOverlayTarget(); + } + }, + + _unrenderOverlay: function _unrenderOverlay() { + if (this._overlayTarget) { + _reactDom2['default'].unmountComponentAtNode(this._overlayTarget); + this._overlayInstance = null; + } + }, + + render: function render() { + return null; + }, + + getMountNode: function getMountNode() { + return this._overlayTarget; + }, + + getOverlayDOMNode: function getOverlayDOMNode() { + if (!this.isMounted()) { + throw new Error('getOverlayDOMNode(): A component must be mounted to have a DOM node.'); + } + + if (this._overlayInstance) { + if (this._overlayInstance.getWrappedDOMNode) { + return this._overlayInstance.getWrappedDOMNode(); + } else { + return _reactDom2['default'].findDOMNode(this._overlayInstance); + } + } + + return null; + }, + + getContainerDOMNode: function getContainerDOMNode() { + return _utilsGetContainer2['default'](this.props.container, _utilsOwnerDocument2['default'](this).body); + } + }); + + exports['default'] = Portal; + module.exports = exports['default']; + +/***/ }, +/* 197 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = getContainer; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _reactDom = __webpack_require__(63); + + var _reactDom2 = _interopRequireDefault(_reactDom); + + function getContainer(container, defaultContainer) { + container = typeof container === 'function' ? container() : container; + return _reactDom2['default'].findDOMNode(container) || defaultContainer; + } + + module.exports = exports['default']; + +/***/ }, +/* 198 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + 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'); } } + + var _domHelpersStyle = __webpack_require__(68); + + var _domHelpersStyle2 = _interopRequireDefault(_domHelpersStyle); + + var _domHelpersClass = __webpack_require__(199); + + var _domHelpersClass2 = _interopRequireDefault(_domHelpersClass); + + var _domHelpersUtilScrollbarSize = __webpack_require__(182); + + var _domHelpersUtilScrollbarSize2 = _interopRequireDefault(_domHelpersUtilScrollbarSize); + + var _utilsIsOverflowing = __webpack_require__(203); + + var _utilsIsOverflowing2 = _interopRequireDefault(_utilsIsOverflowing); + + var _utilsManageAriaHidden = __webpack_require__(205); + + function findIndexOf(arr, cb) { + var idx = -1; + arr.some(function (d, i) { + if (cb(d, i)) { + idx = i; + return true; + } + }); + return idx; + } + + function findContainer(data, modal) { + return findIndexOf(data, function (d) { + return d.modals.indexOf(modal) !== -1; + }); + } + + /** + * Proper state managment for containers and the modals in those containers. + * + * @internal Used by the Modal to ensure proper styling of containers. + */ + + var ModalManager = (function () { + function ModalManager() { + var hideSiblingNodes = arguments[0] === undefined ? true : arguments[0]; + + _classCallCheck(this, ModalManager); + + this.hideSiblingNodes = hideSiblingNodes; + this.modals = []; + this.containers = []; + this.data = []; + } + + ModalManager.prototype.add = function add(modal, container, className) { + var modalIdx = this.modals.indexOf(modal); + var containerIdx = this.containers.indexOf(container); + + if (modalIdx !== -1) { + return modalIdx; + } + + modalIdx = this.modals.length; + this.modals.push(modal); + + if (this.hideSiblingNodes) { + _utilsManageAriaHidden.hideSiblings(container, modal.mountNode); + } + + if (containerIdx !== -1) { + this.data[containerIdx].modals.push(modal); + return modalIdx; + } + + var data = { + modals: [modal], + //right now only the first modal of a container will have its classes applied + classes: className ? className.split(/\s+/) : [], + //we are only interested in the actual `style` here becasue we will override it + style: { + overflow: container.style.overflow, + paddingRight: container.style.paddingRight + } + }; + + var style = { overflow: 'hidden' }; + + data.overflowing = _utilsIsOverflowing2['default'](container); + + if (data.overflowing) { + // use computed style, here to get the real padding + // to add our scrollbar width + style.paddingRight = parseInt(_domHelpersStyle2['default'](container, 'paddingRight') || 0, 10) + _domHelpersUtilScrollbarSize2['default']() + 'px'; + } + + _domHelpersStyle2['default'](container, style); + + data.classes.forEach(_domHelpersClass2['default'].addClass.bind(null, container)); + + this.containers.push(container); + this.data.push(data); + + return modalIdx; + }; + + ModalManager.prototype.remove = function remove(modal) { + var modalIdx = this.modals.indexOf(modal); + + if (modalIdx === -1) { + return; + } + + var containerIdx = findContainer(this.data, modal); + var data = this.data[containerIdx]; + var container = this.containers[containerIdx]; + + data.modals.splice(data.modals.indexOf(modal), 1); + + this.modals.splice(modalIdx, 1); + + //if that was the last modal in a container, clean it up. + if (data.modals.length === 0) { + Object.keys(data.style).forEach(function (key) { + return container.style[key] = data.style[key]; + }); + + data.classes.forEach(_domHelpersClass2['default'].removeClass.bind(null, container)); + + if (this.hideSiblingNodes) { + _utilsManageAriaHidden.showSiblings(container, modal.mountNode); + } + this.containers.splice(containerIdx, 1); + this.data.splice(containerIdx, 1); + } else if (this.hideSiblingNodes) { + //otherwise make sure the next top modal is visible to a SR + _utilsManageAriaHidden.ariaHidden(false, data.modals[data.modals.length - 1].mountNode); + } + }; + + ModalManager.prototype.isTopModal = function isTopModal(modal) { + return !!this.modals.length && this.modals[this.modals.length - 1] === modal; + }; + + return ModalManager; + })(); + + exports['default'] = ModalManager; + module.exports = exports['default']; + +/***/ }, +/* 199 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + module.exports = { + addClass: __webpack_require__(200), + removeClass: __webpack_require__(202), + hasClass: __webpack_require__(201) + }; + +/***/ }, +/* 200 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var hasClass = __webpack_require__(201); + + module.exports = function addClass(element, className) { + if (element.classList) element.classList.add(className);else if (!hasClass(element)) element.className = element.className + ' ' + className; + }; + +/***/ }, +/* 201 */ +/***/ function(module, exports) { + + 'use strict'; + module.exports = function hasClass(element, className) { + if (element.classList) return !!className && element.classList.contains(className);else return (' ' + element.className + ' ').indexOf(' ' + className + ' ') !== -1; + }; + +/***/ }, +/* 202 */ +/***/ function(module, exports) { + + 'use strict'; + + module.exports = function removeClass(element, className) { + if (element.classList) element.classList.remove(className);else element.className = element.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)', 'g'), '$1').replace(/\s+/g, ' ').replace(/^\s*|\s*$/g, ''); + }; + +/***/ }, +/* 203 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = isOverflowing; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _domHelpersQueryIsWindow = __webpack_require__(204); + + var _domHelpersQueryIsWindow2 = _interopRequireDefault(_domHelpersQueryIsWindow); + + var _domHelpersOwnerDocument = __webpack_require__(84); + + var _domHelpersOwnerDocument2 = _interopRequireDefault(_domHelpersOwnerDocument); + + function isBody(node) { + return node && node.tagName.toLowerCase() === 'body'; + } + + function bodyIsOverflowing(node) { + var doc = _domHelpersOwnerDocument2['default'](node); + var win = _domHelpersQueryIsWindow2['default'](doc); + var fullWidth = win.innerWidth; + + // Support: ie8, no innerWidth + if (!fullWidth) { + var documentElementRect = doc.documentElement.getBoundingClientRect(); + fullWidth = documentElementRect.right - Math.abs(documentElementRect.left); + } + + return doc.body.clientWidth < fullWidth; + } + + function isOverflowing(container) { + var win = _domHelpersQueryIsWindow2['default'](container); + + return win || isBody(container) ? bodyIsOverflowing(container) : container.scrollHeight > container.clientHeight; + } + + module.exports = exports['default']; + +/***/ }, +/* 204 */ +/***/ function(module, exports) { + + 'use strict'; + + module.exports = function getWindow(node) { + return node === node.window ? node : node.nodeType === 9 ? node.defaultView || node.parentWindow : false; + }; + +/***/ }, +/* 205 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + exports.ariaHidden = ariaHidden; + exports.hideSiblings = hideSiblings; + exports.showSiblings = showSiblings; + + var BLACKLIST = ['template', 'script', 'style']; + + var isHidable = function isHidable(_ref) { + var nodeType = _ref.nodeType; + var tagName = _ref.tagName; + return nodeType === 1 && BLACKLIST.indexOf(tagName.toLowerCase()) === -1; + }; + + var siblings = function siblings(container, mount, cb) { + mount = [].concat(mount); + + [].forEach.call(container.children, function (node) { + if (mount.indexOf(node) === -1 && isHidable(node)) { + cb(node); + } + }); + }; + + function ariaHidden(show, node) { + if (!node) { + return; + } + if (show) { + node.setAttribute('aria-hidden', 'true'); + } else { + node.removeAttribute('aria-hidden'); + } + } + + function hideSiblings(container, mountNode) { + siblings(container, mountNode, function (node) { + return ariaHidden(true, node); + }); + } + + function showSiblings(container, mountNode) { + siblings(container, mountNode, function (node) { + return ariaHidden(false, node); + }); + } + +/***/ }, +/* 206 */ +/***/ function(module, exports) { + + /** + * Firefox doesn't have a focusin event so using capture is easiest way to get bubbling + * IE8 can't do addEventListener, but does have onfocusin, so we use that in ie8 + * + * We only allow one Listener at a time to avoid stack overflows + */ + 'use strict'; + + exports.__esModule = true; + exports['default'] = addFocusListener; + + function addFocusListener(handler) { + var useFocusin = !document.addEventListener; + var remove = undefined; + + if (useFocusin) { + document.attachEvent('onfocusin', handler); + remove = function () { + return document.detachEvent('onfocusin', handler); + }; + } else { + document.addEventListener('focus', handler, true); + remove = function () { + return document.removeEventListener('focus', handler, true); + }; + } + + return { remove: remove }; + } + + module.exports = exports['default']; + +/***/ }, +/* 207 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(43)['default']; + + var _classCallCheck = __webpack_require__(50)['default']; + + var _extends = __webpack_require__(9)['default']; + + var _interopRequireDefault = __webpack_require__(1)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(4); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(37); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _reactPropTypesLibAll = __webpack_require__(55); + + var _reactPropTypesLibAll2 = _interopRequireDefault(_reactPropTypesLibAll); + + var _reactPropTypesLibDeprecated = __webpack_require__(80); + + var _reactPropTypesLibDeprecated2 = _interopRequireDefault(_reactPropTypesLibDeprecated); + + var _utilsBootstrapUtils = __webpack_require__(8); + + var _utilsBootstrapUtils2 = _interopRequireDefault(_utilsBootstrapUtils); + + var _utilsValidComponentChildren = __webpack_require__(7); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(6); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _Collapse = __webpack_require__(67); + + var _Collapse2 = _interopRequireDefault(_Collapse); + + var Nav = (function (_React$Component) { + _inherits(Nav, _React$Component); + + function Nav() { + _classCallCheck(this, Nav); + + _React$Component.apply(this, arguments); + } + + Nav.prototype.render = function render() { + var _props = this.props; + var className = _props.className; + var ulClassName = _props.ulClassName; + var id = _props.id; + var ulId = _props.ulId; + + var isNavbar = this.props.navbar != null ? this.props.navbar : this.context.$bs_navbar; + var classes = _utilsBootstrapUtils2['default'].getClassSet(this.props); + + classes[_utilsBootstrapUtils2['default'].prefix(this.props, 'stacked')] = this.props.stacked; + classes[_utilsBootstrapUtils2['default'].prefix(this.props, 'justified')] = this.props.justified; + + if (isNavbar) { + var bsClass = this.context.$bs_navbar_bsClass || 'navbar'; + var navbarRight = this.props.right != null ? this.props.right : this.props.pullRight; + + classes[_utilsBootstrapUtils2['default'].prefix({ bsClass: bsClass }, 'nav')] = true; + classes[_utilsBootstrapUtils2['default'].prefix({ bsClass: bsClass }, 'right')] = navbarRight; + classes[_utilsBootstrapUtils2['default'].prefix({ bsClass: bsClass }, 'left')] = this.props.pullLeft; + } else { + classes['pull-right'] = this.props.pullRight; + classes['pull-left'] = this.props.pullLeft; + } + + var list = _react2['default'].createElement( + 'ul', + _extends({ ref: 'ul' + }, this.props, { + id: ulId || id, + role: this.props.bsStyle === 'tabs' ? 'tablist' : null, + className: _classnames2['default'](className, ulClassName, classes) + }), + _utilsValidComponentChildren2['default'].map(this.props.children, this.renderNavItem, this) + ); + + // TODO remove in 0.29 + if (this.context.$bs_deprecated_navbar && this.props.collapsible) { + list = _react2['default'].createElement( + _Collapse2['default'], + { + 'in': this.props.expanded, + className: isNavbar ? 'navbar-collapse' : void 0 + }, + _react2['default'].createElement( + 'div', + null, + list + ) + ); + } + + return list; + }; + + Nav.prototype.getChildActiveProp = function getChildActiveProp(child) { + if (child.props.active) { + return true; + } + if (this.props.activeKey != null) { + if (child.props.eventKey === this.props.activeKey) { + return true; + } + } + if (this.props.activeHref != null) { + if (child.props.href === this.props.activeHref) { + return true; + } + } + + return child.props.active; + }; + + Nav.prototype.renderNavItem = function renderNavItem(child, index) { + return _react.cloneElement(child, { + role: this.props.bsStyle === 'tabs' ? 'tab' : null, + active: this.getChildActiveProp(child), + activeKey: this.props.activeKey, + activeHref: this.props.activeHref, + onSelect: _utilsCreateChainedFunction2['default'](child.props.onSelect, this.props.onSelect), + key: child.key ? child.key : index, + navItem: true + }); + }; + + return Nav; + })(_react2['default'].Component); + + Nav.propTypes = { + activeHref: _react2['default'].PropTypes.string, + activeKey: _react2['default'].PropTypes.any, + + stacked: _react2['default'].PropTypes.bool, + justified: _reactPropTypesLibAll2['default'](_react2['default'].PropTypes.bool, function (_ref) { + var justified = _ref.justified; + var navbar = _ref.navbar; + return justified && navbar ? Error('justified navbar `Nav`s are not supported') : null; + }), + onSelect: _react2['default'].PropTypes.func, + + /** + * CSS classes for the wrapper `nav` element + */ + className: _react2['default'].PropTypes.string, + /** + * HTML id for the wrapper `nav` element + */ + id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + /** + * CSS classes for the inner `ul` element + * + * @deprecated + */ + ulClassName: _reactPropTypesLibDeprecated2['default'](_react2['default'].PropTypes.string, 'The wrapping `