text: 'use strict';
  
  Object.defineProperty(exports, '__esModule', { value: true });
  
  function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  
  var React = require('react');
  var React__default = _interopDefault(React);
  var PropTypes = _interopDefault(require('prop-types'));
  var classNames = _interopDefault(require('classnames'));
  var isFunction = _interopDefault(require('lodash.isfunction'));
  var isobject = _interopDefault(require('lodash.isobject'));
  var ReactDOM = _interopDefault(require('react-dom'));
  var reactPopper = require('react-popper');
  var toNumber = _interopDefault(require('lodash.tonumber'));
  
  // https://github.com/twbs/bootstrap/blob/v4.0.0-alpha.4/js/src/modal.js#L436-L443
  function getScrollbarWidth() {
    var scrollDiv = document.createElement('div');
    // .modal-scrollbar-measure styles // https://github.com/twbs/bootstrap/blob/v4.0.0-alpha.4/scss/_modal.scss#L106-L113
    scrollDiv.style.position = 'absolute';
    scrollDiv.style.top = '-9999px';
    scrollDiv.style.width = '50px';
    scrollDiv.style.height = '50px';
    scrollDiv.style.overflow = 'scroll';
    document.body.appendChild(scrollDiv);
    var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth;
    document.body.removeChild(scrollDiv);
    return scrollbarWidth;
  }
  
  function setScrollbarWidth(padding) {
    document.body.style.paddingRight = padding > 0 ? padding + 'px' : null;
  }
  
  function isBodyOverflowing() {
    return document.body.clientWidth < window.innerWidth;
  }
  
  function getOriginalBodyPadding() {
    return parseInt(window.getComputedStyle(document.body, null).getPropertyValue('padding-right') || 0, 10);
  }
  
  function conditionallyUpdateScrollbar() {
    var scrollbarWidth = getScrollbarWidth();
    // https://github.com/twbs/bootstrap/blob/v4.0.0-alpha.6/js/src/modal.js#L433
    var fixedContent = document.querySelectorAll('.fixed-top, .fixed-bottom, .is-fixed, .sticky-top')[0];
    var bodyPadding = fixedContent ? parseInt(fixedContent.style.paddingRight || 0, 10) : 0;
  
    if (isBodyOverflowing()) {
      setScrollbarWidth(bodyPadding + scrollbarWidth);
    }
  }
  
  function mapToCssModules(className, cssModule) {
    if (!cssModule) return className;
    return className.split(' ').map(function (c) {
      return cssModule[c] || c;
    }).join(' ');
  }
  
  /**
   * Returns a new object with the key/value pairs from `obj` that are not in the array `omitKeys`.
   */
  function omit(obj, omitKeys) {
    var result = {};
    Object.keys(obj).forEach(function (key) {
      if (omitKeys.indexOf(key) === -1) {
        result[key] = obj[key];
      }
    });
    return result;
  }
  
  /**
   * Returns a filtered copy of an object with only the specified keys.
   */
  function pick(obj, keys) {
    var pickKeys = Array.isArray(keys) ? keys : [keys];
    var length = pickKeys.length;
    var key = void 0;
    var result = {};
  
    while (length > 0) {
      length -= 1;
      key = pickKeys[length];
      result[key] = obj[key];
    }
    return result;
  }
  
  var warned = {};
  
  function warnOnce(message) {
    if (!warned[message]) {
      /* istanbul ignore else */
      if (typeof console !== 'undefined') {
        console.error(message); // eslint-disable-line no-console
      }
      warned[message] = true;
    }
  }
  
  function deprecated(propType, explanation) {
    return function validate(props, propName, componentName) {
      if (props[propName] !== null && typeof props[propName] !== 'undefined') {
        warnOnce('"' + propName + '" property of "' + componentName + '" has been deprecated.\n' + explanation);
      }
  
      for (var _len = arguments.length, rest = Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
        rest[_key - 3] = arguments[_key];
      }
  
      return propType.apply(undefined, [props, propName, componentName].concat(rest));
    };
  }
  
  function DOMElement(props, propName, componentName) {
    if (!(props[propName] instanceof Element)) {
      return new Error('Invalid prop `' + propName + '` supplied to `' + componentName + '`. Expected prop to be an instance of Element. Validation failed.');
    }
  }
  
  function getTarget(target) {
    if (isFunction(target)) {
      return target();
    }
  
    if (typeof target === 'string' && document) {
      var selection = document.querySelector(target);
      if (selection === null) {
        return document.querySelector('#' + target);
      }
      return selection;
    }
  
    return target;
  }
  
  /* eslint key-spacing: ["error", { afterColon: true, align: "value" }] */
  // These are all setup to match what is in the bootstrap _variables.scss
  // https://github.com/twbs/bootstrap/blob/v4-dev/scss/_variables.scss
  var TransitionTimeouts = {
    Fade: 150, // $transition-fade
    Collapse: 350, // $transition-collapse
    Modal: 300, // $modal-transition
    Carousel: 600 // $carousel-transition
  };
  
  // Duplicated Transition.propType keys to ensure that Reactstrap builds
  // for distribution properly exclude these keys for nested child HTML attributes
  // since `react-transition-group` removes propTypes in production builds.
  var TransitionPropTypeKeys = ['in', 'mountOnEnter', 'unmountOnExit', 'appear', 'enter', 'exit', 'timeout', 'onEnter', 'onEntering', 'onEntered', 'onExit', 'onExiting', 'onExited'];
  
  var TransitionStatuses = {
    ENTERING: 'entering',
    ENTERED: 'entered',
    EXITING: 'exiting',
    EXITED: 'exited'
  };
  
  var keyCodes = {
    esc: 27,
    space: 32,
    tab: 9,
    up: 38,
    down: 40
  };
  
  var PopperPlacements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];
  
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) {
    return typeof obj;
  } : function (obj) {
    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
  };
  
  
  
  
  
  
  
  
  
  
  
  var classCallCheck = function (instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  };
  
  var createClass = function () {
    function defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    return function (Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps);
      if (staticProps) defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();
  
  
  
  
  
  var defineProperty = function (obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }
  
    return obj;
  };
  
  var _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
  
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
  
    return target;
  };
  
  
  
  var inherits = 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;
  };
  
  
  
  
  
  
  
  
  
  var objectWithoutProperties = 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;
  };
  
  var possibleConstructorReturn = function (self, call) {
    if (!self) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }
  
    return call && (typeof call === "object" || typeof call === "function") ? call : self;
  };
  
  var propTypes = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    fluid: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps = {
    tag: 'div'
  };
  
  var Container = function Container(props) {
    var className = props.className,
        cssModule = props.cssModule,
        fluid = props.fluid,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'fluid', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, fluid ? 'container-fluid' : 'container'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Container.propTypes = propTypes;
  Container.defaultProps = defaultProps;
  
  var propTypes$1 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    noGutters: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$1 = {
    tag: 'div'
  };
  
  var Row = function Row(props) {
    var className = props.className,
        cssModule = props.cssModule,
        noGutters = props.noGutters,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'noGutters', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, noGutters ? 'no-gutters' : null, 'row'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Row.propTypes = propTypes$1;
  Row.defaultProps = defaultProps$1;
  
  var colWidths = ['xs', 'sm', 'md', 'lg', 'xl'];
  var stringOrNumberProp = PropTypes.oneOfType([PropTypes.number, PropTypes.string]);
  
  var columnProps = PropTypes.oneOfType([PropTypes.bool, PropTypes.number, PropTypes.string, PropTypes.shape({
    size: PropTypes.oneOfType([PropTypes.bool, PropTypes.number, PropTypes.string]),
    push: stringOrNumberProp,
    pull: stringOrNumberProp,
    offset: stringOrNumberProp
  })]);
  
  var propTypes$2 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    xs: columnProps,
    sm: columnProps,
    md: columnProps,
    lg: columnProps,
    xl: columnProps,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    widths: PropTypes.array
  };
  
  var defaultProps$2 = {
    tag: 'div',
    widths: colWidths
  };
  
  var getColumnSizeClass = function getColumnSizeClass(isXs, colWidth, colSize) {
    if (colSize === true || colSize === '') {
      return isXs ? 'col' : 'col-' + colWidth;
    } else if (colSize === 'auto') {
      return isXs ? 'col-auto' : 'col-' + colWidth + '-auto';
    }
  
    return isXs ? 'col-' + colSize : 'col-' + colWidth + '-' + colSize;
  };
  
  var Col = function Col(props) {
    var className = props.className,
        cssModule = props.cssModule,
        widths = props.widths,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'widths', 'tag']);
  
    var colClasses = [];
  
    widths.forEach(function (colWidth, i) {
      var columnProp = props[colWidth];
  
      if (!i && columnProp === undefined) {
        columnProp = true;
      }
  
      delete attributes[colWidth];
  
      if (!columnProp && columnProp !== '') {
        return;
      }
  
      var isXs = !i;
      var colClass = void 0;
  
      if (isobject(columnProp)) {
        var _classNames;
  
        var colSizeInterfix = isXs ? '-' : '-' + colWidth + '-';
        colClass = getColumnSizeClass(isXs, colWidth, columnProp.size);
  
        colClasses.push(mapToCssModules(classNames((_classNames = {}, defineProperty(_classNames, colClass, columnProp.size || columnProp.size === ''), defineProperty(_classNames, 'push' + colSizeInterfix + columnProp.push, columnProp.push || columnProp.push === 0), defineProperty(_classNames, 'pull' + colSizeInterfix + columnProp.pull, columnProp.pull || columnProp.pull === 0), defineProperty(_classNames, 'offset' + colSizeInterfix + columnProp.offset, columnProp.offset || columnProp.offset === 0), _classNames))), cssModule);
      } else {
        colClass = getColumnSizeClass(isXs, colWidth, columnProp);
        colClasses.push(colClass);
      }
    });
  
    var classes = mapToCssModules(classNames(className, colClasses), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Col.propTypes = propTypes$2;
  Col.defaultProps = defaultProps$2;
  
  var propTypes$3 = {
    light: PropTypes.bool,
    dark: PropTypes.bool,
    inverse: deprecated(PropTypes.bool, 'Please use the prop "dark"'),
    full: PropTypes.bool,
    fixed: PropTypes.string,
    sticky: PropTypes.string,
    color: PropTypes.string,
    role: PropTypes.string,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object,
    toggleable: deprecated(PropTypes.oneOfType([PropTypes.bool, PropTypes.string]), 'Please use the prop "expand"'),
    expand: PropTypes.oneOfType([PropTypes.bool, PropTypes.string])
  };
  
  var defaultProps$3 = {
    tag: 'nav',
    expand: false
  };
  
  var getExpandClass = function getExpandClass(expand) {
    if (expand === false) {
      return false;
    } else if (expand === true || expand === 'xs') {
      return 'navbar-expand';
    }
  
    return 'navbar-expand-' + expand;
  };
  
  // To better maintain backwards compatibility while toggleable is deprecated.
  // We must map breakpoints to the next breakpoint so that toggleable and expand do the same things at the same breakpoint.
  var toggleableToExpand = {
    xs: 'sm',
    sm: 'md',
    md: 'lg',
    lg: 'xl'
  };
  
  var getToggleableClass = function getToggleableClass(toggleable) {
    if (toggleable === undefined || toggleable === 'xl') {
      return false;
    } else if (toggleable === false) {
      return 'navbar-expand';
    }
  
    return 'navbar-expand-' + (toggleable === true ? 'sm' : toggleableToExpand[toggleable] || toggleable);
  };
  
  var Navbar = function Navbar(props) {
    var _classNames;
  
    var toggleable = props.toggleable,
        expand = props.expand,
        className = props.className,
        cssModule = props.cssModule,
        light = props.light,
        dark = props.dark,
        inverse = props.inverse,
        fixed = props.fixed,
        sticky = props.sticky,
        color = props.color,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['toggleable', 'expand', 'className', 'cssModule', 'light', 'dark', 'inverse', 'fixed', 'sticky', 'color', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'navbar', getExpandClass(expand) || getToggleableClass(toggleable), (_classNames = {
      'navbar-light': light,
      'navbar-dark': inverse || dark
    }, defineProperty(_classNames, 'bg-' + color, color), defineProperty(_classNames, 'fixed-' + fixed, fixed), defineProperty(_classNames, 'sticky-' + sticky, sticky), _classNames)), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Navbar.propTypes = propTypes$3;
  Navbar.defaultProps = defaultProps$3;
  
  var propTypes$4 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$4 = {
    tag: 'a'
  };
  
  var NavbarBrand = function NavbarBrand(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'navbar-brand'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  NavbarBrand.propTypes = propTypes$4;
  NavbarBrand.defaultProps = defaultProps$4;
  
  var propTypes$5 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    type: PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    children: PropTypes.node
  };
  
  var defaultProps$5 = {
    tag: 'button',
    type: 'button'
  };
  
  var NavbarToggler = function NavbarToggler(props) {
    var className = props.className,
        cssModule = props.cssModule,
        children = props.children,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'children', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'navbar-toggler'), cssModule);
  
    return React__default.createElement(
      Tag,
      _extends({}, attributes, { className: classes }),
      children || React__default.createElement('span', { className: mapToCssModules('navbar-toggler-icon', cssModule) })
    );
  };
  
  NavbarToggler.propTypes = propTypes$5;
  NavbarToggler.defaultProps = defaultProps$5;
  
  var propTypes$6 = {
    tabs: PropTypes.bool,
    pills: PropTypes.bool,
    vertical: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
    horizontal: PropTypes.string,
    justified: PropTypes.bool,
    fill: PropTypes.bool,
    navbar: PropTypes.bool,
    card: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$6 = {
    tag: 'ul',
    vertical: false
  };
  
  var getVerticalClass = function getVerticalClass(vertical) {
    if (vertical === false) {
      return false;
    } else if (vertical === true || vertical === 'xs') {
      return 'flex-column';
    }
  
    return 'flex-' + vertical + '-column';
  };
  
  var Nav = function Nav(props) {
    var className = props.className,
        cssModule = props.cssModule,
        tabs = props.tabs,
        pills = props.pills,
        vertical = props.vertical,
        horizontal = props.horizontal,
        justified = props.justified,
        fill = props.fill,
        navbar = props.navbar,
        card = props.card,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tabs', 'pills', 'vertical', 'horizontal', 'justified', 'fill', 'navbar', 'card', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, navbar ? 'navbar-nav' : 'nav', horizontal ? 'justify-content-' + horizontal : false, getVerticalClass(vertical), {
      'nav-tabs': tabs,
      'card-header-tabs': card && tabs,
      'nav-pills': pills,
      'card-header-pills': card && pills,
      'nav-justified': justified,
      'nav-fill': fill
    }), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Nav.propTypes = propTypes$6;
  Nav.defaultProps = defaultProps$6;
  
  var propTypes$7 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$7 = {
    tag: 'li'
  };
  
  var NavItem = function NavItem(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'nav-item'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  NavItem.propTypes = propTypes$7;
  NavItem.defaultProps = defaultProps$7;
  
  /* eslint react/no-find-dom-node: 0 */
  // https://github.com/yannickcr/eslint-plugin-react/blob/master/docs/rules/no-find-dom-node.md
  
  var propTypes$9 = {
    disabled: PropTypes.bool,
    dropup: PropTypes.bool,
    group: PropTypes.bool,
    isOpen: PropTypes.bool,
    size: PropTypes.string,
    tag: PropTypes.string,
    toggle: PropTypes.func,
    children: PropTypes.node,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$9 = {
    isOpen: false,
    dropup: false,
    tag: 'div'
  };
  
  var childContextTypes = {
    toggle: PropTypes.func.isRequired,
    isOpen: PropTypes.bool.isRequired,
    dropup: PropTypes.bool.isRequired
  };
  
  var Dropdown = function (_React$Component) {
    inherits(Dropdown, _React$Component);
  
    function Dropdown(props) {
      classCallCheck(this, Dropdown);
  
      var _this = possibleConstructorReturn(this, (Dropdown.__proto__ || Object.getPrototypeOf(Dropdown)).call(this, props));
  
      _this.addEvents = _this.addEvents.bind(_this);
      _this.handleDocumentClick = _this.handleDocumentClick.bind(_this);
      _this.handleKeyDown = _this.handleKeyDown.bind(_this);
      _this.removeEvents = _this.removeEvents.bind(_this);
      _this.toggle = _this.toggle.bind(_this);
      return _this;
    }
  
    createClass(Dropdown, [{
      key: 'getChildContext',
      value: function getChildContext() {
        return {
          toggle: this.props.toggle,
          isOpen: this.props.isOpen,
          dropup: this.props.dropup
        };
      }
    }, {
      key: 'componentDidMount',
      value: function componentDidMount() {
        this.handleProps();
      }
    }, {
      key: 'componentDidUpdate',
      value: function componentDidUpdate(prevProps) {
        if (this.props.isOpen !== prevProps.isOpen) {
          this.handleProps();
        }
      }
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {
        this.removeEvents();
      }
    }, {
      key: 'getContainer',
      value: function getContainer() {
        return ReactDOM.findDOMNode(this);
      }
    }, {
      key: 'addEvents',
      value: function addEvents() {
        var _this2 = this;
  
        ['click', 'touchstart', 'keyup'].forEach(function (event) {
          return document.addEventListener(event, _this2.handleDocumentClick, true);
        });
      }
    }, {
      key: 'removeEvents',
      value: function removeEvents() {
        var _this3 = this;
  
        ['click', 'touchstart', 'keyup'].forEach(function (event) {
          return document.removeEventListener(event, _this3.handleDocumentClick, true);
        });
      }
    }, {
      key: 'handleDocumentClick',
      value: function handleDocumentClick(e) {
        if (e && (e.which === 3 || e.type === 'keyup' && e.which !== keyCodes.tab)) return;
        var container = this.getContainer();
  
        if (container.contains(e.target) && container !== e.target && (e.type !== 'keyup' || e.which === keyCodes.tab)) {
          return;
        }
  
        this.toggle(e);
      }
    }, {
      key: 'handleKeyDown',
      value: function handleKeyDown(e) {
        if ([keyCodes.esc, keyCodes.up, keyCodes.down, keyCodes.space].indexOf(e.which) === -1 || /button/i.test(e.target.tagName) && e.which === keyCodes.space || /input|textarea/i.test(e.target.tagName)) {
          return;
        }
  
        e.preventDefault();
        if (this.props.disabled) return;
  
        var container = this.getContainer();
  
        if (e.which === keyCodes.space && this.props.isOpen && container !== e.target) {
          e.target.click();
        }
  
        if (e.which === keyCodes.esc || !this.props.isOpen) {
          this.toggle(e);
          container.querySelector('[aria-expanded]').focus();
          return;
        }
  
        var menuClass = mapToCssModules('dropdown-menu', this.props.cssModule);
        var itemClass = mapToCssModules('dropdown-item', this.props.cssModule);
        var disabledClass = mapToCssModules('disabled', this.props.cssModule);
  
        var items = container.querySelectorAll('.' + menuClass + ' .' + itemClass + ':not(.' + disabledClass + ')');
  
        if (!items.length) return;
  
        var index = -1;
        for (var i = 0; i < items.length; i += 1) {
          if (items[i] === e.target) {
            index = i;
            break;
          }
        }
  
        if (e.which === keyCodes.up && index > 0) {
          index -= 1;
        }
  
        if (e.which === keyCodes.down && index < items.length - 1) {
          index += 1;
        }
  
        if (index < 0) {
          index = 0;
        }
  
        items[index].focus();
      }
    }, {
      key: 'handleProps',
      value: function handleProps() {
        if (this.props.isOpen) {
          this.addEvents();
        } else {
          this.removeEvents();
        }
      }
    }, {
      key: 'toggle',
      value: function toggle(e) {
        if (this.props.disabled) {
          return e && e.preventDefault();
        }
  
        return this.props.toggle(e);
      }
    }, {
      key: 'render',
      value: function render() {
        var _classNames;
  
        var _omit = omit(this.props, ['toggle', 'disabled']),
            className = _omit.className,
            cssModule = _omit.cssModule,
            dropup = _omit.dropup,
            isOpen = _omit.isOpen,
            group = _omit.group,
            size = _omit.size,
            attrs = objectWithoutProperties(_omit, ['className', 'cssModule', 'dropup', 'isOpen', 'group', 'size']);
  
        var classes = mapToCssModules(classNames(className, (_classNames = {
          'btn-group': group
        }, defineProperty(_classNames, 'btn-group-' + size, !!size), defineProperty(_classNames, 'dropdown', !group), defineProperty(_classNames, 'show', isOpen), defineProperty(_classNames, 'dropup', dropup), _classNames)), cssModule);
        return React__default.createElement(reactPopper.Manager, _extends({}, attrs, { className: classes, onKeyDown: this.handleKeyDown }));
      }
    }]);
    return Dropdown;
  }(React__default.Component);
  
  Dropdown.propTypes = propTypes$9;
  Dropdown.defaultProps = defaultProps$9;
  Dropdown.childContextTypes = childContextTypes;
  
  var propTypes$8 = {
    children: PropTypes.node,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$8 = {
    tag: 'li'
  };
  
  var NavDropdown = function NavDropdown(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'nav-item'), cssModule);
  
    return React__default.createElement(Dropdown, _extends({}, attributes, { tag: Tag, className: classes }));
  };
  
  NavDropdown.propTypes = propTypes$8;
  NavDropdown.defaultProps = defaultProps$8;
  
  var propTypes$10 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    disabled: PropTypes.bool,
    active: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    onClick: PropTypes.func,
    href: PropTypes.any
  };
  
  var defaultProps$10 = {
    tag: 'a'
  };
  
  var NavLink = function (_React$Component) {
    inherits(NavLink, _React$Component);
  
    function NavLink(props) {
      classCallCheck(this, NavLink);
  
      var _this = possibleConstructorReturn(this, (NavLink.__proto__ || Object.getPrototypeOf(NavLink)).call(this, props));
  
      _this.onClick = _this.onClick.bind(_this);
      return _this;
    }
  
    createClass(NavLink, [{
      key: 'onClick',
      value: function onClick(e) {
        if (this.props.disabled) {
          e.preventDefault();
          return;
        }
  
        if (this.props.href === '#') {
          e.preventDefault();
        }
  
        if (this.props.onClick) {
          this.props.onClick(e);
        }
      }
    }, {
      key: 'render',
      value: function render() {
        var _props = this.props,
            className = _props.className,
            cssModule = _props.cssModule,
            active = _props.active,
            Tag = _props.tag,
            innerRef = _props.innerRef,
            attributes = objectWithoutProperties(_props, ['className', 'cssModule', 'active', 'tag', 'innerRef']);
  
  
        var classes = mapToCssModules(classNames(className, 'nav-link', {
          disabled: attributes.disabled,
          active: active
        }), cssModule);
  
        return React__default.createElement(Tag, _extends({}, attributes, { ref: innerRef, onClick: this.onClick, className: classes }));
      }
    }]);
    return NavLink;
  }(React__default.Component);
  
  NavLink.propTypes = propTypes$10;
  NavLink.defaultProps = defaultProps$10;
  
  var propTypes$11 = {
    tag: PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$11 = {
    tag: 'ol'
  };
  
  var Breadcrumb = function Breadcrumb(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'breadcrumb'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Breadcrumb.propTypes = propTypes$11;
  Breadcrumb.defaultProps = defaultProps$11;
  
  var propTypes$12 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    active: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$12 = {
    tag: 'li'
  };
  
  var BreadcrumbItem = function BreadcrumbItem(props) {
    var className = props.className,
        cssModule = props.cssModule,
        active = props.active,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'active', 'tag']);
  
    var classes = mapToCssModules(classNames(className, active ? 'active' : false, 'breadcrumb-item'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  BreadcrumbItem.propTypes = propTypes$12;
  BreadcrumbItem.defaultProps = defaultProps$12;
  
  var propTypes$13 = {
    active: PropTypes.bool,
    block: PropTypes.bool,
    color: PropTypes.string,
    disabled: PropTypes.bool,
    outline: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    onClick: PropTypes.func,
    size: PropTypes.string,
    children: PropTypes.node,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$13 = {
    color: 'secondary',
    tag: 'button'
  };
  
  var Button = function (_React$Component) {
    inherits(Button, _React$Component);
  
    function Button(props) {
      classCallCheck(this, Button);
  
      var _this = possibleConstructorReturn(this, (Button.__proto__ || Object.getPrototypeOf(Button)).call(this, props));
  
      _this.onClick = _this.onClick.bind(_this);
      return _this;
    }
  
    createClass(Button, [{
      key: 'onClick',
      value: function onClick(e) {
        if (this.props.disabled) {
          e.preventDefault();
          return;
        }
  
        if (this.props.onClick) {
          this.props.onClick(e);
        }
      }
    }, {
      key: 'render',
      value: function render() {
        var _props = this.props,
            active = _props.active,
            block = _props.block,
            className = _props.className,
            cssModule = _props.cssModule,
            color = _props.color,
            outline = _props.outline,
            size = _props.size,
            Tag = _props.tag,
            innerRef = _props.innerRef,
            attributes = objectWithoutProperties(_props, ['active', 'block', 'className', 'cssModule', 'color', 'outline', 'size', 'tag', 'innerRef']);
  
  
        var classes = mapToCssModules(classNames(className, 'btn', 'btn' + (outline ? '-outline' : '') + '-' + color, size ? 'btn-' + size : false, block ? 'btn-block' : false, { active: active, disabled: this.props.disabled }), cssModule);
  
        if (attributes.href && Tag === 'button') {
          Tag = 'a';
        }
  
        return React__default.createElement(Tag, _extends({
          type: Tag === 'button' && attributes.onClick ? 'button' : undefined
        }, attributes, {
          className: classes,
          ref: innerRef,
          onClick: this.onClick
        }));
      }
    }]);
    return Button;
  }(React__default.Component);
  
  Button.propTypes = propTypes$13;
  Button.defaultProps = defaultProps$13;
  
  var propTypes$14 = {
    children: PropTypes.node
  };
  
  var ButtonDropdown = function ButtonDropdown(props) {
    return React__default.createElement(Dropdown, _extends({ group: true }, props));
  };
  
  ButtonDropdown.propTypes = propTypes$14;
  
  var propTypes$15 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    'aria-label': PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    role: PropTypes.string,
    size: PropTypes.string,
    vertical: PropTypes.bool
  };
  
  var defaultProps$14 = {
    tag: 'div',
    role: 'group'
  };
  
  var ButtonGroup = function ButtonGroup(props) {
    var className = props.className,
        cssModule = props.cssModule,
        size = props.size,
        vertical = props.vertical,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'size', 'vertical', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, size ? 'btn-group-' + size : false, vertical ? 'btn-group-vertical' : 'btn-group'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  ButtonGroup.propTypes = propTypes$15;
  ButtonGroup.defaultProps = defaultProps$14;
  
  var propTypes$16 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    'aria-label': PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    role: PropTypes.string
  };
  
  var defaultProps$15 = {
    tag: 'div',
    role: 'toolbar'
  };
  
  var ButtonToolbar = function ButtonToolbar(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'btn-toolbar'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  ButtonToolbar.propTypes = propTypes$16;
  ButtonToolbar.defaultProps = defaultProps$15;
  
  var propTypes$17 = {
    children: PropTypes.node,
    active: PropTypes.bool,
    disabled: PropTypes.bool,
    divider: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    header: PropTypes.bool,
    onClick: PropTypes.func,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    toggle: PropTypes.bool
  };
  
  var contextTypes = {
    toggle: PropTypes.func
  };
  
  var defaultProps$16 = {
    tag: 'button',
    toggle: true
  };
  
  var DropdownItem = function (_React$Component) {
    inherits(DropdownItem, _React$Component);
  
    function DropdownItem(props) {
      classCallCheck(this, DropdownItem);
  
      var _this = possibleConstructorReturn(this, (DropdownItem.__proto__ || Object.getPrototypeOf(DropdownItem)).call(this, props));
  
      _this.onClick = _this.onClick.bind(_this);
      _this.getTabIndex = _this.getTabIndex.bind(_this);
      return _this;
    }
  
    createClass(DropdownItem, [{
      key: 'onClick',
      value: function onClick(e) {
        if (this.props.disabled || this.props.header || this.props.divider) {
          e.preventDefault();
          return;
        }
  
        if (this.props.onClick) {
          this.props.onClick(e);
        }
  
        if (this.props.toggle) {
          this.context.toggle(e);
        }
      }
    }, {
      key: 'getTabIndex',
      value: function getTabIndex() {
        if (this.props.disabled || this.props.header || this.props.divider) {
          return '-1';
        }
  
        return '0';
      }
    }, {
      key: 'render',
      value: function render() {
        var tabIndex = this.getTabIndex();
  
        var _omit = omit(this.props, ['toggle']),
            className = _omit.className,
            cssModule = _omit.cssModule,
            divider = _omit.divider,
            Tag = _omit.tag,
            header = _omit.header,
            active = _omit.active,
            props = objectWithoutProperties(_omit, ['className', 'cssModule', 'divider', 'tag', 'header', 'active']);
  
        var classes = mapToCssModules(classNames(className, {
          disabled: props.disabled,
          'dropdown-item': !divider && !header,
          active: active,
          'dropdown-header': header,
          'dropdown-divider': divider
        }), cssModule);
  
        if (Tag === 'button') {
          if (header) {
            Tag = 'h6';
          } else if (divider) {
            Tag = 'div';
          } else if (props.href) {
            Tag = 'a';
          }
        }
  
        return React__default.createElement(Tag, _extends({
          type: Tag === 'button' && (props.onClick || this.props.toggle) ? 'button' : undefined
        }, props, {
          tabIndex: tabIndex,
          className: classes,
          onClick: this.onClick
        }));
      }
    }]);
    return DropdownItem;
  }(React__default.Component);
  
  DropdownItem.propTypes = propTypes$17;
  DropdownItem.defaultProps = defaultProps$16;
  DropdownItem.contextTypes = contextTypes;
  
  var propTypes$18 = {
    tag: PropTypes.string,
    children: PropTypes.node.isRequired,
    right: PropTypes.bool,
    flip: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$17 = {
    tag: 'div',
    flip: true
  };
  
  var contextTypes$1 = {
    isOpen: PropTypes.bool.isRequired,
    dropup: PropTypes.bool.isRequired
  };
  
  var noFlipModifier = { flip: { enabled: false } };
  
  var DropdownMenu = function DropdownMenu(props, context) {
    var className = props.className,
        cssModule = props.cssModule,
        right = props.right,
        tag = props.tag,
        flip = props.flip,
        attrs = objectWithoutProperties(props, ['className', 'cssModule', 'right', 'tag', 'flip']);
  
    var classes = mapToCssModules(classNames(className, 'dropdown-menu', {
      'dropdown-menu-right': right,
      show: context.isOpen
    }), cssModule);
  
    var Tag = tag;
  
    if (context.isOpen) {
      Tag = reactPopper.Popper;
      var position1 = context.dropup ? 'top' : 'bottom';
      var position2 = right ? 'end' : 'start';
      attrs.placement = position1 + '-' + position2;
      attrs.component = tag;
      attrs.modifiers = !flip ? noFlipModifier : undefined;
    }
  
    return React__default.createElement(Tag, _extends({
      tabIndex: '-1',
      role: 'menu'
    }, attrs, {
      'aria-hidden': !context.isOpen,
      className: classes
    }));
  };
  
  DropdownMenu.propTypes = propTypes$18;
  DropdownMenu.defaultProps = defaultProps$17;
  DropdownMenu.contextTypes = contextTypes$1;
  
  var propTypes$19 = {
    caret: PropTypes.bool,
    color: PropTypes.string,
    children: PropTypes.node,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    disabled: PropTypes.bool,
    onClick: PropTypes.func,
    'aria-haspopup': PropTypes.bool,
    split: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    nav: PropTypes.bool
  };
  
  var defaultProps$18 = {
    'aria-haspopup': true,
    color: 'secondary'
  };
  
  var contextTypes$2 = {
    isOpen: PropTypes.bool.isRequired,
    toggle: PropTypes.func.isRequired
  };
  
  var DropdownToggle = function (_React$Component) {
    inherits(DropdownToggle, _React$Component);
  
    function DropdownToggle(props) {
      classCallCheck(this, DropdownToggle);
  
      var _this = possibleConstructorReturn(this, (DropdownToggle.__proto__ || Object.getPrototypeOf(DropdownToggle)).call(this, props));
  
      _this.onClick = _this.onClick.bind(_this);
      return _this;
    }
  
    createClass(DropdownToggle, [{
      key: 'onClick',
      value: function onClick(e) {
        if (this.props.disabled) {
          e.preventDefault();
          return;
        }
  
        if (this.props.nav && !this.props.tag) {
          e.preventDefault();
        }
  
        if (this.props.onClick) {
          this.props.onClick(e);
        }
  
        this.context.toggle(e);
      }
    }, {
      key: 'render',
      value: function render() {
        var _props = this.props,
            className = _props.className,
            color = _props.color,
            cssModule = _props.cssModule,
            caret = _props.caret,
            split = _props.split,
            nav = _props.nav,
            tag = _props.tag,
            props = objectWithoutProperties(_props, ['className', 'color', 'cssModule', 'caret', 'split', 'nav', 'tag']);
  
        var ariaLabel = props['aria-label'] || 'Toggle Dropdown';
        var classes = mapToCssModules(classNames(className, {
          'dropdown-toggle': caret || split,
          'dropdown-toggle-split': split,
          'nav-link': nav
        }), cssModule);
        var children = props.children || React__default.createElement(
          'span',
          { className: 'sr-only' },
          ariaLabel
        );
  
        var Tag = void 0;
  
        if (nav && !tag) {
          Tag = 'a';
          props.href = '#';
        } else if (!tag) {
          Tag = Button;
          props.color = color;
          props.cssModule = cssModule;
        } else {
          Tag = tag;
        }
  
        return React__default.createElement(reactPopper.Target, _extends({}, props, {
          className: classes,
          component: Tag,
          onClick: this.onClick,
          'aria-expanded': this.context.isOpen,
          children: children
        }));
      }
    }]);
    return DropdownToggle;
  }(React__default.Component);
  
  DropdownToggle.propTypes = propTypes$19;
  DropdownToggle.defaultProps = defaultProps$18;
  DropdownToggle.contextTypes = contextTypes$2;
  
  function unwrapExports (x) {
  	return x && x.__esModule ? x['default'] : x;
  }
  
  function createCommonjsModule(fn, module) {
  	return module = { exports: {} }, fn(module, module.exports), module.exports;
  }
  
  var PropTypes$1 = createCommonjsModule(function (module, exports) {
    'use strict';
  
    exports.__esModule = true;
    exports.classNamesShape = exports.timeoutsShape = undefined;
    exports.transitionTimeout = transitionTimeout;
  
    var _propTypes2 = _interopRequireDefault(PropTypes);
  
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
  
    function transitionTimeout(transitionType) {
      var timeoutPropName = 'transition' + transitionType + 'Timeout';
      var enabledPropName = 'transition' + transitionType;
  
      return function (props) {
        // If the transition is enabled
        if (props[enabledPropName]) {
          // If no timeout duration is provided
          if (props[timeoutPropName] == null) {
            return new Error(timeoutPropName + ' wasn\'t supplied to CSSTransitionGroup: ' + 'this can cause unreliable animations and won\'t be supported in ' + 'a future version of React. See ' + 'https://fb.me/react-animation-transition-group-timeout for more ' + 'information.');
  
            // If the duration isn't a number
          } else if (typeof props[timeoutPropName] !== 'number') {
            return new Error(timeoutPropName + ' must be a number (in milliseconds)');
          }
        }
  
        return null;
      };
    }
  
    var timeoutsShape = exports.timeoutsShape = _propTypes2.default.oneOfType([_propTypes2.default.number, _propTypes2.default.shape({
      enter: _propTypes2.default.number,
      exit: _propTypes2.default.number
    }).isRequired]);
  
    var classNamesShape = exports.classNamesShape = _propTypes2.default.oneOfType([_propTypes2.default.string, _propTypes2.default.shape({
      enter: _propTypes2.default.string,
      exit: _propTypes2.default.string,
      active: _propTypes2.default.string
    }), _propTypes2.default.shape({
      enter: _propTypes2.default.string,
      enterActive: _propTypes2.default.string,
      exit: _propTypes2.default.string,
      exitActive: _propTypes2.default.string
    })]);
  });
  
  var Transition_1 = createCommonjsModule(function (module, exports) {
    'use strict';
  
    exports.__esModule = true;
    exports.EXITING = exports.ENTERED = exports.ENTERING = exports.EXITED = exports.UNMOUNTED = undefined;
  
    var PropTypes$$1 = _interopRequireWildcard(PropTypes);
  
    var _react2 = _interopRequireDefault(React__default);
  
    var _reactDom2 = _interopRequireDefault(ReactDOM);
  
    function _interopRequireDefault(obj) {
      return obj && obj.__esModule ? obj : { default: obj };
    }
  
    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 _objectWithoutProperties(obj, keys) {
      var target = {};for (var i in obj) {
        if (keys.indexOf(i) >= 0) continue;if (!Object.prototype.hasOwnProperty.call(obj, i)) continue;target[i] = obj[i];
      }return target;
    }
  
    function _classCallCheck(instance, Constructor) {
      if (!(instance instanceof Constructor)) {
        throw new TypeError("Cannot call a class as a function");
      }
    }
  
    function _possibleConstructorReturn(self, call) {
      if (!self) {
        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      }return call && ((typeof call === 'undefined' ? 'undefined' : _typeof(call)) === "object" || typeof call === "function") ? call : self;
    }
  
    function _inherits(subClass, superClass) {
      if (typeof superClass !== "function" && superClass !== null) {
        throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === 'undefined' ? 'undefined' : _typeof(superClass)));
      }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
    }
  
    var UNMOUNTED = exports.UNMOUNTED = 'unmounted';
    var EXITED = exports.EXITED = 'exited';
    var ENTERING = exports.ENTERING = 'entering';
    var ENTERED = exports.ENTERED = 'entered';
    var EXITING = exports.EXITING = 'exiting';
  
    /**
     * The Transition component lets you describe a transition from one component
     * state to another _over time_ with a simple declarative API. Most commonly
     * it's used to animate the mounting and unmounting of a component, but can also
     * be used to describe in-place transition states as well.
     *
     * By default the `Transition` component does not alter the behavior of the
     * component it renders, it only tracks "enter" and "exit" states for the components.
     * It's up to you to give meaning and effect to those states. For example we can
     * add styles to a component when it enters or exits:
     *
     * ```jsx
     * import Transition from 'react-transition-group/Transition';
     *
     * const duration = 300;
     *
     * const defaultStyle = {
     *   transition: `opacity ${duration}ms ease-in-out`,
     *   opacity: 0,
     * }
     *
     * const transitionStyles = {
     *   entering: { opacity: 0 },
     *   entered:  { opacity: 1 },
     * };
     *
     * const Fade = ({ in: inProp }) => (
     *   <Transition in={inProp} timeout={duration}>
     *     {(state) => (
     *       <div style={{
     *         ...defaultStyle,
     *         ...transitionStyles[state]
     *       }}>
     *         I'm A fade Transition!
     *       </div>
     *     )}
     *   </Transition>
     * );
     * ```
     *
     * As noted the `Transition` component doesn't _do_ anything by itself to its child component.
     * What it does do is track transition states over time so you can update the
     * component (such as by adding styles or classes) when it changes states.
     *
     * There are 4 main states a Transition can be in:
     *  - `ENTERING`
     *  - `ENTERED`
     *  - `EXITING`
     *  - `EXITED`
     *
     * Transition state is toggled via the `in` prop. When `true` the component begins the
     * "Enter" stage. During this stage, the component will shift from its current transition state,
     * to `'entering'` for the duration of the transition and then to the `'entered'` stage once
     * it's complete. Let's take the following example:
     *
     * ```jsx
     * state= { in: false };
     *
     * toggleEnterState = () => {
     *   this.setState({ in: true });
     * }
     *
     * render() {
     *   return (
     *     <div>
     *       <Transition in={this.state.in} timeout={500} />
     *       <button onClick={this.toggleEnterState}>Click to Enter</button>
     *     </div>
     *   );
     * }
     * ```
     *
     * When the button is clicked the component will shift to the `'entering'` state and
     * stay there for 500ms (the value of `timeout`) when finally switches to `'entered'`.
     *
     * When `in` is `false` the same thing happens except the state moves from `'exiting'` to `'exited'`.
     */
  
    var Transition = function (_React$Component) {
      _inherits(Transition, _React$Component);
  
      function Transition(props, context) {
        _classCallCheck(this, Transition);
  
        var _this = _possibleConstructorReturn(this, _React$Component.call(this, props, context));
  
        var parentGroup = context.transitionGroup;
        // In the context of a TransitionGroup all enters are really appears
        var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;
  
        var initialStatus = void 0;
        _this.nextStatus = null;
  
        if (props.in) {
          if (appear) {
            initialStatus = EXITED;
            _this.nextStatus = ENTERING;
          } else {
            initialStatus = ENTERED;
          }
        } else {
          if (props.unmountOnExit || props.mountOnEnter) {
            initialStatus = UNMOUNTED;
          } else {
            initialStatus = EXITED;
          }
        }
  
        _this.state = { status: initialStatus };
  
        _this.nextCallback = null;
        return _this;
      }
  
      Transition.prototype.getChildContext = function getChildContext() {
        return { transitionGroup: null }; // allows for nested Transitions
      };
  
      Transition.prototype.componentDidMount = function componentDidMount() {
        this.updateStatus(true);
      };
  
      Transition.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
        var _ref = this.pendingState || this.state,
            status = _ref.status;
  
        if (nextProps.in) {
          if (status === UNMOUNTED) {
            this.setState({ status: EXITED });
          }
          if (status !== ENTERING && status !== ENTERED) {
            this.nextStatus = ENTERING;
          }
        } else {
          if (status === ENTERING || status === ENTERED) {
            this.nextStatus = EXITING;
          }
        }
      };
  
      Transition.prototype.componentDidUpdate = function componentDidUpdate() {
        this.updateStatus();
      };
  
      Transition.prototype.componentWillUnmount = function componentWillUnmount() {
        this.cancelNextCallback();
      };
  
      Transition.prototype.getTimeouts = function getTimeouts() {
        var timeout = this.props.timeout;
  
        var exit = void 0,
            enter = void 0,
            appear = void 0;
  
        exit = enter = appear = timeout;
  
        if (timeout != null && typeof timeout !== 'number') {
          exit = timeout.exit;
          enter = timeout.enter;
          appear = timeout.appear;
        }
        return { exit: exit, enter: enter, appear: appear };
      };
  
      Transition.prototype.updateStatus = function updateStatus() {
        var mounting = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
  
        var nextStatus = this.nextStatus;
  
        if (nextStatus !== null) {
          this.nextStatus = null;
          // nextStatus will always be ENTERING or EXITING.
          this.cancelNextCallback();
          var node = _reactDom2.default.findDOMNode(this);
  
          if (nextStatus === ENTERING) {
            this.performEnter(node, mounting);
          } else {
            this.performExit(node);
          }
        } else if (this.props.unmountOnExit && this.state.status === EXITED) {
          this.setState({ status: UNMOUNTED });
        }
      };
  
      Transition.prototype.performEnter = function performEnter(node, mounting) {
        var _this2 = this;
  
        var enter = this.props.enter;
  
        var appearing = this.context.transitionGroup ? this.context.transitionGroup.isMounting : mounting;
  
        var timeouts = this.getTimeouts();
  
        // no enter animation skip right to ENTERED
        // if we are mounting and running this it means appear _must_ be set
        if (!mounting && !enter) {
          this.safeSetState({ status: ENTERED }, function () {
            _this2.props.onEntered(node);
          });
          return;
        }
  
        this.props.onEnter(node, appearing);
  
        this.safeSetState({ status: ENTERING }, function () {
          _this2.props.onEntering(node, appearing);
  
          // FIXME: appear timeout?
          _this2.onTransitionEnd(node, timeouts.enter, function () {
            _this2.safeSetState({ status: ENTERED }, function () {
              _this2.props.onEntered(node, appearing);
            });
          });
        });
      };
  
      Transition.prototype.performExit = function performExit(node) {
        var _this3 = this;
  
        var exit = this.props.exit;
  
        var timeouts = this.getTimeouts();
  
        // no exit animation skip right to EXITED
        if (!exit) {
          this.safeSetState({ status: EXITED }, function () {
            _this3.props.onExited(node);
          });
          return;
        }
        this.props.onExit(node);
  
        this.safeSetState({ status: EXITING }, function () {
          _this3.props.onExiting(node);
  
          _this3.onTransitionEnd(node, timeouts.exit, function () {
            _this3.safeSetState({ status: EXITED }, function () {
              _this3.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) {
        var _this4 = this;
  
        // We need to track pending updates for instances where a cWRP fires quickly
        // after cDM and before the state flushes, which would double trigger a
        // transition
        this.pendingState = nextState;
  
        // 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.
        callback = this.setNextCallback(callback);
        this.setState(nextState, function () {
          _this4.pendingState = null;
          callback();
        });
      };
  
      Transition.prototype.setNextCallback = function setNextCallback(callback) {
        var _this5 = this;
  
        var active = true;
  
        this.nextCallback = function (event) {
          if (active) {
            active = false;
            _this5.nextCallback = null;
  
            callback(event);
          }
        };
  
        this.nextCallback.cancel = function () {
          active = false;
        };
  
        return this.nextCallback;
      };
  
      Transition.prototype.onTransitionEnd = function onTransitionEnd(node, timeout, handler) {
        this.setNextCallback(handler);
  
        if (node) {
          if (this.props.addEndListener) {
            this.props.addEndListener(node, this.nextCallback);
          }
          if (timeout != null) {
            setTimeout(this.nextCallback, 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,
            children = _props.children,
            childProps = _objectWithoutProperties(_props, ['children']);
        // filter props for Transtition
  
  
        delete childProps.in;
        delete childProps.mountOnEnter;
        delete childProps.unmountOnExit;
        delete childProps.appear;
        delete childProps.enter;
        delete childProps.exit;
        delete childProps.timeout;
        delete childProps.addEndListener;
        delete childProps.onEnter;
        delete childProps.onEntering;
        delete childProps.onEntered;
        delete childProps.onExit;
        delete childProps.onExiting;
        delete childProps.onExited;
  
        if (typeof children === 'function') {
          return children(status, childProps);
        }
  
        var child = _react2.default.Children.only(children);
        return _react2.default.cloneElement(child, childProps);
      };
  
      return Transition;
    }(_react2.default.Component);
  
    Transition.contextTypes = {
      transitionGroup: PropTypes$$1.object
    };
    Transition.childContextTypes = {
      transitionGroup: function transitionGroup() {}
    };
  
    Transition.propTypes = process.env.NODE_ENV !== "production" ? {
      /**
       * A `function` child can be used instead of a React element.
       * This function is called with the current transition status
       * ('entering', 'entered', 'exiting', 'exited', 'unmounted'), which can used
       * to apply context specific props to a component.
       *
       * ```jsx
       * <Transition timeout={150}>
       *   {(status) => (
       *     <MyComponent className={`fade fade-${status}`} />
       *   )}
       * </Transition>
       * ```
       */
      children: PropTypes$$1.oneOfType([PropTypes$$1.func.isRequired, PropTypes$$1.element.isRequired]).isRequired,
  
      /**
       * Show the component; triggers the enter or exit states
       */
      in: PropTypes$$1.bool,
  
      /**
       * By default the child component is mounted immediately along with
       * the parent `Transition` component. If you want to "lazy mount" the component on the
       * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
       * mounted, even on "exited", unless you also specify `unmountOnExit`.
       */
      mountOnEnter: PropTypes$$1.bool,
  
      /**
       * By default the child component stays mounted after it reaches the `'exited'` state.
       * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
       */
      unmountOnExit: PropTypes$$1.bool,
  
      /**
       * Normally a component is not transitioned if it is shown when the `<Transition>` component mounts.
       * If you want to transition on the first mount set `appear` to `true`, and the
       * component will transition in as soon as the `<Transition>` mounts.
       *
       * > Note: there are no specific "appear" states. `appear` only adds an additional `enter` transition.
       */
      appear: PropTypes$$1.bool,
  
      /**
       * Enable or disable enter transitions.
       */
      enter: PropTypes$$1.bool,
  
      /**
       * Enable or disable exit transitions.
       */
      exit: PropTypes$$1.bool,
  
      /**
       * The duration of the transition, in milliseconds.
       * Required unless `addEventListener` is provided
       *
       * You may specify a single timeout for all transitions like: `timeout={500}`,
       * or individually like:
       *
       * ```jsx
       * timeout={{
       *  enter: 300,
       *  exit: 500,
       * }}
       * ```
       *
       * @type {number | { enter?: number, exit?: number }}
       */
      timeout: function timeout(props) {
        for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }
  
        var pt = PropTypes$1.timeoutsShape;
        if (!props.addEndListener) pt = pt.isRequired;
        return pt.apply(undefined, [props].concat(args));
      },
  
      /**
       * Add a custom transition end trigger. Called with the transitioning
       * DOM node and a `done` callback. Allows for more fine grained transition end
       * logic. **Note:** Timeouts are still used as a fallback if provided.
       *
       * ```jsx
       * addEndListener={(node, done) => {
       *   // use the css transitionend event to mark the finish of a transition
       *   node.addEventListener('transitionend', done, false);
       * }}
       * ```
       */
      addEndListener: PropTypes$$1.func,
  
      /**
       * Callback fired before the "entering" status is applied. An extra parameter
       * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
       *
       * @type Function(node: HtmlElement, isAppearing: bool) -> void
       */
      onEnter: PropTypes$$1.func,
  
      /**
       * Callback fired after the "entering" status is applied. An extra parameter
       * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
       *
       * @type Function(node: HtmlElement, isAppearing: bool)
       */
      onEntering: PropTypes$$1.func,
  
      /**
       * Callback fired after the "entered" status is applied. An extra parameter
       * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
       *
       * @type Function(node: HtmlElement, isAppearing: bool) -> void
       */
      onEntered: PropTypes$$1.func,
  
      /**
       * Callback fired before the "exiting" status is applied.
       *
       * @type Function(node: HtmlElement) -> void
       */
      onExit: PropTypes$$1.func,
  
      /**
       * Callback fired after the "exiting" status is applied.
       *
       * @type Function(node: HtmlElement) -> void
       */
      onExiting: PropTypes$$1.func,
  
      /**
       * Callback fired after the "exited" status is applied.
       *
       * @type Function(node: HtmlElement) -> void
       */
      onExited: PropTypes$$1.func
    } : {};
  
    // Name the function so it is clearer in the documentation
    function noop() {}
  
    Transition.defaultProps = {
      in: false,
      mountOnEnter: false,
      unmountOnExit: false,
      appear: false,
      enter: true,
      exit: true,
  
      onEnter: noop,
      onEntering: noop,
      onEntered: noop,
  
      onExit: noop,
      onExiting: noop,
      onExited: noop
    };
  
    Transition.UNMOUNTED = 0;
    Transition.EXITED = 1;
    Transition.ENTERING = 2;
    Transition.ENTERED = 3;
    Transition.EXITING = 4;
  
    exports.default = Transition;
  });
  
  var Transition = unwrapExports(Transition_1);
  
  var propTypes$20 = _extends({}, Transition.propTypes, {
    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
    tag: PropTypes.oneOfType([PropTypes.string, PropTypes.func]),
    baseClass: PropTypes.string,
    baseClassActive: PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object
  });
  
  var defaultProps$19 = _extends({}, Transition.defaultProps, {
    tag: 'div',
    baseClass: 'fade',
    baseClassActive: 'show',
    timeout: TransitionTimeouts.Fade,
    appear: true,
    enter: true,
    exit: true,
    in: true
  });
  
  function Fade(props) {
    var Tag = props.tag,
        baseClass = props.baseClass,
        baseClassActive = props.baseClassActive,
        className = props.className,
        cssModule = props.cssModule,
        children = props.children,
        otherProps = objectWithoutProperties(props, ['tag', 'baseClass', 'baseClassActive', 'className', 'cssModule', 'children']);
  
    // In NODE_ENV=production the Transition.propTypes are wrapped which results in an
    // empty object "{}". This is the result of the `react-transition-group` babel
    // configuration settings. Therefore, to ensure that production builds work without
    // error, we can either explicitly define keys or use the Transition.defaultProps.
    // Using the Transition.defaultProps excludes any required props. Thus, the best
    // solution is to explicitly define required props in our utilities and reference these.
    // This also gives us more flexibility in the future to remove the prop-types
    // dependency in distribution builds (Similar to how `react-transition-group` does).
    // Note: Without omitting the `react-transition-group` props, the resulting child
    // Tag component would inherit the Transition properties as attributes for the HTML
    // element which results in errors/warnings for non-valid attributes.
  
    var transitionProps = pick(otherProps, TransitionPropTypeKeys);
    var childProps = omit(otherProps, TransitionPropTypeKeys);
  
    return React__default.createElement(
      Transition,
      transitionProps,
      function (status) {
        var isActive = status === 'entering' || status === 'entered';
        var classes = mapToCssModules(classNames(className, baseClass, isActive && baseClassActive), cssModule);
        return React__default.createElement(
          Tag,
          _extends({ className: classes }, childProps),
          children
        );
      }
    );
  }
  
  Fade.propTypes = propTypes$20;
  Fade.defaultProps = defaultProps$19;
  
  var propTypes$21 = {
    color: PropTypes.string,
    pill: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    children: PropTypes.node,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$20 = {
    color: 'secondary',
    pill: false,
    tag: 'span'
  };
  
  var Badge = function Badge(props) {
    var className = props.className,
        cssModule = props.cssModule,
        color = props.color,
        pill = props.pill,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'color', 'pill', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'badge', 'badge-' + color, pill ? 'badge-pill' : false), cssModule);
  
    if (attributes.href && Tag === 'span') {
      Tag = 'a';
    }
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Badge.propTypes = propTypes$21;
  Badge.defaultProps = defaultProps$20;
  
  var propTypes$22 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    inverse: PropTypes.bool,
    color: PropTypes.string,
    block: deprecated(PropTypes.bool, 'Please use the props "body"'),
    body: PropTypes.bool,
    outline: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$21 = {
    tag: 'div'
  };
  
  var Card = function Card(props) {
    var className = props.className,
        cssModule = props.cssModule,
        color = props.color,
        block = props.block,
        body = props.body,
        inverse = props.inverse,
        outline = props.outline,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'color', 'block', 'body', 'inverse', 'outline', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card', inverse ? 'text-white' : false, block || body ? 'card-body' : false, color ? (outline ? 'border' : 'bg') + '-' + color : false), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Card.propTypes = propTypes$22;
  Card.defaultProps = defaultProps$21;
  
  var propTypes$23 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$22 = {
    tag: 'div'
  };
  
  var CardGroup = function CardGroup(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-group'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardGroup.propTypes = propTypes$23;
  CardGroup.defaultProps = defaultProps$22;
  
  var propTypes$24 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$23 = {
    tag: 'div'
  };
  
  var CardDeck = function CardDeck(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-deck'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardDeck.propTypes = propTypes$24;
  CardDeck.defaultProps = defaultProps$23;
  
  var propTypes$25 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$24 = {
    tag: 'div'
  };
  
  var CardColumns = function CardColumns(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-columns'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardColumns.propTypes = propTypes$25;
  CardColumns.defaultProps = defaultProps$24;
  
  var propTypes$26 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$25 = {
    tag: 'div'
  };
  
  var CardBody = function CardBody(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-body'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardBody.propTypes = propTypes$26;
  CardBody.defaultProps = defaultProps$25;
  
  function CardBlock(props) {
    warnOnce('The "CardBlock" component has been deprecated.\nPlease use component "CardBody".');
    return React__default.createElement(CardBody, props);
  }
  
  var propTypes$27 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$26 = {
    tag: 'a'
  };
  
  var CardLink = function CardLink(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        innerRef = props.innerRef,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag', 'innerRef']);
  
    var classes = mapToCssModules(classNames(className, 'card-link'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { ref: innerRef, className: classes }));
  };
  
  CardLink.propTypes = propTypes$27;
  CardLink.defaultProps = defaultProps$26;
  
  var propTypes$28 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$27 = {
    tag: 'div'
  };
  
  var CardFooter = function CardFooter(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-footer'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardFooter.propTypes = propTypes$28;
  CardFooter.defaultProps = defaultProps$27;
  
  var propTypes$29 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$28 = {
    tag: 'div'
  };
  
  var CardHeader = function CardHeader(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-header'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardHeader.propTypes = propTypes$29;
  CardHeader.defaultProps = defaultProps$28;
  
  var propTypes$30 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    top: PropTypes.bool,
    bottom: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$29 = {
    tag: 'img'
  };
  
  var CardImg = function CardImg(props) {
    var className = props.className,
        cssModule = props.cssModule,
        top = props.top,
        bottom = props.bottom,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'top', 'bottom', 'tag']);
  
  
    var cardImgClassName = 'card-img';
    if (top) {
      cardImgClassName = 'card-img-top';
    }
    if (bottom) {
      cardImgClassName = 'card-img-bottom';
    }
  
    var classes = mapToCssModules(classNames(className, cardImgClassName), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardImg.propTypes = propTypes$30;
  CardImg.defaultProps = defaultProps$29;
  
  var propTypes$31 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$30 = {
    tag: 'div'
  };
  
  var CardImgOverlay = function CardImgOverlay(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-img-overlay'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardImgOverlay.propTypes = propTypes$31;
  CardImgOverlay.defaultProps = defaultProps$30;
  
  var CarouselCaption = function CarouselCaption(props) {
    var captionHeader = props.captionHeader,
        captionText = props.captionText,
        cssModule = props.cssModule;
  
    var classes = mapToCssModules(classNames('carousel-caption', 'd-none', 'd-md-block'), cssModule);
  
    return React__default.createElement(
      'div',
      { className: classes },
      React__default.createElement(
        'h3',
        null,
        captionHeader
      ),
      React__default.createElement(
        'p',
        null,
        captionText
      )
    );
  };
  
  CarouselCaption.propTypes = {
    captionHeader: PropTypes.string,
    captionText: PropTypes.string.isRequired,
    cssModule: PropTypes.object
  };
  
  var CarouselItem = function (_React$Component) {
    inherits(CarouselItem, _React$Component);
  
    function CarouselItem(props) {
      classCallCheck(this, CarouselItem);
  
      var _this = possibleConstructorReturn(this, (CarouselItem.__proto__ || Object.getPrototypeOf(CarouselItem)).call(this, props));
  
      _this.state = {
        startAnimation: false
      };
  
      _this.onEnter = _this.onEnter.bind(_this);
      _this.onEntering = _this.onEntering.bind(_this);
      _this.onExit = _this.onExit.bind(_this);
      _this.onExiting = _this.onExiting.bind(_this);
      _this.onExited = _this.onExited.bind(_this);
      return _this;
    }
  
    createClass(CarouselItem, [{
      key: 'onEnter',
      value: function onEnter(node, isAppearing) {
        this.setState({ startAnimation: false });
        this.props.onEnter(node, isAppearing);
      }
    }, {
      key: 'onEntering',
      value: function onEntering(node, isAppearing) {
        // getting this variable triggers a reflow
        var offsetHeight = node.offsetHeight;
        this.setState({ startAnimation: true });
        this.props.onEntering(node, isAppearing);
        return offsetHeight;
      }
    }, {
      key: 'onExit',
      value: function onExit(node) {
        this.setState({ startAnimation: false });
        this.props.onExit(node);
      }
    }, {
      key: 'onExiting',
      value: function onExiting(node) {
        this.setState({ startAnimation: true });
        node.dispatchEvent(new CustomEvent('slide.bs.carousel'));
        this.props.onExiting(node);
      }
    }, {
      key: 'onExited',
      value: function onExited(node) {
        node.dispatchEvent(new CustomEvent('slid.bs.carousel'));
        this.props.onExited(node);
      }
    }, {
      key: 'render',
      value: function render() {
        var _this2 = this;
  
        var _props = this.props,
            src = _props.src,
            altText = _props.altText,
            isIn = _props.in,
            children = _props.children,
            cssModule = _props.cssModule,
            slide = _props.slide,
            transitionProps = objectWithoutProperties(_props, ['src', 'altText', 'in', 'children', 'cssModule', 'slide']);
  
        var imgClasses = mapToCssModules(classNames('d-block', 'img-fluid'), cssModule);
  
        return React__default.createElement(
          Transition,
          _extends({}, transitionProps, {
            enter: slide,
            exit: slide,
            'in': isIn,
            onEnter: this.onEnter,
            onEntering: this.onEntering,
            onExit: this.onExit,
            onExiting: this.onExiting,
            onExited: this.onExited
          }),
          function (status) {
            var direction = _this2.context.direction;
  
            var isActive = status === TransitionStatuses.ENTERED || status === TransitionStatuses.EXITING;
            var directionClassName = (status === TransitionStatuses.ENTERING || status === TransitionStatuses.EXITING) && _this2.state.startAnimation && (direction === 'right' ? 'carousel-item-left' : 'carousel-item-right');
            var orderClassName = status === TransitionStatuses.ENTERING && (direction === 'right' ? 'carousel-item-next' : 'carousel-item-prev');
            var itemClasses = mapToCssModules(classNames('carousel-item', isActive && 'active', directionClassName, orderClassName), cssModule);
  
            return React__default.createElement(
              'div',
              { className: itemClasses },
              React__default.createElement('img', { className: imgClasses, src: src, alt: altText }),
              children
            );
          }
        );
      }
    }]);
    return CarouselItem;
  }(React__default.Component);
  
  CarouselItem.propTypes = _extends({}, Transition.propTypes, {
    in: PropTypes.bool,
    src: PropTypes.string.isRequired,
    altText: PropTypes.string,
    cssModule: PropTypes.object,
    children: PropTypes.shape({
      type: PropTypes.oneOf([CarouselCaption])
    }),
    slide: PropTypes.bool
  });
  
  CarouselItem.defaultProps = _extends({}, Transition.defaultProps, {
    timeout: TransitionTimeouts.Carousel,
    slide: true
  });
  
  CarouselItem.contextTypes = {
    direction: PropTypes.string
  };
  
  var Carousel = function (_React$Component) {
    inherits(Carousel, _React$Component);
  
    function Carousel(props) {
      classCallCheck(this, Carousel);
  
      var _this = possibleConstructorReturn(this, (Carousel.__proto__ || Object.getPrototypeOf(Carousel)).call(this, props));
  
      _this.handleKeyPress = _this.handleKeyPress.bind(_this);
      _this.renderItems = _this.renderItems.bind(_this);
      _this.hoverStart = _this.hoverStart.bind(_this);
      _this.hoverEnd = _this.hoverEnd.bind(_this);
      _this.state = { direction: 'right' };
      return _this;
    }
  
    createClass(Carousel, [{
      key: 'getChildContext',
      value: function getChildContext() {
        return { direction: this.state.direction };
      }
    }, {
      key: 'componentDidMount',
      value: function componentDidMount() {
        // Set up the cycle
        if (this.props.ride === 'carousel') {
          this.setInterval();
        }
  
        // TODO: move this to the specific carousel like bootstrap. Currently it will trigger ALL carousels on the page.
        document.addEventListener('keyup', this.handleKeyPress);
      }
    }, {
      key: 'componentWillReceiveProps',
      value: function componentWillReceiveProps(nextProps) {
        this.setInterval(nextProps);
        // Calculate the direction to turn
        if (this.props.activeIndex + 1 === nextProps.activeIndex) {
          this.setState({ direction: 'right' });
        } else if (this.props.activeIndex - 1 === nextProps.activeIndex) {
          this.setState({ direction: 'left' });
        } else if (this.props.activeIndex > nextProps.activeIndex) {
          this.setState({ direction: 'right' });
        } else if (this.props.activeIndex !== nextProps.activeIndex) {
          this.setState({ direction: 'left' });
        }
      }
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {
        this.clearInterval();
        document.removeEventListener('keyup', this.handleKeyPress);
      }
    }, {
      key: 'setInterval',
      value: function (_setInterval) {
        function setInterval() {
          return _setInterval.apply(this, arguments);
        }
  
        setInterval.toString = function () {
          return _setInterval.toString();
        };
  
        return setInterval;
      }(function () {
        var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.props;
  
        // make sure not to have multiple intervals going...
        this.clearInterval();
        if (props.interval) {
          this.cycleInterval = setInterval(function () {
            props.next();
          }, parseInt(props.interval, 10));
        }
      })
    }, {
      key: 'clearInterval',
      value: function (_clearInterval) {
        function clearInterval() {
          return _clearInterval.apply(this, arguments);
        }
  
        clearInterval.toString = function () {
          return _clearInterval.toString();
        };
  
        return clearInterval;
      }(function () {
        clearInterval(this.cycleInterval);
      })
    }, {
      key: 'hoverStart',
      value: function hoverStart() {
        if (this.props.pause === 'hover') {
          this.clearInterval();
        }
        if (this.props.mouseEnter) {
          var _props;
  
          (_props = this.props).mouseEnter.apply(_props, arguments);
        }
      }
    }, {
      key: 'hoverEnd',
      value: function hoverEnd() {
        if (this.props.pause === 'hover') {
          this.setInterval();
        }
        if (this.props.mouseLeave) {
          var _props2;
  
          (_props2 = this.props).mouseLeave.apply(_props2, arguments);
        }
      }
    }, {
      key: 'handleKeyPress',
      value: function handleKeyPress(evt) {
        if (this.props.keyboard) {
          if (evt.keyCode === 37) {
            this.props.previous();
          } else if (evt.keyCode === 39) {
            this.props.next();
          }
        }
      }
    }, {
      key: 'renderItems',
      value: function renderItems(carouselItems, className) {
        var _this2 = this;
  
        var slide = this.props.slide;
  
        return React__default.createElement(
          'div',
          { role: 'listbox', className: className },
          carouselItems.map(function (item, index) {
            var isIn = index === _this2.props.activeIndex;
            return React__default.cloneElement(item, {
              in: isIn,
              slide: slide
            });
          })
        );
      }
    }, {
      key: 'render',
      value: function render() {
        var _props3 = this.props,
            children = _props3.children,
            cssModule = _props3.cssModule,
            slide = _props3.slide;
  
        var outerClasses = mapToCssModules(classNames('carousel', slide && 'slide'), cssModule);
  
        var innerClasses = mapToCssModules(classNames('carousel-inner'), cssModule);
  
        var slidesOnly = children.every(function (child) {
          return child.type === CarouselItem;
        });
  
        // Rendering only slides
        if (slidesOnly) {
          return React__default.createElement(
            'div',
            { className: outerClasses, onMouseEnter: this.hoverStart, onMouseLeave: this.hoverEnd },
            this.renderItems(children, innerClasses)
          );
        }
  
        // Rendering slides and controls
        if (children[0] instanceof Array) {
          var _carouselItems = children[0];
          var _controlLeft = children[1];
          var _controlRight = children[2];
  
          return React__default.createElement(
            'div',
            { className: outerClasses, onMouseEnter: this.hoverStart, onMouseLeave: this.hoverEnd },
            this.renderItems(_carouselItems, innerClasses),
            _controlLeft,
            _controlRight
          );
        }
  
        // Rendering indicators, slides and controls
        var indicators = children[0];
        var carouselItems = children[1];
        var controlLeft = children[2];
        var controlRight = children[3];
  
        return React__default.createElement(
          'div',
          { className: outerClasses, onMouseEnter: this.hoverStart, onMouseLeave: this.hoverEnd },
          indicators,
          this.renderItems(carouselItems, innerClasses),
          controlLeft,
          controlRight
        );
      }
    }]);
    return Carousel;
  }(React__default.Component);
  
  Carousel.propTypes = {
    // the current active slide of the carousel
    activeIndex: PropTypes.number,
    // a function which should advance the carousel to the next slide (via activeIndex)
    next: PropTypes.func.isRequired,
    // a function which should advance the carousel to the previous slide (via activeIndex)
    previous: PropTypes.func.isRequired,
    // controls if the left and right arrow keys should control the carousel
    keyboard: PropTypes.bool,
    /* If set to "hover", pauses the cycling of the carousel on mouseenter and resumes the cycling of the carousel on
     * mouseleave. If set to false, hovering over the carousel won't pause it. (default: "hover")
     */
    pause: PropTypes.oneOf(['hover', false]),
    // Autoplays the carousel after the user manually cycles the first item. If "carousel", autoplays the carousel on load.
    // This is how bootstrap defines it... I would prefer a bool named autoplay or something...
    ride: PropTypes.oneOf(['carousel']),
    // the interval at which the carousel automatically cycles (default: 5000)
    // eslint-disable-next-line react/no-unused-prop-types
    interval: PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.bool]),
    children: PropTypes.array,
    // called when the mouse enters the Carousel
    mouseEnter: PropTypes.func,
    // called when the mouse exits the Carousel
    mouseLeave: PropTypes.func,
    // controls whether the slide animation on the Carousel works or not
    slide: PropTypes.bool,
    cssModule: PropTypes.object
  };
  
  Carousel.defaultProps = {
    interval: 5000,
    pause: 'hover',
    keyboard: true,
    slide: true
  };
  
  Carousel.childContextTypes = {
    direction: PropTypes.string
  };
  
  var CarouselControl = function CarouselControl(props) {
    var direction = props.direction,
        onClickHandler = props.onClickHandler,
        cssModule = props.cssModule,
        directionText = props.directionText;
  
  
    var anchorClasses = mapToCssModules(classNames('carousel-control-' + direction), cssModule);
  
    var iconClasses = mapToCssModules(classNames('carousel-control-' + direction + '-icon'), cssModule);
  
    var screenReaderClasses = mapToCssModules(classNames('sr-only'), cssModule);
  
    return React__default.createElement(
      'a',
      {
        className: anchorClasses,
        role: 'button',
        tabIndex: '0',
        onClick: function onClick(e) {
          e.preventDefault();
          onClickHandler();
        }
      },
      React__default.createElement('span', { className: iconClasses, 'aria-hidden': 'true' }),
      React__default.createElement(
        'span',
        { className: screenReaderClasses },
        directionText || direction
      )
    );
  };
  
  CarouselControl.propTypes = {
    direction: PropTypes.oneOf(['prev', 'next']).isRequired,
    onClickHandler: PropTypes.func.isRequired,
    cssModule: PropTypes.object,
    directionText: PropTypes.string
  };
  
  var CarouselIndicators = function CarouselIndicators(props) {
    var items = props.items,
        activeIndex = props.activeIndex,
        cssModule = props.cssModule,
        onClickHandler = props.onClickHandler;
  
  
    var listClasses = mapToCssModules('carousel-indicators', cssModule);
    var indicators = items.map(function (item, idx) {
      var indicatorClasses = mapToCssModules(classNames({ active: activeIndex === idx }), cssModule);
      return React__default.createElement('li', {
        key: '' + (item.key || item.src) + item.caption + item.altText,
        onClick: function onClick(e) {
          e.preventDefault();
          onClickHandler(idx);
        },
        className: indicatorClasses
      });
    });
  
    return React__default.createElement(
      'ol',
      { className: listClasses },
      indicators
    );
  };
  
  CarouselIndicators.propTypes = {
    items: PropTypes.array.isRequired,
    activeIndex: PropTypes.number.isRequired,
    cssModule: PropTypes.object,
    onClickHandler: PropTypes.func.isRequired
  };
  
  var propTypes$32 = {
    items: PropTypes.array.isRequired,
    indicators: PropTypes.bool,
    controls: PropTypes.bool,
    autoPlay: PropTypes.bool,
    activeIndex: PropTypes.number,
    next: PropTypes.func,
    previous: PropTypes.func,
    goToIndex: PropTypes.func
  };
  
  var UncontrolledCarousel = function (_Component) {
    inherits(UncontrolledCarousel, _Component);
  
    function UncontrolledCarousel(props) {
      classCallCheck(this, UncontrolledCarousel);
  
      var _this = possibleConstructorReturn(this, (UncontrolledCarousel.__proto__ || Object.getPrototypeOf(UncontrolledCarousel)).call(this, props));
  
      _this.animating = false;
      _this.state = { activeIndex: 0 };
      _this.next = _this.next.bind(_this);
      _this.previous = _this.previous.bind(_this);
      _this.goToIndex = _this.goToIndex.bind(_this);
      _this.onExiting = _this.onExiting.bind(_this);
      _this.onExited = _this.onExited.bind(_this);
      return _this;
    }
  
    createClass(UncontrolledCarousel, [{
      key: 'onExiting',
      value: function onExiting() {
        this.animating = true;
      }
    }, {
      key: 'onExited',
      value: function onExited() {
        this.animating = false;
      }
    }, {
      key: 'next',
      value: function next() {
        if (this.animating) return;
        var nextIndex = this.state.activeIndex === this.props.items.length - 1 ? 0 : this.state.activeIndex + 1;
        this.setState({ activeIndex: nextIndex });
      }
    }, {
      key: 'previous',
      value: function previous() {
        if (this.animating) return;
        var nextIndex = this.state.activeIndex === 0 ? this.props.items.length - 1 : this.state.activeIndex - 1;
        this.setState({ activeIndex: nextIndex });
      }
    }, {
      key: 'goToIndex',
      value: function goToIndex(newIndex) {
        if (this.animating) return;
        this.setState({ activeIndex: newIndex });
      }
    }, {
      key: 'render',
      value: function render() {
        var _this2 = this;
  
        var _props = this.props,
            autoPlay = _props.autoPlay,
            indicators = _props.indicators,
            controls = _props.controls,
            items = _props.items,
            goToIndex = _props.goToIndex,
            props = objectWithoutProperties(_props, ['autoPlay', 'indicators', 'controls', 'items', 'goToIndex']);
        var activeIndex = this.state.activeIndex;
  
  
        var slides = items.map(function (item) {
          return React__default.createElement(
            CarouselItem,
            {
              onExiting: _this2.onExiting,
              onExited: _this2.onExited,
              key: item.src,
              src: item.src,
              altText: item.altText
            },
            React__default.createElement(CarouselCaption, { captionText: item.caption, captionHeader: item.caption })
          );
        });
  
        return React__default.createElement(
          Carousel,
          _extends({
            activeIndex: activeIndex,
            next: this.next,
            previous: this.previous,
            ride: autoPlay && 'carousel'
          }, props),
          indicators && React__default.createElement(CarouselIndicators, {
            items: items,
            activeIndex: props.activeIndex || activeIndex,
            onClickHandler: goToIndex || this.goToIndex
          }),
          slides,
          controls && React__default.createElement(CarouselControl, {
            direction: 'prev',
            directionText: 'Previous',
            onClickHandler: props.previous || this.previous
          }),
          controls && React__default.createElement(CarouselControl, {
            direction: 'next',
            directionText: 'Next',
            onClickHandler: props.next || this.next
          })
        );
      }
    }]);
    return UncontrolledCarousel;
  }(React.Component);
  
  UncontrolledCarousel.propTypes = propTypes$32;
  UncontrolledCarousel.defaultProps = {
    controls: true,
    indicators: true,
    autoPlay: true
  };
  
  var propTypes$33 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$31 = {
    tag: 'h6'
  };
  
  var CardSubtitle = function CardSubtitle(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-subtitle'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardSubtitle.propTypes = propTypes$33;
  CardSubtitle.defaultProps = defaultProps$31;
  
  var propTypes$34 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$32 = {
    tag: 'p'
  };
  
  var CardText = function CardText(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-text'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardText.propTypes = propTypes$34;
  CardText.defaultProps = defaultProps$32;
  
  var propTypes$35 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$33 = {
    tag: 'h4'
  };
  
  var CardTitle = function CardTitle(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'card-title'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  CardTitle.propTypes = propTypes$35;
  CardTitle.defaultProps = defaultProps$33;
  
  var propTypes$36 = {
    children: PropTypes.node.isRequired,
    className: PropTypes.string,
    placement: PropTypes.string,
    placementPrefix: PropTypes.string,
    tag: PropTypes.string,
    isOpen: PropTypes.bool.isRequired,
    cssModule: PropTypes.object,
    offset: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
    fallbackPlacement: PropTypes.oneOfType([PropTypes.string, PropTypes.array]),
    flip: PropTypes.bool,
    container: PropTypes.oneOfType([PropTypes.string, PropTypes.func, DOMElement]),
    target: PropTypes.oneOfType([PropTypes.string, PropTypes.func, DOMElement]).isRequired
  };
  
  var defaultProps$34 = {
    placement: 'auto',
    isOpen: false,
    offset: 0,
    fallbackPlacement: 'flip',
    flip: true,
    container: 'body'
  };
  
  var childContextTypes$1 = {
    popperManager: PropTypes.object.isRequired
  };
  
  var PopperContent = function (_React$Component) {
    inherits(PopperContent, _React$Component);
  
    function PopperContent(props) {
      classCallCheck(this, PopperContent);
  
      var _this = possibleConstructorReturn(this, (PopperContent.__proto__ || Object.getPrototypeOf(PopperContent)).call(this, props));
  
      _this.handlePlacementChange = _this.handlePlacementChange.bind(_this);
      _this.setTargetNode = _this.setTargetNode.bind(_this);
      _this.getTargetNode = _this.getTargetNode.bind(_this);
      _this.state = {};
      return _this;
    }
  
    createClass(PopperContent, [{
      key: 'getChildContext',
      value: function getChildContext() {
        return {
          popperManager: {
            setTargetNode: this.setTargetNode,
            getTargetNode: this.getTargetNode
          }
        };
      }
    }, {
      key: 'componentDidMount',
      value: function componentDidMount() {
        this.handleProps();
      }
    }, {
      key: 'componentDidUpdate',
      value: function componentDidUpdate(prevProps) {
        if (this.props.isOpen !== prevProps.isOpen) {
          this.handleProps();
        } else if (this._element) {
          // rerender
          this.renderIntoSubtree();
        }
      }
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {
        this.hide();
      }
    }, {
      key: 'setTargetNode',
      value: function setTargetNode(node) {
        this.targetNode = node;
      }
    }, {
      key: 'getTargetNode',
      value: function getTargetNode() {
        return this.targetNode;
      }
    }, {
      key: 'getContainerNode',
      value: function getContainerNode() {
        return getTarget(this.props.container);
      }
    }, {
      key: 'handlePlacementChange',
      value: function handlePlacementChange(data) {
        if (this.state.placement !== data.placement) {
          this.setState({ placement: data.placement });
        }
        return data;
      }
    }, {
      key: 'handleProps',
      value: function handleProps() {
        if (this.props.container !== 'inline') {
          if (this.props.isOpen) {
            this.show();
          } else {
            this.hide();
          }
        }
      }
    }, {
      key: 'hide',
      value: function hide() {
        if (this._element) {
          this.getContainerNode().removeChild(this._element);
          ReactDOM.unmountComponentAtNode(this._element);
          this._element = null;
        }
      }
    }, {
      key: 'show',
      value: function show() {
        this._element = document.createElement('div');
        this.getContainerNode().appendChild(this._element);
        this.renderIntoSubtree();
        if (this._element.childNodes && this._element.childNodes[0] && this._element.childNodes[0].focus) {
          this._element.childNodes[0].focus();
        }
      }
    }, {
      key: 'renderIntoSubtree',
      value: function renderIntoSubtree() {
        ReactDOM.unstable_renderSubtreeIntoContainer(this, this.renderChildren(), this._element);
      }
    }, {
      key: 'renderChildren',
      value: function renderChildren() {
        var _props = this.props,
            cssModule = _props.cssModule,
            children = _props.children,
            isOpen = _props.isOpen,
            flip = _props.flip,
            target = _props.target,
            offset = _props.offset,
            fallbackPlacement = _props.fallbackPlacement,
            placementPrefix = _props.placementPrefix,
            className = _props.className,
            tag = _props.tag,
            container = _props.container,
            attrs = objectWithoutProperties(_props, ['cssModule', 'children', 'isOpen', 'flip', 'target', 'offset', 'fallbackPlacement', 'placementPrefix', 'className', 'tag', 'container']);
  
        var arrowClassName = mapToCssModules('arrow', cssModule);
        var placement = (this.state.placement || attrs.placement).split('-')[0];
        var popperClassName = mapToCssModules(classNames(className, placementPrefix ? placementPrefix + '-' + placement : placement), this.props.cssModule);
  
        var modifiers = {
          offset: { offset: offset },
          flip: { enabled: flip, behavior: fallbackPlacement },
          update: {
            enabled: true,
            order: 950,
            fn: this.handlePlacementChange
          }
        };
  
        return React__default.createElement(
          reactPopper.Popper,
          _extends({ modifiers: modifiers }, attrs, { component: tag, className: popperClassName }),
          children,
          React__default.createElement(reactPopper.Arrow, { className: arrowClassName })
        );
      }
    }, {
      key: 'render',
      value: function render() {
        this.setTargetNode(getTarget(this.props.target));
  
        if (this.props.container === 'inline') {
          return this.props.isOpen ? this.renderChildren() : null;
        }
  
        return null;
      }
    }]);
    return PopperContent;
  }(React__default.Component);
  
  PopperContent.propTypes = propTypes$36;
  PopperContent.defaultProps = defaultProps$34;
  PopperContent.childContextTypes = childContextTypes$1;
  
  var PopperTargetHelper = function PopperTargetHelper(props, context) {
    context.popperManager.setTargetNode(getTarget(props.target));
    return null;
  };
  
  PopperTargetHelper.contextTypes = {
    popperManager: PropTypes.object.isRequired
  };
  
  PopperTargetHelper.propTypes = {
    target: PropTypes.oneOfType([PropTypes.string, PropTypes.func, DOMElement]).isRequired
  };
  
  var propTypes$37 = {
    placement: PropTypes.oneOf(PopperPlacements),
    target: PropTypes.oneOfType([PropTypes.string, PropTypes.func, DOMElement]).isRequired,
    container: PropTypes.oneOfType([PropTypes.string, PropTypes.func, DOMElement]),
    isOpen: PropTypes.bool,
    disabled: PropTypes.bool,
    className: PropTypes.string,
    innerClassName: PropTypes.string,
    placementPrefix: PropTypes.string,
    cssModule: PropTypes.object,
    toggle: PropTypes.func,
    delay: PropTypes.oneOfType([PropTypes.shape({ show: PropTypes.number, hide: PropTypes.number }), PropTypes.number])
  };
  
  var DEFAULT_DELAYS = {
    show: 0,
    hide: 0
  };
  
  var defaultProps$35 = {
    isOpen: false,
    placement: 'right',
    placementPrefix: 'bs-popover',
    delay: DEFAULT_DELAYS,
    toggle: function toggle() {}
  };
  
  var Popover = function (_React$Component) {
    inherits(Popover, _React$Component);
  
    function Popover(props) {
      classCallCheck(this, Popover);
  
      var _this = possibleConstructorReturn(this, (Popover.__proto__ || Object.getPrototypeOf(Popover)).call(this, props));
  
      _this.addTargetEvents = _this.addTargetEvents.bind(_this);
      _this.handleDocumentClick = _this.handleDocumentClick.bind(_this);
      _this.removeTargetEvents = _this.removeTargetEvents.bind(_this);
      _this.getRef = _this.getRef.bind(_this);
      _this.toggle = _this.toggle.bind(_this);
      _this.show = _this.show.bind(_this);
      _this.hide = _this.hide.bind(_this);
      return _this;
    }
  
    createClass(Popover, [{
      key: 'componentDidMount',
      value: function componentDidMount() {
        this._target = getTarget(this.props.target);
        this.handleProps();
      }
    }, {
      key: 'componentDidUpdate',
      value: function componentDidUpdate() {
        this.handleProps();
      }
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {
        this.clearShowTimeout();
        this.clearHideTimeout();
        this.removeTargetEvents();
      }
    }, {
      key: 'getRef',
      value: function getRef(ref) {
        this._popover = ref;
      }
    }, {
      key: 'getDelay',
      value: function getDelay(key) {
        var delay = this.props.delay;
  
        if ((typeof delay === 'undefined' ? 'undefined' : _typeof(delay)) === 'object') {
          return isNaN(delay[key]) ? DEFAULT_DELAYS[key] : delay[key];
        }
        return delay;
      }
    }, {
      key: 'handleProps',
      value: function handleProps() {
        if (this.props.isOpen) {
          this.show();
        } else {
          this.hide();
        }
      }
    }, {
      key: 'show',
      value: function show() {
        this.clearHideTimeout();
        this.addTargetEvents();
        if (!this.props.isOpen) {
          this.clearShowTimeout();
          this._showTimeout = setTimeout(this.toggle, this.getDelay('show'));
        }
      }
    }, {
      key: 'hide',
      value: function hide() {
        this.clearShowTimeout();
        this.removeTargetEvents();
        if (this.props.isOpen) {
          this.clearHideTimeout();
          this._hideTimeout = setTimeout(this.toggle, this.getDelay('hide'));
        }
      }
    }, {
      key: 'clearShowTimeout',
      value: function clearShowTimeout() {
        clearTimeout(this._showTimeout);
        this._showTimeout = undefined;
      }
    }, {
      key: 'clearHideTimeout',
      value: function clearHideTimeout() {
        clearTimeout(this._hideTimeout);
        this._hideTimeout = undefined;
      }
    }, {
      key: 'handleDocumentClick',
      value: function handleDocumentClick(e) {
        if (e.target !== this._target && !this._target.contains(e.target) && e.target !== this._popover && !(this._popover && this._popover.contains(e.target))) {
          if (this._hideTimeout) {
            this.clearHideTimeout();
          }
  
          if (this.props.isOpen) {
            this.toggle();
          }
        }
      }
    }, {
      key: 'addTargetEvents',
      value: function addTargetEvents() {
        var _this2 = this;
  
        ['click', 'touchstart'].forEach(function (event) {
          return document.addEventListener(event, _this2.handleDocumentClick, true);
        });
      }
    }, {
      key: 'removeTargetEvents',
      value: function removeTargetEvents() {
        var _this3 = this;
  
        ['click', 'touchstart'].forEach(function (event) {
          return document.removeEventListener(event, _this3.handleDocumentClick, true);
        });
      }
    }, {
      key: 'toggle',
      value: function toggle(e) {
        if (this.props.disabled) {
          return e && e.preventDefault();
        }
  
        return this.props.toggle();
      }
    }, {
      key: 'render',
      value: function render() {
        if (!this.props.isOpen) {
          return null;
        }
  
        var attributes = omit(this.props, Object.keys(propTypes$37));
        var classes = mapToCssModules(classNames('popover-inner', this.props.innerClassName), this.props.cssModule);
  
        var popperClasses = mapToCssModules(classNames('popover', 'show', this.props.className), this.props.cssModule);
  
        return React__default.createElement(
          PopperContent,
          {
            className: popperClasses,
            target: this.props.target,
            isOpen: this.props.isOpen,
            placement: this.props.placement,
            placementPrefix: this.props.placementPrefix,
            container: this.props.container
          },
          React__default.createElement('div', _extends({}, attributes, { className: classes, ref: this.getRef }))
        );
      }
    }]);
    return Popover;
  }(React__default.Component);
  
  Popover.propTypes = propTypes$37;
  Popover.defaultProps = defaultProps$35;
  
  var propTypes$38 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$36 = {
    tag: 'h3'
  };
  
  var PopoverHeader = function PopoverHeader(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'popover-header'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  PopoverHeader.propTypes = propTypes$38;
  PopoverHeader.defaultProps = defaultProps$36;
  
  function PopoverTitle(props) {
    warnOnce('The "PopoverTitle" component has been deprecated.\nPlease use component "PopoverHeader".');
    return React__default.createElement(PopoverHeader, props);
  }
  
  var propTypes$39 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$37 = {
    tag: 'div'
  };
  
  var PopoverBody = function PopoverBody(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'popover-body'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  PopoverBody.propTypes = propTypes$39;
  PopoverBody.defaultProps = defaultProps$37;
  
  function PopoverContent(props) {
    warnOnce('The "PopoverContent" component has been deprecated.\nPlease use component "PopoverBody".');
    return React__default.createElement(PopoverBody, props);
  }
  
  var propTypes$40 = {
    children: PropTypes.node,
    bar: PropTypes.bool,
    multi: PropTypes.bool,
    tag: PropTypes.string,
    value: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
    max: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
    animated: PropTypes.bool,
    striped: PropTypes.bool,
    color: PropTypes.string,
    className: PropTypes.string,
    barClassName: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$38 = {
    tag: 'div',
    value: 0,
    max: 100
  };
  
  var Progress = function Progress(props) {
    var children = props.children,
        className = props.className,
        barClassName = props.barClassName,
        cssModule = props.cssModule,
        value = props.value,
        max = props.max,
        animated = props.animated,
        striped = props.striped,
        color = props.color,
        bar = props.bar,
        multi = props.multi,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['children', 'className', 'barClassName', 'cssModule', 'value', 'max', 'animated', 'striped', 'color', 'bar', 'multi', 'tag']);
  
  
    var percent = toNumber(value) / toNumber(max) * 100;
  
    var progressClasses = mapToCssModules(classNames(className, 'progress'), cssModule);
  
    var progressBarClasses = mapToCssModules(classNames('progress-bar', bar ? className || barClassName : barClassName, animated ? 'progress-bar-animated' : null, color ? 'bg-' + color : null, striped || animated ? 'progress-bar-striped' : null), cssModule);
  
    var ProgressBar = multi ? children : React__default.createElement('div', {
      className: progressBarClasses,
      style: { width: percent + '%' },
      role: 'progressbar',
      'aria-valuenow': value,
      'aria-valuemin': '0',
      'aria-valuemax': max,
      children: children
    });
  
    if (bar) {
      return ProgressBar;
    }
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: progressClasses, children: ProgressBar }));
  };
  
  Progress.propTypes = propTypes$40;
  Progress.defaultProps = defaultProps$38;
  
  function noop() {}
  
  var FadePropTypes = PropTypes.shape(Fade.propTypes);
  
  var propTypes$41 = {
    isOpen: PropTypes.bool,
    autoFocus: PropTypes.bool,
    size: PropTypes.string,
    toggle: PropTypes.func,
    keyboard: PropTypes.bool,
    role: PropTypes.string,
    labelledBy: PropTypes.string,
    backdrop: PropTypes.oneOfType([PropTypes.bool, PropTypes.oneOf(['static'])]),
    onEnter: PropTypes.func,
    onExit: PropTypes.func,
    onOpened: PropTypes.func,
    onClosed: PropTypes.func,
    children: PropTypes.node,
    className: PropTypes.string,
    wrapClassName: PropTypes.string,
    modalClassName: PropTypes.string,
    backdropClassName: PropTypes.string,
    contentClassName: PropTypes.string,
    fade: PropTypes.bool,
    cssModule: PropTypes.object,
    zIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
    backdropTransition: FadePropTypes,
    modalTransition: FadePropTypes
  };
  
  var propsToOmit = Object.keys(propTypes$41);
  
  var defaultProps$39 = {
    isOpen: false,
    autoFocus: true,
    role: 'dialog',
    backdrop: true,
    keyboard: true,
    zIndex: 1050,
    fade: true,
    onOpened: noop,
    onClosed: noop,
    modalTransition: {
      timeout: TransitionTimeouts.Modal
    },
    backdropTransition: {
      mountOnEnter: true,
      timeout: TransitionTimeouts.Fade // uses standard fade transition
    }
  };
  
  var Modal = function (_React$Component) {
    inherits(Modal, _React$Component);
  
    function Modal(props) {
      classCallCheck(this, Modal);
  
      var _this = possibleConstructorReturn(this, (Modal.__proto__ || Object.getPrototypeOf(Modal)).call(this, props));
  
      _this.originalBodyPadding = null;
      _this.isBodyOverflowing = false;
      _this.togglePortal = _this.togglePortal.bind(_this);
      _this.handleBackdropClick = _this.handleBackdropClick.bind(_this);
      _this.handleEscape = _this.handleEscape.bind(_this);
      _this.destroy = _this.destroy.bind(_this);
      _this.onOpened = _this.onOpened.bind(_this);
      _this.onClosed = _this.onClosed.bind(_this);
      return _this;
    }
  
    createClass(Modal, [{
      key: 'componentDidMount',
      value: function componentDidMount() {
        if (this.props.isOpen) {
          this.togglePortal();
        }
        if (this.props.onEnter) {
          this.props.onEnter();
        }
      }
    }, {
      key: 'componentDidUpdate',
      value: function componentDidUpdate(prevProps) {
        if (this.props.isOpen !== prevProps.isOpen) {
          // handle portal events/dom updates
          this.togglePortal();
        } else if (this._element) {
          // rerender portal
          this.renderIntoSubtree();
        }
      }
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {
        this.destroy();
        if (this.props.onExit) {
          this.props.onExit();
        }
      }
    }, {
      key: 'onOpened',
      value: function onOpened(node, isAppearing) {
        this.props.onOpened();
        (this.props.modalTransition.onEntered || noop)(node, isAppearing);
      }
    }, {
      key: 'onClosed',
      value: function onClosed(node) {
        var _this2 = this;
  
        // so all methods get called before it is unmounted
        setTimeout(function () {
          return _this2.destroy();
        }, 0);
        this.props.onClosed();
        (this.props.modalTransition.onExited || noop)(node);
      }
    }, {
      key: 'handleEscape',
      value: function handleEscape(e) {
        if (this.props.keyboard && e.keyCode === 27 && this.props.toggle) {
          this.props.toggle();
        }
      }
    }, {
      key: 'handleBackdropClick',
      value: function handleBackdropClick(e) {
        if (this.props.backdrop !== true) return;
  
        var container = this._dialog;
  
        if (e.target && !container.contains(e.target) && this.props.toggle) {
          this.props.toggle();
        }
      }
    }, {
      key: 'togglePortal',
      value: function togglePortal() {
        if (this.props.isOpen) {
          if (this.props.autoFocus) {
            this._focus = true;
          }
          this.show();
        } else {
          this.hide();
        }
      }
    }, {
      key: 'destroy',
      value: function destroy() {
        if (this._element) {
          ReactDOM.unmountComponentAtNode(this._element);
          document.body.removeChild(this._element);
          this._element = null;
        }
  
        // Use regex to prevent matching `modal-open` as part of a different class, e.g. `my-modal-opened`
        var classes = document.body.className.replace(/(^| )modal-open( |$)/, ' ');
        document.body.className = mapToCssModules(classNames(classes).trim(), this.props.cssModule);
        setScrollbarWidth(this.originalBodyPadding);
      }
    }, {
      key: 'hide',
      value: function hide() {
        this.renderIntoSubtree();
      }
    }, {
      key: 'show',
      value: function show() {
        var classes = document.body.className;
        this._element = document.createElement('div');
        this._element.setAttribute('tabindex', '-1');
        this._element.style.position = 'relative';
        this._element.style.zIndex = this.props.zIndex;
        this.originalBodyPadding = getOriginalBodyPadding();
  
        conditionallyUpdateScrollbar();
  
        document.body.appendChild(this._element);
  
        document.body.className = mapToCssModules(classNames(classes, 'modal-open'), this.props.cssModule);
  
        this.renderIntoSubtree();
      }
    }, {
      key: 'renderModalDialog',
      value: function renderModalDialog() {
        var _this3 = this;
  
        var attributes = omit(this.props, propsToOmit);
  
        return React__default.createElement(
          'div',
          _extends({
            className: mapToCssModules(classNames('modal-dialog', this.props.className, defineProperty({}, 'modal-' + this.props.size, this.props.size)), this.props.cssModule),
            role: 'document',
            ref: function ref(c) {
              _this3._dialog = c;
            }
          }, attributes),
          React__default.createElement(
            'div',
            {
              className: mapToCssModules(classNames('modal-content', this.props.contentClassName), this.props.cssModule)
            },
            this.props.children
          )
        );
      }
    }, {
      key: 'renderIntoSubtree',
      value: function renderIntoSubtree() {
        ReactDOM.unstable_renderSubtreeIntoContainer(this, this.renderChildren(), this._element);
  
        // check if modal should receive focus
        if (this._focus) {
          if (this._dialog && this._dialog.parentNode && typeof this._dialog.parentNode.focus === 'function') {
            this._dialog.parentNode.focus();
          }
          this._focus = false;
        }
      }
    }, {
      key: 'renderChildren',
      value: function renderChildren() {
        var _props = this.props,
            wrapClassName = _props.wrapClassName,
            modalClassName = _props.modalClassName,
            backdropClassName = _props.backdropClassName,
            cssModule = _props.cssModule,
            isOpen = _props.isOpen,
            backdrop = _props.backdrop,
            role = _props.role,
            labelledBy = _props.labelledBy;
  
  
        var modalAttributes = {
          onClickCapture: this.handleBackdropClick,
          onKeyUp: this.handleEscape,
          style: { display: 'block' },
          'aria-labelledby': labelledBy,
          role: role,
          tabIndex: '-1'
        };
  
        var hasTransition = this.props.fade;
        var modalTransition = _extends({}, Fade.defaultProps, this.props.modalTransition, {
          baseClass: hasTransition ? this.props.modalTransition.baseClass : '',
          timeout: hasTransition ? this.props.modalTransition.timeout : 0
        });
        var backdropTransition = _extends({}, Fade.defaultProps, this.props.backdropTransition, {
          baseClass: hasTransition ? this.props.backdropTransition.baseClass : '',
          timeout: hasTransition ? this.props.backdropTransition.timeout : 0
        });
        return React__default.createElement(
          'div',
          { className: mapToCssModules(wrapClassName) },
          React__default.createElement(
            Fade,
            _extends({}, modalAttributes, modalTransition, {
              'in': isOpen,
              onEntered: this.onOpened,
              onExited: this.onClosed,
              cssModule: cssModule,
              className: mapToCssModules(classNames('modal', modalClassName), cssModule)
            }),
            this.renderModalDialog()
          ),
          React__default.createElement(Fade, _extends({}, backdropTransition, {
            'in': isOpen && !!backdrop,
            cssModule: cssModule,
            className: mapToCssModules(classNames('modal-backdrop', backdropClassName), cssModule)
          }))
        );
      }
    }, {
      key: 'render',
      value: function render() {
        return null;
      }
    }]);
    return Modal;
  }(React__default.Component);
  
  Modal.propTypes = propTypes$41;
  Modal.defaultProps = defaultProps$39;
  
  var propTypes$42 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    wrapTag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    toggle: PropTypes.func,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    children: PropTypes.node,
    closeAriaLabel: PropTypes.string
  };
  
  var defaultProps$40 = {
    tag: 'h4',
    wrapTag: 'div',
    closeAriaLabel: 'Close'
  };
  
  var ModalHeader = function ModalHeader(props) {
    var closeButton = void 0;
    var className = props.className,
        cssModule = props.cssModule,
        children = props.children,
        toggle = props.toggle,
        Tag = props.tag,
        WrapTag = props.wrapTag,
        closeAriaLabel = props.closeAriaLabel,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'children', 'toggle', 'tag', 'wrapTag', 'closeAriaLabel']);
  
  
    var classes = mapToCssModules(classNames(className, 'modal-header'), cssModule);
  
    if (toggle) {
      closeButton = React__default.createElement(
        'button',
        { type: 'button', onClick: toggle, className: 'close', 'aria-label': closeAriaLabel },
        React__default.createElement(
          'span',
          { 'aria-hidden': 'true' },
          String.fromCharCode(215)
        )
      );
    }
  
    return React__default.createElement(
      WrapTag,
      _extends({}, attributes, { className: classes }),
      React__default.createElement(
        Tag,
        { className: mapToCssModules('modal-title', cssModule) },
        children
      ),
      closeButton
    );
  };
  
  ModalHeader.propTypes = propTypes$42;
  ModalHeader.defaultProps = defaultProps$40;
  
  var propTypes$43 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$41 = {
    tag: 'div'
  };
  
  var ModalBody = function ModalBody(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'modal-body'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  ModalBody.propTypes = propTypes$43;
  ModalBody.defaultProps = defaultProps$41;
  
  var propTypes$44 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$42 = {
    tag: 'div'
  };
  
  var ModalFooter = function ModalFooter(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'modal-footer'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  ModalFooter.propTypes = propTypes$44;
  ModalFooter.defaultProps = defaultProps$42;
  
  var propTypes$45 = {
    placement: PropTypes.oneOf(PopperPlacements),
    target: PropTypes.oneOfType([PropTypes.string, PropTypes.func, DOMElement]).isRequired,
    container: PropTypes.oneOfType([PropTypes.string, PropTypes.func, DOMElement]),
    isOpen: PropTypes.bool,
    disabled: PropTypes.bool,
    className: PropTypes.string,
    innerClassName: PropTypes.string,
    cssModule: PropTypes.object,
    toggle: PropTypes.func,
    autohide: PropTypes.bool,
    placementPrefix: PropTypes.string,
    delay: PropTypes.oneOfType([PropTypes.shape({ show: PropTypes.number, hide: PropTypes.number }), PropTypes.number])
  };
  
  var DEFAULT_DELAYS$1 = {
    show: 0,
    hide: 250
  };
  
  var defaultProps$43 = {
    isOpen: false,
    placement: 'top',
    placementPrefix: 'bs-tooltip',
    delay: DEFAULT_DELAYS$1,
    autohide: true,
    toggle: function toggle() {}
  };
  
  var Tooltip = function (_React$Component) {
    inherits(Tooltip, _React$Component);
  
    function Tooltip(props) {
      classCallCheck(this, Tooltip);
  
      var _this = possibleConstructorReturn(this, (Tooltip.__proto__ || Object.getPrototypeOf(Tooltip)).call(this, props));
  
      _this.addTargetEvents = _this.addTargetEvents.bind(_this);
      _this.handleDocumentClick = _this.handleDocumentClick.bind(_this);
      _this.removeTargetEvents = _this.removeTargetEvents.bind(_this);
      _this.toggle = _this.toggle.bind(_this);
      _this.onMouseOverTooltip = _this.onMouseOverTooltip.bind(_this);
      _this.onMouseLeaveTooltip = _this.onMouseLeaveTooltip.bind(_this);
      _this.onMouseOverTooltipContent = _this.onMouseOverTooltipContent.bind(_this);
      _this.onMouseLeaveTooltipContent = _this.onMouseLeaveTooltipContent.bind(_this);
      _this.show = _this.show.bind(_this);
      _this.hide = _this.hide.bind(_this);
      return _this;
    }
  
    createClass(Tooltip, [{
      key: 'componentDidMount',
      value: function componentDidMount() {
        this._target = getTarget(this.props.target);
        this.addTargetEvents();
      }
    }, {
      key: 'componentWillUnmount',
      value: function componentWillUnmount() {
        this.removeTargetEvents();
      }
    }, {
      key: 'onMouseOverTooltip',
      value: function onMouseOverTooltip() {
        if (this._hideTimeout) {
          this.clearHideTimeout();
        }
        this._showTimeout = setTimeout(this.show, this.getDelay('show'));
      }
    }, {
      key: 'onMouseLeaveTooltip',
      value: function onMouseLeaveTooltip() {
        if (this._showTimeout) {
          this.clearShowTimeout();
        }
        this._hideTimeout = setTimeout(this.hide, this.getDelay('hide'));
      }
    }, {
      key: 'onMouseOverTooltipContent',
      value: function onMouseOverTooltipContent() {
        if (this.props.autohide) {
          return;
        }
        if (this._hideTimeout) {
          this.clearHideTimeout();
        }
      }
    }, {
      key: 'onMouseLeaveTooltipContent',
      value: function onMouseLeaveTooltipContent() {
        if (this.props.autohide) {
          return;
        }
        if (this._showTimeout) {
          this.clearShowTimeout();
        }
        this._hideTimeout = setTimeout(this.hide, this.getDelay('hide'));
      }
    }, {
      key: 'getDelay',
      value: function getDelay(key) {
        var delay = this.props.delay;
  
        if ((typeof delay === 'undefined' ? 'undefined' : _typeof(delay)) === 'object') {
          return isNaN(delay[key]) ? DEFAULT_DELAYS$1[key] : delay[key];
        }
        return delay;
      }
    }, {
      key: 'show',
      value: function show() {
        if (!this.props.isOpen) {
          this.clearShowTimeout();
          this.toggle();
        }
      }
    }, {
      key: 'hide',
      value: function hide() {
        if (this.props.isOpen) {
          this.clearHideTimeout();
          this.toggle();
        }
      }
    }, {
      key: 'clearShowTimeout',
      value: function clearShowTimeout() {
        clearTimeout(this._showTimeout);
        this._showTimeout = undefined;
      }
    }, {
      key: 'clearHideTimeout',
      value: function clearHideTimeout() {
        clearTimeout(this._hideTimeout);
        this._hideTimeout = undefined;
      }
    }, {
      key: 'handleDocumentClick',
      value: function handleDocumentClick(e) {
        if (e.target === this._target || this._target.contains(e.target)) {
          if (this._hideTimeout) {
            this.clearHideTimeout();
          }
  
          if (!this.props.isOpen) {
            this.toggle();
          }
        }
      }
    }, {
      key: 'addTargetEvents',
      value: function addTargetEvents() {
        var _this2 = this;
  
        this._target.addEventListener('mouseover', this.onMouseOverTooltip, true);
        this._target.addEventListener('mouseout', this.onMouseLeaveTooltip, true);
        ['click', 'touchstart'].forEach(function (event) {
          return document.addEventListener(event, _this2.handleDocumentClick, true);
        });
      }
    }, {
      key: 'removeTargetEvents',
      value: function removeTargetEvents() {
        var _this3 = this;
  
        this._target.removeEventListener('mouseover', this.onMouseOverTooltip, true);
        this._target.removeEventListener('mouseout', this.onMouseLeaveTooltip, true);
        ['click', 'touchstart'].forEach(function (event) {
          return document.removeEventListener(event, _this3.handleDocumentClick, true);
        });
      }
    }, {
      key: 'toggle',
      value: function toggle(e) {
        if (this.props.disabled) {
          return e && e.preventDefault();
        }
  
        return this.props.toggle();
      }
    }, {
      key: 'render',
      value: function render() {
        if (!this.props.isOpen) {
          return null;
        }
  
        var attributes = omit(this.props, Object.keys(propTypes$45));
        var classes = mapToCssModules(classNames('tooltip-inner', this.props.innerClassName), this.props.cssModule);
  
        var popperClasses = mapToCssModules(classNames('tooltip', 'show', this.props.className), this.props.cssModule);
  
        return React__default.createElement(
          PopperContent,
          {
            className: popperClasses,
            target: this.props.target,
            isOpen: this.props.isOpen,
            placement: this.props.placement,
            placementPrefix: this.props.placementPrefix,
            container: this.props.container
          },
          React__default.createElement('div', _extends({}, attributes, {
            className: classes,
            onMouseOver: this.onMouseOverTooltipContent,
            onMouseLeave: this.onMouseLeaveTooltipContent
          }))
        );
      }
    }]);
    return Tooltip;
  }(React__default.Component);
  
  Tooltip.propTypes = propTypes$45;
  Tooltip.defaultProps = defaultProps$43;
  
  var propTypes$46 = {
    className: PropTypes.string,
    cssModule: PropTypes.object,
    size: PropTypes.string,
    bordered: PropTypes.bool,
    striped: PropTypes.bool,
    inverse: PropTypes.bool,
    hover: PropTypes.bool,
    reflow: PropTypes.bool,
    responsive: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    responsiveTag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
  };
  
  var defaultProps$44 = {
    tag: 'table',
    responsiveTag: 'div'
  };
  
  var Table = function Table(props) {
    var className = props.className,
        cssModule = props.cssModule,
        size = props.size,
        bordered = props.bordered,
        striped = props.striped,
        inverse = props.inverse,
        hover = props.hover,
        reflow = props.reflow,
        responsive = props.responsive,
        Tag = props.tag,
        ResponsiveTag = props.responsiveTag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'size', 'bordered', 'striped', 'inverse', 'hover', 'reflow', 'responsive', 'tag', 'responsiveTag']);
  
  
    var classes = mapToCssModules(classNames(className, 'table', size ? 'table-' + size : false, bordered ? 'table-bordered' : false, striped ? 'table-striped' : false, inverse ? 'table-inverse' : false, hover ? 'table-hover' : false, reflow ? 'table-reflow' : false), cssModule);
  
    var table = React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  
    if (responsive) {
      return React__default.createElement(
        ResponsiveTag,
        { className: 'table-responsive' },
        table
      );
    }
  
    return table;
  };
  
  Table.propTypes = propTypes$46;
  Table.defaultProps = defaultProps$44;
  
  var propTypes$47 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    flush: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$45 = {
    tag: 'ul'
  };
  
  var ListGroup = function ListGroup(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        flush = props.flush,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag', 'flush']);
  
    var classes = mapToCssModules(classNames(className, 'list-group', flush ? 'list-group-flush' : false), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  ListGroup.propTypes = propTypes$47;
  ListGroup.defaultProps = defaultProps$45;
  
  var propTypes$48 = {
    children: PropTypes.node,
    inline: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$46 = {
    tag: 'form'
  };
  
  var Form = function Form(props) {
    var className = props.className,
        cssModule = props.cssModule,
        inline = props.inline,
        Tag = props.tag,
        innerRef = props.innerRef,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'inline', 'tag', 'innerRef']);
  
  
    var classes = mapToCssModules(classNames(className, inline ? 'form-inline' : false), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { ref: innerRef, className: classes }));
  };
  
  Form.propTypes = propTypes$48;
  Form.defaultProps = defaultProps$46;
  
  var propTypes$49 = {
    children: PropTypes.node,
    tag: PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$47 = {
    tag: 'div'
  };
  
  var FormFeedback = function FormFeedback(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'invalid-feedback'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  FormFeedback.propTypes = propTypes$49;
  FormFeedback.defaultProps = defaultProps$47;
  
  var propTypes$50 = {
    children: PropTypes.node,
    row: PropTypes.bool,
    check: PropTypes.bool,
    disabled: PropTypes.bool,
    tag: PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$48 = {
    tag: 'div'
  };
  
  var FormGroup = function FormGroup(props) {
    var className = props.className,
        cssModule = props.cssModule,
        row = props.row,
        disabled = props.disabled,
        check = props.check,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'row', 'disabled', 'check', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, row ? 'row' : false, check ? 'form-check' : 'form-group', check && disabled ? 'disabled' : false), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  FormGroup.propTypes = propTypes$50;
  FormGroup.defaultProps = defaultProps$48;
  
  var propTypes$51 = {
    children: PropTypes.node,
    inline: PropTypes.bool,
    tag: PropTypes.string,
    color: PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$49 = {
    tag: 'small',
    color: 'muted'
  };
  
  var FormText = function FormText(props) {
    var className = props.className,
        cssModule = props.cssModule,
        inline = props.inline,
        color = props.color,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'inline', 'color', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, !inline ? 'form-text' : false, color ? 'text-' + color : false), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  FormText.propTypes = propTypes$51;
  FormText.defaultProps = defaultProps$49;
  
  /* eslint react/prefer-stateless-function: 0 */
  
  var propTypes$52 = {
    children: PropTypes.node,
    type: PropTypes.string,
    size: PropTypes.string,
    state: deprecated(PropTypes.string, 'Please use the prop "valid"'),
    valid: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    static: deprecated(PropTypes.bool, 'Please use the prop "plaintext"'),
    plaintext: PropTypes.bool,
    addon: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$50 = {
    tag: 'p',
    type: 'text'
  };
  
  var Input = function (_React$Component) {
    inherits(Input, _React$Component);
  
    function Input() {
      classCallCheck(this, Input);
      return possibleConstructorReturn(this, (Input.__proto__ || Object.getPrototypeOf(Input)).apply(this, arguments));
    }
  
    createClass(Input, [{
      key: 'render',
      value: function render() {
        var _props = this.props,
            className = _props.className,
            cssModule = _props.cssModule,
            type = _props.type,
            size = _props.size,
            state = _props.state,
            valid = _props.valid,
            tag = _props.tag,
            addon = _props.addon,
            staticInput = _props.static,
            plaintext = _props.plaintext,
            innerRef = _props.innerRef,
            attributes = objectWithoutProperties(_props, ['className', 'cssModule', 'type', 'size', 'state', 'valid', 'tag', 'addon', 'static', 'plaintext', 'innerRef']);
  
  
        var checkInput = ['radio', 'checkbox'].indexOf(type) > -1;
  
        var fileInput = type === 'file';
        var textareaInput = type === 'textarea';
        var selectInput = type === 'select';
        var Tag = selectInput || textareaInput ? type : 'input';
  
        var formControlClass = 'form-control';
  
        if (plaintext || staticInput) {
          formControlClass = formControlClass + '-plaintext';
          Tag = tag;
        } else if (fileInput) {
          formControlClass = formControlClass + '-file';
        } else if (checkInput) {
          if (addon) {
            formControlClass = null;
          } else {
            formControlClass = 'form-check-input';
          }
        }
  
        if (state && typeof valid === 'undefined') {
          if (state === 'danger') {
            valid = false;
          } else if (state === 'success') {
            valid = true;
          }
        }
  
        var classes = mapToCssModules(classNames(className, valid === false && 'is-invalid', valid && 'is-valid', size ? 'form-control-' + size : false, formControlClass), cssModule);
  
        if (Tag === 'input') {
          attributes.type = type;
        }
  
        return React__default.createElement(Tag, _extends({}, attributes, { ref: innerRef, className: classes }));
      }
    }]);
    return Input;
  }(React__default.Component);
  
  Input.propTypes = propTypes$52;
  Input.defaultProps = defaultProps$50;
  
  var propTypes$53 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    size: PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$51 = {
    tag: 'div'
  };
  
  var InputGroup = function InputGroup(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        size = props.size,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag', 'size']);
  
    var classes = mapToCssModules(classNames(className, 'input-group', size ? 'input-group-' + size : null), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  InputGroup.propTypes = propTypes$53;
  InputGroup.defaultProps = defaultProps$51;
  
  var propTypes$54 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$52 = {
    tag: 'div'
  };
  
  var InputGroupAddon = function InputGroupAddon(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag']);
  
    var classes = mapToCssModules(classNames(className, 'input-group-addon'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  InputGroupAddon.propTypes = propTypes$54;
  InputGroupAddon.defaultProps = defaultProps$52;
  
  var propTypes$55 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    children: PropTypes.node,
    groupClassName: PropTypes.string,
    groupAttributes: PropTypes.object,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$53 = {
    tag: 'div'
  };
  
  var InputGroupButton = function InputGroupButton(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        children = props.children,
        groupClassName = props.groupClassName,
        groupAttributes = props.groupAttributes,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag', 'children', 'groupClassName', 'groupAttributes']);
  
  
    if (typeof children === 'string') {
      var groupClasses = mapToCssModules(classNames(groupClassName, 'input-group-btn'), cssModule);
  
      return React__default.createElement(
        Tag,
        _extends({}, groupAttributes, { className: groupClasses }),
        React__default.createElement(Button, _extends({}, attributes, { className: className, children: children }))
      );
    }
  
    var classes = mapToCssModules(classNames(className, 'input-group-btn'), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes, children: children }));
  };
  
  InputGroupButton.propTypes = propTypes$55;
  InputGroupButton.defaultProps = defaultProps$53;
  
  var colWidths$1 = ['xs', 'sm', 'md', 'lg', 'xl'];
  
  var stringOrNumberProp$1 = PropTypes.oneOfType([PropTypes.number, PropTypes.string]);
  
  var columnProps$1 = PropTypes.oneOfType([PropTypes.string, PropTypes.number, PropTypes.shape({
    size: stringOrNumberProp$1,
    push: stringOrNumberProp$1,
    pull: stringOrNumberProp$1,
    offset: stringOrNumberProp$1
  })]);
  
  var propTypes$56 = {
    children: PropTypes.node,
    hidden: PropTypes.bool,
    check: PropTypes.bool,
    inline: PropTypes.bool,
    disabled: PropTypes.bool,
    size: PropTypes.string,
    for: PropTypes.string,
    tag: PropTypes.string,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    xs: columnProps$1,
    sm: columnProps$1,
    md: columnProps$1,
    lg: columnProps$1,
    xl: columnProps$1,
    widths: PropTypes.array
  };
  
  var defaultProps$54 = {
    tag: 'label',
    widths: colWidths$1
  };
  
  var getColumnSizeClass$1 = function getColumnSizeClass(isXs, colWidth, colSize) {
    if (colSize === true || colSize === '') {
      return isXs ? 'col' : 'col-' + colWidth;
    } else if (colSize === 'auto') {
      return isXs ? 'col-auto' : 'col-' + colWidth + '-auto';
    }
  
    return isXs ? 'col-' + colSize : 'col-' + colWidth + '-' + colSize;
  };
  
  var Label = function Label(props) {
    var className = props.className,
        cssModule = props.cssModule,
        hidden = props.hidden,
        widths = props.widths,
        Tag = props.tag,
        check = props.check,
        inline = props.inline,
        disabled = props.disabled,
        size = props.size,
        htmlFor = props.for,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'hidden', 'widths', 'tag', 'check', 'inline', 'disabled', 'size', 'for']);
  
  
    var colClasses = [];
  
    widths.forEach(function (colWidth, i) {
      var columnProp = props[colWidth];
  
      delete attributes[colWidth];
  
      if (!columnProp && columnProp !== '') {
        return;
      }
  
      var isXs = !i;
      var colClass = void 0;
  
      if (isobject(columnProp)) {
        var _classNames;
  
        var colSizeInterfix = isXs ? '-' : '-' + colWidth + '-';
        colClass = getColumnSizeClass$1(isXs, colWidth, columnProp.size);
  
        colClasses.push(mapToCssModules(classNames((_classNames = {}, defineProperty(_classNames, colClass, columnProp.size || columnProp.size === ''), defineProperty(_classNames, 'push' + colSizeInterfix + columnProp.push, columnProp.push || columnProp.push === 0), defineProperty(_classNames, 'pull' + colSizeInterfix + columnProp.pull, columnProp.pull || columnProp.pull === 0), defineProperty(_classNames, 'offset' + colSizeInterfix + columnProp.offset, columnProp.offset || columnProp.offset === 0), _classNames))), cssModule);
      } else {
        colClass = getColumnSizeClass$1(isXs, colWidth, columnProp);
        colClasses.push(colClass);
      }
    });
  
    var classes = mapToCssModules(classNames(className, hidden ? 'sr-only' : false, check ? 'form-check-' + (inline ? 'inline' : 'label') : false, check && inline && disabled ? 'disabled' : false, size ? 'col-form-label-' + size : false, colClasses, colClasses.length ? 'col-form-label' : false, !check && !colClasses.length ? 'form-control-label' : false), cssModule);
  
    return React__default.createElement(Tag, _extends({ htmlFor: htmlFor }, attributes, { className: classes }));
  };
  
  Label.propTypes = propTypes$56;
  Label.defaultProps = defaultProps$54;
  
  var propTypes$57 = {
    body: PropTypes.bool,
    bottom: PropTypes.bool,
    children: PropTypes.node,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    heading: PropTypes.bool,
    left: PropTypes.bool,
    list: PropTypes.bool,
    middle: PropTypes.bool,
    object: PropTypes.bool,
    right: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    top: PropTypes.bool
  };
  
  var Media = function Media(props) {
    var body = props.body,
        bottom = props.bottom,
        className = props.className,
        cssModule = props.cssModule,
        heading = props.heading,
        left = props.left,
        list = props.list,
        middle = props.middle,
        object = props.object,
        right = props.right,
        tag = props.tag,
        top = props.top,
        attributes = objectWithoutProperties(props, ['body', 'bottom', 'className', 'cssModule', 'heading', 'left', 'list', 'middle', 'object', 'right', 'tag', 'top']);
  
  
    var defaultTag = void 0;
    if (heading) {
      defaultTag = 'h4';
    } else if (left || right) {
      defaultTag = 'a';
    } else if (object) {
      defaultTag = 'img';
    } else if (list) {
      defaultTag = 'ul';
    } else {
      defaultTag = 'div';
    }
    var Tag = tag || defaultTag;
  
    var classes = mapToCssModules(classNames(className, {
      'media-body': body,
      'media-heading': heading,
      'media-left': left,
      'media-right': right,
      'media-top': top,
      'media-bottom': bottom,
      'media-middle': middle,
      'media-object': object,
      'media-list': list,
      media: !body && !heading && !left && !right && !top && !bottom && !middle && !object && !list
    }), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Media.propTypes = propTypes$57;
  
  var propTypes$58 = {
    children: PropTypes.node,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    size: PropTypes.string,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
  };
  
  var defaultProps$55 = {
    tag: 'ul'
  };
  
  var Pagination = function Pagination(props) {
    var className = props.className,
        cssModule = props.cssModule,
        size = props.size,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'size', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'pagination', defineProperty({}, 'pagination-' + size, !!size)), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Pagination.propTypes = propTypes$58;
  Pagination.defaultProps = defaultProps$55;
  
  var propTypes$59 = {
    active: PropTypes.bool,
    children: PropTypes.node,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    disabled: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
  };
  
  var defaultProps$56 = {
    tag: 'li'
  };
  
  var PaginationItem = function PaginationItem(props) {
    var active = props.active,
        className = props.className,
        cssModule = props.cssModule,
        disabled = props.disabled,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['active', 'className', 'cssModule', 'disabled', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'page-item', {
      active: active,
      disabled: disabled
    }), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  PaginationItem.propTypes = propTypes$59;
  PaginationItem.defaultProps = defaultProps$56;
  
  var propTypes$60 = {
    'aria-label': PropTypes.string,
    children: PropTypes.node,
    className: PropTypes.string,
    cssModule: PropTypes.object,
    next: PropTypes.bool,
    previous: PropTypes.bool,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string])
  };
  
  var defaultProps$57 = {
    tag: 'a'
  };
  
  var PaginationLink = function PaginationLink(props) {
    var className = props.className,
        cssModule = props.cssModule,
        next = props.next,
        previous = props.previous,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'next', 'previous', 'tag']);
  
  
    var classes = mapToCssModules(classNames(className, 'page-link'), cssModule);
  
    var defaultAriaLabel = void 0;
    if (previous) {
      defaultAriaLabel = 'Previous';
    } else if (next) {
      defaultAriaLabel = 'Next';
    }
    var ariaLabel = props['aria-label'] || defaultAriaLabel;
  
    var defaultCaret = void 0;
    if (previous) {
      defaultCaret = '\xAB';
    } else if (next) {
      defaultCaret = '\xBB';
    }
  
    var children = props.children;
    if (children && Array.isArray(children) && children.length === 0) {
      children = null;
    }
  
    if (previous || next) {
      children = [React__default.createElement(
        'span',
        {
          'aria-hidden': 'true',
          key: 'caret'
        },
        children || defaultCaret
      ), React__default.createElement(
        'span',
        {
          className: 'sr-only',
          key: 'sr'
        },
        ariaLabel
      )];
    }
  
    return React__default.createElement(
      Tag,
      _extends({}, attributes, {
        className: classes,
        'aria-label': ariaLabel
      }),
      children
    );
  };
  
  PaginationLink.propTypes = propTypes$60;
  PaginationLink.defaultProps = defaultProps$57;
  
  var propTypes$61 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    activeTab: PropTypes.any,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$58 = {
    tag: 'div'
  };
  
  var childContextTypes$2 = {
    activeTabId: PropTypes.any
  };
  
  var TabContent = function (_Component) {
    inherits(TabContent, _Component);
  
    function TabContent(props) {
      classCallCheck(this, TabContent);
  
      var _this = possibleConstructorReturn(this, (TabContent.__proto__ || Object.getPrototypeOf(TabContent)).call(this, props));
  
      _this.state = {
        activeTab: _this.props.activeTab
      };
      return _this;
    }
  
    createClass(TabContent, [{
      key: 'getChildContext',
      value: function getChildContext() {
        return {
          activeTabId: this.state.activeTab
        };
      }
    }, {
      key: 'componentWillReceiveProps',
      value: function componentWillReceiveProps(nextProps) {
        if (this.state.activeTab !== nextProps.activeTab) {
          this.setState({
            activeTab: nextProps.activeTab
          });
        }
      }
    }, {
      key: 'render',
      value: function render() {
        var _props = this.props,
            className = _props.className,
            cssModule = _props.cssModule,
            Tag = _props.tag;
  
  
        var attributes = omit(this.props, Object.keys(propTypes$61));
  
        var classes = mapToCssModules(classNames('tab-content', className), cssModule);
  
        return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
      }
    }]);
    return TabContent;
  }(React.Component);
  
  TabContent.propTypes = propTypes$61;
  TabContent.defaultProps = defaultProps$58;
  TabContent.childContextTypes = childContextTypes$2;
  
  var propTypes$62 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.string,
    cssModule: PropTypes.object,
    tabId: PropTypes.any
  };
  
  var defaultProps$59 = {
    tag: 'div'
  };
  
  var contextTypes$3 = {
    activeTabId: PropTypes.any
  };
  
  function TabPane(props, context) {
    var className = props.className,
        cssModule = props.cssModule,
        tabId = props.tabId,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tabId', 'tag']);
  
    var classes = mapToCssModules(classNames('tab-pane', className, { active: tabId === context.activeTabId }), cssModule);
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  }
  TabPane.propTypes = propTypes$62;
  TabPane.defaultProps = defaultProps$59;
  TabPane.contextTypes = contextTypes$3;
  
  var propTypes$63 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    fluid: PropTypes.bool,
    className: PropTypes.string,
    cssModule: PropTypes.object
  };
  
  var defaultProps$60 = {
    tag: 'div'
  };
  
  var Jumbotron = function Jumbotron(props) {
    var className = props.className,
        cssModule = props.cssModule,
        Tag = props.tag,
        fluid = props.fluid,
        attributes = objectWithoutProperties(props, ['className', 'cssModule', 'tag', 'fluid']);
  
  
    var classes = mapToCssModules(classNames(className, 'jumbotron', fluid ? 'jumbotron-fluid' : false), cssModule);
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  Jumbotron.propTypes = propTypes$63;
  Jumbotron.defaultProps = defaultProps$60;
  
  var propTypes$64 = {
    children: PropTypes.node,
    className: PropTypes.string,
    closeClassName: PropTypes.string,
    closeAriaLabel: PropTypes.string,
    cssModule: PropTypes.object,
    color: PropTypes.string,
    isOpen: PropTypes.bool,
    toggle: PropTypes.func,
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    transition: PropTypes.shape(Fade.propTypes)
  };
  
  var defaultProps$61 = {
    color: 'success',
    isOpen: true,
    tag: 'div',
    closeAriaLabel: 'Close',
    transition: _extends({}, Fade.defaultProps, {
      unmountOnExit: true
    })
  };
  
  function Alert(props) {
    var className = props.className,
        closeClassName = props.closeClassName,
        closeAriaLabel = props.closeAriaLabel,
        cssModule = props.cssModule,
        Tag = props.tag,
        color = props.color,
        isOpen = props.isOpen,
        toggle = props.toggle,
        children = props.children,
        transition = props.transition,
        attributes = objectWithoutProperties(props, ['className', 'closeClassName', 'closeAriaLabel', 'cssModule', 'tag', 'color', 'isOpen', 'toggle', 'children', 'transition']);
  
  
    var classes = mapToCssModules(classNames(className, 'alert', 'alert-' + color, { 'alert-dismissible': toggle }), cssModule);
  
    var closeClasses = mapToCssModules(classNames('close', closeClassName), cssModule);
  
    return React__default.createElement(
      Fade,
      _extends({}, attributes, transition, { tag: Tag, className: classes, 'in': isOpen, role: 'alert' }),
      toggle ? React__default.createElement(
        'button',
        { type: 'button', className: closeClasses, 'aria-label': closeAriaLabel, onClick: toggle },
        React__default.createElement(
          'span',
          { 'aria-hidden': 'true' },
          '\xD7'
        )
      ) : null,
      children
    );
  }
  
  Alert.propTypes = propTypes$64;
  Alert.defaultProps = defaultProps$61;
  
  var _transitionStatusToCl;
  
  var propTypes$65 = _extends({}, Transition.propTypes, {
    isOpen: PropTypes.bool,
    children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.node,
    navbar: PropTypes.bool,
    cssModule: PropTypes.object
  });
  
  var defaultProps$62 = _extends({}, Transition.defaultProps, {
    isOpen: false,
    appear: false,
    enter: true,
    exit: true,
    tag: 'div',
    timeout: TransitionTimeouts.Collapse
  });
  
  var transitionStatusToClassHash = (_transitionStatusToCl = {}, defineProperty(_transitionStatusToCl, TransitionStatuses.ENTERING, 'collapsing'), defineProperty(_transitionStatusToCl, TransitionStatuses.ENTERED, 'collapse show'), defineProperty(_transitionStatusToCl, TransitionStatuses.EXITING, 'collapsing'), defineProperty(_transitionStatusToCl, TransitionStatuses.EXITED, 'collapse'), _transitionStatusToCl);
  
  function getTransitionClass(status) {
    return transitionStatusToClassHash[status] || 'collapse';
  }
  
  function getHeight(node) {
    return node.scrollHeight;
  }
  
  var Collapse = function (_Component) {
    inherits(Collapse, _Component);
  
    function Collapse(props) {
      classCallCheck(this, Collapse);
  
      var _this = possibleConstructorReturn(this, (Collapse.__proto__ || Object.getPrototypeOf(Collapse)).call(this, props));
  
      _this.state = {
        height: null
      };
  
      ['onEntering', 'onEntered', 'onExit', 'onExiting', 'onExited'].forEach(function (name) {
        _this[name] = _this[name].bind(_this);
      });
      return _this;
    }
  
    createClass(Collapse, [{
      key: 'onEntering',
      value: function onEntering(node, isAppearing) {
        this.setState({ height: getHeight(node) });
        this.props.onEntering(node, isAppearing);
      }
    }, {
      key: 'onEntered',
      value: function onEntered(node, isAppearing) {
        this.setState({ height: null });
        this.props.onEntered(node, isAppearing);
      }
    }, {
      key: 'onExit',
      value: function onExit(node) {
        this.setState({ height: getHeight(node) });
        this.props.onExit(node);
      }
    }, {
      key: 'onExiting',
      value: function onExiting(node) {
        // getting this variable triggers a reflow
        var _unused = node.offsetHeight; // eslint-disable-line no-unused-vars
        this.setState({ height: 0 });
        this.props.onExiting(node);
      }
    }, {
      key: 'onExited',
      value: function onExited(node) {
        this.setState({ height: null });
        this.props.onExited(node);
      }
    }, {
      key: 'render',
      value: function render() {
        var _props = this.props,
            Tag = _props.tag,
            isOpen = _props.isOpen,
            className = _props.className,
            navbar = _props.navbar,
            cssModule = _props.cssModule,
            children = _props.children,
            otherProps = objectWithoutProperties(_props, ['tag', 'isOpen', 'className', 'navbar', 'cssModule', 'children']);
        var height = this.state.height;
  
        // In NODE_ENV=production the Transition.propTypes are wrapped which results in an
        // empty object "{}". This is the result of the `react-transition-group` babel
        // configuration settings. Therefore, to ensure that production builds work without
        // error, we can either explicitly define keys or use the Transition.defaultProps.
        // Using the Transition.defaultProps excludes any required props. Thus, the best
        // solution is to explicitly define required props in our utilities and reference these.
        // This also gives us more flexibility in the future to remove the prop-types
        // dependency in distribution builds (Similar to how `react-transition-group` does).
        // Note: Without omitting the `react-transition-group` props, the resulting child
        // Tag component would inherit the Transition properties as attributes for the HTML
        // element which results in errors/warnings for non-valid attributes.
  
        var transitionProps = pick(otherProps, TransitionPropTypeKeys);
        var childProps = omit(otherProps, TransitionPropTypeKeys);
  
        return React__default.createElement(
          Transition,
          _extends({}, transitionProps, {
            'in': isOpen,
            onEntering: this.onEntering,
            onEntered: this.onEntered,
            onExit: this.onExit,
            onExiting: this.onExiting,
            onExited: this.onExited
          }),
          function (status) {
            var collapseClass = getTransitionClass(status);
            var classes = mapToCssModules(classNames(className, collapseClass, navbar && 'navbar-collapse'), cssModule);
            var style = height === null ? null : { height: height };
            return React__default.createElement(
              Tag,
              _extends({}, childProps, {
                style: _extends({}, childProps.style, style),
                className: classes
              }),
              children
            );
          }
        );
      }
    }]);
    return Collapse;
  }(React.Component);
  
  Collapse.propTypes = propTypes$65;
  Collapse.defaultProps = defaultProps$62;
  
  var propTypes$66 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    active: PropTypes.bool,
    disabled: PropTypes.bool,
    color: PropTypes.string,
    action: PropTypes.bool,
    className: PropTypes.any
  };
  
  var defaultProps$63 = {
    tag: 'li'
  };
  
  var handleDisabledOnClick = function handleDisabledOnClick(e) {
    e.preventDefault();
  };
  
  var ListGroupItem = function ListGroupItem(props) {
    var className = props.className,
        Tag = props.tag,
        active = props.active,
        disabled = props.disabled,
        action = props.action,
        color = props.color,
        attributes = objectWithoutProperties(props, ['className', 'tag', 'active', 'disabled', 'action', 'color']);
  
    var classes = classNames(className, active ? 'active' : false, disabled ? 'disabled' : false, action ? 'list-group-item-action' : false, color ? 'list-group-item-' + color : false, 'list-group-item');
  
    // Prevent click event when disabled.
    if (disabled) {
      attributes.onClick = handleDisabledOnClick;
    }
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  ListGroupItem.propTypes = propTypes$66;
  ListGroupItem.defaultProps = defaultProps$63;
  
  var propTypes$67 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.any
  };
  
  var defaultProps$64 = {
    tag: 'h5'
  };
  
  var ListGroupItemHeading = function ListGroupItemHeading(props) {
    var className = props.className,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'tag']);
  
    var classes = classNames(className, 'list-group-item-heading');
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  ListGroupItemHeading.propTypes = propTypes$67;
  ListGroupItemHeading.defaultProps = defaultProps$64;
  
  var propTypes$68 = {
    tag: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),
    className: PropTypes.any
  };
  
  var defaultProps$65 = {
    tag: 'p'
  };
  
  var ListGroupItemText = function ListGroupItemText(props) {
    var className = props.className,
        Tag = props.tag,
        attributes = objectWithoutProperties(props, ['className', 'tag']);
  
    var classes = classNames(className, 'list-group-item-text');
  
    return React__default.createElement(Tag, _extends({}, attributes, { className: classes }));
  };
  
  ListGroupItemText.propTypes = propTypes$68;
  ListGroupItemText.defaultProps = defaultProps$65;
  
  var Component$1 = React__default.Component;
  
  var components = {
    UncontrolledAlert: Alert,
    UncontrolledButtonDropdown: ButtonDropdown,
    UncontrolledDropdown: Dropdown,
    UncontrolledNavDropdown: NavDropdown,
    UncontrolledTooltip: Tooltip
  };
  
  Object.keys(components).forEach(function (key) {
    var Tag = components[key];
    var defaultValue = Tag === Alert;
  
    var Uncontrolled = function (_Component) {
      inherits(Uncontrolled, _Component);
  
      function Uncontrolled(props) {
        classCallCheck(this, Uncontrolled);
  
        var _this = possibleConstructorReturn(this, (Uncontrolled.__proto__ || Object.getPrototypeOf(Uncontrolled)).call(this, props));
  
        _this.state = { isOpen: defaultValue };
  
        _this.toggle = _this.toggle.bind(_this);
        return _this;
      }
  
      createClass(Uncontrolled, [{
        key: 'toggle',
        value: function toggle() {
          this.setState({ isOpen: !this.state.isOpen });
        }
      }, {
        key: 'render',
        value: function render() {
          return React__default.createElement(Tag, _extends({ isOpen: this.state.isOpen, toggle: this.toggle }, this.props));
        }
      }]);
      return Uncontrolled;
    }(Component$1);
  
    Uncontrolled.displayName = key;
  
    components[key] = Uncontrolled;
  });
  
  var UncontrolledAlert = components.UncontrolledAlert;
  var UncontrolledButtonDropdown = components.UncontrolledButtonDropdown;
  var UncontrolledDropdown = components.UncontrolledDropdown;
  var UncontrolledNavDropdown = components.UncontrolledNavDropdown;
  var UncontrolledTooltip = components.UncontrolledTooltip;
  
  exports.Alert = Alert;
  exports.Container = Container;
  exports.Row = Row;
  exports.Col = Col;
  exports.Navbar = Navbar;
  exports.NavbarBrand = NavbarBrand;
  exports.NavbarToggler = NavbarToggler;
  exports.Nav = Nav;
  exports.NavItem = NavItem;
  exports.NavDropdown = NavDropdown;
  exports.NavLink = NavLink;
  exports.Breadcrumb = Breadcrumb;
  exports.BreadcrumbItem = BreadcrumbItem;
  exports.Button = Button;
  exports.ButtonDropdown = ButtonDropdown;
  exports.ButtonGroup = ButtonGroup;
  exports.ButtonToolbar = ButtonToolbar;
  exports.Dropdown = Dropdown;
  exports.DropdownItem = DropdownItem;
  exports.DropdownMenu = DropdownMenu;
  exports.DropdownToggle = DropdownToggle;
  exports.Fade = Fade;
  exports.Badge = Badge;
  exports.Card = Card;
  exports.CardLink = CardLink;
  exports.CardGroup = CardGroup;
  exports.CardDeck = CardDeck;
  exports.CardColumns = CardColumns;
  exports.CardBody = CardBody;
  exports.CardBlock = CardBlock;
  exports.CardFooter = CardFooter;
  exports.CardHeader = CardHeader;
  exports.CardImg = CardImg;
  exports.CardImgOverlay = CardImgOverlay;
  exports.Carousel = Carousel;
  exports.UncontrolledCarousel = UncontrolledCarousel;
  exports.CarouselControl = CarouselControl;
  exports.CarouselItem = CarouselItem;
  exports.CarouselIndicators = CarouselIndicators;
  exports.CarouselCaption = CarouselCaption;
  exports.CardSubtitle = CardSubtitle;
  exports.CardText = CardText;
  exports.CardTitle = CardTitle;
  exports.Popover = Popover;
  exports.PopoverContent = PopoverContent;
  exports.PopoverBody = PopoverBody;
  exports.PopoverTitle = PopoverTitle;
  exports.PopoverHeader = PopoverHeader;
  exports.Progress = Progress;
  exports.Modal = Modal;
  exports.ModalHeader = ModalHeader;
  exports.ModalBody = ModalBody;
  exports.ModalFooter = ModalFooter;
  exports.PopperContent = PopperContent;
  exports.PopperTargetHelper = PopperTargetHelper;
  exports.Tooltip = Tooltip;
  exports.Table = Table;
  exports.ListGroup = ListGroup;
  exports.Form = Form;
  exports.FormFeedback = FormFeedback;
  exports.FormGroup = FormGroup;
  exports.FormText = FormText;
  exports.Input = Input;
  exports.InputGroup = InputGroup;
  exports.InputGroupAddon = InputGroupAddon;
  exports.InputGroupButton = InputGroupButton;
  exports.Label = Label;
  exports.Media = Media;
  exports.Pagination = Pagination;
  exports.PaginationItem = PaginationItem;
  exports.PaginationLink = PaginationLink;
  exports.TabContent = TabContent;
  exports.TabPane = TabPane;
  exports.Jumbotron = Jumbotron;
  exports.Collapse = Collapse;
  exports.ListGroupItem = ListGroupItem;
  exports.ListGroupItemText = ListGroupItemText;
  exports.ListGroupItemHeading = ListGroupItemHeading;
  exports.UncontrolledAlert = UncontrolledAlert;
  exports.UncontrolledButtonDropdown = UncontrolledButtonDropdown;
  exports.UncontrolledDropdown = UncontrolledDropdown;
  exports.UncontrolledNavDropdown = UncontrolledNavDropdown;
  exports.UncontrolledTooltip = UncontrolledTooltip;
  //# sourceMappingURL=reactstrap.cjs.js.map
  