Initial commit

node_modules/react-bootstrap/es/Accordion.js

@@ -0,0 +1,26 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import React from 'react';
+import PanelGroup from './PanelGroup';
+
+var Accordion =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Accordion, _React$Component);
+
+  function Accordion() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Accordion.prototype;
+
+  _proto.render = function render() {
+    return React.createElement(PanelGroup, _extends({}, this.props, {
+      accordion: true
+    }), this.props.children);
+  };
+
+  return Accordion;
+}(React.Component);
+
+export default Accordion;

node_modules/react-bootstrap/es/Alert.js

@@ -0,0 +1,62 @@
+import _Object$values from "@babel/runtime-corejs2/core-js/object/values";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { bsClass, bsStyles, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+import { State } from './utils/StyleConfig';
+import CloseButton from './CloseButton';
+var propTypes = {
+  onDismiss: PropTypes.func,
+  closeLabel: PropTypes.string
+};
+var defaultProps = {
+  closeLabel: 'Close alert'
+};
+
+var Alert =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Alert, _React$Component);
+
+  function Alert() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Alert.prototype;
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        onDismiss = _this$props.onDismiss,
+        closeLabel = _this$props.closeLabel,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["onDismiss", "closeLabel", "className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var dismissable = !!onDismiss;
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[prefix(bsProps, 'dismissable')] = dismissable, _extends2));
+
+    return React.createElement("div", _extends({}, elementProps, {
+      role: "alert",
+      className: classNames(className, classes)
+    }), dismissable && React.createElement(CloseButton, {
+      onClick: onDismiss,
+      label: closeLabel
+    }), children);
+  };
+
+  return Alert;
+}(React.Component);
+
+Alert.propTypes = propTypes;
+Alert.defaultProps = defaultProps;
+export default bsStyles(_Object$values(State), State.INFO, bsClass('alert', Alert));

node_modules/react-bootstrap/es/Badge.js

@@ -0,0 +1,68 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils'; // TODO: `pullRight` doesn't belong here. There's no special handling here.
+
+var propTypes = {
+  pullRight: PropTypes.bool
+};
+var defaultProps = {
+  pullRight: false
+};
+
+var Badge =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Badge, _React$Component);
+
+  function Badge() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Badge.prototype;
+
+  _proto.hasContent = function hasContent(children) {
+    var result = false;
+    React.Children.forEach(children, function (child) {
+      if (result) {
+        return;
+      }
+
+      if (child || child === 0) {
+        result = true;
+      }
+    });
+    return result;
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        pullRight = _this$props.pullRight,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["pullRight", "className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      'pull-right': pullRight,
+      // Hack for collapsing on IE8.
+      hidden: !this.hasContent(children)
+    });
+
+    return React.createElement("span", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), children);
+  };
+
+  return Badge;
+}(React.Component);
+
+Badge.propTypes = propTypes;
+Badge.defaultProps = defaultProps;
+export default bsClass('badge', Badge);

node_modules/react-bootstrap/es/Breadcrumb.js

@@ -0,0 +1,41 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import BreadcrumbItem from './BreadcrumbItem';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var Breadcrumb =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Breadcrumb, _React$Component);
+
+  function Breadcrumb() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Breadcrumb.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("ol", _extends({}, elementProps, {
+      role: "navigation",
+      "aria-label": "breadcrumbs",
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Breadcrumb;
+}(React.Component);
+
+Breadcrumb.Item = BreadcrumbItem;
+export default bsClass('breadcrumb', Breadcrumb);

node_modules/react-bootstrap/es/BreadcrumbItem.js

@@ -0,0 +1,71 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import SafeAnchor from './SafeAnchor';
+var propTypes = {
+  /**
+   * If set to true, renders `span` instead of `a`
+   */
+  active: PropTypes.bool,
+
+  /**
+   * `href` attribute for the inner `a` element
+   */
+  href: PropTypes.string,
+
+  /**
+   * `title` attribute for the inner `a` element
+   */
+  title: PropTypes.node,
+
+  /**
+   * `target` attribute for the inner `a` element
+   */
+  target: PropTypes.string
+};
+var defaultProps = {
+  active: false
+};
+
+var BreadcrumbItem =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(BreadcrumbItem, _React$Component);
+
+  function BreadcrumbItem() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = BreadcrumbItem.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        active = _this$props.active,
+        href = _this$props.href,
+        title = _this$props.title,
+        target = _this$props.target,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["active", "href", "title", "target", "className"]); // Don't try to render these props on non-active <span>.
+
+
+    var linkProps = {
+      href: href,
+      title: title,
+      target: target
+    };
+    return React.createElement("li", {
+      className: classNames(className, {
+        active: active
+      })
+    }, active ? React.createElement("span", props) : React.createElement(SafeAnchor, _extends({}, props, linkProps)));
+  };
+
+  return BreadcrumbItem;
+}(React.Component);
+
+BreadcrumbItem.propTypes = propTypes;
+BreadcrumbItem.defaultProps = defaultProps;
+export default BreadcrumbItem;

node_modules/react-bootstrap/es/Button.js

@@ -0,0 +1,91 @@
+import _Object$values from "@babel/runtime-corejs2/core-js/object/values";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, bsSizes, bsStyles, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+import { Size, State, Style } from './utils/StyleConfig';
+import SafeAnchor from './SafeAnchor';
+var propTypes = {
+  active: PropTypes.bool,
+  disabled: PropTypes.bool,
+  block: PropTypes.bool,
+  onClick: PropTypes.func,
+  componentClass: elementType,
+  href: PropTypes.string,
+
+  /**
+   * Defines HTML button type attribute
+   * @defaultValue 'button'
+   */
+  type: PropTypes.oneOf(['button', 'reset', 'submit'])
+};
+var defaultProps = {
+  active: false,
+  block: false,
+  disabled: false
+};
+
+var Button =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Button, _React$Component);
+
+  function Button() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Button.prototype;
+
+  _proto.renderAnchor = function renderAnchor(elementProps, className) {
+    return React.createElement(SafeAnchor, _extends({}, elementProps, {
+      className: classNames(className, elementProps.disabled && 'disabled')
+    }));
+  };
+
+  _proto.renderButton = function renderButton(_ref, className) {
+    var componentClass = _ref.componentClass,
+        elementProps = _objectWithoutPropertiesLoose(_ref, ["componentClass"]);
+
+    var Component = componentClass || 'button';
+    return React.createElement(Component, _extends({}, elementProps, {
+      type: elementProps.type || 'button',
+      className: className
+    }));
+  };
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        active = _this$props.active,
+        block = _this$props.block,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["active", "block", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {
+      active: active
+    }, _extends2[prefix(bsProps, 'block')] = block, _extends2));
+
+    var fullClassName = classNames(className, classes);
+
+    if (elementProps.href) {
+      return this.renderAnchor(elementProps, fullClassName);
+    }
+
+    return this.renderButton(elementProps, fullClassName);
+  };
+
+  return Button;
+}(React.Component);
+
+Button.propTypes = propTypes;
+Button.defaultProps = defaultProps;
+export default bsClass('btn', bsSizes([Size.LARGE, Size.SMALL, Size.XSMALL], bsStyles(_Object$values(State).concat([Style.DEFAULT, Style.PRIMARY, Style.LINK]), Style.DEFAULT, Button)));

node_modules/react-bootstrap/es/ButtonGroup.js

@@ -0,0 +1,67 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import all from 'prop-types-extra/lib/all';
+import Button from './Button';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  vertical: PropTypes.bool,
+  justified: PropTypes.bool,
+
+  /**
+   * Display block buttons; only useful when used with the "vertical" prop.
+   * @type {bool}
+   */
+  block: all(PropTypes.bool, function (_ref) {
+    var block = _ref.block,
+        vertical = _ref.vertical;
+    return block && !vertical ? new Error('`block` requires `vertical` to be set to have any effect') : null;
+  })
+};
+var defaultProps = {
+  block: false,
+  justified: false,
+  vertical: false
+};
+
+var ButtonGroup =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ButtonGroup, _React$Component);
+
+  function ButtonGroup() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ButtonGroup.prototype;
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        block = _this$props.block,
+        justified = _this$props.justified,
+        vertical = _this$props.vertical,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["block", "justified", "vertical", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[prefix(bsProps)] = !vertical, _extends2[prefix(bsProps, 'vertical')] = vertical, _extends2[prefix(bsProps, 'justified')] = justified, _extends2[prefix(Button.defaultProps, 'block')] = block, _extends2));
+
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return ButtonGroup;
+}(React.Component);
+
+ButtonGroup.propTypes = propTypes;
+ButtonGroup.defaultProps = defaultProps;
+export default bsClass('btn-group', ButtonGroup);

node_modules/react-bootstrap/es/ButtonToolbar.js

@@ -0,0 +1,38 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var ButtonToolbar =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ButtonToolbar, _React$Component);
+
+  function ButtonToolbar() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ButtonToolbar.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("div", _extends({}, elementProps, {
+      role: "toolbar",
+      className: classNames(className, classes)
+    }));
+  };
+
+  return ButtonToolbar;
+}(React.Component);
+
+export default bsClass('btn-toolbar', ButtonToolbar);

node_modules/react-bootstrap/es/Carousel.js

@@ -0,0 +1,388 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import CarouselCaption from './CarouselCaption';
+import CarouselItem from './CarouselItem';
+import Glyphicon from './Glyphicon';
+import SafeAnchor from './SafeAnchor';
+import { bsClass, getClassSet, prefix, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+import ValidComponentChildren from './utils/ValidComponentChildren'; // TODO: `slide` should be `animate`.
+// TODO: Use uncontrollable.
+
+var propTypes = {
+  slide: PropTypes.bool,
+  indicators: PropTypes.bool,
+
+  /**
+   * The amount of time to delay between automatically cycling an item.
+   * If `null`, carousel will not automatically cycle.
+   */
+  interval: PropTypes.number,
+  controls: PropTypes.bool,
+  pauseOnHover: PropTypes.bool,
+  wrap: PropTypes.bool,
+
+  /**
+   * Callback fired when the active item changes.
+   *
+   * ```js
+   * (eventKey: any, ?event: Object) => any
+   * ```
+   *
+   * If this callback takes two or more arguments, the second argument will
+   * be a persisted event object with `direction` set to the direction of the
+   * transition.
+   */
+  onSelect: PropTypes.func,
+  onSlideEnd: PropTypes.func,
+  activeIndex: PropTypes.number,
+  defaultActiveIndex: PropTypes.number,
+  direction: PropTypes.oneOf(['prev', 'next']),
+  prevIcon: PropTypes.node,
+
+  /**
+   * Label shown to screen readers only, can be used to show the previous element
+   * in the carousel.
+   * Set to null to deactivate.
+   */
+  prevLabel: PropTypes.string,
+  nextIcon: PropTypes.node,
+
+  /**
+   * Label shown to screen readers only, can be used to show the next element
+   * in the carousel.
+   * Set to null to deactivate.
+   */
+  nextLabel: PropTypes.string
+};
+var defaultProps = {
+  slide: true,
+  interval: 5000,
+  pauseOnHover: true,
+  wrap: true,
+  indicators: true,
+  controls: true,
+  prevIcon: React.createElement(Glyphicon, {
+    glyph: "chevron-left"
+  }),
+  prevLabel: 'Previous',
+  nextIcon: React.createElement(Glyphicon, {
+    glyph: "chevron-right"
+  }),
+  nextLabel: 'Next'
+};
+
+var Carousel =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Carousel, _React$Component);
+
+  function Carousel(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleMouseOver = _this.handleMouseOver.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleMouseOut = _this.handleMouseOut.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handlePrev = _this.handlePrev.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleNext = _this.handleNext.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleItemAnimateOutEnd = _this.handleItemAnimateOutEnd.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    var defaultActiveIndex = props.defaultActiveIndex;
+    _this.state = {
+      activeIndex: defaultActiveIndex != null ? defaultActiveIndex : 0,
+      previousActiveIndex: null,
+      direction: null
+    };
+    _this.isUnmounted = false;
+    return _this;
+  }
+
+  var _proto = Carousel.prototype;
+
+  _proto.componentDidMount = function componentDidMount() {
+    this.waitForNext();
+  };
+
+  _proto.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
+    var activeIndex = this.getActiveIndex();
+
+    if (nextProps.activeIndex != null && nextProps.activeIndex !== activeIndex) {
+      clearTimeout(this.timeout);
+      this.setState({
+        previousActiveIndex: activeIndex,
+        direction: nextProps.direction != null ? nextProps.direction : this.getDirection(activeIndex, nextProps.activeIndex)
+      });
+    }
+
+    if (nextProps.activeIndex == null && this.state.activeIndex >= nextProps.children.length) {
+      this.setState({
+        activeIndex: 0,
+        previousActiveIndex: null,
+        direction: null
+      });
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    clearTimeout(this.timeout);
+    this.isUnmounted = true;
+  };
+
+  _proto.getActiveIndex = function getActiveIndex() {
+    var activeIndexProp = this.props.activeIndex;
+    return activeIndexProp != null ? activeIndexProp : this.state.activeIndex;
+  };
+
+  _proto.getDirection = function getDirection(prevIndex, index) {
+    if (prevIndex === index) {
+      return null;
+    }
+
+    return prevIndex > index ? 'prev' : 'next';
+  };
+
+  _proto.handleItemAnimateOutEnd = function handleItemAnimateOutEnd() {
+    var _this2 = this;
+
+    this.setState({
+      previousActiveIndex: null,
+      direction: null
+    }, function () {
+      _this2.waitForNext();
+
+      if (_this2.props.onSlideEnd) {
+        _this2.props.onSlideEnd();
+      }
+    });
+  };
+
+  _proto.handleMouseOut = function handleMouseOut() {
+    if (this.isPaused) {
+      this.play();
+    }
+  };
+
+  _proto.handleMouseOver = function handleMouseOver() {
+    if (this.props.pauseOnHover) {
+      this.pause();
+    }
+  };
+
+  _proto.handleNext = function handleNext(e) {
+    var index = this.getActiveIndex() + 1;
+    var count = ValidComponentChildren.count(this.props.children);
+
+    if (index > count - 1) {
+      if (!this.props.wrap) {
+        return;
+      }
+
+      index = 0;
+    }
+
+    this.select(index, e, 'next');
+  };
+
+  _proto.handlePrev = function handlePrev(e) {
+    var index = this.getActiveIndex() - 1;
+
+    if (index < 0) {
+      if (!this.props.wrap) {
+        return;
+      }
+
+      index = ValidComponentChildren.count(this.props.children) - 1;
+    }
+
+    this.select(index, e, 'prev');
+  }; // This might be a public API.
+
+
+  _proto.pause = function pause() {
+    this.isPaused = true;
+    clearTimeout(this.timeout);
+  }; // This might be a public API.
+
+
+  _proto.play = function play() {
+    this.isPaused = false;
+    this.waitForNext();
+  };
+
+  _proto.select = function select(index, e, direction) {
+    clearTimeout(this.timeout); // TODO: Is this necessary? Seems like the only risk is if the component
+    // unmounts while handleItemAnimateOutEnd fires.
+
+    if (this.isUnmounted) {
+      return;
+    }
+
+    var previousActiveIndex = this.props.slide ? this.getActiveIndex() : null;
+    direction = direction || this.getDirection(previousActiveIndex, index);
+    var onSelect = this.props.onSelect;
+
+    if (onSelect) {
+      if (onSelect.length > 1) {
+        // React SyntheticEvents are pooled, so we need to remove this event
+        // from the pool to add a custom property. To avoid unnecessarily
+        // removing objects from the pool, only do this when the listener
+        // actually wants the event.
+        if (e) {
+          e.persist();
+          e.direction = direction;
+        } else {
+          e = {
+            direction: direction
+          };
+        }
+
+        onSelect(index, e);
+      } else {
+        onSelect(index);
+      }
+    }
+
+    if (this.props.activeIndex == null && index !== previousActiveIndex) {
+      if (this.state.previousActiveIndex != null) {
+        // If currently animating don't activate the new index.
+        // TODO: look into queueing this canceled call and
+        // animating after the current animation has ended.
+        return;
+      }
+
+      this.setState({
+        activeIndex: index,
+        previousActiveIndex: previousActiveIndex,
+        direction: direction
+      });
+    }
+  };
+
+  _proto.waitForNext = function waitForNext() {
+    var _this$props = this.props,
+        slide = _this$props.slide,
+        interval = _this$props.interval,
+        activeIndexProp = _this$props.activeIndex;
+
+    if (!this.isPaused && slide && interval && activeIndexProp == null) {
+      this.timeout = setTimeout(this.handleNext, interval);
+    }
+  };
+
+  _proto.renderControls = function renderControls(properties) {
+    var wrap = properties.wrap,
+        children = properties.children,
+        activeIndex = properties.activeIndex,
+        prevIcon = properties.prevIcon,
+        nextIcon = properties.nextIcon,
+        bsProps = properties.bsProps,
+        prevLabel = properties.prevLabel,
+        nextLabel = properties.nextLabel;
+    var controlClassName = prefix(bsProps, 'control');
+    var count = ValidComponentChildren.count(children);
+    return [(wrap || activeIndex !== 0) && React.createElement(SafeAnchor, {
+      key: "prev",
+      className: classNames(controlClassName, 'left'),
+      onClick: this.handlePrev
+    }, prevIcon, prevLabel && React.createElement("span", {
+      className: "sr-only"
+    }, prevLabel)), (wrap || activeIndex !== count - 1) && React.createElement(SafeAnchor, {
+      key: "next",
+      className: classNames(controlClassName, 'right'),
+      onClick: this.handleNext
+    }, nextIcon, nextLabel && React.createElement("span", {
+      className: "sr-only"
+    }, nextLabel))];
+  };
+
+  _proto.renderIndicators = function renderIndicators(children, activeIndex, bsProps) {
+    var _this3 = this;
+
+    var indicators = [];
+    ValidComponentChildren.forEach(children, function (child, index) {
+      indicators.push(React.createElement("li", {
+        key: index,
+        className: index === activeIndex ? 'active' : null,
+        onClick: function onClick(e) {
+          return _this3.select(index, e);
+        }
+      }), // Force whitespace between indicator elements. Bootstrap requires
+      // this for correct spacing of elements.
+      ' ');
+    });
+    return React.createElement("ol", {
+      className: prefix(bsProps, 'indicators')
+    }, indicators);
+  };
+
+  _proto.render = function render() {
+    var _this4 = this;
+
+    var _this$props2 = this.props,
+        slide = _this$props2.slide,
+        indicators = _this$props2.indicators,
+        controls = _this$props2.controls,
+        wrap = _this$props2.wrap,
+        prevIcon = _this$props2.prevIcon,
+        prevLabel = _this$props2.prevLabel,
+        nextIcon = _this$props2.nextIcon,
+        nextLabel = _this$props2.nextLabel,
+        className = _this$props2.className,
+        children = _this$props2.children,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["slide", "indicators", "controls", "wrap", "prevIcon", "prevLabel", "nextIcon", "nextLabel", "className", "children"]);
+
+    var _this$state = this.state,
+        previousActiveIndex = _this$state.previousActiveIndex,
+        direction = _this$state.direction;
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(props, ['interval', 'pauseOnHover', 'onSelect', 'onSlideEnd', 'activeIndex', // Accessed via this.getActiveIndex().
+    'defaultActiveIndex', 'direction']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1];
+
+    var activeIndex = this.getActiveIndex();
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      slide: slide
+    });
+
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes),
+      onMouseOver: this.handleMouseOver,
+      onMouseOut: this.handleMouseOut
+    }), indicators && this.renderIndicators(children, activeIndex, bsProps), React.createElement("div", {
+      className: prefix(bsProps, 'inner')
+    }, ValidComponentChildren.map(children, function (child, index) {
+      var active = index === activeIndex;
+      var previousActive = slide && index === previousActiveIndex;
+      return cloneElement(child, {
+        active: active,
+        index: index,
+        animateOut: previousActive,
+        animateIn: active && previousActiveIndex != null && slide,
+        direction: direction,
+        onAnimateOutEnd: previousActive ? _this4.handleItemAnimateOutEnd : null
+      });
+    })), controls && this.renderControls({
+      wrap: wrap,
+      children: children,
+      activeIndex: activeIndex,
+      prevIcon: prevIcon,
+      prevLabel: prevLabel,
+      nextIcon: nextIcon,
+      nextLabel: nextLabel,
+      bsProps: bsProps
+    }));
+  };
+
+  return Carousel;
+}(React.Component);
+
+Carousel.propTypes = propTypes;
+Carousel.defaultProps = defaultProps;
+Carousel.Caption = CarouselCaption;
+Carousel.Item = CarouselItem;
+export default bsClass('carousel', Carousel);

node_modules/react-bootstrap/es/CarouselCaption.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var CarouselCaption =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(CarouselCaption, _React$Component);
+
+  function CarouselCaption() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = CarouselCaption.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return CarouselCaption;
+}(React.Component);
+
+CarouselCaption.propTypes = propTypes;
+CarouselCaption.defaultProps = defaultProps;
+export default bsClass('carousel-caption', CarouselCaption);

node_modules/react-bootstrap/es/CarouselItem.js

@@ -0,0 +1,126 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import transition from 'dom-helpers/transition';
+var propTypes = {
+  direction: PropTypes.oneOf(['prev', 'next']),
+  onAnimateOutEnd: PropTypes.func,
+  active: PropTypes.bool,
+  animateIn: PropTypes.bool,
+  animateOut: PropTypes.bool,
+  index: PropTypes.number
+};
+var defaultProps = {
+  active: false,
+  animateIn: false,
+  animateOut: false
+};
+
+var CarouselItem =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(CarouselItem, _React$Component);
+
+  function CarouselItem(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleAnimateOutEnd = _this.handleAnimateOutEnd.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.state = {
+      direction: null
+    };
+    _this.isUnmounted = false;
+    return _this;
+  }
+
+  var _proto = CarouselItem.prototype;
+
+  _proto.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
+    if (this.props.active !== nextProps.active) {
+      this.setState({
+        direction: null
+      });
+    }
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    var _this2 = this;
+
+    var active = this.props.active;
+    var prevActive = prevProps.active;
+
+    if (!active && prevActive) {
+      transition.end(ReactDOM.findDOMNode(this), this.handleAnimateOutEnd);
+    }
+
+    if (active !== prevActive) {
+      setTimeout(function () {
+        return _this2.startAnimation();
+      }, 20);
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.isUnmounted = true;
+  };
+
+  _proto.handleAnimateOutEnd = function handleAnimateOutEnd() {
+    if (this.isUnmounted) {
+      return;
+    }
+
+    if (this.props.onAnimateOutEnd) {
+      this.props.onAnimateOutEnd(this.props.index);
+    }
+  };
+
+  _proto.startAnimation = function startAnimation() {
+    if (this.isUnmounted) {
+      return;
+    }
+
+    this.setState({
+      direction: this.props.direction === 'prev' ? 'right' : 'left'
+    });
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        direction = _this$props.direction,
+        active = _this$props.active,
+        animateIn = _this$props.animateIn,
+        animateOut = _this$props.animateOut,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["direction", "active", "animateIn", "animateOut", "className"]);
+
+    delete props.onAnimateOutEnd;
+    delete props.index;
+    var classes = {
+      item: true,
+      active: active && !animateIn || animateOut
+    };
+
+    if (direction && active && animateIn) {
+      classes[direction] = true;
+    }
+
+    if (this.state.direction && (animateIn || animateOut)) {
+      classes[this.state.direction] = true;
+    }
+
+    return React.createElement("div", _extends({}, props, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return CarouselItem;
+}(React.Component);
+
+CarouselItem.propTypes = propTypes;
+CarouselItem.defaultProps = defaultProps;
+export default CarouselItem;

node_modules/react-bootstrap/es/Checkbox.js

@@ -0,0 +1,105 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+
+/* eslint-disable jsx-a11y/label-has-for */
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import warning from 'warning';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  inline: PropTypes.bool,
+  disabled: PropTypes.bool,
+  title: PropTypes.string,
+
+  /**
+   * Only valid if `inline` is not set.
+   */
+  validationState: PropTypes.oneOf(['success', 'warning', 'error', null]),
+
+  /**
+   * Attaches a ref to the `<input>` element. Only functions can be used here.
+   *
+   * ```js
+   * <Checkbox inputRef={ref => { this.input = ref; }} />
+   * ```
+   */
+  inputRef: PropTypes.func
+};
+var defaultProps = {
+  inline: false,
+  disabled: false,
+  title: ''
+};
+
+var Checkbox =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Checkbox, _React$Component);
+
+  function Checkbox() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Checkbox.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        inline = _this$props.inline,
+        disabled = _this$props.disabled,
+        validationState = _this$props.validationState,
+        inputRef = _this$props.inputRef,
+        className = _this$props.className,
+        style = _this$props.style,
+        title = _this$props.title,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["inline", "disabled", "validationState", "inputRef", "className", "style", "title", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var input = React.createElement("input", _extends({}, elementProps, {
+      ref: inputRef,
+      type: "checkbox",
+      disabled: disabled
+    }));
+
+    if (inline) {
+      var _classes2;
+
+      var _classes = (_classes2 = {}, _classes2[prefix(bsProps, 'inline')] = true, _classes2.disabled = disabled, _classes2); // Use a warning here instead of in propTypes to get better-looking
+      // generated documentation.
+
+
+      process.env.NODE_ENV !== "production" ? warning(!validationState, '`validationState` is ignored on `<Checkbox inline>`. To display ' + 'validation state on an inline checkbox, set `validationState` on a ' + 'parent `<FormGroup>` or other element instead.') : void 0;
+      return React.createElement("label", {
+        className: classNames(className, _classes),
+        style: style,
+        title: title
+      }, input, children);
+    }
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      disabled: disabled
+    });
+
+    if (validationState) {
+      classes["has-" + validationState] = true;
+    }
+
+    return React.createElement("div", {
+      className: classNames(className, classes),
+      style: style
+    }, React.createElement("label", {
+      title: title
+    }, input, children));
+  };
+
+  return Checkbox;
+}(React.Component);
+
+Checkbox.propTypes = propTypes;
+Checkbox.defaultProps = defaultProps;
+export default bsClass('checkbox', Checkbox);

node_modules/react-bootstrap/es/Clearfix.js

@@ -0,0 +1,95 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+import capitalize from './utils/capitalize';
+import { DEVICE_SIZES } from './utils/StyleConfig';
+var propTypes = {
+  componentClass: elementType,
+
+  /**
+   * Apply clearfix
+   *
+   * on Extra small devices Phones
+   *
+   * adds class `visible-xs-block`
+   */
+  visibleXsBlock: PropTypes.bool,
+
+  /**
+   * Apply clearfix
+   *
+   * on Small devices Tablets
+   *
+   * adds class `visible-sm-block`
+   */
+  visibleSmBlock: PropTypes.bool,
+
+  /**
+   * Apply clearfix
+   *
+   * on Medium devices Desktops
+   *
+   * adds class `visible-md-block`
+   */
+  visibleMdBlock: PropTypes.bool,
+
+  /**
+   * Apply clearfix
+   *
+   * on Large devices Desktops
+   *
+   * adds class `visible-lg-block`
+   */
+  visibleLgBlock: PropTypes.bool
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var Clearfix =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Clearfix, _React$Component);
+
+  function Clearfix() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Clearfix.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    DEVICE_SIZES.forEach(function (size) {
+      var propName = "visible" + capitalize(size) + "Block";
+
+      if (elementProps[propName]) {
+        classes["visible-" + size + "-block"] = true;
+      }
+
+      delete elementProps[propName];
+    });
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Clearfix;
+}(React.Component);
+
+Clearfix.propTypes = propTypes;
+Clearfix.defaultProps = defaultProps;
+export default bsClass('clearfix', Clearfix);

node_modules/react-bootstrap/es/CloseButton.js

@@ -0,0 +1,43 @@
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import PropTypes from 'prop-types';
+import React from 'react';
+var propTypes = {
+  label: PropTypes.string.isRequired,
+  onClick: PropTypes.func
+};
+var defaultProps = {
+  label: 'Close'
+};
+
+var CloseButton =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(CloseButton, _React$Component);
+
+  function CloseButton() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = CloseButton.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        label = _this$props.label,
+        onClick = _this$props.onClick;
+    return React.createElement("button", {
+      type: "button",
+      className: "close",
+      onClick: onClick
+    }, React.createElement("span", {
+      "aria-hidden": "true"
+    }, "\xD7"), React.createElement("span", {
+      className: "sr-only"
+    }, label));
+  };
+
+  return CloseButton;
+}(React.Component);
+
+CloseButton.propTypes = propTypes;
+CloseButton.defaultProps = defaultProps;
+export default CloseButton;

node_modules/react-bootstrap/es/Col.js

