couchdb-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From robertkowal...@apache.org
Subject [2/4] fauxton commit: updated refs/heads/master to 246057e
Date Wed, 21 Oct 2015 15:02:09 GMT
http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/blob/246057e6/assets/js/libs/react-bootstrap.js
----------------------------------------------------------------------
diff --git a/assets/js/libs/react-bootstrap.js b/assets/js/libs/react-bootstrap.js
new file mode 100644
index 0000000..caef22b
--- /dev/null
+++ b/assets/js/libs/react-bootstrap.js
@@ -0,0 +1,16265 @@
+(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_4__) {
+return /******/ (function(modules) { // webpackBootstrap
+/******/  // The module cache
+/******/  var installedModules = {};
+
+/******/  // The require function
+/******/  function __webpack_require__(moduleId) {
+
+/******/    // Check if module is in cache
+/******/    if(installedModules[moduleId])
+/******/      return installedModules[moduleId].exports;
+
+/******/    // Create a new module (and put it into the cache)
+/******/    var module = installedModules[moduleId] = {
+/******/      exports: {},
+/******/      id: moduleId,
+/******/      loaded: false
+/******/    };
+
+/******/    // Execute the module function
+/******/    modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+
+/******/    // Flag the module as loaded
+/******/    module.loaded = true;
+
+/******/    // Return the exports of the module
+/******/    return module.exports;
+/******/  }
+
+
+/******/  // expose the modules object (__webpack_modules__)
+/******/  __webpack_require__.m = modules;
+
+/******/  // expose the module cache
+/******/  __webpack_require__.c = installedModules;
+
+/******/  // __webpack_public_path__
+/******/  __webpack_require__.p = "";
+
+/******/  // Load entry module and return exports
+/******/  return __webpack_require__(0);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  var _interopRequireWildcard = __webpack_require__(2)['default'];
+
+  exports.__esModule = true;
+
+  var _utilsChildrenValueInputValidation = __webpack_require__(3);
+
+  var _utilsChildrenValueInputValidation2 = _interopRequireDefault(_utilsChildrenValueInputValidation);
+
+  var _utilsCreateChainedFunction = __webpack_require__(6);
+
+  var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction);
+
+  var _utilsValidComponentChildren = __webpack_require__(7);
+
+  var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren);
+
+  var _Accordion2 = __webpack_require__(8);
+
+  var _Accordion3 = _interopRequireDefault(_Accordion2);
+
+  exports.Accordion = _Accordion3['default'];
+
+  var _Affix2 = __webpack_require__(32);
+
+  var _Affix3 = _interopRequireDefault(_Affix2);
+
+  exports.Affix = _Affix3['default'];
+
+  var _AffixMixin2 = __webpack_require__(33);
+
+  var _AffixMixin3 = _interopRequireDefault(_AffixMixin2);
+
+  exports.AffixMixin = _AffixMixin3['default'];
+
+  var _Alert2 = __webpack_require__(43);
+
+  var _Alert3 = _interopRequireDefault(_Alert2);
+
+  exports.Alert = _Alert3['default'];
+
+  var _Badge2 = __webpack_require__(44);
+
+  var _Badge3 = _interopRequireDefault(_Badge2);
+
+  exports.Badge = _Badge3['default'];
+
+  var _BootstrapMixin2 = __webpack_require__(28);
+
+  var _BootstrapMixin3 = _interopRequireDefault(_BootstrapMixin2);
+
+  exports.BootstrapMixin = _BootstrapMixin3['default'];
+
+  var _Breadcrumb2 = __webpack_require__(45);
+
+  var _Breadcrumb3 = _interopRequireDefault(_Breadcrumb2);
+
+  exports.Breadcrumb = _Breadcrumb3['default'];
+
+  var _BreadcrumbItem2 = __webpack_require__(46);
+
+  var _BreadcrumbItem3 = _interopRequireDefault(_BreadcrumbItem2);
+
+  exports.BreadcrumbItem = _BreadcrumbItem3['default'];
+
+  var _Button2 = __webpack_require__(62);
+
+  var _Button3 = _interopRequireDefault(_Button2);
+
+  exports.Button = _Button3['default'];
+
+  var _ButtonGroup2 = __webpack_require__(68);
+
+  var _ButtonGroup3 = _interopRequireDefault(_ButtonGroup2);
+
+  exports.ButtonGroup = _ButtonGroup3['default'];
+
+  var _ButtonInput2 = __webpack_require__(64);
+
+  var _ButtonInput3 = _interopRequireDefault(_ButtonInput2);
+
+  exports.ButtonInput = _ButtonInput3['default'];
+
+  var _ButtonToolbar2 = __webpack_require__(70);
+
+  var _ButtonToolbar3 = _interopRequireDefault(_ButtonToolbar2);
+
+  exports.ButtonToolbar = _ButtonToolbar3['default'];
+
+  var _Carousel2 = __webpack_require__(71);
+
+  var _Carousel3 = _interopRequireDefault(_Carousel2);
+
+  exports.Carousel = _Carousel3['default'];
+
+  var _CarouselItem2 = __webpack_require__(72);
+
+  var _CarouselItem3 = _interopRequireDefault(_CarouselItem2);
+
+  exports.CarouselItem = _CarouselItem3['default'];
+
+  var _Col2 = __webpack_require__(74);
+
+  var _Col3 = _interopRequireDefault(_Col2);
+
+  exports.Col = _Col3['default'];
+
+  var _CollapsibleNav2 = __webpack_require__(79);
+
+  var _CollapsibleNav3 = _interopRequireDefault(_CollapsibleNav2);
+
+  exports.CollapsibleNav = _CollapsibleNav3['default'];
+
+  var _Dropdown2 = __webpack_require__(92);
+
+  var _Dropdown3 = _interopRequireDefault(_Dropdown2);
+
+  exports.Dropdown = _Dropdown3['default'];
+
+  var _DropdownButton2 = __webpack_require__(177);
+
+  var _DropdownButton3 = _interopRequireDefault(_DropdownButton2);
+
+  exports.DropdownButton = _DropdownButton3['default'];
+
+  var _Glyphicon2 = __webpack_require__(67);
+
+  var _Glyphicon3 = _interopRequireDefault(_Glyphicon2);
+
+  exports.Glyphicon = _Glyphicon3['default'];
+
+  var _Grid2 = __webpack_require__(178);
+
+  var _Grid3 = _interopRequireDefault(_Grid2);
+
+  exports.Grid = _Grid3['default'];
+
+  var _Image2 = __webpack_require__(179);
+
+  var _Image3 = _interopRequireDefault(_Image2);
+
+  exports.Image = _Image3['default'];
+
+  var _Input2 = __webpack_require__(180);
+
+  var _Input3 = _interopRequireDefault(_Input2);
+
+  exports.Input = _Input3['default'];
+
+  var _Interpolate2 = __webpack_require__(183);
+
+  var _Interpolate3 = _interopRequireDefault(_Interpolate2);
+
+  exports.Interpolate = _Interpolate3['default'];
+
+  var _Jumbotron2 = __webpack_require__(184);
+
+  var _Jumbotron3 = _interopRequireDefault(_Jumbotron2);
+
+  exports.Jumbotron = _Jumbotron3['default'];
+
+  var _Label2 = __webpack_require__(185);
+
+  var _Label3 = _interopRequireDefault(_Label2);
+
+  exports.Label = _Label3['default'];
+
+  var _ListGroup2 = __webpack_require__(186);
+
+  var _ListGroup3 = _interopRequireDefault(_ListGroup2);
+
+  exports.ListGroup = _ListGroup3['default'];
+
+  var _ListGroupItem2 = __webpack_require__(187);
+
+  var _ListGroupItem3 = _interopRequireDefault(_ListGroupItem2);
+
+  exports.ListGroupItem = _ListGroupItem3['default'];
+
+  var _MenuItem2 = __webpack_require__(188);
+
+  var _MenuItem3 = _interopRequireDefault(_MenuItem2);
+
+  exports.MenuItem = _MenuItem3['default'];
+
+  var _Modal2 = __webpack_require__(189);
+
+  var _Modal3 = _interopRequireDefault(_Modal2);
+
+  exports.Modal = _Modal3['default'];
+
+  var _ModalBody2 = __webpack_require__(200);
+
+  var _ModalBody3 = _interopRequireDefault(_ModalBody2);
+
+  exports.ModalBody = _ModalBody3['default'];
+
+  var _ModalFooter2 = __webpack_require__(203);
+
+  var _ModalFooter3 = _interopRequireDefault(_ModalFooter2);
+
+  exports.ModalFooter = _ModalFooter3['default'];
+
+  var _ModalHeader2 = __webpack_require__(201);
+
+  var _ModalHeader3 = _interopRequireDefault(_ModalHeader2);
+
+  exports.ModalHeader = _ModalHeader3['default'];
+
+  var _ModalTitle2 = __webpack_require__(202);
+
+  var _ModalTitle3 = _interopRequireDefault(_ModalTitle2);
+
+  exports.ModalTitle = _ModalTitle3['default'];
+
+  var _Nav2 = __webpack_require__(204);
+
+  var _Nav3 = _interopRequireDefault(_Nav2);
+
+  exports.Nav = _Nav3['default'];
+
+  var _Navbar2 = __webpack_require__(205);
+
+  var _Navbar3 = _interopRequireDefault(_Navbar2);
+
+  exports.Navbar = _Navbar3['default'];
+
+  var _NavBrand2 = __webpack_require__(206);
+
+  var _NavBrand3 = _interopRequireDefault(_NavBrand2);
+
+  exports.NavBrand = _NavBrand3['default'];
+
+  var _NavDropdown2 = __webpack_require__(207);
+
+  var _NavDropdown3 = _interopRequireDefault(_NavDropdown2);
+
+  exports.NavDropdown = _NavDropdown3['default'];
+
+  var _NavItem2 = __webpack_require__(208);
+
+  var _NavItem3 = _interopRequireDefault(_NavItem2);
+
+  exports.NavItem = _NavItem3['default'];
+
+  var _Overlay2 = __webpack_require__(209);
+
+  var _Overlay3 = _interopRequireDefault(_Overlay2);
+
+  exports.Overlay = _Overlay3['default'];
+
+  var _OverlayTrigger2 = __webpack_require__(218);
+
+  var _OverlayTrigger3 = _interopRequireDefault(_OverlayTrigger2);
+
+  exports.OverlayTrigger = _OverlayTrigger3['default'];
+
+  var _PageHeader2 = __webpack_require__(221);
+
+  var _PageHeader3 = _interopRequireDefault(_PageHeader2);
+
+  exports.PageHeader = _PageHeader3['default'];
+
+  var _PageItem2 = __webpack_require__(222);
+
+  var _PageItem3 = _interopRequireDefault(_PageItem2);
+
+  exports.PageItem = _PageItem3['default'];
+
+  var _Pager2 = __webpack_require__(223);
+
+  var _Pager3 = _interopRequireDefault(_Pager2);
+
+  exports.Pager = _Pager3['default'];
+
+  var _Pagination2 = __webpack_require__(224);
+
+  var _Pagination3 = _interopRequireDefault(_Pagination2);
+
+  exports.Pagination = _Pagination3['default'];
+
+  var _Panel2 = __webpack_require__(227);
+
+  var _Panel3 = _interopRequireDefault(_Panel2);
+
+  exports.Panel = _Panel3['default'];
+
+  var _PanelGroup2 = __webpack_require__(25);
+
+  var _PanelGroup3 = _interopRequireDefault(_PanelGroup2);
+
+  exports.PanelGroup = _PanelGroup3['default'];
+
+  var _Popover2 = __webpack_require__(228);
+
+  var _Popover3 = _interopRequireDefault(_Popover2);
+
+  exports.Popover = _Popover3['default'];
+
+  var _ProgressBar2 = __webpack_require__(229);
+
+  var _ProgressBar3 = _interopRequireDefault(_ProgressBar2);
+
+  exports.ProgressBar = _ProgressBar3['default'];
+
+  var _ResponsiveEmbed2 = __webpack_require__(230);
+
+  var _ResponsiveEmbed3 = _interopRequireDefault(_ResponsiveEmbed2);
+
+  exports.ResponsiveEmbed = _ResponsiveEmbed3['default'];
+
+  var _Row2 = __webpack_require__(231);
+
+  var _Row3 = _interopRequireDefault(_Row2);
+
+  exports.Row = _Row3['default'];
+
+  var _SafeAnchor2 = __webpack_require__(47);
+
+  var _SafeAnchor3 = _interopRequireDefault(_SafeAnchor2);
+
+  exports.SafeAnchor = _SafeAnchor3['default'];
+
+  var _SplitButton3 = __webpack_require__(232);
+
+  var _SplitButton4 = _interopRequireDefault(_SplitButton3);
+
+  exports.SplitButton = _SplitButton4['default'];
+
+  var _SplitButton5 = _interopRequireDefault(_SplitButton3);
+
+  exports.SplitButton = _SplitButton5['default'];
+
+  var _styleMaps2 = __webpack_require__(29);
+
+  var _styleMaps3 = _interopRequireDefault(_styleMaps2);
+
+  exports.styleMaps = _styleMaps3['default'];
+
+  var _SubNav2 = __webpack_require__(234);
+
+  var _SubNav3 = _interopRequireDefault(_SubNav2);
+
+  exports.SubNav = _SubNav3['default'];
+
+  var _Tab2 = __webpack_require__(235);
+
+  var _Tab3 = _interopRequireDefault(_Tab2);
+
+  exports.Tab = _Tab3['default'];
+
+  var _Table2 = __webpack_require__(236);
+
+  var _Table3 = _interopRequireDefault(_Table2);
+
+  exports.Table = _Table3['default'];
+
+  var _Tabs2 = __webpack_require__(237);
+
+  var _Tabs3 = _interopRequireDefault(_Tabs2);
+
+  exports.Tabs = _Tabs3['default'];
+
+  var _Thumbnail2 = __webpack_require__(238);
+
+  var _Thumbnail3 = _interopRequireDefault(_Thumbnail2);
+
+  exports.Thumbnail = _Thumbnail3['default'];
+
+  var _Tooltip2 = __webpack_require__(239);
+
+  var _Tooltip3 = _interopRequireDefault(_Tooltip2);
+
+  exports.Tooltip = _Tooltip3['default'];
+
+  var _Well2 = __webpack_require__(240);
+
+  var _Well3 = _interopRequireDefault(_Well2);
+
+  exports.Well = _Well3['default'];
+
+  var _Collapse2 = __webpack_require__(80);
+
+  var _Collapse3 = _interopRequireDefault(_Collapse2);
+
+  exports.Collapse = _Collapse3['default'];
+
+  var _Fade2 = __webpack_require__(198);
+
+  var _Fade3 = _interopRequireDefault(_Fade2);
+
+  exports.Fade = _Fade3['default'];
+
+  var _FormControls2 = __webpack_require__(181);
+
+  var _FormControls = _interopRequireWildcard(_FormControls2);
+
+  exports.FormControls = _FormControls;
+  var utils = {
+    childrenValueInputValidation: _utilsChildrenValueInputValidation2['default'],
+    createChainedFunction: _utilsCreateChainedFunction2['default'],
+    ValidComponentChildren: _utilsValidComponentChildren2['default']
+  };
+  exports.utils = utils;
+
+/***/ },
+/* 1 */
+/***/ function(module, exports) {
+
+  "use strict";
+
+  exports["default"] = function (obj) {
+    return obj && obj.__esModule ? obj : {
+      "default": obj
+    };
+  };
+
+  exports.__esModule = true;
+
+/***/ },
+/* 2 */
+/***/ function(module, exports) {
+
+  "use strict";
+
+  exports["default"] = function (obj) {
+    if (obj && obj.__esModule) {
+      return obj;
+    } else {
+      var newObj = {};
+
+      if (obj != null) {
+        for (var key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key];
+        }
+      }
+
+      newObj["default"] = obj;
+      return newObj;
+    }
+  };
+
+  exports.__esModule = true;
+
+/***/ },
+/* 3 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+  exports['default'] = valueValidation;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _reactPropTypesLibSinglePropFrom = __webpack_require__(5);
+
+  var _reactPropTypesLibSinglePropFrom2 = _interopRequireDefault(_reactPropTypesLibSinglePropFrom);
+
+  function valueValidation(props, propName, componentName) {
+    var error = _reactPropTypesLibSinglePropFrom2['default']('children', 'value')(props, propName, componentName);
+
+    if (!error) {
+      error = _react2['default'].PropTypes.node(props, propName, componentName);
+    }
+
+    return error;
+  }
+
+  module.exports = exports['default'];
+
+/***/ },
+/* 4 */
+/***/ function(module, exports) {
+
+  module.exports = __WEBPACK_EXTERNAL_MODULE_4__;
+
+/***/ },
+/* 5 */
+/***/ function(module, exports) {
+
+  /**
+   * Checks if only one of the listed properties is in use. An error is given
+   * if multiple have a value
+   *
+   * @param props
+   * @param propName
+   * @param componentName
+   * @returns {Error|undefined}
+   */
+  'use strict';
+
+  exports.__esModule = true;
+  exports['default'] = createSinglePropFromChecker;
+
+  function createSinglePropFromChecker() {
+    for (var _len = arguments.length, arrOfProps = Array(_len), _key = 0; _key < _len; _key++) {
+      arrOfProps[_key] = arguments[_key];
+    }
+
+    function validate(props, propName, componentName) {
+      var usedPropCount = arrOfProps.map(function (listedProp) {
+        return props[listedProp];
+      }).reduce(function (acc, curr) {
+        return acc + (curr !== undefined ? 1 : 0);
+      }, 0);
+
+      if (usedPropCount > 1) {
+        var first = arrOfProps[0];
+        var others = arrOfProps.slice(1);
+
+        var message = others.join(', ') + ' and ' + first;
+        return new Error('Invalid prop \'' + propName + '\', only one of the following ' + ('may be provided: ' + message));
+      }
+    }
+    return validate;
+  }
+
+  module.exports = exports['default'];
+
+/***/ },
+/* 6 */
+/***/ function(module, exports) {
+
+  /**
+   * Safe chained function
+   *
+   * Will only create a new function if needed,
+   * otherwise will pass back existing functions or null.
+   *
+   * @param {function} functions to chain
+   * @returns {function|null}
+   */
+  'use strict';
+
+  exports.__esModule = true;
+  function createChainedFunction() {
+    for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
+      funcs[_key] = arguments[_key];
+    }
+
+    return funcs.filter(function (f) {
+      return f != null;
+    }).reduce(function (acc, f) {
+      if (typeof f !== 'function') {
+        throw new Error('Invalid Argument Type, must only provide functions, undefined, or null.');
+      }
+
+      if (acc === null) {
+        return f;
+      }
+
+      return function chainedFunction() {
+        for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+
+        acc.apply(this, args);
+        f.apply(this, args);
+      };
+    }, null);
+  }
+
+  exports['default'] = createChainedFunction;
+  module.exports = exports['default'];
+
+/***/ },
+/* 7 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  /**
+   * Maps children that are typically specified as `props.children`,
+   * but only iterates over children that are "valid components".
+   *
+   * The mapFunction provided index will be normalised to the components mapped,
+   * so an invalid component would not increase the index.
+   *
+   * @param {?*} children Children tree container.
+   * @param {function(*, int)} mapFunction.
+   * @param {*} mapContext Context for mapFunction.
+   * @return {object} Object containing the ordered map of results.
+   */
+  function mapValidComponents(children, func, context) {
+    var index = 0;
+
+    return _react2['default'].Children.map(children, function (child) {
+      if (_react2['default'].isValidElement(child)) {
+        var lastIndex = index;
+        index++;
+        return func.call(context, child, lastIndex);
+      }
+
+      return child;
+    });
+  }
+
+  /**
+   * Iterates through children that are typically specified as `props.children`,
+   * but only iterates over children that are "valid components".
+   *
+   * The provided forEachFunc(child, index) will be called for each
+   * leaf child with the index reflecting the position relative to "valid components".
+   *
+   * @param {?*} children Children tree container.
+   * @param {function(*, int)} forEachFunc.
+   * @param {*} forEachContext Context for forEachContext.
+   */
+  function forEachValidComponents(children, func, context) {
+    var index = 0;
+
+    return _react2['default'].Children.forEach(children, function (child) {
+      if (_react2['default'].isValidElement(child)) {
+        func.call(context, child, index);
+        index++;
+      }
+    });
+  }
+
+  /**
+   * Count the number of "valid components" in the Children container.
+   *
+   * @param {?*} children Children tree container.
+   * @returns {number}
+   */
+  function numberOfValidComponents(children) {
+    var count = 0;
+
+    _react2['default'].Children.forEach(children, function (child) {
+      if (_react2['default'].isValidElement(child)) {
+        count++;
+      }
+    });
+
+    return count;
+  }
+
+  /**
+   * Determine if the Child container has one or more "valid components".
+   *
+   * @param {?*} children Children tree container.
+   * @returns {boolean}
+   */
+  function hasValidComponent(children) {
+    var hasValid = false;
+
+    _react2['default'].Children.forEach(children, function (child) {
+      if (!hasValid && _react2['default'].isValidElement(child)) {
+        hasValid = true;
+      }
+    });
+
+    return hasValid;
+  }
+
+  function find(children, finder) {
+    var child = undefined;
+
+    forEachValidComponents(children, function (c, idx) {
+      if (!child && finder(c, idx, children)) {
+        child = c;
+      }
+    });
+
+    return child;
+  }
+
+  /**
+   * Finds children that are typically specified as `props.children`,
+   * but only iterates over children that are "valid components".
+   *
+   * The provided forEachFunc(child, index) will be called for each
+   * leaf child with the index reflecting the position relative to "valid components".
+   *
+   * @param {?*} children Children tree container.
+   * @param {function(*, int)} findFunc.
+   * @param {*} findContext Context for findContext.
+   * @returns {array} of children that meet the findFunc return statement
+   */
+  function findValidComponents(children, func, context) {
+    var index = 0;
+    var returnChildren = [];
+
+    _react2['default'].Children.forEach(children, function (child) {
+      if (_react2['default'].isValidElement(child)) {
+        if (func.call(context, child, index)) {
+          returnChildren.push(child);
+        }
+        index++;
+      }
+    });
+
+    return returnChildren;
+  }
+
+  exports['default'] = {
+    map: mapValidComponents,
+    forEach: forEachValidComponents,
+    numberOf: numberOfValidComponents,
+    find: find,
+    findValidComponents: findValidComponents,
+    hasValidComponent: hasValidComponent
+  };
+  module.exports = exports['default'];
+
+/***/ },
+/* 8 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _PanelGroup = __webpack_require__(25);
+
+  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'];
+
+/***/ },
+/* 9 */
+/***/ function(module, exports, __webpack_require__) {
+
+  "use strict";
+
+  var _Object$assign = __webpack_require__(10)["default"];
+
+  exports["default"] = _Object$assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  exports.__esModule = true;
+
+/***/ },
+/* 10 */
+/***/ function(module, exports, __webpack_require__) {
+
+  module.exports = { "default": __webpack_require__(11), __esModule: true };
+
+/***/ },
+/* 11 */
+/***/ function(module, exports, __webpack_require__) {
+
+  __webpack_require__(12);
+  module.exports = __webpack_require__(15).Object.assign;
+
+/***/ },
+/* 12 */
+/***/ function(module, exports, __webpack_require__) {
+
+  // 19.1.3.1 Object.assign(target, source)
+  var $def = __webpack_require__(13);
+
+  $def($def.S + $def.F, 'Object', {assign: __webpack_require__(16)});
+
+/***/ },
+/* 13 */
+/***/ function(module, exports, __webpack_require__) {
+
+  var global    = __webpack_require__(14)
+    , core      = __webpack_require__(15)
+    , 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;
+
+/***/ },
+/* 14 */
+/***/ function(module, exports) {
+
+  // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+  var UNDEFINED = 'undefined';
+  var global = module.exports = typeof window != UNDEFINED && window.Math == Math
+    ? window : typeof self != UNDEFINED && self.Math == Math ? self : Function('return this')();
+  if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
+
+/***/ },
+/* 15 */
+/***/ function(module, exports) {
+
+  var core = module.exports = {version: '1.2.1'};
+  if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
+
+/***/ },
+/* 16 */
+/***/ function(module, exports, __webpack_require__) {
+
+  // 19.1.2.1 Object.assign(target, source, ...)
+  var toObject = __webpack_require__(17)
+    , IObject  = __webpack_require__(19)
+    , enumKeys = __webpack_require__(21)
+    , has      = __webpack_require__(23);
+
+  // should work with symbols and should have deterministic property order (V8 bug)
+  module.exports = __webpack_require__(24)(function(){
+    var a = Object.assign
+      , A = {}
+      , B = {}
+      , S = Symbol()
+      , K = 'abcdefghijklmnopqrst';
+    A[S] = 7;
+    K.split('').forEach(function(k){ B[k] = k; });
+    return a({}, A)[S] != 7 || Object.keys(a({}, B)).join('') != K;
+  }) ? function assign(target, source){   // eslint-disable-line no-unused-vars
+    var T = toObject(target)
+      , 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)if(has(S, key = keys[j++]))T[key] = S[key];
+    }
+    return T;
+  } : Object.assign;
+
+/***/ },
+/* 17 */
+/***/ function(module, exports, __webpack_require__) {
+
+  // 7.1.13 ToObject(argument)
+  var defined = __webpack_require__(18);
+  module.exports = function(it){
+    return Object(defined(it));
+  };
+
+/***/ },
+/* 18 */
+/***/ 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;
+  };
+
+/***/ },
+/* 19 */
+/***/ function(module, exports, __webpack_require__) {
+
+  // indexed object, fallback for non-array-like ES3 strings
+  var cof = __webpack_require__(20);
+  module.exports = 0 in Object('z') ? Object : function(it){
+    return cof(it) == 'String' ? it.split('') : Object(it);
+  };
+
+/***/ },
+/* 20 */
+/***/ function(module, exports) {
+
+  var toString = {}.toString;
+
+  module.exports = function(it){
+    return toString.call(it).slice(8, -1);
+  };
+
+/***/ },
+/* 21 */
+/***/ function(module, exports, __webpack_require__) {
+
+  // all enumerable object keys, includes symbols
+  var $ = __webpack_require__(22);
+  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;
+  };
+
+/***/ },
+/* 22 */
+/***/ 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
+  };
+
+/***/ },
+/* 23 */
+/***/ function(module, exports) {
+
+  var hasOwnProperty = {}.hasOwnProperty;
+  module.exports = function(it, key){
+    return hasOwnProperty.call(it, key);
+  };
+
+/***/ },
+/* 24 */
+/***/ function(module, exports) {
+
+  module.exports = function(exec){
+    try {
+      return !!exec();
+    } catch(e){
+      return true;
+    }
+  };
+
+/***/ },
+/* 25 */
+/***/ function(module, exports, __webpack_require__) {
+
+  /* eslint react/prop-types: [2, {ignore: "bsStyle"}] */
+  /* BootstrapMixin contains `bsStyle` type validation */
+
+  'use strict';
+
+  var _objectWithoutProperties = __webpack_require__(26)['default'];
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _classnames = __webpack_require__(27);
+
+  var _classnames2 = _interopRequireDefault(_classnames);
+
+  var _BootstrapMixin = __webpack_require__(28);
+
+  var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin);
+
+  var _utilsValidComponentChildren = __webpack_require__(7);
+
+  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'];
+
+/***/ },
+/* 26 */
+/***/ 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;
+
+/***/ },
+/* 27 */
+/***/ function(module, exports, __webpack_require__) {
+
+  var __WEBPACK_AMD_DEFINE_RESULT__;/*!
+    Copyright (c) 2015 Jed Watson.
+    Licensed under the MIT License (MIT), see
+    http://jedwatson.github.io/classnames
+  */
+  /* global define */
+
+  (function () {
+    'use strict';
+
+    var hasOwn = {}.hasOwnProperty;
+
+    function classNames () {
+      var classes = '';
+
+      for (var i = 0; i < arguments.length; i++) {
+        var arg = arguments[i];
+        if (!arg) continue;
+
+        var argType = typeof arg;
+
+        if (argType === 'string' || argType === 'number') {
+          classes += ' ' + arg;
+        } else if (Array.isArray(arg)) {
+          classes += ' ' + classNames.apply(null, arg);
+        } else if (argType === 'object') {
+          for (var key in arg) {
+            if (hasOwn.call(arg, key) && arg[key]) {
+              classes += ' ' + key;
+            }
+          }
+        }
+      }
+
+      return classes.substr(1);
+    }
+
+    if (typeof module !== 'undefined' && module.exports) {
+      module.exports = classNames;
+    } else if (true) {
+      // register as 'classnames', consistent with npm package name
+      !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
+        return classNames;
+      }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+    } else {
+      window.classNames = classNames;
+    }
+  }());
+
+
+/***/ },
+/* 28 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _styleMaps = __webpack_require__(29);
+
+  var _styleMaps2 = _interopRequireDefault(_styleMaps);
+
+  var _reactPropTypesLibKeyOf = __webpack_require__(30);
+
+  var _reactPropTypesLibKeyOf2 = _interopRequireDefault(_reactPropTypesLibKeyOf);
+
+  var BootstrapMixin = {
+    propTypes: {
+      /**
+       * bootstrap className
+       * @private
+       */
+      bsClass: _reactPropTypesLibKeyOf2['default'](_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: _reactPropTypesLibKeyOf2['default'](_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'];
+
+/***/ },
+/* 29 */
+/***/ 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'];
+
+/***/ },
+/* 30 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  exports.__esModule = true;
+  exports['default'] = keyOf;
+
+  var _common = __webpack_require__(31);
+
+  /**
+   * Checks whether a prop matches a key of an associated object
+   *
+   * @param props
+   * @param propName
+   * @param componentName
+   * @returns {Error|undefined}
+   */
+
+  function keyOf(obj) {
+    function validate(props, propName, componentName) {
+      var propValue = props[propName];
+      if (!obj.hasOwnProperty(propValue)) {
+        var valuesString = JSON.stringify(Object.keys(obj));
+        return new Error(_common.errMsg(props, propName, componentName, ', expected one of ' + valuesString + '.'));
+      }
+    }
+    return _common.createChainableTypeChecker(validate);
+  }
+
+  module.exports = exports['default'];
+
+/***/ },
+/* 31 */
+/***/ 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 || '<<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;
+  }
+
+/***/ },
+/* 32 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _classnames = __webpack_require__(27);
+
+  var _classnames2 = _interopRequireDefault(_classnames);
+
+  var _AffixMixin = __webpack_require__(33);
+
+  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
+
+/***/ },
+/* 33 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _utilsDomUtils = __webpack_require__(34);
+
+  var _utilsDomUtils2 = _interopRequireDefault(_utilsDomUtils);
+
+  var _domHelpersQueryOffset = __webpack_require__(38);
+
+  var _domHelpersQueryOffset2 = _interopRequireDefault(_domHelpersQueryOffset);
+
+  var _utilsEventListener = __webpack_require__(42);
+
+  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 = _domHelpersQueryOffset2['default'](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 = _domHelpersQueryOffset2['default'](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 - _domHelpersQueryOffset2['default'](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'];
+
+/***/ },
+/* 34 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _domHelpersOwnerDocument = __webpack_require__(35);
+
+  var _domHelpersOwnerDocument2 = _interopRequireDefault(_domHelpersOwnerDocument);
+
+  var _domHelpersOwnerWindow = __webpack_require__(36);
+
+  var _domHelpersOwnerWindow2 = _interopRequireDefault(_domHelpersOwnerWindow);
+
+  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);
+  }
+
+  /**
+   * 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'] = {
+    ownerWindow: ownerWindow,
+    ownerDocument: ownerDocument,
+    getDocumentHeight: getDocumentHeight,
+    getSize: getSize
+  };
+  module.exports = exports['default'];
+
+/***/ },
+/* 35 */
+/***/ function(module, exports) {
+
+  "use strict";
+
+  exports.__esModule = true;
+  exports["default"] = ownerDocument;
+
+  function ownerDocument(node) {
+    return node && node.ownerDocument || document;
+  }
+
+  module.exports = exports["default"];
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var babelHelpers = __webpack_require__(37);
+
+  exports.__esModule = true;
+  exports['default'] = ownerWindow;
+
+  var _ownerDocument = __webpack_require__(35);
+
+  var _ownerDocument2 = babelHelpers.interopRequireDefault(_ownerDocument);
+
+  function ownerWindow(node) {
+    var doc = (0, _ownerDocument2['default'])(node);
+    return doc && doc.defaultView || doc.parentWindow;
+  }
+
+  module.exports = exports['default'];
+
+/***/ },
+/* 37 */
+/***/ 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;
+    };
+  })
+
+/***/ },
+/* 38 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+  var contains = __webpack_require__(39),
+      getWindow = __webpack_require__(41),
+      ownerDocument = __webpack_require__(35);
+
+  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;
+  };
+
+/***/ },
+/* 39 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+  var canUseDOM = __webpack_require__(40);
+
+  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;
+
+/***/ },
+/* 40 */
+/***/ function(module, exports) {
+
+  'use strict';
+  module.exports = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
+
+/***/ },
+/* 41 */
+/***/ function(module, exports) {
+
+  'use strict';
+
+  module.exports = function getWindow(node) {
+    return node === node.window ? node : node.nodeType === 9 ? node.defaultView || node.parentWindow : false;
+  };
+
+/***/ },
+/* 42 */
+/***/ 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'];
+
+/***/ },
+/* 43 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _classnames = __webpack_require__(27);
+
+  var _classnames2 = _interopRequireDefault(_classnames);
+
+  var _BootstrapMixin = __webpack_require__(28);
+
+  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',
+          onClick: this.props.onDismiss,
+          'aria-hidden': 'true' },
+        _react2['default'].createElement(
+          'span',
+          null,
+          '×'
+        )
+      );
+    },
+
+    renderSrOnlyDismissButton: function renderSrOnlyDismissButton() {
+      return _react2['default'].createElement(
+        'button',
+        {
+          type: 'button',
+          className: 'close sr-only',
+          onClick: this.props.onDismiss },
+        this.props.closeLabel
+      );
+    },
+
+    render: function render() {
+      var classes = 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,
+        isDismissable ? this.renderSrOnlyDismissButton() : null
+      );
+    },
+
+    componentDidMount: function componentDidMount() {
+      if (this.props.dismissAfter && this.props.onDismiss) {
+        this.dismissTimer = setTimeout(this.props.onDismiss, this.props.dismissAfter);
+      }
+    },
+
+    componentWillUnmount: function componentWillUnmount() {
+      clearTimeout(this.dismissTimer);
+    }
+  });
+
+  exports['default'] = Alert;
+  module.exports = exports['default'];
+
+/***/ },
+/* 44 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _utilsValidComponentChildren = __webpack_require__(7);
+
+  var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren);
+
+  var _classnames = __webpack_require__(27);
+
+  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'];
+
+/***/ },
+/* 45 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _objectWithoutProperties = __webpack_require__(26)['default'];
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _classnames = __webpack_require__(27);
+
+  var _classnames2 = _interopRequireDefault(_classnames);
+
+  var _utilsValidComponentChildren = __webpack_require__(7);
+
+  var _utilsValidComponentChildren2 = _interopRequireDefault(_utilsValidComponentChildren);
+
+  var Breadcrumb = _react2['default'].createClass({
+    displayName: 'Breadcrumb',
+
+    propTypes: {
+      /**
+       * bootstrap className
+       * @private
+       */
+      bsClass: _react2['default'].PropTypes.string
+    },
+
+    getDefaultProps: function getDefaultProps() {
+      return {
+        bsClass: 'breadcrumb'
+      };
+    },
+
+    render: function render() {
+      var _props = this.props;
+      var className = _props.className;
+
+      var props = _objectWithoutProperties(_props, ['className']);
+
+      return _react2['default'].createElement(
+        'ol',
+        _extends({}, props, {
+          role: 'navigation',
+          'aria-label': 'breadcrumbs',
+          className: _classnames2['default'](className, this.props.bsClass) }),
+        _utilsValidComponentChildren2['default'].map(this.props.children, this.renderBreadcrumbItem)
+      );
+    },
+
+    renderBreadcrumbItem: function renderBreadcrumbItem(child, index) {
+      return _react.cloneElement(child, { key: child.key ? child.key : index });
+    }
+  });
+
+  exports['default'] = Breadcrumb;
+  module.exports = exports['default'];
+
+/***/ },
+/* 46 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _objectWithoutProperties = __webpack_require__(26)['default'];
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _classnames = __webpack_require__(27);
+
+  var _classnames2 = _interopRequireDefault(_classnames);
+
+  var _SafeAnchor = __webpack_require__(47);
+
+  var _SafeAnchor2 = _interopRequireDefault(_SafeAnchor);
+
+  var _reactLibWarning = __webpack_require__(60);
+
+  var _reactLibWarning2 = _interopRequireDefault(_reactLibWarning);
+
+  var BreadcrumbItem = _react2['default'].createClass({
+    displayName: 'BreadcrumbItem',
+
+    propTypes: {
+      /**
+       * If set to true, renders `span` instead of `a`
+       */
+      active: _react2['default'].PropTypes.bool,
+      /**
+       * HTML id for the wrapper `li` element
+       */
+      id: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]),
+      /**
+       * HTML id for the inner `a` element
+       */
+      linkId: _react2['default'].PropTypes.oneOfType([_react2['default'].PropTypes.string, _react2['default'].PropTypes.number]),
+      /**
+       * `href` attribute for the inner `a` element
+       */
+      href: _react2['default'].PropTypes.string,
+      /**
+       * `title` attribute for the inner `a` element
+       */
+      title: _react2['default'].PropTypes.node,
+      /**
+       * `target` attribute for the inner `a` element
+       */
+      target: _react2['default'].PropTypes.string
+    },
+
+    getDefaultProps: function getDefaultProps() {
+      return {
+        active: false
+      };
+    },
+
+    render: function render() {
+      var _props = this.props;
+      var active = _props.active;
+      var className = _props.className;
+      var id = _props.id;
+      var linkId = _props.linkId;
+      var children = _props.children;
+      var href = _props.href;
+      var title = _props.title;
+      var target = _props.target;
+
+      var props = _objectWithoutProperties(_props, ['active', 'className', 'id', 'linkId', 'children', 'href', 'title', 'target']);
+
+      _reactLibWarning2['default'](!(href && active), '[react-bootstrap] `href` and `active` properties cannot be set at the same time');
+
+      var linkProps = {
+        href: href,
+        title: title,
+        target: target,
+        id: linkId
+      };
+
+      return _react2['default'].createElement(
+        'li',
+        { id: id, className: _classnames2['default'](className, { active: active }) },
+        active ? _react2['default'].createElement(
+          'span',
+          props,
+          children
+        ) : _react2['default'].createElement(
+          _SafeAnchor2['default'],
+          _extends({}, props, linkProps),
+          children
+        )
+      );
+    }
+  });
+
+  exports['default'] = BreadcrumbItem;
+  module.exports = exports['default'];
+
+/***/ },
+/* 47 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _inherits = __webpack_require__(48)['default'];
+
+  var _classCallCheck = __webpack_require__(59)['default'];
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _utilsCreateChainedFunction = __webpack_require__(6);
+
+  var _utilsCreateChainedFunction2 = _interopRequireDefault(_utilsCreateChainedFunction);
+
+  /**
+   * Note: This is intended as a stop-gap for accessibility concerns that the
+   * Bootstrap CSS does not address as they have styled anchors and not buttons
+   * in many cases.
+   */
+
+  var SafeAnchor = (function (_React$Component) {
+    _inherits(SafeAnchor, _React$Component);
+
+    function SafeAnchor(props) {
+      _classCallCheck(this, SafeAnchor);
+
+      _React$Component.call(this, props);
+
+      this.handleClick = this.handleClick.bind(this);
+    }
+
+    SafeAnchor.prototype.handleClick = function handleClick(event) {
+      if (this.props.href === undefined) {
+        event.preventDefault();
+      }
+    };
+
+    SafeAnchor.prototype.render = function render() {
+      return _react2['default'].createElement('a', _extends({ role: this.props.href ? undefined : 'button'
+      }, this.props, {
+        onClick: _utilsCreateChainedFunction2['default'](this.props.onClick, this.handleClick),
+        href: this.props.href || '' }));
+    };
+
+    return SafeAnchor;
+  })(_react2['default'].Component);
+
+  exports['default'] = SafeAnchor;
+
+  SafeAnchor.propTypes = {
+    href: _react2['default'].PropTypes.string,
+    onClick: _react2['default'].PropTypes.func
+  };
+  module.exports = exports['default'];
+
+/***/ },
+/* 48 */
+/***/ function(module, exports, __webpack_require__) {
+
+  "use strict";
+
+  var _Object$create = __webpack_require__(49)["default"];
+
+  var _Object$setPrototypeOf = __webpack_require__(51)["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;
+
+/***/ },
+/* 49 */
+/***/ function(module, exports, __webpack_require__) {
+
+  module.exports = { "default": __webpack_require__(50), __esModule: true };
+
+/***/ },
+/* 50 */
+/***/ function(module, exports, __webpack_require__) {
+
+  var $ = __webpack_require__(22);
+  module.exports = function create(P, D){
+    return $.create(P, D);
+  };
+
+/***/ },
+/* 51 */
+/***/ function(module, exports, __webpack_require__) {
+
+  module.exports = { "default": __webpack_require__(52), __esModule: true };
+
+/***/ },
+/* 52 */
+/***/ function(module, exports, __webpack_require__) {
+
+  __webpack_require__(53);
+  module.exports = __webpack_require__(15).Object.setPrototypeOf;
+
+/***/ },
+/* 53 */
+/***/ function(module, exports, __webpack_require__) {
+
+  // 19.1.3.19 Object.setPrototypeOf(O, proto)
+  var $def = __webpack_require__(13);
+  $def($def.S, 'Object', {setPrototypeOf: __webpack_require__(54).set});
+
+/***/ },
+/* 54 */
+/***/ 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__(22).getDesc
+    , isObject = __webpack_require__(55)
+    , anObject = __webpack_require__(56);
+  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 no-proto
+      function(test, buggy, set){
+        try {
+          set = __webpack_require__(57)(Function.call, getDesc(Object.prototype, '__proto__').set, 2);
+          set(test, []);
+          buggy = !(test instanceof Array);
+        } catch(e){ buggy = true; }
+        return function setPrototypeOf(O, proto){
+          check(O, proto);
+          if(buggy)O.__proto__ = proto;
+          else set(O, proto);
+          return O;
+        };
+      }({}, false) : undefined),
+    check: check
+  };
+
+/***/ },
+/* 55 */
+/***/ function(module, exports) {
+
+  module.exports = function(it){
+    return typeof it === 'object' ? it !== null : typeof it === 'function';
+  };
+
+/***/ },
+/* 56 */
+/***/ function(module, exports, __webpack_require__) {
+
+  var isObject = __webpack_require__(55);
+  module.exports = function(it){
+    if(!isObject(it))throw TypeError(it + ' is not an object!');
+    return it;
+  };
+
+/***/ },
+/* 57 */
+/***/ function(module, exports, __webpack_require__) {
+
+  // optional / simple context binding
+  var aFunction = __webpack_require__(58);
+  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);
+    };
+  };
+
+/***/ },
+/* 58 */
+/***/ function(module, exports) {
+
+  module.exports = function(it){
+    if(typeof it != 'function')throw TypeError(it + ' is not a function!');
+    return it;
+  };
+
+/***/ },
+/* 59 */
+/***/ 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;
+
+/***/ },
+/* 60 */
+/***/ 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__(61);
+
+  /**
+   * 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;
+
+
+/***/ },
+/* 61 */
+/***/ 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;
+
+
+/***/ },
+/* 62 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _classnames = __webpack_require__(27);
+
+  var _classnames2 = _interopRequireDefault(_classnames);
+
+  var _BootstrapMixin = __webpack_require__(28);
+
+  var _BootstrapMixin2 = _interopRequireDefault(_BootstrapMixin);
+
+  var _reactPropTypesLibElementType = __webpack_require__(63);
+
+  var _reactPropTypesLibElementType2 = _interopRequireDefault(_reactPropTypesLibElementType);
+
+  var _ButtonInput = __webpack_require__(64);
+
+  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: _reactPropTypesLibElementType2['default'],
+      href: _react2['default'].PropTypes.string,
+      target: _react2['default'].PropTypes.string,
+      /**
+       * Defines HTML button type Attribute
+       * @type {("button"|"reset"|"submit")}
+       * @defaultValue 'button'
+       */
+      type: _react2['default'].PropTypes.oneOf(_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'];
+
+/***/ },
+/* 63 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  exports.__esModule = true;
+
+  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _common = __webpack_require__(31);
+
+  /**
+   * 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'];
+
+/***/ },
+/* 64 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _inherits = __webpack_require__(48)['default'];
+
+  var _classCallCheck = __webpack_require__(59)['default'];
+
+  var _objectWithoutProperties = __webpack_require__(26)['default'];
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _Button = __webpack_require__(62);
+
+  var _Button2 = _interopRequireDefault(_Button);
+
+  var _FormGroup = __webpack_require__(65);
+
+  var _FormGroup2 = _interopRequireDefault(_FormGroup);
+
+  var _InputBase2 = __webpack_require__(66);
+
+  var _InputBase3 = _interopRequireDefault(_InputBase2);
+
+  var _utilsChildrenValueInputValidation = __webpack_require__(3);
+
+  var _utilsChildrenValueInputValidation2 = _interopRequireDefault(_utilsChildrenValueInputValidation);
+
+  var ButtonInput = (function (_InputBase) {
+    _inherits(ButtonInput, _InputBase);
+
+    function ButtonInput() {
+      _classCallCheck(this, ButtonInput);
+
+      _InputBase.apply(this, arguments);
+    }
+
+    ButtonInput.prototype.renderFormGroup = function renderFormGroup(children) {
+      var _props = this.props;
+      var bsStyle = _props.bsStyle;
+      var value = _props.value;
+
+      var other = _objectWithoutProperties(_props, ['bsStyle', 'value']);
+
+      return _react2['default'].createElement(
+        _FormGroup2['default'],
+        other,
+        children
+      );
+    };
+
+    ButtonInput.prototype.renderInput = function renderInput() {
+      var _props2 = this.props;
+      var children = _props2.children;
+      var value = _props2.value;
+
+      var other = _objectWithoutProperties(_props2, ['children', 'value']);
+
+      var val = children ? children : value;
+      return _react2['default'].createElement(_Button2['default'], _extends({}, other, { componentClass: 'input', ref: 'input', key: 'input', value: val }));
+    };
+
+    return ButtonInput;
+  })(_InputBase3['default']);
+
+  ButtonInput.types = ['button', 'reset', 'submit'];
+
+  ButtonInput.defaultProps = {
+    type: 'button'
+  };
+
+  ButtonInput.propTypes = {
+    type: _react2['default'].PropTypes.oneOf(ButtonInput.types),
+    bsStyle: function bsStyle() {
+      // defer to Button propTypes of bsStyle
+      return null;
+    },
+    children: _utilsChildrenValueInputValidation2['default'],
+    value: _utilsChildrenValueInputValidation2['default']
+  };
+
+  exports['default'] = ButtonInput;
+  module.exports = exports['default'];
+
+/***/ },
+/* 65 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _inherits = __webpack_require__(48)['default'];
+
+  var _classCallCheck = __webpack_require__(59)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _classnames = __webpack_require__(27);
+
+  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'];
+
+/***/ },
+/* 66 */
+/***/ function(module, exports, __webpack_require__) {
+
+  'use strict';
+
+  var _inherits = __webpack_require__(48)['default'];
+
+  var _classCallCheck = __webpack_require__(59)['default'];
+
+  var _extends = __webpack_require__(9)['default'];
+
+  var _interopRequireDefault = __webpack_require__(1)['default'];
+
+  exports.__esModule = true;
+
+  var _react = __webpack_require__(4);
+
+  var _react2 = _interopRequireDefault(_react);
+
+  var _classnames = __webpack_require__(27);
+
+  var _classnames2 = _interopRequireDefault(_classnames);
+
+  var _FormGroup = __webpack_require__(65);
+
+  var _FormGroup2 = _interopRequireDefault(_FormGroup);
+
+  var _Glyphicon = __webpack_require__(67);
+
+  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();
+        }
+        return this.getInputDOMNode().value;
+      }
+      throw new Error('Cannot use getValue without specifying input type.');
+    };
+
+    InputBase.prototype.getChecked = function getChecked() {
+      return this.getInputDOMNode().checked;
+    };
+
+    InputBase.prototype.getSelectedOptions = function getSelectedOptions() {
+      var values = [];
+
+      Array.prototype.forEach.call(this.getInputDOMNode().getElementsByTagName('option'), function (option) {
+        if (option.selected) {
+          var value = option.getAttribute('value') || option.innerHtml;
+          values.push(value);
+        }
+      });
+
+      return values;
+    };
+
+    InputBase.prototype.isCheckboxOrRadio = function isCheckboxOrRadio() {
+      return this.props.type === 'checkbox' || this.props.type === 'radio';
+    };
+
+    InputBase.prototype.isFile = function isFile() {
+      return this.props.type === 'file';
+    };
+
+    InputBase.prototype.renderInputGroup = function renderInputGroup(children) {
+      var addonBefore = this.props.addonBefore ? _react2['default'].createElement(
+        'span',
+        { className: 'input-group-addon', key: 'addonBefore' },
+        this.props.addonBefore
+      ) : null;
+
+      var addonAfter = this.props.addonAfter ? _react2['default'].createElement(
+        'span',
+        { className: 'input-group-addon', key: 'addonAfter' },
+        this.props.addonAfter
+      ) : null;
+
+      var buttonBefore = this.props.buttonBefore ? _react2['default'].createElement(
+        'span',
+        { className: 'input-group-btn' },
+        this.props.buttonBefore
+      ) : null;
+
+      var buttonAfter = this.props.buttonAfter ? _react2['default'].createElement(
+        'span',
+        { className: 'input-group-btn' },
+        this.props.buttonAfter
+      ) : null;
+
+      var inputGroupClassName = undefined;
+      switch (this.props.bsSize) {
+        case 'small':
+          inputGroupClassName = 'input-group-sm';break;
+        case 'large':
+          inputGroupClassName = 'input-group-lg';break;
+        default:
+      }
+
+      return addonBefore || addonAfter || buttonBefore || buttonAfter ? _react2['default'].createElement(
+        'div',
+        { className: _classnames2['default'](inputGroupClassName, 'input-group'), key: 'input-group' },
+        addonBefore,
+        buttonBefore,
+        children,
+        addonAfter,
+        buttonAfter
+      ) : children;
+    };
+
+    InputBase.prototype.renderIcon = function renderIcon() {
+      if (this.props.hasFeedback) {
+        if (this.props.feedbackIcon) {
+          return _react2['default'].cloneElement(this.props.feedbackIcon, { formControlFeedback: true });
+        }
+
+        switch (this.props.bsStyle) {
+          case 'success':
+            return _react2['default'].createElement(_Glyphicon2['default'], { formControlFeedback: true, glyph: 'ok', key: 'icon' });
+          case 'warning':
+            return _react2['default'].createElement(_Glyphicon2['default'], { formControlFeedback: true, glyph: 'warning-sign', key: 'icon' });
+          case 'error':
+            return _react2['default'].createElement(_Glyphicon2['default'], { formControlFeedback: true, glyph: 'remove', key: 'icon' });
+          default:
+            return _react2['default'].createElement('span', { className: 'form-control-feedback', key: 'icon' });
+        }
+      } else {
+        return null;
+      }
+    };
+
+    InputBase.prototype.renderHelp = function renderHelp() {
+      return this.props.help ? _react2['default'].createElement(
+        'span',
+        { className: 'help-block', key: 'help' },
+        this.props.help
+      ) : null;
+    };
+
+    InputBase.prototype.renderCheckboxAndRadioWrapper = function renderCheckboxAndRadioWrapper(children) {
+      var classes = {
+        'checkbox': this.props.type === 'checkbox',
+        'radio': thi

<TRUNCATED>

Mime
View raw message