From 0ea0233c50dbccc498cb53481b9fdf18d027e5b2 Mon Sep 17 00:00:00 2001 From: Christopher Speller Date: Mon, 14 Sep 2015 13:56:58 -0400 Subject: New add channel modal using react-bootstrap. --- web/static/js/react-bootstrap-0.25.1.js | 15678 ++++++++++++++++++++++++++++++ 1 file changed, 15678 insertions(+) create mode 100644 web/static/js/react-bootstrap-0.25.1.js (limited to 'web/static/js/react-bootstrap-0.25.1.js') diff --git a/web/static/js/react-bootstrap-0.25.1.js b/web/static/js/react-bootstrap-0.25.1.js new file mode 100644 index 000000000..db5326612 --- /dev/null +++ b/web/static/js/react-bootstrap-0.25.1.js @@ -0,0 +1,15678 @@ +(function webpackUniversalModuleDefinition(root, factory) { + if(typeof exports === 'object' && typeof module === 'object') + module.exports = factory(require("react")); + else if(typeof define === 'function' && define.amd) + define(["react"], factory); + else if(typeof exports === 'object') + exports["ReactBootstrap"] = factory(require("react")); + else + root["ReactBootstrap"] = factory(root["React"]); +})(this, function(__WEBPACK_EXTERNAL_MODULE_32__) { +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 _Object$keys = __webpack_require__(1)['default']; + + var _Object$defineProperty = __webpack_require__(11)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + var _interopRequireWildcard = __webpack_require__(15)['default']; + + exports.__esModule = true; + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var _utilsDomUtils = __webpack_require__(31); + + var _utilsDomUtils2 = _interopRequireDefault(_utilsDomUtils); + + var _utilsChildrenValueInputValidation = __webpack_require__(52); + + var _utilsChildrenValueInputValidation2 = _interopRequireDefault(_utilsChildrenValueInputValidation); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _Accordion2 = __webpack_require__(57); + + var _Accordion3 = _interopRequireDefault(_Accordion2); + + exports.Accordion = _Accordion3['default']; + + var _Affix2 = __webpack_require__(71); + + var _Affix3 = _interopRequireDefault(_Affix2); + + exports.Affix = _Affix3['default']; + + var _AffixMixin2 = __webpack_require__(72); + + var _AffixMixin3 = _interopRequireDefault(_AffixMixin2); + + exports.AffixMixin = _AffixMixin3['default']; + + var _Alert2 = __webpack_require__(74); + + var _Alert3 = _interopRequireDefault(_Alert2); + + exports.Alert = _Alert3['default']; + + var _Badge2 = __webpack_require__(75); + + var _Badge3 = _interopRequireDefault(_Badge2); + + exports.Badge = _Badge3['default']; + + var _BootstrapMixin2 = __webpack_require__(69); + + var _BootstrapMixin3 = _interopRequireDefault(_BootstrapMixin2); + + exports.BootstrapMixin = _BootstrapMixin3['default']; + + var _Button2 = __webpack_require__(76); + + var _Button3 = _interopRequireDefault(_Button2); + + exports.Button = _Button3['default']; + + var _ButtonGroup2 = __webpack_require__(81); + + var _ButtonGroup3 = _interopRequireDefault(_ButtonGroup2); + + exports.ButtonGroup = _ButtonGroup3['default']; + + var _ButtonInput2 = __webpack_require__(77); + + var _ButtonInput3 = _interopRequireDefault(_ButtonInput2); + + exports.ButtonInput = _ButtonInput3['default']; + + var _ButtonToolbar2 = __webpack_require__(82); + + var _ButtonToolbar3 = _interopRequireDefault(_ButtonToolbar2); + + exports.ButtonToolbar = _ButtonToolbar3['default']; + + var _Carousel2 = __webpack_require__(83); + + var _Carousel3 = _interopRequireDefault(_Carousel2); + + exports.Carousel = _Carousel3['default']; + + var _CarouselItem2 = __webpack_require__(84); + + var _CarouselItem3 = _interopRequireDefault(_CarouselItem2); + + exports.CarouselItem = _CarouselItem3['default']; + + var _Col2 = __webpack_require__(86); + + var _Col3 = _interopRequireDefault(_Col2); + + exports.Col = _Col3['default']; + + var _CollapsibleMixin2 = __webpack_require__(87); + + var _CollapsibleMixin3 = _interopRequireDefault(_CollapsibleMixin2); + + exports.CollapsibleMixin = _CollapsibleMixin3['default']; + + var _CollapsibleNav2 = __webpack_require__(88); + + var _CollapsibleNav3 = _interopRequireDefault(_CollapsibleNav2); + + exports.CollapsibleNav = _CollapsibleNav3['default']; + + var _Dropdown2 = __webpack_require__(93); + + var _Dropdown3 = _interopRequireDefault(_Dropdown2); + + exports.Dropdown = _Dropdown3['default']; + + var _DropdownButton2 = __webpack_require__(171); + + var _DropdownButton3 = _interopRequireDefault(_DropdownButton2); + + exports.DropdownButton = _DropdownButton3['default']; + + var _NavDropdown2 = __webpack_require__(172); + + var _NavDropdown3 = _interopRequireDefault(_NavDropdown2); + + exports.NavDropdown = _NavDropdown3['default']; + + var _SplitButton3 = __webpack_require__(173); + + var _SplitButton4 = _interopRequireDefault(_SplitButton3); + + exports.SplitButton = _SplitButton4['default']; + + var _FadeMixin2 = __webpack_require__(175); + + var _FadeMixin3 = _interopRequireDefault(_FadeMixin2); + + exports.FadeMixin = _FadeMixin3['default']; + + var _Glyphicon2 = __webpack_require__(80); + + var _Glyphicon3 = _interopRequireDefault(_Glyphicon2); + + exports.Glyphicon = _Glyphicon3['default']; + + var _Grid2 = __webpack_require__(176); + + var _Grid3 = _interopRequireDefault(_Grid2); + + exports.Grid = _Grid3['default']; + + var _Input2 = __webpack_require__(177); + + var _Input3 = _interopRequireDefault(_Input2); + + exports.Input = _Input3['default']; + + var _Interpolate2 = __webpack_require__(180); + + var _Interpolate3 = _interopRequireDefault(_Interpolate2); + + exports.Interpolate = _Interpolate3['default']; + + var _Jumbotron2 = __webpack_require__(181); + + var _Jumbotron3 = _interopRequireDefault(_Jumbotron2); + + exports.Jumbotron = _Jumbotron3['default']; + + var _Label2 = __webpack_require__(182); + + var _Label3 = _interopRequireDefault(_Label2); + + exports.Label = _Label3['default']; + + var _ListGroup2 = __webpack_require__(183); + + var _ListGroup3 = _interopRequireDefault(_ListGroup2); + + exports.ListGroup = _ListGroup3['default']; + + var _ListGroupItem2 = __webpack_require__(184); + + var _ListGroupItem3 = _interopRequireDefault(_ListGroupItem2); + + exports.ListGroupItem = _ListGroupItem3['default']; + + var _MenuItem2 = __webpack_require__(185); + + var _MenuItem3 = _interopRequireDefault(_MenuItem2); + + exports.MenuItem = _MenuItem3['default']; + + var _Modal2 = __webpack_require__(186); + + var _Modal3 = _interopRequireDefault(_Modal2); + + exports.Modal = _Modal3['default']; + + var _ModalHeader2 = __webpack_require__(198); + + var _ModalHeader3 = _interopRequireDefault(_ModalHeader2); + + exports.ModalHeader = _ModalHeader3['default']; + + var _ModalTitle2 = __webpack_require__(199); + + var _ModalTitle3 = _interopRequireDefault(_ModalTitle2); + + exports.ModalTitle = _ModalTitle3['default']; + + var _ModalBody2 = __webpack_require__(197); + + var _ModalBody3 = _interopRequireDefault(_ModalBody2); + + exports.ModalBody = _ModalBody3['default']; + + var _ModalFooter2 = __webpack_require__(200); + + var _ModalFooter3 = _interopRequireDefault(_ModalFooter2); + + exports.ModalFooter = _ModalFooter3['default']; + + var _Nav2 = __webpack_require__(201); + + var _Nav3 = _interopRequireDefault(_Nav2); + + exports.Nav = _Nav3['default']; + + var _Navbar2 = __webpack_require__(202); + + var _Navbar3 = _interopRequireDefault(_Navbar2); + + exports.Navbar = _Navbar3['default']; + + var _NavItem2 = __webpack_require__(203); + + var _NavItem3 = _interopRequireDefault(_NavItem2); + + exports.NavItem = _NavItem3['default']; + + var _Overlay2 = __webpack_require__(204); + + var _Overlay3 = _interopRequireDefault(_Overlay2); + + exports.Overlay = _Overlay3['default']; + + var _OverlayTrigger2 = __webpack_require__(209); + + var _OverlayTrigger3 = _interopRequireDefault(_OverlayTrigger2); + + exports.OverlayTrigger = _OverlayTrigger3['default']; + + var _PageHeader2 = __webpack_require__(212); + + var _PageHeader3 = _interopRequireDefault(_PageHeader2); + + exports.PageHeader = _PageHeader3['default']; + + var _PageItem2 = __webpack_require__(213); + + var _PageItem3 = _interopRequireDefault(_PageItem2); + + exports.PageItem = _PageItem3['default']; + + var _Pager2 = __webpack_require__(214); + + var _Pager3 = _interopRequireDefault(_Pager2); + + exports.Pager = _Pager3['default']; + + var _Pagination2 = __webpack_require__(215); + + var _Pagination3 = _interopRequireDefault(_Pagination2); + + exports.Pagination = _Pagination3['default']; + + var _Panel2 = __webpack_require__(218); + + var _Panel3 = _interopRequireDefault(_Panel2); + + exports.Panel = _Panel3['default']; + + var _PanelGroup2 = __webpack_require__(66); + + var _PanelGroup3 = _interopRequireDefault(_PanelGroup2); + + exports.PanelGroup = _PanelGroup3['default']; + + var _Popover2 = __webpack_require__(219); + + var _Popover3 = _interopRequireDefault(_Popover2); + + exports.Popover = _Popover3['default']; + + var _ProgressBar2 = __webpack_require__(220); + + var _ProgressBar3 = _interopRequireDefault(_ProgressBar2); + + exports.ProgressBar = _ProgressBar3['default']; + + var _Row2 = __webpack_require__(221); + + var _Row3 = _interopRequireDefault(_Row2); + + exports.Row = _Row3['default']; + + var _SafeAnchor2 = __webpack_require__(100); + + var _SafeAnchor3 = _interopRequireDefault(_SafeAnchor2); + + exports.SafeAnchor = _SafeAnchor3['default']; + + var _SplitButton5 = _interopRequireDefault(_SplitButton3); + + exports.SplitButton = _SplitButton5['default']; + + var _styleMaps2 = __webpack_require__(70); + + var _styleMaps3 = _interopRequireDefault(_styleMaps2); + + exports.styleMaps = _styleMaps3['default']; + + var _SubNav2 = __webpack_require__(222); + + var _SubNav3 = _interopRequireDefault(_SubNav2); + + exports.SubNav = _SubNav3['default']; + + var _Tab2 = __webpack_require__(223); + + var _Tab3 = _interopRequireDefault(_Tab2); + + exports.Tab = _Tab3['default']; + + var _TabbedArea2 = __webpack_require__(224); + + var _TabbedArea3 = _interopRequireDefault(_TabbedArea2); + + exports.TabbedArea = _TabbedArea3['default']; + + var _Table2 = __webpack_require__(227); + + var _Table3 = _interopRequireDefault(_Table2); + + exports.Table = _Table3['default']; + + var _TabPane2 = __webpack_require__(226); + + var _TabPane3 = _interopRequireDefault(_TabPane2); + + exports.TabPane = _TabPane3['default']; + + var _Tabs2 = __webpack_require__(225); + + var _Tabs3 = _interopRequireDefault(_Tabs2); + + exports.Tabs = _Tabs3['default']; + + var _Thumbnail2 = __webpack_require__(228); + + var _Thumbnail3 = _interopRequireDefault(_Thumbnail2); + + exports.Thumbnail = _Thumbnail3['default']; + + var _Tooltip2 = __webpack_require__(229); + + var _Tooltip3 = _interopRequireDefault(_Tooltip2); + + exports.Tooltip = _Tooltip3['default']; + + var _Well2 = __webpack_require__(230); + + var _Well3 = _interopRequireDefault(_Well2); + + exports.Well = _Well3['default']; + + var _Portal2 = __webpack_require__(231); + + var _Portal3 = _interopRequireDefault(_Portal2); + + exports.Portal = _Portal3['default']; + + var _Position2 = __webpack_require__(232); + + var _Position3 = _interopRequireDefault(_Position2); + + exports.Position = _Position3['default']; + + var _Collapse2 = __webpack_require__(89); + + var _Collapse3 = _interopRequireDefault(_Collapse2); + + exports.Collapse = _Collapse3['default']; + + var _Fade2 = __webpack_require__(195); + + var _Fade3 = _interopRequireDefault(_Fade2); + + exports.Fade = _Fade3['default']; + + var _FormControls2 = __webpack_require__(178); + + var _FormControls = _interopRequireWildcard(_FormControls2); + + exports.FormControls = _FormControls; + var utils = { + childrenValueInputValidation: _utilsChildrenValueInputValidation2['default'], + createChainedFunction: _utilsCreateChainedFunction2['default'], + ValidComponentChildren: _utilsValidComponentChildren2['default'], + CustomPropTypes: _utilsCustomPropTypes2['default'], + domUtils: createDeprecationWrapper(_utilsDomUtils2['default'], 'utils/domUtils', 'npm install dom-helpers') + }; + + exports.utils = utils; + function createDeprecationWrapper(obj, deprecated, instead, link) { + var wrapper = {}; + + if (false) { + return obj; + } + + _Object$keys(obj).forEach(function (key) { + _Object$defineProperty(wrapper, key, { + get: function get() { + _utilsDeprecationWarning2['default'](deprecated, instead, link); + return obj[key]; + }, + set: function set(x) { + obj[key] = x; + } + }); + }); + + return wrapper; + } + +/***/ }, +/* 1 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(2), __esModule: true }; + +/***/ }, +/* 2 */ +/***/ function(module, exports, __webpack_require__) { + + __webpack_require__(3); + module.exports = __webpack_require__(9).Object.keys; + +/***/ }, +/* 3 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.2.14 Object.keys(O) + var toObject = __webpack_require__(4); + + __webpack_require__(6)('keys', function($keys){ + return function keys(it){ + return $keys(toObject(it)); + }; + }); + +/***/ }, +/* 4 */ +/***/ function(module, exports, __webpack_require__) { + + // 7.1.13 ToObject(argument) + var defined = __webpack_require__(5); + module.exports = function(it){ + return Object(defined(it)); + }; + +/***/ }, +/* 5 */ +/***/ 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; + }; + +/***/ }, +/* 6 */ +/***/ function(module, exports, __webpack_require__) { + + // most Object methods by ES6 should accept primitives + module.exports = function(KEY, exec){ + var $def = __webpack_require__(7) + , fn = (__webpack_require__(9).Object || {})[KEY] || Object[KEY] + , exp = {}; + exp[KEY] = exec(fn); + $def($def.S + $def.F * __webpack_require__(10)(function(){ fn(1); }), 'Object', exp); + }; + +/***/ }, +/* 7 */ +/***/ function(module, exports, __webpack_require__) { + + var global = __webpack_require__(8) + , core = __webpack_require__(9) + , PROTOTYPE = 'prototype'; + var ctx = function(fn, that){ + return function(){ + return fn.apply(that, arguments); + }; + }; + var $def = function(type, name, source){ + var key, own, out, exp + , isGlobal = type & $def.G + , isProto = type & $def.P + , target = isGlobal ? global : type & $def.S + ? global[name] : (global[name] || {})[PROTOTYPE] + , exports = isGlobal ? core : core[name] || (core[name] = {}); + if(isGlobal)source = name; + for(key in source){ + // contains in native + own = !(type & $def.F) && 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 + if(isGlobal && typeof target[key] != 'function')exp = source[key]; + // bind timers to global for call from export context + else if(type & $def.B && own)exp = ctx(out, global); + // wrap global constructors for prevent change them in library + else if(type & $def.W && target[key] == out)!function(C){ + exp = function(param){ + return this instanceof C ? new C(param) : C(param); + }; + exp[PROTOTYPE] = C[PROTOTYPE]; + }(out); + else exp = isProto && typeof out == 'function' ? ctx(Function.call, out) : out; + // export + exports[key] = exp; + if(isProto)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out; + } + }; + // type bitmap + $def.F = 1; // forced + $def.G = 2; // global + $def.S = 4; // static + $def.P = 8; // proto + $def.B = 16; // bind + $def.W = 32; // wrap + module.exports = $def; + +/***/ }, +/* 8 */ +/***/ function(module, exports) { + + var global = typeof self != 'undefined' && self.Math == Math ? self : Function('return this')(); + module.exports = global; + if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef + +/***/ }, +/* 9 */ +/***/ function(module, exports) { + + var core = module.exports = {}; + if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef + +/***/ }, +/* 10 */ +/***/ function(module, exports) { + + module.exports = function(exec){ + try { + return !!exec(); + } catch(e){ + return true; + } + }; + +/***/ }, +/* 11 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(12), __esModule: true }; + +/***/ }, +/* 12 */ +/***/ function(module, exports, __webpack_require__) { + + var $ = __webpack_require__(13); + module.exports = function defineProperty(it, key, desc){ + return $.setDesc(it, key, desc); + }; + +/***/ }, +/* 13 */ +/***/ 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 + }; + +/***/ }, +/* 14 */ +/***/ function(module, exports) { + + "use strict"; + + exports["default"] = function (obj) { + return obj && obj.__esModule ? obj : { + "default": obj + }; + }; + + exports.__esModule = true; + +/***/ }, +/* 15 */ +/***/ 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; + +/***/ }, +/* 16 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _reactLibWarning = __webpack_require__(29); + + var _reactLibWarning2 = _interopRequireDefault(_reactLibWarning); + + 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; + } + + _reactLibWarning2['default'](false, message); + 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']; + +/***/ }, +/* 17 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + + var _Object$create = __webpack_require__(18)["default"]; + + var _Object$setPrototypeOf = __webpack_require__(20)["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; + +/***/ }, +/* 18 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(19), __esModule: true }; + +/***/ }, +/* 19 */ +/***/ function(module, exports, __webpack_require__) { + + var $ = __webpack_require__(13); + module.exports = function create(P, D){ + return $.create(P, D); + }; + +/***/ }, +/* 20 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(21), __esModule: true }; + +/***/ }, +/* 21 */ +/***/ function(module, exports, __webpack_require__) { + + __webpack_require__(22); + module.exports = __webpack_require__(9).Object.setPrototypeOf; + +/***/ }, +/* 22 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.3.19 Object.setPrototypeOf(O, proto) + var $def = __webpack_require__(7); + $def($def.S, 'Object', {setPrototypeOf: __webpack_require__(23).set}); + +/***/ }, +/* 23 */ +/***/ 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__(13).getDesc + , isObject = __webpack_require__(24) + , anObject = __webpack_require__(25); + 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(buggy, set){ + try { + set = __webpack_require__(26)(Function.call, getDesc(Object.prototype, '__proto__').set, 2); + set({}, []); + } catch(e){ buggy = true; } + return function setPrototypeOf(O, proto){ + check(O, proto); + if(buggy)O.__proto__ = proto; + else set(O, proto); + return O; + }; + }() + : undefined), + check: check + }; + +/***/ }, +/* 24 */ +/***/ function(module, exports) { + + // http://jsperf.com/core-js-isobject + module.exports = function(it){ + return it !== null && (typeof it == 'object' || typeof it == 'function'); + }; + +/***/ }, +/* 25 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(24); + module.exports = function(it){ + if(!isObject(it))throw TypeError(it + ' is not an object!'); + return it; + }; + +/***/ }, +/* 26 */ +/***/ function(module, exports, __webpack_require__) { + + // optional / simple context binding + var aFunction = __webpack_require__(27); + 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); + }; + }; + +/***/ }, +/* 27 */ +/***/ function(module, exports) { + + module.exports = function(it){ + if(typeof it != 'function')throw TypeError(it + ' is not a function!'); + return it; + }; + +/***/ }, +/* 28 */ +/***/ 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; + +/***/ }, +/* 29 */ +/***/ 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. + * + * @providesModule warning + */ + + "use strict"; + + var emptyFunction = __webpack_require__(30); + + /** + * 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 = emptyFunction; + + if (true) { + warning = function(condition, format ) {for (var args=[],$__0=2,$__1=arguments.length;$__0<$__1;$__0++) args.push(arguments[$__0]); + 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 (format.indexOf('Failed Composite propType: ') === 0) { + return; // Ignore CompositeComponent proptype check. + } + + if (!condition) { + var argIndex = 0; + var message = 'Warning: ' + format.replace(/%s/g, function() {return args[argIndex++];}); + console.warn(message); + try { + // --- Welcome to debugging React --- + // 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; + + +/***/ }, +/* 30 */ +/***/ function(module, exports) { + + /** + * 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 emptyFunction + */ + + function makeEmptyFunction(arg) { + return function() { + return arg; + }; + } + + /** + * This function accepts and discards inputs; it has no side effects. This is + * primarily useful idiomatically for overridable function endpoints which + * always need to be callable, since JS lacks a null-call idiom ala Cocoa. + */ + function emptyFunction() {} + + emptyFunction.thatReturns = makeEmptyFunction; + emptyFunction.thatReturnsFalse = makeEmptyFunction(false); + emptyFunction.thatReturnsTrue = makeEmptyFunction(true); + emptyFunction.thatReturnsNull = makeEmptyFunction(null); + emptyFunction.thatReturnsThis = function() { return this; }; + emptyFunction.thatReturnsArgument = function(arg) { return arg; }; + + module.exports = emptyFunction; + + +/***/ }, +/* 31 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _domHelpersUtilInDOM = __webpack_require__(33); + + var _domHelpersUtilInDOM2 = _interopRequireDefault(_domHelpersUtilInDOM); + + var _domHelpersOwnerDocument = __webpack_require__(34); + + var _domHelpersOwnerDocument2 = _interopRequireDefault(_domHelpersOwnerDocument); + + var _domHelpersOwnerWindow = __webpack_require__(35); + + var _domHelpersOwnerWindow2 = _interopRequireDefault(_domHelpersOwnerWindow); + + var _domHelpersQueryContains = __webpack_require__(37); + + var _domHelpersQueryContains2 = _interopRequireDefault(_domHelpersQueryContains); + + var _domHelpersActiveElement = __webpack_require__(38); + + var _domHelpersActiveElement2 = _interopRequireDefault(_domHelpersActiveElement); + + var _domHelpersQueryOffset = __webpack_require__(39); + + var _domHelpersQueryOffset2 = _interopRequireDefault(_domHelpersQueryOffset); + + var _domHelpersQueryOffsetParent = __webpack_require__(41); + + var _domHelpersQueryOffsetParent2 = _interopRequireDefault(_domHelpersQueryOffsetParent); + + var _domHelpersQueryPosition = __webpack_require__(49); + + var _domHelpersQueryPosition2 = _interopRequireDefault(_domHelpersQueryPosition); + + var _domHelpersStyle = __webpack_require__(42); + + var _domHelpersStyle2 = _interopRequireDefault(_domHelpersStyle); + + function ownerDocument(componentOrElement) { + var elem = _react2['default'].findDOMNode(componentOrElement); + return _domHelpersOwnerDocument2['default'](elem && elem.ownerDocument || document); + } + + function ownerWindow(componentOrElement) { + var doc = ownerDocument(componentOrElement); + return _domHelpersOwnerWindow2['default'](doc); + } + + //TODO remove in 0.26 + function getComputedStyles(elem) { + return ownerDocument(elem).defaultView.getComputedStyle(elem, null); + } + + /** + * Get the height of the document + * + * @returns {documentHeight: number} + */ + function getDocumentHeight() { + return Math.max(document.documentElement.offsetHeight, document.height, document.body.scrollHeight, document.body.offsetHeight); + } + + /** + * Get an element's size + * + * @param {HTMLElement} elem + * @returns {{width: number, height: number}} + */ + function getSize(elem) { + var rect = { + width: elem.offsetWidth || 0, + height: elem.offsetHeight || 0 + }; + if (typeof elem.getBoundingClientRect !== 'undefined') { + var _elem$getBoundingClientRect = elem.getBoundingClientRect(); + + var width = _elem$getBoundingClientRect.width; + var height = _elem$getBoundingClientRect.height; + + rect.width = width || rect.width; + rect.height = height || rect.height; + } + return rect; + } + + exports['default'] = { + canUseDom: _domHelpersUtilInDOM2['default'], + css: _domHelpersStyle2['default'], + getComputedStyles: getComputedStyles, + contains: _domHelpersQueryContains2['default'], + ownerWindow: ownerWindow, + ownerDocument: ownerDocument, + getOffset: _domHelpersQueryOffset2['default'], + getDocumentHeight: getDocumentHeight, + getPosition: _domHelpersQueryPosition2['default'], + getSize: getSize, + activeElement: _domHelpersActiveElement2['default'], + offsetParent: _domHelpersQueryOffsetParent2['default'] + }; + module.exports = exports['default']; + +/***/ }, +/* 32 */ +/***/ function(module, exports) { + + module.exports = __WEBPACK_EXTERNAL_MODULE_32__; + +/***/ }, +/* 33 */ +/***/ function(module, exports) { + + 'use strict'; + module.exports = !!(typeof window !== 'undefined' && window.document && window.document.createElement); + +/***/ }, +/* 34 */ +/***/ function(module, exports) { + + "use strict"; + + exports.__esModule = true; + exports["default"] = ownerDocument; + + function ownerDocument(node) { + return node && node.ownerDocument || document; + } + + module.exports = exports["default"]; + +/***/ }, +/* 35 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var babelHelpers = __webpack_require__(36); + + exports.__esModule = true; + exports['default'] = ownerWindow; + + var _ownerDocument = __webpack_require__(34); + + var _ownerDocument2 = babelHelpers.interopRequireDefault(_ownerDocument); + + function ownerWindow(node) { + var doc = (0, _ownerDocument2['default'])(node); + return doc && doc.defaultView || doc.parentWindow; + } + + module.exports = exports['default']; + +/***/ }, +/* 36 */ +/***/ 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; + }; + }) + +/***/ }, +/* 37 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var canUseDOM = __webpack_require__(33); + + 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; + +/***/ }, +/* 38 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var babelHelpers = __webpack_require__(36); + + exports.__esModule = true; + + /** + * document.activeElement + */ + exports['default'] = activeElement; + + var _ownerDocument = __webpack_require__(34); + + 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']; + +/***/ }, +/* 39 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var contains = __webpack_require__(37), + getWindow = __webpack_require__(40), + ownerDocument = __webpack_require__(34); + + module.exports = function offset(node) { + var doc = ownerDocument(node), + win = getWindow(doc), + docElem = doc && doc.documentElement, + box = { top: 0, left: 0, height: 0, width: 0 }; + + if (!doc) return; + + // Make sure it's not a disconnected DOM node + if (!contains(docElem, node)) return box; + + if (node.getBoundingClientRect !== undefined) box = node.getBoundingClientRect(); + + if (box.width || box.height) { + + box = { + top: box.top + (win.pageYOffset || docElem.scrollTop) - (docElem.clientTop || 0), + left: box.left + (win.pageXOffset || docElem.scrollLeft) - (docElem.clientLeft || 0), + width: (box.width == null ? node.offsetWidth : box.width) || 0, + height: (box.height == null ? node.offsetHeight : box.height) || 0 + }; + } + + return box; + }; + +/***/ }, +/* 40 */ +/***/ function(module, exports) { + + 'use strict'; + + module.exports = function getWindow(node) { + return node === node.window ? node : node.nodeType === 9 ? node.defaultView || node.parentWindow : false; + }; + +/***/ }, +/* 41 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var babelHelpers = __webpack_require__(36); + + exports.__esModule = true; + exports['default'] = offsetParent; + + var _ownerDocument = __webpack_require__(34); + + var _ownerDocument2 = babelHelpers.interopRequireDefault(_ownerDocument); + + var _style = __webpack_require__(42); + + var _style2 = babelHelpers.interopRequireDefault(_style); + + function nodeName(node) { + return node.nodeName && node.nodeName.toLowerCase(); + } + + function offsetParent(node) { + var doc = (0, _ownerDocument2['default'])(node), + offsetParent = node && node.offsetParent; + + while (offsetParent && nodeName(node) !== 'html' && (0, _style2['default'])(offsetParent, 'position') === 'static') { + offsetParent = offsetParent.offsetParent; + } + + return offsetParent || doc.documentElement; + } + + module.exports = exports['default']; + +/***/ }, +/* 42 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var camelize = __webpack_require__(43), + hyphenate = __webpack_require__(45), + _getComputedStyle = __webpack_require__(47), + removeStyle = __webpack_require__(48); + + 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; + }; + +/***/ }, +/* 43 */ +/***/ 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__(44); + var msPattern = /^-ms-/; + + module.exports = function camelizeStyleName(string) { + return camelize(string.replace(msPattern, 'ms-')); + }; + +/***/ }, +/* 44 */ +/***/ function(module, exports) { + + "use strict"; + + var rHyphen = /-(.)/g; + + module.exports = function camelize(string) { + return string.replace(rHyphen, function (_, chr) { + return chr.toUpperCase(); + }); + }; + +/***/ }, +/* 45 */ +/***/ 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__(46); + var msPattern = /^ms-/; + + module.exports = function hyphenateStyleName(string) { + return hyphenate(string).replace(msPattern, "-ms-"); + }; + +/***/ }, +/* 46 */ +/***/ function(module, exports) { + + 'use strict'; + + var rUpper = /([A-Z])/g; + + module.exports = function hyphenate(string) { + return string.replace(rUpper, '-$1').toLowerCase(); + }; + +/***/ }, +/* 47 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var babelHelpers = __webpack_require__(36); + + var _utilCamelizeStyle = __webpack_require__(43); + + 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; + } + }; + }; + +/***/ }, +/* 48 */ +/***/ function(module, exports) { + + 'use strict'; + + module.exports = function removeStyle(node, key) { + return 'removeProperty' in node.style ? node.style.removeProperty(key) : node.style.removeAttribute(key); + }; + +/***/ }, +/* 49 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var babelHelpers = __webpack_require__(36); + + exports.__esModule = true; + exports['default'] = position; + + var _offset = __webpack_require__(39); + + var _offset2 = babelHelpers.interopRequireDefault(_offset); + + var _offsetParent = __webpack_require__(41); + + var _offsetParent2 = babelHelpers.interopRequireDefault(_offsetParent); + + var _scrollTop = __webpack_require__(50); + + var _scrollTop2 = babelHelpers.interopRequireDefault(_scrollTop); + + var _scrollLeft = __webpack_require__(51); + + var _scrollLeft2 = babelHelpers.interopRequireDefault(_scrollLeft); + + var _style = __webpack_require__(42); + + var _style2 = babelHelpers.interopRequireDefault(_style); + + function nodeName(node) { + return node.nodeName && node.nodeName.toLowerCase(); + } + + function position(node, offsetParent) { + var parentOffset = { top: 0, left: 0 }, + offset; + + // Fixed elements are offset from window (parentOffset = {top:0, left: 0}, + // because it is its only offset parent + if ((0, _style2['default'])(node, 'position') === 'fixed') { + offset = node.getBoundingClientRect(); + } else { + offsetParent = offsetParent || (0, _offsetParent2['default'])(node); + offset = (0, _offset2['default'])(node); + + if (nodeName(offsetParent) !== 'html') parentOffset = (0, _offset2['default'])(offsetParent); + + parentOffset.top += parseInt((0, _style2['default'])(offsetParent, 'borderTopWidth'), 10) - (0, _scrollTop2['default'])(offsetParent) || 0; + parentOffset.left += parseInt((0, _style2['default'])(offsetParent, 'borderLeftWidth'), 10) - (0, _scrollLeft2['default'])(offsetParent) || 0; + } + + // Subtract parent offsets and node margins + return babelHelpers._extends({}, offset, { + top: offset.top - parentOffset.top - (parseInt((0, _style2['default'])(node, 'marginTop'), 10) || 0), + left: offset.left - parentOffset.left - (parseInt((0, _style2['default'])(node, 'marginLeft'), 10) || 0) + }); + } + + module.exports = exports['default']; + +/***/ }, +/* 50 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var getWindow = __webpack_require__(40); + + module.exports = function scrollTop(node, val) { + var win = getWindow(node); + + if (val === undefined) return win ? 'pageYOffset' in win ? win.pageYOffset : win.document.documentElement.scrollTop : node.scrollTop; + + if (win) win.scrollTo('pageXOffset' in win ? win.pageXOffset : win.document.documentElement.scrollLeft, val);else node.scrollTop = val; + }; + +/***/ }, +/* 51 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var getWindow = __webpack_require__(40); + + module.exports = function scrollTop(node, val) { + var win = getWindow(node); + + if (val === undefined) return win ? 'pageXOffset' in win ? win.pageXOffset : win.document.documentElement.scrollLeft : node.scrollLeft; + + if (win) win.scrollTo(val, 'pageYOffset' in win ? win.pageYOffset : win.document.documentElement.scrollTop);else node.scrollLeft = val; + }; + +/***/ }, +/* 52 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + exports['default'] = valueValidation; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _CustomPropTypes = __webpack_require__(53); + + var propList = ['children', 'value']; + var typeList = [_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]; + + function valueValidation(props, propName, componentName) { + var error = _CustomPropTypes.singlePropFrom(propList)(props, propName, componentName); + if (!error) { + var oneOfType = _react2['default'].PropTypes.oneOfType(typeList); + error = oneOfType(props, propName, componentName); + } + return error; + } + + module.exports = exports['default']; + +/***/ }, +/* 53 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _Object$keys = __webpack_require__(1)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _reactLibWarning = __webpack_require__(29); + + var _reactLibWarning2 = _interopRequireDefault(_reactLibWarning); + + var _childrenToArray = __webpack_require__(54); + + var _childrenToArray2 = _interopRequireDefault(_childrenToArray); + + var ANONYMOUS = '<>'; + + /** + * Create chain-able isRequired validator + * + * Largely copied directly from: + * https://github.com/facebook/react/blob/0.11-stable/src/core/ReactPropTypes.js#L94 + */ + function createChainableTypeChecker(validate) { + function checkType(isRequired, props, propName, componentName) { + componentName = componentName || ANONYMOUS; + if (props[propName] == null) { + if (isRequired) { + return new Error('Required prop \'' + propName + '\' was not specified in \'' + componentName + '\'.'); + } + } else { + return validate(props, propName, componentName); + } + } + + var chainedCheckType = checkType.bind(null, false); + chainedCheckType.isRequired = checkType.bind(null, true); + + return chainedCheckType; + } + + var CustomPropTypes = { + + deprecated: function deprecated(propType, explanation) { + return function (props, propName, componentName) { + if (props[propName] != null) { + _reactLibWarning2['default'](false, '"' + propName + '" property of "' + componentName + '" has been deprecated.\n' + explanation); + } + + return propType(props, propName, componentName); + }; + }, + + isRequiredForA11y: function isRequiredForA11y(propType) { + return function (props, propName, componentName) { + if (props[propName] == null) { + return new Error('The prop `' + propName + '` is required to make ' + componentName + ' accessible ' + 'for users using assistive technologies such as screen readers `'); + } + + return propType(props, propName, componentName); + }; + }, + + requiredRoles: function requiredRoles() { + for (var _len = arguments.length, roles = Array(_len), _key = 0; _key < _len; _key++) { + roles[_key] = arguments[_key]; + } + + return 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 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(', '))); + } + }); + }, + + /** + * Checks whether a prop provides a DOM element + * + * The element can be provided in two forms: + * - Directly passed + * - Or passed an object that has a `render` method + * + * @param props + * @param propName + * @param componentName + * @returns {Error|undefined} + */ + mountable: createMountableChecker(), + + /** + * Checks whether a prop provides a type of element. + * + * The type of element can be provided in two forms: + * - tag name (string) + * - a return value of React.createClass(...) + * + * @param props + * @param propName + * @param componentName + * @returns {Error|undefined} + */ + elementType: createElementTypeChecker(), + + /** + * Checks whether a prop matches a key of an associated object + * + * @param props + * @param propName + * @param componentName + * @returns {Error|undefined} + */ + keyOf: createKeyOfChecker, + /** + * Checks if only one of the listed properties is in use. An error is given + * if multiple have a value + * + * @param props + * @param propName + * @param componentName + * @returns {Error|undefined} + */ + singlePropFrom: createSinglePropFromChecker, + + all: all + }; + + function errMsg(props, propName, componentName, msgContinuation) { + return 'Invalid prop \'' + propName + '\' of value \'' + props[propName] + '\'' + (' supplied to \'' + componentName + '\'' + msgContinuation); + } + + function createMountableChecker() { + function validate(props, propName, componentName) { + if (typeof props[propName] !== 'object' || typeof props[propName].render !== 'function' && props[propName].nodeType !== 1) { + return new Error(errMsg(props, propName, componentName, ', expected a DOM element or an object that has a `render` method')); + } + } + + return createChainableTypeChecker(validate); + } + + function createKeyOfChecker(obj) { + function validate(props, propName, componentName) { + var propValue = props[propName]; + if (!obj.hasOwnProperty(propValue)) { + var valuesString = JSON.stringify(_Object$keys(obj)); + return new Error(errMsg(props, propName, componentName, ', expected one of ' + valuesString + '.')); + } + } + return createChainableTypeChecker(validate); + } + + function createSinglePropFromChecker(arrOfProps) { + function validate(props, propName, componentName) { + var usedPropCount = arrOfProps.map(function (listedProp) { + return props[listedProp]; + }).reduce(function (acc, curr) { + return acc + (curr !== undefined ? 1 : 0); + }, 0); + + if (usedPropCount > 1) { + var first = arrOfProps[0]; + var others = arrOfProps.slice(1); + + var message = others.join(', ') + ' and ' + first; + return new Error('Invalid prop \'' + propName + '\', only one of the following ' + ('may be provided: ' + message)); + } + } + return validate; + } + + function all(propTypes) { + if (propTypes === undefined) { + throw new Error('No validations provided'); + } + + if (!(propTypes instanceof Array)) { + throw new Error('Invalid argument must be an array'); + } + + if (propTypes.length === 0) { + throw new Error('No validations provided'); + } + + return function (props, propName, componentName) { + for (var i = 0; i < propTypes.length; i++) { + var result = propTypes[i](props, propName, componentName); + + if (result !== undefined && result !== null) { + return result; + } + } + }; + } + + function createElementTypeChecker() { + function validate(props, propName, componentName) { + var errBeginning = errMsg(props, propName, componentName, '. Expected an Element `type`'); + + if (typeof props[propName] !== 'function') { + if (_react2['default'].isValidElement(props[propName])) { + return new Error(errBeginning + ', not an actual Element'); + } + + if (typeof props[propName] !== 'string') { + return new Error(errBeginning + ' such as a tag name or return value of React.createClass(...)'); + } + } + } + + return createChainableTypeChecker(validate); + } + + exports['default'] = CustomPropTypes; + module.exports = exports['default']; + +/***/ }, +/* 54 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + exports['default'] = childrenAsArray; + + var _ValidComponentChildren = __webpack_require__(55); + + 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']; + +/***/ }, +/* 55 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + /** + * Maps children that are typically specified as `props.children`, + * but only iterates over children that are "valid components". + * + * The mapFunction provided index will be normalised to the components mapped, + * so an invalid component would not increase the index. + * + * @param {?*} children Children tree container. + * @param {function(*, int)} mapFunction. + * @param {*} mapContext Context for mapFunction. + * @return {object} Object containing the ordered map of results. + */ + function mapValidComponents(children, func, context) { + var index = 0; + + return _react2['default'].Children.map(children, function (child) { + if (_react2['default'].isValidElement(child)) { + var lastIndex = index; + index++; + return func.call(context, child, lastIndex); + } + + return child; + }); + } + + /** + * Iterates through children that are typically specified as `props.children`, + * but only iterates over children that are "valid components". + * + * The provided forEachFunc(child, index) will be called for each + * leaf child with the index reflecting the position relative to "valid components". + * + * @param {?*} children Children tree container. + * @param {function(*, int)} forEachFunc. + * @param {*} forEachContext Context for forEachContext. + */ + function forEachValidComponents(children, func, context) { + var index = 0; + + return _react2['default'].Children.forEach(children, function (child) { + if (_react2['default'].isValidElement(child)) { + func.call(context, child, index); + index++; + } + }); + } + + /** + * Count the number of "valid components" in the Children container. + * + * @param {?*} children Children tree container. + * @returns {number} + */ + function numberOfValidComponents(children) { + var count = 0; + + _react2['default'].Children.forEach(children, function (child) { + if (_react2['default'].isValidElement(child)) { + count++; + } + }); + + return count; + } + + /** + * Determine if the Child container has one or more "valid components". + * + * @param {?*} children Children tree container. + * @returns {boolean} + */ + function hasValidComponent(children) { + var hasValid = false; + + _react2['default'].Children.forEach(children, function (child) { + if (!hasValid && _react2['default'].isValidElement(child)) { + hasValid = true; + } + }); + + return hasValid; + } + + exports['default'] = { + map: mapValidComponents, + forEach: forEachValidComponents, + numberOf: numberOfValidComponents, + hasValidComponent: hasValidComponent + }; + module.exports = exports['default']; + +/***/ }, +/* 56 */ +/***/ 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']; + +/***/ }, +/* 57 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _PanelGroup = __webpack_require__(66); + + 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']; + +/***/ }, +/* 58 */ +/***/ function(module, exports, __webpack_require__) { + + "use strict"; + + var _Object$assign = __webpack_require__(59)["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; + +/***/ }, +/* 59 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(60), __esModule: true }; + +/***/ }, +/* 60 */ +/***/ function(module, exports, __webpack_require__) { + + __webpack_require__(61); + module.exports = __webpack_require__(9).Object.assign; + +/***/ }, +/* 61 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.3.1 Object.assign(target, source) + var $def = __webpack_require__(7); + $def($def.S, 'Object', {assign: __webpack_require__(62)}); + +/***/ }, +/* 62 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.2.1 Object.assign(target, source, ...) + var toObject = __webpack_require__(4) + , IObject = __webpack_require__(63) + , enumKeys = __webpack_require__(65); + /* eslint-disable no-unused-vars */ + module.exports = Object.assign || function assign(target, source){ + /* eslint-enable no-unused-vars */ + var T = toObject(target) + , l = arguments.length + , i = 1; + while(l > i){ + var S = IObject(arguments[i++]) + , keys = enumKeys(S) + , length = keys.length + , j = 0 + , key; + while(length > j)T[key = keys[j++]] = S[key]; + } + return T; + }; + +/***/ }, +/* 63 */ +/***/ function(module, exports, __webpack_require__) { + + // indexed object, fallback for non-array-like ES3 strings + var cof = __webpack_require__(64); + module.exports = 0 in Object('z') ? Object : function(it){ + return cof(it) == 'String' ? it.split('') : Object(it); + }; + +/***/ }, +/* 64 */ +/***/ function(module, exports) { + + var toString = {}.toString; + + module.exports = function(it){ + return toString.call(it).slice(8, -1); + }; + +/***/ }, +/* 65 */ +/***/ function(module, exports, __webpack_require__) { + + // all enumerable object keys, includes symbols + var $ = __webpack_require__(13); + module.exports = function(it){ + var keys = $.getKeys(it) + , getSymbols = $.getSymbols; + if(getSymbols){ + var symbols = getSymbols(it) + , isEnum = $.isEnum + , i = 0 + , key; + while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key); + } + return keys; + }; + +/***/ }, +/* 66 */ +/***/ function(module, exports, __webpack_require__) { + + /* eslint react/prop-types: [2, {ignore: "bsStyle"}] */ + /* BootstrapMixin contains `bsStyle` type validation */ + + 'use strict'; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var PanelGroup = _react2['default'].createClass({ + displayName: 'PanelGroup', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + accordion: _react2['default'].PropTypes.bool, + activeKey: _react2['default'].PropTypes.any, + className: _react2['default'].PropTypes.string, + children: _react2['default'].PropTypes.node, + defaultActiveKey: _react2['default'].PropTypes.any, + onSelect: _react2['default'].PropTypes.func + }, + + getDefaultProps: function getDefaultProps() { + return { + accordion: false, + bsClass: 'panel-group' + }; + }, + + getInitialState: function getInitialState() { + var defaultActiveKey = this.props.defaultActiveKey; + + return { + activeKey: defaultActiveKey + }; + }, + + render: function render() { + var classes = this.getBsClassSet(); + 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'] = PanelGroup; + module.exports = exports['default']; + +/***/ }, +/* 67 */ +/***/ 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; + +/***/ }, +/* 68 */ +/***/ function(module, exports, __webpack_require__) { + + var __WEBPACK_AMD_DEFINE_RESULT__;/*! + Copyright (c) 2015 Jed Watson. + Licensed under the MIT License (MIT), see + http://jedwatson.github.io/classnames + */ + + (function () { + 'use strict'; + + function classNames () { + + var classes = ''; + + for (var i = 0; i < arguments.length; i++) { + var arg = arguments[i]; + if (!arg) continue; + + var argType = typeof arg; + + if ('string' === argType || 'number' === argType) { + classes += ' ' + arg; + + } else if (Array.isArray(arg)) { + classes += ' ' + classNames.apply(null, arg); + + } else if ('object' === argType) { + for (var key in arg) { + if (arg.hasOwnProperty(key) && arg[key]) { + classes += ' ' + key; + } + } + } + } + + return classes.substr(1); + } + + if (typeof module !== 'undefined' && module.exports) { + module.exports = classNames; + } else if (true){ + // AMD. Register as an anonymous module. + !(__WEBPACK_AMD_DEFINE_RESULT__ = function () { + return classNames; + }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); + } else { + window.classNames = classNames; + } + + }()); + + +/***/ }, +/* 69 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _styleMaps = __webpack_require__(70); + + var _styleMaps2 = _interopRequireDefault(_styleMaps); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var BootstrapMixin = { + propTypes: { + /** + * bootstrap className + * @private + */ + bsClass: _utilsCustomPropTypes2['default'].keyOf(_styleMaps2['default'].CLASSES), + /** + * Style variants + * @type {("default"|"primary"|"success"|"info"|"warning"|"danger"|"link")} + */ + bsStyle: _react2['default'].PropTypes.oneOf(_styleMaps2['default'].STYLES), + /** + * Size variants + * @type {("xsmall"|"small"|"medium"|"large"|"xs"|"sm"|"md"|"lg")} + */ + bsSize: _utilsCustomPropTypes2['default'].keyOf(_styleMaps2['default'].SIZES) + }, + + getBsClassSet: function getBsClassSet() { + var classes = {}; + + var bsClass = this.props.bsClass && _styleMaps2['default'].CLASSES[this.props.bsClass]; + if (bsClass) { + classes[bsClass] = true; + + var prefix = bsClass + '-'; + + var bsSize = this.props.bsSize && _styleMaps2['default'].SIZES[this.props.bsSize]; + if (bsSize) { + classes[prefix + bsSize] = true; + } + + if (this.props.bsStyle) { + if (_styleMaps2['default'].STYLES.indexOf(this.props.bsStyle) >= 0) { + classes[prefix + this.props.bsStyle] = true; + } else { + classes[this.props.bsStyle] = true; + } + } + } + + return classes; + }, + + prefixClass: function prefixClass(subClass) { + return _styleMaps2['default'].CLASSES[this.props.bsClass] + '-' + subClass; + } + }; + + exports['default'] = BootstrapMixin; + module.exports = exports['default']; + +/***/ }, +/* 70 */ +/***/ function(module, exports) { + + 'use strict'; + + exports.__esModule = true; + var styleMaps = { + CLASSES: { + 'alert': 'alert', + 'button': 'btn', + 'button-group': 'btn-group', + 'button-toolbar': 'btn-toolbar', + 'column': 'col', + 'input-group': 'input-group', + 'form': 'form', + 'glyphicon': 'glyphicon', + 'label': 'label', + 'thumbnail': 'thumbnail', + 'list-group-item': 'list-group-item', + 'panel': 'panel', + 'panel-group': 'panel-group', + 'pagination': 'pagination', + 'progress-bar': 'progress-bar', + 'nav': 'nav', + 'navbar': 'navbar', + 'modal': 'modal', + 'row': 'row', + 'well': 'well' + }, + STYLES: ['default', 'primary', 'success', 'info', 'warning', 'danger', 'link', 'inline', 'tabs', 'pills'], + addStyle: function addStyle(name) { + styleMaps.STYLES.push(name); + }, + SIZES: { + 'large': 'lg', + 'medium': 'md', + 'small': 'sm', + 'xsmall': 'xs', + 'lg': 'lg', + 'md': 'md', + 'sm': 'sm', + 'xs': 'xs' + }, + GRID_COLUMNS: 12 + }; + + exports['default'] = styleMaps; + module.exports = exports['default']; + +/***/ }, +/* 71 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _AffixMixin = __webpack_require__(72); + + var _AffixMixin2 = _interopRequireDefault(_AffixMixin); + + var Affix = _react2['default'].createClass({ + displayName: 'Affix', + + mixins: [_AffixMixin2['default']], + + render: function render() { + var holderStyle = _extends({ + top: this.state.affixPositionTop + }, this.props.style); + + // eslint-disable-line react/prop-types + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, this.state.affixClass), + style: holderStyle }), + this.props.children + ); + } + }); + + exports['default'] = Affix; + module.exports = exports['default']; + // we don't want to expose the `style` property + +/***/ }, +/* 72 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsDomUtils = __webpack_require__(31); + + var _utilsDomUtils2 = _interopRequireDefault(_utilsDomUtils); + + var _utilsEventListener = __webpack_require__(73); + + var _utilsEventListener2 = _interopRequireDefault(_utilsEventListener); + + var AffixMixin = { + propTypes: { + offset: _react2['default'].PropTypes.number, + offsetTop: _react2['default'].PropTypes.number, + offsetBottom: _react2['default'].PropTypes.number + }, + + getInitialState: function getInitialState() { + return { + affixClass: 'affix-top' + }; + }, + + getPinnedOffset: function getPinnedOffset(DOMNode) { + if (this.pinnedOffset) { + return this.pinnedOffset; + } + + DOMNode.className = DOMNode.className.replace(/affix-top|affix-bottom|affix/, ''); + DOMNode.className += DOMNode.className.length ? ' affix' : 'affix'; + + this.pinnedOffset = _utilsDomUtils2['default'].getOffset(DOMNode).top - window.pageYOffset; + + return this.pinnedOffset; + }, + + checkPosition: function checkPosition() { + var DOMNode = undefined, + scrollHeight = undefined, + scrollTop = undefined, + position = undefined, + offsetTop = undefined, + offsetBottom = undefined, + affix = undefined, + affixType = undefined, + affixPositionTop = undefined; + + // TODO: or not visible + if (!this.isMounted()) { + return; + } + + DOMNode = _react2['default'].findDOMNode(this); + scrollHeight = _utilsDomUtils2['default'].getDocumentHeight(); + scrollTop = window.pageYOffset; + position = _utilsDomUtils2['default'].getOffset(DOMNode); + + if (this.affixed === 'top') { + position.top += scrollTop; + } + + offsetTop = this.props.offsetTop != null ? this.props.offsetTop : this.props.offset; + offsetBottom = this.props.offsetBottom != null ? this.props.offsetBottom : this.props.offset; + + if (offsetTop == null && offsetBottom == null) { + return; + } + if (offsetTop == null) { + offsetTop = 0; + } + if (offsetBottom == null) { + offsetBottom = 0; + } + + if (this.unpin != null && scrollTop + this.unpin <= position.top) { + affix = false; + } else if (offsetBottom != null && position.top + DOMNode.offsetHeight >= scrollHeight - offsetBottom) { + affix = 'bottom'; + } else if (offsetTop != null && scrollTop <= offsetTop) { + affix = 'top'; + } else { + affix = false; + } + + if (this.affixed === affix) { + return; + } + + if (this.unpin != null) { + DOMNode.style.top = ''; + } + + affixType = 'affix' + (affix ? '-' + affix : ''); + + this.affixed = affix; + this.unpin = affix === 'bottom' ? this.getPinnedOffset(DOMNode) : null; + + if (affix === 'bottom') { + DOMNode.className = DOMNode.className.replace(/affix-top|affix-bottom|affix/, 'affix-bottom'); + affixPositionTop = scrollHeight - offsetBottom - DOMNode.offsetHeight - _utilsDomUtils2['default'].getOffset(DOMNode).top; + } + + this.setState({ + affixClass: affixType, + affixPositionTop: affixPositionTop + }); + }, + + checkPositionWithEventLoop: function checkPositionWithEventLoop() { + setTimeout(this.checkPosition, 0); + }, + + componentDidMount: function componentDidMount() { + this._onWindowScrollListener = _utilsEventListener2['default'].listen(window, 'scroll', this.checkPosition); + this._onDocumentClickListener = _utilsEventListener2['default'].listen(_utilsDomUtils2['default'].ownerDocument(this), 'click', this.checkPositionWithEventLoop); + }, + + componentWillUnmount: function componentWillUnmount() { + if (this._onWindowScrollListener) { + this._onWindowScrollListener.remove(); + } + + if (this._onDocumentClickListener) { + this._onDocumentClickListener.remove(); + } + }, + + componentDidUpdate: function componentDidUpdate(prevProps, prevState) { + if (prevState.affixClass === this.state.affixClass) { + this.checkPositionWithEventLoop(); + } + } + }; + + exports['default'] = AffixMixin; + module.exports = exports['default']; + +/***/ }, +/* 73 */ +/***/ function(module, exports) { + + /** + * Copyright 2013-2014 Facebook, Inc. + * + * This file contains a modified version of: + * https://github.com/facebook/react/blob/v0.12.0/src/vendor/stubs/EventListener.js + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * TODO: remove in favour of solution provided by: + * https://github.com/facebook/react/issues/285 + */ + + /** + * Does not take into account specific nature of platform. + */ + 'use strict'; + + exports.__esModule = true; + var EventListener = { + /** + * Listen to DOM events during the bubble phase. + * + * @param {DOMEventTarget} target DOM element to register listener on. + * @param {string} eventType Event type, e.g. 'click' or 'mouseover'. + * @param {function} callback Callback function. + * @return {object} Object with a `remove` method. + */ + listen: function listen(target, eventType, callback) { + if (target.addEventListener) { + target.addEventListener(eventType, callback, false); + return { + remove: function remove() { + target.removeEventListener(eventType, callback, false); + } + }; + } else if (target.attachEvent) { + target.attachEvent('on' + eventType, callback); + return { + remove: function remove() { + target.detachEvent('on' + eventType, callback); + } + }; + } + } + }; + + exports['default'] = EventListener; + module.exports = exports['default']; + +/***/ }, +/* 74 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var Alert = _react2['default'].createClass({ + displayName: 'Alert', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + onDismiss: _react2['default'].PropTypes.func, + dismissAfter: _react2['default'].PropTypes.number, + closeLabel: _react2['default'].PropTypes.string + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'alert', + bsStyle: 'info', + closeLabel: 'Close Alert' + }; + }, + + renderDismissButton: function renderDismissButton() { + return _react2['default'].createElement( + 'button', + { + type: 'button', + className: 'close', + 'aria-label': this.props.closeLabel, + onClick: this.props.onDismiss }, + _react2['default'].createElement( + 'span', + { 'aria-hidden': 'true' }, + '×' + ) + ); + }, + + render: function render() { + var classes = this.getBsClassSet(); + var isDismissable = !!this.props.onDismiss; + + classes['alert-dismissable'] = isDismissable; + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { role: 'alert', className: _classnames2['default'](this.props.className, classes) }), + isDismissable ? this.renderDismissButton() : null, + this.props.children + ); + }, + + componentDidMount: function componentDidMount() { + if (this.props.dismissAfter && this.props.onDismiss) { + this.dismissTimer = setTimeout(this.props.onDismiss, this.props.dismissAfter); + } + }, + + componentWillUnmount: function componentWillUnmount() { + clearTimeout(this.dismissTimer); + } + }); + + exports['default'] = Alert; + module.exports = exports['default']; + +/***/ }, +/* 75 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var Badge = _react2['default'].createClass({ + displayName: 'Badge', + + propTypes: { + pullRight: _react2['default'].PropTypes.bool + }, + + getDefaultProps: function getDefaultProps() { + return { + pullRight: false + }; + }, + + 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 = { + 'pull-right': this.props.pullRight, + 'badge': this.hasContent() + }; + 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']; + +/***/ }, +/* 76 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _ButtonInput = __webpack_require__(77); + + var _ButtonInput2 = _interopRequireDefault(_ButtonInput); + + var Button = _react2['default'].createClass({ + displayName: 'Button', + + mixins: [_BootstrapMixin2['default']], + + 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: _utilsCustomPropTypes2['default'].elementType, + 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(_ButtonInput2['default'].types) + }, + + getDefaultProps: function getDefaultProps() { + return { + active: false, + block: false, + bsClass: 'button', + bsStyle: 'default', + disabled: false, + navItem: false, + navDropdown: false + }; + }, + + render: function render() { + var classes = this.props.navDropdown ? {} : this.getBsClassSet(); + var renderFuncName = undefined; + + classes = _extends({ + active: this.props.active, + 'btn-block': this.props.block + }, 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) + ); + } + }); + + exports['default'] = Button; + module.exports = exports['default']; + +/***/ }, +/* 77 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _Button = __webpack_require__(76); + + var _Button2 = _interopRequireDefault(_Button); + + var _FormGroup = __webpack_require__(78); + + var _FormGroup2 = _interopRequireDefault(_FormGroup); + + var _InputBase2 = __webpack_require__(79); + + var _InputBase3 = _interopRequireDefault(_InputBase2); + + var _utilsChildrenValueInputValidation = __webpack_require__(52); + + 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 = ['button', 'reset', 'submit']; + + ButtonInput.defaultProps = { + type: 'button' + }; + + ButtonInput.propTypes = { + type: _react2['default'].PropTypes.oneOf(ButtonInput.types), + bsStyle: function bsStyle(props) { + //defer to Button propTypes of bsStyle + return null; + }, + children: _utilsChildrenValueInputValidation2['default'], + value: _utilsChildrenValueInputValidation2['default'] + }; + + exports['default'] = ButtonInput; + module.exports = exports['default']; + +/***/ }, +/* 78 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + 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']; + +/***/ }, +/* 79 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _FormGroup = __webpack_require__(78); + + var _FormGroup2 = _interopRequireDefault(_FormGroup); + + var _Glyphicon = __webpack_require__(80); + + 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 _react2['default'].findDOMNode(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(); + } else { + return this.getInputDOMNode().value; + } + } else { + throw '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']; + +/***/ }, +/* 80 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + 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']; + +/***/ }, +/* 81 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var ButtonGroup = _react2['default'].createClass({ + displayName: 'ButtonGroup', + + mixins: [_BootstrapMixin2['default']], + + 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: _utilsCustomPropTypes2['default'].all([_react2['default'].PropTypes.bool, function (props, propName, componentName) { + 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, + bsClass: 'button-group', + justified: false, + vertical: false + }; + }, + + render: function render() { + var classes = this.getBsClassSet(); + classes['btn-group'] = !this.props.vertical; + classes['btn-group-vertical'] = this.props.vertical; + classes['btn-group-justified'] = this.props.justified; + classes['btn-block'] = this.props.block; + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + } + }); + + exports['default'] = ButtonGroup; + module.exports = exports['default']; + +/***/ }, +/* 82 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var ButtonToolbar = _react2['default'].createClass({ + displayName: 'ButtonToolbar', + + mixins: [_BootstrapMixin2['default']], + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'button-toolbar' + }; + }, + + render: function render() { + var classes = this.getBsClassSet(); + + 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']; + +/***/ }, +/* 83 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _Glyphicon = __webpack_require__(80); + + var _Glyphicon2 = _interopRequireDefault(_Glyphicon); + + var Carousel = _react2['default'].createClass({ + displayName: 'Carousel', + + mixins: [_BootstrapMixin2['default']], + + 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 { + 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 = { + carousel: true, + slide: this.props.slide + }; + + 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', + { className: 'carousel-inner', ref: 'inner' }, + _utilsValidComponentChildren2['default'].map(this.props.children, this.renderItem) + ), + this.props.controls ? this.renderControls() : null + ); + }, + + renderPrev: function renderPrev() { + return _react2['default'].createElement( + 'a', + { className: 'left carousel-control', href: '#prev', key: 0, onClick: this.prev }, + this.props.prevIcon + ); + }, + + renderNext: function renderNext() { + return _react2['default'].createElement( + 'a', + { className: 'right carousel-control', 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 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: 'carousel-indicators' }, + indicators + ); + }, + + getActiveIndex: function getActiveIndex() { + return this.props.activeIndex != null ? this.props.activeIndex : this.state.activeIndex; + }, + + handleItemAnimateOutEnd: function handleItemAnimateOutEnd() { + this.setState({ + previousActiveIndex: null, + direction: null + }, function () { + this.waitForNext(); + + if (this.props.onSlideEnd) { + this.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']; + +/***/ }, +/* 84 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsTransitionEvents = __webpack_require__(85); + + var _utilsTransitionEvents2 = _interopRequireDefault(_utilsTransitionEvents); + + 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 { + 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(_react2['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() { + return _react2['default'].createElement( + 'div', + { className: 'carousel-caption' }, + this.props.caption + ); + } + }); + + exports['default'] = CarouselItem; + module.exports = exports['default']; + +/***/ }, +/* 85 */ +/***/ 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) { + 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']; + +/***/ }, +/* 86 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _Object$keys = __webpack_require__(1)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _styleMaps = __webpack_require__(70); + + var _styleMaps2 = _interopRequireDefault(_styleMaps); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + 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: _utilsCustomPropTypes2['default'].elementType + }, + + getDefaultProps: function getDefaultProps() { + return { + componentClass: 'div' + }; + }, + + render: function render() { + 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']; + +/***/ }, +/* 87 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsTransitionEvents = __webpack_require__(85); + + var _utilsTransitionEvents2 = _interopRequireDefault(_utilsTransitionEvents); + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var CollapsibleMixin = { + + propTypes: { + defaultExpanded: _react2['default'].PropTypes.bool, + expanded: _react2['default'].PropTypes.bool + }, + + getInitialState: function getInitialState() { + var defaultExpanded = this.props.defaultExpanded != null ? this.props.defaultExpanded : this.props.expanded != null ? this.props.expanded : false; + + return { + expanded: defaultExpanded, + collapsing: false + }; + }, + + componentWillMount: function componentWillMount() { + _utilsDeprecationWarning2['default']('CollapsibleMixin', 'Collapse Component'); + }, + + componentWillUpdate: function componentWillUpdate(nextProps, nextState) { + var willExpanded = nextProps.expanded != null ? nextProps.expanded : nextState.expanded; + if (willExpanded === this.isExpanded()) { + return; + } + + // if the expanded state is being toggled, ensure node has a dimension value + // this is needed for the animation to work and needs to be set before + // the collapsing class is applied (after collapsing is applied the in class + // is removed and the node's dimension will be wrong) + + var node = this.getCollapsibleDOMNode(); + var dimension = this.dimension(); + var value = '0'; + + if (!willExpanded) { + value = this.getCollapsibleDimensionValue(); + } + + node.style[dimension] = value + 'px'; + + this._afterWillUpdate(); + }, + + componentDidUpdate: function componentDidUpdate(prevProps, prevState) { + // check if expanded is being toggled; if so, set collapsing + this._checkToggleCollapsing(prevProps, prevState); + + // check if collapsing was turned on; if so, start animation + this._checkStartAnimation(); + }, + + // helps enable test stubs + _afterWillUpdate: function _afterWillUpdate() {}, + + _checkStartAnimation: function _checkStartAnimation() { + if (!this.state.collapsing) { + return; + } + + var node = this.getCollapsibleDOMNode(); + var dimension = this.dimension(); + var value = this.getCollapsibleDimensionValue(); + + // setting the dimension here starts the transition animation + var result = undefined; + if (this.isExpanded()) { + result = value + 'px'; + } else { + result = '0px'; + } + node.style[dimension] = result; + }, + + _checkToggleCollapsing: function _checkToggleCollapsing(prevProps, prevState) { + var wasExpanded = prevProps.expanded != null ? prevProps.expanded : prevState.expanded; + var isExpanded = this.isExpanded(); + if (wasExpanded !== isExpanded) { + if (wasExpanded) { + this._handleCollapse(); + } else { + this._handleExpand(); + } + } + }, + + _handleExpand: function _handleExpand() { + var _this = this; + + var node = this.getCollapsibleDOMNode(); + var dimension = this.dimension(); + + var complete = function complete() { + _this._removeEndEventListener(node, complete); + // remove dimension value - this ensures the collapsible item can grow + // in dimension after initial display (such as an image loading) + node.style[dimension] = ''; + _this.setState({ + collapsing: false + }); + }; + + this._addEndEventListener(node, complete); + + this.setState({ + collapsing: true + }); + }, + + _handleCollapse: function _handleCollapse() { + var _this2 = this; + + var node = this.getCollapsibleDOMNode(); + + var complete = function complete() { + _this2._removeEndEventListener(node, complete); + _this2.setState({ + collapsing: false + }); + }; + + this._addEndEventListener(node, complete); + + this.setState({ + collapsing: true + }); + }, + + // helps enable test stubs + _addEndEventListener: function _addEndEventListener(node, complete) { + _utilsTransitionEvents2['default'].addEndEventListener(node, complete); + }, + + // helps enable test stubs + _removeEndEventListener: function _removeEndEventListener(node, complete) { + _utilsTransitionEvents2['default'].removeEndEventListener(node, complete); + }, + + dimension: function dimension() { + return typeof this.getCollapsibleDimension === 'function' ? this.getCollapsibleDimension() : 'height'; + }, + + isExpanded: function isExpanded() { + return this.props.expanded != null ? this.props.expanded : this.state.expanded; + }, + + getCollapsibleClassSet: function getCollapsibleClassSet(className) { + var classes = {}; + + if (typeof className === 'string') { + className.split(' ').forEach(function (subClasses) { + if (subClasses) { + classes[subClasses] = true; + } + }); + } + + classes.collapsing = this.state.collapsing; + classes.collapse = !this.state.collapsing; + classes['in'] = this.isExpanded() && !this.state.collapsing; + + return classes; + } + }; + + exports['default'] = CollapsibleMixin; + module.exports = exports['default']; + +/***/ }, +/* 88 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _Collapse = __webpack_require__(89); + + var _Collapse2 = _interopRequireDefault(_Collapse); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var CollapsibleNav = _react2['default'].createClass({ + displayName: 'CollapsibleNav', + + mixins: [_BootstrapMixin2['default']], + + 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 + ); + } else { + 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'] = CollapsibleNav; + module.exports = exports['default']; + +/***/ }, +/* 89 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _reactOverlaysLibTransition = __webpack_require__(90); + + var _reactOverlaysLibTransition2 = _interopRequireDefault(_reactOverlaysLibTransition); + + var _utilsDomUtils = __webpack_require__(31); + + var _utilsDomUtils2 = _interopRequireDefault(_utilsDomUtils); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + 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(_utilsDomUtils2['default'].css(elem, margins[0]), 10) + parseInt(_utilsDomUtils2['default'].css(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: this._dimension() === 'width' ? '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: _utilsCustomPropTypes2['default'].all([_react2['default'].PropTypes.number, function (props) { + if (props.duration != null) { + _utilsDeprecationWarning2['default']('Collapse `duration`', 'the `timeout` prop'); + } + return null; + }]), + + /** + * 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']; + +/***/ }, +/* 90 */ +/***/ 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__(32); + + var _react2 = _interopRequireDefault(_react); + + var _domHelpersTransitionProperties = __webpack_require__(91); + + var _domHelpersTransitionProperties2 = _interopRequireDefault(_domHelpersTransitionProperties); + + var _domHelpersEventsOn = __webpack_require__(92); + + var _domHelpersEventsOn2 = _interopRequireDefault(_domHelpersEventsOn); + + var _classnames = __webpack_require__(68); + + 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 = _react2['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 = _react2['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; + +/***/ }, +/* 91 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var canUseDOM = __webpack_require__(33); + + 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 }; + } + +/***/ }, +/* 92 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var canUseDOM = __webpack_require__(33); + 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; + +/***/ }, +/* 93 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _keycode = __webpack_require__(94); + + var _keycode2 = _interopRequireDefault(_keycode); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _uncontrollable = __webpack_require__(95); + + var _uncontrollable2 = _interopRequireDefault(_uncontrollable); + + var _ButtonGroup = __webpack_require__(81); + + var _ButtonGroup2 = _interopRequireDefault(_ButtonGroup); + + var _DropdownToggle = __webpack_require__(99); + + var _DropdownToggle2 = _interopRequireDefault(_DropdownToggle); + + var _DropdownMenu = __webpack_require__(101); + + var _DropdownMenu2 = _interopRequireDefault(_DropdownMenu); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _lodashCollectionFind = __webpack_require__(107); + + var _lodashCollectionFind2 = _interopRequireDefault(_lodashCollectionFind); + + var _lodashObjectOmit = __webpack_require__(156); + + var _lodashObjectOmit2 = _interopRequireDefault(_lodashObjectOmit); + + var TOGGLE_REF = 'toggle-btn'; + + var TOGGLE_ROLE = _DropdownToggle2['default'].defaultProps.bsRole; + exports.TOGGLE_ROLE = TOGGLE_ROLE; + var MENU_ROLE = _DropdownMenu2['default'].defaultProps.bsRole; + + exports.MENU_ROLE = MENU_ROLE; + + 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 = {}; + } + + Dropdown.prototype.componentDidMount = function componentDidMount() { + var menu = this.refs.menu; + if (this.props.open && menu.focusNext) { + menu.focusNext(); + } + }; + + Dropdown.prototype.componentDidUpdate = function componentDidUpdate(prevProps, prevState) { + var menu = this.refs.menu; + if (this.props.open && !prevProps.open && menu.focusNext) { + menu.focusNext(); + } + }; + + Dropdown.prototype.render = function render() { + var children = this.extractChildren(); + var Component = this.props.componentClass; + + var props = _lodashObjectOmit2['default'](this.props, ['id']); + + var rootClasses = { + open: this.props.open, + dropdown: !this.props.dropup, + dropup: this.props.dropup + }; + + return _react2['default'].createElement( + Component, + _extends({}, props, { + className: _classnames2['default'](this.props.className, rootClasses) + }), + children + ); + }; + + Dropdown.prototype.toggleOpen = function toggleOpen() { + var open = !this.props.open; + + if (this.props.onToggle) { + this.props.onToggle(open); + } + }; + + Dropdown.prototype.handleClick = function handleClick(event) { + if (this.props.disabled) { + return; + } + + this.toggleOpen(); + }; + + Dropdown.prototype.handleKeyDown = function handleKeyDown(event) { + var _this = this; + + var focusNext = function focusNext() { + if (_this.refs.menu.focusNext) { + _this.refs.menu.focusNext(); + } + }; + + switch (event.keyCode) { + case _keycode2['default'].codes.down: + if (!this.props.open) { + this.toggleOpen(); + } else { + focusNext(); + } + event.preventDefault(); + break; + case _keycode2['default'].codes.esc: + case _keycode2['default'].codes.tab: + if (this.props.open) { + this.handleClose(event); + } + break; + default: + } + }; + + Dropdown.prototype.handleClose = function handleClose(event) { + if (!this.props.open) { + return; + } + + // we need to let the current event finish before closing the menu. + // otherwise the menu may close, shifting focus to document.body, before focus has moved + // to the next focusable input + if (event && event.keyCode === _keycode2['default'].codes.tab) { + setTimeout(this.toggleOpen); + } else { + this.toggleOpen(); + } + + if (event && event.type === 'keydown' && event.keyCode === _keycode2['default'].codes.esc) { + var toggle = _react2['default'].findDOMNode(this.refs[TOGGLE_REF]); + event.preventDefault(); + event.stopPropagation(); + toggle.focus(); + } + }; + + Dropdown.prototype.extractChildren = function extractChildren() { + var _this2 = this; + + var open = !!this.props.open; + var seen = {}; + + return _react2['default'].Children.map(this.props.children, function (child) { + var extractor = _lodashCollectionFind2['default'](_this2.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 + }; + + 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 + }; + + 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.defaultProps = { + componentClass: _ButtonGroup2['default'] + }; + + Dropdown.propTypes = { + /** + * 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: _utilsCustomPropTypes2['default'].isRequiredForA11y(_react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number])), + + componentClass: _utilsCustomPropTypes2['default'].elementType, + + /** + * The children of a Dropdown may be a `` or a ``. + * @type {node} + */ + children: _utilsCustomPropTypes2['default'].all([_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 + }; + + Dropdown = _uncontrollable2['default'](Dropdown, { open: 'onToggle' }); + + Dropdown.Toggle = _DropdownToggle2['default']; + Dropdown.Menu = _DropdownMenu2['default']; + + exports['default'] = Dropdown; + +/***/ }, +/* 94 */ +/***/ 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] + } + + +/***/ }, +/* 95 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _createUncontrollable = __webpack_require__(96); + + var _createUncontrollable2 = _interopRequireDefault(_createUncontrollable); + + var mixin = { + shouldComponentUpdate: function shouldComponentUpdate() { + //let the setState 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']; + +/***/ }, +/* 96 */ +/***/ 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__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utils = __webpack_require__(97); + + var utils = _interopRequireWildcard(_utils); + + function createUncontrollable(mixins, set) { + + return uncontrollable; + + function uncontrollable(Component, controlledValues) { + var forwardMethods = 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); + + var methods = utils.transform(forwardMethods, function (proto, method) { + proto[method] = function () { + var controlled = this.refs.controlled; + return controlled[method].apply(controlled, 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)]; + }, {}); + }, + + render: function render() { + var _this = 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 = _this.props[propName]; + + if (linkPropName && !isProp(_this.props, propName) && isProp(_this.props, linkPropName)) { + prop = _this.props[linkPropName].value; + } + + newProps[propName] = prop !== undefined ? prop : _this._values[propName]; + + newProps[handle] = setAndNotify.bind(_this, propName); + }); + + newProps = _extends({ ref: 'controlled' }, props, newProps); + + 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']; + +/***/ }, +/* 97 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports.customPropType = customPropType; + exports.uncontrolledPropTypes = uncontrolledPropTypes; + exports.getType = getType; + 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__(32); + + var _react2 = _interopRequireDefault(_react); + + var _invariant = __webpack_require__(98); + + var _invariant2 = _interopRequireDefault(_invariant); + + function customPropType(handler, propType, name) { + + return function (props, propName, componentName) { + + 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 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; + } + +/***/ }, +/* 98 */ +/***/ 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; + + +/***/ }, +/* 99 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _Button = __webpack_require__(76); + + var _Button2 = _interopRequireDefault(_Button); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _SafeAnchor = __webpack_require__(100); + + 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.title || this.props.children, + caret + ); + }; + + return DropdownToggle; + })(_react2['default'].Component); + + exports['default'] = DropdownToggle; + + var titleAndChildrenValidation = _utilsCustomPropTypes2['default'].singlePropFrom(['title', 'children']); + + DropdownToggle.defaultProps = { + open: false, + useAnchor: false, + bsRole: 'toggle' + }; + + DropdownToggle.propTypes = { + bsRole: _react2['default'].PropTypes.string, + children: titleAndChildrenValidation, + noCaret: _react2['default'].PropTypes.bool, + open: _react2['default'].PropTypes.bool, + title: titleAndChildrenValidation, + useAnchor: _react2['default'].PropTypes.bool + }; + + DropdownToggle.isToggle = true; + DropdownToggle.titleProp = 'title'; + DropdownToggle.onClickProp = 'onClick'; + module.exports = exports['default']; + +/***/ }, +/* 100 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + 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']; + +/***/ }, +/* 101 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _keycode = __webpack_require__(94); + + var _keycode2 = _interopRequireDefault(_keycode); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _reactOverlaysLibRootCloseWrapper = __webpack_require__(102); + + var _reactOverlaysLibRootCloseWrapper2 = _interopRequireDefault(_reactOverlaysLibRootCloseWrapper); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + 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 (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 = _react2['default'].findDOMNode(this); + + if (menuNode === undefined) { + return []; + } + + return [].slice.call(menuNode.querySelectorAll('[tabIndex="-1"]'), 0); + }; + + DropdownMenu.prototype.render = function render() { + var _this = this; + + var items = _utilsValidComponentChildren2['default'].map(this.props.children, function (child) { + var _ref = child.props || {}; + + var children = _ref.children; + var onKeyDown = _ref.onKeyDown; + var onSelect = _ref.onSelect; + + return _react2['default'].cloneElement(child, { + onKeyDown: _utilsCreateChainedFunction2['default'](onKeyDown, _this.handleKeyDown), + onSelect: _utilsCreateChainedFunction2['default'](onSelect, _this.props.onSelect) + }, children); + }); + + var classes = { + 'dropdown-menu': true, + 'dropdown-menu-right': this.props.pullRight + }; + + var list = _react2['default'].createElement( + 'ul', + { + className: _classnames2['default'](this.props.className, classes), + role: 'menu', + 'aria-labelledby': this.props.labelledBy + }, + items + ); + + if (this.props.open) { + list = _react2['default'].createElement( + _reactOverlaysLibRootCloseWrapper2['default'], + { noWrap: true, onRootClose: this.props.onClose }, + list + ); + } + + return list; + }; + + return DropdownMenu; + })(_react2['default'].Component); + + DropdownMenu.defaultProps = { + bsRole: 'menu', + 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']; + +/***/ }, +/* 102 */ +/***/ 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__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsAddEventListener = __webpack_require__(103); + + var _utilsAddEventListener2 = _interopRequireDefault(_utilsAddEventListener); + + var _utilsCreateChainedFunction = __webpack_require__(105); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _utilsOwnerDocument = __webpack_require__(106); + + var _utilsOwnerDocument2 = _interopRequireDefault(_utilsOwnerDocument); + + // TODO: Consider using an ES6 symbol here, once we use babel-runtime. + var CLICK_WAS_INSIDE = '__click_was_inside'; + + 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[CLICK_WAS_INSIDE] = 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); + } + + _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[CLICK_WAS_INSIDE]) { + 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'](suppressRootClose, 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: suppressRootClose }, + 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 = _react2['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']; + +/***/ }, +/* 103 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _domHelpersEventsOn = __webpack_require__(92); + + var _domHelpersEventsOn2 = _interopRequireDefault(_domHelpersEventsOn); + + var _domHelpersEventsOff = __webpack_require__(104); + + 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']; + +/***/ }, +/* 104 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + var canUseDOM = __webpack_require__(33); + 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; + +/***/ }, +/* 105 */ +/***/ 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']; + +/***/ }, +/* 106 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _domHelpersOwnerDocument = __webpack_require__(34); + + var _domHelpersOwnerDocument2 = _interopRequireDefault(_domHelpersOwnerDocument); + + exports['default'] = function (componentOrElement) { + return _domHelpersOwnerDocument2['default'](_react2['default'].findDOMNode(componentOrElement)); + }; + + module.exports = exports['default']; + +/***/ }, +/* 107 */ +/***/ function(module, exports, __webpack_require__) { + + var baseEach = __webpack_require__(108), + createFind = __webpack_require__(129); + + /** + * 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; + + +/***/ }, +/* 108 */ +/***/ function(module, exports, __webpack_require__) { + + var baseForOwn = __webpack_require__(109), + createBaseEach = __webpack_require__(128); + + /** + * 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; + + +/***/ }, +/* 109 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFor = __webpack_require__(110), + keys = __webpack_require__(114); + + /** + * 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; + + +/***/ }, +/* 110 */ +/***/ function(module, exports, __webpack_require__) { + + var createBaseFor = __webpack_require__(111); + + /** + * 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; + + +/***/ }, +/* 111 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(112); + + /** + * 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; + + +/***/ }, +/* 112 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(113); + + /** + * 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) { + return isObject(value) ? value : Object(value); + } + + module.exports = toObject; + + +/***/ }, +/* 113 */ +/***/ 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; + + +/***/ }, +/* 114 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(115), + isArrayLike = __webpack_require__(119), + isObject = __webpack_require__(113), + shimKeys = __webpack_require__(123); + + /* 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' && isArrayLike(object))) { + return shimKeys(object); + } + return isObject(object) ? nativeKeys(object) : []; + }; + + module.exports = keys; + + +/***/ }, +/* 115 */ +/***/ function(module, exports, __webpack_require__) { + + var isNative = __webpack_require__(116); + + /** + * 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; + + +/***/ }, +/* 116 */ +/***/ function(module, exports, __webpack_require__) { + + var isFunction = __webpack_require__(117), + isObjectLike = __webpack_require__(118); + + /** 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) && reIsHostCtor.test(value); + } + + module.exports = isNative; + + +/***/ }, +/* 117 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(113); + + /** `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; + + +/***/ }, +/* 118 */ +/***/ 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; + + +/***/ }, +/* 119 */ +/***/ function(module, exports, __webpack_require__) { + + var getLength = __webpack_require__(120), + isLength = __webpack_require__(122); + + /** + * 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; + + +/***/ }, +/* 120 */ +/***/ function(module, exports, __webpack_require__) { + + var baseProperty = __webpack_require__(121); + + /** + * 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; + + +/***/ }, +/* 121 */ +/***/ function(module, exports) { + + /** + * 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 : object[key]; + }; + } + + module.exports = baseProperty; + + +/***/ }, +/* 122 */ +/***/ 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; + + +/***/ }, +/* 123 */ +/***/ function(module, exports, __webpack_require__) { + + var isArguments = __webpack_require__(124), + isArray = __webpack_require__(125), + isIndex = __webpack_require__(126), + isLength = __webpack_require__(122), + keysIn = __webpack_require__(127); + + /** 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)); + + 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; + + +/***/ }, +/* 124 */ +/***/ function(module, exports, __webpack_require__) { + + var isArrayLike = __webpack_require__(119), + isObjectLike = __webpack_require__(118); + + /** 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; + + +/***/ }, +/* 125 */ +/***/ function(module, exports, __webpack_require__) { + + var getNative = __webpack_require__(115), + isLength = __webpack_require__(122), + isObjectLike = __webpack_require__(118); + + /** `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; + + +/***/ }, +/* 126 */ +/***/ 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; + + +/***/ }, +/* 127 */ +/***/ function(module, exports, __webpack_require__) { + + var isArguments = __webpack_require__(124), + isArray = __webpack_require__(125), + isIndex = __webpack_require__(126), + isLength = __webpack_require__(122), + isObject = __webpack_require__(113); + + /** Used for native method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * 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)) && length) || 0; + + var Ctor = object.constructor, + index = -1, + isProto = typeof Ctor == 'function' && Ctor.prototype === object, + result = Array(length), + skipIndexes = length > 0; + + while (++index < length) { + result[index] = (index + ''); + } + for (var key in object) { + if (!(skipIndexes && isIndex(key, length)) && + !(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) { + result.push(key); + } + } + return result; + } + + module.exports = keysIn; + + +/***/ }, +/* 128 */ +/***/ function(module, exports, __webpack_require__) { + + var getLength = __webpack_require__(120), + isLength = __webpack_require__(122), + toObject = __webpack_require__(112); + + /** + * 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; + + +/***/ }, +/* 129 */ +/***/ function(module, exports, __webpack_require__) { + + var baseCallback = __webpack_require__(130), + baseFind = __webpack_require__(154), + baseFindIndex = __webpack_require__(155), + isArray = __webpack_require__(125); + + /** + * 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; + + +/***/ }, +/* 130 */ +/***/ function(module, exports, __webpack_require__) { + + var baseMatches = __webpack_require__(131), + baseMatchesProperty = __webpack_require__(143), + bindCallback = __webpack_require__(150), + identity = __webpack_require__(151), + property = __webpack_require__(152); + + /** + * 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; + + +/***/ }, +/* 131 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsMatch = __webpack_require__(132), + getMatchData = __webpack_require__(140), + toObject = __webpack_require__(112); + + /** + * 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; + } + return object[key] === value && (value !== undefined || (key in toObject(object))); + }; + } + return function(object) { + return baseIsMatch(object, matchData); + }; + } + + module.exports = baseMatches; + + +/***/ }, +/* 132 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsEqual = __webpack_require__(133), + toObject = __webpack_require__(112); + + /** + * 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; + + +/***/ }, +/* 133 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIsEqualDeep = __webpack_require__(134), + isObject = __webpack_require__(113), + isObjectLike = __webpack_require__(118); + + /** + * 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; + + +/***/ }, +/* 134 */ +/***/ function(module, exports, __webpack_require__) { + + var equalArrays = __webpack_require__(135), + equalByTag = __webpack_require__(137), + equalObjects = __webpack_require__(138), + isArray = __webpack_require__(125), + isTypedArray = __webpack_require__(139); + + /** `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, + othIsObj = othTag == objectTag, + 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; + + +/***/ }, +/* 135 */ +/***/ function(module, exports, __webpack_require__) { + + var arraySome = __webpack_require__(136); + + /** + * 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; + + +/***/ }, +/* 136 */ +/***/ 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; + + +/***/ }, +/* 137 */ +/***/ 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; + + +/***/ }, +/* 138 */ +/***/ function(module, exports, __webpack_require__) { + + var keys = __webpack_require__(114); + + /** 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; + + +/***/ }, +/* 139 */ +/***/ function(module, exports, __webpack_require__) { + + var isLength = __webpack_require__(122), + isObjectLike = __webpack_require__(118); + + /** `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; + + +/***/ }, +/* 140 */ +/***/ function(module, exports, __webpack_require__) { + + var isStrictComparable = __webpack_require__(141), + pairs = __webpack_require__(142); + + /** + * 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; + + +/***/ }, +/* 141 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(113); + + /** + * 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; + + +/***/ }, +/* 142 */ +/***/ function(module, exports, __webpack_require__) { + + var keys = __webpack_require__(114), + toObject = __webpack_require__(112); + + /** + * 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; + + +/***/ }, +/* 143 */ +/***/ function(module, exports, __webpack_require__) { + + var baseGet = __webpack_require__(144), + baseIsEqual = __webpack_require__(133), + baseSlice = __webpack_require__(145), + isArray = __webpack_require__(125), + isKey = __webpack_require__(146), + isStrictComparable = __webpack_require__(141), + last = __webpack_require__(147), + toObject = __webpack_require__(112), + toPath = __webpack_require__(148); + + /** + * 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; + + +/***/ }, +/* 144 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(112); + + /** + * 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; + } + if (pathKey !== undefined && pathKey in toObject(object)) { + path = [pathKey]; + } + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[path[index++]]; + } + return (index && index == length) ? object : undefined; + } + + module.exports = baseGet; + + +/***/ }, +/* 145 */ +/***/ 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; + + +/***/ }, +/* 146 */ +/***/ function(module, exports, __webpack_require__) { + + var isArray = __webpack_require__(125), + toObject = __webpack_require__(112); + + /** 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; + + +/***/ }, +/* 147 */ +/***/ 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; + + +/***/ }, +/* 148 */ +/***/ function(module, exports, __webpack_require__) { + + var baseToString = __webpack_require__(149), + isArray = __webpack_require__(125); + + /** 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; + + +/***/ }, +/* 149 */ +/***/ 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; + + +/***/ }, +/* 150 */ +/***/ function(module, exports, __webpack_require__) { + + var identity = __webpack_require__(151); + + /** + * 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; + + +/***/ }, +/* 151 */ +/***/ 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; + + +/***/ }, +/* 152 */ +/***/ function(module, exports, __webpack_require__) { + + var baseProperty = __webpack_require__(121), + basePropertyDeep = __webpack_require__(153), + isKey = __webpack_require__(146); + + /** + * 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; + + +/***/ }, +/* 153 */ +/***/ function(module, exports, __webpack_require__) { + + var baseGet = __webpack_require__(144), + toPath = __webpack_require__(148); + + /** + * 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; + + +/***/ }, +/* 154 */ +/***/ 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; + + +/***/ }, +/* 155 */ +/***/ 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; + + +/***/ }, +/* 156 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayMap = __webpack_require__(157), + baseDifference = __webpack_require__(158), + baseFlatten = __webpack_require__(165), + bindCallback = __webpack_require__(150), + keysIn = __webpack_require__(127), + pickByArray = __webpack_require__(167), + pickByCallback = __webpack_require__(168), + restParam = __webpack_require__(170); + + /** + * 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; + + +/***/ }, +/* 157 */ +/***/ 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; + + +/***/ }, +/* 158 */ +/***/ function(module, exports, __webpack_require__) { + + var baseIndexOf = __webpack_require__(159), + cacheIndexOf = __webpack_require__(161), + createCache = __webpack_require__(162); + + /** 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; + + +/***/ }, +/* 159 */ +/***/ function(module, exports, __webpack_require__) { + + var indexOfNaN = __webpack_require__(160); + + /** + * 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; + + +/***/ }, +/* 160 */ +/***/ 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; + + +/***/ }, +/* 161 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(113); + + /** + * 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; + + +/***/ }, +/* 162 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {var SetCache = __webpack_require__(163), + getNative = __webpack_require__(115); + + /** 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; }()))) + +/***/ }, +/* 163 */ +/***/ function(module, exports, __webpack_require__) { + + /* WEBPACK VAR INJECTION */(function(global) {var cachePush = __webpack_require__(164), + getNative = __webpack_require__(115); + + /** 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; }()))) + +/***/ }, +/* 164 */ +/***/ function(module, exports, __webpack_require__) { + + var isObject = __webpack_require__(113); + + /** + * 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; + + +/***/ }, +/* 165 */ +/***/ function(module, exports, __webpack_require__) { + + var arrayPush = __webpack_require__(166), + isArguments = __webpack_require__(124), + isArray = __webpack_require__(125), + isArrayLike = __webpack_require__(119), + isObjectLike = __webpack_require__(118); + + /** + * 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; + + +/***/ }, +/* 166 */ +/***/ 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; + + +/***/ }, +/* 167 */ +/***/ function(module, exports, __webpack_require__) { + + var toObject = __webpack_require__(112); + + /** + * 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; + + +/***/ }, +/* 168 */ +/***/ function(module, exports, __webpack_require__) { + + var baseForIn = __webpack_require__(169); + + /** + * 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; + + +/***/ }, +/* 169 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFor = __webpack_require__(110), + keysIn = __webpack_require__(127); + + /** + * 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; + + +/***/ }, +/* 170 */ +/***/ 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; + + +/***/ }, +/* 171 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _Dropdown = __webpack_require__(93); + + var _Dropdown2 = _interopRequireDefault(_Dropdown); + + var _NavDropdown = __webpack_require__(172); + + var _NavDropdown2 = _interopRequireDefault(_NavDropdown); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var _lodashObjectOmit = __webpack_require__(156); + + var _lodashObjectOmit2 = _interopRequireDefault(_lodashObjectOmit); + + var DropdownButton = (function (_React$Component) { + _inherits(DropdownButton, _React$Component); + + function DropdownButton(props) { + _classCallCheck(this, DropdownButton); + + _React$Component.call(this, props); + } + + DropdownButton.prototype.render = function render() { + var _props = this.props; + var title = _props.title; + var navItem = _props.navItem; + + var props = _objectWithoutProperties(_props, ['title', 'navItem']); + + var toggleProps = _lodashObjectOmit2['default'](props, _Dropdown2['default'].ControlledComponent.propTypes); + + if (navItem) { + return _react2['default'].createElement(_NavDropdown2['default'], this.props); + } + + return _react2['default'].createElement( + _Dropdown2['default'], + props, + _react2['default'].createElement( + _Dropdown2['default'].Toggle, + toggleProps, + title + ), + _react2['default'].createElement( + _Dropdown2['default'].Menu, + null, + this.props.children + ) + ); + }; + + return DropdownButton; + })(_react2['default'].Component); + + DropdownButton.propTypes = _extends({ + /** + * When used with the `title` prop, the noCaret option will not render a caret icon, in the toggle element. + */ + noCaret: _react2['default'].PropTypes.bool, + + /** + * Specify whether this Dropdown is part of a Nav component + * + * @type {bool} + * @deprecated Use the `NavDropdown` instead. + */ + navItem: _utilsCustomPropTypes2['default'].all([_react2['default'].PropTypes.bool, function (props, propName, componentName) { + if (props.navItem) { + _utilsDeprecationWarning2['default']('navItem', 'NavDropdown component', 'https://github.com/react-bootstrap/react-bootstrap/issues/526'); + } + }]), + title: _react2['default'].PropTypes.node.isRequired + }, _Dropdown2['default'].propTypes, _BootstrapMixin2['default'].propTypes); + + DropdownButton.defaultProps = { + pullRight: false, + dropup: false, + navItem: false, + noCaret: false + }; + + exports['default'] = DropdownButton; + module.exports = exports['default']; + +/***/ }, +/* 172 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _Dropdown = __webpack_require__(93); + + var _Dropdown2 = _interopRequireDefault(_Dropdown); + + var NavDropdown = (function (_React$Component) { + _inherits(NavDropdown, _React$Component); + + function NavDropdown() { + _classCallCheck(this, NavDropdown); + + _React$Component.apply(this, arguments); + } + + NavDropdown.prototype.render = function render() { + var _props = this.props; + var children = _props.children; + var title = _props.title; + var noCaret = _props.noCaret; + + var props = _objectWithoutProperties(_props, ['children', 'title', 'noCaret']); + + return _react2['default'].createElement( + _Dropdown2['default'], + _extends({}, props, { componentClass: 'li' }), + _react2['default'].createElement( + _Dropdown2['default'].Toggle, + { + useAnchor: true, + disabled: props.disabled, + noCaret: noCaret + }, + title + ), + _react2['default'].createElement( + _Dropdown2['default'].Menu, + null, + children + ) + ); + }; + + return NavDropdown; + })(_react2['default'].Component); + + NavDropdown.propTypes = _extends({ + noCaret: _react2['default'].PropTypes.bool, + title: _react2['default'].PropTypes.node.isRequired + }, _Dropdown2['default'].propTypes); + + exports['default'] = NavDropdown; + module.exports = exports['default']; + +/***/ }, +/* 173 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _Button = __webpack_require__(76); + + var _Button2 = _interopRequireDefault(_Button); + + var _Dropdown = __webpack_require__(93); + + var _Dropdown2 = _interopRequireDefault(_Dropdown); + + var _SplitToggle = __webpack_require__(174); + + var _SplitToggle2 = _interopRequireDefault(_SplitToggle); + + var SplitButton = (function (_React$Component) { + _inherits(SplitButton, _React$Component); + + function SplitButton() { + _classCallCheck(this, SplitButton); + + _React$Component.apply(this, arguments); + } + + SplitButton.prototype.render = function render() { + var _props = this.props; + var children = _props.children; + var title = _props.title; + var onClick = _props.onClick; + var target = _props.target; + var href = _props.href; + var + // bsStyle is validated by 'Button' component + bsStyle = _props.bsStyle; + + var props = _objectWithoutProperties(_props, ['children', 'title', 'onClick', 'target', 'href', 'bsStyle']); + + var disabled = props.disabled; + + var button = _react2['default'].createElement( + _Button2['default'], + { + onClick: onClick, + bsStyle: bsStyle, + disabled: disabled, + target: target, + href: href + }, + title + ); + + return _react2['default'].createElement( + _Dropdown2['default'], + props, + button, + _react2['default'].createElement(_SplitToggle2['default'], { + 'aria-label': title, + bsStyle: bsStyle, + disabled: disabled + }), + _react2['default'].createElement( + _Dropdown2['default'].Menu, + null, + children + ) + ); + }; + + return SplitButton; + })(_react2['default'].Component); + + SplitButton.propTypes = _extends({}, _Dropdown2['default'].propTypes, _BootstrapMixin2['default'].propTypes, { + + /** + * @private + */ + onClick: function onClick() {}, + target: _react2['default'].PropTypes.string, + href: _react2['default'].PropTypes.string, + /** + * The content of the split button. + */ + title: _react2['default'].PropTypes.node.isRequired + }); + + SplitButton.defaultProps = { + disabled: false, + dropup: false, + pullRight: false + }; + + SplitButton.Toggle = _SplitToggle2['default']; + + exports['default'] = SplitButton; + module.exports = exports['default']; + // eslint-disable-line + + //dropup: React.PropTypes.bool, + +/***/ }, +/* 174 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _DropdownToggle = __webpack_require__(99); + + var _DropdownToggle2 = _interopRequireDefault(_DropdownToggle); + + var SplitToggle = (function (_React$Component) { + _inherits(SplitToggle, _React$Component); + + function SplitToggle() { + _classCallCheck(this, SplitToggle); + + _React$Component.apply(this, arguments); + } + + SplitToggle.prototype.render = function render() { + return _react2['default'].createElement(_DropdownToggle2['default'], _extends({}, this.props, { + useAnchor: false, + noCaret: false + })); + }; + + return SplitToggle; + })(_react2['default'].Component); + + exports['default'] = SplitToggle; + + SplitToggle.defaultProps = _DropdownToggle2['default'].defaultProps; + module.exports = exports['default']; + +/***/ }, +/* 175 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsDomUtils = __webpack_require__(31); + + var _utilsDomUtils2 = _interopRequireDefault(_utilsDomUtils); + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + // TODO: listen for onTransitionEnd to remove el + function getElementsAndSelf(root, classes) { + var els = root.querySelectorAll('.' + classes.join('.')); + + els = [].map.call(els, function (e) { + return e; + }); + + for (var i = 0; i < classes.length; i++) { + if (!root.className.match(new RegExp('\\b' + classes[i] + '\\b'))) { + return els; + } + } + els.unshift(root); + return els; + } + + exports['default'] = { + componentWillMount: function componentWillMount() { + _utilsDeprecationWarning2['default']('FadeMixin', 'Fade Component'); + }, + + _fadeIn: function _fadeIn() { + var els = undefined; + + if (this.isMounted()) { + els = getElementsAndSelf(_react2['default'].findDOMNode(this), ['fade']); + + if (els.length) { + els.forEach(function (el) { + el.className += ' in'; + }); + } + } + }, + + _fadeOut: function _fadeOut() { + var els = getElementsAndSelf(this._fadeOutEl, ['fade', 'in']); + + if (els.length) { + els.forEach(function (el) { + el.className = el.className.replace(/\bin\b/, ''); + }); + } + + setTimeout(this._handleFadeOutEnd, 300); + }, + + _handleFadeOutEnd: function _handleFadeOutEnd() { + if (this._fadeOutEl && this._fadeOutEl.parentNode) { + this._fadeOutEl.parentNode.removeChild(this._fadeOutEl); + } + }, + + componentDidMount: function componentDidMount() { + if (document.querySelectorAll) { + // Firefox needs delay for transition to be triggered + setTimeout(this._fadeIn, 20); + } + }, + + componentWillUnmount: function componentWillUnmount() { + var els = getElementsAndSelf(_react2['default'].findDOMNode(this), ['fade']); + var container = this.props.container && _react2['default'].findDOMNode(this.props.container) || _utilsDomUtils2['default'].ownerDocument(this).body; + + if (els.length) { + this._fadeOutEl = document.createElement('div'); + container.appendChild(this._fadeOutEl); + this._fadeOutEl.appendChild(_react2['default'].findDOMNode(this).cloneNode(true)); + // Firefox needs delay for transition to be triggered + setTimeout(this._fadeOut, 20); + } + } + }; + module.exports = exports['default']; + +/***/ }, +/* 176 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + 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: _utilsCustomPropTypes2['default'].elementType + }, + + 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']; + +/***/ }, +/* 177 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + var _interopRequireWildcard = __webpack_require__(15)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _InputBase2 = __webpack_require__(79); + + var _InputBase3 = _interopRequireDefault(_InputBase2); + + var _FormControls = __webpack_require__(178); + + var FormControls = _interopRequireWildcard(_FormControls); + + var _utilsDeprecationWarning = __webpack_require__(16); + + 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', 'StaticText'); + 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']; + +/***/ }, +/* 178 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _Static2 = __webpack_require__(179); + + var _Static3 = _interopRequireDefault(_Static2); + + exports.Static = _Static3['default']; + +/***/ }, +/* 179 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _InputBase2 = __webpack_require__(79); + + var _InputBase3 = _interopRequireDefault(_InputBase2); + + var _utilsChildrenValueInputValidation = __webpack_require__(52); + + 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']; + +/***/ }, +/* 180 */ +/***/ 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__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsValidComponentChildren = __webpack_require__(55); + + 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); + } else { + 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']; + +/***/ }, +/* 181 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var Jumbotron = _react2['default'].createClass({ + displayName: 'Jumbotron', + + propTypes: { + /** + * You can use a custom element for this component + */ + componentClass: _utilsCustomPropTypes2['default'].elementType + }, + + 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']; + +/***/ }, +/* 182 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var Label = _react2['default'].createClass({ + displayName: 'Label', + + mixins: [_BootstrapMixin2['default']], + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'label', + bsStyle: 'default' + }; + }, + + render: function render() { + var classes = this.getBsClassSet(); + + return _react2['default'].createElement( + 'span', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + } + }); + + exports['default'] = Label; + module.exports = exports['default']; + +/***/ }, +/* 183 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(55); + + 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 }); + }); + + var shouldRenderDiv = false; + + if (!this.props.children) { + shouldRenderDiv = true; + } else { + _react2['default'].Children.forEach(this.props.children, function (child) { + if (_this.isAnchorOrButton(child.props)) { + shouldRenderDiv = true; + } + }); + } + + if (shouldRenderDiv) { + return this.renderDiv(items); + } else { + return this.renderUL(items); + } + }; + + ListGroup.prototype.isAnchorOrButton = function isAnchorOrButton(props) { + return props.href || props.onClick; + }; + + ListGroup.prototype.renderUL = function renderUL(items) { + var listItems = _utilsValidComponentChildren2['default'].map(items, function (item, index) { + 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.propTypes = { + className: _react2['default'].PropTypes.string, + id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]) + }; + + exports['default'] = ListGroup; + module.exports = exports['default']; + +/***/ }, +/* 184 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var ListGroupItem = _react2['default'].createClass({ + displayName: 'ListGroupItem', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + bsStyle: _react2['default'].PropTypes.oneOf(['danger', 'info', 'success', 'warning']), + 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 + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'list-group-item', + listItem: false + }; + }, + + render: function render() { + var classes = this.getBsClassSet(); + + 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); + } else { + return this.renderSpan(classes); + } + }, + + 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 + ); + }, + + 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 + ); + }, + + renderButton: function renderButton(classes) { + return _react2['default'].createElement( + 'button', + _extends({ + type: 'button' + }, this.props, { + className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + }, + + 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 + ); + }, + + renderStructuredContent: function renderStructuredContent() { + var header = undefined; + if (_react2['default'].isValidElement(this.props.header)) { + header = _react.cloneElement(this.props.header, { + key: 'header', + className: _classnames2['default'](this.props.header.props.className, 'list-group-item-heading') + }); + } else { + header = _react2['default'].createElement( + 'h4', + { key: 'header', className: 'list-group-item-heading' }, + this.props.header + ); + } + + var content = _react2['default'].createElement( + 'p', + { key: 'content', className: 'list-group-item-text' }, + this.props.children + ); + + return [header, content]; + } + }); + + exports['default'] = ListGroupItem; + module.exports = exports['default']; + +/***/ }, +/* 185 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _SafeAnchor = __webpack_require__(100); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + 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() { + 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: 'dropdown-header' }, + this.props.children + ); + } + + var classes = { + disabled: this.props.disabled + }; + + return _react2['default'].createElement( + 'li', + { role: 'presentation', + className: _classnames2['default'](this.props.className, classes), + style: this.props.style + }, + _react2['default'].createElement( + _SafeAnchor2['default'], + { + role: 'menuitem', + tabIndex: '-1', + id: this.props.id, + target: this.props.target, + title: this.props.title, + href: this.props.href || '', + onKeyDown: this.props.onKeyDown, + onClick: this.handleClick }, + this.props.children + ) + ); + }; + + return MenuItem; + })(_react2['default'].Component); + + exports['default'] = MenuItem; + + MenuItem.propTypes = { + disabled: _react2['default'].PropTypes.bool, + divider: _utilsCustomPropTypes2['default'].all([_react2['default'].PropTypes.bool, function (props, propName, componentName) { + if (props.divider && props.children) { + return new Error('Children will not be rendered for dividers'); + } + }]), + eventKey: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]), + header: _react2['default'].PropTypes.bool, + href: _react2['default'].PropTypes.string, + target: _react2['default'].PropTypes.string, + title: _react2['default'].PropTypes.string, + 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 + }; + module.exports = exports['default']; + +/***/ }, +/* 186 */ +/***/ function(module, exports, __webpack_require__) { + + /*eslint-disable react/prop-types */ + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _Object$isFrozen = __webpack_require__(187)['default']; + + var _Object$keys = __webpack_require__(1)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsDomUtils = __webpack_require__(31); + + var _utilsDomUtils2 = _interopRequireDefault(_utilsDomUtils); + + var _domHelpersUtilScrollbarSize = __webpack_require__(190); + + var _domHelpersUtilScrollbarSize2 = _interopRequireDefault(_domHelpersUtilScrollbarSize); + + var _utilsEventListener = __webpack_require__(73); + + var _utilsEventListener2 = _interopRequireDefault(_utilsEventListener); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _reactOverlaysLibPortal = __webpack_require__(191); + + var _reactOverlaysLibPortal2 = _interopRequireDefault(_reactOverlaysLibPortal); + + var _Fade = __webpack_require__(195); + + var _Fade2 = _interopRequireDefault(_Fade); + + var _ModalDialog = __webpack_require__(196); + + var _ModalDialog2 = _interopRequireDefault(_ModalDialog); + + var _ModalBody = __webpack_require__(197); + + var _ModalBody2 = _interopRequireDefault(_ModalBody); + + var _ModalHeader = __webpack_require__(198); + + var _ModalHeader2 = _interopRequireDefault(_ModalHeader); + + var _ModalTitle = __webpack_require__(199); + + var _ModalTitle2 = _interopRequireDefault(_ModalTitle); + + var _ModalFooter = __webpack_require__(200); + + var _ModalFooter2 = _interopRequireDefault(_ModalFooter); + + /** + * Gets the correct clientHeight of the modal container + * when the body/window/document you need to use the docElement clientHeight + * @param {HTMLElement} container + * @param {ReactElement|HTMLElement} context + * @return {Number} + */ + function containerClientHeight(container, context) { + var doc = _utilsDomUtils2['default'].ownerDocument(context); + + return container === doc.body || container === doc.documentElement ? doc.documentElement.clientHeight : container.clientHeight; + } + + function getContainer(context) { + return context.props.container && _react2['default'].findDOMNode(context.props.container) || _utilsDomUtils2['default'].ownerDocument(context).body; + } + + var currentFocusListener = undefined; + + /** + * 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 + * + * @param {ReactElement|HTMLElement} context + * @param {Function} handler + */ + function onFocus(context, handler) { + var doc = _utilsDomUtils2['default'].ownerDocument(context); + var useFocusin = !doc.addEventListener; + var remove = undefined; + + if (currentFocusListener) { + currentFocusListener.remove(); + } + + 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); + }; + } + + currentFocusListener = { remove: remove }; + + return currentFocusListener; + } + + var Modal = _react2['default'].createClass({ + displayName: 'Modal', + + propTypes: _extends({}, _reactOverlaysLibPortal2['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: _utilsCustomPropTypes2['default'].elementType, + + /** + * 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 + }), + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'modal', + dialogComponent: _ModalDialog2['default'], + show: false, + animation: true, + backdrop: true, + keyboard: true, + autoFocus: true, + enforceFocus: true + }; + }, + + getInitialState: function getInitialState() { + return { + exited: !this.props.show + }; + }, + + render: function render() { + var _props = this.props; + var children = _props.children; + var animation = _props.animation; + var backdrop = _props.backdrop; + + var props = _objectWithoutProperties(_props, ['children', 'animation', 'backdrop']); + + 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 = props.dialogComponent; + + var mountModal = show || animation && !this.state.exited; + if (!mountModal) { + return null; + } + + var modal = _react2['default'].createElement( + Dialog, + _extends({}, props, { + ref: this._setDialogRef, + className: _classnames2['default'](this.props.className, { 'in': show && !animation }), + onClick: backdrop === true ? this.handleBackdropClick : null }), + this.renderContent() + ); + + if (animation) { + modal = _react2['default'].createElement( + _Fade2['default'], + { + transitionAppear: true, + unmountOnExit: true, + 'in': show, + timeout: Modal.TRANSITION_DURATION, + onExit: onExit, + onExiting: onExiting, + onExited: this.handleHidden, + onEnter: onEnter, + onEntering: onEntering, + onEntered: onEntered }, + modal + ); + } + + if (backdrop) { + modal = this.renderBackdrop(modal); + } + + return _react2['default'].createElement( + _reactOverlaysLibPortal2['default'], + { container: props.container }, + modal + ); + }, + + renderContent: function renderContent() { + var _this = this; + + return _react2['default'].Children.map(this.props.children, function (child) { + // TODO: use context in 0.14 + if (child && child.type && child.type.__isModalHeader) { + return _react.cloneElement(child, { + onHide: _utilsCreateChainedFunction2['default'](_this.props.onHide, child.props.onHide) + }); + } + return child; + }); + }, + + renderBackdrop: function renderBackdrop(modal) { + var _props2 = this.props; + var animation = _props2.animation; + var bsClass = _props2.bsClass; + + var duration = Modal.BACKDROP_TRANSITION_DURATION; + + // Don't handle clicks for "static" backdrops + var onClick = this.props.backdrop === true ? this.handleBackdropClick : null; + + var backdrop = _react2['default'].createElement('div', { + ref: 'backdrop', + className: _classnames2['default'](bsClass + '-backdrop', { 'in': this.props.show && !animation }), + onClick: onClick }); + + return _react2['default'].createElement( + 'div', + { + ref: 'modal' }, + animation ? _react2['default'].createElement( + _Fade2['default'], + { transitionAppear: true, 'in': this.props.show, timeout: duration }, + backdrop + ) : backdrop, + modal + ); + }, + + _setDialogRef: function _setDialogRef(ref) { + // issue #1074 + // due to: https://github.com/facebook/react/blob/v0.13.3/src/core/ReactCompositeComponent.js#L842 + // + // when backdrop is `false` react hasn't had a chance to reassign the refs to a usable object, b/c there are no other + // "classic" refs on the component (or they haven't been processed yet) + // TODO: Remove the need for this in next breaking release + if (_Object$isFrozen(this.refs) && !_Object$keys(this.refs).length) { + this.refs = {}; + } + + this.refs.dialog = ref; + + //maintains backwards compat with older component breakdown + if (!this.props.backdrop) { + this.refs.modal = ref; + } + }, + + componentWillReceiveProps: function componentWillReceiveProps(nextProps) { + if (nextProps.show) { + this.setState({ exited: false }); + } else if (!nextProps.animation) { + // 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 animation = this.props.animation; + + if (prevProps.show && !this.props.show && !animation) { + //otherwise handleHidden will call this. + this.onHide(); + } else if (!prevProps.show && this.props.show) { + this.onShow(); + } + }, + + componentWillUnmount: function componentWillUnmount() { + if (this.props.show) { + this.onHide(); + } + }, + + onShow: function onShow() { + var _this2 = this; + + var doc = _utilsDomUtils2['default'].ownerDocument(this); + var win = _utilsDomUtils2['default'].ownerWindow(this); + + this._onDocumentKeyupListener = _utilsEventListener2['default'].listen(doc, 'keyup', this.handleDocumentKeyUp); + + this._onWindowResizeListener = _utilsEventListener2['default'].listen(win, 'resize', this.handleWindowResize); + + if (this.props.enforceFocus) { + this._onFocusinListener = onFocus(this, this.enforceFocus); + } + + var container = getContainer(this); + + container.className += container.className.length ? ' modal-open' : 'modal-open'; + + this._containerIsOverflowing = container.scrollHeight > containerClientHeight(container, this); + + this._originalPadding = container.style.paddingRight; + + if (this._containerIsOverflowing) { + container.style.paddingRight = parseInt(this._originalPadding || 0, 10) + _domHelpersUtilScrollbarSize2['default']() + 'px'; + } + + if (this.props.backdrop) { + this.iosClickHack(); + } + + this.setState(this._getStyles(), function () { + return _this2.focusModalContent(); + }); + }, + + onHide: function onHide() { + this._onDocumentKeyupListener.remove(); + this._onWindowResizeListener.remove(); + + if (this._onFocusinListener) { + this._onFocusinListener.remove(); + } + + var container = getContainer(this); + + container.style.paddingRight = this._originalPadding; + + container.className = container.className.replace(/ ?modal-open/, ''); + + this.restoreLastFocus(); + }, + + handleHidden: function handleHidden() { + this.setState({ exited: true }); + + this.onHide(); + + if (this.props.onExited) { + var _props3; + + (_props3 = this.props).onExited.apply(_props3, arguments); + } + }, + + handleBackdropClick: function handleBackdropClick(e) { + if (e.target !== e.currentTarget) { + return; + } + + this.props.onHide(); + }, + + handleDocumentKeyUp: function handleDocumentKeyUp(e) { + if (this.props.keyboard && e.keyCode === 27) { + this.props.onHide(); + } + }, + + handleWindowResize: function handleWindowResize() { + this.setState(this._getStyles()); + }, + + checkForFocus: function checkForFocus() { + if (_utilsDomUtils2['default'].canUseDom) { + this.lastFocus = _utilsDomUtils2['default'].activeElement(document); + } + }, + + focusModalContent: function focusModalContent() { + var modalContent = _react2['default'].findDOMNode(this.refs.dialog); + var current = _utilsDomUtils2['default'].activeElement(_utilsDomUtils2['default'].ownerDocument(this)); + var focusInModal = current && _utilsDomUtils2['default'].contains(modalContent, current); + + if (modalContent && this.props.autoFocus && !focusInModal) { + this.lastFocus = current; + modalContent.focus(); + } + }, + + restoreLastFocus: function restoreLastFocus() { + if (this.lastFocus && this.lastFocus.focus) { + this.lastFocus.focus(); + this.lastFocus = null; + } + }, + + enforceFocus: function enforceFocus() { + if (!this.isMounted()) { + return; + } + + var active = _utilsDomUtils2['default'].activeElement(_utilsDomUtils2['default'].ownerDocument(this)); + var modal = _react2['default'].findDOMNode(this.refs.dialog); + + if (modal && modal !== active && !_utilsDomUtils2['default'].contains(modal, active)) { + modal.focus(); + } + }, + + iosClickHack: function iosClickHack() { + // IOS only allows click events to be delegated to the document on elements + // it considers 'clickable' - anchors, buttons, etc. We fake a click handler on the + // DOM nodes themselves. Remove if handled by React: https://github.com/facebook/react/issues/1169 + _react2['default'].findDOMNode(this.refs.modal).onclick = function () {}; + _react2['default'].findDOMNode(this.refs.backdrop).onclick = function () {}; + }, + + _getStyles: function _getStyles() { + if (!_utilsDomUtils2['default'].canUseDom) { + return {}; + } + + var node = _react2['default'].findDOMNode(this.refs.modal); + var scrollHt = node.scrollHeight; + var container = getContainer(this); + var containerIsOverflowing = this._containerIsOverflowing; + var modalIsOverflowing = scrollHt > containerClientHeight(container, this); + + return { + dialogStyles: { + paddingRight: containerIsOverflowing && !modalIsOverflowing ? _domHelpersUtilScrollbarSize2['default']() : void 0, + paddingLeft: !containerIsOverflowing && 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'] = Modal; + module.exports = exports['default']; + +/***/ }, +/* 187 */ +/***/ function(module, exports, __webpack_require__) { + + module.exports = { "default": __webpack_require__(188), __esModule: true }; + +/***/ }, +/* 188 */ +/***/ function(module, exports, __webpack_require__) { + + __webpack_require__(189); + module.exports = __webpack_require__(9).Object.isFrozen; + +/***/ }, +/* 189 */ +/***/ function(module, exports, __webpack_require__) { + + // 19.1.2.12 Object.isFrozen(O) + var isObject = __webpack_require__(24); + + __webpack_require__(6)('isFrozen', function($isFrozen){ + return function isFrozen(it){ + return isObject(it) ? $isFrozen ? $isFrozen(it) : false : true; + }; + }); + +/***/ }, +/* 190 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var canUseDOM = __webpack_require__(33); + + 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; + }; + +/***/ }, +/* 191 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _reactPropTypesLibMountable = __webpack_require__(192); + + var _reactPropTypesLibMountable2 = _interopRequireDefault(_reactPropTypesLibMountable); + + var _utilsOwnerDocument = __webpack_require__(106); + + var _utilsOwnerDocument2 = _interopRequireDefault(_utilsOwnerDocument); + + var _utilsGetContainer = __webpack_require__(194); + + 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 = _react2['default'].render(overlay, this._overlayTarget); + } else { + // Unrender if the component is null for transitions to null + this._unrenderOverlay(); + this._unmountOverlayTarget(); + } + }, + + _unrenderOverlay: function _unrenderOverlay() { + if (this._overlayTarget) { + _react2['default'].unmountComponentAtNode(this._overlayTarget); + this._overlayInstance = null; + } + }, + + render: function render() { + return null; + }, + + 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 _react2['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']; + +/***/ }, +/* 192 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + var _common = __webpack_require__(193); + + /** + * 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']; + +/***/ }, +/* 193 */ +/***/ 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; + } + +/***/ }, +/* 194 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + exports['default'] = getContainer; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + function getContainer(container, defaultContainer) { + container = typeof container === 'function' ? container() : container; + return _react2['default'].findDOMNode(container) || defaultContainer; + } + + module.exports = exports['default']; + +/***/ }, +/* 195 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _reactOverlaysLibTransition = __webpack_require__(90); + + var _reactOverlaysLibTransition2 = _interopRequireDefault(_reactOverlaysLibTransition); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + 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: '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: _utilsCustomPropTypes2['default'].all([_react2['default'].PropTypes.number, function (props) { + if (props.duration != null) { + _utilsDeprecationWarning2['default']('Fade `duration`', 'the `timeout` prop'); + } + return null; + }]), + + /** + * 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']; + +/***/ }, +/* 196 */ +/***/ function(module, exports, __webpack_require__) { + + /*eslint-disable react/prop-types */ + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var ModalDialog = _react2['default'].createClass({ + displayName: 'ModalDialog', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + /** + * A Callback fired when the header closeButton or non-static backdrop is clicked. + * @type {function} + * @required + */ + onHide: _react2['default'].PropTypes.func.isRequired, + + /** + * A css class to apply to the Modal dialog DOM node. + */ + dialogClassName: _react2['default'].PropTypes.string + + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'modal', + closeButton: true + }; + }, + + render: function render() { + var modalStyle = _extends({ + display: 'block' + }, this.props.style); + var bsClass = this.props.bsClass; + var dialogClasses = this.getBsClassSet(); + + delete dialogClasses.modal; + dialogClasses[bsClass + '-dialog'] = true; + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + title: null, + tabIndex: '-1', + role: 'dialog', + style: modalStyle, + className: _classnames2['default'](this.props.className, bsClass) }), + _react2['default'].createElement( + 'div', + { className: _classnames2['default'](this.props.dialogClassName, dialogClasses) }, + _react2['default'].createElement( + 'div', + { className: bsClass + '-content', role: 'document' }, + this.props.children + ) + ) + ); + } + }); + + exports['default'] = ModalDialog; + module.exports = exports['default']; + +/***/ }, +/* 197 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + 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, this.props.modalClassName) }), + this.props.children + ); + }; + + return ModalBody; + })(_react2['default'].Component); + + ModalBody.propTypes = { + /** + * A css class applied to the Component + */ + modalClassName: _react2['default'].PropTypes.string + }; + + ModalBody.defaultProps = { + modalClassName: 'modal-body' + }; + + exports['default'] = ModalBody; + module.exports = exports['default']; + +/***/ }, +/* 198 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var ModalHeader = (function (_React$Component) { + _inherits(ModalHeader, _React$Component); + + function ModalHeader() { + _classCallCheck(this, ModalHeader); + + _React$Component.apply(this, arguments); + } + + //used in liue of parent contexts right now to auto wire the close button + + ModalHeader.prototype.render = function render() { + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, this.props.modalClassName) }), + this.props.closeButton && _react2['default'].createElement( + 'button', + { + className: 'close', + onClick: this.props.onHide }, + _react2['default'].createElement( + 'span', + { 'aria-hidden': 'true' }, + '×' + ) + ), + this.props.children + ); + }; + + return ModalHeader; + })(_react2['default'].Component); + + ModalHeader.__isModalHeader = true; + + ModalHeader.propTypes = { + /** + * The 'aria-label' attribute is used to define a string that labels the current element. + * It is used for Assistive Technology when the label text is not visible on screen. + */ + 'aria-label': _react2['default'].PropTypes.string, + + /** + * A css class applied to the Component + */ + modalClassName: _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.defaultProps = { + 'aria-label': 'Close', + modalClassName: 'modal-header', + closeButton: false + }; + + exports['default'] = ModalHeader; + module.exports = exports['default']; + +/***/ }, +/* 199 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + 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, this.props.modalClassName) }), + this.props.children + ); + }; + + return ModalTitle; + })(_react2['default'].Component); + + ModalTitle.propTypes = { + /** + * A css class applied to the Component + */ + modalClassName: _react2['default'].PropTypes.string + }; + + ModalTitle.defaultProps = { + modalClassName: 'modal-title' + }; + + exports['default'] = ModalTitle; + module.exports = exports['default']; + +/***/ }, +/* 200 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + 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, this.props.modalClassName) }), + this.props.children + ); + }; + + return ModalFooter; + })(_react2['default'].Component); + + ModalFooter.propTypes = { + /** + * A css class applied to the Component + */ + modalClassName: _react2['default'].PropTypes.string + }; + + ModalFooter.defaultProps = { + modalClassName: 'modal-footer' + }; + + exports['default'] = ModalFooter; + module.exports = exports['default']; + +/***/ }, +/* 201 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _Collapse = __webpack_require__(89); + + var _Collapse2 = _interopRequireDefault(_Collapse); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var Nav = _react2['default'].createClass({ + displayName: 'Nav', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + activeHref: _react2['default'].PropTypes.string, + activeKey: _react2['default'].PropTypes.any, + bsStyle: _react2['default'].PropTypes.oneOf(['tabs', 'pills']), + stacked: _react2['default'].PropTypes.bool, + justified: _react2['default'].PropTypes.bool, + onSelect: _react2['default'].PropTypes.func, + collapsible: _react2['default'].PropTypes.bool, + /** + * 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 + */ + ulClassName: _react2['default'].PropTypes.string, + /** + * HTML id for the inner `ul` element + */ + ulId: _react2['default'].PropTypes.string, + expanded: _react2['default'].PropTypes.bool, + navbar: _react2['default'].PropTypes.bool, + eventKey: _react2['default'].PropTypes.any, + pullRight: _react2['default'].PropTypes.bool, + right: _react2['default'].PropTypes.bool + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'nav', + collapsible: false, + expanded: true, + justified: false, + navbar: false, + pullRight: false, + right: false, + stacked: false + }; + }, + + render: function render() { + var classes = this.props.collapsible ? 'navbar-collapse' : null; + + if (this.props.navbar && !this.props.collapsible) { + return this.renderUl(); + } + + return _react2['default'].createElement( + _Collapse2['default'], + { 'in': this.props.expanded }, + _react2['default'].createElement( + 'nav', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.renderUl() + ) + ); + }, + + renderUl: function renderUl() { + var classes = this.getBsClassSet(); + + classes['nav-stacked'] = this.props.stacked; + classes['nav-justified'] = this.props.justified; + classes['navbar-nav'] = this.props.navbar; + classes['pull-right'] = this.props.pullRight; + classes['navbar-right'] = this.props.right; + + return _react2['default'].createElement( + 'ul', + _extends({}, this.props, { + role: this.props.bsStyle === 'tabs' ? 'tablist' : null, + className: _classnames2['default'](this.props.ulClassName, classes), + id: this.props.ulId, + ref: 'ul' + }), + _utilsValidComponentChildren2['default'].map(this.props.children, this.renderNavItem) + ); + }, + + 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; + }, + + 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 + }); + } + }); + + exports['default'] = Nav; + module.exports = exports['default']; + +/***/ }, +/* 202 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var Navbar = _react2['default'].createClass({ + displayName: 'Navbar', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + fixedTop: _react2['default'].PropTypes.bool, + fixedBottom: _react2['default'].PropTypes.bool, + staticTop: _react2['default'].PropTypes.bool, + inverse: _react2['default'].PropTypes.bool, + fluid: _react2['default'].PropTypes.bool, + role: _react2['default'].PropTypes.string, + /** + * You can use a custom element for this component + */ + componentClass: _utilsCustomPropTypes2['default'].elementType, + brand: _react2['default'].PropTypes.node, + toggleButton: _react2['default'].PropTypes.node, + toggleNavKey: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + onToggle: _react2['default'].PropTypes.func, + navExpanded: _react2['default'].PropTypes.bool, + defaultNavExpanded: _react2['default'].PropTypes.bool + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'navbar', + bsStyle: 'default', + role: 'navigation', + componentClass: 'nav', + fixedTop: false, + fixedBottom: false, + staticTop: false, + inverse: false, + fluid: false, + defaultNavExpanded: false + }; + }, + + getInitialState: function getInitialState() { + return { + navExpanded: this.props.defaultNavExpanded + }; + }, + + shouldComponentUpdate: function shouldComponentUpdate() { + // Defer any updates to this component during the `onSelect` handler. + return !this._isChanging; + }, + + handleToggle: function handleToggle() { + if (this.props.onToggle) { + this._isChanging = true; + this.props.onToggle(); + this._isChanging = false; + } + + this.setState({ + navExpanded: !this.state.navExpanded + }); + }, + + isNavExpanded: function isNavExpanded() { + return this.props.navExpanded != null ? this.props.navExpanded : this.state.navExpanded; + }, + + render: function render() { + var classes = this.getBsClassSet(); + var ComponentClass = this.props.componentClass; + + classes['navbar-fixed-top'] = this.props.fixedTop; + classes['navbar-fixed-bottom'] = this.props.fixedBottom; + classes['navbar-static-top'] = this.props.staticTop; + classes['navbar-inverse'] = this.props.inverse; + + return _react2['default'].createElement( + ComponentClass, + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + _react2['default'].createElement( + 'div', + { className: this.props.fluid ? 'container-fluid' : 'container' }, + this.props.brand || this.props.toggleButton || this.props.toggleNavKey != null ? this.renderHeader() : null, + _utilsValidComponentChildren2['default'].map(this.props.children, this.renderChild) + ) + ); + }, + + renderChild: function renderChild(child, index) { + return _react.cloneElement(child, { + navbar: true, + collapsible: this.props.toggleNavKey != null && this.props.toggleNavKey === child.props.eventKey, + expanded: this.props.toggleNavKey != null && this.props.toggleNavKey === child.props.eventKey && this.isNavExpanded(), + key: child.key ? child.key : index + }); + }, + + renderHeader: function renderHeader() { + var brand = undefined; + + if (this.props.brand) { + if (_react2['default'].isValidElement(this.props.brand)) { + brand = _react.cloneElement(this.props.brand, { + className: _classnames2['default'](this.props.brand.props.className, 'navbar-brand') + }); + } else { + brand = _react2['default'].createElement( + 'span', + { className: 'navbar-brand' }, + this.props.brand + ); + } + } + + return _react2['default'].createElement( + 'div', + { className: 'navbar-header' }, + brand, + this.props.toggleButton || this.props.toggleNavKey != null ? this.renderToggleButton() : null + ); + }, + + renderToggleButton: function renderToggleButton() { + var children = undefined; + + if (_react2['default'].isValidElement(this.props.toggleButton)) { + + return _react.cloneElement(this.props.toggleButton, { + className: _classnames2['default'](this.props.toggleButton.props.className, 'navbar-toggle'), + onClick: _utilsCreateChainedFunction2['default'](this.handleToggle, this.props.toggleButton.props.onClick) + }); + } + + children = this.props.toggleButton != null ? this.props.toggleButton : [_react2['default'].createElement( + 'span', + { className: 'sr-only', key: 0 }, + 'Toggle navigation' + ), _react2['default'].createElement('span', { className: 'icon-bar', key: 1 }), _react2['default'].createElement('span', { className: 'icon-bar', key: 2 }), _react2['default'].createElement('span', { className: 'icon-bar', key: 3 })]; + + return _react2['default'].createElement( + 'button', + { className: 'navbar-toggle', type: 'button', onClick: this.handleToggle }, + children + ); + } + }); + + exports['default'] = Navbar; + module.exports = exports['default']; + +/***/ }, +/* 203 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _SafeAnchor = __webpack_require__(100); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + var NavItem = _react2['default'].createClass({ + displayName: 'NavItem', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + linkId: _react2['default'].PropTypes.string, + onSelect: _react2['default'].PropTypes.func, + active: _react2['default'].PropTypes.bool, + disabled: _react2['default'].PropTypes.bool, + href: _react2['default'].PropTypes.string, + role: _react2['default'].PropTypes.string, + title: _react2['default'].PropTypes.node, + eventKey: _react2['default'].PropTypes.any, + target: _react2['default'].PropTypes.string, + 'aria-controls': _react2['default'].PropTypes.string + }, + + getDefaultProps: function getDefaultProps() { + return { + active: false, + disabled: false + }; + }, + + render: function render() { + var _props = this.props; + var role = _props.role; + var linkId = _props.linkId; + var disabled = _props.disabled; + var active = _props.active; + var href = _props.href; + var title = _props.title; + var target = _props.target; + var children = _props.children; + var ariaControls = _props['aria-controls']; + + var props = _objectWithoutProperties(_props, ['role', 'linkId', 'disabled', 'active', 'href', 'title', 'target', 'children', 'aria-controls']); + + var classes = { + active: active, + disabled: disabled + }; + var linkProps = { + role: role, + href: href, + title: title, + target: target, + id: linkId, + onClick: this.handleClick + }; + + if (!role && href === '#') { + linkProps.role = 'button'; + } + + return _react2['default'].createElement( + 'li', + _extends({}, props, { role: 'presentation', className: _classnames2['default'](props.className, classes) }), + _react2['default'].createElement( + _SafeAnchor2['default'], + _extends({}, linkProps, { 'aria-selected': active, 'aria-controls': ariaControls }), + children + ) + ); + }, + + handleClick: function handleClick(e) { + if (this.props.onSelect) { + e.preventDefault(); + + if (!this.props.disabled) { + this.props.onSelect(this.props.eventKey, this.props.href, this.props.target); + } + } + } + }); + + exports['default'] = NavItem; + module.exports = exports['default']; + +/***/ }, +/* 204 */ +/***/ function(module, exports, __webpack_require__) { + + /* eslint react/prop-types: [2, {ignore: ["container", "containerPadding", "target", "placement", "children"] }] */ + /* These properties are validated in 'Portal' and 'Position' components */ + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _reactOverlaysLibOverlay = __webpack_require__(205); + + var _reactOverlaysLibOverlay2 = _interopRequireDefault(_reactOverlaysLibOverlay); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _Fade = __webpack_require__(195); + + var _Fade2 = _interopRequireDefault(_Fade); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var Overlay = (function (_React$Component) { + _inherits(Overlay, _React$Component); + + function Overlay() { + _classCallCheck(this, Overlay); + + _React$Component.apply(this, arguments); + } + + Overlay.prototype.render = function render() { + var _props = this.props; + var child = _props.children; + var transition = _props.animation; + + var props = _objectWithoutProperties(_props, ['children', 'animation']); + + if (transition === true) { + transition = _Fade2['default']; + } + + if (!transition) { + child = _react.cloneElement(child, { + className: _classnames2['default']('in', child.props.className) + }); + } + + return _react2['default'].createElement( + _reactOverlaysLibOverlay2['default'], + _extends({}, props, { + transition: transition + }), + child + ); + }; + + return Overlay; + })(_react2['default'].Component); + + Overlay.propTypes = _extends({}, _reactOverlaysLibOverlay2['default'].propTypes, { + + /** + * Set the visibility of the Overlay + */ + show: _react2['default'].PropTypes.bool, + /** + * Specify whether the overlay should trigger onHide when the user clicks outside the overlay + */ + rootClose: _react2['default'].PropTypes.bool, + /** + * A Callback fired by the Overlay when it wishes to be hidden. + */ + onHide: _react2['default'].PropTypes.func, + + /** + * Use animation + */ + animation: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.bool, _utilsCustomPropTypes2['default'].elementType]), + + /** + * Callback fired before the Overlay transitions in + */ + onEnter: _react2['default'].PropTypes.func, + + /** + * Callback fired as the Overlay begins to transition in + */ + onEntering: _react2['default'].PropTypes.func, + + /** + * Callback fired after the Overlay finishes transitioning in + */ + onEntered: _react2['default'].PropTypes.func, + + /** + * Callback fired right before the Overlay transitions out + */ + onExit: _react2['default'].PropTypes.func, + + /** + * Callback fired as the Overlay begins to transition out + */ + onExiting: _react2['default'].PropTypes.func, + + /** + * Callback fired after the Overlay finishes transitioning out + */ + onExited: _react2['default'].PropTypes.func + }); + + Overlay.defaultProps = { + animation: _Fade2['default'], + rootClose: false, + show: false + }; + + exports['default'] = Overlay; + module.exports = exports['default']; + +/***/ }, +/* 205 */ +/***/ 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__(32); + + var _react2 = _interopRequireDefault(_react); + + var _Portal = __webpack_require__(191); + + var _Portal2 = _interopRequireDefault(_Portal); + + var _Position = __webpack_require__(206); + + var _Position2 = _interopRequireDefault(_Position); + + var _RootCloseWrapper = __webpack_require__(102); + + var _RootCloseWrapper2 = _interopRequireDefault(_RootCloseWrapper); + + var _reactPropTypesLibElementType = __webpack_require__(208); + + var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType); + + /** + * Built on top of `` and ``, the overlay component is great for custom tooltip overlays. + */ + + var Overlay = (function (_React$Component) { + function Overlay(props, context) { + _classCallCheck(this, Overlay); + + _React$Component.call(this, props, context); + + this.state = { exited: !props.show }; + this.onHiddenListener = this.handleHidden.bind(this); + } + + _inherits(Overlay, _React$Component); + + Overlay.prototype.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 }); + } + }; + + Overlay.prototype.render = function render() { + var _props = this.props; + var container = _props.container; + var containerPadding = _props.containerPadding; + var target = _props.target; + var placement = _props.placement; + var rootClose = _props.rootClose; + var children = _props.children; + var Transition = _props.transition; + + var props = _objectWithoutProperties(_props, ['container', 'containerPadding', 'target', 'placement', 'rootClose', 'children', 'transition']); + + // Don't un-render the overlay while it's transitioning out. + var mountOverlay = props.show || Transition && !this.state.exited; + if (!mountOverlay) { + // Don't bother showing anything if we don't have to. + return null; + } + + var child = children; + + // Position is be inner-most because it adds inline styles into the child, + // which the other wrappers don't forward correctly. + child = _react2['default'].createElement( + _Position2['default'], + { container: container, containerPadding: containerPadding, target: target, placement: placement }, + child + ); + + if (Transition) { + var onExit = props.onExit; + var onExiting = props.onExiting; + var onEnter = props.onEnter; + var onEntering = props.onEntering; + var onEntered = props.onEntered; + + // This animates the child node by injecting props, so it must precede + // anything that adds a wrapping div. + child = _react2['default'].createElement( + Transition, + { + 'in': props.show, + transitionAppear: true, + onExit: onExit, + onExiting: onExiting, + onExited: this.onHiddenListener, + onEnter: onEnter, + onEntering: onEntering, + onEntered: onEntered + }, + child + ); + } + + // This goes after everything else because it adds a wrapping div. + if (rootClose) { + child = _react2['default'].createElement( + _RootCloseWrapper2['default'], + { onRootClose: props.onHide }, + child + ); + } + + return _react2['default'].createElement( + _Portal2['default'], + { container: container }, + child + ); + }; + + Overlay.prototype.handleHidden = function handleHidden() { + this.setState({ exited: true }); + + if (this.props.onExited) { + var _props2; + + (_props2 = this.props).onExited.apply(_props2, arguments); + } + }; + + return Overlay; + })(_react2['default'].Component); + + Overlay.propTypes = _extends({}, _Portal2['default'].propTypes, _Position2['default'].propTypes, { + /** + * Set the visibility of the Overlay + */ + show: _react2['default'].PropTypes.bool, + /** + * Specify whether the overlay should trigger onHide when the user clicks outside the overlay + */ + rootClose: _react2['default'].PropTypes.bool, + /** + * A Callback fired by the Overlay when it wishes to be hidden. + */ + onHide: _react2['default'].PropTypes.func, + + /** + * A `` component used to animate the overlay changes visibility. + */ + transition: _reactPropTypesLibElementType2['default'], + + /** + * Callback fired before the Overlay transitions in + */ + onEnter: _react2['default'].PropTypes.func, + + /** + * Callback fired as the Overlay begins to transition in + */ + onEntering: _react2['default'].PropTypes.func, + + /** + * Callback fired after the Overlay finishes transitioning in + */ + onEntered: _react2['default'].PropTypes.func, + + /** + * Callback fired right before the Overlay transitions out + */ + onExit: _react2['default'].PropTypes.func, + + /** + * Callback fired as the Overlay begins to transition out + */ + onExiting: _react2['default'].PropTypes.func, + + /** + * Callback fired after the Overlay finishes transitioning out + */ + onExited: _react2['default'].PropTypes.func + }); + + exports['default'] = Overlay; + module.exports = exports['default']; + +/***/ }, +/* 206 */ +/***/ 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__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsOwnerDocument = __webpack_require__(106); + + var _utilsOwnerDocument2 = _interopRequireDefault(_utilsOwnerDocument); + + var _utilsGetContainer = __webpack_require__(194); + + var _utilsGetContainer2 = _interopRequireDefault(_utilsGetContainer); + + var _utilsOverlayPositionUtils = __webpack_require__(207); + + var _reactPropTypesLibMountable = __webpack_require__(192); + + var _reactPropTypesLibMountable2 = _interopRequireDefault(_reactPropTypesLibMountable); + + /** + * The Position component calulates the corrdinates for its child, to + * position it relative to a `target` component or node. Useful for creating callouts and tooltips, + * the Position component injects a `style` props with `left` and `top` values for positioning your component. + * + * It also injects "arrow" `left`, and `top` values for styling callout arrows for giving your components + * a sense of directionality. + */ + + var Position = (function (_React$Component) { + function Position(props, context) { + _classCallCheck(this, Position); + + _React$Component.call(this, props, context); + + this.state = { + positionLeft: null, + positionTop: null, + arrowOffsetLeft: null, + arrowOffsetTop: null + }; + + this._needsFlush = false; + this._lastTarget = null; + } + + _inherits(Position, _React$Component); + + Position.prototype.componentDidMount = function componentDidMount() { + this.updatePosition(); + }; + + Position.prototype.componentWillReceiveProps = function componentWillReceiveProps() { + this._needsFlush = true; + }; + + Position.prototype.componentDidUpdate = function componentDidUpdate(prevProps) { + if (this._needsFlush) { + this._needsFlush = false; + this.updatePosition(prevProps.placement !== this.props.placement); + } + }; + + Position.prototype.componentWillUnmount = function componentWillUnmount() { + // Probably not necessary, but just in case holding a reference to the + // target causes problems somewhere. + this._lastTarget = null; + }; + + Position.prototype.render = function render() { + var _props = this.props; + var children = _props.children; + var className = _props.className; + + var props = _objectWithoutProperties(_props, ['children', 'className']); + + var _state = this.state; + var positionLeft = _state.positionLeft; + var positionTop = _state.positionTop; + + var arrowPosition = _objectWithoutProperties(_state, ['positionLeft', 'positionTop']); + + var child = _react2['default'].Children.only(children); + return _react.cloneElement(child, _extends({}, props, arrowPosition, { + //do we need to also forward positionLeft and positionTop if they are set to style? + positionLeft: positionLeft, + positionTop: positionTop, + className: _classnames2['default'](className, child.props.className), + style: _extends({}, child.props.style, { + left: positionLeft, + top: positionTop + }) + })); + }; + + Position.prototype.getTargetSafe = function getTargetSafe() { + if (!this.props.target) { + return null; + } + + var target = this.props.target(this.props); + if (!target) { + // This is so we can just use === check below on all falsy targets. + return null; + } + + return target; + }; + + Position.prototype.updatePosition = function updatePosition(placementChanged) { + var target = this.getTargetSafe(); + + if (target === this._lastTarget && !placementChanged) { + return; + } + + this._lastTarget = target; + + if (!target) { + this.setState({ + positionLeft: null, + positionTop: null, + arrowOffsetLeft: null, + arrowOffsetTop: null + }); + + return; + } + + var overlay = _react2['default'].findDOMNode(this); + var container = _utilsGetContainer2['default'](this.props.container, _utilsOwnerDocument2['default'](this).body); + + this.setState(_utilsOverlayPositionUtils.calcOverlayPosition(this.props.placement, overlay, target, container, this.props.containerPadding)); + }; + + return Position; + })(_react2['default'].Component); + + Position.propTypes = { + /** + * Function mapping props to a DOM node the component is positioned next to + */ + target: _react2['default'].PropTypes.func, + /** + * "offsetParent" of the component + */ + container: _reactPropTypesLibMountable2['default'], + /** + * Minimum spacing in pixels between container border and component border + */ + containerPadding: _react2['default'].PropTypes.number, + /** + * How to position the component relative to the target + */ + placement: _react2['default'].PropTypes.oneOf(['top', 'right', 'bottom', 'left']) + }; + + Position.displayName = 'Position'; + + Position.defaultProps = { + containerPadding: 0, + placement: 'right' + }; + + exports['default'] = Position; + module.exports = exports['default']; + +/***/ }, +/* 207 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _ownerDocument = __webpack_require__(106); + + var _ownerDocument2 = _interopRequireDefault(_ownerDocument); + + var _domHelpersQueryOffset = __webpack_require__(39); + + var _domHelpersQueryOffset2 = _interopRequireDefault(_domHelpersQueryOffset); + + var _domHelpersQueryPosition = __webpack_require__(49); + + var _domHelpersQueryPosition2 = _interopRequireDefault(_domHelpersQueryPosition); + + var _domHelpersQueryScrollTop = __webpack_require__(50); + + var _domHelpersQueryScrollTop2 = _interopRequireDefault(_domHelpersQueryScrollTop); + + var utils = { + + getContainerDimensions: function getContainerDimensions(containerNode) { + var width = undefined, + height = undefined, + scroll = undefined; + + if (containerNode.tagName === 'BODY') { + width = window.innerWidth; + height = window.innerHeight; + + scroll = _domHelpersQueryScrollTop2['default'](_ownerDocument2['default'](containerNode).documentElement) || _domHelpersQueryScrollTop2['default'](containerNode); + } else { + var _getOffset = _domHelpersQueryOffset2['default'](containerNode); + + width = _getOffset.width; + height = _getOffset.height; + + scroll = _domHelpersQueryScrollTop2['default'](containerNode); + } + + return { width: width, height: height, scroll: scroll }; + }, + + getPosition: function getPosition(target, container) { + var offset = container.tagName === 'BODY' ? _domHelpersQueryOffset2['default'](target) : _domHelpersQueryPosition2['default'](target, container); + + return offset; + }, + + calcOverlayPosition: function calcOverlayPosition(placement, overlayNode, target, container, padding) { + var childOffset = utils.getPosition(target, container); + + var _getOffset2 = _domHelpersQueryOffset2['default'](overlayNode); + + var overlayHeight = _getOffset2.height; + var overlayWidth = _getOffset2.width; + + var positionLeft = undefined, + positionTop = undefined, + arrowOffsetLeft = undefined, + arrowOffsetTop = undefined; + + if (placement === 'left' || placement === 'right') { + positionTop = childOffset.top + (childOffset.height - overlayHeight) / 2; + + if (placement === 'left') { + positionLeft = childOffset.left - overlayWidth; + } else { + positionLeft = childOffset.left + childOffset.width; + } + + var topDelta = getTopDelta(positionTop, overlayHeight, container, padding); + + positionTop += topDelta; + arrowOffsetTop = 50 * (1 - 2 * topDelta / overlayHeight) + '%'; + arrowOffsetLeft = void 0; + } else if (placement === 'top' || placement === 'bottom') { + positionLeft = childOffset.left + (childOffset.width - overlayWidth) / 2; + + if (placement === 'top') { + positionTop = childOffset.top - overlayHeight; + } else { + positionTop = childOffset.top + childOffset.height; + } + + var leftDelta = getLeftDelta(positionLeft, overlayWidth, container, padding); + positionLeft += leftDelta; + arrowOffsetLeft = 50 * (1 - 2 * leftDelta / overlayWidth) + '%'; + arrowOffsetTop = void 0; + } else { + throw new Error('calcOverlayPosition(): No such placement of "' + placement + '" found.'); + } + + return { positionLeft: positionLeft, positionTop: positionTop, arrowOffsetLeft: arrowOffsetLeft, arrowOffsetTop: arrowOffsetTop }; + } + }; + + function getTopDelta(top, overlayHeight, container, padding) { + var containerDimensions = utils.getContainerDimensions(container); + var containerScroll = containerDimensions.scroll; + var containerHeight = containerDimensions.height; + + var topEdgeOffset = top - padding - containerScroll; + var bottomEdgeOffset = top + padding - containerScroll + overlayHeight; + + if (topEdgeOffset < 0) { + return -topEdgeOffset; + } else if (bottomEdgeOffset > containerHeight) { + return containerHeight - bottomEdgeOffset; + } else { + return 0; + } + } + + function getLeftDelta(left, overlayWidth, container, padding) { + var containerDimensions = utils.getContainerDimensions(container); + var containerWidth = containerDimensions.width; + + var leftEdgeOffset = left - padding; + var rightEdgeOffset = left + padding + overlayWidth; + + if (leftEdgeOffset < 0) { + return -leftEdgeOffset; + } else if (rightEdgeOffset > containerWidth) { + return containerWidth - rightEdgeOffset; + } else { + return 0; + } + } + exports['default'] = utils; + module.exports = exports['default']; + +/***/ }, +/* 208 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + exports.__esModule = true; + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _common = __webpack_require__(193); + + /** + * 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']; + +/***/ }, +/* 209 */ +/***/ function(module, exports, __webpack_require__) { + + /*eslint-disable react/prop-types */ + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _Object$keys = __webpack_require__(1)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _utilsCreateContextWrapper = __webpack_require__(210); + + var _utilsCreateContextWrapper2 = _interopRequireDefault(_utilsCreateContextWrapper); + + var _Overlay = __webpack_require__(204); + + var _Overlay2 = _interopRequireDefault(_Overlay); + + var _reactLibWarning = __webpack_require__(29); + + var _reactLibWarning2 = _interopRequireDefault(_reactLibWarning); + + var _lodashObjectPick = __webpack_require__(211); + + var _lodashObjectPick2 = _interopRequireDefault(_lodashObjectPick); + + /** + * Check if value one is inside or equal to the of value + * + * @param {string} one + * @param {string|array} of + * @returns {boolean} + */ + function isOneOf(one, of) { + if (Array.isArray(of)) { + return of.indexOf(one) >= 0; + } + return one === of; + } + + var OverlayTrigger = _react2['default'].createClass({ + displayName: 'OverlayTrigger', + + propTypes: _extends({}, _Overlay2['default'].propTypes, { + + /** + * Specify which action or actions trigger Overlay visibility + */ + trigger: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.oneOf(['click', 'hover', 'focus']), _react2['default'].PropTypes.arrayOf(_react2['default'].PropTypes.oneOf(['click', 'hover', 'focus']))]), + + /** + * A millisecond delay amount to show and hide the Overlay once triggered + */ + delay: _react2['default'].PropTypes.number, + /** + * A millisecond delay amount before showing the Overlay once triggered. + */ + delayShow: _react2['default'].PropTypes.number, + /** + * A millisecond delay amount before hiding the Overlay once triggered. + */ + delayHide: _react2['default'].PropTypes.number, + + /** + * The initial visibility state of the Overlay, for more nuanced visibility controll consider + * using the Overlay component directly. + */ + defaultOverlayShown: _react2['default'].PropTypes.bool, + + /** + * An element or text to overlay next to the target. + */ + overlay: _react2['default'].PropTypes.node.isRequired, + + /** + * @private + */ + onBlur: _react2['default'].PropTypes.func, + /** + * @private + */ + onClick: _react2['default'].PropTypes.func, + /** + * @private + */ + onFocus: _react2['default'].PropTypes.func, + /** + * @private + */ + onMouseEnter: _react2['default'].PropTypes.func, + /** + * @private + */ + onMouseLeave: _react2['default'].PropTypes.func, + + //override specific overlay props + /** + * @private + */ + target: function target() {}, + /** + * @private + */ + onHide: function onHide() {}, + /** + * @private + */ + show: function show() {} + }), + + getDefaultProps: function getDefaultProps() { + return { + defaultOverlayShown: false, + trigger: ['hover', 'focus'] + }; + }, + + getInitialState: function getInitialState() { + return { + isOverlayShown: this.props.defaultOverlayShown + }; + }, + + show: function show() { + this.setState({ + isOverlayShown: true + }); + }, + + hide: function hide() { + this.setState({ + isOverlayShown: false + }); + }, + + toggle: function toggle() { + if (this.state.isOverlayShown) { + this.hide(); + } else { + this.show(); + } + }, + + componentDidMount: function componentDidMount() { + this._mountNode = document.createElement('div'); + _react2['default'].render(this._overlay, this._mountNode); + }, + + componentWillUnmount: function componentWillUnmount() { + _react2['default'].unmountComponentAtNode(this._mountNode); + this._mountNode = null; + clearTimeout(this._hoverDelay); + }, + + componentDidUpdate: function componentDidUpdate() { + if (this._mountNode) { + _react2['default'].render(this._overlay, this._mountNode); + } + }, + + getOverlayTarget: function getOverlayTarget() { + return _react2['default'].findDOMNode(this); + }, + + getOverlay: function getOverlay() { + var overlayProps = _extends({}, _lodashObjectPick2['default'](this.props, _Object$keys(_Overlay2['default'].propTypes)), { + show: this.state.isOverlayShown, + onHide: this.hide, + target: this.getOverlayTarget, + onExit: this.props.onExit, + onExiting: this.props.onExiting, + onExited: this.props.onExited, + onEnter: this.props.onEnter, + onEntering: this.props.onEntering, + onEntered: this.props.onEntered + }); + + var overlay = _react.cloneElement(this.props.overlay, { + placement: overlayProps.placement, + container: overlayProps.container + }); + + return _react2['default'].createElement( + _Overlay2['default'], + overlayProps, + overlay + ); + }, + + render: function render() { + var trigger = _react2['default'].Children.only(this.props.children); + + var props = { + 'aria-describedby': this.props.overlay.props.id + }; + + // create in render otherwise owner is lost... + this._overlay = this.getOverlay(); + + props.onClick = _utilsCreateChainedFunction2['default'](trigger.props.onClick, this.props.onClick); + + if (isOneOf('click', this.props.trigger)) { + props.onClick = _utilsCreateChainedFunction2['default'](this.toggle, props.onClick); + } + + if (isOneOf('hover', this.props.trigger)) { + _reactLibWarning2['default'](!(this.props.trigger === 'hover'), '[react-bootstrap] Specifying only the `"hover"` trigger limits the visibilty of the overlay to just mouse users. ' + 'Consider also including the `"focus"` trigger so that touch and keyboard only users can see the overlay as well.'); + + props.onMouseOver = _utilsCreateChainedFunction2['default'](this.handleDelayedShow, this.props.onMouseOver); + props.onMouseOut = _utilsCreateChainedFunction2['default'](this.handleDelayedHide, this.props.onMouseOut); + } + + if (isOneOf('focus', this.props.trigger)) { + props.onFocus = _utilsCreateChainedFunction2['default'](this.handleDelayedShow, this.props.onFocus); + props.onBlur = _utilsCreateChainedFunction2['default'](this.handleDelayedHide, this.props.onBlur); + } + + return _react.cloneElement(trigger, props); + }, + + handleDelayedShow: function handleDelayedShow() { + var _this = this; + + if (this._hoverDelay != null) { + clearTimeout(this._hoverDelay); + this._hoverDelay = null; + return; + } + + var delay = this.props.delayShow != null ? this.props.delayShow : this.props.delay; + + if (!delay) { + this.show(); + return; + } + + this._hoverDelay = setTimeout(function () { + _this._hoverDelay = null; + _this.show(); + }, delay); + }, + + handleDelayedHide: function handleDelayedHide() { + var _this2 = this; + + if (this._hoverDelay != null) { + clearTimeout(this._hoverDelay); + this._hoverDelay = null; + return; + } + + var delay = this.props.delayHide != null ? this.props.delayHide : this.props.delay; + + if (!delay) { + this.hide(); + return; + } + + this._hoverDelay = setTimeout(function () { + _this2._hoverDelay = null; + _this2.hide(); + }, delay); + } + + }); + + /** + * Creates a new OverlayTrigger class that forwards the relevant context + * + * This static method should only be called at the module level, instead of in + * e.g. a render() method, because it's expensive to create new classes. + * + * For example, you would want to have: + * + * > export default OverlayTrigger.withContext({ + * > myContextKey: React.PropTypes.object + * > }); + * + * and import this when needed. + */ + OverlayTrigger.withContext = _utilsCreateContextWrapper2['default'](OverlayTrigger, 'overlay'); + + exports['default'] = OverlayTrigger; + module.exports = exports['default']; + +/***/ }, +/* 210 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _inherits = __webpack_require__(17)['default']; + + var _classCallCheck = __webpack_require__(28)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + exports['default'] = createContextWrapper; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + /** + * Creates new trigger class that injects context into overlay. + */ + + function createContextWrapper(Trigger, propName) { + return function (contextTypes) { + var ContextWrapper = (function (_React$Component) { + _inherits(ContextWrapper, _React$Component); + + function ContextWrapper() { + _classCallCheck(this, ContextWrapper); + + _React$Component.apply(this, arguments); + } + + ContextWrapper.prototype.getChildContext = function getChildContext() { + return this.props.context; + }; + + ContextWrapper.prototype.render = function render() { + // Strip injected props from below. + var _props = this.props; + var wrapped = _props.wrapped; + var context = _props.context; + + var props = _objectWithoutProperties(_props, ['wrapped', 'context']); + + return _react2['default'].cloneElement(wrapped, props); + }; + + return ContextWrapper; + })(_react2['default'].Component); + + ContextWrapper.childContextTypes = contextTypes; + + var TriggerWithContext = (function () { + function TriggerWithContext() { + _classCallCheck(this, TriggerWithContext); + } + + TriggerWithContext.prototype.render = function render() { + var props = _extends({}, this.props); + props[propName] = this.getWrappedOverlay(); + + return _react2['default'].createElement( + Trigger, + props, + this.props.children + ); + }; + + TriggerWithContext.prototype.getWrappedOverlay = function getWrappedOverlay() { + return _react2['default'].createElement(ContextWrapper, { + context: this.context, + wrapped: this.props[propName] + }); + }; + + return TriggerWithContext; + })(); + + TriggerWithContext.contextTypes = contextTypes; + + return TriggerWithContext; + }; + } + + module.exports = exports['default']; + +/***/ }, +/* 211 */ +/***/ function(module, exports, __webpack_require__) { + + var baseFlatten = __webpack_require__(165), + bindCallback = __webpack_require__(150), + pickByArray = __webpack_require__(167), + pickByCallback = __webpack_require__(168), + restParam = __webpack_require__(170); + + /** + * 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; + + +/***/ }, +/* 212 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var PageHeader = _react2['default'].createClass({ + displayName: 'PageHeader', + + render: function render() { + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, 'page-header') }), + _react2['default'].createElement( + 'h1', + null, + this.props.children + ) + ); + } + }); + + exports['default'] = PageHeader; + module.exports = exports['default']; + +/***/ }, +/* 213 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _SafeAnchor = __webpack_require__(100); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + var PageItem = _react2['default'].createClass({ + displayName: 'PageItem', + + propTypes: { + href: _react2['default'].PropTypes.string, + target: _react2['default'].PropTypes.string, + title: _react2['default'].PropTypes.string, + disabled: _react2['default'].PropTypes.bool, + previous: _react2['default'].PropTypes.bool, + next: _react2['default'].PropTypes.bool, + onSelect: _react2['default'].PropTypes.func, + eventKey: _react2['default'].PropTypes.any + }, + + getDefaultProps: function getDefaultProps() { + return { + disabled: false, + previous: false, + next: false + }; + }, + + render: function render() { + var classes = { + 'disabled': this.props.disabled, + 'previous': this.props.previous, + 'next': this.props.next + }; + + return _react2['default'].createElement( + 'li', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, classes) }), + _react2['default'].createElement( + _SafeAnchor2['default'], + { + href: this.props.href, + title: this.props.title, + target: this.props.target, + onClick: this.handleSelect }, + this.props.children + ) + ); + }, + + handleSelect: function handleSelect(e) { + if (this.props.onSelect || this.props.disabled) { + e.preventDefault(); + + if (!this.props.disabled) { + this.props.onSelect(this.props.eventKey, this.props.href, this.props.target); + } + } + } + }); + + exports['default'] = PageItem; + module.exports = exports['default']; + +/***/ }, +/* 214 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var Pager = _react2['default'].createClass({ + displayName: 'Pager', + + propTypes: { + onSelect: _react2['default'].PropTypes.func + }, + + render: function render() { + return _react2['default'].createElement( + 'ul', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, 'pager') }), + _utilsValidComponentChildren2['default'].map(this.props.children, this.renderPageItem) + ); + }, + + renderPageItem: function renderPageItem(child, index) { + return _react.cloneElement(child, { + onSelect: _utilsCreateChainedFunction2['default'](child.props.onSelect, this.props.onSelect), + key: child.key ? child.key : index + }); + } + }); + + exports['default'] = Pager; + module.exports = exports['default']; + +/***/ }, +/* 215 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _PaginationButton = __webpack_require__(216); + + var _PaginationButton2 = _interopRequireDefault(_PaginationButton); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var _SafeAnchor = __webpack_require__(100); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + var Pagination = _react2['default'].createClass({ + displayName: 'Pagination', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + activePage: _react2['default'].PropTypes.number, + items: _react2['default'].PropTypes.number, + maxButtons: _react2['default'].PropTypes.number, + ellipsis: _react2['default'].PropTypes.bool, + first: _react2['default'].PropTypes.bool, + last: _react2['default'].PropTypes.bool, + prev: _react2['default'].PropTypes.bool, + next: _react2['default'].PropTypes.bool, + onSelect: _react2['default'].PropTypes.func, + /** + * You can use a custom element for the buttons + */ + buttonComponentClass: _utilsCustomPropTypes2['default'].elementType + }, + + getDefaultProps: function getDefaultProps() { + return { + activePage: 1, + items: 1, + maxButtons: 0, + first: false, + last: false, + prev: false, + next: false, + ellipsis: true, + buttonComponentClass: _SafeAnchor2['default'], + bsClass: 'pagination' + }; + }, + + renderPageButtons: function renderPageButtons() { + var pageButtons = []; + var startPage = undefined, + endPage = undefined, + hasHiddenPagesAfter = undefined; + var _props = this.props; + var maxButtons = _props.maxButtons; + var activePage = _props.activePage; + var items = _props.items; + var onSelect = _props.onSelect; + var ellipsis = _props.ellipsis; + var buttonComponentClass = _props.buttonComponentClass; + + if (maxButtons) { + var hiddenPagesBefore = activePage - parseInt(maxButtons / 2, 10); + startPage = hiddenPagesBefore > 1 ? hiddenPagesBefore : 1; + hasHiddenPagesAfter = startPage + maxButtons <= items; + + if (!hasHiddenPagesAfter) { + endPage = items; + startPage = items - maxButtons + 1; + if (startPage < 1) { + startPage = 1; + } + } else { + endPage = startPage + maxButtons - 1; + } + } else { + startPage = 1; + endPage = items; + } + + for (var pagenumber = startPage; pagenumber <= endPage; pagenumber++) { + pageButtons.push(_react2['default'].createElement( + _PaginationButton2['default'], + { + key: pagenumber, + eventKey: pagenumber, + active: pagenumber === activePage, + onSelect: onSelect, + buttonComponentClass: buttonComponentClass }, + pagenumber + )); + } + + if (maxButtons && hasHiddenPagesAfter && ellipsis) { + pageButtons.push(_react2['default'].createElement( + _PaginationButton2['default'], + { + key: 'ellipsis', + disabled: true, + buttonComponentClass: buttonComponentClass }, + _react2['default'].createElement( + 'span', + { 'aria-label': 'More' }, + '...' + ) + )); + } + + return pageButtons; + }, + + renderPrev: function renderPrev() { + if (!this.props.prev) { + return null; + } + + return _react2['default'].createElement( + _PaginationButton2['default'], + { + key: 'prev', + eventKey: this.props.activePage - 1, + disabled: this.props.activePage === 1, + onSelect: this.props.onSelect, + buttonComponentClass: this.props.buttonComponentClass }, + _react2['default'].createElement( + 'span', + { 'aria-label': 'Previous' }, + '‹' + ) + ); + }, + + renderNext: function renderNext() { + if (!this.props.next) { + return null; + } + + return _react2['default'].createElement( + _PaginationButton2['default'], + { + key: 'next', + eventKey: this.props.activePage + 1, + disabled: this.props.activePage >= this.props.items, + onSelect: this.props.onSelect, + buttonComponentClass: this.props.buttonComponentClass }, + _react2['default'].createElement( + 'span', + { 'aria-label': 'Next' }, + '›' + ) + ); + }, + + renderFirst: function renderFirst() { + if (!this.props.first) { + return null; + } + + return _react2['default'].createElement( + _PaginationButton2['default'], + { + key: 'first', + eventKey: 1, + disabled: this.props.activePage === 1, + onSelect: this.props.onSelect, + buttonComponentClass: this.props.buttonComponentClass }, + _react2['default'].createElement( + 'span', + { 'aria-label': 'First' }, + '«' + ) + ); + }, + + renderLast: function renderLast() { + if (!this.props.last) { + return null; + } + + return _react2['default'].createElement( + _PaginationButton2['default'], + { + key: 'last', + eventKey: this.props.items, + disabled: this.props.activePage >= this.props.items, + onSelect: this.props.onSelect, + buttonComponentClass: this.props.buttonComponentClass }, + _react2['default'].createElement( + 'span', + { 'aria-label': 'Last' }, + '»' + ) + ); + }, + + render: function render() { + return _react2['default'].createElement( + 'ul', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, this.getBsClassSet()) }), + this.renderFirst(), + this.renderPrev(), + this.renderPageButtons(), + this.renderNext(), + this.renderLast() + ); + } + }); + + exports['default'] = Pagination; + module.exports = exports['default']; + +/***/ }, +/* 216 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _utilsCreateSelectedEvent = __webpack_require__(217); + + var _utilsCreateSelectedEvent2 = _interopRequireDefault(_utilsCreateSelectedEvent); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var PaginationButton = _react2['default'].createClass({ + displayName: 'PaginationButton', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + className: _react2['default'].PropTypes.string, + eventKey: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + onSelect: _react2['default'].PropTypes.func, + disabled: _react2['default'].PropTypes.bool, + active: _react2['default'].PropTypes.bool, + /** + * You can use a custom element for this component + */ + buttonComponentClass: _utilsCustomPropTypes2['default'].elementType + }, + + getDefaultProps: function getDefaultProps() { + return { + active: false, + disabled: false + }; + }, + + handleClick: function handleClick(event) { + if (this.props.disabled) { + return; + } + + if (this.props.onSelect) { + var selectedEvent = _utilsCreateSelectedEvent2['default'](this.props.eventKey); + this.props.onSelect(event, selectedEvent); + } + }, + + render: function render() { + var classes = _extends({ + active: this.props.active, + disabled: this.props.disabled + }, this.getBsClassSet()); + + var _props = this.props; + var className = _props.className; + + var anchorProps = _objectWithoutProperties(_props, ['className']); + + var ButtonComponentClass = this.props.buttonComponentClass; + + return _react2['default'].createElement( + 'li', + { className: _classnames2['default'](className, classes) }, + _react2['default'].createElement(ButtonComponentClass, _extends({}, anchorProps, { + onClick: this.handleClick })) + ); + } + }); + + exports['default'] = PaginationButton; + module.exports = exports['default']; + +/***/ }, +/* 217 */ +/***/ function(module, exports) { + + "use strict"; + + exports.__esModule = true; + exports["default"] = createSelectedEvent; + + function createSelectedEvent(eventKey) { + var selectionPrevented = false; + + return { + eventKey: eventKey, + + preventSelection: function preventSelection() { + selectionPrevented = true; + }, + + isSelectionPrevented: function isSelectionPrevented() { + return selectionPrevented; + } + }; + } + + module.exports = exports["default"]; + +/***/ }, +/* 218 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _Collapse = __webpack_require__(89); + + var _Collapse2 = _interopRequireDefault(_Collapse); + + var Panel = _react2['default'].createClass({ + displayName: 'Panel', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + collapsible: _react2['default'].PropTypes.bool, + onSelect: _react2['default'].PropTypes.func, + header: _react2['default'].PropTypes.node, + id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + footer: _react2['default'].PropTypes.node, + defaultExpanded: _react2['default'].PropTypes.bool, + expanded: _react2['default'].PropTypes.bool, + eventKey: _react2['default'].PropTypes.any, + headerRole: _react2['default'].PropTypes.string, + panelRole: _react2['default'].PropTypes.string + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'panel', + bsStyle: 'default', + defaultExpanded: false + }; + }, + + getInitialState: function getInitialState() { + return { + expanded: this.props.defaultExpanded + }; + }, + + handleSelect: function handleSelect(e) { + e.selected = true; + + if (this.props.onSelect) { + this.props.onSelect(e, this.props.eventKey); + } else { + e.preventDefault(); + } + + if (e.selected) { + this.handleToggle(); + } + }, + + handleToggle: function handleToggle() { + this.setState({ expanded: !this.state.expanded }); + }, + + isExpanded: function isExpanded() { + return this.props.expanded != null ? this.props.expanded : this.state.expanded; + }, + + render: function render() { + var _props = this.props; + var headerRole = _props.headerRole; + var panelRole = _props.panelRole; + + var props = _objectWithoutProperties(_props, ['headerRole', 'panelRole']); + + return _react2['default'].createElement( + 'div', + _extends({}, props, { + className: _classnames2['default'](this.props.className, this.getBsClassSet()), + id: this.props.collapsible ? null : this.props.id, onSelect: null }), + this.renderHeading(headerRole), + this.props.collapsible ? this.renderCollapsibleBody(panelRole) : this.renderBody(), + this.renderFooter() + ); + }, + + renderCollapsibleBody: function renderCollapsibleBody(panelRole) { + var props = { + className: this.prefixClass('collapse'), + id: this.props.id, + ref: 'panel', + 'aria-hidden': !this.isExpanded() + }; + if (panelRole) { + props.role = panelRole; + } + + return _react2['default'].createElement( + _Collapse2['default'], + { 'in': this.isExpanded() }, + _react2['default'].createElement( + 'div', + props, + this.renderBody() + ) + ); + }, + + renderBody: function renderBody() { + var allChildren = this.props.children; + var bodyElements = []; + var panelBodyChildren = []; + var bodyClass = this.prefixClass('body'); + + function getProps() { + return { key: bodyElements.length }; + } + + function addPanelChild(child) { + bodyElements.push(_react.cloneElement(child, getProps())); + } + + function addPanelBody(children) { + bodyElements.push(_react2['default'].createElement( + 'div', + _extends({ className: bodyClass }, getProps()), + children + )); + } + + function maybeRenderPanelBody() { + if (panelBodyChildren.length === 0) { + return; + } + + addPanelBody(panelBodyChildren); + panelBodyChildren = []; + } + + // Handle edge cases where we should not iterate through children. + if (!Array.isArray(allChildren) || allChildren.length === 0) { + if (this.shouldRenderFill(allChildren)) { + addPanelChild(allChildren); + } else { + addPanelBody(allChildren); + } + } else { + + allChildren.forEach((function (child) { + if (this.shouldRenderFill(child)) { + maybeRenderPanelBody(); + + // Separately add the filled element. + addPanelChild(child); + } else { + panelBodyChildren.push(child); + } + }).bind(this)); + + maybeRenderPanelBody(); + } + + return bodyElements; + }, + + shouldRenderFill: function shouldRenderFill(child) { + return _react2['default'].isValidElement(child) && child.props.fill != null; + }, + + renderHeading: function renderHeading(headerRole) { + var header = this.props.header; + + if (!header) { + return null; + } + + if (!_react2['default'].isValidElement(header) || Array.isArray(header)) { + header = this.props.collapsible ? this.renderCollapsibleTitle(header, headerRole) : header; + } else { + var className = _classnames2['default'](this.prefixClass('title'), header.props.className); + + if (this.props.collapsible) { + header = _react.cloneElement(header, { + className: className, + children: this.renderAnchor(header.props.children, headerRole) + }); + } else { + header = _react.cloneElement(header, { className: className }); + } + } + + return _react2['default'].createElement( + 'div', + { className: this.prefixClass('heading') }, + header + ); + }, + + renderAnchor: function renderAnchor(header, headerRole) { + return _react2['default'].createElement( + 'a', + { + href: '#' + (this.props.id || ''), + 'aria-controls': this.props.collapsible ? this.props.id : null, + className: this.isExpanded() ? null : 'collapsed', + 'aria-expanded': this.isExpanded(), + 'aria-selected': this.isExpanded(), + onClick: this.handleSelect, + role: headerRole }, + header + ); + }, + + renderCollapsibleTitle: function renderCollapsibleTitle(header, headerRole) { + return _react2['default'].createElement( + 'h4', + { className: this.prefixClass('title'), role: 'presentation' }, + this.renderAnchor(header, headerRole) + ); + }, + + renderFooter: function renderFooter() { + if (!this.props.footer) { + return null; + } + + return _react2['default'].createElement( + 'div', + { className: this.prefixClass('footer') }, + this.props.footer + ); + } + }); + + exports['default'] = Panel; + module.exports = exports['default']; + +/***/ }, +/* 219 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var Popover = _react2['default'].createClass({ + displayName: 'Popover', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + /** + * An html id attribute, necessary for accessibility + * @type {string} + * @required + */ + id: _utilsCustomPropTypes2['default'].isRequiredForA11y(_react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number])), + + /** + * Sets the direction the Popover is positioned towards. + */ + placement: _react2['default'].PropTypes.oneOf(['top', 'right', 'bottom', 'left']), + + /** + * The "left" position value for the Popover. + */ + positionLeft: _react2['default'].PropTypes.number, + /** + * The "top" position value for the Popover. + */ + positionTop: _react2['default'].PropTypes.number, + /** + * The "left" position value for the Popover arrow. + */ + arrowOffsetLeft: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]), + /** + * The "top" position value for the Popover arrow. + */ + arrowOffsetTop: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]), + /** + * Title text + */ + title: _react2['default'].PropTypes.node + }, + + getDefaultProps: function getDefaultProps() { + return { + placement: 'right' + }; + }, + + render: function render() { + var _classes; + + var classes = (_classes = { + 'popover': true + }, _classes[this.props.placement] = true, _classes); + + var style = _extends({ + 'left': this.props.positionLeft, + 'top': this.props.positionTop, + 'display': 'block' + }, this.props.style); + + // eslint-disable-line react/prop-types + var arrowStyle = { + 'left': this.props.arrowOffsetLeft, + 'top': this.props.arrowOffsetTop + }; + + return _react2['default'].createElement( + 'div', + _extends({ role: 'tooltip' }, this.props, { className: _classnames2['default'](this.props.className, classes), style: style, title: null }), + _react2['default'].createElement('div', { className: 'arrow', style: arrowStyle }), + this.props.title ? this.renderTitle() : null, + _react2['default'].createElement( + 'div', + { className: 'popover-content' }, + this.props.children + ) + ); + }, + + renderTitle: function renderTitle() { + return _react2['default'].createElement( + 'h3', + { className: 'popover-title' }, + this.props.title + ); + } + }); + + exports['default'] = Popover; + module.exports = exports['default']; + // we don't want to expose the `style` property + +/***/ }, +/* 220 */ +/***/ function(module, exports, __webpack_require__) { + + /* eslint react/prop-types: [2, {ignore: "bsStyle"}] */ + /* BootstrapMixin contains `bsStyle` type validation */ + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _Interpolate = __webpack_require__(180); + + var _Interpolate2 = _interopRequireDefault(_Interpolate); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var ProgressBar = _react2['default'].createClass({ + displayName: 'ProgressBar', + + propTypes: { + min: _react.PropTypes.number, + now: _react.PropTypes.number, + max: _react.PropTypes.number, + label: _react.PropTypes.node, + srOnly: _react.PropTypes.bool, + striped: _react.PropTypes.bool, + active: _react.PropTypes.bool, + children: onlyProgressBar, + className: _react2['default'].PropTypes.string, + interpolateClass: _react.PropTypes.node, + /** + * @private + */ + isChild: _react.PropTypes.bool + }, + + mixins: [_BootstrapMixin2['default']], + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'progress-bar', + min: 0, + max: 100, + active: false, + isChild: false, + srOnly: false, + striped: false + }; + }, + + getPercentage: function getPercentage(now, min, max) { + var roundPrecision = 1000; + return Math.round((now - min) / (max - min) * 100 * roundPrecision) / roundPrecision; + }, + + render: function render() { + if (this.props.isChild) { + return this.renderProgressBar(); + } + + var content = undefined; + + if (this.props.children) { + content = _utilsValidComponentChildren2['default'].map(this.props.children, this.renderChildBar); + } else { + content = this.renderProgressBar(); + } + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + className: _classnames2['default'](this.props.className, 'progress'), + min: null, + max: null, + label: null, + 'aria-valuetext': null + }), + content + ); + }, + + renderChildBar: function renderChildBar(child, index) { + return _react.cloneElement(child, { + isChild: true, + key: child.key ? child.key : index + }); + }, + + renderProgressBar: function renderProgressBar() { + var _props = this.props; + var className = _props.className; + var label = _props.label; + var now = _props.now; + var min = _props.min; + var max = _props.max; + + var props = _objectWithoutProperties(_props, ['className', 'label', 'now', 'min', 'max']); + + var percentage = this.getPercentage(now, min, max); + + if (typeof label === 'string') { + label = this.renderLabel(percentage); + } + + if (this.props.srOnly) { + label = _react2['default'].createElement( + 'span', + { className: 'sr-only' }, + label + ); + } + + var classes = _classnames2['default'](className, this.getBsClassSet(), { + active: this.props.active, + 'progress-bar-striped': this.props.active || this.props.striped + }); + + return _react2['default'].createElement( + 'div', + _extends({}, props, { + className: classes, + role: 'progressbar', + style: { width: percentage + '%' }, + 'aria-valuenow': this.props.now, + 'aria-valuemin': this.props.min, + 'aria-valuemax': this.props.max }), + label + ); + }, + + renderLabel: function renderLabel(percentage) { + var InterpolateClass = this.props.interpolateClass || _Interpolate2['default']; + + return _react2['default'].createElement( + InterpolateClass, + { + now: this.props.now, + min: this.props.min, + max: this.props.max, + percent: percentage, + bsStyle: this.props.bsStyle }, + this.props.label + ); + } + }); + + /** + * Custom propTypes checker + */ + function onlyProgressBar(props, propName, componentName) { + if (props[propName]) { + var _ret = (function () { + var error = undefined, + childIdentifier = undefined; + + _react2['default'].Children.forEach(props[propName], function (child) { + if (child.type !== ProgressBar) { + childIdentifier = child.type.displayName ? child.type.displayName : child.type; + error = new Error('Children of ' + componentName + ' can contain only ProgressBar components. Found ' + childIdentifier); + } + }); + + return { + v: error + }; + })(); + + if (typeof _ret === 'object') return _ret.v; + } + } + + exports['default'] = ProgressBar; + module.exports = exports['default']; + +/***/ }, +/* 221 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var Row = _react2['default'].createClass({ + displayName: 'Row', + + propTypes: { + /** + * You can use a custom element for this component + */ + componentClass: _utilsCustomPropTypes2['default'].elementType + }, + + 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, 'row') }), + this.props.children + ); + } + }); + + exports['default'] = Row; + module.exports = exports['default']; + +/***/ }, +/* 222 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsCreateChainedFunction = __webpack_require__(56); + + var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _SafeAnchor = __webpack_require__(100); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + var SubNav = _react2['default'].createClass({ + displayName: 'SubNav', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + onSelect: _react2['default'].PropTypes.func, + active: _react2['default'].PropTypes.bool, + activeHref: _react2['default'].PropTypes.string, + activeKey: _react2['default'].PropTypes.any, + disabled: _react2['default'].PropTypes.bool, + eventKey: _react2['default'].PropTypes.any, + href: _react2['default'].PropTypes.string, + title: _react2['default'].PropTypes.string, + text: _react2['default'].PropTypes.node, + target: _react2['default'].PropTypes.string + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'nav', + active: false, + disabled: false + }; + }, + + handleClick: function handleClick(e) { + if (this.props.onSelect) { + e.preventDefault(); + + if (!this.props.disabled) { + this.props.onSelect(this.props.eventKey, this.props.href, this.props.target); + } + } + }, + + isActive: function isActive() { + return this.isChildActive(this); + }, + + isChildActive: function isChildActive(child) { + if (child.props.active) { + return true; + } + + if (this.props.activeKey != null && this.props.activeKey === child.props.eventKey) { + return true; + } + + if (this.props.activeHref != null && this.props.activeHref === child.props.href) { + return true; + } + + if (child.props.children) { + var isActive = false; + + _utilsValidComponentChildren2['default'].forEach(child.props.children, function (grandchild) { + if (this.isChildActive(grandchild)) { + isActive = true; + } + }, this); + + return isActive; + } + + return false; + }, + + 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; + }, + + render: function render() { + var classes = { + 'active': this.isActive(), + 'disabled': this.props.disabled + }; + + return _react2['default'].createElement( + 'li', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + _react2['default'].createElement( + _SafeAnchor2['default'], + { + href: this.props.href, + title: this.props.title, + target: this.props.target, + onClick: this.handleClick }, + this.props.text + ), + _react2['default'].createElement( + 'ul', + { className: 'nav' }, + _utilsValidComponentChildren2['default'].map(this.props.children, this.renderNavItem) + ) + ); + }, + + renderNavItem: function renderNavItem(child, index) { + return _react.cloneElement(child, { + active: this.getChildActiveProp(child), + onSelect: _utilsCreateChainedFunction2['default'](child.props.onSelect, this.props.onSelect), + key: child.key ? child.key : index + }); + } + }); + + exports['default'] = SubNav; + module.exports = exports['default']; + +/***/ }, +/* 223 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _utilsTransitionEvents = __webpack_require__(85); + + var _utilsTransitionEvents2 = _interopRequireDefault(_utilsTransitionEvents); + + var Tab = _react2['default'].createClass({ + displayName: 'Tab', + + propTypes: { + /** + * @private + */ + active: _react2['default'].PropTypes.bool, + animation: _react2['default'].PropTypes.bool, + /** + * It is used by 'Tabs' - parent component + * @private + */ + onAnimateOutEnd: _react2['default'].PropTypes.func, + disabled: _react2['default'].PropTypes.bool, + title: _react2['default'].PropTypes.node + }, + + getDefaultProps: function getDefaultProps() { + return { + animation: true + }; + }, + + getInitialState: function getInitialState() { + return { + animateIn: false, + animateOut: false + }; + }, + + componentWillReceiveProps: function componentWillReceiveProps(nextProps) { + if (this.props.animation) { + if (!this.state.animateIn && nextProps.active && !this.props.active) { + this.setState({ + animateIn: true + }); + } else if (!this.state.animateOut && !nextProps.active && this.props.active) { + this.setState({ + animateOut: true + }); + } + } + }, + + componentDidUpdate: function componentDidUpdate() { + if (this.state.animateIn) { + setTimeout(this.startAnimateIn, 0); + } + if (this.state.animateOut) { + _utilsTransitionEvents2['default'].addEndEventListener(_react2['default'].findDOMNode(this), this.stopAnimateOut); + } + }, + + startAnimateIn: function startAnimateIn() { + if (this.isMounted()) { + this.setState({ + animateIn: false + }); + } + }, + + stopAnimateOut: function stopAnimateOut() { + if (this.isMounted()) { + this.setState({ + animateOut: false + }); + + if (this.props.onAnimateOutEnd) { + this.props.onAnimateOutEnd(); + } + } + }, + + render: function render() { + var classes = { + 'tab-pane': true, + 'fade': true, + 'active': this.props.active || this.state.animateOut, + 'in': this.props.active && !this.state.animateIn + }; + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { + title: undefined, + role: 'tabpanel', + 'aria-hidden': !this.props.active, + className: _classnames2['default'](this.props.className, classes) + }), + this.props.children + ); + } + }); + + exports['default'] = Tab; + module.exports = exports['default']; + +/***/ }, +/* 224 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _Tabs = __webpack_require__(225); + + var _Tabs2 = _interopRequireDefault(_Tabs); + + var _TabPane = __webpack_require__(226); + + var _TabPane2 = _interopRequireDefault(_TabPane); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var TabbedArea = _react2['default'].createClass({ + displayName: 'TabbedArea', + + componentWillMount: function componentWillMount() { + _utilsDeprecationWarning2['default']('TabbedArea', 'Tabs', 'https://github.com/react-bootstrap/react-bootstrap/pull/1091'); + }, + + render: function render() { + var _props = this.props; + var children = _props.children; + + var props = _objectWithoutProperties(_props, ['children']); + + var tabs = _utilsValidComponentChildren2['default'].map(children, function (child) { + var _child$props = child.props; + var title = _child$props.tab; + + var others = _objectWithoutProperties(_child$props, ['tab']); + + return _react2['default'].createElement(_TabPane2['default'], _extends({ title: title }, others)); + }); + + return _react2['default'].createElement( + _Tabs2['default'], + props, + tabs + ); + } + }); + + exports['default'] = TabbedArea; + module.exports = exports['default']; + +/***/ }, +/* 225 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _objectWithoutProperties = __webpack_require__(67)['default']; + + var _Object$keys = __webpack_require__(1)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _Col = __webpack_require__(86); + + var _Col2 = _interopRequireDefault(_Col); + + var _Grid = __webpack_require__(176); + + var _Grid2 = _interopRequireDefault(_Grid); + + var _Nav = __webpack_require__(201); + + var _Nav2 = _interopRequireDefault(_Nav); + + var _NavItem = __webpack_require__(203); + + var _NavItem2 = _interopRequireDefault(_NavItem); + + var _Row = __webpack_require__(221); + + var _Row2 = _interopRequireDefault(_Row); + + var _styleMaps = __webpack_require__(70); + + var _styleMaps2 = _interopRequireDefault(_styleMaps); + + var _utilsValidComponentChildren = __webpack_require__(55); + + var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren); + + var paneId = function paneId(props, child) { + return child.props.id ? child.props.id : props.id && props.id + '___pane___' + child.props.eventKey; + }; + var tabId = function tabId(props, child) { + return child.props.id ? child.props.id + '___tab' : props.id && props.id + '___tab___' + child.props.eventKey; + }; + + function getDefaultActiveKeyFromChildren(children) { + var defaultActiveKey = undefined; + + _utilsValidComponentChildren2['default'].forEach(children, function (child) { + if (defaultActiveKey == null) { + defaultActiveKey = child.props.eventKey; + } + }); + + return defaultActiveKey; + } + + var Tabs = _react2['default'].createClass({ + displayName: 'Tabs', + + propTypes: { + activeKey: _react2['default'].PropTypes.any, + defaultActiveKey: _react2['default'].PropTypes.any, + /** + * Navigation style for tabs + * + * If not specified, it will be treated as `'tabs'` when vertically + * positioned and `'pills'` when horizontally positioned. + */ + bsStyle: _react2['default'].PropTypes.oneOf(['tabs', 'pills']), + animation: _react2['default'].PropTypes.bool, + id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]), + onSelect: _react2['default'].PropTypes.func, + position: _react2['default'].PropTypes.oneOf(['top', 'left', 'right']), + /** + * Number of grid columns for the tabs if horizontally positioned + * + * This accepts either a single width or a mapping of size to width. + */ + tabWidth: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.object]), + /** + * Number of grid columns for the panes if horizontally positioned + * + * This accepts either a single width or a mapping of size to width. If not + * specified, it will be treated as `styleMaps.GRID_COLUMNS` minus + * `tabWidth`. + */ + paneWidth: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.object]) + }, + + getDefaultProps: function getDefaultProps() { + return { + animation: true, + tabWidth: 2, + position: 'top' + }; + }, + + getInitialState: function getInitialState() { + var defaultActiveKey = this.props.defaultActiveKey != null ? this.props.defaultActiveKey : getDefaultActiveKeyFromChildren(this.props.children); + + return { + activeKey: defaultActiveKey, + previousActiveKey: null + }; + }, + + componentWillReceiveProps: function componentWillReceiveProps(nextProps) { + var _this = this; + + if (nextProps.activeKey != null && nextProps.activeKey !== this.props.activeKey) { + (function () { + // check if the 'previousActiveKey' child still exists + var previousActiveKey = _this.props.activeKey; + _react2['default'].Children.forEach(nextProps.children, function (child) { + if (_react2['default'].isValidElement(child)) { + if (child.props.eventKey === previousActiveKey) { + _this.setState({ + previousActiveKey: previousActiveKey + }); + return; + } + } + }); + })(); + } + }, + + handlePaneAnimateOutEnd: function handlePaneAnimateOutEnd() { + this.setState({ + previousActiveKey: null + }); + }, + + render: function render() { + var _props = this.props; + var id = _props.id; + var className = _props.className; + var style = _props.style; + var position = _props.position; + var bsStyle = _props.bsStyle; + var tabWidth = _props.tabWidth; + var paneWidth = _props.paneWidth; + var children = _props.children; + + var props = _objectWithoutProperties(_props, ['id', 'className', 'style', 'position', 'bsStyle', 'tabWidth', 'paneWidth', 'children']); + + var isHorizontal = position === 'left' || position === 'right'; + + if (bsStyle == null) { + bsStyle = isHorizontal ? 'pills' : 'tabs'; + } + + var containerProps = { id: id, className: className, style: style }; + + var tabsProps = _extends({}, props, { + bsStyle: bsStyle, + stacked: isHorizontal, + activeKey: this.getActiveKey(), + onSelect: this.handleSelect, + ref: 'tabs', + role: 'tablist' + }); + var childTabs = _utilsValidComponentChildren2['default'].map(children, this.renderTab); + + var panesProps = { + className: 'tab-content', + ref: 'panes' + }; + var childPanes = _utilsValidComponentChildren2['default'].map(children, this.renderPane); + + if (isHorizontal) { + var _getColProps = this.getColProps({ tabWidth: tabWidth, paneWidth: paneWidth }); + + var tabsColProps = _getColProps.tabsColProps; + var panesColProps = _getColProps.panesColProps; + + var tabs = _react2['default'].createElement( + _Col2['default'], + _extends({ componentClass: _Nav2['default'] }, tabsProps, tabsColProps), + childTabs + ); + var panes = _react2['default'].createElement( + _Col2['default'], + _extends({}, panesProps, panesColProps), + childPanes + ); + + var body = undefined; + if (position === 'left') { + body = _react2['default'].createElement( + _Row2['default'], + containerProps, + tabs, + panes + ); + } else { + body = _react2['default'].createElement( + _Row2['default'], + containerProps, + panes, + tabs + ); + } + + return _react2['default'].createElement( + _Grid2['default'], + null, + body + ); + } else { + return _react2['default'].createElement( + 'div', + containerProps, + _react2['default'].createElement( + _Nav2['default'], + tabsProps, + childTabs + ), + _react2['default'].createElement( + 'div', + panesProps, + childPanes + ) + ); + } + }, + + getActiveKey: function getActiveKey() { + return this.props.activeKey !== undefined ? this.props.activeKey : this.state.activeKey; + }, + + renderPane: function renderPane(child, index) { + var previousActiveKey = this.state.previousActiveKey; + + var shouldPaneBeSetActive = child.props.eventKey === this.getActiveKey(); + var thereIsNoActivePane = previousActiveKey == null; + + var paneIsAlreadyActive = previousActiveKey != null && child.props.eventKey === previousActiveKey; + + return _react.cloneElement(child, { + active: shouldPaneBeSetActive && (thereIsNoActivePane || !this.props.animation), + id: paneId(this.props, child), + 'aria-labelledby': tabId(this.props, child), + key: child.key ? child.key : index, + animation: this.props.animation, + onAnimateOutEnd: paneIsAlreadyActive ? this.handlePaneAnimateOutEnd : null + }); + }, + + renderTab: function renderTab(child) { + if (child.props.title == null) { + return null; + } + + var _child$props = child.props; + var eventKey = _child$props.eventKey; + var title = _child$props.title; + var disabled = _child$props.disabled; + + return _react2['default'].createElement( + _NavItem2['default'], + { + linkId: tabId(this.props, child), + ref: 'tab' + eventKey, + 'aria-controls': paneId(this.props, child), + eventKey: eventKey, + disabled: disabled }, + title + ); + }, + + getColProps: function getColProps(_ref) { + var tabWidth = _ref.tabWidth; + var paneWidth = _ref.paneWidth; + + var tabsColProps = undefined; + if (tabWidth instanceof Object) { + tabsColProps = tabWidth; + } else { + tabsColProps = { xs: tabWidth }; + } + + var panesColProps = undefined; + if (paneWidth == null) { + panesColProps = {}; + _Object$keys(tabsColProps).forEach(function (size) { + panesColProps[size] = _styleMaps2['default'].GRID_COLUMNS - tabsColProps[size]; + }); + } else if (paneWidth instanceof Object) { + panesColProps = paneWidth; + } else { + panesColProps = { xs: paneWidth }; + } + + return { tabsColProps: tabsColProps, panesColProps: panesColProps }; + }, + + shouldComponentUpdate: function shouldComponentUpdate() { + // Defer any updates to this component during the `onSelect` handler. + return !this._isChanging; + }, + + handleSelect: function handleSelect(selectedKey) { + if (this.props.onSelect) { + this._isChanging = true; + this.props.onSelect(selectedKey); + this._isChanging = false; + return; + } + + // if there is no external handler, then use embedded one + var previousActiveKey = this.getActiveKey(); + if (selectedKey !== previousActiveKey) { + this.setState({ + activeKey: selectedKey, + previousActiveKey: previousActiveKey + }); + } + } + }); + + exports['default'] = Tabs; + module.exports = exports['default']; + +/***/ }, +/* 226 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var _Tab = __webpack_require__(223); + + var _Tab2 = _interopRequireDefault(_Tab); + + var TabPane = _react2['default'].createClass({ + displayName: 'TabPane', + + componentWillMount: function componentWillMount() { + _utilsDeprecationWarning2['default']('TabPane', 'Tab', 'https://github.com/react-bootstrap/react-bootstrap/pull/1091'); + }, + + render: function render() { + return _react2['default'].createElement(_Tab2['default'], this.props); + } + }); + + exports['default'] = TabPane; + module.exports = exports['default']; + +/***/ }, +/* 227 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var Table = _react2['default'].createClass({ + displayName: 'Table', + + propTypes: { + striped: _react2['default'].PropTypes.bool, + bordered: _react2['default'].PropTypes.bool, + condensed: _react2['default'].PropTypes.bool, + hover: _react2['default'].PropTypes.bool, + responsive: _react2['default'].PropTypes.bool + }, + + getDefaultProps: function getDefaultProps() { + return { + bordered: false, + condensed: false, + hover: false, + responsive: false, + striped: false + }; + }, + + render: function render() { + var classes = { + 'table': true, + 'table-striped': this.props.striped, + 'table-bordered': this.props.bordered, + 'table-condensed': this.props.condensed, + 'table-hover': this.props.hover + }; + var table = _react2['default'].createElement( + 'table', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + + return this.props.responsive ? _react2['default'].createElement( + 'div', + { className: 'table-responsive' }, + table + ) : table; + } + }); + + exports['default'] = Table; + module.exports = exports['default']; + +/***/ }, +/* 228 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _SafeAnchor = __webpack_require__(100); + + var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor); + + var Thumbnail = _react2['default'].createClass({ + displayName: 'Thumbnail', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + alt: _react2['default'].PropTypes.string, + href: _react2['default'].PropTypes.string, + src: _react2['default'].PropTypes.string + }, + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'thumbnail' + }; + }, + + render: function render() { + var classes = this.getBsClassSet(); + + if (this.props.href) { + return _react2['default'].createElement( + _SafeAnchor2['default'], + _extends({}, this.props, { href: this.props.href, className: _classnames2['default'](this.props.className, classes) }), + _react2['default'].createElement('img', { src: this.props.src, alt: this.props.alt }) + ); + } else { + if (this.props.children) { + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + _react2['default'].createElement('img', { src: this.props.src, alt: this.props.alt }), + _react2['default'].createElement( + 'div', + { className: 'caption' }, + this.props.children + ) + ); + } else { + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + _react2['default'].createElement('img', { src: this.props.src, alt: this.props.alt }) + ); + } + } + } + }); + + exports['default'] = Thumbnail; + module.exports = exports['default']; + +/***/ }, +/* 229 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var _utilsCustomPropTypes = __webpack_require__(53); + + var _utilsCustomPropTypes2 = _interopRequireDefault(_utilsCustomPropTypes); + + var Tooltip = _react2['default'].createClass({ + displayName: 'Tooltip', + + mixins: [_BootstrapMixin2['default']], + + propTypes: { + /** + * An html id attribute, necessary for accessibility + * @type {string} + * @required + */ + id: _utilsCustomPropTypes2['default'].isRequiredForA11y(_react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number])), + + /** + * Sets the direction the Tooltip is positioned towards. + */ + placement: _react2['default'].PropTypes.oneOf(['top', 'right', 'bottom', 'left']), + + /** + * The "left" position value for the Tooltip. + */ + positionLeft: _react2['default'].PropTypes.number, + /** + * The "top" position value for the Tooltip. + */ + positionTop: _react2['default'].PropTypes.number, + /** + * The "left" position value for the Tooltip arrow. + */ + arrowOffsetLeft: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]), + /** + * The "top" position value for the Tooltip arrow. + */ + arrowOffsetTop: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.number, _react2['default'].PropTypes.string]), + /** + * Title text + */ + title: _react2['default'].PropTypes.node + }, + + getDefaultProps: function getDefaultProps() { + return { + placement: 'right' + }; + }, + + render: function render() { + var _classes; + + var classes = (_classes = { + 'tooltip': true + }, _classes[this.props.placement] = true, _classes); + + var style = _extends({ + 'left': this.props.positionLeft, + 'top': this.props.positionTop + }, this.props.style); + + var arrowStyle = { + 'left': this.props.arrowOffsetLeft, + 'top': this.props.arrowOffsetTop + }; + + return _react2['default'].createElement( + 'div', + _extends({ role: 'tooltip' }, this.props, { className: _classnames2['default'](this.props.className, classes), style: style }), + _react2['default'].createElement('div', { className: 'tooltip-arrow', style: arrowStyle }), + _react2['default'].createElement( + 'div', + { className: 'tooltip-inner' }, + this.props.children + ) + ); + } + }); + + exports['default'] = Tooltip; + module.exports = exports['default']; + +/***/ }, +/* 230 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _extends = __webpack_require__(58)['default']; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _react = __webpack_require__(32); + + var _react2 = _interopRequireDefault(_react); + + var _classnames = __webpack_require__(68); + + var _classnames2 = _interopRequireDefault(_classnames); + + var _BootstrapMixin = __webpack_require__(69); + + var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin); + + var Well = _react2['default'].createClass({ + displayName: 'Well', + + mixins: [_BootstrapMixin2['default']], + + getDefaultProps: function getDefaultProps() { + return { + bsClass: 'well' + }; + }, + + render: function render() { + var classes = this.getBsClassSet(); + + return _react2['default'].createElement( + 'div', + _extends({}, this.props, { className: _classnames2['default'](this.props.className, classes) }), + this.props.children + ); + } + }); + + exports['default'] = Well; + module.exports = exports['default']; + +/***/ }, +/* 231 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var _reactOverlaysLibPortal = __webpack_require__(191); + + var _reactOverlaysLibPortal2 = _interopRequireDefault(_reactOverlaysLibPortal); + + exports['default'] = _utilsDeprecationWarning2['default'].wrapper(_reactOverlaysLibPortal2['default'], { + message: 'The Portal component is deprecated in react-bootstrap. It has been moved to a more generic library: react-overlays. ' + 'You can read more at: ' + 'http://react-bootstrap.github.io/react-overlays/examples/#portal and ' + 'https://github.com/react-bootstrap/react-bootstrap/issues/1084' + }); + module.exports = exports['default']; + +/***/ }, +/* 232 */ +/***/ function(module, exports, __webpack_require__) { + + 'use strict'; + + var _interopRequireDefault = __webpack_require__(14)['default']; + + exports.__esModule = true; + + var _utilsDeprecationWarning = __webpack_require__(16); + + var _utilsDeprecationWarning2 = _interopRequireDefault(_utilsDeprecationWarning); + + var _reactOverlaysLibPosition = __webpack_require__(206); + + var _reactOverlaysLibPosition2 = _interopRequireDefault(_reactOverlaysLibPosition); + + exports['default'] = _utilsDeprecationWarning2['default'].wrapper(_reactOverlaysLibPosition2['default'], { + message: 'The Position component is deprecated in react-bootstrap. It has been moved to a more generic library: react-overlays. ' + 'You can read more at: ' + 'http://react-bootstrap.github.io/react-overlays/examples/#position and ' + 'https://github.com/react-bootstrap/react-bootstrap/issues/1084' + }); + module.exports = exports['default']; + +/***/ } +/******/ ]) +}); +; \ No newline at end of file -- cgit v1.2.3-1-g7c22