@@ -0,0 +1,253 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, prefix, splitBsProps } from './utils/bootstrapUtils';
+import { DEVICE_SIZES } from './utils/StyleConfig';
+var propTypes = {
+  componentClass: elementType,
+
+  /**
+   * The number of columns you wish to span
+   *
+   * for Extra small devices Phones (<768px)
+   *
+   * class-prefix `col-xs-`
+   */
+  xs: PropTypes.number,
+
+  /**
+   * The number of columns you wish to span
+   *
+   * for Small devices Tablets (≥768px)
+   *
+   * class-prefix `col-sm-`
+   */
+  sm: PropTypes.number,
+
+  /**
+   * The number of columns you wish to span
+   *
+   * for Medium devices Desktops (≥992px)
+   *
+   * class-prefix `col-md-`
+   */
+  md: PropTypes.number,
+
+  /**
+   * The number of columns you wish to span
+   *
+   * for Large devices Desktops (≥1200px)
+   *
+   * class-prefix `col-lg-`
+   */
+  lg: PropTypes.number,
+
+  /**
+   * Hide column
+   *
+   * on Extra small devices Phones
+   *
+   * adds class `hidden-xs`
+   */
+  xsHidden: PropTypes.bool,
+
+  /**
+   * Hide column
+   *
+   * on Small devices Tablets
+   *
+   * adds class `hidden-sm`
+   */
+  smHidden: PropTypes.bool,
+
+  /**
+   * Hide column
+   *
+   * on Medium devices Desktops
+   *
+   * adds class `hidden-md`
+   */
+  mdHidden: PropTypes.bool,
+
+  /**
+   * Hide column
+   *
+   * on Large devices Desktops
+   *
+   * adds class `hidden-lg`
+   */
+  lgHidden: PropTypes.bool,
+
+  /**
+   * Move columns to the right
+   *
+   * for Extra small devices Phones
+   *
+   * class-prefix `col-xs-offset-`
+   */
+  xsOffset: PropTypes.number,
+
+  /**
+   * Move columns to the right
+   *
+   * for Small devices Tablets
+   *
+   * class-prefix `col-sm-offset-`
+   */
+  smOffset: PropTypes.number,
+
+  /**
+   * Move columns to the right
+   *
+   * for Medium devices Desktops
+   *
+   * class-prefix `col-md-offset-`
+   */
+  mdOffset: PropTypes.number,
+
+  /**
+   * Move columns to the right
+   *
+   * for Large devices Desktops
+   *
+   * class-prefix `col-lg-offset-`
+   */
+  lgOffset: PropTypes.number,
+
+  /**
+   * Change the order of grid columns to the right
+   *
+   * for Extra small devices Phones
+   *
+   * class-prefix `col-xs-push-`
+   */
+  xsPush: PropTypes.number,
+
+  /**
+   * Change the order of grid columns to the right
+   *
+   * for Small devices Tablets
+   *
+   * class-prefix `col-sm-push-`
+   */
+  smPush: PropTypes.number,
+
+  /**
+   * Change the order of grid columns to the right
+   *
+   * for Medium devices Desktops
+   *
+   * class-prefix `col-md-push-`
+   */
+  mdPush: PropTypes.number,
+
+  /**
+   * Change the order of grid columns to the right
+   *
+   * for Large devices Desktops
+   *
+   * class-prefix `col-lg-push-`
+   */
+  lgPush: PropTypes.number,
+
+  /**
+   * Change the order of grid columns to the left
+   *
+   * for Extra small devices Phones
+   *
+   * class-prefix `col-xs-pull-`
+   */
+  xsPull: PropTypes.number,
+
+  /**
+   * Change the order of grid columns to the left
+   *
+   * for Small devices Tablets
+   *
+   * class-prefix `col-sm-pull-`
+   */
+  smPull: PropTypes.number,
+
+  /**
+   * Change the order of grid columns to the left
+   *
+   * for Medium devices Desktops
+   *
+   * class-prefix `col-md-pull-`
+   */
+  mdPull: PropTypes.number,
+
+  /**
+   * Change the order of grid columns to the left
+   *
+   * for Large devices Desktops
+   *
+   * class-prefix `col-lg-pull-`
+   */
+  lgPull: PropTypes.number
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var Col =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Col, _React$Component);
+
+  function Col() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Col.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = [];
+    DEVICE_SIZES.forEach(function (size) {
+      function popProp(propSuffix, modifier) {
+        var propName = "" + size + propSuffix;
+        var propValue = elementProps[propName];
+
+        if (propValue != null) {
+          classes.push(prefix(bsProps, "" + size + modifier + "-" + propValue));
+        }
+
+        delete elementProps[propName];
+      }
+
+      popProp('', '');
+      popProp('Offset', '-offset');
+      popProp('Push', '-push');
+      popProp('Pull', '-pull');
+      var hiddenPropName = size + "Hidden";
+
+      if (elementProps[hiddenPropName]) {
+        classes.push("hidden-" + size);
+      }
+
+      delete elementProps[hiddenPropName];
+    });
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Col;
+}(React.Component);
+
+Col.propTypes = propTypes;
+Col.defaultProps = defaultProps;
+export default bsClass('col', Col);

node_modules/react-bootstrap/es/Collapse.js

@@ -0,0 +1,218 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _parseInt from "@babel/runtime-corejs2/core-js/parse-int";
+
+var _collapseStyles;
+
+import classNames from 'classnames';
+import css from 'dom-helpers/style';
+import React from 'react';
+import PropTypes from 'prop-types';
+import Transition, { EXITED, ENTERED, ENTERING, EXITING } from 'react-transition-group/Transition';
+import capitalize from './utils/capitalize';
+import createChainedFunction from './utils/createChainedFunction';
+var MARGINS = {
+  height: ['marginTop', 'marginBottom'],
+  width: ['marginLeft', 'marginRight']
+}; // reading a dimension prop will cause the browser to recalculate,
+// which will let our animations work
+
+function triggerBrowserReflow(node) {
+  node.offsetHeight; // eslint-disable-line no-unused-expressions
+}
+
+function getDimensionValue(dimension, elem) {
+  var value = elem["offset" + capitalize(dimension)];
+  var margins = MARGINS[dimension];
+  return value + _parseInt(css(elem, margins[0]), 10) + _parseInt(css(elem, margins[1]), 10);
+}
+
+var collapseStyles = (_collapseStyles = {}, _collapseStyles[EXITED] = 'collapse', _collapseStyles[EXITING] = 'collapsing', _collapseStyles[ENTERING] = 'collapsing', _collapseStyles[ENTERED] = 'collapse in', _collapseStyles);
+var propTypes = {
+  /**
+   * Show the component; triggers the expand or collapse animation
+   */
+  in: PropTypes.bool,
+
+  /**
+   * Wait until the first "enter" transition to mount the component (add it to the DOM)
+   */
+  mountOnEnter: PropTypes.bool,
+
+  /**
+   * Unmount the component (remove it from the DOM) when it is collapsed
+   */
+  unmountOnExit: PropTypes.bool,
+
+  /**
+   * Run the expand animation when the component mounts, if it is initially
+   * shown
+   */
+  appear: PropTypes.bool,
+
+  /**
+   * Duration of the collapse animation in milliseconds, to ensure that
+   * finishing callbacks are fired even if the original browser transition end
+   * events are canceled
+   */
+  timeout: PropTypes.number,
+
+  /**
+   * Callback fired before the component expands
+   */
+  onEnter: PropTypes.func,
+
+  /**
+   * Callback fired after the component starts to expand
+   */
+  onEntering: PropTypes.func,
+
+  /**
+   * Callback fired after the component has expanded
+   */
+  onEntered: PropTypes.func,
+
+  /**
+   * Callback fired before the component collapses
+   */
+  onExit: PropTypes.func,
+
+  /**
+   * Callback fired after the component starts to collapse
+   */
+  onExiting: PropTypes.func,
+
+  /**
+   * Callback fired after the component has collapsed
+   */
+  onExited: PropTypes.func,
+
+  /**
+   * The dimension used when collapsing, or a function that returns the
+   * dimension
+   *
+   * _Note: Bootstrap only partially supports 'width'!
+   * You will need to supply your own CSS animation for the `.width` CSS class._
+   */
+  dimension: PropTypes.oneOfType([PropTypes.oneOf(['height', 'width']), PropTypes.func]),
+
+  /**
+   * Function that returns the height or width of the animating DOM node
+   *
+   * Allows for providing some custom logic for how much the Collapse component
+   * should animate in its specified dimension. Called with the current
+   * dimension prop value and the DOM node.
+   */
+  getDimensionValue: PropTypes.func,
+
+  /**
+   * ARIA role of collapsible element
+   */
+  role: PropTypes.string
+};
+var defaultProps = {
+  in: false,
+  timeout: 300,
+  mountOnEnter: false,
+  unmountOnExit: false,
+  appear: false,
+  dimension: 'height',
+  getDimensionValue: getDimensionValue
+};
+
+var Collapse =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Collapse, _React$Component);
+
+  function Collapse() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+
+    _this.handleEnter = function (elem) {
+      elem.style[_this.getDimension()] = '0';
+    };
+
+    _this.handleEntering = function (elem) {
+      var dimension = _this.getDimension();
+
+      elem.style[dimension] = _this._getScrollDimensionValue(elem, dimension);
+    };
+
+    _this.handleEntered = function (elem) {
+      elem.style[_this.getDimension()] = null;
+    };
+
+    _this.handleExit = function (elem) {
+      var dimension = _this.getDimension();
+
+      elem.style[dimension] = _this.props.getDimensionValue(dimension, elem) + "px";
+      triggerBrowserReflow(elem);
+    };
+
+    _this.handleExiting = function (elem) {
+      elem.style[_this.getDimension()] = '0';
+    };
+
+    return _this;
+  }
+
+  var _proto = Collapse.prototype;
+
+  _proto.getDimension = function getDimension() {
+    return typeof this.props.dimension === 'function' ? this.props.dimension() : this.props.dimension;
+  }; // for testing
+
+
+  _proto._getScrollDimensionValue = function _getScrollDimensionValue(elem, dimension) {
+    return elem["scroll" + capitalize(dimension)] + "px";
+  };
+  /* -- Expanding -- */
+
+
+  _proto.render = function render() {
+    var _this2 = this;
+
+    var _this$props = this.props,
+        onEnter = _this$props.onEnter,
+        onEntering = _this$props.onEntering,
+        onEntered = _this$props.onEntered,
+        onExit = _this$props.onExit,
+        onExiting = _this$props.onExiting,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["onEnter", "onEntering", "onEntered", "onExit", "onExiting", "className", "children"]);
+
+    delete props.dimension;
+    delete props.getDimensionValue;
+    var handleEnter = createChainedFunction(this.handleEnter, onEnter);
+    var handleEntering = createChainedFunction(this.handleEntering, onEntering);
+    var handleEntered = createChainedFunction(this.handleEntered, onEntered);
+    var handleExit = createChainedFunction(this.handleExit, onExit);
+    var handleExiting = createChainedFunction(this.handleExiting, onExiting);
+    return React.createElement(Transition, _extends({}, props, {
+      "aria-expanded": props.role ? props.in : null,
+      onEnter: handleEnter,
+      onEntering: handleEntering,
+      onEntered: handleEntered,
+      onExit: handleExit,
+      onExiting: handleExiting
+    }), function (state, innerProps) {
+      return React.cloneElement(children, _extends({}, innerProps, {
+        className: classNames(className, children.props.className, collapseStyles[state], _this2.getDimension() === 'width' && 'width')
+      }));
+    });
+  };
+
+  return Collapse;
+}(React.Component);
+
+Collapse.propTypes = propTypes;
+Collapse.defaultProps = defaultProps;
+export default Collapse;

node_modules/react-bootstrap/es/ControlLabel.js

@@ -0,0 +1,67 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import warning from 'warning';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * Uses `controlId` from `<FormGroup>` if not explicitly specified.
+   */
+  htmlFor: PropTypes.string,
+  srOnly: PropTypes.bool
+};
+var defaultProps = {
+  srOnly: false
+};
+var contextTypes = {
+  $bs_formGroup: PropTypes.object
+};
+
+var ControlLabel =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ControlLabel, _React$Component);
+
+  function ControlLabel() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ControlLabel.prototype;
+
+  _proto.render = function render() {
+    var formGroup = this.context.$bs_formGroup;
+    var controlId = formGroup && formGroup.controlId;
+
+    var _this$props = this.props,
+        _this$props$htmlFor = _this$props.htmlFor,
+        htmlFor = _this$props$htmlFor === void 0 ? controlId : _this$props$htmlFor,
+        srOnly = _this$props.srOnly,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["htmlFor", "srOnly", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    process.env.NODE_ENV !== "production" ? warning(controlId == null || htmlFor === controlId, '`controlId` is ignored on `<ControlLabel>` when `htmlFor` is specified.') : void 0;
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      'sr-only': srOnly
+    });
+
+    return React.createElement("label", _extends({}, elementProps, {
+      htmlFor: htmlFor,
+      className: classNames(className, classes)
+    }));
+  };
+
+  return ControlLabel;
+}(React.Component);
+
+ControlLabel.propTypes = propTypes;
+ControlLabel.defaultProps = defaultProps;
+ControlLabel.contextTypes = contextTypes;
+export default bsClass('control-label', ControlLabel);

node_modules/react-bootstrap/es/Dropdown.js

@@ -0,0 +1,361 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import activeElement from 'dom-helpers/activeElement';
+import contains from 'dom-helpers/query/contains';
+import keycode from 'keycode';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import all from 'prop-types-extra/lib/all';
+import elementType from 'prop-types-extra/lib/elementType';
+import isRequiredForA11y from 'prop-types-extra/lib/isRequiredForA11y';
+import uncontrollable from 'uncontrollable';
+import warning from 'warning';
+import ButtonGroup from './ButtonGroup';
+import DropdownMenu from './DropdownMenu';
+import DropdownToggle from './DropdownToggle';
+import { bsClass as setBsClass, prefix } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+import { exclusiveRoles, requiredRoles } from './utils/PropTypes';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+var TOGGLE_ROLE = DropdownToggle.defaultProps.bsRole;
+var MENU_ROLE = DropdownMenu.defaultProps.bsRole;
+var propTypes = {
+  /**
+   * The menu will open above the dropdown button, instead of below it.
+   */
+  dropup: PropTypes.bool,
+
+  /**
+   * An html id attribute, necessary for assistive technologies, such as screen readers.
+   * @type {string|number}
+   * @required
+   */
+  id: isRequiredForA11y(PropTypes.oneOfType([PropTypes.string, PropTypes.number])),
+  componentClass: elementType,
+
+  /**
+   * The children of a Dropdown may be a `<Dropdown.Toggle>` or a `<Dropdown.Menu>`.
+   * @type {node}
+   */
+  children: all(requiredRoles(TOGGLE_ROLE, MENU_ROLE), exclusiveRoles(MENU_ROLE)),
+
+  /**
+   * Whether or not component is disabled.
+   */
+  disabled: PropTypes.bool,
+
+  /**
+   * Align the menu to the right side of the Dropdown toggle
+   */
+  pullRight: PropTypes.bool,
+
+  /**
+   * Whether or not the Dropdown is visible.
+   *
+   * @controllable onToggle
+   */
+  open: PropTypes.bool,
+  defaultOpen: PropTypes.bool,
+
+  /**
+   * A callback fired when the Dropdown wishes to change visibility. Called with the requested
+   * `open` value, the DOM event, and the source that fired it: `'click'`,`'keydown'`,`'rootClose'`, or `'select'`.
+   *
+   * ```js
+   * function(Boolean isOpen, Object event, { String source }) {}
+   * ```
+   * @controllable open
+   */
+  onToggle: PropTypes.func,
+
+  /**
+   * A callback fired when a menu item is selected.
+   *
+   * ```js
+   * (eventKey: any, event: Object) => any
+   * ```
+   */
+  onSelect: PropTypes.func,
+
+  /**
+   * If `'menuitem'`, causes the dropdown to behave like a menu item rather than
+   * a menu button.
+   */
+  role: PropTypes.string,
+
+  /**
+   * Which event when fired outside the component will cause it to be closed
+   *
+   * *Note: For custom dropdown components, you will have to pass the
+   * `rootCloseEvent` to `<RootCloseWrapper>` in your custom dropdown menu
+   * component ([similarly to how it is implemented in `<Dropdown.Menu>`](https://github.com/react-bootstrap/react-bootstrap/blob/v0.31.5/src/DropdownMenu.js#L115-L119)).*
+   */
+  rootCloseEvent: PropTypes.oneOf(['click', 'mousedown']),
+
+  /**
+   * @private
+   */
+  onMouseEnter: PropTypes.func,
+
+  /**
+   * @private
+   */
+  onMouseLeave: PropTypes.func
+};
+var defaultProps = {
+  componentClass: ButtonGroup
+};
+
+var Dropdown =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Dropdown, _React$Component);
+
+  function Dropdown(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleClick = _this.handleClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleKeyDown = _this.handleKeyDown.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleClose = _this.handleClose.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this._focusInDropdown = false;
+    _this.lastOpenEventType = null;
+    return _this;
+  }
+
+  var _proto = Dropdown.prototype;
+
+  _proto.componentDidMount = function componentDidMount() {
+    this.focusNextOnOpen();
+  };
+
+  _proto.componentWillUpdate = function componentWillUpdate(nextProps) {
+    if (!nextProps.open && this.props.open) {
+      this._focusInDropdown = contains(ReactDOM.findDOMNode(this.menu), activeElement(document));
+    }
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    var open = this.props.open;
+    var prevOpen = prevProps.open;
+
+    if (open && !prevOpen) {
+      this.focusNextOnOpen();
+    }
+
+    if (!open && prevOpen) {
+      // if focus hasn't already moved from the menu let's return it
+      // to the toggle
+      if (this._focusInDropdown) {
+        this._focusInDropdown = false;
+        this.focus();
+      }
+    }
+  };
+
+  _proto.focus = function focus() {
+    var toggle = ReactDOM.findDOMNode(this.toggle);
+
+    if (toggle && toggle.focus) {
+      toggle.focus();
+    }
+  };
+
+  _proto.focusNextOnOpen = function focusNextOnOpen() {
+    var menu = this.menu;
+
+    if (!menu || !menu.focusNext) {
+      return;
+    }
+
+    if (this.lastOpenEventType === 'keydown' || this.props.role === 'menuitem') {
+      menu.focusNext();
+    }
+  };
+
+  _proto.handleClick = function handleClick(event) {
+    if (this.props.disabled) {
+      return;
+    }
+
+    this.toggleOpen(event, {
+      source: 'click'
+    });
+  };
+
+  _proto.handleClose = function handleClose(event, eventDetails) {
+    if (!this.props.open) {
+      return;
+    }
+
+    this.toggleOpen(event, eventDetails);
+  };
+
+  _proto.handleKeyDown = function handleKeyDown(event) {
+    if (this.props.disabled) {
+      return;
+    }
+
+    switch (event.keyCode) {
+      case keycode.codes.down:
+        if (!this.props.open) {
+          this.toggleOpen(event, {
+            source: 'keydown'
+          });
+        } else if (this.menu.focusNext) {
+          this.menu.focusNext();
+        }
+
+        event.preventDefault();
+        break;
+
+      case keycode.codes.esc:
+      case keycode.codes.tab:
+        this.handleClose(event, {
+          source: 'keydown'
+        });
+        break;
+
+      default:
+    }
+  };
+
+  _proto.toggleOpen = function toggleOpen(event, eventDetails) {
+    var open = !this.props.open;
+
+    if (open) {
+      this.lastOpenEventType = eventDetails.source;
+    }
+
+    if (this.props.onToggle) {
+      this.props.onToggle(open, event, eventDetails);
+    }
+  };
+
+  _proto.renderMenu = function renderMenu(child, _ref) {
+    var _this2 = this;
+
+    var id = _ref.id,
+        onSelect = _ref.onSelect,
+        rootCloseEvent = _ref.rootCloseEvent,
+        props = _objectWithoutPropertiesLoose(_ref, ["id", "onSelect", "rootCloseEvent"]);
+
+    var ref = function ref(c) {
+      _this2.menu = c;
+    };
+
+    if (typeof child.ref === 'string') {
+      process.env.NODE_ENV !== "production" ? warning(false, 'String refs are not supported on `<Dropdown.Menu>` components. ' + 'To apply a ref to the component use the callback signature:\n\n ' + 'https://facebook.github.io/react/docs/more-about-refs.html#the-ref-callback-attribute') : void 0;
+    } else {
+      ref = createChainedFunction(child.ref, ref);
+    }
+
+    return cloneElement(child, _extends({}, props, {
+      ref: ref,
+      labelledBy: id,
+      bsClass: prefix(props, 'menu'),
+      onClose: createChainedFunction(child.props.onClose, this.handleClose),
+      onSelect: createChainedFunction(child.props.onSelect, onSelect, function (key, event) {
+        return _this2.handleClose(event, {
+          source: 'select'
+        });
+      }),
+      rootCloseEvent: rootCloseEvent
+    }));
+  };
+
+  _proto.renderToggle = function renderToggle(child, props) {
+    var _this3 = this;
+
+    var ref = function ref(c) {
+      _this3.toggle = c;
+    };
+
+    if (typeof child.ref === 'string') {
+      process.env.NODE_ENV !== "production" ? warning(false, 'String refs are not supported on `<Dropdown.Toggle>` components. ' + 'To apply a ref to the component use the callback signature:\n\n ' + 'https://facebook.github.io/react/docs/more-about-refs.html#the-ref-callback-attribute') : void 0;
+    } else {
+      ref = createChainedFunction(child.ref, ref);
+    }
+
+    return cloneElement(child, _extends({}, props, {
+      ref: ref,
+      bsClass: prefix(props, 'toggle'),
+      onClick: createChainedFunction(child.props.onClick, this.handleClick),
+      onKeyDown: createChainedFunction(child.props.onKeyDown, this.handleKeyDown)
+    }));
+  };
+
+  _proto.render = function render() {
+    var _classes,
+        _this4 = this;
+
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        id = _this$props.id,
+        dropup = _this$props.dropup,
+        disabled = _this$props.disabled,
+        pullRight = _this$props.pullRight,
+        open = _this$props.open,
+        onSelect = _this$props.onSelect,
+        role = _this$props.role,
+        bsClass = _this$props.bsClass,
+        className = _this$props.className,
+        rootCloseEvent = _this$props.rootCloseEvent,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "id", "dropup", "disabled", "pullRight", "open", "onSelect", "role", "bsClass", "className", "rootCloseEvent", "children"]);
+
+    delete props.onToggle;
+    var classes = (_classes = {}, _classes[bsClass] = true, _classes.open = open, _classes.disabled = disabled, _classes);
+
+    if (dropup) {
+      classes[bsClass] = false;
+      classes.dropup = true;
+    } // This intentionally forwards bsSize and bsStyle (if set) to the
+    // underlying component, to allow it to render size and style variants.
+
+
+    return React.createElement(Component, _extends({}, props, {
+      className: classNames(className, classes)
+    }), ValidComponentChildren.map(children, function (child) {
+      switch (child.props.bsRole) {
+        case TOGGLE_ROLE:
+          return _this4.renderToggle(child, {
+            id: id,
+            disabled: disabled,
+            open: open,
+            role: role,
+            bsClass: bsClass
+          });
+
+        case MENU_ROLE:
+          return _this4.renderMenu(child, {
+            id: id,
+            open: open,
+            pullRight: pullRight,
+            bsClass: bsClass,
+            onSelect: onSelect,
+            rootCloseEvent: rootCloseEvent
+          });
+
+        default:
+          return child;
+      }
+    }));
+  };
+
+  return Dropdown;
+}(React.Component);
+
+Dropdown.propTypes = propTypes;
+Dropdown.defaultProps = defaultProps;
+setBsClass('dropdown', Dropdown);
+var UncontrolledDropdown = uncontrollable(Dropdown, {
+  open: 'onToggle'
+});
+UncontrolledDropdown.Toggle = DropdownToggle;
+UncontrolledDropdown.Menu = DropdownMenu;
+export default UncontrolledDropdown;

node_modules/react-bootstrap/es/DropdownButton.js

@@ -0,0 +1,59 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import React from 'react';
+import PropTypes from 'prop-types';
+import Dropdown from './Dropdown';
+import splitComponentProps from './utils/splitComponentProps';
+
+var propTypes = _extends({}, Dropdown.propTypes, {
+  // Toggle props.
+  bsStyle: PropTypes.string,
+  bsSize: PropTypes.string,
+  title: PropTypes.node.isRequired,
+  noCaret: PropTypes.bool,
+  // Override generated docs from <Dropdown>.
+
+  /**
+   * @private
+   */
+  children: PropTypes.node
+});
+
+var DropdownButton =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(DropdownButton, _React$Component);
+
+  function DropdownButton() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = DropdownButton.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        bsSize = _this$props.bsSize,
+        bsStyle = _this$props.bsStyle,
+        title = _this$props.title,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["bsSize", "bsStyle", "title", "children"]);
+
+    var _splitComponentProps = splitComponentProps(props, Dropdown.ControlledComponent),
+        dropdownProps = _splitComponentProps[0],
+        toggleProps = _splitComponentProps[1];
+
+    return React.createElement(Dropdown, _extends({}, dropdownProps, {
+      bsSize: bsSize,
+      bsStyle: bsStyle
+    }), React.createElement(Dropdown.Toggle, _extends({}, toggleProps, {
+      bsSize: bsSize,
+      bsStyle: bsStyle
+    }), title), React.createElement(Dropdown.Menu, null, children));
+  };
+
+  return DropdownButton;
+}(React.Component);
+
+DropdownButton.propTypes = propTypes;
+export default DropdownButton;

node_modules/react-bootstrap/es/DropdownMenu.js

@@ -0,0 +1,159 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _Array$from from "@babel/runtime-corejs2/core-js/array/from";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import keycode from 'keycode';
+import React from 'react';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import RootCloseWrapper from 'react-overlays/lib/RootCloseWrapper';
+import { bsClass, getClassSet, prefix, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+var propTypes = {
+  open: PropTypes.bool,
+  pullRight: PropTypes.bool,
+  onClose: PropTypes.func,
+  labelledBy: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  onSelect: PropTypes.func,
+  rootCloseEvent: PropTypes.oneOf(['click', 'mousedown'])
+};
+var defaultProps = {
+  bsRole: 'menu',
+  pullRight: false
+};
+
+var DropdownMenu =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(DropdownMenu, _React$Component);
+
+  function DropdownMenu(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.handleRootClose = _this.handleRootClose.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleKeyDown = _this.handleKeyDown.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = DropdownMenu.prototype;
+
+  _proto.getFocusableMenuItems = function getFocusableMenuItems() {
+    var node = ReactDOM.findDOMNode(this);
+
+    if (!node) {
+      return [];
+    }
+
+    return _Array$from(node.querySelectorAll('[tabIndex="-1"]'));
+  };
+
+  _proto.getItemsAndActiveIndex = function getItemsAndActiveIndex() {
+    var items = this.getFocusableMenuItems();
+    var activeIndex = items.indexOf(document.activeElement);
+    return {
+      items: items,
+      activeIndex: activeIndex
+    };
+  };
+
+  _proto.focusNext = function focusNext() {
+    var _this$getItemsAndActi = this.getItemsAndActiveIndex(),
+        items = _this$getItemsAndActi.items,
+        activeIndex = _this$getItemsAndActi.activeIndex;
+
+    if (items.length === 0) {
+      return;
+    }
+
+    var nextIndex = activeIndex === items.length - 1 ? 0 : activeIndex + 1;
+    items[nextIndex].focus();
+  };
+
+  _proto.focusPrevious = function focusPrevious() {
+    var _this$getItemsAndActi2 = this.getItemsAndActiveIndex(),
+        items = _this$getItemsAndActi2.items,
+        activeIndex = _this$getItemsAndActi2.activeIndex;
+
+    if (items.length === 0) {
+      return;
+    }
+
+    var prevIndex = activeIndex === 0 ? items.length - 1 : activeIndex - 1;
+    items[prevIndex].focus();
+  };
+
+  _proto.handleKeyDown = function handleKeyDown(event) {
+    switch (event.keyCode) {
+      case keycode.codes.down:
+        this.focusNext();
+        event.preventDefault();
+        break;
+
+      case keycode.codes.up:
+        this.focusPrevious();
+        event.preventDefault();
+        break;
+
+      case keycode.codes.esc:
+      case keycode.codes.tab:
+        this.props.onClose(event, {
+          source: 'keydown'
+        });
+        break;
+
+      default:
+    }
+  };
+
+  _proto.handleRootClose = function handleRootClose(event) {
+    this.props.onClose(event, {
+      source: 'rootClose'
+    });
+  };
+
+  _proto.render = function render() {
+    var _extends2,
+        _this2 = this;
+
+    var _this$props = this.props,
+        open = _this$props.open,
+        pullRight = _this$props.pullRight,
+        labelledBy = _this$props.labelledBy,
+        onSelect = _this$props.onSelect,
+        className = _this$props.className,
+        rootCloseEvent = _this$props.rootCloseEvent,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["open", "pullRight", "labelledBy", "onSelect", "className", "rootCloseEvent", "children"]);
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(props, ['onClose']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[prefix(bsProps, 'right')] = pullRight, _extends2));
+
+    return React.createElement(RootCloseWrapper, {
+      disabled: !open,
+      onRootClose: this.handleRootClose,
+      event: rootCloseEvent
+    }, React.createElement("ul", _extends({}, elementProps, {
+      role: "menu",
+      className: classNames(className, classes),
+      "aria-labelledby": labelledBy
+    }), ValidComponentChildren.map(children, function (child) {
+      return React.cloneElement(child, {
+        onKeyDown: createChainedFunction(child.props.onKeyDown, _this2.handleKeyDown),
+        onSelect: createChainedFunction(child.props.onSelect, onSelect)
+      });
+    })));
+  };
+
+  return DropdownMenu;
+}(React.Component);
+
+DropdownMenu.propTypes = propTypes;
+DropdownMenu.defaultProps = defaultProps;
+export default bsClass('dropdown-menu', DropdownMenu);

node_modules/react-bootstrap/es/DropdownToggle.js

@@ -0,0 +1,64 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Button from './Button';
+import SafeAnchor from './SafeAnchor';
+import { bsClass as setBsClass } from './utils/bootstrapUtils';
+var propTypes = {
+  noCaret: PropTypes.bool,
+  open: PropTypes.bool,
+  title: PropTypes.string,
+  useAnchor: PropTypes.bool
+};
+var defaultProps = {
+  open: false,
+  useAnchor: false,
+  bsRole: 'toggle'
+};
+
+var DropdownToggle =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(DropdownToggle, _React$Component);
+
+  function DropdownToggle() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = DropdownToggle.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        noCaret = _this$props.noCaret,
+        open = _this$props.open,
+        useAnchor = _this$props.useAnchor,
+        bsClass = _this$props.bsClass,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["noCaret", "open", "useAnchor", "bsClass", "className", "children"]);
+
+    delete props.bsRole;
+    var Component = useAnchor ? SafeAnchor : Button;
+    var useCaret = !noCaret; // This intentionally forwards bsSize and bsStyle (if set) to the
+    // underlying component, to allow it to render size and style variants.
+    // FIXME: Should this really fall back to `title` as children?
+
+    return React.createElement(Component, _extends({}, props, {
+      role: "button",
+      className: classNames(className, bsClass),
+      "aria-haspopup": true,
+      "aria-expanded": open
+    }), children || props.title, useCaret && ' ', useCaret && React.createElement("span", {
+      className: "caret"
+    }));
+  };
+
+  return DropdownToggle;
+}(React.Component);
+
+DropdownToggle.propTypes = propTypes;
+DropdownToggle.defaultProps = defaultProps;
+export default setBsClass('dropdown-toggle', DropdownToggle);

node_modules/react-bootstrap/es/Fade.js

@@ -0,0 +1,108 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+
+var _fadeStyles;
+
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import Transition, { ENTERED, ENTERING } from 'react-transition-group/Transition';
+var propTypes = {
+  /**
+   * Show the component; triggers the fade in or fade out animation
+   */
+  in: PropTypes.bool,
+
+  /**
+   * Wait until the first "enter" transition to mount the component (add it to the DOM)
+   */
+  mountOnEnter: PropTypes.bool,
+
+  /**
+   * Unmount the component (remove it from the DOM) when it is faded out
+   */
+  unmountOnExit: PropTypes.bool,
+
+  /**
+   * Run the fade in animation when the component mounts, if it is initially
+   * shown
+   */
+  appear: PropTypes.bool,
+
+  /**
+   * Duration of the fade animation in milliseconds, to ensure that finishing
+   * callbacks are fired even if the original browser transition end events are
+   * canceled
+   */
+  timeout: PropTypes.number,
+
+  /**
+   * Callback fired before the component fades in
+   */
+  onEnter: PropTypes.func,
+
+  /**
+   * Callback fired after the component starts to fade in
+   */
+  onEntering: PropTypes.func,
+
+  /**
+   * Callback fired after the has component faded in
+   */
+  onEntered: PropTypes.func,
+
+  /**
+   * Callback fired before the component fades out
+   */
+  onExit: PropTypes.func,
+
+  /**
+   * Callback fired after the component starts to fade out
+   */
+  onExiting: PropTypes.func,
+
+  /**
+   * Callback fired after the component has faded out
+   */
+  onExited: PropTypes.func
+};
+var defaultProps = {
+  in: false,
+  timeout: 300,
+  mountOnEnter: false,
+  unmountOnExit: false,
+  appear: false
+};
+var fadeStyles = (_fadeStyles = {}, _fadeStyles[ENTERING] = 'in', _fadeStyles[ENTERED] = 'in', _fadeStyles);
+
+var Fade =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Fade, _React$Component);
+
+  function Fade() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Fade.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className", "children"]);
+
+    return React.createElement(Transition, props, function (status, innerProps) {
+      return React.cloneElement(children, _extends({}, innerProps, {
+        className: classNames('fade', className, children.props.className, fadeStyles[status])
+      }));
+    });
+  };
+
+  return Fade;
+}(React.Component);
+
+Fade.propTypes = propTypes;
+Fade.defaultProps = defaultProps;
+export default Fade;

node_modules/react-bootstrap/es/Form.js

@@ -0,0 +1,63 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  horizontal: PropTypes.bool,
+  inline: PropTypes.bool,
+  componentClass: elementType
+};
+var defaultProps = {
+  horizontal: false,
+  inline: false,
+  componentClass: 'form'
+};
+
+var Form =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Form, _React$Component);
+
+  function Form() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Form.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        horizontal = _this$props.horizontal,
+        inline = _this$props.inline,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["horizontal", "inline", "componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = [];
+
+    if (horizontal) {
+      classes.push(prefix(bsProps, 'horizontal'));
+    }
+
+    if (inline) {
+      classes.push(prefix(bsProps, 'inline'));
+    }
+
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Form;
+}(React.Component);
+
+Form.propTypes = propTypes;
+Form.defaultProps = defaultProps;
+export default bsClass('form', Form);

node_modules/react-bootstrap/es/FormControl.js

@@ -0,0 +1,104 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import warning from 'warning';
+import FormControlFeedback from './FormControlFeedback';
+import FormControlStatic from './FormControlStatic';
+import { prefix, bsClass, getClassSet, splitBsProps, bsSizes } from './utils/bootstrapUtils';
+import { SIZE_MAP, Size } from './utils/StyleConfig';
+var propTypes = {
+  componentClass: elementType,
+
+  /**
+   * Only relevant if `componentClass` is `'input'`.
+   */
+  type: PropTypes.string,
+
+  /**
+   * Uses `controlId` from `<FormGroup>` if not explicitly specified.
+   */
+  id: PropTypes.string,
+
+  /**
+   * Attaches a ref to the `<input>` element. Only functions can be used here.
+   *
+   * ```js
+   * <FormControl inputRef={ref => { this.input = ref; }} />
+   * ```
+   */
+  inputRef: PropTypes.func
+};
+var defaultProps = {
+  componentClass: 'input'
+};
+var contextTypes = {
+  $bs_formGroup: PropTypes.object
+};
+
+var FormControl =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(FormControl, _React$Component);
+
+  function FormControl() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = FormControl.prototype;
+
+  _proto.render = function render() {
+    var formGroup = this.context.$bs_formGroup;
+    var controlId = formGroup && formGroup.controlId;
+
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        type = _this$props.type,
+        _this$props$id = _this$props.id,
+        id = _this$props$id === void 0 ? controlId : _this$props$id,
+        inputRef = _this$props.inputRef,
+        className = _this$props.className,
+        bsSize = _this$props.bsSize,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "type", "id", "inputRef", "className", "bsSize"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    process.env.NODE_ENV !== "production" ? warning(controlId == null || id === controlId, '`controlId` is ignored on `<FormControl>` when `id` is specified.') : void 0; // input[type="file"] should not have .form-control.
+
+    var classes;
+
+    if (type !== 'file') {
+      classes = getClassSet(bsProps);
+    } // If user provides a size, make sure to append it to classes as input-
+    // e.g. if bsSize is small, it will append input-sm
+
+
+    if (bsSize) {
+      var size = SIZE_MAP[bsSize] || bsSize;
+      classes[prefix({
+        bsClass: 'input'
+      }, size)] = true;
+    }
+
+    return React.createElement(Component, _extends({}, elementProps, {
+      type: type,
+      id: id,
+      ref: inputRef,
+      className: classNames(className, classes)
+    }));
+  };
+
+  return FormControl;
+}(React.Component);
+
+FormControl.propTypes = propTypes;
+FormControl.defaultProps = defaultProps;
+FormControl.contextTypes = contextTypes;
+FormControl.Feedback = FormControlFeedback;
+FormControl.Static = FormControlStatic;
+export default bsClass('form-control', bsSizes([Size.SMALL, Size.LARGE], FormControl));

node_modules/react-bootstrap/es/FormControlFeedback.js

@@ -0,0 +1,83 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import Glyphicon from './Glyphicon';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var defaultProps = {
+  bsRole: 'feedback'
+};
+var contextTypes = {
+  $bs_formGroup: PropTypes.object
+};
+
+var FormControlFeedback =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(FormControlFeedback, _React$Component);
+
+  function FormControlFeedback() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = FormControlFeedback.prototype;
+
+  _proto.getGlyph = function getGlyph(validationState) {
+    switch (validationState) {
+      case 'success':
+        return 'ok';
+
+      case 'warning':
+        return 'warning-sign';
+
+      case 'error':
+        return 'remove';
+
+      default:
+        return null;
+    }
+  };
+
+  _proto.renderDefaultFeedback = function renderDefaultFeedback(formGroup, className, classes, elementProps) {
+    var glyph = this.getGlyph(formGroup && formGroup.validationState);
+
+    if (!glyph) {
+      return null;
+    }
+
+    return React.createElement(Glyphicon, _extends({}, elementProps, {
+      glyph: glyph,
+      className: classNames(className, classes)
+    }));
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+
+    if (!children) {
+      return this.renderDefaultFeedback(this.context.$bs_formGroup, className, classes, elementProps);
+    }
+
+    var child = React.Children.only(children);
+    return React.cloneElement(child, _extends({}, elementProps, {
+      className: classNames(child.props.className, className, classes)
+    }));
+  };
+
+  return FormControlFeedback;
+}(React.Component);
+
+FormControlFeedback.defaultProps = defaultProps;
+FormControlFeedback.contextTypes = contextTypes;
+export default bsClass('form-control-feedback', FormControlFeedback);

node_modules/react-bootstrap/es/FormControlStatic.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'p'
+};
+
+var FormControlStatic =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(FormControlStatic, _React$Component);
+
+  function FormControlStatic() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = FormControlStatic.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return FormControlStatic;
+}(React.Component);
+
+FormControlStatic.propTypes = propTypes;
+FormControlStatic.defaultProps = defaultProps;
+export default bsClass('form-control-static', FormControlStatic);

node_modules/react-bootstrap/es/FormGroup.js

@@ -0,0 +1,81 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { bsClass, bsSizes, getClassSet, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+import { Size } from './utils/StyleConfig';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+var propTypes = {
+  /**
+   * Sets `id` on `<FormControl>` and `htmlFor` on `<FormGroup.Label>`.
+   */
+  controlId: PropTypes.string,
+  validationState: PropTypes.oneOf(['success', 'warning', 'error', null])
+};
+var childContextTypes = {
+  $bs_formGroup: PropTypes.object.isRequired
+};
+
+var FormGroup =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(FormGroup, _React$Component);
+
+  function FormGroup() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = FormGroup.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    var _this$props = this.props,
+        controlId = _this$props.controlId,
+        validationState = _this$props.validationState;
+    return {
+      $bs_formGroup: {
+        controlId: controlId,
+        validationState: validationState
+      }
+    };
+  };
+
+  _proto.hasFeedback = function hasFeedback(children) {
+    var _this = this;
+
+    return ValidComponentChildren.some(children, function (child) {
+      return child.props.bsRole === 'feedback' || child.props.children && _this.hasFeedback(child.props.children);
+    });
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        validationState = _this$props2.validationState,
+        className = _this$props2.className,
+        children = _this$props2.children,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["validationState", "className", "children"]);
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(props, ['controlId']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1];
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      'has-feedback': this.hasFeedback(children)
+    });
+
+    if (validationState) {
+      classes["has-" + validationState] = true;
+    }
+
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), children);
+  };
+
+  return FormGroup;
+}(React.Component);
+
+FormGroup.propTypes = propTypes;
+FormGroup.childContextTypes = childContextTypes;
+export default bsClass('form-group', bsSizes([Size.LARGE, Size.SMALL], FormGroup));

node_modules/react-bootstrap/es/Glyphicon.js

@@ -0,0 +1,49 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * An icon name without "glyphicon-" prefix. See e.g. http://getbootstrap.com/components/#glyphicons
+   */
+  glyph: PropTypes.string.isRequired
+};
+
+var Glyphicon =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Glyphicon, _React$Component);
+
+  function Glyphicon() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Glyphicon.prototype;
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        glyph = _this$props.glyph,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["glyph", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[prefix(bsProps, glyph)] = true, _extends2));
+
+    return React.createElement("span", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Glyphicon;
+}(React.Component);
+
+Glyphicon.propTypes = propTypes;
+export default bsClass('glyphicon', Glyphicon);

node_modules/react-bootstrap/es/Grid.js

@@ -0,0 +1,60 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * Turn any fixed-width grid layout into a full-width layout by this property.
+   *
+   * Adds `container-fluid` class.
+   */
+  fluid: PropTypes.bool,
+
+  /**
+   * You can use a custom element for this component
+   */
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div',
+  fluid: false
+};
+
+var Grid =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Grid, _React$Component);
+
+  function Grid() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Grid.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        fluid = _this$props.fluid,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["fluid", "componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = prefix(bsProps, fluid && 'fluid');
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Grid;
+}(React.Component);
+
+Grid.propTypes = propTypes;
+Grid.defaultProps = defaultProps;
+export default bsClass('container', Grid);

node_modules/react-bootstrap/es/HelpBlock.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var HelpBlock =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(HelpBlock, _React$Component);
+
+  function HelpBlock() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = HelpBlock.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("span", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return HelpBlock;
+}(React.Component);
+
+export default bsClass('help-block', HelpBlock);

node_modules/react-bootstrap/es/Image.js

@@ -0,0 +1,73 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { bsClass, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * Sets image as responsive image
+   */
+  responsive: PropTypes.bool,
+
+  /**
+   * Sets image shape as rounded
+   */
+  rounded: PropTypes.bool,
+
+  /**
+   * Sets image shape as circle
+   */
+  circle: PropTypes.bool,
+
+  /**
+   * Sets image shape as thumbnail
+   */
+  thumbnail: PropTypes.bool
+};
+var defaultProps = {
+  responsive: false,
+  rounded: false,
+  circle: false,
+  thumbnail: false
+};
+
+var Image =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Image, _React$Component);
+
+  function Image() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Image.prototype;
+
+  _proto.render = function render() {
+    var _classes;
+
+    var _this$props = this.props,
+        responsive = _this$props.responsive,
+        rounded = _this$props.rounded,
+        circle = _this$props.circle,
+        thumbnail = _this$props.thumbnail,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["responsive", "rounded", "circle", "thumbnail", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = (_classes = {}, _classes[prefix(bsProps, 'responsive')] = responsive, _classes[prefix(bsProps, 'rounded')] = rounded, _classes[prefix(bsProps, 'circle')] = circle, _classes[prefix(bsProps, 'thumbnail')] = thumbnail, _classes);
+    return React.createElement("img", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Image;
+}(React.Component);
+
+Image.propTypes = propTypes;
+Image.defaultProps = defaultProps;
+export default bsClass('img', Image);

node_modules/react-bootstrap/es/InputGroup.js

@@ -0,0 +1,42 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import InputGroupAddon from './InputGroupAddon';
+import InputGroupButton from './InputGroupButton';
+import { bsClass, bsSizes, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+import { Size } from './utils/StyleConfig';
+
+var InputGroup =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(InputGroup, _React$Component);
+
+  function InputGroup() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = InputGroup.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("span", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return InputGroup;
+}(React.Component);
+
+InputGroup.Addon = InputGroupAddon;
+InputGroup.Button = InputGroupButton;
+export default bsClass('input-group', bsSizes([Size.LARGE, Size.SMALL], InputGroup));

node_modules/react-bootstrap/es/InputGroupAddon.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var InputGroupAddon =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(InputGroupAddon, _React$Component);
+
+  function InputGroupAddon() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = InputGroupAddon.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("span", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return InputGroupAddon;
+}(React.Component);
+
+export default bsClass('input-group-addon', InputGroupAddon);

node_modules/react-bootstrap/es/InputGroupButton.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var InputGroupButton =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(InputGroupButton, _React$Component);
+
+  function InputGroupButton() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = InputGroupButton.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("span", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return InputGroupButton;
+}(React.Component);
+
+export default bsClass('input-group-btn', InputGroupButton);

node_modules/react-bootstrap/es/Jumbotron.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import React from 'react';
+import classNames from 'classnames';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var Jumbotron =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Jumbotron, _React$Component);
+
+  function Jumbotron() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Jumbotron.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Jumbotron;
+}(React.Component);
+
+Jumbotron.propTypes = propTypes;
+Jumbotron.defaultProps = defaultProps;
+export default bsClass('jumbotron', Jumbotron);

node_modules/react-bootstrap/es/Label.js

@@ -0,0 +1,58 @@
+import _Object$values from "@babel/runtime-corejs2/core-js/object/values";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, bsStyles, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+import { State, Style } from './utils/StyleConfig';
+
+var Label =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Label, _React$Component);
+
+  function Label() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Label.prototype;
+
+  _proto.hasContent = function hasContent(children) {
+    var result = false;
+    React.Children.forEach(children, function (child) {
+      if (result) {
+        return;
+      }
+
+      if (child || child === 0) {
+        result = true;
+      }
+    });
+    return result;
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      // Hack for collapsing on IE8.
+      hidden: !this.hasContent(children)
+    });
+
+    return React.createElement("span", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), children);
+  };
+
+  return Label;
+}(React.Component);
+
+export default bsClass('label', bsStyles(_Object$values(State).concat([Style.DEFAULT, Style.PRIMARY]), Style.DEFAULT, Label));

node_modules/react-bootstrap/es/ListGroup.js

@@ -0,0 +1,75 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React, { cloneElement } from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import ListGroupItem from './ListGroupItem';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+var propTypes = {
+  /**
+   * You can use a custom element type for this component.
+   *
+   * If not specified, it will be treated as `'li'` if every child is a
+   * non-actionable `<ListGroupItem>`, and `'div'` otherwise.
+   */
+  componentClass: elementType
+};
+
+function getDefaultComponent(children) {
+  if (!children) {
+    // FIXME: This is the old behavior. Is this right?
+    return 'div';
+  }
+
+  if (ValidComponentChildren.some(children, function (child) {
+    return child.type !== ListGroupItem || child.props.href || child.props.onClick;
+  })) {
+    return 'div';
+  }
+
+  return 'ul';
+}
+
+var ListGroup =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ListGroup, _React$Component);
+
+  function ListGroup() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ListGroup.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        _this$props$component = _this$props.componentClass,
+        Component = _this$props$component === void 0 ? getDefaultComponent(children) : _this$props$component,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["children", "componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    var useListItem = Component === 'ul' && ValidComponentChildren.every(children, function (child) {
+      return child.type === ListGroupItem;
+    });
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), useListItem ? ValidComponentChildren.map(children, function (child) {
+      return cloneElement(child, {
+        listItem: true
+      });
+    }) : children);
+  };
+
+  return ListGroup;
+}(React.Component);
+
+ListGroup.propTypes = propTypes;
+export default bsClass('list-group', ListGroup);

node_modules/react-bootstrap/es/ListGroupItem.js

@@ -0,0 +1,94 @@
+import _Object$values from "@babel/runtime-corejs2/core-js/object/values";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import { bsClass, bsStyles, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+import { State } from './utils/StyleConfig';
+var propTypes = {
+  active: PropTypes.any,
+  disabled: PropTypes.any,
+  header: PropTypes.node,
+  listItem: PropTypes.bool,
+  onClick: PropTypes.func,
+  href: PropTypes.string,
+  type: PropTypes.string
+};
+var defaultProps = {
+  listItem: false
+};
+
+var ListGroupItem =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ListGroupItem, _React$Component);
+
+  function ListGroupItem() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ListGroupItem.prototype;
+
+  _proto.renderHeader = function renderHeader(header, headingClassName) {
+    if (React.isValidElement(header)) {
+      return cloneElement(header, {
+        className: classNames(header.props.className, headingClassName)
+      });
+    }
+
+    return React.createElement("h4", {
+      className: headingClassName
+    }, header);
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        active = _this$props.active,
+        disabled = _this$props.disabled,
+        className = _this$props.className,
+        header = _this$props.header,
+        listItem = _this$props.listItem,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["active", "disabled", "className", "header", "listItem", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      active: active,
+      disabled: disabled
+    });
+
+    var Component;
+
+    if (elementProps.href) {
+      Component = 'a';
+    } else if (elementProps.onClick) {
+      Component = 'button';
+      elementProps.type = elementProps.type || 'button';
+    } else if (listItem) {
+      Component = 'li';
+    } else {
+      Component = 'span';
+    }
+
+    elementProps.className = classNames(className, classes); // TODO: Deprecate `header` prop.
+
+    if (header) {
+      return React.createElement(Component, elementProps, this.renderHeader(header, prefix(bsProps, 'heading')), React.createElement("p", {
+        className: prefix(bsProps, 'text')
+      }, children));
+    }
+
+    return React.createElement(Component, elementProps, children);
+  };
+
+  return ListGroupItem;
+}(React.Component);
+
+ListGroupItem.propTypes = propTypes;
+ListGroupItem.defaultProps = defaultProps;
+export default bsClass('list-group-item', bsStyles(_Object$values(State), ListGroupItem));

node_modules/react-bootstrap/es/Media.js

@@ -0,0 +1,59 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import MediaBody from './MediaBody';
+import MediaHeading from './MediaHeading';
+import MediaLeft from './MediaLeft';
+import MediaList from './MediaList';
+import MediaListItem from './MediaListItem';
+import MediaRight from './MediaRight';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var Media =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Media, _React$Component);
+
+  function Media() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Media.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Media;
+}(React.Component);
+
+Media.propTypes = propTypes;
+Media.defaultProps = defaultProps;
+Media.Heading = MediaHeading;
+Media.Body = MediaBody;
+Media.Left = MediaLeft;
+Media.Right = MediaRight;
+Media.List = MediaList;
+Media.ListItem = MediaListItem;
+export default bsClass('media', Media);

node_modules/react-bootstrap/es/MediaBody.js

@@ -0,0 +1,60 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import Media from './Media';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * Align the media to the top, middle, or bottom of the media object.
+   */
+  align: PropTypes.oneOf(['top', 'middle', 'bottom']),
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var MediaBody =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(MediaBody, _React$Component);
+
+  function MediaBody() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = MediaBody.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        align = _this$props.align,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "align", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+
+    if (align) {
+      // The class is e.g. `media-top`, not `media-left-top`.
+      classes[prefix(Media.defaultProps, align)] = true;
+    }
+
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return MediaBody;
+}(React.Component);
+
+MediaBody.propTypes = propTypes;
+MediaBody.defaultProps = defaultProps;
+export default bsClass('media-body', MediaBody);

node_modules/react-bootstrap/es/MediaHeading.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'h4'
+};
+
+var MediaHeading =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(MediaHeading, _React$Component);
+
+  function MediaHeading() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = MediaHeading.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return MediaHeading;
+}(React.Component);
+
+MediaHeading.propTypes = propTypes;
+MediaHeading.defaultProps = defaultProps;
+export default bsClass('media-heading', MediaHeading);

node_modules/react-bootstrap/es/MediaLeft.js

@@ -0,0 +1,53 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import Media from './Media';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * Align the media to the top, middle, or bottom of the media object.
+   */
+  align: PropTypes.oneOf(['top', 'middle', 'bottom'])
+};
+
+var MediaLeft =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(MediaLeft, _React$Component);
+
+  function MediaLeft() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = MediaLeft.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        align = _this$props.align,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["align", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+
+    if (align) {
+      // The class is e.g. `media-top`, not `media-left-top`.
+      classes[prefix(Media.defaultProps, align)] = true;
+    }
+
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return MediaLeft;
+}(React.Component);
+
+MediaLeft.propTypes = propTypes;
+export default bsClass('media-left', MediaLeft);

node_modules/react-bootstrap/es/MediaList.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var MediaList =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(MediaList, _React$Component);
+
+  function MediaList() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = MediaList.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("ul", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return MediaList;
+}(React.Component);
+
+export default bsClass('media-list', MediaList);

node_modules/react-bootstrap/es/MediaListItem.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var MediaListItem =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(MediaListItem, _React$Component);
+
+  function MediaListItem() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = MediaListItem.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("li", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return MediaListItem;
+}(React.Component);
+
+export default bsClass('media', MediaListItem);

node_modules/react-bootstrap/es/MediaRight.js

@@ -0,0 +1,53 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import Media from './Media';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * Align the media to the top, middle, or bottom of the media object.
+   */
+  align: PropTypes.oneOf(['top', 'middle', 'bottom'])
+};
+
+var MediaRight =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(MediaRight, _React$Component);
+
+  function MediaRight() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = MediaRight.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        align = _this$props.align,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["align", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+
+    if (align) {
+      // The class is e.g. `media-top`, not `media-right-top`.
+      classes[prefix(Media.defaultProps, align)] = true;
+    }
+
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return MediaRight;
+}(React.Component);
+
+MediaRight.propTypes = propTypes;
+export default bsClass('media-right', MediaRight);

node_modules/react-bootstrap/es/MenuItem.js

@@ -0,0 +1,155 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import all from 'prop-types-extra/lib/all';
+import SafeAnchor from './SafeAnchor';
+import { bsClass, prefix, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+var propTypes = {
+  /**
+   * Highlight the menu item as active.
+   */
+  active: PropTypes.bool,
+
+  /**
+   * Disable the menu item, making it unselectable.
+   */
+  disabled: PropTypes.bool,
+
+  /**
+   * Styles the menu item as a horizontal rule, providing visual separation between
+   * groups of menu items.
+   */
+  divider: all(PropTypes.bool, function (_ref) {
+    var divider = _ref.divider,
+        children = _ref.children;
+    return divider && children ? new Error('Children will not be rendered for dividers') : null;
+  }),
+
+  /**
+   * Value passed to the `onSelect` handler, useful for identifying the selected menu item.
+   */
+  eventKey: PropTypes.any,
+
+  /**
+   * Styles the menu item as a header label, useful for describing a group of menu items.
+   */
+  header: PropTypes.bool,
+
+  /**
+   * HTML `href` attribute corresponding to `a.href`.
+   */
+  href: PropTypes.string,
+
+  /**
+   * Callback fired when the menu item is clicked.
+   */
+  onClick: PropTypes.func,
+
+  /**
+   * Callback fired when the menu item is selected.
+   *
+   * ```js
+   * (eventKey: any, event: Object) => any
+   * ```
+   */
+  onSelect: PropTypes.func
+};
+var defaultProps = {
+  divider: false,
+  disabled: false,
+  header: false
+};
+
+var MenuItem =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(MenuItem, _React$Component);
+
+  function MenuItem(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleClick = _this.handleClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = MenuItem.prototype;
+
+  _proto.handleClick = function handleClick(event) {
+    var _this$props = this.props,
+        href = _this$props.href,
+        disabled = _this$props.disabled,
+        onSelect = _this$props.onSelect,
+        eventKey = _this$props.eventKey;
+
+    if (!href || disabled) {
+      event.preventDefault();
+    }
+
+    if (disabled) {
+      return;
+    }
+
+    if (onSelect) {
+      onSelect(eventKey, event);
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        active = _this$props2.active,
+        disabled = _this$props2.disabled,
+        divider = _this$props2.divider,
+        header = _this$props2.header,
+        onClick = _this$props2.onClick,
+        className = _this$props2.className,
+        style = _this$props2.style,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["active", "disabled", "divider", "header", "onClick", "className", "style"]);
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(props, ['eventKey', 'onSelect']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1];
+
+    if (divider) {
+      // Forcibly blank out the children; separators shouldn't render any.
+      elementProps.children = undefined;
+      return React.createElement("li", _extends({}, elementProps, {
+        role: "separator",
+        className: classNames(className, 'divider'),
+        style: style
+      }));
+    }
+
+    if (header) {
+      return React.createElement("li", _extends({}, elementProps, {
+        role: "heading",
+        className: classNames(className, prefix(bsProps, 'header')),
+        style: style
+      }));
+    }
+
+    return React.createElement("li", {
+      role: "presentation",
+      className: classNames(className, {
+        active: active,
+        disabled: disabled
+      }),
+      style: style
+    }, React.createElement(SafeAnchor, _extends({}, elementProps, {
+      role: "menuitem",
+      tabIndex: "-1",
+      onClick: createChainedFunction(onClick, this.handleClick)
+    })));
+  };
+
+  return MenuItem;
+}(React.Component);
+
+MenuItem.propTypes = propTypes;
+MenuItem.defaultProps = defaultProps;
+export default bsClass('dropdown', MenuItem);

node_modules/react-bootstrap/es/Modal.js

@@ -0,0 +1,281 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import classNames from 'classnames';
+import events from 'dom-helpers/events';
+import ownerDocument from 'dom-helpers/ownerDocument';
+import canUseDOM from 'dom-helpers/util/inDOM';
+import getScrollbarSize from 'dom-helpers/util/scrollbarSize';
+import React from 'react';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import BaseModal from 'react-overlays/lib/Modal';
+import isOverflowing from 'react-overlays/lib/utils/isOverflowing';
+import elementType from 'prop-types-extra/lib/elementType';
+import Fade from './Fade';
+import Body from './ModalBody';
+import ModalDialog from './ModalDialog';
+import Footer from './ModalFooter';
+import Header from './ModalHeader';
+import Title from './ModalTitle';
+import { bsClass, bsSizes, prefix } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+import splitComponentProps from './utils/splitComponentProps';
+import { Size } from './utils/StyleConfig';
+
+var propTypes = _extends({}, BaseModal.propTypes, ModalDialog.propTypes, {
+  /**
+   * Include a backdrop component. Specify 'static' for a backdrop that doesn't
+   * trigger an "onHide" when clicked.
+   */
+  backdrop: PropTypes.oneOf(['static', true, false]),
+
+  /**
+   * Add an optional extra class name to .modal-backdrop
+   * It could end up looking like class="modal-backdrop foo-modal-backdrop in".
+   */
+  backdropClassName: PropTypes.string,
+
+  /**
+   * Close the modal when escape key is pressed
+   */
+  keyboard: PropTypes.bool,
+
+  /**
+   * Open and close the Modal with a slide and fade animation.
+   */
+  animation: PropTypes.bool,
+
+  /**
+   * A Component type that provides the modal content Markup. This is a useful
+   * prop when you want to use your own styles and markup to create a custom
+   * modal component.
+   */
+  dialogComponentClass: elementType,
+
+  /**
+   * When `true` The modal will automatically shift focus to itself when it
+   * opens, and replace it to the last focused element when it closes.
+   * Generally this should never be set to false as it makes the Modal less
+   * accessible to assistive technologies, like screen-readers.
+   */
+  autoFocus: PropTypes.bool,
+
+  /**
+   * When `true` The modal will prevent focus from leaving the Modal while
+   * open. Consider leaving the default value here, as it is necessary to make
+   * the Modal work well with assistive technologies, such as screen readers.
+   */
+  enforceFocus: PropTypes.bool,
+
+  /**
+   * When `true` The modal will restore focus to previously focused element once
+   * modal is hidden
+   */
+  restoreFocus: PropTypes.bool,
+
+  /**
+   * When `true` The modal will show itself.
+   */
+  show: PropTypes.bool,
+
+  /**
+   * A callback fired when the header closeButton or non-static backdrop is
+   * clicked. Required if either are specified.
+   */
+  onHide: PropTypes.func,
+
+  /**
+   * Callback fired before the Modal transitions in
+   */
+  onEnter: PropTypes.func,
+
+  /**
+   * Callback fired as the Modal begins to transition in
+   */
+  onEntering: PropTypes.func,
+
+  /**
+   * Callback fired after the Modal finishes transitioning in
+   */
+  onEntered: PropTypes.func,
+
+  /**
+   * Callback fired right before the Modal transitions out
+   */
+  onExit: PropTypes.func,
+
+  /**
+   * Callback fired as the Modal begins to transition out
+   */
+  onExiting: PropTypes.func,
+
+  /**
+   * Callback fired after the Modal finishes transitioning out
+   */
+  onExited: PropTypes.func,
+
+  /**
+   * @private
+   */
+  container: BaseModal.propTypes.container
+});
+
+var defaultProps = _extends({}, BaseModal.defaultProps, {
+  animation: true,
+  dialogComponentClass: ModalDialog
+});
+
+var childContextTypes = {
+  $bs_modal: PropTypes.shape({
+    onHide: PropTypes.func
+  })
+};
+/* eslint-disable no-use-before-define, react/no-multi-comp */
+
+function DialogTransition(props) {
+  return React.createElement(Fade, _extends({}, props, {
+    timeout: Modal.TRANSITION_DURATION
+  }));
+}
+
+function BackdropTransition(props) {
+  return React.createElement(Fade, _extends({}, props, {
+    timeout: Modal.BACKDROP_TRANSITION_DURATION
+  }));
+}
+/* eslint-enable no-use-before-define */
+
+
+var Modal =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Modal, _React$Component);
+
+  function Modal(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleEntering = _this.handleEntering.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleExited = _this.handleExited.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleWindowResize = _this.handleWindowResize.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleDialogClick = _this.handleDialogClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.setModalRef = _this.setModalRef.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.state = {
+      style: {}
+    };
+    return _this;
+  }
+
+  var _proto = Modal.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    return {
+      $bs_modal: {
+        onHide: this.props.onHide
+      }
+    };
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    // Clean up the listener if we need to.
+    this.handleExited();
+  };
+
+  _proto.setModalRef = function setModalRef(ref) {
+    this._modal = ref;
+  };
+
+  _proto.handleDialogClick = function handleDialogClick(e) {
+    if (e.target !== e.currentTarget) {
+      return;
+    }
+
+    this.props.onHide();
+  };
+
+  _proto.handleEntering = function handleEntering() {
+    // FIXME: This should work even when animation is disabled.
+    events.on(window, 'resize', this.handleWindowResize);
+    this.updateStyle();
+  };
+
+  _proto.handleExited = function handleExited() {
+    // FIXME: This should work even when animation is disabled.
+    events.off(window, 'resize', this.handleWindowResize);
+  };
+
+  _proto.handleWindowResize = function handleWindowResize() {
+    this.updateStyle();
+  };
+
+  _proto.updateStyle = function updateStyle() {
+    if (!canUseDOM) {
+      return;
+    }
+
+    var dialogNode = this._modal.getDialogElement();
+
+    var dialogHeight = dialogNode.scrollHeight;
+    var document = ownerDocument(dialogNode);
+    var bodyIsOverflowing = isOverflowing(ReactDOM.findDOMNode(this.props.container || document.body));
+    var modalIsOverflowing = dialogHeight > document.documentElement.clientHeight;
+    this.setState({
+      style: {
+        paddingRight: bodyIsOverflowing && !modalIsOverflowing ? getScrollbarSize() : undefined,
+        paddingLeft: !bodyIsOverflowing && modalIsOverflowing ? getScrollbarSize() : undefined
+      }
+    });
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        backdrop = _this$props.backdrop,
+        backdropClassName = _this$props.backdropClassName,
+        animation = _this$props.animation,
+        show = _this$props.show,
+        Dialog = _this$props.dialogComponentClass,
+        className = _this$props.className,
+        style = _this$props.style,
+        children = _this$props.children,
+        onEntering = _this$props.onEntering,
+        onExited = _this$props.onExited,
+        props = _objectWithoutPropertiesLoose(_this$props, ["backdrop", "backdropClassName", "animation", "show", "dialogComponentClass", "className", "style", "children", "onEntering", "onExited"]);
+
+    var _splitComponentProps = splitComponentProps(props, BaseModal),
+        baseModalProps = _splitComponentProps[0],
+        dialogProps = _splitComponentProps[1];
+
+    var inClassName = show && !animation && 'in';
+    return React.createElement(BaseModal, _extends({}, baseModalProps, {
+      ref: this.setModalRef,
+      show: show,
+      containerClassName: prefix(props, 'open'),
+      transition: animation ? DialogTransition : undefined,
+      backdrop: backdrop,
+      backdropTransition: animation ? BackdropTransition : undefined,
+      backdropClassName: classNames(prefix(props, 'backdrop'), backdropClassName, inClassName),
+      onEntering: createChainedFunction(onEntering, this.handleEntering),
+      onExited: createChainedFunction(onExited, this.handleExited)
+    }), React.createElement(Dialog, _extends({}, dialogProps, {
+      style: _extends({}, this.state.style, style),
+      className: classNames(className, inClassName),
+      onClick: backdrop === true ? this.handleDialogClick : null
+    }), children));
+  };
+
+  return Modal;
+}(React.Component);
+
+Modal.propTypes = propTypes;
+Modal.defaultProps = defaultProps;
+Modal.childContextTypes = childContextTypes;
+Modal.Body = Body;
+Modal.Header = Header;
+Modal.Title = Title;
+Modal.Footer = Footer;
+Modal.Dialog = ModalDialog;
+Modal.TRANSITION_DURATION = 300;
+Modal.BACKDROP_TRANSITION_DURATION = 150;
+export default bsClass('modal', bsSizes([Size.LARGE, Size.SMALL], Modal));

node_modules/react-bootstrap/es/ModalBody.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var ModalBody =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ModalBody, _React$Component);
+
+  function ModalBody() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ModalBody.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return ModalBody;
+}(React.Component);
+
+ModalBody.propTypes = propTypes;
+ModalBody.defaultProps = defaultProps;
+export default bsClass('modal-body', ModalBody);

node_modules/react-bootstrap/es/ModalDialog.js

@@ -0,0 +1,66 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { bsClass, bsSizes, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+import { Size } from './utils/StyleConfig';
+var propTypes = {
+  /**
+   * A css class to apply to the Modal dialog DOM node.
+   */
+  dialogClassName: PropTypes.string
+};
+
+var ModalDialog =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ModalDialog, _React$Component);
+
+  function ModalDialog() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ModalDialog.prototype;
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        dialogClassName = _this$props.dialogClassName,
+        className = _this$props.className,
+        style = _this$props.style,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["dialogClassName", "className", "style", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var bsClassName = prefix(bsProps);
+
+    var modalStyle = _extends({
+      display: 'block'
+    }, style);
+
+    var dialogClasses = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[bsClassName] = false, _extends2[prefix(bsProps, 'dialog')] = true, _extends2));
+
+    return React.createElement("div", _extends({}, elementProps, {
+      tabIndex: "-1",
+      role: "dialog",
+      style: modalStyle,
+      className: classNames(className, bsClassName)
+    }), React.createElement("div", {
+      className: classNames(dialogClassName, dialogClasses)
+    }, React.createElement("div", {
+      className: prefix(bsProps, 'content'),
+      role: "document"
+    }, children)));
+  };
+
+  return ModalDialog;
+}(React.Component);
+
+ModalDialog.propTypes = propTypes;
+export default bsClass('modal', bsSizes([Size.LARGE, Size.SMALL], ModalDialog));

node_modules/react-bootstrap/es/ModalFooter.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var ModalFooter =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ModalFooter, _React$Component);
+
+  function ModalFooter() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ModalFooter.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return ModalFooter;
+}(React.Component);
+
+ModalFooter.propTypes = propTypes;
+ModalFooter.defaultProps = defaultProps;
+export default bsClass('modal-footer', ModalFooter);

node_modules/react-bootstrap/es/ModalHeader.js

@@ -0,0 +1,82 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import PropTypes from 'prop-types';
+import React from 'react';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+import CloseButton from './CloseButton'; // TODO: `aria-label` should be `closeLabel`.
+
+var propTypes = {
+  /**
+   * Provides an accessible label for the close
+   * button. It is used for Assistive Technology when the label text is not
+   * readable.
+   */
+  closeLabel: PropTypes.string,
+
+  /**
+   * Specify whether the Component should contain a close button
+   */
+  closeButton: PropTypes.bool,
+
+  /**
+   * A Callback fired when the close button is clicked. If used directly inside
+   * a Modal component, the onHide will automatically be propagated up to the
+   * parent Modal `onHide`.
+   */
+  onHide: PropTypes.func
+};
+var defaultProps = {
+  closeLabel: 'Close',
+  closeButton: false
+};
+var contextTypes = {
+  $bs_modal: PropTypes.shape({
+    onHide: PropTypes.func
+  })
+};
+
+var ModalHeader =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ModalHeader, _React$Component);
+
+  function ModalHeader() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ModalHeader.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        closeLabel = _this$props.closeLabel,
+        closeButton = _this$props.closeButton,
+        onHide = _this$props.onHide,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["closeLabel", "closeButton", "onHide", "className", "children"]);
+
+    var modal = this.context.$bs_modal;
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), closeButton && React.createElement(CloseButton, {
+      label: closeLabel,
+      onClick: createChainedFunction(modal && modal.onHide, onHide)
+    }), children);
+  };
+
+  return ModalHeader;
+}(React.Component);
+
+ModalHeader.propTypes = propTypes;
+ModalHeader.defaultProps = defaultProps;
+ModalHeader.contextTypes = contextTypes;
+export default bsClass('modal-header', ModalHeader);

node_modules/react-bootstrap/es/ModalTitle.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'h4'
+};
+
+var ModalTitle =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ModalTitle, _React$Component);
+
+  function ModalTitle() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ModalTitle.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return ModalTitle;
+}(React.Component);
+
+ModalTitle.propTypes = propTypes;
+ModalTitle.defaultProps = defaultProps;
+export default bsClass('modal-title', ModalTitle);

node_modules/react-bootstrap/es/Nav.js

@@ -0,0 +1,335 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import keycode from 'keycode';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import all from 'prop-types-extra/lib/all';
+import warning from 'warning';
+import { bsClass, bsStyles, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+import ValidComponentChildren from './utils/ValidComponentChildren'; // TODO: Should we expose `<NavItem>` as `<Nav.Item>`?
+// TODO: This `bsStyle` is very unlike the others. Should we rename it?
+// TODO: `pullRight` and `pullLeft` don't render right outside of `navbar`.
+// Consider renaming or replacing them.
+
+var propTypes = {
+  /**
+   * Marks the NavItem with a matching `eventKey` as active. Has a
+   * higher precedence over `activeHref`.
+   */
+  activeKey: PropTypes.any,
+
+  /**
+   * Marks the child NavItem with a matching `href` prop as active.
+   */
+  activeHref: PropTypes.string,
+
+  /**
+   * NavItems are be positioned vertically.
+   */
+  stacked: PropTypes.bool,
+  justified: all(PropTypes.bool, function (_ref) {
+    var justified = _ref.justified,
+        navbar = _ref.navbar;
+    return justified && navbar ? Error('justified navbar `Nav`s are not supported') : null;
+  }),
+
+  /**
+   * A callback fired when a NavItem is selected.
+   *
+   * ```js
+   * function (
+   *  Any eventKey,
+   *  SyntheticEvent event?
+   * )
+   * ```
+   */
+  onSelect: PropTypes.func,
+
+  /**
+   * ARIA role for the Nav, in the context of a TabContainer, the default will
+   * be set to "tablist", but can be overridden by the Nav when set explicitly.
+   *
+   * When the role is set to "tablist" NavItem focus is managed according to
+   * the ARIA authoring practices for tabs:
+   * https://www.w3.org/TR/2013/WD-wai-aria-practices-20130307/#tabpanel
+   */
+  role: PropTypes.string,
+
+  /**
+   * Apply styling an alignment for use in a Navbar. This prop will be set
+   * automatically when the Nav is used inside a Navbar.
+   */
+  navbar: PropTypes.bool,
+
+  /**
+   * Float the Nav to the right. When `navbar` is `true` the appropriate
+   * contextual classes are added as well.
+   */
+  pullRight: PropTypes.bool,
+
+  /**
+   * Float the Nav to the left. When `navbar` is `true` the appropriate
+   * contextual classes are added as well.
+   */
+  pullLeft: PropTypes.bool
+};
+var defaultProps = {
+  justified: false,
+  pullRight: false,
+  pullLeft: false,
+  stacked: false
+};
+var contextTypes = {
+  $bs_navbar: PropTypes.shape({
+    bsClass: PropTypes.string,
+    onSelect: PropTypes.func
+  }),
+  $bs_tabContainer: PropTypes.shape({
+    activeKey: PropTypes.any,
+    onSelect: PropTypes.func.isRequired,
+    getTabId: PropTypes.func.isRequired,
+    getPaneId: PropTypes.func.isRequired
+  })
+};
+
+var Nav =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Nav, _React$Component);
+
+  function Nav() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Nav.prototype;
+
+  _proto.componentDidUpdate = function componentDidUpdate() {
+    var _this = this;
+
+    if (!this._needsRefocus) {
+      return;
+    }
+
+    this._needsRefocus = false;
+    var children = this.props.children;
+
+    var _this$getActiveProps = this.getActiveProps(),
+        activeKey = _this$getActiveProps.activeKey,
+        activeHref = _this$getActiveProps.activeHref;
+
+    var activeChild = ValidComponentChildren.find(children, function (child) {
+      return _this.isActive(child, activeKey, activeHref);
+    });
+    var childrenArray = ValidComponentChildren.toArray(children);
+    var activeChildIndex = childrenArray.indexOf(activeChild);
+    var childNodes = ReactDOM.findDOMNode(this).children;
+    var activeNode = childNodes && childNodes[activeChildIndex];
+
+    if (!activeNode || !activeNode.firstChild) {
+      return;
+    }
+
+    activeNode.firstChild.focus();
+  };
+
+  _proto.getActiveProps = function getActiveProps() {
+    var tabContainer = this.context.$bs_tabContainer;
+
+    if (tabContainer) {
+      process.env.NODE_ENV !== "production" ? warning(this.props.activeKey == null && !this.props.activeHref, 'Specifying a `<Nav>` `activeKey` or `activeHref` in the context of ' + 'a `<TabContainer>` is not supported. Instead use `<TabContainer ' + ("activeKey={" + this.props.activeKey + "} />`.")) : void 0;
+      return tabContainer;
+    }
+
+    return this.props;
+  };
+
+  _proto.getNextActiveChild = function getNextActiveChild(offset) {
+    var _this2 = this;
+
+    var children = this.props.children;
+    var validChildren = children.filter(function (child) {
+      return child.props.eventKey != null && !child.props.disabled;
+    });
+
+    var _this$getActiveProps2 = this.getActiveProps(),
+        activeKey = _this$getActiveProps2.activeKey,
+        activeHref = _this$getActiveProps2.activeHref;
+
+    var activeChild = ValidComponentChildren.find(children, function (child) {
+      return _this2.isActive(child, activeKey, activeHref);
+    }); // This assumes the active child is not disabled.
+
+    var activeChildIndex = validChildren.indexOf(activeChild);
+
+    if (activeChildIndex === -1) {
+      // Something has gone wrong. Select the first valid child we can find.
+      return validChildren[0];
+    }
+
+    var nextIndex = activeChildIndex + offset;
+    var numValidChildren = validChildren.length;
+
+    if (nextIndex >= numValidChildren) {
+      nextIndex = 0;
+    } else if (nextIndex < 0) {
+      nextIndex = numValidChildren - 1;
+    }
+
+    return validChildren[nextIndex];
+  };
+
+  _proto.getTabProps = function getTabProps(child, tabContainer, navRole, active, onSelect) {
+    var _this3 = this;
+
+    if (!tabContainer && navRole !== 'tablist') {
+      // No tab props here.
+      return null;
+    }
+
+    var _child$props = child.props,
+        id = _child$props.id,
+        controls = _child$props['aria-controls'],
+        eventKey = _child$props.eventKey,
+        role = _child$props.role,
+        onKeyDown = _child$props.onKeyDown,
+        tabIndex = _child$props.tabIndex;
+
+    if (tabContainer) {
+      process.env.NODE_ENV !== "production" ? warning(!id && !controls, 'In the context of a `<TabContainer>`, `<NavItem>`s are given ' + 'generated `id` and `aria-controls` attributes for the sake of ' + 'proper component accessibility. Any provided ones will be ignored. ' + 'To control these attributes directly, provide a `generateChildId` ' + 'prop to the parent `<TabContainer>`.') : void 0;
+      id = tabContainer.getTabId(eventKey);
+      controls = tabContainer.getPaneId(eventKey);
+    }
+
+    if (navRole === 'tablist') {
+      role = role || 'tab';
+      onKeyDown = createChainedFunction(function (event) {
+        return _this3.handleTabKeyDown(onSelect, event);
+      }, onKeyDown);
+      tabIndex = active ? tabIndex : -1;
+    }
+
+    return {
+      id: id,
+      role: role,
+      onKeyDown: onKeyDown,
+      'aria-controls': controls,
+      tabIndex: tabIndex
+    };
+  };
+
+  _proto.handleTabKeyDown = function handleTabKeyDown(onSelect, event) {
+    var nextActiveChild;
+
+    switch (event.keyCode) {
+      case keycode.codes.left:
+      case keycode.codes.up:
+        nextActiveChild = this.getNextActiveChild(-1);
+        break;
+
+      case keycode.codes.right:
+      case keycode.codes.down:
+        nextActiveChild = this.getNextActiveChild(1);
+        break;
+
+      default:
+        // It was a different key; don't handle this keypress.
+        return;
+    }
+
+    event.preventDefault();
+
+    if (onSelect && nextActiveChild && nextActiveChild.props.eventKey != null) {
+      onSelect(nextActiveChild.props.eventKey);
+    }
+
+    this._needsRefocus = true;
+  };
+
+  _proto.isActive = function isActive(_ref2, activeKey, activeHref) {
+    var props = _ref2.props;
+
+    if (props.active || activeKey != null && props.eventKey === activeKey || activeHref && props.href === activeHref) {
+      return true;
+    }
+
+    return props.active;
+  };
+
+  _proto.render = function render() {
+    var _extends2,
+        _this4 = this;
+
+    var _this$props = this.props,
+        stacked = _this$props.stacked,
+        justified = _this$props.justified,
+        onSelect = _this$props.onSelect,
+        propsRole = _this$props.role,
+        propsNavbar = _this$props.navbar,
+        pullRight = _this$props.pullRight,
+        pullLeft = _this$props.pullLeft,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["stacked", "justified", "onSelect", "role", "navbar", "pullRight", "pullLeft", "className", "children"]);
+
+    var tabContainer = this.context.$bs_tabContainer;
+    var role = propsRole || (tabContainer ? 'tablist' : null);
+
+    var _this$getActiveProps3 = this.getActiveProps(),
+        activeKey = _this$getActiveProps3.activeKey,
+        activeHref = _this$getActiveProps3.activeHref;
+
+    delete props.activeKey; // Accessed via this.getActiveProps().
+
+    delete props.activeHref; // Accessed via this.getActiveProps().
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[prefix(bsProps, 'stacked')] = stacked, _extends2[prefix(bsProps, 'justified')] = justified, _extends2));
+
+    var navbar = propsNavbar != null ? propsNavbar : this.context.$bs_navbar;
+    var pullLeftClassName;
+    var pullRightClassName;
+
+    if (navbar) {
+      var navbarProps = this.context.$bs_navbar || {
+        bsClass: 'navbar'
+      };
+      classes[prefix(navbarProps, 'nav')] = true;
+      pullRightClassName = prefix(navbarProps, 'right');
+      pullLeftClassName = prefix(navbarProps, 'left');
+    } else {
+      pullRightClassName = 'pull-right';
+      pullLeftClassName = 'pull-left';
+    }
+
+    classes[pullRightClassName] = pullRight;
+    classes[pullLeftClassName] = pullLeft;
+    return React.createElement("ul", _extends({}, elementProps, {
+      role: role,
+      className: classNames(className, classes)
+    }), ValidComponentChildren.map(children, function (child) {
+      var active = _this4.isActive(child, activeKey, activeHref);
+
+      var childOnSelect = createChainedFunction(child.props.onSelect, onSelect, navbar && navbar.onSelect, tabContainer && tabContainer.onSelect);
+      return cloneElement(child, _extends({}, _this4.getTabProps(child, tabContainer, role, active, childOnSelect), {
+        active: active,
+        activeKey: activeKey,
+        activeHref: activeHref,
+        onSelect: childOnSelect
+      }));
+    }));
+  };
+
+  return Nav;
+}(React.Component);
+
+Nav.propTypes = propTypes;
+Nav.defaultProps = defaultProps;
+Nav.contextTypes = contextTypes;
+export default bsClass('nav', bsStyles(['tabs', 'pills'], Nav));

node_modules/react-bootstrap/es/NavDropdown.js

@@ -0,0 +1,97 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import Dropdown from './Dropdown';
+import splitComponentProps from './utils/splitComponentProps';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+
+var propTypes = _extends({}, Dropdown.propTypes, {
+  // Toggle props.
+  title: PropTypes.node.isRequired,
+  noCaret: PropTypes.bool,
+  active: PropTypes.bool,
+  activeKey: PropTypes.any,
+  activeHref: PropTypes.string,
+  // Override generated docs from <Dropdown>.
+
+  /**
+   * @private
+   */
+  children: PropTypes.node
+});
+
+var NavDropdown =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(NavDropdown, _React$Component);
+
+  function NavDropdown() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = NavDropdown.prototype;
+
+  _proto.isActive = function isActive(_ref, activeKey, activeHref) {
+    var _this = this;
+
+    var props = _ref.props;
+
+    if (props.active || activeKey != null && props.eventKey === activeKey || activeHref && props.href === activeHref) {
+      return true;
+    }
+
+    if (ValidComponentChildren.some(props.children, function (child) {
+      return _this.isActive(child, activeKey, activeHref);
+    })) {
+      return true;
+    }
+
+    return props.active;
+  };
+
+  _proto.render = function render() {
+    var _this2 = this;
+
+    var _this$props = this.props,
+        title = _this$props.title,
+        activeKey = _this$props.activeKey,
+        activeHref = _this$props.activeHref,
+        className = _this$props.className,
+        style = _this$props.style,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["title", "activeKey", "activeHref", "className", "style", "children"]);
+
+    var active = this.isActive(this, activeKey, activeHref);
+    delete props.active; // Accessed via this.isActive().
+
+    delete props.eventKey; // Accessed via this.isActive().
+
+    var _splitComponentProps = splitComponentProps(props, Dropdown.ControlledComponent),
+        dropdownProps = _splitComponentProps[0],
+        toggleProps = _splitComponentProps[1]; // Unlike for the other dropdowns, styling needs to go to the `<Dropdown>`
+    // rather than the `<Dropdown.Toggle>`.
+
+
+    return React.createElement(Dropdown, _extends({}, dropdownProps, {
+      componentClass: "li",
+      className: classNames(className, {
+        active: active
+      }),
+      style: style
+    }), React.createElement(Dropdown.Toggle, _extends({}, toggleProps, {
+      useAnchor: true
+    }), title), React.createElement(Dropdown.Menu, null, ValidComponentChildren.map(children, function (child) {
+      return React.cloneElement(child, {
+        active: _this2.isActive(child, activeKey, activeHref)
+      });
+    })));
+  };
+
+  return NavDropdown;
+}(React.Component);
+
+NavDropdown.propTypes = propTypes;
+export default NavDropdown;

node_modules/react-bootstrap/es/NavItem.js

@@ -0,0 +1,91 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import SafeAnchor from './SafeAnchor';
+import createChainedFunction from './utils/createChainedFunction';
+var propTypes = {
+  active: PropTypes.bool,
+  disabled: PropTypes.bool,
+  role: PropTypes.string,
+  href: PropTypes.string,
+  onClick: PropTypes.func,
+  onSelect: PropTypes.func,
+  eventKey: PropTypes.any
+};
+var defaultProps = {
+  active: false,
+  disabled: false
+};
+
+var NavItem =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(NavItem, _React$Component);
+
+  function NavItem(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleClick = _this.handleClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = NavItem.prototype;
+
+  _proto.handleClick = function handleClick(e) {
+    if (this.props.disabled) {
+      e.preventDefault();
+      return;
+    }
+
+    if (this.props.onSelect) {
+      this.props.onSelect(this.props.eventKey, e);
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        active = _this$props.active,
+        disabled = _this$props.disabled,
+        onClick = _this$props.onClick,
+        className = _this$props.className,
+        style = _this$props.style,
+        props = _objectWithoutPropertiesLoose(_this$props, ["active", "disabled", "onClick", "className", "style"]);
+
+    delete props.onSelect;
+    delete props.eventKey; // These are injected down by `<Nav>` for building `<SubNav>`s.
+
+    delete props.activeKey;
+    delete props.activeHref;
+
+    if (!props.role) {
+      if (props.href === '#') {
+        props.role = 'button';
+      }
+    } else if (props.role === 'tab') {
+      props['aria-selected'] = active;
+    }
+
+    return React.createElement("li", {
+      role: "presentation",
+      className: classNames(className, {
+        active: active,
+        disabled: disabled
+      }),
+      style: style
+    }, React.createElement(SafeAnchor, _extends({}, props, {
+      disabled: disabled,
+      onClick: createChainedFunction(onClick, this.handleClick)
+    })));
+  };
+
+  return NavItem;
+}(React.Component);
+
+NavItem.propTypes = propTypes;
+NavItem.defaultProps = defaultProps;
+export default NavItem;

node_modules/react-bootstrap/es/Navbar.js

@@ -0,0 +1,264 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+// TODO: Remove this pragma once we upgrade eslint-config-airbnb.
+
+/* eslint-disable react/no-multi-comp */
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import uncontrollable from 'uncontrollable';
+import Grid from './Grid';
+import NavbarBrand from './NavbarBrand';
+import NavbarCollapse from './NavbarCollapse';
+import NavbarHeader from './NavbarHeader';
+import NavbarToggle from './NavbarToggle';
+import { bsClass as setBsClass, bsStyles, getClassSet, prefix, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+import { Style } from './utils/StyleConfig';
+import createChainedFunction from './utils/createChainedFunction';
+var propTypes = {
+  /**
+   * Create a fixed navbar along the top of the screen, that scrolls with the
+   * page
+   */
+  fixedTop: PropTypes.bool,
+
+  /**
+   * Create a fixed navbar along the bottom of the screen, that scrolls with
+   * the page
+   */
+  fixedBottom: PropTypes.bool,
+
+  /**
+   * Create a full-width navbar that scrolls away with the page
+   */
+  staticTop: PropTypes.bool,
+
+  /**
+   * An alternative dark visual style for the Navbar
+   */
+  inverse: PropTypes.bool,
+
+  /**
+   * Allow the Navbar to fluidly adjust to the page or container width, instead
+   * of at the predefined screen breakpoints
+   */
+  fluid: PropTypes.bool,
+
+  /**
+   * Set a custom element for this component.
+   */
+  componentClass: elementType,
+
+  /**
+   * A callback fired when the `<Navbar>` body collapses or expands. Fired when
+   * a `<Navbar.Toggle>` is clicked and called with the new `expanded`
+   * boolean value.
+   *
+   * @controllable expanded
+   */
+  onToggle: PropTypes.func,
+
+  /**
+   * A callback fired when a descendant of a child `<Nav>` is selected. Should
+   * be used to execute complex closing or other miscellaneous actions desired
+   * after selecting a descendant of `<Nav>`. Does nothing if no `<Nav>` or `<Nav>`
+   * descendants exist. The callback is called with an eventKey, which is a
+   * prop from the selected `<Nav>` descendant, and an event.
+   *
+   * ```js
+   * function (
+   *  Any eventKey,
+   *  SyntheticEvent event?
+   * )
+   * ```
+   *
+   * For basic closing behavior after all `<Nav>` descendant onSelect events in
+   * mobile viewports, try using collapseOnSelect.
+   *
+   * Note: If you are manually closing the navbar using this `OnSelect` prop,
+   * ensure that you are setting `expanded` to false and not *toggling* between
+   * true and false.
+   */
+  onSelect: PropTypes.func,
+
+  /**
+   * Sets `expanded` to `false` after the onSelect event of a descendant of a
+   * child `<Nav>`. Does nothing if no `<Nav>` or `<Nav>` descendants exist.
+   *
+   * The onSelect callback should be used instead for more complex operations
+   * that need to be executed after the `select` event of `<Nav>` descendants.
+   */
+  collapseOnSelect: PropTypes.bool,
+
+  /**
+   * Explicitly set the visiblity of the navbar body
+   *
+   * @controllable onToggle
+   */
+  expanded: PropTypes.bool,
+  role: PropTypes.string
+};
+var defaultProps = {
+  componentClass: 'nav',
+  fixedTop: false,
+  fixedBottom: false,
+  staticTop: false,
+  inverse: false,
+  fluid: false,
+  collapseOnSelect: false
+};
+var childContextTypes = {
+  $bs_navbar: PropTypes.shape({
+    bsClass: PropTypes.string,
+    expanded: PropTypes.bool,
+    onToggle: PropTypes.func.isRequired,
+    onSelect: PropTypes.func
+  })
+};
+
+var Navbar =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Navbar, _React$Component);
+
+  function Navbar(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleToggle = _this.handleToggle.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleCollapse = _this.handleCollapse.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = Navbar.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    var _this$props = this.props,
+        bsClass = _this$props.bsClass,
+        expanded = _this$props.expanded,
+        onSelect = _this$props.onSelect,
+        collapseOnSelect = _this$props.collapseOnSelect;
+    return {
+      $bs_navbar: {
+        bsClass: bsClass,
+        expanded: expanded,
+        onToggle: this.handleToggle,
+        onSelect: createChainedFunction(onSelect, collapseOnSelect ? this.handleCollapse : null)
+      }
+    };
+  };
+
+  _proto.handleCollapse = function handleCollapse() {
+    var _this$props2 = this.props,
+        onToggle = _this$props2.onToggle,
+        expanded = _this$props2.expanded;
+
+    if (expanded) {
+      onToggle(false);
+    }
+  };
+
+  _proto.handleToggle = function handleToggle() {
+    var _this$props3 = this.props,
+        onToggle = _this$props3.onToggle,
+        expanded = _this$props3.expanded;
+    onToggle(!expanded);
+  };
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props4 = this.props,
+        Component = _this$props4.componentClass,
+        fixedTop = _this$props4.fixedTop,
+        fixedBottom = _this$props4.fixedBottom,
+        staticTop = _this$props4.staticTop,
+        inverse = _this$props4.inverse,
+        fluid = _this$props4.fluid,
+        className = _this$props4.className,
+        children = _this$props4.children,
+        props = _objectWithoutPropertiesLoose(_this$props4, ["componentClass", "fixedTop", "fixedBottom", "staticTop", "inverse", "fluid", "className", "children"]);
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(props, ['expanded', 'onToggle', 'onSelect', 'collapseOnSelect']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1]; // will result in some false positives but that seems better
+    // than false negatives. strict `undefined` check allows explicit
+    // "nulling" of the role if the user really doesn't want one
+
+
+    if (elementProps.role === undefined && Component !== 'nav') {
+      elementProps.role = 'navigation';
+    }
+
+    if (inverse) {
+      bsProps.bsStyle = Style.INVERSE;
+    }
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[prefix(bsProps, 'fixed-top')] = fixedTop, _extends2[prefix(bsProps, 'fixed-bottom')] = fixedBottom, _extends2[prefix(bsProps, 'static-top')] = staticTop, _extends2));
+
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), React.createElement(Grid, {
+      fluid: fluid
+    }, children));
+  };
+
+  return Navbar;
+}(React.Component);
+
+Navbar.propTypes = propTypes;
+Navbar.defaultProps = defaultProps;
+Navbar.childContextTypes = childContextTypes;
+setBsClass('navbar', Navbar);
+var UncontrollableNavbar = uncontrollable(Navbar, {
+  expanded: 'onToggle'
+});
+
+function createSimpleWrapper(tag, suffix, displayName) {
+  var Wrapper = function Wrapper(_ref, _ref2) {
+    var Component = _ref.componentClass,
+        className = _ref.className,
+        pullRight = _ref.pullRight,
+        pullLeft = _ref.pullLeft,
+        props = _objectWithoutPropertiesLoose(_ref, ["componentClass", "className", "pullRight", "pullLeft"]);
+
+    var _ref2$$bs_navbar = _ref2.$bs_navbar,
+        navbarProps = _ref2$$bs_navbar === void 0 ? {
+      bsClass: 'navbar'
+    } : _ref2$$bs_navbar;
+    return React.createElement(Component, _extends({}, props, {
+      className: classNames(className, prefix(navbarProps, suffix), pullRight && prefix(navbarProps, 'right'), pullLeft && prefix(navbarProps, 'left'))
+    }));
+  };
+
+  Wrapper.displayName = displayName;
+  Wrapper.propTypes = {
+    componentClass: elementType,
+    pullRight: PropTypes.bool,
+    pullLeft: PropTypes.bool
+  };
+  Wrapper.defaultProps = {
+    componentClass: tag,
+    pullRight: false,
+    pullLeft: false
+  };
+  Wrapper.contextTypes = {
+    $bs_navbar: PropTypes.shape({
+      bsClass: PropTypes.string
+    })
+  };
+  return Wrapper;
+}
+
+UncontrollableNavbar.Brand = NavbarBrand;
+UncontrollableNavbar.Header = NavbarHeader;
+UncontrollableNavbar.Toggle = NavbarToggle;
+UncontrollableNavbar.Collapse = NavbarCollapse;
+UncontrollableNavbar.Form = createSimpleWrapper('div', 'form', 'NavbarForm');
+UncontrollableNavbar.Text = createSimpleWrapper('p', 'text', 'NavbarText');
+UncontrollableNavbar.Link = createSimpleWrapper('a', 'link', 'NavbarLink'); // Set bsStyles here so they can be overridden.
+
+export default bsStyles([Style.DEFAULT, Style.INVERSE], Style.DEFAULT, UncontrollableNavbar);

node_modules/react-bootstrap/es/NavbarBrand.js

@@ -0,0 +1,51 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { prefix } from './utils/bootstrapUtils';
+var contextTypes = {
+  $bs_navbar: PropTypes.shape({
+    bsClass: PropTypes.string
+  })
+};
+
+var NavbarBrand =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(NavbarBrand, _React$Component);
+
+  function NavbarBrand() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = NavbarBrand.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className", "children"]);
+
+    var navbarProps = this.context.$bs_navbar || {
+      bsClass: 'navbar'
+    };
+    var bsClassName = prefix(navbarProps, 'brand');
+
+    if (React.isValidElement(children)) {
+      return React.cloneElement(children, {
+        className: classNames(children.props.className, className, bsClassName)
+      });
+    }
+
+    return React.createElement("span", _extends({}, props, {
+      className: classNames(className, bsClassName)
+    }), children);
+  };
+
+  return NavbarBrand;
+}(React.Component);
+
+NavbarBrand.contextTypes = contextTypes;
+export default NavbarBrand;

node_modules/react-bootstrap/es/NavbarCollapse.js

@@ -0,0 +1,46 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import Collapse from './Collapse';
+import { prefix } from './utils/bootstrapUtils';
+var contextTypes = {
+  $bs_navbar: PropTypes.shape({
+    bsClass: PropTypes.string,
+    expanded: PropTypes.bool
+  })
+};
+
+var NavbarCollapse =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(NavbarCollapse, _React$Component);
+
+  function NavbarCollapse() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = NavbarCollapse.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["children"]);
+
+    var navbarProps = this.context.$bs_navbar || {
+      bsClass: 'navbar'
+    };
+    var bsClassName = prefix(navbarProps, 'collapse');
+    return React.createElement(Collapse, _extends({
+      in: navbarProps.expanded
+    }, props), React.createElement("div", {
+      className: bsClassName
+    }, children));
+  };
+
+  return NavbarCollapse;
+}(React.Component);
+
+NavbarCollapse.contextTypes = contextTypes;
+export default NavbarCollapse;

node_modules/react-bootstrap/es/NavbarHeader.js

@@ -0,0 +1,43 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { prefix } from './utils/bootstrapUtils';
+var contextTypes = {
+  $bs_navbar: PropTypes.shape({
+    bsClass: PropTypes.string
+  })
+};
+
+var NavbarHeader =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(NavbarHeader, _React$Component);
+
+  function NavbarHeader() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = NavbarHeader.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var navbarProps = this.context.$bs_navbar || {
+      bsClass: 'navbar'
+    };
+    var bsClassName = prefix(navbarProps, 'header');
+    return React.createElement("div", _extends({}, props, {
+      className: classNames(className, bsClassName)
+    }));
+  };
+
+  return NavbarHeader;
+}(React.Component);
+
+NavbarHeader.contextTypes = contextTypes;
+export default NavbarHeader;

node_modules/react-bootstrap/es/NavbarToggle.js

@@ -0,0 +1,74 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { prefix } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+var propTypes = {
+  onClick: PropTypes.func,
+
+  /**
+   * The toggle content, if left empty it will render the default toggle (seen above).
+   */
+  children: PropTypes.node
+};
+var contextTypes = {
+  $bs_navbar: PropTypes.shape({
+    bsClass: PropTypes.string,
+    expanded: PropTypes.bool,
+    onToggle: PropTypes.func.isRequired
+  })
+};
+
+var NavbarToggle =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(NavbarToggle, _React$Component);
+
+  function NavbarToggle() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = NavbarToggle.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        onClick = _this$props.onClick,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["onClick", "className", "children"]);
+
+    var navbarProps = this.context.$bs_navbar || {
+      bsClass: 'navbar'
+    };
+
+    var buttonProps = _extends({
+      type: 'button'
+    }, props, {
+      onClick: createChainedFunction(onClick, navbarProps.onToggle),
+      className: classNames(className, prefix(navbarProps, 'toggle'), !navbarProps.expanded && 'collapsed')
+    });
+
+    if (children) {
+      return React.createElement("button", buttonProps, children);
+    }
+
+    return React.createElement("button", buttonProps, React.createElement("span", {
+      className: "sr-only"
+    }, "Toggle navigation"), React.createElement("span", {
+      className: "icon-bar"
+    }), React.createElement("span", {
+      className: "icon-bar"
+    }), React.createElement("span", {
+      className: "icon-bar"
+    }));
+  };
+
+  return NavbarToggle;
+}(React.Component);
+
+NavbarToggle.propTypes = propTypes;
+NavbarToggle.contextTypes = contextTypes;
+export default NavbarToggle;

node_modules/react-bootstrap/es/Overlay.js

@@ -0,0 +1,114 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import classNames from 'classnames';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import BaseOverlay from 'react-overlays/lib/Overlay';
+import elementType from 'prop-types-extra/lib/elementType';
+import Fade from './Fade';
+
+var propTypes = _extends({}, BaseOverlay.propTypes, {
+  /**
+   * Set the visibility of the Overlay
+   */
+  show: PropTypes.bool,
+
+  /**
+   * Specify whether the overlay should trigger onHide when the user clicks outside the overlay
+   */
+  rootClose: PropTypes.bool,
+
+  /**
+   * A callback invoked by the overlay when it wishes to be hidden. Required if
+   * `rootClose` is specified.
+   */
+  onHide: PropTypes.func,
+
+  /**
+   * Use animation
+   */
+  animation: PropTypes.oneOfType([PropTypes.bool, elementType]),
+
+  /**
+   * Callback fired before the Overlay transitions in
+   */
+  onEnter: PropTypes.func,
+
+  /**
+   * Callback fired as the Overlay begins to transition in
+   */
+  onEntering: PropTypes.func,
+
+  /**
+   * Callback fired after the Overlay finishes transitioning in
+   */
+  onEntered: PropTypes.func,
+
+  /**
+   * Callback fired right before the Overlay transitions out
+   */
+  onExit: PropTypes.func,
+
+  /**
+   * Callback fired as the Overlay begins to transition out
+   */
+  onExiting: PropTypes.func,
+
+  /**
+   * Callback fired after the Overlay finishes transitioning out
+   */
+  onExited: PropTypes.func,
+
+  /**
+   * Sets the direction of the Overlay.
+   */
+  placement: PropTypes.oneOf(['top', 'right', 'bottom', 'left'])
+});
+
+var defaultProps = {
+  animation: Fade,
+  rootClose: false,
+  show: false,
+  placement: 'right'
+};
+
+var Overlay =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Overlay, _React$Component);
+
+  function Overlay() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Overlay.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        animation = _this$props.animation,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["animation", "children"]);
+
+    var transition = animation === true ? Fade : animation || null;
+    var child;
+
+    if (!transition) {
+      child = cloneElement(children, {
+        className: classNames(children.props.className, 'in')
+      });
+    } else {
+      child = children;
+    }
+
+    return React.createElement(BaseOverlay, _extends({}, props, {
+      transition: transition
+    }), child);
+  };
+
+  return Overlay;
+}(React.Component);
+
+Overlay.propTypes = propTypes;
+Overlay.defaultProps = defaultProps;
+export default Overlay;

node_modules/react-bootstrap/es/OverlayTrigger.js

@@ -0,0 +1,313 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _Array$isArray from "@babel/runtime-corejs2/core-js/array/is-array";
+import contains from 'dom-helpers/query/contains';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import warning from 'warning';
+import Overlay from './Overlay';
+import createChainedFunction from './utils/createChainedFunction';
+/**
+ * Check if value one is inside or equal to the of value
+ *
+ * @param {string} one
+ * @param {string|array} of
+ * @returns {boolean}
+ */
+
+function isOneOf(one, of) {
+  if (_Array$isArray(of)) {
+    return of.indexOf(one) >= 0;
+  }
+
+  return one === of;
+}
+
+var triggerType = PropTypes.oneOf(['click', 'hover', 'focus']);
+
+var propTypes = _extends({}, Overlay.propTypes, {
+  /**
+   * Specify which action or actions trigger Overlay visibility
+   */
+  trigger: PropTypes.oneOfType([triggerType, PropTypes.arrayOf(triggerType)]),
+
+  /**
+   * A millisecond delay amount to show and hide the Overlay once triggered
+   */
+  delay: PropTypes.number,
+
+  /**
+   * A millisecond delay amount before showing the Overlay once triggered.
+   */
+  delayShow: PropTypes.number,
+
+  /**
+   * A millisecond delay amount before hiding the Overlay once triggered.
+   */
+  delayHide: PropTypes.number,
+  // FIXME: This should be `defaultShow`.
+
+  /**
+   * The initial visibility state of the Overlay. For more nuanced visibility
+   * control, consider using the Overlay component directly.
+   */
+  defaultOverlayShown: PropTypes.bool,
+
+  /**
+   * An element or text to overlay next to the target.
+   */
+  overlay: PropTypes.node.isRequired,
+
+  /**
+   * @private
+   */
+  onBlur: PropTypes.func,
+
+  /**
+   * @private
+   */
+  onClick: PropTypes.func,
+
+  /**
+   * @private
+   */
+  onFocus: PropTypes.func,
+
+  /**
+   * @private
+   */
+  onMouseOut: PropTypes.func,
+
+  /**
+   * @private
+   */
+  onMouseOver: PropTypes.func,
+  // Overridden props from `<Overlay>`.
+
+  /**
+   * @private
+   */
+  target: PropTypes.oneOf([null]),
+
+  /**
+   * @private
+   */
+  onHide: PropTypes.oneOf([null]),
+
+  /**
+   * @private
+   */
+  show: PropTypes.oneOf([null])
+});
+
+var defaultProps = {
+  defaultOverlayShown: false,
+  trigger: ['hover', 'focus']
+};
+
+var OverlayTrigger =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(OverlayTrigger, _React$Component);
+
+  function OverlayTrigger(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleToggle = _this.handleToggle.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleDelayedShow = _this.handleDelayedShow.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleDelayedHide = _this.handleDelayedHide.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleHide = _this.handleHide.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+
+    _this.handleMouseOver = function (e) {
+      return _this.handleMouseOverOut(_this.handleDelayedShow, e, 'fromElement');
+    };
+
+    _this.handleMouseOut = function (e) {
+      return _this.handleMouseOverOut(_this.handleDelayedHide, e, 'toElement');
+    };
+
+    _this._mountNode = null;
+    _this.state = {
+      show: props.defaultOverlayShown
+    };
+    return _this;
+  }
+
+  var _proto = OverlayTrigger.prototype;
+
+  _proto.componentDidMount = function componentDidMount() {
+    this._mountNode = document.createElement('div');
+    this.renderOverlay();
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate() {
+    this.renderOverlay();
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    ReactDOM.unmountComponentAtNode(this._mountNode);
+    this._mountNode = null;
+    clearTimeout(this._hoverShowDelay);
+    clearTimeout(this._hoverHideDelay);
+  };
+
+  _proto.handleDelayedHide = function handleDelayedHide() {
+    var _this2 = this;
+
+    if (this._hoverShowDelay != null) {
+      clearTimeout(this._hoverShowDelay);
+      this._hoverShowDelay = null;
+      return;
+    }
+
+    if (!this.state.show || this._hoverHideDelay != null) {
+      return;
+    }
+
+    var delay = this.props.delayHide != null ? this.props.delayHide : this.props.delay;
+
+    if (!delay) {
+      this.hide();
+      return;
+    }
+
+    this._hoverHideDelay = setTimeout(function () {
+      _this2._hoverHideDelay = null;
+
+      _this2.hide();
+    }, delay);
+  };
+
+  _proto.handleDelayedShow = function handleDelayedShow() {
+    var _this3 = this;
+
+    if (this._hoverHideDelay != null) {
+      clearTimeout(this._hoverHideDelay);
+      this._hoverHideDelay = null;
+      return;
+    }
+
+    if (this.state.show || this._hoverShowDelay != null) {
+      return;
+    }
+
+    var delay = this.props.delayShow != null ? this.props.delayShow : this.props.delay;
+
+    if (!delay) {
+      this.show();
+      return;
+    }
+
+    this._hoverShowDelay = setTimeout(function () {
+      _this3._hoverShowDelay = null;
+
+      _this3.show();
+    }, delay);
+  };
+
+  _proto.handleHide = function handleHide() {
+    this.hide();
+  }; // Simple implementation of mouseEnter and mouseLeave.
+  // React's built version is broken: https://github.com/facebook/react/issues/4251
+  // for cases when the trigger is disabled and mouseOut/Over can cause flicker
+  // moving from one child element to another.
+
+
+  _proto.handleMouseOverOut = function handleMouseOverOut(handler, e, relatedNative) {
+    var target = e.currentTarget;
+    var related = e.relatedTarget || e.nativeEvent[relatedNative];
+
+    if ((!related || related !== target) && !contains(target, related)) {
+      handler(e);
+    }
+  };
+
+  _proto.handleToggle = function handleToggle() {
+    if (this.state.show) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  };
+
+  _proto.hide = function hide() {
+    this.setState({
+      show: false
+    });
+  };
+
+  _proto.makeOverlay = function makeOverlay(overlay, props) {
+    return React.createElement(Overlay, _extends({}, props, {
+      show: this.state.show,
+      onHide: this.handleHide,
+      target: this
+    }), overlay);
+  };
+
+  _proto.show = function show() {
+    this.setState({
+      show: true
+    });
+  };
+
+  _proto.renderOverlay = function renderOverlay() {
+    ReactDOM.unstable_renderSubtreeIntoContainer(this, this._overlay, this._mountNode);
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        trigger = _this$props.trigger,
+        overlay = _this$props.overlay,
+        children = _this$props.children,
+        onBlur = _this$props.onBlur,
+        onClick = _this$props.onClick,
+        onFocus = _this$props.onFocus,
+        onMouseOut = _this$props.onMouseOut,
+        onMouseOver = _this$props.onMouseOver,
+        props = _objectWithoutPropertiesLoose(_this$props, ["trigger", "overlay", "children", "onBlur", "onClick", "onFocus", "onMouseOut", "onMouseOver"]);
+
+    delete props.delay;
+    delete props.delayShow;
+    delete props.delayHide;
+    delete props.defaultOverlayShown;
+    var child = React.Children.only(children);
+    var childProps = child.props;
+    var triggerProps = {};
+
+    if (this.state.show) {
+      triggerProps['aria-describedby'] = overlay.props.id;
+    } // FIXME: The logic here for passing through handlers on this component is
+    // inconsistent. We shouldn't be passing any of these props through.
+
+
+    triggerProps.onClick = createChainedFunction(childProps.onClick, onClick);
+
+    if (isOneOf('click', trigger)) {
+      triggerProps.onClick = createChainedFunction(triggerProps.onClick, this.handleToggle);
+    }
+
+    if (isOneOf('hover', trigger)) {
+      process.env.NODE_ENV !== "production" ? warning(!(trigger === 'hover'), '[react-bootstrap] Specifying only the `"hover"` trigger limits the ' + 'visibility of the overlay to just mouse users. Consider also ' + 'including the `"focus"` trigger so that touch and keyboard only ' + 'users can see the overlay as well.') : void 0;
+      triggerProps.onMouseOver = createChainedFunction(childProps.onMouseOver, onMouseOver, this.handleMouseOver);
+      triggerProps.onMouseOut = createChainedFunction(childProps.onMouseOut, onMouseOut, this.handleMouseOut);
+    }
+
+    if (isOneOf('focus', trigger)) {
+      triggerProps.onFocus = createChainedFunction(childProps.onFocus, onFocus, this.handleDelayedShow);
+      triggerProps.onBlur = createChainedFunction(childProps.onBlur, onBlur, this.handleDelayedHide);
+    }
+
+    this._overlay = this.makeOverlay(overlay, props);
+    return cloneElement(child, triggerProps);
+  };
+
+  return OverlayTrigger;
+}(React.Component);
+
+OverlayTrigger.propTypes = propTypes;
+OverlayTrigger.defaultProps = defaultProps;
+export default OverlayTrigger;

node_modules/react-bootstrap/es/PageHeader.js

@@ -0,0 +1,38 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var PageHeader =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PageHeader, _React$Component);
+
+  function PageHeader() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = PageHeader.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), React.createElement("h1", null, children));
+  };
+
+  return PageHeader;
+}(React.Component);
+
+export default bsClass('page-header', PageHeader);

node_modules/react-bootstrap/es/PageItem.js

@@ -0,0 +1,3 @@
+import PagerItem from './PagerItem';
+import deprecationWarning from './utils/deprecationWarning';
+export default deprecationWarning.wrapper(PagerItem, '`<PageItem>`', '`<Pager.Item>`');

node_modules/react-bootstrap/es/Pager.js

@@ -0,0 +1,52 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import PagerItem from './PagerItem';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+var propTypes = {
+  onSelect: PropTypes.func
+};
+
+var Pager =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Pager, _React$Component);
+
+  function Pager() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Pager.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        onSelect = _this$props.onSelect,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["onSelect", "className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("ul", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), ValidComponentChildren.map(children, function (child) {
+      return cloneElement(child, {
+        onSelect: createChainedFunction(child.props.onSelect, onSelect)
+      });
+    }));
+  };
+
+  return Pager;
+}(React.Component);
+
+Pager.propTypes = propTypes;
+Pager.Item = PagerItem;
+export default bsClass('pager', Pager);

node_modules/react-bootstrap/es/PagerItem.js

@@ -0,0 +1,85 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import SafeAnchor from './SafeAnchor';
+import createChainedFunction from './utils/createChainedFunction';
+var propTypes = {
+  disabled: PropTypes.bool,
+  previous: PropTypes.bool,
+  next: PropTypes.bool,
+  onClick: PropTypes.func,
+  onSelect: PropTypes.func,
+  eventKey: PropTypes.any
+};
+var defaultProps = {
+  disabled: false,
+  previous: false,
+  next: false
+};
+
+var PagerItem =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PagerItem, _React$Component);
+
+  function PagerItem(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleSelect = _this.handleSelect.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = PagerItem.prototype;
+
+  _proto.handleSelect = function handleSelect(e) {
+    var _this$props = this.props,
+        disabled = _this$props.disabled,
+        onSelect = _this$props.onSelect,
+        eventKey = _this$props.eventKey;
+
+    if (disabled) {
+      e.preventDefault();
+      return;
+    }
+
+    if (onSelect) {
+      onSelect(eventKey, e);
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        disabled = _this$props2.disabled,
+        previous = _this$props2.previous,
+        next = _this$props2.next,
+        onClick = _this$props2.onClick,
+        className = _this$props2.className,
+        style = _this$props2.style,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["disabled", "previous", "next", "onClick", "className", "style"]);
+
+    delete props.onSelect;
+    delete props.eventKey;
+    return React.createElement("li", {
+      className: classNames(className, {
+        disabled: disabled,
+        previous: previous,
+        next: next
+      }),
+      style: style
+    }, React.createElement(SafeAnchor, _extends({}, props, {
+      disabled: disabled,
+      onClick: createChainedFunction(onClick, this.handleSelect)
+    })));
+  };
+
+  return PagerItem;
+}(React.Component);
+
+PagerItem.propTypes = propTypes;
+PagerItem.defaultProps = defaultProps;
+export default PagerItem;

node_modules/react-bootstrap/es/Pagination.js

@@ -0,0 +1,46 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PaginationItem, { First, Prev, Ellipsis, Next, Last } from './PaginationItem';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+
+var Pagination =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Pagination, _React$Component);
+
+  function Pagination() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Pagination.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("ul", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), children);
+  };
+
+  return Pagination;
+}(React.Component);
+
+bsClass('pagination', Pagination);
+Pagination.First = First;
+Pagination.Prev = Prev;
+Pagination.Ellipsis = Ellipsis;
+Pagination.Item = PaginationItem;
+Pagination.Next = Next;
+Pagination.Last = Last;
+export default Pagination;

node_modules/react-bootstrap/es/PaginationItem.js

@@ -0,0 +1,92 @@
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+
+/* eslint-disable react/no-multi-comp */
+import classNames from 'classnames';
+import PropTypes from 'prop-types';
+import React from 'react';
+import SafeAnchor from './SafeAnchor';
+var propTypes = {
+  eventKey: PropTypes.any,
+  className: PropTypes.string,
+  onSelect: PropTypes.func,
+  disabled: PropTypes.bool,
+  active: PropTypes.bool,
+  activeLabel: PropTypes.string.isRequired
+};
+var defaultProps = {
+  active: false,
+  disabled: false,
+  activeLabel: '(current)'
+};
+export default function PaginationItem(_ref) {
+  var active = _ref.active,
+      disabled = _ref.disabled,
+      className = _ref.className,
+      style = _ref.style,
+      activeLabel = _ref.activeLabel,
+      children = _ref.children,
+      props = _objectWithoutPropertiesLoose(_ref, ["active", "disabled", "className", "style", "activeLabel", "children"]);
+
+  var Component = active || disabled ? 'span' : SafeAnchor;
+  return React.createElement("li", {
+    style: style,
+    className: classNames(className, {
+      active: active,
+      disabled: disabled
+    })
+  }, React.createElement(Component, _extends({
+    disabled: disabled
+  }, props), children, active && React.createElement("span", {
+    className: "sr-only"
+  }, activeLabel)));
+}
+PaginationItem.propTypes = propTypes;
+PaginationItem.defaultProps = defaultProps;
+
+function createButton(name, defaultValue, label) {
+  var _class, _temp;
+
+  if (label === void 0) {
+    label = name;
+  }
+
+  return _temp = _class =
+  /*#__PURE__*/
+  function (_React$Component) {
+    _inheritsLoose(_class, _React$Component);
+
+    function _class() {
+      return _React$Component.apply(this, arguments) || this;
+    }
+
+    var _proto = _class.prototype;
+
+    _proto.render = function render() {
+      var _this$props = this.props,
+          disabled = _this$props.disabled,
+          children = _this$props.children,
+          className = _this$props.className,
+          props = _objectWithoutPropertiesLoose(_this$props, ["disabled", "children", "className"]);
+
+      var Component = disabled ? 'span' : SafeAnchor;
+      return React.createElement("li", _extends({
+        "aria-label": label,
+        className: classNames(className, {
+          disabled: disabled
+        })
+      }, props), React.createElement(Component, null, children || defaultValue));
+    };
+
+    return _class;
+  }(React.Component), _class.displayName = name, _class.propTypes = {
+    disabled: PropTypes.bool
+  }, _temp;
+}
+
+export var First = createButton('First', "\xAB");
+export var Prev = createButton('Prev', "\u2039");
+export var Ellipsis = createButton('Ellipsis', "\u2026", 'More');
+export var Next = createButton('Next', "\u203A");
+export var Last = createButton('Last', "\xBB");

node_modules/react-bootstrap/es/Panel.js

@@ -0,0 +1,163 @@
+import _Object$assign from "@babel/runtime-corejs2/core-js/object/assign";
+import _Object$values from "@babel/runtime-corejs2/core-js/object/values";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import PropTypes from 'prop-types';
+import React from 'react';
+import uncontrollable from 'uncontrollable';
+import warning from 'warning';
+import { bsStyles, bsClass, getClassSet, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+import { State, Style } from './utils/StyleConfig';
+import Body from './PanelBody';
+import Heading from './PanelHeading';
+import Title from './PanelTitle';
+import Footer from './PanelFooter';
+import Toggle from './PanelToggle';
+import Collapse from './PanelCollapse';
+var has = Object.prototype.hasOwnProperty;
+
+var defaultGetId = function defaultGetId(id, type) {
+  return id ? id + "--" + type : null;
+};
+
+var propTypes = {
+  /**
+   * Controls the collapsed/expanded state ofthe Panel. Requires
+   * a `Panel.Collapse` or `<Panel.Body collapsible>` child component
+   * in order to actually animate out or in.
+   *
+   * @controllable onToggle
+   */
+  expanded: PropTypes.bool,
+
+  /**
+   * A callback fired when the collapse state changes.
+   *
+   * @controllable expanded
+   */
+  onToggle: PropTypes.func,
+  eventKey: PropTypes.any,
+
+  /**
+   * An HTML `id` attribute uniquely identifying the Panel component.
+   */
+  id: PropTypes.string
+};
+var contextTypes = {
+  $bs_panelGroup: PropTypes.shape({
+    getId: PropTypes.func,
+    activeKey: PropTypes.any,
+    onToggle: PropTypes.func
+  })
+};
+var childContextTypes = {
+  $bs_panel: PropTypes.shape({
+    headingId: PropTypes.string,
+    bodyId: PropTypes.string,
+    bsClass: PropTypes.string,
+    onToggle: PropTypes.func,
+    expanded: PropTypes.bool
+  })
+};
+
+var Panel =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Panel, _React$Component);
+
+  function Panel() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+
+    _this.handleToggle = function (e) {
+      var panelGroup = _this.context.$bs_panelGroup;
+      var expanded = !_this.getExpanded();
+
+      if (panelGroup && panelGroup.onToggle) {
+        panelGroup.onToggle(_this.props.eventKey, expanded, e);
+      } else {
+        _this.props.onToggle(expanded, e);
+      }
+    };
+
+    return _this;
+  }
+
+  var _proto = Panel.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    var _this$props = this.props,
+        eventKey = _this$props.eventKey,
+        id = _this$props.id;
+    var idKey = eventKey == null ? id : eventKey;
+    var ids;
+
+    if (idKey !== null) {
+      var panelGroup = this.context.$bs_panelGroup;
+      var getId = panelGroup && panelGroup.getId || defaultGetId;
+      ids = {
+        headingId: getId(idKey, 'heading'),
+        bodyId: getId(idKey, 'body')
+      };
+    }
+
+    return {
+      $bs_panel: _extends({}, ids, {
+        bsClass: this.props.bsClass,
+        expanded: this.getExpanded(),
+        onToggle: this.handleToggle
+      })
+    };
+  };
+
+  _proto.getExpanded = function getExpanded() {
+    var panelGroup = this.context.$bs_panelGroup;
+
+    if (panelGroup && has.call(panelGroup, 'activeKey')) {
+      process.env.NODE_ENV !== "production" ? warning(this.props.expanded == null, 'Specifying `<Panel>` `expanded` in the context of an accordion ' + '`<PanelGroup>` is not supported. Set `activeKey` on the ' + '`<PanelGroup>` instead.') : void 0;
+      return panelGroup.activeKey === this.props.eventKey;
+    }
+
+    return !!this.props.expanded;
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        className = _this$props2.className,
+        children = _this$props2.children;
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(this.props, ['onToggle', 'eventKey', 'expanded']),
+        bsProps = _splitBsPropsAndOmit[0],
+        props = _splitBsPropsAndOmit[1];
+
+    return React.createElement("div", _extends({}, props, {
+      className: classNames(className, getClassSet(bsProps))
+    }), children);
+  };
+
+  return Panel;
+}(React.Component);
+
+Panel.propTypes = propTypes;
+Panel.contextTypes = contextTypes;
+Panel.childContextTypes = childContextTypes;
+var UncontrolledPanel = uncontrollable(bsClass('panel', bsStyles(_Object$values(State).concat([Style.DEFAULT, Style.PRIMARY]), Style.DEFAULT, Panel)), {
+  expanded: 'onToggle'
+});
+
+_Object$assign(UncontrolledPanel, {
+  Heading: Heading,
+  Title: Title,
+  Body: Body,
+  Footer: Footer,
+  Toggle: Toggle,
+  Collapse: Collapse
+});
+
+export default UncontrolledPanel;

node_modules/react-bootstrap/es/PanelBody.js

@@ -0,0 +1,73 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import PropTypes from 'prop-types';
+import React from 'react';
+import cn from 'classnames';
+import { prefix, splitBsPropsAndOmit, bsClass } from './utils/bootstrapUtils';
+import PanelCollapse from './PanelCollapse';
+var propTypes = {
+  /**
+   * A convenience prop that renders a Collapse component around the Body for
+   * situations when the parent Panel only contains a single Panel.Body child.
+   *
+   * renders:
+   * ```jsx
+   * <Panel.Collapse>
+   *  <Panel.Body />
+   * </Panel.Collapse>
+   * ```
+   */
+  collapsible: PropTypes.bool.isRequired
+};
+var defaultProps = {
+  collapsible: false
+};
+var contextTypes = {
+  $bs_panel: PropTypes.shape({
+    bsClass: PropTypes.string
+  })
+};
+
+var PanelBody =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PanelBody, _React$Component);
+
+  function PanelBody() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = PanelBody.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        collapsible = _this$props.collapsible;
+
+    var _ref = this.context.$bs_panel || {},
+        _bsClass = _ref.bsClass;
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(this.props, ['collapsible']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1];
+
+    bsProps.bsClass = _bsClass || bsProps.bsClass;
+    var body = React.createElement("div", _extends({}, elementProps, {
+      className: cn(className, prefix(bsProps, 'body'))
+    }), children);
+
+    if (collapsible) {
+      body = React.createElement(PanelCollapse, null, body);
+    }
+
+    return body;
+  };
+
+  return PanelBody;
+}(React.Component);
+
+PanelBody.propTypes = propTypes;
+PanelBody.defaultProps = defaultProps;
+PanelBody.contextTypes = contextTypes;
+export default bsClass('panel', PanelBody);

node_modules/react-bootstrap/es/PanelCollapse.js

@@ -0,0 +1,91 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import PropTypes from 'prop-types';
+import React from 'react';
+import { prefix, splitBsProps, bsClass } from './utils/bootstrapUtils';
+import Collapse from './Collapse';
+var propTypes = {
+  /**
+   * Callback fired before the component expands
+   */
+  onEnter: PropTypes.func,
+
+  /**
+   * Callback fired after the component starts to expand
+   */
+  onEntering: PropTypes.func,
+
+  /**
+   * Callback fired after the component has expanded
+   */
+  onEntered: PropTypes.func,
+
+  /**
+   * Callback fired before the component collapses
+   */
+  onExit: PropTypes.func,
+
+  /**
+   * Callback fired after the component starts to collapse
+   */
+  onExiting: PropTypes.func,
+
+  /**
+   * Callback fired after the component has collapsed
+   */
+  onExited: PropTypes.func
+};
+var contextTypes = {
+  $bs_panel: PropTypes.shape({
+    headingId: PropTypes.string,
+    bodyId: PropTypes.string,
+    bsClass: PropTypes.string,
+    expanded: PropTypes.bool
+  })
+};
+
+var PanelCollapse =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PanelCollapse, _React$Component);
+
+  function PanelCollapse() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = PanelCollapse.prototype;
+
+  _proto.render = function render() {
+    var children = this.props.children;
+
+    var _ref = this.context.$bs_panel || {},
+        headingId = _ref.headingId,
+        bodyId = _ref.bodyId,
+        _bsClass = _ref.bsClass,
+        expanded = _ref.expanded;
+
+    var _splitBsProps = splitBsProps(this.props),
+        bsProps = _splitBsProps[0],
+        props = _splitBsProps[1];
+
+    bsProps.bsClass = _bsClass || bsProps.bsClass;
+
+    if (headingId && bodyId) {
+      props.id = bodyId;
+      props.role = props.role || 'tabpanel';
+      props['aria-labelledby'] = headingId;
+    }
+
+    return React.createElement(Collapse, _extends({
+      in: expanded
+    }, props), React.createElement("div", {
+      className: prefix(bsProps, 'collapse')
+    }, children));
+  };
+
+  return PanelCollapse;
+}(React.Component);
+
+PanelCollapse.propTypes = propTypes;
+PanelCollapse.contextTypes = contextTypes;
+export default bsClass('panel', PanelCollapse);

node_modules/react-bootstrap/es/PanelFooter.js

@@ -0,0 +1,46 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import PropTypes from 'prop-types';
+import React from 'react';
+import cn from 'classnames';
+import { prefix, bsClass, splitBsProps } from './utils/bootstrapUtils';
+var contextTypes = {
+  $bs_panel: PropTypes.shape({
+    bsClass: PropTypes.string
+  })
+};
+
+var PanelFooter =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PanelFooter, _React$Component);
+
+  function PanelFooter() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = PanelFooter.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className;
+
+    var _ref = this.context.$bs_panel || {},
+        _bsClass = _ref.bsClass;
+
+    var _splitBsProps = splitBsProps(this.props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    bsProps.bsClass = _bsClass || bsProps.bsClass;
+    return React.createElement("div", _extends({}, elementProps, {
+      className: cn(className, prefix(bsProps, 'footer'))
+    }), children);
+  };
+
+  return PanelFooter;
+}(React.Component);
+
+PanelFooter.contextTypes = contextTypes;
+export default bsClass('panel', PanelFooter);

node_modules/react-bootstrap/es/PanelGroup.js

@@ -0,0 +1,151 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import PropTypes from 'prop-types';
+import React, { cloneElement } from 'react';
+import uncontrollable from 'uncontrollable';
+import { bsClass, getClassSet, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+import { generatedId } from './utils/PropTypes';
+var propTypes = {
+  accordion: PropTypes.bool,
+
+  /**
+   * When `accordion` is enabled, `activeKey` controls the which child `Panel` is expanded. `activeKey` should
+   * match a child Panel `eventKey` prop exactly.
+   *
+   * @controllable onSelect
+   */
+  activeKey: PropTypes.any,
+
+  /**
+   * A callback fired when a child Panel collapse state changes. It's called with the next expanded `activeKey`
+   *
+   * @controllable activeKey
+   */
+  onSelect: PropTypes.func,
+
+  /**
+   * An HTML role attribute
+   */
+  role: PropTypes.string,
+
+  /**
+   * A function that takes an eventKey and type and returns a
+   * unique id for each Panel heading and Panel Collapse. The function _must_ be a pure function,
+   * meaning it should always return the _same_ id for the same set of inputs. The default
+   * value requires that an `id` to be set for the PanelGroup.
+   *
+   * The `type` argument will either be `"body"` or `"heading"`.
+   *
+   * @defaultValue (eventKey, type) => `${this.props.id}-${type}-${key}`
+   */
+  generateChildId: PropTypes.func,
+
+  /**
+   * HTML id attribute, required if no `generateChildId` prop
+   * is specified.
+   */
+  id: generatedId('PanelGroup')
+};
+var defaultProps = {
+  accordion: false
+};
+var childContextTypes = {
+  $bs_panelGroup: PropTypes.shape({
+    getId: PropTypes.func,
+    headerRole: PropTypes.string,
+    panelRole: PropTypes.string,
+    activeKey: PropTypes.any,
+    onToggle: PropTypes.func
+  })
+};
+
+var PanelGroup =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PanelGroup, _React$Component);
+
+  function PanelGroup() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+
+    _this.handleSelect = function (key, expanded, e) {
+      if (expanded) {
+        _this.props.onSelect(key, e);
+      } else if (_this.props.activeKey === key) {
+        _this.props.onSelect(null, e);
+      }
+    };
+
+    return _this;
+  }
+
+  var _proto = PanelGroup.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    var _this$props = this.props,
+        activeKey = _this$props.activeKey,
+        accordion = _this$props.accordion,
+        generateChildId = _this$props.generateChildId,
+        id = _this$props.id;
+    var getId = null;
+
+    if (accordion) {
+      getId = generateChildId || function (key, type) {
+        return id ? id + "-" + type + "-" + key : null;
+      };
+    }
+
+    return {
+      $bs_panelGroup: _extends({
+        getId: getId,
+        headerRole: 'tab',
+        panelRole: 'tabpanel'
+      }, accordion && {
+        activeKey: activeKey,
+        onToggle: this.handleSelect
+      })
+    };
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        accordion = _this$props2.accordion,
+        className = _this$props2.className,
+        children = _this$props2.children,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["accordion", "className", "children"]);
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(props, ['onSelect', 'activeKey']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1];
+
+    if (accordion) {
+      elementProps.role = elementProps.role || 'tablist';
+    }
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), ValidComponentChildren.map(children, function (child) {
+      return cloneElement(child, {
+        bsStyle: child.props.bsStyle || bsProps.bsStyle
+      });
+    }));
+  };
+
+  return PanelGroup;
+}(React.Component);
+
+PanelGroup.propTypes = propTypes;
+PanelGroup.defaultProps = defaultProps;
+PanelGroup.childContextTypes = childContextTypes;
+export default uncontrollable(bsClass('panel-group', PanelGroup), {
+  activeKey: 'onSelect'
+});

node_modules/react-bootstrap/es/PanelHeading.js

@@ -0,0 +1,66 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import PropTypes from 'prop-types';
+import React from 'react';
+import cn from 'classnames';
+import elementType from 'react-prop-types/lib/elementType';
+import { prefix, bsClass, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+var contextTypes = {
+  $bs_panel: PropTypes.shape({
+    headingId: PropTypes.string,
+    bsClass: PropTypes.string
+  })
+};
+
+var PanelHeading =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PanelHeading, _React$Component);
+
+  function PanelHeading() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = PanelHeading.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        Component = _this$props.componentClass,
+        props = _objectWithoutPropertiesLoose(_this$props, ["children", "className", "componentClass"]);
+
+    var _ref = this.context.$bs_panel || {},
+        headingId = _ref.headingId,
+        _bsClass = _ref.bsClass;
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    bsProps.bsClass = _bsClass || bsProps.bsClass;
+
+    if (headingId) {
+      elementProps.role = elementProps.role || 'tab';
+      elementProps.id = headingId;
+    }
+
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: cn(className, prefix(bsProps, 'heading'))
+    }), children);
+  };
+
+  return PanelHeading;
+}(React.Component);
+
+PanelHeading.propTypes = propTypes;
+PanelHeading.defaultProps = defaultProps;
+PanelHeading.contextTypes = contextTypes;
+export default bsClass('panel', PanelHeading);

node_modules/react-bootstrap/es/PanelTitle.js

@@ -0,0 +1,71 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import cn from 'classnames';
+import PropTypes from 'prop-types';
+import React from 'react';
+import elementType from 'react-prop-types/lib/elementType';
+import { prefix, splitBsProps, bsClass } from './utils/bootstrapUtils';
+import PanelToggle from './PanelToggle';
+var propTypes = {
+  componentClass: elementType,
+
+  /**
+   * A convenience prop that renders the Panel.Title as a panel collapse toggle component
+   * for the common use-case.
+   */
+  toggle: PropTypes.bool
+};
+var contextTypes = {
+  $bs_panel: PropTypes.shape({
+    bsClass: PropTypes.string
+  })
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var PanelTitle =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PanelTitle, _React$Component);
+
+  function PanelTitle() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = PanelTitle.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        className = _this$props.className,
+        toggle = _this$props.toggle,
+        Component = _this$props.componentClass,
+        props = _objectWithoutPropertiesLoose(_this$props, ["children", "className", "toggle", "componentClass"]);
+
+    var _ref = this.context.$bs_panel || {},
+        _bsClass = _ref.bsClass;
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    bsProps.bsClass = _bsClass || bsProps.bsClass;
+
+    if (toggle) {
+      children = React.createElement(PanelToggle, null, children);
+    }
+
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: cn(className, prefix(bsProps, 'title'))
+    }), children);
+  };
+
+  return PanelTitle;
+}(React.Component);
+
+PanelTitle.propTypes = propTypes;
+PanelTitle.defaultProps = defaultProps;
+PanelTitle.contextTypes = contextTypes;
+export default bsClass('panel', PanelTitle);

node_modules/react-bootstrap/es/PanelToggle.js

@@ -0,0 +1,91 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import PropTypes from 'prop-types';
+import React from 'react';
+import classNames from 'classnames';
+import elementType from 'react-prop-types/lib/elementType';
+import SafeAnchor from './SafeAnchor';
+import createChainedFunction from './utils/createChainedFunction';
+var propTypes = {
+  /**
+   * only here to satisfy linting, just the html onClick handler.
+   *
+   * @private
+   */
+  onClick: PropTypes.func,
+
+  /**
+   * You can use a custom element for this component
+   */
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: SafeAnchor
+};
+var contextTypes = {
+  $bs_panel: PropTypes.shape({
+    bodyId: PropTypes.string,
+    onToggle: PropTypes.func,
+    expanded: PropTypes.bool
+  })
+};
+
+var PanelToggle =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(PanelToggle, _React$Component);
+
+  function PanelToggle() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+    _this.handleToggle = _this.handleToggle.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = PanelToggle.prototype;
+
+  _proto.handleToggle = function handleToggle(event) {
+    var _ref = this.context.$bs_panel || {},
+        onToggle = _ref.onToggle;
+
+    if (onToggle) {
+      onToggle(event);
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        onClick = _this$props.onClick,
+        className = _this$props.className,
+        componentClass = _this$props.componentClass,
+        props = _objectWithoutPropertiesLoose(_this$props, ["onClick", "className", "componentClass"]);
+
+    var _ref2 = this.context.$bs_panel || {},
+        expanded = _ref2.expanded,
+        bodyId = _ref2.bodyId;
+
+    var Component = componentClass;
+    props.onClick = createChainedFunction(onClick, this.handleToggle);
+    props['aria-expanded'] = expanded;
+    props.className = classNames(className, !expanded && 'collapsed');
+
+    if (bodyId) {
+      props['aria-controls'] = bodyId;
+    }
+
+    return React.createElement(Component, props);
+  };
+
+  return PanelToggle;
+}(React.Component);
+
+PanelToggle.propTypes = propTypes;
+PanelToggle.defaultProps = defaultProps;
+PanelToggle.contextTypes = contextTypes;
+export default PanelToggle;

node_modules/react-bootstrap/es/Popover.js

@@ -0,0 +1,112 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import isRequiredForA11y from 'prop-types-extra/lib/isRequiredForA11y';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * An html id attribute, necessary for accessibility
+   * @type {string}
+   * @required
+   */
+  id: isRequiredForA11y(PropTypes.oneOfType([PropTypes.string, PropTypes.number])),
+
+  /**
+   * Sets the direction the Popover is positioned towards.
+   */
+  placement: PropTypes.oneOf(['top', 'right', 'bottom', 'left']),
+
+  /**
+   * The "top" position value for the Popover.
+   */
+  positionTop: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+
+  /**
+   * The "left" position value for the Popover.
+   */
+  positionLeft: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+
+  /**
+   * The "top" position value for the Popover arrow.
+   */
+  arrowOffsetTop: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+
+  /**
+   * The "left" position value for the Popover arrow.
+   */
+  arrowOffsetLeft: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+
+  /**
+   * Title content
+   */
+  title: PropTypes.node
+};
+var defaultProps = {
+  placement: 'right'
+};
+
+var Popover =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Popover, _React$Component);
+
+  function Popover() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Popover.prototype;
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        placement = _this$props.placement,
+        positionTop = _this$props.positionTop,
+        positionLeft = _this$props.positionLeft,
+        arrowOffsetTop = _this$props.arrowOffsetTop,
+        arrowOffsetLeft = _this$props.arrowOffsetLeft,
+        title = _this$props.title,
+        className = _this$props.className,
+        style = _this$props.style,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["placement", "positionTop", "positionLeft", "arrowOffsetTop", "arrowOffsetLeft", "title", "className", "style", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[placement] = true, _extends2));
+
+    var outerStyle = _extends({
+      display: 'block',
+      top: positionTop,
+      left: positionLeft
+    }, style);
+
+    var arrowStyle = {
+      top: arrowOffsetTop,
+      left: arrowOffsetLeft
+    };
+    return React.createElement("div", _extends({}, elementProps, {
+      role: "tooltip",
+      className: classNames(className, classes),
+      style: outerStyle
+    }), React.createElement("div", {
+      className: "arrow",
+      style: arrowStyle
+    }), title && React.createElement("h3", {
+      className: prefix(bsProps, 'title')
+    }, title), React.createElement("div", {
+      className: prefix(bsProps, 'content')
+    }, children));
+  };
+
+  return Popover;
+}(React.Component);
+
+Popover.propTypes = propTypes;
+Popover.defaultProps = defaultProps;
+export default bsClass('popover', Popover);

node_modules/react-bootstrap/es/ProgressBar.js

@@ -0,0 +1,166 @@
+import _Object$values from "@babel/runtime-corejs2/core-js/object/values";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import { bsClass as setBsClass, bsStyles, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+import { State } from './utils/StyleConfig';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+var ROUND_PRECISION = 1000;
+/**
+ * Validate that children, if any, are instances of `<ProgressBar>`.
+ */
+
+function onlyProgressBar(props, propName, componentName) {
+  var children = props[propName];
+
+  if (!children) {
+    return null;
+  }
+
+  var error = null;
+  React.Children.forEach(children, function (child) {
+    if (error) {
+      return;
+    }
+    /**
+     * Compare types in a way that works with libraries that patch and proxy
+     * components like react-hot-loader.
+     *
+     * see https://github.com/gaearon/react-hot-loader#checking-element-types
+     */
+
+
+    var element = React.createElement(ProgressBar, null);
+    if (child.type === element.type) return;
+    var childIdentifier = React.isValidElement(child) ? child.type.displayName || child.type.name || child.type : child;
+    error = new Error("Children of " + componentName + " can contain only ProgressBar " + ("components. Found " + childIdentifier + "."));
+  });
+  return error;
+}
+
+var propTypes = {
+  min: PropTypes.number,
+  now: PropTypes.number,
+  max: PropTypes.number,
+  label: PropTypes.node,
+  srOnly: PropTypes.bool,
+  striped: PropTypes.bool,
+  active: PropTypes.bool,
+  children: onlyProgressBar,
+
+  /**
+   * @private
+   */
+  isChild: PropTypes.bool
+};
+var defaultProps = {
+  min: 0,
+  max: 100,
+  active: false,
+  isChild: false,
+  srOnly: false,
+  striped: false
+};
+
+function getPercentage(now, min, max) {
+  var percentage = (now - min) / (max - min) * 100;
+  return Math.round(percentage * ROUND_PRECISION) / ROUND_PRECISION;
+}
+
+var ProgressBar =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ProgressBar, _React$Component);
+
+  function ProgressBar() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ProgressBar.prototype;
+
+  _proto.renderProgressBar = function renderProgressBar(_ref) {
+    var _extends2;
+
+    var min = _ref.min,
+        now = _ref.now,
+        max = _ref.max,
+        label = _ref.label,
+        srOnly = _ref.srOnly,
+        striped = _ref.striped,
+        active = _ref.active,
+        className = _ref.className,
+        style = _ref.style,
+        props = _objectWithoutPropertiesLoose(_ref, ["min", "now", "max", "label", "srOnly", "striped", "active", "className", "style"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {
+      active: active
+    }, _extends2[prefix(bsProps, 'striped')] = active || striped, _extends2));
+
+    return React.createElement("div", _extends({}, elementProps, {
+      role: "progressbar",
+      className: classNames(className, classes),
+      style: _extends({
+        width: getPercentage(now, min, max) + "%"
+      }, style),
+      "aria-valuenow": now,
+      "aria-valuemin": min,
+      "aria-valuemax": max
+    }), srOnly ? React.createElement("span", {
+      className: "sr-only"
+    }, label) : label);
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        isChild = _this$props.isChild,
+        props = _objectWithoutPropertiesLoose(_this$props, ["isChild"]);
+
+    if (isChild) {
+      return this.renderProgressBar(props);
+    }
+
+    var min = props.min,
+        now = props.now,
+        max = props.max,
+        label = props.label,
+        srOnly = props.srOnly,
+        striped = props.striped,
+        active = props.active,
+        bsClass = props.bsClass,
+        bsStyle = props.bsStyle,
+        className = props.className,
+        children = props.children,
+        wrapperProps = _objectWithoutPropertiesLoose(props, ["min", "now", "max", "label", "srOnly", "striped", "active", "bsClass", "bsStyle", "className", "children"]);
+
+    return React.createElement("div", _extends({}, wrapperProps, {
+      className: classNames(className, 'progress')
+    }), children ? ValidComponentChildren.map(children, function (child) {
+      return cloneElement(child, {
+        isChild: true
+      });
+    }) : this.renderProgressBar({
+      min: min,
+      now: now,
+      max: max,
+      label: label,
+      srOnly: srOnly,
+      striped: striped,
+      active: active,
+      bsClass: bsClass,
+      bsStyle: bsStyle
+    }));
+  };
+
+  return ProgressBar;
+}(React.Component);
+
+ProgressBar.propTypes = propTypes;
+ProgressBar.defaultProps = defaultProps;
+export default setBsClass('progress-bar', bsStyles(_Object$values(State), ProgressBar));

node_modules/react-bootstrap/es/Radio.js

@@ -0,0 +1,105 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+
+/* eslint-disable jsx-a11y/label-has-for */
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import warning from 'warning';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  inline: PropTypes.bool,
+  disabled: PropTypes.bool,
+  title: PropTypes.string,
+
+  /**
+   * Only valid if `inline` is not set.
+   */
+  validationState: PropTypes.oneOf(['success', 'warning', 'error', null]),
+
+  /**
+   * Attaches a ref to the `<input>` element. Only functions can be used here.
+   *
+   * ```js
+   * <Radio inputRef={ref => { this.input = ref; }} />
+   * ```
+   */
+  inputRef: PropTypes.func
+};
+var defaultProps = {
+  inline: false,
+  disabled: false,
+  title: ''
+};
+
+var Radio =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Radio, _React$Component);
+
+  function Radio() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Radio.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        inline = _this$props.inline,
+        disabled = _this$props.disabled,
+        validationState = _this$props.validationState,
+        inputRef = _this$props.inputRef,
+        className = _this$props.className,
+        style = _this$props.style,
+        title = _this$props.title,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["inline", "disabled", "validationState", "inputRef", "className", "style", "title", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var input = React.createElement("input", _extends({}, elementProps, {
+      ref: inputRef,
+      type: "radio",
+      disabled: disabled
+    }));
+
+    if (inline) {
+      var _classes2;
+
+      var _classes = (_classes2 = {}, _classes2[prefix(bsProps, 'inline')] = true, _classes2.disabled = disabled, _classes2); // Use a warning here instead of in propTypes to get better-looking
+      // generated documentation.
+
+
+      process.env.NODE_ENV !== "production" ? warning(!validationState, '`validationState` is ignored on `<Radio inline>`. To display ' + 'validation state on an inline radio, set `validationState` on a ' + 'parent `<FormGroup>` or other element instead.') : void 0;
+      return React.createElement("label", {
+        className: classNames(className, _classes),
+        style: style,
+        title: title
+      }, input, children);
+    }
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      disabled: disabled
+    });
+
+    if (validationState) {
+      classes["has-" + validationState] = true;
+    }
+
+    return React.createElement("div", {
+      className: classNames(className, classes),
+      style: style
+    }, React.createElement("label", {
+      title: title
+    }, input, children));
+  };
+
+  return Radio;
+}(React.Component);
+
+Radio.propTypes = propTypes;
+Radio.defaultProps = defaultProps;
+export default bsClass('radio', Radio);

node_modules/react-bootstrap/es/ResponsiveEmbed.js

@@ -0,0 +1,73 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React, { cloneElement } from 'react';
+import PropTypes from 'prop-types';
+import warning from 'warning';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils'; // TODO: This should probably take a single `aspectRatio` prop.
+
+var propTypes = {
+  /**
+   * This component requires a single child element
+   */
+  children: PropTypes.element.isRequired,
+
+  /**
+   * 16by9 aspect ratio
+   */
+  a16by9: PropTypes.bool,
+
+  /**
+   * 4by3 aspect ratio
+   */
+  a4by3: PropTypes.bool
+};
+var defaultProps = {
+  a16by9: false,
+  a4by3: false
+};
+
+var ResponsiveEmbed =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ResponsiveEmbed, _React$Component);
+
+  function ResponsiveEmbed() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ResponsiveEmbed.prototype;
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        a16by9 = _this$props.a16by9,
+        a4by3 = _this$props.a4by3,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["a16by9", "a4by3", "className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    process.env.NODE_ENV !== "production" ? warning(a16by9 || a4by3, 'Either `a16by9` or `a4by3` must be set.') : void 0;
+    process.env.NODE_ENV !== "production" ? warning(!(a16by9 && a4by3), 'Only one of `a16by9` or `a4by3` can be set.') : void 0;
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[prefix(bsProps, '16by9')] = a16by9, _extends2[prefix(bsProps, '4by3')] = a4by3, _extends2));
+
+    return React.createElement("div", {
+      className: classNames(classes)
+    }, cloneElement(children, _extends({}, elementProps, {
+      className: classNames(className, prefix(bsProps, 'item'))
+    })));
+  };
+
+  return ResponsiveEmbed;
+}(React.Component);
+
+ResponsiveEmbed.propTypes = propTypes;
+ResponsiveEmbed.defaultProps = defaultProps;
+export default bsClass('embed-responsive', ResponsiveEmbed);

node_modules/react-bootstrap/es/Row.js

@@ -0,0 +1,47 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'div'
+};
+
+var Row =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Row, _React$Component);
+
+  function Row() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Row.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.componentClass,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["componentClass", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Row;
+}(React.Component);
+
+Row.propTypes = propTypes;
+Row.defaultProps = defaultProps;
+export default bsClass('row', Row);

node_modules/react-bootstrap/es/SafeAnchor.js

@@ -0,0 +1,113 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import createChainedFunction from './utils/createChainedFunction';
+var propTypes = {
+  href: PropTypes.string,
+  onClick: PropTypes.func,
+  onKeyDown: PropTypes.func,
+  disabled: PropTypes.bool,
+  role: PropTypes.string,
+  tabIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+
+  /**
+   * this is sort of silly but needed for Button
+   */
+  componentClass: elementType
+};
+var defaultProps = {
+  componentClass: 'a'
+};
+
+function isTrivialHref(href) {
+  return !href || href.trim() === '#';
+}
+/**
+ * There are situations due to browser quirks or Bootstrap CSS where
+ * an anchor tag is needed, when semantically a button tag is the
+ * better choice. SafeAnchor ensures that when an anchor is used like a
+ * button its accessible. It also emulates input `disabled` behavior for
+ * links, which is usually desirable for Buttons, NavItems, MenuItems, etc.
+ */
+
+
+var SafeAnchor =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(SafeAnchor, _React$Component);
+
+  function SafeAnchor(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleClick = _this.handleClick.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleKeyDown = _this.handleKeyDown.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    return _this;
+  }
+
+  var _proto = SafeAnchor.prototype;
+
+  _proto.handleClick = function handleClick(event) {
+    var _this$props = this.props,
+        disabled = _this$props.disabled,
+        href = _this$props.href,
+        onClick = _this$props.onClick;
+
+    if (disabled || isTrivialHref(href)) {
+      event.preventDefault();
+    }
+
+    if (disabled) {
+      event.stopPropagation();
+      return;
+    }
+
+    if (onClick) {
+      onClick(event);
+    }
+  };
+
+  _proto.handleKeyDown = function handleKeyDown(event) {
+    if (event.key === ' ') {
+      event.preventDefault();
+      this.handleClick(event);
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        Component = _this$props2.componentClass,
+        disabled = _this$props2.disabled,
+        onKeyDown = _this$props2.onKeyDown,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["componentClass", "disabled", "onKeyDown"]);
+
+    if (isTrivialHref(props.href)) {
+      props.role = props.role || 'button'; // we want to make sure there is a href attribute on the node
+      // otherwise, the cursor incorrectly styled (except with role='button')
+
+      props.href = props.href || '#';
+    }
+
+    if (disabled) {
+      props.tabIndex = -1;
+      props.style = _extends({
+        pointerEvents: 'none'
+      }, props.style);
+    }
+
+    return React.createElement(Component, _extends({}, props, {
+      onClick: this.handleClick,
+      onKeyDown: createChainedFunction(this.handleKeyDown, onKeyDown)
+    }));
+  };
+
+  return SafeAnchor;
+}(React.Component);
+
+SafeAnchor.propTypes = propTypes;
+SafeAnchor.defaultProps = defaultProps;
+export default SafeAnchor;

node_modules/react-bootstrap/es/SplitButton.js

@@ -0,0 +1,78 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import React from 'react';
+import PropTypes from 'prop-types';
+import Button from './Button';
+import Dropdown from './Dropdown';
+import SplitToggle from './SplitToggle';
+import splitComponentProps from './utils/splitComponentProps';
+
+var propTypes = _extends({}, Dropdown.propTypes, {
+  // Toggle props.
+  bsStyle: PropTypes.string,
+  bsSize: PropTypes.string,
+  href: PropTypes.string,
+  onClick: PropTypes.func,
+
+  /**
+   * The content of the split button.
+   */
+  title: PropTypes.node.isRequired,
+
+  /**
+   * Accessible label for the toggle; the value of `title` if not specified.
+   */
+  toggleLabel: PropTypes.string,
+  // Override generated docs from <Dropdown>.
+
+  /**
+   * @private
+   */
+  children: PropTypes.node
+});
+
+var SplitButton =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(SplitButton, _React$Component);
+
+  function SplitButton() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = SplitButton.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        bsSize = _this$props.bsSize,
+        bsStyle = _this$props.bsStyle,
+        title = _this$props.title,
+        toggleLabel = _this$props.toggleLabel,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["bsSize", "bsStyle", "title", "toggleLabel", "children"]);
+
+    var _splitComponentProps = splitComponentProps(props, Dropdown.ControlledComponent),
+        dropdownProps = _splitComponentProps[0],
+        buttonProps = _splitComponentProps[1];
+
+    return React.createElement(Dropdown, _extends({}, dropdownProps, {
+      bsSize: bsSize,
+      bsStyle: bsStyle
+    }), React.createElement(Button, _extends({}, buttonProps, {
+      disabled: props.disabled,
+      bsSize: bsSize,
+      bsStyle: bsStyle
+    }), title), React.createElement(SplitToggle, {
+      "aria-label": toggleLabel || title,
+      bsSize: bsSize,
+      bsStyle: bsStyle
+    }), React.createElement(Dropdown.Menu, null, children));
+  };
+
+  return SplitButton;
+}(React.Component);
+
+SplitButton.propTypes = propTypes;
+SplitButton.Toggle = SplitToggle;
+export default SplitButton;

node_modules/react-bootstrap/es/SplitToggle.js

@@ -0,0 +1,28 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import React from 'react';
+import DropdownToggle from './DropdownToggle';
+
+var SplitToggle =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(SplitToggle, _React$Component);
+
+  function SplitToggle() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = SplitToggle.prototype;
+
+  _proto.render = function render() {
+    return React.createElement(DropdownToggle, _extends({}, this.props, {
+      useAnchor: false,
+      noCaret: false
+    }));
+  };
+
+  return SplitToggle;
+}(React.Component);
+
+SplitToggle.defaultProps = DropdownToggle.defaultProps;
+export default SplitToggle;

node_modules/react-bootstrap/es/Tab.js

@@ -0,0 +1,47 @@
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import React from 'react';
+import PropTypes from 'prop-types';
+import TabContainer from './TabContainer';
+import TabContent from './TabContent';
+import TabPane from './TabPane';
+
+var propTypes = _extends({}, TabPane.propTypes, {
+  disabled: PropTypes.bool,
+  title: PropTypes.node,
+
+  /**
+   * tabClassName is used as className for the associated NavItem
+   */
+  tabClassName: PropTypes.string
+});
+
+var Tab =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Tab, _React$Component);
+
+  function Tab() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Tab.prototype;
+
+  _proto.render = function render() {
+    var props = _extends({}, this.props); // These props are for the parent `<Tabs>` rather than the `<TabPane>`.
+
+
+    delete props.title;
+    delete props.disabled;
+    delete props.tabClassName;
+    return React.createElement(TabPane, props);
+  };
+
+  return Tab;
+}(React.Component);
+
+Tab.propTypes = propTypes;
+Tab.Container = TabContainer;
+Tab.Content = TabContent;
+Tab.Pane = TabPane;
+export default Tab;

node_modules/react-bootstrap/es/TabContainer.js

@@ -0,0 +1,122 @@
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import uncontrollable from 'uncontrollable';
+var TAB = 'tab';
+var PANE = 'pane';
+var idPropType = PropTypes.oneOfType([PropTypes.string, PropTypes.number]);
+var propTypes = {
+  /**
+   * HTML id attribute, required if no `generateChildId` prop
+   * is specified.
+   */
+  id: function id(props) {
+    var error = null;
+
+    if (!props.generateChildId) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      error = idPropType.apply(void 0, [props].concat(args));
+
+      if (!error && !props.id) {
+        error = new Error('In order to properly initialize Tabs in a way that is accessible ' + 'to assistive technologies (such as screen readers) an `id` or a ' + '`generateChildId` prop to TabContainer is required');
+      }
+    }
+
+    return error;
+  },
+
+  /**
+   * A function that takes an `eventKey` and `type` and returns a unique id for
+   * child tab `<NavItem>`s and `<TabPane>`s. The function _must_ be a pure
+   * function, meaning it should always return the _same_ id for the same set
+   * of inputs. The default value requires that an `id` to be set for the
+   * `<TabContainer>`.
+   *
+   * The `type` argument will either be `"tab"` or `"pane"`.
+   *
+   * @defaultValue (eventKey, type) => `${this.props.id}-${type}-${key}`
+   */
+  generateChildId: PropTypes.func,
+
+  /**
+   * A callback fired when a tab is selected.
+   *
+   * @controllable activeKey
+   */
+  onSelect: PropTypes.func,
+
+  /**
+   * The `eventKey` of the currently active tab.
+   *
+   * @controllable onSelect
+   */
+  activeKey: PropTypes.any
+};
+var childContextTypes = {
+  $bs_tabContainer: PropTypes.shape({
+    activeKey: PropTypes.any,
+    onSelect: PropTypes.func.isRequired,
+    getTabId: PropTypes.func.isRequired,
+    getPaneId: PropTypes.func.isRequired
+  })
+};
+
+var TabContainer =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(TabContainer, _React$Component);
+
+  function TabContainer() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = TabContainer.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    var _this$props = this.props,
+        activeKey = _this$props.activeKey,
+        onSelect = _this$props.onSelect,
+        generateChildId = _this$props.generateChildId,
+        id = _this$props.id;
+
+    var getId = generateChildId || function (key, type) {
+      return id ? id + "-" + type + "-" + key : null;
+    };
+
+    return {
+      $bs_tabContainer: {
+        activeKey: activeKey,
+        onSelect: onSelect,
+        getTabId: function getTabId(key) {
+          return getId(key, TAB);
+        },
+        getPaneId: function getPaneId(key) {
+          return getId(key, PANE);
+        }
+      }
+    };
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        children = _this$props2.children,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["children"]);
+
+    delete props.generateChildId;
+    delete props.onSelect;
+    delete props.activeKey;
+    return React.cloneElement(React.Children.only(children), props);
+  };
+
+  return TabContainer;
+}(React.Component);
+
+TabContainer.propTypes = propTypes;
+TabContainer.childContextTypes = childContextTypes;
+export default uncontrollable(TabContainer, {
+  activeKey: 'onSelect'
+});

node_modules/react-bootstrap/es/TabContent.js

@@ -0,0 +1,178 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import { bsClass as setBsClass, prefix, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+var propTypes = {
+  componentClass: elementType,
+
+  /**
+   * Sets a default animation strategy for all children `<TabPane>`s. Use
+   * `false` to disable, `true` to enable the default `<Fade>` animation or
+   * a react-transition-group v2 `<Transition/>` component.
+   */
+  animation: PropTypes.oneOfType([PropTypes.bool, elementType]),
+
+  /**
+   * Wait until the first "enter" transition to mount tabs (add them to the DOM)
+   */
+  mountOnEnter: PropTypes.bool,
+
+  /**
+   * Unmount tabs (remove it from the DOM) when they are no longer visible
+   */
+  unmountOnExit: PropTypes.bool
+};
+var defaultProps = {
+  componentClass: 'div',
+  animation: true,
+  mountOnEnter: false,
+  unmountOnExit: false
+};
+var contextTypes = {
+  $bs_tabContainer: PropTypes.shape({
+    activeKey: PropTypes.any
+  })
+};
+var childContextTypes = {
+  $bs_tabContent: PropTypes.shape({
+    bsClass: PropTypes.string,
+    animation: PropTypes.oneOfType([PropTypes.bool, elementType]),
+    activeKey: PropTypes.any,
+    mountOnEnter: PropTypes.bool,
+    unmountOnExit: PropTypes.bool,
+    onPaneEnter: PropTypes.func.isRequired,
+    onPaneExited: PropTypes.func.isRequired,
+    exiting: PropTypes.bool.isRequired
+  })
+};
+
+var TabContent =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(TabContent, _React$Component);
+
+  function TabContent(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handlePaneEnter = _this.handlePaneEnter.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handlePaneExited = _this.handlePaneExited.bind(_assertThisInitialized(_assertThisInitialized(_this))); // Active entries in state will be `null` unless `animation` is set. Need
+    // to track active child in case keys swap and the active child changes
+    // but the active key does not.
+
+    _this.state = {
+      activeKey: null,
+      activeChild: null
+    };
+    return _this;
+  }
+
+  var _proto = TabContent.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    var _this$props = this.props,
+        bsClass = _this$props.bsClass,
+        animation = _this$props.animation,
+        mountOnEnter = _this$props.mountOnEnter,
+        unmountOnExit = _this$props.unmountOnExit;
+    var stateActiveKey = this.state.activeKey;
+    var containerActiveKey = this.getContainerActiveKey();
+    var activeKey = stateActiveKey != null ? stateActiveKey : containerActiveKey;
+    var exiting = stateActiveKey != null && stateActiveKey !== containerActiveKey;
+    return {
+      $bs_tabContent: {
+        bsClass: bsClass,
+        animation: animation,
+        activeKey: activeKey,
+        mountOnEnter: mountOnEnter,
+        unmountOnExit: unmountOnExit,
+        onPaneEnter: this.handlePaneEnter,
+        onPaneExited: this.handlePaneExited,
+        exiting: exiting
+      }
+    };
+  };
+
+  _proto.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
+    if (!nextProps.animation && this.state.activeChild) {
+      this.setState({
+        activeKey: null,
+        activeChild: null
+      });
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.isUnmounted = true;
+  };
+
+  _proto.getContainerActiveKey = function getContainerActiveKey() {
+    var tabContainer = this.context.$bs_tabContainer;
+    return tabContainer && tabContainer.activeKey;
+  };
+
+  _proto.handlePaneEnter = function handlePaneEnter(child, childKey) {
+    if (!this.props.animation) {
+      return false;
+    } // It's possible that this child should be transitioning out.
+
+
+    if (childKey !== this.getContainerActiveKey()) {
+      return false;
+    }
+
+    this.setState({
+      activeKey: childKey,
+      activeChild: child
+    });
+    return true;
+  };
+
+  _proto.handlePaneExited = function handlePaneExited(child) {
+    // This might happen as everything is unmounting.
+    if (this.isUnmounted) {
+      return;
+    }
+
+    this.setState(function (_ref) {
+      var activeChild = _ref.activeChild;
+
+      if (activeChild !== child) {
+        return null;
+      }
+
+      return {
+        activeKey: null,
+        activeChild: null
+      };
+    });
+  };
+
+  _proto.render = function render() {
+    var _this$props2 = this.props,
+        Component = _this$props2.componentClass,
+        className = _this$props2.className,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["componentClass", "className"]);
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(props, ['animation', 'mountOnEnter', 'unmountOnExit']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1];
+
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, prefix(bsProps, 'content'))
+    }));
+  };
+
+  return TabContent;
+}(React.Component);
+
+TabContent.propTypes = propTypes;
+TabContent.defaultProps = defaultProps;
+TabContent.contextTypes = contextTypes;
+TabContent.childContextTypes = childContextTypes;
+export default setBsClass('tab', TabContent);

node_modules/react-bootstrap/es/TabPane.js

@@ -0,0 +1,270 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import _assertThisInitialized from "@babel/runtime-corejs2/helpers/esm/assertThisInitialized";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import elementType from 'prop-types-extra/lib/elementType';
+import warning from 'warning';
+import { bsClass, getClassSet, prefix, splitBsPropsAndOmit } from './utils/bootstrapUtils';
+import createChainedFunction from './utils/createChainedFunction';
+import Fade from './Fade';
+var propTypes = {
+  /**
+   * Uniquely identify the `<TabPane>` among its siblings.
+   */
+  eventKey: PropTypes.any,
+
+  /**
+   * Use animation when showing or hiding `<TabPane>`s. Use `false` to disable,
+   * `true` to enable the default `<Fade>` animation or
+   * a react-transition-group v2 `<Transition/>` component.
+   */
+  animation: PropTypes.oneOfType([PropTypes.bool, elementType]),
+
+  /** @private * */
+  id: PropTypes.string,
+
+  /** @private * */
+  'aria-labelledby': PropTypes.string,
+
+  /**
+   * If not explicitly specified and rendered in the context of a
+   * `<TabContent>`, the `bsClass` of the `<TabContent>` suffixed by `-pane`.
+   * If otherwise not explicitly specified, `tab-pane`.
+   */
+  bsClass: PropTypes.string,
+
+  /**
+   * Transition onEnter callback when animation is not `false`
+   */
+  onEnter: PropTypes.func,
+
+  /**
+   * Transition onEntering callback when animation is not `false`
+   */
+  onEntering: PropTypes.func,
+
+  /**
+   * Transition onEntered callback when animation is not `false`
+   */
+  onEntered: PropTypes.func,
+
+  /**
+   * Transition onExit callback when animation is not `false`
+   */
+  onExit: PropTypes.func,
+
+  /**
+   * Transition onExiting callback when animation is not `false`
+   */
+  onExiting: PropTypes.func,
+
+  /**
+   * Transition onExited callback when animation is not `false`
+   */
+  onExited: PropTypes.func,
+
+  /**
+   * Wait until the first "enter" transition to mount the tab (add it to the DOM)
+   */
+  mountOnEnter: PropTypes.bool,
+
+  /**
+   * Unmount the tab (remove it from the DOM) when it is no longer visible
+   */
+  unmountOnExit: PropTypes.bool
+};
+var contextTypes = {
+  $bs_tabContainer: PropTypes.shape({
+    getTabId: PropTypes.func,
+    getPaneId: PropTypes.func
+  }),
+  $bs_tabContent: PropTypes.shape({
+    bsClass: PropTypes.string,
+    animation: PropTypes.oneOfType([PropTypes.bool, elementType]),
+    activeKey: PropTypes.any,
+    mountOnEnter: PropTypes.bool,
+    unmountOnExit: PropTypes.bool,
+    onPaneEnter: PropTypes.func.isRequired,
+    onPaneExited: PropTypes.func.isRequired,
+    exiting: PropTypes.bool.isRequired
+  })
+};
+/**
+ * We override the `<TabContainer>` context so `<Nav>`s in `<TabPane>`s don't
+ * conflict with the top level one.
+ */
+
+var childContextTypes = {
+  $bs_tabContainer: PropTypes.oneOf([null])
+};
+
+var TabPane =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(TabPane, _React$Component);
+
+  function TabPane(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    _this.handleEnter = _this.handleEnter.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.handleExited = _this.handleExited.bind(_assertThisInitialized(_assertThisInitialized(_this)));
+    _this.in = false;
+    return _this;
+  }
+
+  var _proto = TabPane.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    return {
+      $bs_tabContainer: null
+    };
+  };
+
+  _proto.componentDidMount = function componentDidMount() {
+    if (this.shouldBeIn()) {
+      // In lieu of the action event firing.
+      this.handleEnter();
+    }
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate() {
+    if (this.in) {
+      if (!this.shouldBeIn()) {
+        // We shouldn't be active any more. Notify the parent.
+        this.handleExited();
+      }
+    } else if (this.shouldBeIn()) {
+      // We are the active child. Notify the parent.
+      this.handleEnter();
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    if (this.in) {
+      // In lieu of the action event firing.
+      this.handleExited();
+    }
+  };
+
+  _proto.getAnimation = function getAnimation() {
+    if (this.props.animation != null) {
+      return this.props.animation;
+    }
+
+    var tabContent = this.context.$bs_tabContent;
+    return tabContent && tabContent.animation;
+  };
+
+  _proto.handleEnter = function handleEnter() {
+    var tabContent = this.context.$bs_tabContent;
+
+    if (!tabContent) {
+      return;
+    }
+
+    this.in = tabContent.onPaneEnter(this, this.props.eventKey);
+  };
+
+  _proto.handleExited = function handleExited() {
+    var tabContent = this.context.$bs_tabContent;
+
+    if (!tabContent) {
+      return;
+    }
+
+    tabContent.onPaneExited(this);
+    this.in = false;
+  };
+
+  _proto.isActive = function isActive() {
+    var tabContent = this.context.$bs_tabContent;
+    var activeKey = tabContent && tabContent.activeKey;
+    return this.props.eventKey === activeKey;
+  };
+
+  _proto.shouldBeIn = function shouldBeIn() {
+    return this.getAnimation() && this.isActive();
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        eventKey = _this$props.eventKey,
+        className = _this$props.className,
+        onEnter = _this$props.onEnter,
+        onEntering = _this$props.onEntering,
+        onEntered = _this$props.onEntered,
+        onExit = _this$props.onExit,
+        onExiting = _this$props.onExiting,
+        onExited = _this$props.onExited,
+        propsMountOnEnter = _this$props.mountOnEnter,
+        propsUnmountOnExit = _this$props.unmountOnExit,
+        props = _objectWithoutPropertiesLoose(_this$props, ["eventKey", "className", "onEnter", "onEntering", "onEntered", "onExit", "onExiting", "onExited", "mountOnEnter", "unmountOnExit"]);
+
+    var _this$context = this.context,
+        tabContent = _this$context.$bs_tabContent,
+        tabContainer = _this$context.$bs_tabContainer;
+
+    var _splitBsPropsAndOmit = splitBsPropsAndOmit(props, ['animation']),
+        bsProps = _splitBsPropsAndOmit[0],
+        elementProps = _splitBsPropsAndOmit[1];
+
+    var active = this.isActive();
+    var animation = this.getAnimation();
+    var mountOnEnter = propsMountOnEnter != null ? propsMountOnEnter : tabContent && tabContent.mountOnEnter;
+    var unmountOnExit = propsUnmountOnExit != null ? propsUnmountOnExit : tabContent && tabContent.unmountOnExit;
+
+    if (!active && !animation && unmountOnExit) {
+      return null;
+    }
+
+    var Transition = animation === true ? Fade : animation || null;
+
+    if (tabContent) {
+      bsProps.bsClass = prefix(tabContent, 'pane');
+    }
+
+    var classes = _extends({}, getClassSet(bsProps), {
+      active: active
+    });
+
+    if (tabContainer) {
+      process.env.NODE_ENV !== "production" ? warning(!elementProps.id && !elementProps['aria-labelledby'], 'In the context of a `<TabContainer>`, `<TabPanes>` are given ' + 'generated `id` and `aria-labelledby` attributes for the sake of ' + 'proper component accessibility. Any provided ones will be ignored. ' + 'To control these attributes directly provide a `generateChildId` ' + 'prop to the parent `<TabContainer>`.') : void 0;
+      elementProps.id = tabContainer.getPaneId(eventKey);
+      elementProps['aria-labelledby'] = tabContainer.getTabId(eventKey);
+    }
+
+    var pane = React.createElement("div", _extends({}, elementProps, {
+      role: "tabpanel",
+      "aria-hidden": !active,
+      className: classNames(className, classes)
+    }));
+
+    if (Transition) {
+      var exiting = tabContent && tabContent.exiting;
+      return React.createElement(Transition, {
+        in: active && !exiting,
+        onEnter: createChainedFunction(this.handleEnter, onEnter),
+        onEntering: onEntering,
+        onEntered: onEntered,
+        onExit: onExit,
+        onExiting: onExiting,
+        onExited: createChainedFunction(this.handleExited, onExited),
+        mountOnEnter: mountOnEnter,
+        unmountOnExit: unmountOnExit
+      }, pane);
+    }
+
+    return pane;
+  };
+
+  return TabPane;
+}(React.Component);
+
+TabPane.propTypes = propTypes;
+TabPane.contextTypes = contextTypes;
+TabPane.childContextTypes = childContextTypes;
+export default bsClass('tab-pane', TabPane);

node_modules/react-bootstrap/es/Table.js

@@ -0,0 +1,70 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  striped: PropTypes.bool,
+  bordered: PropTypes.bool,
+  condensed: PropTypes.bool,
+  hover: PropTypes.bool,
+  responsive: PropTypes.bool
+};
+var defaultProps = {
+  bordered: false,
+  condensed: false,
+  hover: false,
+  responsive: false,
+  striped: false
+};
+
+var Table =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Table, _React$Component);
+
+  function Table() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Table.prototype;
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        striped = _this$props.striped,
+        bordered = _this$props.bordered,
+        condensed = _this$props.condensed,
+        hover = _this$props.hover,
+        responsive = _this$props.responsive,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["striped", "bordered", "condensed", "hover", "responsive", "className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[prefix(bsProps, 'striped')] = striped, _extends2[prefix(bsProps, 'bordered')] = bordered, _extends2[prefix(bsProps, 'condensed')] = condensed, _extends2[prefix(bsProps, 'hover')] = hover, _extends2));
+
+    var table = React.createElement("table", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+
+    if (responsive) {
+      return React.createElement("div", {
+        className: prefix(bsProps, 'responsive')
+      }, table);
+    }
+
+    return table;
+  };
+
+  return Table;
+}(React.Component);
+
+Table.propTypes = propTypes;
+Table.defaultProps = defaultProps;
+export default bsClass('table', Table);

node_modules/react-bootstrap/es/Tabs.js

@@ -0,0 +1,146 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import requiredForA11y from 'prop-types-extra/lib/isRequiredForA11y';
+import uncontrollable from 'uncontrollable';
+import elementType from 'prop-types-extra/lib/elementType';
+import Nav from './Nav';
+import NavItem from './NavItem';
+import UncontrolledTabContainer from './TabContainer';
+import TabContent from './TabContent';
+import { bsClass as setBsClass } from './utils/bootstrapUtils';
+import ValidComponentChildren from './utils/ValidComponentChildren';
+var TabContainer = UncontrolledTabContainer.ControlledComponent;
+var propTypes = {
+  /**
+   * Mark the Tab with a matching `eventKey` as active.
+   *
+   * @controllable onSelect
+   */
+  activeKey: PropTypes.any,
+
+  /**
+   * Navigation style
+   */
+  bsStyle: PropTypes.oneOf(['tabs', 'pills']),
+
+  /**
+   * Sets a default animation strategy. Use `false` to disable, `true`
+   * to enable the default `<Fade>` animation, or a react-transition-group
+   * v2 `<Transition/>` component.
+   */
+  animation: PropTypes.oneOfType([PropTypes.bool, elementType]),
+  id: requiredForA11y(PropTypes.oneOfType([PropTypes.string, PropTypes.number])),
+
+  /**
+   * Callback fired when a Tab is selected.
+   *
+   * ```js
+   * function (
+   *   Any eventKey,
+   *   SyntheticEvent event?
+   * )
+   * ```
+   *
+   * @controllable activeKey
+   */
+  onSelect: PropTypes.func,
+
+  /**
+   * Wait until the first "enter" transition to mount tabs (add them to the DOM)
+   */
+  mountOnEnter: PropTypes.bool,
+
+  /**
+   * Unmount tabs (remove it from the DOM) when it is no longer visible
+   */
+  unmountOnExit: PropTypes.bool
+};
+var defaultProps = {
+  bsStyle: 'tabs',
+  animation: true,
+  mountOnEnter: false,
+  unmountOnExit: false
+};
+
+function getDefaultActiveKey(children) {
+  var defaultActiveKey;
+  ValidComponentChildren.forEach(children, function (child) {
+    if (defaultActiveKey == null) {
+      defaultActiveKey = child.props.eventKey;
+    }
+  });
+  return defaultActiveKey;
+}
+
+var Tabs =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Tabs, _React$Component);
+
+  function Tabs() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Tabs.prototype;
+
+  _proto.renderTab = function renderTab(child) {
+    var _child$props = child.props,
+        title = _child$props.title,
+        eventKey = _child$props.eventKey,
+        disabled = _child$props.disabled,
+        tabClassName = _child$props.tabClassName;
+
+    if (title == null) {
+      return null;
+    }
+
+    return React.createElement(NavItem, {
+      eventKey: eventKey,
+      disabled: disabled,
+      className: tabClassName
+    }, title);
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        id = _this$props.id,
+        onSelect = _this$props.onSelect,
+        animation = _this$props.animation,
+        mountOnEnter = _this$props.mountOnEnter,
+        unmountOnExit = _this$props.unmountOnExit,
+        bsClass = _this$props.bsClass,
+        className = _this$props.className,
+        style = _this$props.style,
+        children = _this$props.children,
+        _this$props$activeKey = _this$props.activeKey,
+        activeKey = _this$props$activeKey === void 0 ? getDefaultActiveKey(children) : _this$props$activeKey,
+        props = _objectWithoutPropertiesLoose(_this$props, ["id", "onSelect", "animation", "mountOnEnter", "unmountOnExit", "bsClass", "className", "style", "children", "activeKey"]);
+
+    return React.createElement(TabContainer, {
+      id: id,
+      activeKey: activeKey,
+      onSelect: onSelect,
+      className: className,
+      style: style
+    }, React.createElement("div", null, React.createElement(Nav, _extends({}, props, {
+      role: "tablist"
+    }), ValidComponentChildren.map(children, this.renderTab)), React.createElement(TabContent, {
+      bsClass: bsClass,
+      animation: animation,
+      mountOnEnter: mountOnEnter,
+      unmountOnExit: unmountOnExit
+    }, children)));
+  };
+
+  return Tabs;
+}(React.Component);
+
+Tabs.propTypes = propTypes;
+Tabs.defaultProps = defaultProps;
+setBsClass('tab', Tabs);
+export default uncontrollable(Tabs, {
+  activeKey: 'onSelect'
+});

node_modules/react-bootstrap/es/Thumbnail.js

@@ -0,0 +1,81 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+
+/* eslint-disable jsx-a11y/alt-text */
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import SafeAnchor from './SafeAnchor';
+import { bsClass, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * src property that is passed down to the image inside this component
+   */
+  src: PropTypes.string,
+
+  /**
+   * alt property that is passed down to the image inside this component
+   */
+  alt: PropTypes.string,
+
+  /**
+   * href property that is passed down to the image inside this component
+   */
+  href: PropTypes.string,
+
+  /**
+   * onError callback that is passed down to the image inside this component
+   */
+  onError: PropTypes.func,
+
+  /**
+   * onLoad callback that is passed down to the image inside this component
+   */
+  onLoad: PropTypes.func
+};
+
+var Thumbnail =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Thumbnail, _React$Component);
+
+  function Thumbnail() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Thumbnail.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        src = _this$props.src,
+        alt = _this$props.alt,
+        onError = _this$props.onError,
+        onLoad = _this$props.onLoad,
+        className = _this$props.className,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["src", "alt", "onError", "onLoad", "className", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var Component = elementProps.href ? SafeAnchor : 'div';
+    var classes = getClassSet(bsProps);
+    return React.createElement(Component, _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }), React.createElement("img", {
+      src: src,
+      alt: alt,
+      onError: onError,
+      onLoad: onLoad
+    }), children && React.createElement("div", {
+      className: "caption"
+    }, children));
+  };
+
+  return Thumbnail;
+}(React.Component);
+
+Thumbnail.propTypes = propTypes;
+export default bsClass('thumbnail', Thumbnail);

node_modules/react-bootstrap/es/ToggleButton.js

@@ -0,0 +1,81 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import PropTypes from 'prop-types';
+import React from 'react';
+import Button from './Button';
+var propTypes = {
+  /**
+   * The `<input>` `type`
+   * @type {[type]}
+   */
+  type: PropTypes.oneOf(['checkbox', 'radio']),
+
+  /**
+   * The HTML input name, used to group like checkboxes or radio buttons together
+   * semantically
+   */
+  name: PropTypes.string,
+
+  /**
+   * The checked state of the input, managed by `<ToggleButtonGroup>`` automatically
+   */
+  checked: PropTypes.bool,
+
+  /**
+   * The disabled state of both the label and input
+   */
+  disabled: PropTypes.bool,
+
+  /**
+   * [onChange description]
+   */
+  onChange: PropTypes.func,
+
+  /**
+   * The value of the input, and unique identifier in the ToggleButtonGroup
+   */
+  value: PropTypes.any.isRequired
+};
+
+var ToggleButton =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ToggleButton, _React$Component);
+
+  function ToggleButton() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ToggleButton.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        name = _this$props.name,
+        checked = _this$props.checked,
+        type = _this$props.type,
+        onChange = _this$props.onChange,
+        value = _this$props.value,
+        props = _objectWithoutPropertiesLoose(_this$props, ["children", "name", "checked", "type", "onChange", "value"]);
+
+    var disabled = props.disabled;
+    return React.createElement(Button, _extends({}, props, {
+      active: !!checked,
+      componentClass: "label"
+    }), React.createElement("input", {
+      name: name,
+      type: type,
+      autoComplete: "off",
+      value: value,
+      checked: !!checked,
+      disabled: !!disabled,
+      onChange: onChange
+    }), children);
+  };
+
+  return ToggleButton;
+}(React.Component);
+
+ToggleButton.propTypes = propTypes;
+export default ToggleButton;

node_modules/react-bootstrap/es/ToggleButtonGroup.js

@@ -0,0 +1,129 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import PropTypes from 'prop-types';
+import React from 'react';
+import invariant from 'invariant';
+import uncontrollable from 'uncontrollable';
+import chainFunction from './utils/createChainedFunction';
+import ValidChildren from './utils/ValidComponentChildren';
+import ButtonGroup from './ButtonGroup';
+import ToggleButton from './ToggleButton';
+var propTypes = {
+  /**
+   * An HTML `<input>` name for each child button.
+   *
+   * __Required if `type` is set to `'radio'`__
+   */
+  name: PropTypes.string,
+
+  /**
+   * The value, or array of values, of the active (pressed) buttons
+   *
+   * @controllable onChange
+   */
+  value: PropTypes.any,
+
+  /**
+   * Callback fired when a button is pressed, depending on whether the `type`
+   * is `'radio'` or `'checkbox'`, `onChange` will be called with the value or
+   * array of active values
+   *
+   * @controllable values
+   */
+  onChange: PropTypes.func,
+
+  /**
+   * The input `type` of the rendered buttons, determines the toggle behavior
+   * of the buttons
+   */
+  type: PropTypes.oneOf(['checkbox', 'radio']).isRequired
+};
+var defaultProps = {
+  type: 'radio'
+};
+
+var ToggleButtonGroup =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ToggleButtonGroup, _React$Component);
+
+  function ToggleButtonGroup() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = ToggleButtonGroup.prototype;
+
+  _proto.getValues = function getValues() {
+    var value = this.props.value;
+    return value == null ? [] : [].concat(value);
+  };
+
+  _proto.handleToggle = function handleToggle(value) {
+    var _this$props = this.props,
+        type = _this$props.type,
+        onChange = _this$props.onChange;
+    var values = this.getValues();
+    var isActive = values.indexOf(value) !== -1;
+
+    if (type === 'radio') {
+      if (!isActive) {
+        onChange(value);
+      }
+
+      return;
+    }
+
+    if (isActive) {
+      onChange(values.filter(function (n) {
+        return n !== value;
+      }));
+    } else {
+      onChange(values.concat([value]));
+    }
+  };
+
+  _proto.render = function render() {
+    var _this = this;
+
+    var _this$props2 = this.props,
+        children = _this$props2.children,
+        type = _this$props2.type,
+        name = _this$props2.name,
+        props = _objectWithoutPropertiesLoose(_this$props2, ["children", "type", "name"]);
+
+    var values = this.getValues();
+    !(type !== 'radio' || !!name) ? process.env.NODE_ENV !== "production" ? invariant(false, 'A `name` is required to group the toggle buttons when the `type` ' + 'is set to "radio"') : invariant(false) : void 0;
+    delete props.onChange;
+    delete props.value; // the data attribute is required b/c twbs css uses it in the selector
+
+    return React.createElement(ButtonGroup, _extends({}, props, {
+      "data-toggle": "buttons"
+    }), ValidChildren.map(children, function (child) {
+      var _child$props = child.props,
+          value = _child$props.value,
+          onChange = _child$props.onChange;
+
+      var handler = function handler() {
+        return _this.handleToggle(value);
+      };
+
+      return React.cloneElement(child, {
+        type: type,
+        name: child.name || name,
+        checked: values.indexOf(value) !== -1,
+        onChange: chainFunction(onChange, handler)
+      });
+    }));
+  };
+
+  return ToggleButtonGroup;
+}(React.Component);
+
+ToggleButtonGroup.propTypes = propTypes;
+ToggleButtonGroup.defaultProps = defaultProps;
+var UncontrolledToggleButtonGroup = uncontrollable(ToggleButtonGroup, {
+  value: 'onChange'
+});
+UncontrolledToggleButtonGroup.Button = ToggleButton;
+export default UncontrolledToggleButtonGroup;

node_modules/react-bootstrap/es/Tooltip.js

@@ -0,0 +1,103 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import PropTypes from 'prop-types';
+import isRequiredForA11y from 'prop-types-extra/lib/isRequiredForA11y';
+import { bsClass, getClassSet, prefix, splitBsProps } from './utils/bootstrapUtils';
+var propTypes = {
+  /**
+   * An html id attribute, necessary for accessibility
+   * @type {string|number}
+   * @required
+   */
+  id: isRequiredForA11y(PropTypes.oneOfType([PropTypes.string, PropTypes.number])),
+
+  /**
+   * Sets the direction the Tooltip is positioned towards.
+   */
+  placement: PropTypes.oneOf(['top', 'right', 'bottom', 'left']),
+
+  /**
+   * The "top" position value for the Tooltip.
+   */
+  positionTop: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+
+  /**
+   * The "left" position value for the Tooltip.
+   */
+  positionLeft: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+
+  /**
+   * The "top" position value for the Tooltip arrow.
+   */
+  arrowOffsetTop: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+
+  /**
+   * The "left" position value for the Tooltip arrow.
+   */
+  arrowOffsetLeft: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+};
+var defaultProps = {
+  placement: 'right'
+};
+
+var Tooltip =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Tooltip, _React$Component);
+
+  function Tooltip() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Tooltip.prototype;
+
+  _proto.render = function render() {
+    var _extends2;
+
+    var _this$props = this.props,
+        placement = _this$props.placement,
+        positionTop = _this$props.positionTop,
+        positionLeft = _this$props.positionLeft,
+        arrowOffsetTop = _this$props.arrowOffsetTop,
+        arrowOffsetLeft = _this$props.arrowOffsetLeft,
+        className = _this$props.className,
+        style = _this$props.style,
+        children = _this$props.children,
+        props = _objectWithoutPropertiesLoose(_this$props, ["placement", "positionTop", "positionLeft", "arrowOffsetTop", "arrowOffsetLeft", "className", "style", "children"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = _extends({}, getClassSet(bsProps), (_extends2 = {}, _extends2[placement] = true, _extends2));
+
+    var outerStyle = _extends({
+      top: positionTop,
+      left: positionLeft
+    }, style);
+
+    var arrowStyle = {
+      top: arrowOffsetTop,
+      left: arrowOffsetLeft
+    };
+    return React.createElement("div", _extends({}, elementProps, {
+      role: "tooltip",
+      className: classNames(className, classes),
+      style: outerStyle
+    }), React.createElement("div", {
+      className: prefix(bsProps, 'arrow'),
+      style: arrowStyle
+    }), React.createElement("div", {
+      className: prefix(bsProps, 'inner')
+    }, children));
+  };
+
+  return Tooltip;
+}(React.Component);
+
+Tooltip.propTypes = propTypes;
+Tooltip.defaultProps = defaultProps;
+export default bsClass('tooltip', Tooltip);

node_modules/react-bootstrap/es/Well.js

@@ -0,0 +1,38 @@
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime-corejs2/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime-corejs2/helpers/esm/inheritsLoose";
+import classNames from 'classnames';
+import React from 'react';
+import { bsClass, bsSizes, getClassSet, splitBsProps } from './utils/bootstrapUtils';
+import { Size } from './utils/StyleConfig';
+
+var Well =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Well, _React$Component);
+
+  function Well() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = Well.prototype;
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        props = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var _splitBsProps = splitBsProps(props),
+        bsProps = _splitBsProps[0],
+        elementProps = _splitBsProps[1];
+
+    var classes = getClassSet(bsProps);
+    return React.createElement("div", _extends({}, elementProps, {
+      className: classNames(className, classes)
+    }));
+  };
+
+  return Well;
+}(React.Component);
+
+export default bsClass('well', bsSizes([Size.LARGE, Size.SMALL], Well));

node_modules/react-bootstrap/es/index.js

@@ -0,0 +1,142 @@
+import _Accordion from './Accordion';
+export { _Accordion as Accordion };
+import _Alert from './Alert';
+export { _Alert as Alert };
+import _Badge from './Badge';
+export { _Badge as Badge };
+import _Breadcrumb from './Breadcrumb';
+export { _Breadcrumb as Breadcrumb };
+import _BreadcrumbItem from './BreadcrumbItem';
+export { _BreadcrumbItem as BreadcrumbItem };
+import _Button from './Button';
+export { _Button as Button };
+import _ButtonGroup from './ButtonGroup';
+export { _ButtonGroup as ButtonGroup };
+import _ButtonToolbar from './ButtonToolbar';
+export { _ButtonToolbar as ButtonToolbar };
+import _Carousel from './Carousel';
+export { _Carousel as Carousel };
+import _CarouselItem from './CarouselItem';
+export { _CarouselItem as CarouselItem };
+import _Checkbox from './Checkbox';
+export { _Checkbox as Checkbox };
+import _Clearfix from './Clearfix';
+export { _Clearfix as Clearfix };
+import _CloseButton from './CloseButton';
+export { _CloseButton as CloseButton };
+import _ControlLabel from './ControlLabel';
+export { _ControlLabel as ControlLabel };
+import _Col from './Col';
+export { _Col as Col };
+import _Collapse from './Collapse';
+export { _Collapse as Collapse };
+import _Dropdown from './Dropdown';
+export { _Dropdown as Dropdown };
+import _DropdownButton from './DropdownButton';
+export { _DropdownButton as DropdownButton };
+import _Fade from './Fade';
+export { _Fade as Fade };
+import _Form from './Form';
+export { _Form as Form };
+import _FormControl from './FormControl';
+export { _FormControl as FormControl };
+import _FormGroup from './FormGroup';
+export { _FormGroup as FormGroup };
+import _Glyphicon from './Glyphicon';
+export { _Glyphicon as Glyphicon };
+import _Grid from './Grid';
+export { _Grid as Grid };
+import _HelpBlock from './HelpBlock';
+export { _HelpBlock as HelpBlock };
+import _Image from './Image';
+export { _Image as Image };
+import _InputGroup from './InputGroup';
+export { _InputGroup as InputGroup };
+import _Jumbotron from './Jumbotron';
+export { _Jumbotron as Jumbotron };
+import _Label from './Label';
+export { _Label as Label };
+import _ListGroup from './ListGroup';
+export { _ListGroup as ListGroup };
+import _ListGroupItem from './ListGroupItem';
+export { _ListGroupItem as ListGroupItem };
+import _Media from './Media';
+export { _Media as Media };
+import _MenuItem from './MenuItem';
+export { _MenuItem as MenuItem };
+import _Modal from './Modal';
+export { _Modal as Modal };
+import _ModalBody from './ModalBody';
+export { _ModalBody as ModalBody };
+import _ModalDialog from './ModalDialog';
+export { _ModalDialog as ModalDialog };
+import _ModalFooter from './ModalFooter';
+export { _ModalFooter as ModalFooter };
+import _ModalHeader from './ModalHeader';
+export { _ModalHeader as ModalHeader };
+import _ModalTitle from './ModalTitle';
+export { _ModalTitle as ModalTitle };
+import _Nav from './Nav';
+export { _Nav as Nav };
+import _Navbar from './Navbar';
+export { _Navbar as Navbar };
+import _NavbarBrand from './NavbarBrand';
+export { _NavbarBrand as NavbarBrand };
+import _NavDropdown from './NavDropdown';
+export { _NavDropdown as NavDropdown };
+import _NavItem from './NavItem';
+export { _NavItem as NavItem };
+import _Overlay from './Overlay';
+export { _Overlay as Overlay };
+import _OverlayTrigger from './OverlayTrigger';
+export { _OverlayTrigger as OverlayTrigger };
+import _PageHeader from './PageHeader';
+export { _PageHeader as PageHeader };
+import _PageItem from './PageItem';
+export { _PageItem as PageItem };
+import _Pager from './Pager';
+export { _Pager as Pager };
+import _Pagination from './Pagination';
+export { _Pagination as Pagination };
+import _Panel from './Panel';
+export { _Panel as Panel };
+import _PanelGroup from './PanelGroup';
+export { _PanelGroup as PanelGroup };
+import _Popover from './Popover';
+export { _Popover as Popover };
+import _ProgressBar from './ProgressBar';
+export { _ProgressBar as ProgressBar };
+import _Radio from './Radio';
+export { _Radio as Radio };
+import _ResponsiveEmbed from './ResponsiveEmbed';
+export { _ResponsiveEmbed as ResponsiveEmbed };
+import _Row from './Row';
+export { _Row as Row };
+import _SafeAnchor from './SafeAnchor';
+export { _SafeAnchor as SafeAnchor };
+import _SplitButton from './SplitButton';
+export { _SplitButton as SplitButton };
+import _Tab from './Tab';
+export { _Tab as Tab };
+import _TabContainer from './TabContainer';
+export { _TabContainer as TabContainer };
+import _TabContent from './TabContent';
+export { _TabContent as TabContent };
+import _Table from './Table';
+export { _Table as Table };
+import _TabPane from './TabPane';
+export { _TabPane as TabPane };
+import _Tabs from './Tabs';
+export { _Tabs as Tabs };
+import _Thumbnail from './Thumbnail';
+export { _Thumbnail as Thumbnail };
+import _ToggleButton from './ToggleButton';
+export { _ToggleButton as ToggleButton };
+import _ToggleButtonGroup from './ToggleButtonGroup';
+export { _ToggleButtonGroup as ToggleButtonGroup };
+import _Tooltip from './Tooltip';
+export { _Tooltip as Tooltip };
+import _Well from './Well';
+export { _Well as Well };
+import * as _utils from './utils';
+export { _utils as utils };

node_modules/react-bootstrap/es/utils/PropTypes.js

@@ -0,0 +1,75 @@
+import PropTypes from 'prop-types';
+import createChainableTypeChecker from 'prop-types-extra/lib/utils/createChainableTypeChecker';
+import ValidComponentChildren from './ValidComponentChildren';
+var idPropType = PropTypes.oneOfType([PropTypes.string, PropTypes.number]);
+export function generatedId(name) {
+  return function (props) {
+    var error = null;
+
+    if (!props.generateChildId) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      error = idPropType.apply(void 0, [props].concat(args));
+
+      if (!error && !props.id) {
+        error = new Error("In order to properly initialize the " + name + " in a way that is accessible to assistive technologies " + ("(such as screen readers) an `id` or a `generateChildId` prop to " + name + " is required"));
+      }
+    }
+
+    return error;
+  };
+}
+export function requiredRoles() {
+  for (var _len2 = arguments.length, roles = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    roles[_key2] = arguments[_key2];
+  }
+
+  return createChainableTypeChecker(function (props, propName, component) {
+    var missing;
+    roles.every(function (role) {
+      if (!ValidComponentChildren.some(props.children, function (child) {
+        return child.props.bsRole === role;
+      })) {
+        missing = role;
+        return false;
+      }
+
+      return true;
+    });
+
+    if (missing) {
+      return new Error("(children) " + component + " - Missing a required child with bsRole: " + (missing + ". " + component + " must have at least one child of each of ") + ("the following bsRoles: " + roles.join(', ')));
+    }
+
+    return null;
+  });
+}
+export function exclusiveRoles() {
+  for (var _len3 = arguments.length, roles = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+    roles[_key3] = arguments[_key3];
+  }
+
+  return createChainableTypeChecker(function (props, propName, component) {
+    var duplicate;
+    roles.every(function (role) {
+      var childrenWithRole = ValidComponentChildren.filter(props.children, function (child) {
+        return child.props.bsRole === role;
+      });
+
+      if (childrenWithRole.length > 1) {
+        duplicate = role;
+        return false;
+      }
+
+      return true;
+    });
+
+    if (duplicate) {
+      return new Error("(children) " + component + " - Duplicate children detected of bsRole: " + (duplicate + ". Only one child each allowed with the following ") + ("bsRoles: " + roles.join(', ')));
+    }
+
+    return null;
+  });
+}

node_modules/react-bootstrap/es/utils/StyleConfig.js

@@ -0,0 +1,28 @@
+export var Size = {
+  LARGE: 'large',
+  SMALL: 'small',
+  XSMALL: 'xsmall'
+};
+export var SIZE_MAP = {
+  large: 'lg',
+  medium: 'md',
+  small: 'sm',
+  xsmall: 'xs',
+  lg: 'lg',
+  md: 'md',
+  sm: 'sm',
+  xs: 'xs'
+};
+export var DEVICE_SIZES = ['lg', 'md', 'sm', 'xs'];
+export var State = {
+  SUCCESS: 'success',
+  WARNING: 'warning',
+  DANGER: 'danger',
+  INFO: 'info'
+};
+export var Style = {
+  DEFAULT: 'default',
+  PRIMARY: 'primary',
+  LINK: 'link',
+  INVERSE: 'inverse'
+};

node_modules/react-bootstrap/es/utils/ValidComponentChildren.js

@@ -0,0 +1,174 @@
+// TODO: This module should be ElementChildren, and should use named exports.
+import React from 'react';
+/**
+ * Iterates through children that are typically specified as `props.children`,
+ * but only maps over children that are "valid components".
+ *
+ * The mapFunction provided index will be normalised to the components mapped,
+ * so an invalid component would not increase the index.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} func.
+ * @param {*} context Context for func.
+ * @return {object} Object containing the ordered map of results.
+ */
+
+function map(children, func, context) {
+  var index = 0;
+  return React.Children.map(children, function (child) {
+    if (!React.isValidElement(child)) {
+      return child;
+    }
+
+    return func.call(context, child, index++);
+  });
+}
+/**
+ * Iterates through children that are "valid components".
+ *
+ * The provided forEachFunc(child, index) will be called for each
+ * leaf child with the index reflecting the position relative to "valid components".
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} func.
+ * @param {*} context Context for context.
+ */
+
+
+function forEach(children, func, context) {
+  var index = 0;
+  React.Children.forEach(children, function (child) {
+    if (!React.isValidElement(child)) {
+      return;
+    }
+
+    func.call(context, child, index++);
+  });
+}
+/**
+ * Count the number of "valid components" in the Children container.
+ *
+ * @param {?*} children Children tree container.
+ * @returns {number}
+ */
+
+
+function count(children) {
+  var result = 0;
+  React.Children.forEach(children, function (child) {
+    if (!React.isValidElement(child)) {
+      return;
+    }
+
+    ++result;
+  });
+  return result;
+}
+/**
+ * Finds children that are typically specified as `props.children`,
+ * but only iterates over children that are "valid components".
+ *
+ * The provided forEachFunc(child, index) will be called for each
+ * leaf child with the index reflecting the position relative to "valid components".
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} func.
+ * @param {*} context Context for func.
+ * @returns {array} of children that meet the func return statement
+ */
+
+
+function filter(children, func, context) {
+  var index = 0;
+  var result = [];
+  React.Children.forEach(children, function (child) {
+    if (!React.isValidElement(child)) {
+      return;
+    }
+
+    if (func.call(context, child, index++)) {
+      result.push(child);
+    }
+  });
+  return result;
+}
+
+function find(children, func, context) {
+  var index = 0;
+  var result;
+  React.Children.forEach(children, function (child) {
+    if (result) {
+      return;
+    }
+
+    if (!React.isValidElement(child)) {
+      return;
+    }
+
+    if (func.call(context, child, index++)) {
+      result = child;
+    }
+  });
+  return result;
+}
+
+function every(children, func, context) {
+  var index = 0;
+  var result = true;
+  React.Children.forEach(children, function (child) {
+    if (!result) {
+      return;
+    }
+
+    if (!React.isValidElement(child)) {
+      return;
+    }
+
+    if (!func.call(context, child, index++)) {
+      result = false;
+    }
+  });
+  return result;
+}
+
+function some(children, func, context) {
+  var index = 0;
+  var result = false;
+  React.Children.forEach(children, function (child) {
+    if (result) {
+      return;
+    }
+
+    if (!React.isValidElement(child)) {
+      return;
+    }
+
+    if (func.call(context, child, index++)) {
+      result = true;
+    }
+  });
+  return result;
+}
+
+function toArray(children) {
+  var result = [];
+  React.Children.forEach(children, function (child) {
+    if (!React.isValidElement(child)) {
+      return;
+    }
+
+    result.push(child);
+  });
+  return result;
+}
+
+export default {
+  map: map,
+  forEach: forEach,
+  count: count,
+  find: find,
+  filter: filter,
+  every: every,
+  some: some,
+  toArray: toArray
+};

node_modules/react-bootstrap/es/utils/bootstrapUtils.js

@@ -0,0 +1,181 @@
+import _Object$entries from "@babel/runtime-corejs2/core-js/object/entries";
+import _extends from "@babel/runtime-corejs2/helpers/esm/extends";
+// TODO: The publicly exposed parts of this should be in lib/BootstrapUtils.
+import invariant from 'invariant';
+import PropTypes from 'prop-types';
+import { SIZE_MAP } from './StyleConfig';
+
+function curry(fn) {
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    var last = args[args.length - 1];
+
+    if (typeof last === 'function') {
+      return fn.apply(void 0, args);
+    }
+
+    return function (Component) {
+      return fn.apply(void 0, args.concat([Component]));
+    };
+  };
+}
+
+export function prefix(props, variant) {
+  var bsClass = (props.bsClass || '').trim();
+  !(bsClass != null) ? process.env.NODE_ENV !== "production" ? invariant(false, 'A `bsClass` prop is required for this component') : invariant(false) : void 0;
+  return bsClass + (variant ? "-" + variant : '');
+}
+export var bsClass = curry(function (defaultClass, Component) {
+  var propTypes = Component.propTypes || (Component.propTypes = {});
+  var defaultProps = Component.defaultProps || (Component.defaultProps = {});
+  propTypes.bsClass = PropTypes.string;
+  defaultProps.bsClass = defaultClass;
+  return Component;
+});
+export var bsStyles = curry(function (styles, defaultStyle, Component) {
+  if (typeof defaultStyle !== 'string') {
+    Component = defaultStyle;
+    defaultStyle = undefined;
+  }
+
+  var existing = Component.STYLES || [];
+  var propTypes = Component.propTypes || {};
+  styles.forEach(function (style) {
+    if (existing.indexOf(style) === -1) {
+      existing.push(style);
+    }
+  });
+  var propType = PropTypes.oneOf(existing); // expose the values on the propType function for documentation
+
+  Component.STYLES = existing;
+  propType._values = existing;
+  Component.propTypes = _extends({}, propTypes, {
+    bsStyle: propType
+  });
+
+  if (defaultStyle !== undefined) {
+    var defaultProps = Component.defaultProps || (Component.defaultProps = {});
+    defaultProps.bsStyle = defaultStyle;
+  }
+
+  return Component;
+});
+export var bsSizes = curry(function (sizes, defaultSize, Component) {
+  if (typeof defaultSize !== 'string') {
+    Component = defaultSize;
+    defaultSize = undefined;
+  }
+
+  var existing = Component.SIZES || [];
+  var propTypes = Component.propTypes || {};
+  sizes.forEach(function (size) {
+    if (existing.indexOf(size) === -1) {
+      existing.push(size);
+    }
+  });
+  var values = [];
+  existing.forEach(function (size) {
+    var mappedSize = SIZE_MAP[size];
+
+    if (mappedSize && mappedSize !== size) {
+      values.push(mappedSize);
+    }
+
+    values.push(size);
+  });
+  var propType = PropTypes.oneOf(values);
+  propType._values = values; // expose the values on the propType function for documentation
+
+  Component.SIZES = existing;
+  Component.propTypes = _extends({}, propTypes, {
+    bsSize: propType
+  });
+
+  if (defaultSize !== undefined) {
+    if (!Component.defaultProps) {
+      Component.defaultProps = {};
+    }
+
+    Component.defaultProps.bsSize = defaultSize;
+  }
+
+  return Component;
+});
+export function getClassSet(props) {
+  var _classes;
+
+  var classes = (_classes = {}, _classes[prefix(props)] = true, _classes);
+
+  if (props.bsSize) {
+    var bsSize = SIZE_MAP[props.bsSize] || props.bsSize;
+    classes[prefix(props, bsSize)] = true;
+  }
+
+  if (props.bsStyle) {
+    classes[prefix(props, props.bsStyle)] = true;
+  }
+
+  return classes;
+}
+
+function getBsProps(props) {
+  return {
+    bsClass: props.bsClass,
+    bsSize: props.bsSize,
+    bsStyle: props.bsStyle,
+    bsRole: props.bsRole
+  };
+}
+
+function isBsProp(propName) {
+  return propName === 'bsClass' || propName === 'bsSize' || propName === 'bsStyle' || propName === 'bsRole';
+}
+
+export function splitBsProps(props) {
+  var elementProps = {};
+
+  _Object$entries(props).forEach(function (_ref) {
+    var propName = _ref[0],
+        propValue = _ref[1];
+
+    if (!isBsProp(propName)) {
+      elementProps[propName] = propValue;
+    }
+  });
+
+  return [getBsProps(props), elementProps];
+}
+export function splitBsPropsAndOmit(props, omittedPropNames) {
+  var isOmittedProp = {};
+  omittedPropNames.forEach(function (propName) {
+    isOmittedProp[propName] = true;
+  });
+  var elementProps = {};
+
+  _Object$entries(props).forEach(function (_ref2) {
+    var propName = _ref2[0],
+        propValue = _ref2[1];
+
+    if (!isBsProp(propName) && !isOmittedProp[propName]) {
+      elementProps[propName] = propValue;
+    }
+  });
+
+  return [getBsProps(props), elementProps];
+}
+/**
+ * Add a style variant to a Component. Mutates the propTypes of the component
+ * in order to validate the new variant.
+ */
+
+export function addStyle(Component) {
+  for (var _len2 = arguments.length, styleVariant = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+    styleVariant[_key2 - 1] = arguments[_key2];
+  }
+
+  bsStyles(styleVariant, Component);
+}
+export var _curry = curry;