inital commit

node_modules/reactstrap/esm/Accordion.js

@@ -0,0 +1,53 @@
+var _excluded = ["flush", "open", "toggle", "className", "cssModule", "tag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { useMemo } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import { AccordionContext } from './AccordionContext';
+var propTypes = {
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  /** Render accordions edge-to-edge with their parent container */
+  flush: PropTypes.bool,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  /** The current active key that corresponds to the currently expanded card */
+  open: PropTypes.oneOfType([PropTypes.array, PropTypes.string]).isRequired,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Function that's triggered on clicking `AccordionHeader` */
+  toggle: PropTypes.func.isRequired
+};
+function Accordion(props) {
+  var flush = props.flush,
+    open = props.open,
+    toggle = props.toggle,
+    className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'accordion', {
+    'accordion-flush': flush
+  }), cssModule);
+  var accordionContext = useMemo(function () {
+    return {
+      open: open,
+      toggle: toggle
+    };
+  });
+  return /*#__PURE__*/React.createElement(AccordionContext.Provider, {
+    value: accordionContext
+  }, /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  })));
+}
+Accordion.propTypes = propTypes;
+export default Accordion;

node_modules/reactstrap/esm/AccordionBody.js

@@ -0,0 +1,45 @@
+var _excluded = ["className", "cssModule", "tag", "innerRef", "children", "accordionId"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { useContext } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import Collapse from './Collapse';
+import { AccordionContext } from './AccordionContext';
+var propTypes = {
+  /** Unique key used to control item's collapse/expand */
+  accordionId: PropTypes.string.isRequired,
+  /** To add custom class */
+  className: PropTypes.string,
+  children: PropTypes.node,
+  /** Change existing base class name with a new class name */
+  cssModule: PropTypes.object,
+  /** Pass ref to the component */
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function AccordionBody(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    innerRef = props.innerRef,
+    children = props.children,
+    accordionId = props.accordionId,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var _useContext = useContext(AccordionContext),
+    open = _useContext.open;
+  var classes = mapToCssModules(classNames(className, 'accordion-collapse'), cssModule);
+  return /*#__PURE__*/React.createElement(Collapse, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef,
+    isOpen: Array.isArray(open) ? open.includes(accordionId) : open === accordionId
+  }), /*#__PURE__*/React.createElement(Tag, {
+    className: "accordion-body"
+  }, children));
+}
+AccordionBody.propTypes = propTypes;
+export default AccordionBody;

node_modules/reactstrap/esm/AccordionContext.js

@@ -0,0 +1,10 @@
+import React from 'react';
+
+/**
+ * AccordionContext
+ * {
+ *  toggle: PropTypes.func.isRequired,
+ *  openId: PropTypes.string,
+ * }
+ */
+export var AccordionContext = /*#__PURE__*/React.createContext({});

node_modules/reactstrap/esm/AccordionHeader.js

@@ -0,0 +1,50 @@
+var _excluded = ["className", "cssModule", "tag", "innerRef", "children", "targetId"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { useContext } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import { AccordionContext } from './AccordionContext';
+var propTypes = {
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change existing base class name with a new class name */
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Unique key used to control item's collapse/expand */
+  targetId: PropTypes.string.isRequired
+};
+function AccordionHeader(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'h2' : _props$tag,
+    innerRef = props.innerRef,
+    children = props.children,
+    targetId = props.targetId,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var _useContext = useContext(AccordionContext),
+    open = _useContext.open,
+    toggle = _useContext.toggle;
+  var classes = mapToCssModules(classNames(className, 'accordion-header'), cssModule);
+  var buttonClasses = mapToCssModules(classNames('accordion-button', {
+    collapsed: !(Array.isArray(open) ? open.includes(targetId) : open === targetId)
+  }), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: buttonClasses,
+    onClick: function onClick() {
+      return toggle(targetId);
+    }
+  }, children));
+}
+AccordionHeader.propTypes = propTypes;
+export default AccordionHeader;

node_modules/reactstrap/esm/AccordionItem.js

@@ -0,0 +1,33 @@
+var _excluded = ["className", "cssModule", "tag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  /** To add custom class */
+  className: PropTypes.string,
+  /** Change existing base class name with a new class name */
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function AccordionItem(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'accordion-item'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }));
+}
+AccordionItem.propTypes = propTypes;
+export default AccordionItem;

node_modules/reactstrap/esm/Alert.js

@@ -0,0 +1,82 @@
+var _excluded = ["className", "closeClassName", "closeAriaLabel", "cssModule", "tag", "color", "isOpen", "toggle", "children", "transition", "fade", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import Fade from './Fade';
+var propTypes = {
+  /** Pass children so this component can wrap the child elements */
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Add custom class for close button */
+  closeClassName: PropTypes.string,
+  /** Aria label for close button */
+  closeAriaLabel: PropTypes.string,
+  /** Change color of alert */
+  color: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  /** Toggle fade animation */
+  fade: PropTypes.bool,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  /** Control visibility state of Alert */
+  isOpen: PropTypes.bool,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Function to toggle visibility */
+  toggle: PropTypes.func,
+  /** Props to be passed to `Fade` to modify transition */
+  transition: PropTypes.shape(Fade.propTypes)
+};
+function Alert(props) {
+  var className = props.className,
+    closeClassName = props.closeClassName,
+    _props$closeAriaLabel = props.closeAriaLabel,
+    closeAriaLabel = _props$closeAriaLabel === void 0 ? 'Close' : _props$closeAriaLabel,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    _props$color = props.color,
+    color = _props$color === void 0 ? 'success' : _props$color,
+    _props$isOpen = props.isOpen,
+    isOpen = _props$isOpen === void 0 ? true : _props$isOpen,
+    toggle = props.toggle,
+    children = props.children,
+    _props$transition = props.transition,
+    transition = _props$transition === void 0 ? _objectSpread(_objectSpread({}, Fade.defaultProps), {}, {
+      unmountOnExit: true
+    }) : _props$transition,
+    _props$fade = props.fade,
+    fade = _props$fade === void 0 ? true : _props$fade,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'alert', "alert-".concat(color), {
+    'alert-dismissible': toggle
+  }), cssModule);
+  var closeClasses = mapToCssModules(classNames('btn-close', closeClassName), cssModule);
+  var alertTransition = _objectSpread(_objectSpread(_objectSpread({}, Fade.defaultProps), transition), {}, {
+    baseClass: fade ? transition.baseClass : '',
+    timeout: fade ? transition.timeout : 0
+  });
+  return /*#__PURE__*/React.createElement(Fade, _extends({}, attributes, alertTransition, {
+    tag: Tag,
+    className: classes,
+    "in": isOpen,
+    role: "alert",
+    innerRef: innerRef
+  }), toggle ? /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    className: closeClasses,
+    "aria-label": closeAriaLabel,
+    onClick: toggle
+  }) : null, children);
+}
+Alert.propTypes = propTypes;
+export default Alert;

node_modules/reactstrap/esm/Badge.js

@@ -0,0 +1,45 @@
+var _excluded = ["className", "cssModule", "color", "innerRef", "pill", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Pass children so this component can wrap the child elements */
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change background color of Badge */
+  color: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  /** Add rounded corners to the Badge */
+  pill: PropTypes.bool,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function Badge(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$color = props.color,
+    color = _props$color === void 0 ? 'secondary' : _props$color,
+    innerRef = props.innerRef,
+    _props$pill = props.pill,
+    pill = _props$pill === void 0 ? false : _props$pill,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'span' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'badge', 'bg-' + color, pill ? 'rounded-pill' : false), cssModule);
+  if (attributes.href && Tag === 'span') {
+    Tag = 'a';
+  }
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }));
+}
+Badge.propTypes = propTypes;
+export default Badge;

node_modules/reactstrap/esm/Breadcrumb.js

@@ -0,0 +1,47 @@
+var _excluded = ["className", "listClassName", "cssModule", "children", "tag", "listTag", "aria-label"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Aria label */
+  'aria-label': PropTypes.string,
+  /** Pass children so this component can wrap them */
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  /** Add custom class to list tag */
+  listClassName: PropTypes.string,
+  /** Set a custom element for list tag */
+  listTag: tagPropType,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function Breadcrumb(props) {
+  var className = props.className,
+    listClassName = props.listClassName,
+    cssModule = props.cssModule,
+    children = props.children,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'nav' : _props$tag,
+    _props$listTag = props.listTag,
+    ListTag = _props$listTag === void 0 ? 'ol' : _props$listTag,
+    _props$ariaLabel = props['aria-label'],
+    label = _props$ariaLabel === void 0 ? 'breadcrumb' : _props$ariaLabel,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className), cssModule);
+  var listClasses = mapToCssModules(classNames('breadcrumb', listClassName), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    "aria-label": label
+  }), /*#__PURE__*/React.createElement(ListTag, {
+    className: listClasses
+  }, children));
+}
+Breadcrumb.propTypes = propTypes;
+export default Breadcrumb;

node_modules/reactstrap/esm/BreadcrumbItem.js

@@ -0,0 +1,33 @@
+var _excluded = ["className", "cssModule", "active", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Adds a visual "active" state to a Breadcrumb Item */
+  active: PropTypes.bool,
+  /** Add custom class to the element */
+  className: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function BreadcrumbItem(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    active = props.active,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'li' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, active ? 'active' : false, 'breadcrumb-item'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    "aria-current": active ? 'page' : undefined
+  }));
+}
+BreadcrumbItem.propTypes = propTypes;
+export default BreadcrumbItem;

node_modules/reactstrap/esm/Button.js

@@ -0,0 +1,83 @@
+var _excluded = ["active", "aria-label", "block", "className", "close", "cssModule", "color", "outline", "size", "tag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { useCallback } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import CloseButton from './CloseButton';
+var propTypes = {
+  /** Manually set the visual state of the button to active */
+  active: PropTypes.bool,
+  /** Aria label */
+  'aria-label': PropTypes.string,
+  block: PropTypes.bool,
+  /** Pass children so this component can wrap them */
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  /** Use the button as a close button */
+  close: PropTypes.bool,
+  /** Change color of Button to one of the available colors */
+  color: PropTypes.string,
+  /** Disables the button */
+  disabled: PropTypes.bool,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  /** Function to be triggered on click */
+  onClick: PropTypes.func,
+  /** Adds outline to the button */
+  outline: PropTypes.bool,
+  /** Make the button bigger or smaller */
+  size: PropTypes.string,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function Button(props) {
+  var onClick = useCallback(function (e) {
+    if (props.disabled) {
+      e.preventDefault();
+      return;
+    }
+    if (props.onClick) {
+      return props.onClick(e);
+    }
+  }, [props.onClick, props.disabled]);
+  var active = props.active,
+    ariaLabel = props['aria-label'],
+    block = props.block,
+    className = props.className,
+    close = props.close,
+    cssModule = props.cssModule,
+    _props$color = props.color,
+    color = _props$color === void 0 ? 'secondary' : _props$color,
+    outline = props.outline,
+    size = props.size,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'button' : _props$tag,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  if (close) {
+    return /*#__PURE__*/React.createElement(CloseButton, attributes);
+  }
+  var btnOutlineColor = "btn".concat(outline ? '-outline' : '', "-").concat(color);
+  var classes = mapToCssModules(classNames(className, 'btn', btnOutlineColor, size ? "btn-".concat(size) : false, block ? 'd-block w-100' : false, {
+    active: active,
+    disabled: props.disabled
+  }), cssModule);
+  if (attributes.href && Tag === 'button') {
+    Tag = 'a';
+  }
+  return /*#__PURE__*/React.createElement(Tag, _extends({
+    type: Tag === 'button' && attributes.onClick ? 'button' : undefined
+  }, attributes, {
+    className: classes,
+    ref: innerRef,
+    onClick: onClick,
+    "aria-label": ariaLabel
+  }));
+}
+Button.propTypes = propTypes;
+export default Button;

node_modules/reactstrap/esm/ButtonDropdown.js

@@ -0,0 +1,14 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import Dropdown from './Dropdown';
+var propTypes = {
+  children: PropTypes.node
+};
+function ButtonDropdown(props) {
+  return /*#__PURE__*/React.createElement(Dropdown, _extends({
+    group: true
+  }, props));
+}
+ButtonDropdown.propTypes = propTypes;
+export default ButtonDropdown;

node_modules/reactstrap/esm/ButtonGroup.js

@@ -0,0 +1,44 @@
+var _excluded = ["className", "cssModule", "size", "vertical", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Aria label */
+  'aria-label': PropTypes.string,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** In order for assistive technologies (such as screen readers) to convey that a series of buttons is grouped, an appropriate role attribute needs to be provided. For button groups, this would be role="group", while toolbars should have a role="toolbar". */
+  role: PropTypes.string,
+  /** Make the button bigger or smaller */
+  size: PropTypes.string,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Make button group vertical */
+  vertical: PropTypes.bool
+};
+function ButtonGroup(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    size = props.size,
+    vertical = props.vertical,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, size ? 'btn-group-' + size : false, vertical ? 'btn-group-vertical' : 'btn-group'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, _objectSpread({
+    role: 'group'
+  }, attributes), {
+    className: classes
+  }));
+}
+ButtonGroup.propTypes = propTypes;
+export default ButtonGroup;

node_modules/reactstrap/esm/ButtonToggle.js

@@ -0,0 +1,66 @@
+var _excluded = ["className"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import React, { useCallback, useState } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Button from './Button';
+import { mapToCssModules } from './utils';
+var propTypes = {
+  onClick: PropTypes.func,
+  onBlur: PropTypes.func,
+  onFocus: PropTypes.func,
+  defaultValue: PropTypes.bool,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function ButtonToggle(props) {
+  var _props$defaultValue;
+  var _useState = useState((_props$defaultValue = props.defaultValue) !== null && _props$defaultValue !== void 0 ? _props$defaultValue : false),
+    _useState2 = _slicedToArray(_useState, 2),
+    toggled = _useState2[0],
+    setToggled = _useState2[1];
+  var _useState3 = useState(false),
+    _useState4 = _slicedToArray(_useState3, 2),
+    focus = _useState4[0],
+    setFocus = _useState4[1];
+  var onBlur = useCallback(function (e) {
+    if (props.onBlur) {
+      props.onBlur(e);
+    }
+    setFocus(false);
+  }, [props.onBlur]);
+  var onFocus = useCallback(function (e) {
+    if (props.onFocus) {
+      props.onFocus(e);
+    }
+    setFocus(true);
+  }, [props.onFocus]);
+  var onClick = useCallback(function (e) {
+    if (props.onClick) {
+      props.onClick(e);
+    }
+    setToggled(!toggled);
+  }, [props.onClick]);
+  var className = props.className,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, {
+    focus: focus
+  }), props.cssModule);
+  return /*#__PURE__*/React.createElement(Button, _extends({
+    active: toggled,
+    onBlur: onBlur,
+    onFocus: onFocus,
+    onClick: onClick,
+    className: classes
+  }, attributes));
+}
+ButtonToggle.propTypes = propTypes;
+export default ButtonToggle;

node_modules/reactstrap/esm/ButtonToolbar.js

@@ -0,0 +1,38 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Aria label */
+  'aria-label': PropTypes.string,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  /** In order for assistive technologies (such as screen readers) to convey that a series of buttons is grouped, an appropriate role attribute needs to be provided. For button groups, this would be role="group", while toolbars should have a role="toolbar". */
+  role: PropTypes.string,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function ButtonToolbar(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'btn-toolbar'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, _objectSpread({
+    role: 'toolbar'
+  }, attributes), {
+    className: classes
+  }));
+}
+ButtonToolbar.propTypes = propTypes;
+export default ButtonToolbar;

node_modules/reactstrap/esm/Card.js

@@ -0,0 +1,44 @@
+var _excluded = ["className", "cssModule", "color", "body", "inverse", "outline", "tag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Toggles card padding using `.card-body` */
+  body: PropTypes.bool,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change background color of component */
+  color: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  /** Inverts the color */
+  inverse: PropTypes.bool,
+  /** Changes the card to have only outline */
+  outline: PropTypes.bool,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function Card(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    color = props.color,
+    body = props.body,
+    inverse = props.inverse,
+    outline = props.outline,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card', inverse ? 'text-white' : false, body ? 'card-body' : false, color ? "".concat(outline ? 'border' : 'bg', "-").concat(color) : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }));
+}
+Card.propTypes = propTypes;
+export default Card;

node_modules/reactstrap/esm/CardBody.js

@@ -0,0 +1,32 @@
+var _excluded = ["className", "cssModule", "innerRef", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function CardBody(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    innerRef = props.innerRef,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-body'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }));
+}
+CardBody.propTypes = propTypes;
+export default CardBody;

node_modules/reactstrap/esm/CardColumns.js

@@ -0,0 +1,26 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function CardColumns(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-columns'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardColumns.propTypes = propTypes;
+export default CardColumns;

node_modules/reactstrap/esm/CardDeck.js

@@ -0,0 +1,26 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function CardDeck(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-deck'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardDeck.propTypes = propTypes;
+export default CardDeck;

node_modules/reactstrap/esm/CardFooter.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function CardFooter(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-footer'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardFooter.propTypes = propTypes;
+export default CardFooter;

node_modules/reactstrap/esm/CardGroup.js

@@ -0,0 +1,26 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function CardGroup(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-group'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardGroup.propTypes = propTypes;
+export default CardGroup;

node_modules/reactstrap/esm/CardHeader.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function CardHeader(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-header'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardHeader.propTypes = propTypes;
+export default CardHeader;

node_modules/reactstrap/esm/CardImg.js

@@ -0,0 +1,42 @@
+var _excluded = ["className", "cssModule", "top", "bottom", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add `bottom` prop if image is at bottom of card */
+  bottom: PropTypes.bool,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Add `top` prop if image is at top of card */
+  top: PropTypes.bool
+};
+function CardImg(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    top = props.top,
+    bottom = props.bottom,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'img' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var cardImgClassName = 'card-img';
+  if (top) {
+    cardImgClassName = 'card-img-top';
+  }
+  if (bottom) {
+    cardImgClassName = 'card-img-bottom';
+  }
+  var classes = mapToCssModules(classNames(className, cardImgClassName), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardImg.propTypes = propTypes;
+export default CardImg;

node_modules/reactstrap/esm/CardImgOverlay.js

@@ -0,0 +1,26 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function CardImgOverlay(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-img-overlay'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardImgOverlay.propTypes = propTypes;
+export default CardImgOverlay;

node_modules/reactstrap/esm/CardLink.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function CardLink(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'a' : _props$tag,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-link'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    ref: innerRef,
+    className: classes
+  }));
+}
+CardLink.propTypes = propTypes;
+export default CardLink;

node_modules/reactstrap/esm/CardSubtitle.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function CardSubtitle(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-subtitle'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardSubtitle.propTypes = propTypes;
+export default CardSubtitle;

node_modules/reactstrap/esm/CardText.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function CardText(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'p' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-text'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardText.propTypes = propTypes;
+export default CardText;

node_modules/reactstrap/esm/CardTitle.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function CardTitle(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'card-title'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+CardTitle.propTypes = propTypes;
+export default CardTitle;

node_modules/reactstrap/esm/Carousel.js

@@ -0,0 +1,334 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import CarouselItem from './CarouselItem';
+import { CarouselContext } from './CarouselContext';
+import { mapToCssModules, omit } from './utils';
+var SWIPE_THRESHOLD = 40;
+var propTypes = {
+  /** the current active slide of the carousel */
+  activeIndex: PropTypes.number,
+  /** a function which should advance the carousel to the next slide (via activeIndex) */
+  next: PropTypes.func.isRequired,
+  /** a function which should advance the carousel to the previous slide (via activeIndex) */
+  previous: PropTypes.func.isRequired,
+  /** controls if the left and right arrow keys should control the carousel */
+  keyboard: PropTypes.bool,
+  /** If set to "hover", pauses the cycling of the carousel on mouseenter and resumes the cycling of the carousel on
+   * mouseleave. If set to false, hovering over the carousel won't pause it.
+   */
+  pause: PropTypes.oneOf(['hover', false]),
+  /** Autoplays the carousel after the user manually cycles the first item. If "carousel", autoplays the carousel on load. */
+  ride: PropTypes.oneOf(['carousel']),
+  /** the interval at which the carousel automatically cycles */
+  interval: PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.bool]),
+  children: PropTypes.array,
+  /** called when the mouse enters the Carousel */
+  mouseEnter: PropTypes.func,
+  /** called when the mouse exits the Carousel */
+  mouseLeave: PropTypes.func,
+  /** controls whether the slide animation on the Carousel works or not */
+  slide: PropTypes.bool,
+  /** make the controls, indicators and captions dark on the Carousel */
+  dark: PropTypes.bool,
+  fade: PropTypes.bool,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Enable touch support */
+  enableTouch: PropTypes.bool
+};
+var propsToOmit = Object.keys(propTypes);
+var defaultProps = {
+  interval: 5000,
+  pause: 'hover',
+  keyboard: true,
+  slide: true,
+  enableTouch: true,
+  fade: false
+};
+var Carousel = /*#__PURE__*/function (_React$Component) {
+  _inherits(Carousel, _React$Component);
+  var _super = _createSuper(Carousel);
+  function Carousel(props) {
+    var _this;
+    _classCallCheck(this, Carousel);
+    _this = _super.call(this, props);
+    _this.handleKeyPress = _this.handleKeyPress.bind(_assertThisInitialized(_this));
+    _this.renderItems = _this.renderItems.bind(_assertThisInitialized(_this));
+    _this.hoverStart = _this.hoverStart.bind(_assertThisInitialized(_this));
+    _this.hoverEnd = _this.hoverEnd.bind(_assertThisInitialized(_this));
+    _this.handleTouchStart = _this.handleTouchStart.bind(_assertThisInitialized(_this));
+    _this.handleTouchEnd = _this.handleTouchEnd.bind(_assertThisInitialized(_this));
+    _this.touchStartX = 0;
+    _this.touchStartY = 0;
+    _this.state = {
+      activeIndex: _this.props.activeIndex,
+      direction: 'end',
+      indicatorClicked: false
+    };
+    return _this;
+  }
+  _createClass(Carousel, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      // Set up the cycle
+      if (this.props.ride === 'carousel') {
+        this.setInterval();
+      }
+
+      // TODO: move this to the specific carousel like bootstrap. Currently it will trigger ALL carousels on the page.
+      document.addEventListener('keyup', this.handleKeyPress);
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      if (prevState.activeIndex === this.state.activeIndex) return;
+      this.setInterval();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.clearInterval();
+      document.removeEventListener('keyup', this.handleKeyPress);
+    }
+  }, {
+    key: "handleKeyPress",
+    value: function handleKeyPress(evt) {
+      if (this.props.keyboard) {
+        if (evt.keyCode === 37) {
+          this.props.previous();
+        } else if (evt.keyCode === 39) {
+          this.props.next();
+        }
+      }
+    }
+  }, {
+    key: "handleTouchStart",
+    value: function handleTouchStart(e) {
+      if (!this.props.enableTouch) {
+        return;
+      }
+      this.touchStartX = e.changedTouches[0].screenX;
+      this.touchStartY = e.changedTouches[0].screenY;
+    }
+  }, {
+    key: "handleTouchEnd",
+    value: function handleTouchEnd(e) {
+      if (!this.props.enableTouch) {
+        return;
+      }
+      var currentX = e.changedTouches[0].screenX;
+      var currentY = e.changedTouches[0].screenY;
+      var diffX = Math.abs(this.touchStartX - currentX);
+      var diffY = Math.abs(this.touchStartY - currentY);
+
+      // Don't swipe if Y-movement is bigger than X-movement
+      if (diffX < diffY) {
+        return;
+      }
+      if (diffX < SWIPE_THRESHOLD) {
+        return;
+      }
+      if (currentX < this.touchStartX) {
+        this.props.next();
+      } else {
+        this.props.previous();
+      }
+    }
+  }, {
+    key: "getContextValue",
+    value: function getContextValue() {
+      return {
+        direction: this.state.direction
+      };
+    }
+  }, {
+    key: "setInterval",
+    value: function (_setInterval) {
+      function setInterval() {
+        return _setInterval.apply(this, arguments);
+      }
+      setInterval.toString = function () {
+        return _setInterval.toString();
+      };
+      return setInterval;
+    }(function () {
+      var _this2 = this;
+      // make sure not to have multiple intervals going...
+      this.clearInterval();
+      if (this.props.interval) {
+        this.cycleInterval = setInterval(function () {
+          _this2.props.next();
+        }, parseInt(this.props.interval, 10));
+      }
+    })
+  }, {
+    key: "clearInterval",
+    value: function (_clearInterval) {
+      function clearInterval() {
+        return _clearInterval.apply(this, arguments);
+      }
+      clearInterval.toString = function () {
+        return _clearInterval.toString();
+      };
+      return clearInterval;
+    }(function () {
+      clearInterval(this.cycleInterval);
+    })
+  }, {
+    key: "hoverStart",
+    value: function hoverStart() {
+      if (this.props.pause === 'hover') {
+        this.clearInterval();
+      }
+      if (this.props.mouseEnter) {
+        var _this$props;
+        (_this$props = this.props).mouseEnter.apply(_this$props, arguments);
+      }
+    }
+  }, {
+    key: "hoverEnd",
+    value: function hoverEnd() {
+      if (this.props.pause === 'hover') {
+        this.setInterval();
+      }
+      if (this.props.mouseLeave) {
+        var _this$props2;
+        (_this$props2 = this.props).mouseLeave.apply(_this$props2, arguments);
+      }
+    }
+  }, {
+    key: "renderItems",
+    value: function renderItems(carouselItems, className) {
+      var _this3 = this;
+      var slide = this.props.slide;
+      return /*#__PURE__*/React.createElement("div", {
+        className: className
+      }, carouselItems.map(function (item, index) {
+        var isIn = index === _this3.state.activeIndex;
+        return /*#__PURE__*/React.cloneElement(item, {
+          "in": isIn,
+          slide: slide
+        });
+      }));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this4 = this;
+      var _this$props3 = this.props,
+        cssModule = _this$props3.cssModule,
+        slide = _this$props3.slide,
+        className = _this$props3.className,
+        dark = _this$props3.dark,
+        fade = _this$props3.fade;
+      var attributes = omit(this.props, propsToOmit);
+      var outerClasses = mapToCssModules(classNames(className, 'carousel', fade && 'carousel-fade', slide && 'slide', dark && 'carousel-dark'), cssModule);
+      var innerClasses = mapToCssModules(classNames('carousel-inner'), cssModule);
+
+      // filter out booleans, null, or undefined
+      var children = this.props.children.filter(function (child) {
+        return child !== null && child !== undefined && typeof child !== 'boolean';
+      });
+      var slidesOnly = children.every(function (child) {
+        return child.type === CarouselItem;
+      });
+
+      // Rendering only slides
+      if (slidesOnly) {
+        return /*#__PURE__*/React.createElement("div", _extends({}, attributes, {
+          className: outerClasses,
+          onMouseEnter: this.hoverStart,
+          onMouseLeave: this.hoverEnd
+        }), /*#__PURE__*/React.createElement(CarouselContext.Provider, {
+          value: this.getContextValue()
+        }, this.renderItems(children, innerClasses)));
+      }
+
+      // Rendering slides and controls
+      if (children[0] instanceof Array) {
+        var _carouselItems = children[0];
+        var _controlLeft = children[1];
+        var _controlRight = children[2];
+        return /*#__PURE__*/React.createElement("div", _extends({}, attributes, {
+          className: outerClasses,
+          onMouseEnter: this.hoverStart,
+          onMouseLeave: this.hoverEnd
+        }), /*#__PURE__*/React.createElement(CarouselContext.Provider, {
+          value: this.getContextValue()
+        }, this.renderItems(_carouselItems, innerClasses), _controlLeft, _controlRight));
+      }
+
+      // Rendering indicators, slides and controls
+      var indicators = children[0];
+      var wrappedOnClick = function wrappedOnClick(e) {
+        if (typeof indicators.props.onClickHandler === 'function') {
+          _this4.setState({
+            indicatorClicked: true
+          }, function () {
+            return indicators.props.onClickHandler(e);
+          });
+        }
+      };
+      var wrappedIndicators = /*#__PURE__*/React.cloneElement(indicators, {
+        onClickHandler: wrappedOnClick
+      });
+      var carouselItems = children[1];
+      var controlLeft = children[2];
+      var controlRight = children[3];
+      return /*#__PURE__*/React.createElement("div", _extends({}, attributes, {
+        className: outerClasses,
+        onMouseEnter: this.hoverStart,
+        onMouseLeave: this.hoverEnd,
+        onTouchStart: this.handleTouchStart,
+        onTouchEnd: this.handleTouchEnd
+      }), /*#__PURE__*/React.createElement(CarouselContext.Provider, {
+        value: this.getContextValue()
+      }, wrappedIndicators, this.renderItems(carouselItems, innerClasses), controlLeft, controlRight));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      var newState = null;
+      var activeIndex = prevState.activeIndex,
+        direction = prevState.direction,
+        indicatorClicked = prevState.indicatorClicked;
+      if (nextProps.activeIndex !== activeIndex) {
+        // Calculate the direction to turn
+        if (nextProps.activeIndex === activeIndex + 1) {
+          direction = 'end';
+        } else if (nextProps.activeIndex === activeIndex - 1) {
+          direction = 'start';
+        } else if (nextProps.activeIndex < activeIndex) {
+          direction = indicatorClicked ? 'start' : 'end';
+        } else if (nextProps.activeIndex !== activeIndex) {
+          direction = indicatorClicked ? 'end' : 'start';
+        }
+        newState = {
+          activeIndex: nextProps.activeIndex,
+          direction: direction,
+          indicatorClicked: false
+        };
+      }
+      return newState;
+    }
+  }]);
+  return Carousel;
+}(React.Component);
+Carousel.propTypes = propTypes;
+Carousel.defaultProps = defaultProps;
+export default Carousel;

node_modules/reactstrap/esm/CarouselCaption.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+function CarouselCaption(props) {
+  var captionHeader = props.captionHeader,
+    captionText = props.captionText,
+    cssModule = props.cssModule,
+    className = props.className;
+  var classes = mapToCssModules(classNames(className, 'carousel-caption', 'd-none', 'd-md-block'), cssModule);
+  return /*#__PURE__*/React.createElement("div", {
+    className: classes
+  }, /*#__PURE__*/React.createElement("h3", null, captionHeader), /*#__PURE__*/React.createElement("p", null, captionText));
+}
+CarouselCaption.propTypes = {
+  /** Heading for the caption */
+  captionHeader: PropTypes.node,
+  /** Text for caption */
+  captionText: PropTypes.node.isRequired,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object
+};
+export default CarouselCaption;

node_modules/reactstrap/esm/CarouselContext.js

@@ -0,0 +1,9 @@
+import React from 'react';
+
+/**
+ * CarouselContext
+ * {
+ *  direction: PropTypes.oneOf(['start', 'end']).isRequired,
+ * }
+ */
+export var CarouselContext = /*#__PURE__*/React.createContext({});

node_modules/reactstrap/esm/CarouselControl.js

@@ -0,0 +1,56 @@
+var _excluded = ["direction", "onClickHandler", "cssModule", "directionText", "className"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+function CarouselControl(props) {
+  var direction = props.direction,
+    onClickHandler = props.onClickHandler,
+    cssModule = props.cssModule,
+    directionText = props.directionText,
+    className = props.className,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var anchorClasses = mapToCssModules(classNames(className, "carousel-control-".concat(direction)), cssModule);
+  var iconClasses = mapToCssModules(classNames("carousel-control-".concat(direction, "-icon")), cssModule);
+  var screenReaderClasses = mapToCssModules(classNames('visually-hidden'), cssModule);
+  return (
+    /*#__PURE__*/
+    // We need to disable this linting rule to use an `<a>` instead of
+    // `<button>` because that's what the Bootstrap examples require:
+    // https://getbootstrap.com/docs/4.5/components/carousel/#with-controls
+    // eslint-disable-next-line jsx-a11y/anchor-is-valid
+    React.createElement("a", _extends({}, attributes, {
+      className: anchorClasses,
+      style: {
+        cursor: 'pointer'
+      },
+      role: "button",
+      tabIndex: "0",
+      onClick: function onClick(e) {
+        e.preventDefault();
+        onClickHandler();
+      }
+    }), /*#__PURE__*/React.createElement("span", {
+      className: iconClasses,
+      "aria-hidden": "true"
+    }), /*#__PURE__*/React.createElement("span", {
+      className: screenReaderClasses
+    }, directionText || direction))
+  );
+}
+CarouselControl.propTypes = {
+  /** Set the direction of control button */
+  direction: PropTypes.oneOf(['prev', 'next']).isRequired,
+  /** Function to be triggered on click */
+  onClickHandler: PropTypes.func.isRequired,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Screen reader text */
+  directionText: PropTypes.string,
+  /** Add custom class */
+  className: PropTypes.string
+};
+export default CarouselControl;

node_modules/reactstrap/esm/CarouselIndicators.js

@@ -0,0 +1,49 @@
+var _excluded = ["items", "activeIndex", "cssModule", "onClickHandler", "className"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+function CarouselIndicators(props) {
+  var items = props.items,
+    activeIndex = props.activeIndex,
+    cssModule = props.cssModule,
+    onClickHandler = props.onClickHandler,
+    className = props.className,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var listClasses = mapToCssModules(classNames(className, 'carousel-indicators'), cssModule);
+  var indicators = items.map(function (item, idx) {
+    var indicatorClasses = mapToCssModules(classNames({
+      active: activeIndex === idx
+    }), cssModule);
+    return /*#__PURE__*/React.createElement("button", {
+      "aria-label": item.caption,
+      "data-bs-target": true,
+      type: "button",
+      key: "".concat(item.key || Object.values(item).join('')),
+      onClick: function onClick(e) {
+        e.preventDefault();
+        onClickHandler(idx);
+      },
+      className: indicatorClasses
+    });
+  });
+  return /*#__PURE__*/React.createElement("div", _extends({
+    className: listClasses
+  }, attributes), indicators);
+}
+CarouselIndicators.propTypes = {
+  /** The current active index */
+  activeIndex: PropTypes.number.isRequired,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Array of items to show */
+  items: PropTypes.array.isRequired,
+  /** Function to be triggered on click */
+  onClickHandler: PropTypes.func.isRequired
+};
+export default CarouselIndicators;

node_modules/reactstrap/esm/CarouselItem.js

@@ -0,0 +1,137 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["in", "children", "cssModule", "slide", "tag", "className"];
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Transition } from 'react-transition-group';
+import { CarouselContext } from './CarouselContext';
+import { mapToCssModules, TransitionTimeouts, TransitionStatuses, tagPropType } from './utils';
+var CarouselItem = /*#__PURE__*/function (_React$Component) {
+  _inherits(CarouselItem, _React$Component);
+  var _super = _createSuper(CarouselItem);
+  function CarouselItem(props) {
+    var _this;
+    _classCallCheck(this, CarouselItem);
+    _this = _super.call(this, props);
+    _this.state = {
+      startAnimation: false
+    };
+    _this.onEnter = _this.onEnter.bind(_assertThisInitialized(_this));
+    _this.onEntering = _this.onEntering.bind(_assertThisInitialized(_this));
+    _this.onExit = _this.onExit.bind(_assertThisInitialized(_this));
+    _this.onExiting = _this.onExiting.bind(_assertThisInitialized(_this));
+    _this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(CarouselItem, [{
+    key: "onEnter",
+    value: function onEnter(node, isAppearing) {
+      this.setState({
+        startAnimation: false
+      });
+      this.props.onEnter(node, isAppearing);
+    }
+  }, {
+    key: "onEntering",
+    value: function onEntering(node, isAppearing) {
+      // getting this variable triggers a reflow
+      var offsetHeight = node.offsetHeight;
+      this.setState({
+        startAnimation: true
+      });
+      this.props.onEntering(node, isAppearing);
+      return offsetHeight;
+    }
+  }, {
+    key: "onExit",
+    value: function onExit(node) {
+      this.setState({
+        startAnimation: false
+      });
+      this.props.onExit(node);
+    }
+  }, {
+    key: "onExiting",
+    value: function onExiting(node) {
+      this.setState({
+        startAnimation: true
+      });
+      node.dispatchEvent(new CustomEvent('slide.bs.carousel'));
+      this.props.onExiting(node);
+    }
+  }, {
+    key: "onExited",
+    value: function onExited(node) {
+      node.dispatchEvent(new CustomEvent('slid.bs.carousel'));
+      this.props.onExited(node);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props = this.props,
+        isIn = _this$props["in"],
+        children = _this$props.children,
+        cssModule = _this$props.cssModule,
+        _this$props$slide = _this$props.slide,
+        slide = _this$props$slide === void 0 ? true : _this$props$slide,
+        _this$props$tag = _this$props.tag,
+        Tag = _this$props$tag === void 0 ? 'div' : _this$props$tag,
+        className = _this$props.className,
+        transitionProps = _objectWithoutProperties(_this$props, _excluded);
+      return /*#__PURE__*/React.createElement(Transition, _extends({}, transitionProps, {
+        enter: slide,
+        exit: slide,
+        "in": isIn,
+        onEnter: this.onEnter,
+        onEntering: this.onEntering,
+        onExit: this.onExit,
+        onExiting: this.onExiting,
+        onExited: this.onExited
+      }), function (status) {
+        var direction = _this2.context.direction;
+        var isActive = status === TransitionStatuses.ENTERED || status === TransitionStatuses.EXITING;
+        var directionClassName = (status === TransitionStatuses.ENTERING || status === TransitionStatuses.EXITING) && _this2.state.startAnimation && (direction === 'end' ? 'carousel-item-start' : 'carousel-item-end');
+        var orderClassName = status === TransitionStatuses.ENTERING && (direction === 'end' ? 'carousel-item-next' : 'carousel-item-prev');
+        var itemClasses = mapToCssModules(classNames(className, 'carousel-item', isActive && 'active', directionClassName, orderClassName), cssModule);
+        return /*#__PURE__*/React.createElement(Tag, {
+          className: itemClasses
+        }, children);
+      });
+    }
+  }]);
+  return CarouselItem;
+}(React.Component);
+CarouselItem.propTypes = _objectSpread(_objectSpread({}, Transition.propTypes), {}, {
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  "in": PropTypes.bool,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  children: PropTypes.node,
+  /** Enable/disable animation */
+  slide: PropTypes.bool,
+  /** Add custom class */
+  className: PropTypes.string
+});
+CarouselItem.defaultProps = _objectSpread(_objectSpread({}, Transition.defaultProps), {}, {
+  timeout: TransitionTimeouts.Carousel
+});
+CarouselItem.contextType = CarouselContext;
+export default CarouselItem;

node_modules/reactstrap/esm/CloseButton.js

@@ -0,0 +1,41 @@
+var _excluded = ["className", "cssModule", "variant", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+var propTypes = {
+  /** Disable the button if needed */
+  active: PropTypes.bool,
+  /** Aria label */
+  'aria-label': PropTypes.string,
+  /** Function to be triggered on click */
+  onClick: PropTypes.func,
+  /** Change the variant to white */
+  variant: PropTypes.oneOf(['white']),
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+};
+function CloseButton(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    variant = props.variant,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'btn-close', variant && "btn-close-".concat(variant)));
+  return /*#__PURE__*/React.createElement("button", _extends({
+    ref: innerRef,
+    type: "button",
+    className: classes
+  }, _objectSpread({
+    'aria-label': 'close'
+  }, attributes)));
+}
+CloseButton.propTypes = propTypes;
+export default CloseButton;

node_modules/reactstrap/esm/Col.js

@@ -0,0 +1,84 @@
+var _excluded = ["className", "cssModule", "widths", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType, isObject } from './utils';
+var colWidths = ['xs', 'sm', 'md', 'lg', 'xl', 'xxl'];
+var stringOrNumberProp = PropTypes.oneOfType([PropTypes.number, PropTypes.string]);
+var columnProps = PropTypes.oneOfType([PropTypes.bool, PropTypes.number, PropTypes.string, PropTypes.shape({
+  size: PropTypes.oneOfType([PropTypes.bool, PropTypes.number, PropTypes.string]),
+  order: stringOrNumberProp,
+  offset: stringOrNumberProp
+})]);
+var propTypes = {
+  tag: tagPropType,
+  xs: columnProps,
+  sm: columnProps,
+  md: columnProps,
+  lg: columnProps,
+  xl: columnProps,
+  xxl: columnProps,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  widths: PropTypes.array
+};
+var getColumnSizeClass = function getColumnSizeClass(isXs, colWidth, colSize) {
+  if (colSize === true || colSize === '') {
+    return isXs ? 'col' : "col-".concat(colWidth);
+  }
+  if (colSize === 'auto') {
+    return isXs ? 'col-auto' : "col-".concat(colWidth, "-auto");
+  }
+  return isXs ? "col-".concat(colSize) : "col-".concat(colWidth, "-").concat(colSize);
+};
+export var getColumnClasses = function getColumnClasses(attributes, cssModule) {
+  var widths = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : colWidths;
+  var modifiedAttributes = attributes;
+  var colClasses = [];
+  widths.forEach(function (colWidth, i) {
+    var columnProp = modifiedAttributes[colWidth];
+    delete modifiedAttributes[colWidth];
+    if (!columnProp && columnProp !== '') {
+      return;
+    }
+    var isXs = !i;
+    if (isObject(columnProp)) {
+      var _classNames;
+      var colSizeInterfix = isXs ? '-' : "-".concat(colWidth, "-");
+      var colClass = getColumnSizeClass(isXs, colWidth, columnProp.size);
+      colClasses.push(mapToCssModules(classNames((_classNames = {}, _defineProperty(_classNames, colClass, columnProp.size || columnProp.size === ''), _defineProperty(_classNames, "order".concat(colSizeInterfix).concat(columnProp.order), columnProp.order || columnProp.order === 0), _defineProperty(_classNames, "offset".concat(colSizeInterfix).concat(columnProp.offset), columnProp.offset || columnProp.offset === 0), _classNames)), cssModule));
+    } else {
+      var _colClass = getColumnSizeClass(isXs, colWidth, columnProp);
+      colClasses.push(_colClass);
+    }
+  });
+  return {
+    colClasses: colClasses,
+    modifiedAttributes: modifiedAttributes
+  };
+};
+function Col(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$widths = props.widths,
+    widths = _props$widths === void 0 ? colWidths : _props$widths,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var _getColumnClasses = getColumnClasses(attributes, cssModule, widths),
+    modifiedAttributes = _getColumnClasses.modifiedAttributes,
+    colClasses = _getColumnClasses.colClasses;
+  if (!colClasses.length) {
+    colClasses.push('col');
+  }
+  var classes = mapToCssModules(classNames(className, colClasses), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, modifiedAttributes, {
+    className: classes
+  }));
+}
+Col.propTypes = propTypes;
+export default Col;

node_modules/reactstrap/esm/Collapse.js

@@ -0,0 +1,169 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["tag", "horizontal", "isOpen", "className", "navbar", "cssModule", "children", "innerRef"];
+var _transitionStatusToCl;
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Transition } from 'react-transition-group';
+import { mapToCssModules, omit, pick, TransitionTimeouts, TransitionPropTypeKeys, TransitionStatuses, tagPropType } from './utils';
+var propTypes = _objectSpread(_objectSpread({}, Transition.propTypes), {}, {
+  /** Make content animation appear horizontally */
+  horizontal: PropTypes.bool,
+  /** Set if Collapse is open or closed */
+  isOpen: PropTypes.bool,
+  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Add custom class */
+  className: PropTypes.node,
+  navbar: PropTypes.bool,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.shape({
+    current: PropTypes.object
+  })
+});
+var defaultProps = _objectSpread(_objectSpread({}, Transition.defaultProps), {}, {
+  horizontal: false,
+  isOpen: false,
+  appear: false,
+  enter: true,
+  exit: true,
+  tag: 'div',
+  timeout: TransitionTimeouts.Collapse
+});
+var transitionStatusToClassHash = (_transitionStatusToCl = {}, _defineProperty(_transitionStatusToCl, TransitionStatuses.ENTERING, 'collapsing'), _defineProperty(_transitionStatusToCl, TransitionStatuses.ENTERED, 'collapse show'), _defineProperty(_transitionStatusToCl, TransitionStatuses.EXITING, 'collapsing'), _defineProperty(_transitionStatusToCl, TransitionStatuses.EXITED, 'collapse'), _transitionStatusToCl);
+function getTransitionClass(status) {
+  return transitionStatusToClassHash[status] || 'collapse';
+}
+var Collapse = /*#__PURE__*/function (_Component) {
+  _inherits(Collapse, _Component);
+  var _super = _createSuper(Collapse);
+  function Collapse(props) {
+    var _this;
+    _classCallCheck(this, Collapse);
+    _this = _super.call(this, props);
+    _this.state = {
+      dimension: null
+    };
+    _this.nodeRef = props.innerRef || /*#__PURE__*/React.createRef();
+    ['onEntering', 'onEntered', 'onExit', 'onExiting', 'onExited'].forEach(function (name) {
+      _this[name] = _this[name].bind(_assertThisInitialized(_this));
+    });
+    return _this;
+  }
+  _createClass(Collapse, [{
+    key: "onEntering",
+    value: function onEntering(_, isAppearing) {
+      var node = this.getNode();
+      this.setState({
+        dimension: this.getDimension(node)
+      });
+      this.props.onEntering(node, isAppearing);
+    }
+  }, {
+    key: "onEntered",
+    value: function onEntered(_, isAppearing) {
+      var node = this.getNode();
+      this.setState({
+        dimension: null
+      });
+      this.props.onEntered(node, isAppearing);
+    }
+  }, {
+    key: "onExit",
+    value: function onExit() {
+      var node = this.getNode();
+      this.setState({
+        dimension: this.getDimension(node)
+      });
+      this.props.onExit(node);
+    }
+  }, {
+    key: "onExiting",
+    value: function onExiting() {
+      var node = this.getNode();
+      // getting this variable triggers a reflow
+      var _unused = this.getDimension(node); // eslint-disable-line no-unused-vars
+      this.setState({
+        dimension: 0
+      });
+      this.props.onExiting(node);
+    }
+  }, {
+    key: "onExited",
+    value: function onExited() {
+      var node = this.getNode();
+      this.setState({
+        dimension: null
+      });
+      this.props.onExited(node);
+    }
+  }, {
+    key: "getNode",
+    value: function getNode() {
+      return this.nodeRef.current;
+    }
+  }, {
+    key: "getDimension",
+    value: function getDimension(node) {
+      return this.props.horizontal ? node.scrollWidth : node.scrollHeight;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props = this.props,
+        Tag = _this$props.tag,
+        horizontal = _this$props.horizontal,
+        isOpen = _this$props.isOpen,
+        className = _this$props.className,
+        navbar = _this$props.navbar,
+        cssModule = _this$props.cssModule,
+        children = _this$props.children,
+        innerRef = _this$props.innerRef,
+        otherProps = _objectWithoutProperties(_this$props, _excluded);
+      var dimension = this.state.dimension;
+      var transitionProps = pick(otherProps, TransitionPropTypeKeys);
+      var childProps = omit(otherProps, TransitionPropTypeKeys);
+      return /*#__PURE__*/React.createElement(Transition, _extends({}, transitionProps, {
+        "in": isOpen,
+        nodeRef: this.nodeRef,
+        onEntering: this.onEntering,
+        onEntered: this.onEntered,
+        onExit: this.onExit,
+        onExiting: this.onExiting,
+        onExited: this.onExited
+      }), function (status) {
+        var collapseClass = getTransitionClass(status);
+        var classes = mapToCssModules(classNames(className, horizontal && 'collapse-horizontal', collapseClass, navbar && 'navbar-collapse'), cssModule);
+        var style = dimension === null ? null : _defineProperty({}, horizontal ? 'width' : 'height', dimension);
+        return /*#__PURE__*/React.createElement(Tag, _extends({}, childProps, {
+          style: _objectSpread(_objectSpread({}, childProps.style), style),
+          className: classes,
+          ref: _this2.nodeRef
+        }), children);
+      });
+    }
+  }]);
+  return Collapse;
+}(Component);
+Collapse.propTypes = propTypes;
+Collapse.defaultProps = defaultProps;
+export default Collapse;

node_modules/reactstrap/esm/Container.js

@@ -0,0 +1,34 @@
+var _excluded = ["className", "cssModule", "fluid", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  fluid: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function Container(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    fluid = props.fluid,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var containerClass = 'container';
+  if (fluid === true) {
+    containerClass = 'container-fluid';
+  } else if (fluid) {
+    containerClass = "container-".concat(fluid);
+  }
+  var classes = mapToCssModules(classNames(className, containerClass), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+Container.propTypes = propTypes;
+export default Container;

node_modules/reactstrap/esm/Dropdown.js

@@ -0,0 +1,336 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["className", "cssModule", "direction", "isOpen", "group", "size", "nav", "setActiveFromChild", "active", "tag", "menuRole"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/* eslint react/no-find-dom-node: 0 */
+// https://github.com/yannickcr/eslint-plugin-react/blob/master/docs/rules/no-find-dom-node.md
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Manager } from 'react-popper';
+import classNames from 'classnames';
+import { DropdownContext } from './DropdownContext';
+import { mapToCssModules, omit, keyCodes, tagPropType } from './utils';
+import { InputGroupContext } from './InputGroupContext';
+var propTypes = {
+  a11y: PropTypes.bool,
+  disabled: PropTypes.bool,
+  direction: PropTypes.oneOf(['up', 'down', 'start', 'end', 'left', 'right']),
+  group: PropTypes.bool,
+  isOpen: PropTypes.bool,
+  nav: PropTypes.bool,
+  active: PropTypes.bool,
+  size: PropTypes.string,
+  tag: tagPropType,
+  toggle: PropTypes.func,
+  children: PropTypes.node,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  dropup: PropTypes.bool,
+  inNavbar: PropTypes.bool,
+  setActiveFromChild: PropTypes.bool,
+  menuRole: PropTypes.oneOf(['listbox', 'menu'])
+};
+var defaultProps = {
+  a11y: true,
+  isOpen: false,
+  direction: 'down',
+  nav: false,
+  active: false,
+  inNavbar: false,
+  setActiveFromChild: false
+};
+var preventDefaultKeys = [keyCodes.space, keyCodes.enter, keyCodes.up, keyCodes.down, keyCodes.end, keyCodes.home];
+var Dropdown = /*#__PURE__*/function (_React$Component) {
+  _inherits(Dropdown, _React$Component);
+  var _super = _createSuper(Dropdown);
+  function Dropdown(props) {
+    var _this;
+    _classCallCheck(this, Dropdown);
+    _this = _super.call(this, props);
+    _this.addEvents = _this.addEvents.bind(_assertThisInitialized(_this));
+    _this.handleDocumentClick = _this.handleDocumentClick.bind(_assertThisInitialized(_this));
+    _this.handleKeyDown = _this.handleKeyDown.bind(_assertThisInitialized(_this));
+    _this.removeEvents = _this.removeEvents.bind(_assertThisInitialized(_this));
+    _this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
+    _this.handleMenuRef = _this.handleMenuRef.bind(_assertThisInitialized(_this));
+    _this.handleToggleRef = _this.handleToggleRef.bind(_assertThisInitialized(_this));
+    _this.containerRef = /*#__PURE__*/React.createRef();
+    _this.menuRef = /*#__PURE__*/React.createRef();
+    _this.toggleRef = /*#__PURE__*/React.createRef();
+    // ref for DropdownToggle
+    return _this;
+  }
+  _createClass(Dropdown, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this.handleProps();
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps) {
+      if (this.props.isOpen !== prevProps.isOpen) {
+        this.handleProps();
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.removeEvents();
+    }
+  }, {
+    key: "handleMenuRef",
+    value: function handleMenuRef(menuRef) {
+      this.menuRef.current = menuRef;
+    }
+  }, {
+    key: "handleToggleRef",
+    value: function handleToggleRef(toggleRef) {
+      this.toggleRef.current = toggleRef;
+    }
+  }, {
+    key: "handleDocumentClick",
+    value: function handleDocumentClick(e) {
+      if (e && (e.which === 3 || e.type === 'keyup' && e.which !== keyCodes.tab)) return;
+      var container = this.getContainer();
+      var menu = this.getMenu();
+      var toggle = this.getToggle();
+
+      // Add a conditional check to avoid using toggle
+      // if there is no toggle component in the dropdown
+      if (!toggle) {
+        return;
+      }
+      var targetIsToggle = toggle.contains(e.target);
+      var clickIsInMenu = menu && menu.contains(e.target) && menu !== e.target;
+      var clickIsInInput = false;
+      if (container) {
+        // This is only for InputGroup with type dropdown
+        clickIsInInput = container.classList.contains('input-group') && container.classList.contains('dropdown') && e.target.tagName === 'INPUT';
+      }
+      if ((targetIsToggle && !clickIsInInput || clickIsInMenu) && (e.type !== 'keyup' || e.which === keyCodes.tab)) {
+        return;
+      }
+      this.toggle(e);
+    }
+  }, {
+    key: "handleKeyDown",
+    value: function handleKeyDown(e) {
+      var _this2 = this;
+      var isTargetMenuItem = e.target.getAttribute('role') === 'menuitem' || e.target.getAttribute('role') === 'option';
+      var isTargetMenuCtrl = this.getMenuCtrl() === e.target;
+      var isTab = keyCodes.tab === e.which;
+      if (/input|textarea/i.test(e.target.tagName) || isTab && !this.props.a11y || isTab && !(isTargetMenuItem || isTargetMenuCtrl)) {
+        return;
+      }
+      if (preventDefaultKeys.indexOf(e.which) !== -1 || e.which >= 48 && e.which <= 90) {
+        e.preventDefault();
+      }
+      if (this.props.disabled) return;
+      if (isTargetMenuCtrl) {
+        if ([keyCodes.space, keyCodes.enter, keyCodes.up, keyCodes.down].indexOf(e.which) > -1) {
+          // Open the menu (if not open) and focus the first menu item
+          if (!this.props.isOpen) {
+            this.toggle(e);
+          }
+          setTimeout(function () {
+            var _this2$getMenuItems$;
+            return (_this2$getMenuItems$ = _this2.getMenuItems()[0]) === null || _this2$getMenuItems$ === void 0 ? void 0 : _this2$getMenuItems$.focus();
+          });
+        } else if (this.props.isOpen && isTab) {
+          var _this$getMenuItems$;
+          // Focus the first menu item if tabbing from an open menu. We need this
+          // for cases where the DropdownMenu sets a custom container, which may
+          // not be the natural next item to tab to from the DropdownToggle.
+          e.preventDefault();
+          (_this$getMenuItems$ = this.getMenuItems()[0]) === null || _this$getMenuItems$ === void 0 ? void 0 : _this$getMenuItems$.focus();
+        } else if (this.props.isOpen && e.which === keyCodes.esc) {
+          this.toggle(e);
+        }
+      }
+      if (this.props.isOpen && isTargetMenuItem) {
+        if ([keyCodes.tab, keyCodes.esc].indexOf(e.which) > -1) {
+          this.toggle(e);
+          this.getMenuCtrl().focus();
+        } else if ([keyCodes.space, keyCodes.enter].indexOf(e.which) > -1) {
+          e.target.click();
+          this.getMenuCtrl().focus();
+        } else if ([keyCodes.down, keyCodes.up].indexOf(e.which) > -1 || [keyCodes.n, keyCodes.p].indexOf(e.which) > -1 && e.ctrlKey) {
+          var $menuitems = this.getMenuItems();
+          var index = $menuitems.indexOf(e.target);
+          if (keyCodes.up === e.which || keyCodes.p === e.which && e.ctrlKey) {
+            index = index !== 0 ? index - 1 : $menuitems.length - 1;
+          } else if (keyCodes.down === e.which || keyCodes.n === e.which && e.ctrlKey) {
+            index = index === $menuitems.length - 1 ? 0 : index + 1;
+          }
+          $menuitems[index].focus();
+        } else if (keyCodes.end === e.which) {
+          var _$menuitems = this.getMenuItems();
+          _$menuitems[_$menuitems.length - 1].focus();
+        } else if (keyCodes.home === e.which) {
+          var _$menuitems2 = this.getMenuItems();
+          _$menuitems2[0].focus();
+        } else if (e.which >= 48 && e.which <= 90) {
+          var _$menuitems3 = this.getMenuItems();
+          var charPressed = String.fromCharCode(e.which).toLowerCase();
+          for (var i = 0; i < _$menuitems3.length; i += 1) {
+            var firstLetter = _$menuitems3[i].textContent && _$menuitems3[i].textContent[0].toLowerCase();
+            if (firstLetter === charPressed) {
+              _$menuitems3[i].focus();
+              break;
+            }
+          }
+        }
+      }
+    }
+  }, {
+    key: "handleProps",
+    value: function handleProps() {
+      if (this.props.isOpen) {
+        this.addEvents();
+      } else {
+        this.removeEvents();
+      }
+    }
+  }, {
+    key: "getContextValue",
+    value: function getContextValue() {
+      return {
+        toggle: this.toggle,
+        isOpen: this.props.isOpen,
+        direction: this.props.direction === 'down' && this.props.dropup ? 'up' : this.props.direction,
+        inNavbar: this.props.inNavbar,
+        disabled: this.props.disabled,
+        // Callback that should be called by DropdownMenu to provide a ref to
+        // a HTML tag that's used for the DropdownMenu
+        onMenuRef: this.handleMenuRef,
+        onToggleRef: this.handleToggleRef,
+        menuRole: this.props.menuRole
+      };
+    }
+  }, {
+    key: "getContainer",
+    value: function getContainer() {
+      return this.containerRef.current;
+    }
+  }, {
+    key: "getMenu",
+    value: function getMenu() {
+      return this.menuRef.current;
+    }
+  }, {
+    key: "getToggle",
+    value: function getToggle() {
+      return this.toggleRef.current;
+    }
+  }, {
+    key: "getMenuCtrl",
+    value: function getMenuCtrl() {
+      if (this._$menuCtrl) return this._$menuCtrl;
+      this._$menuCtrl = this.getToggle();
+      return this._$menuCtrl;
+    }
+  }, {
+    key: "getItemType",
+    value: function getItemType() {
+      if (this.props.menuRole === 'listbox') {
+        return 'option';
+      }
+      return 'menuitem';
+    }
+  }, {
+    key: "getMenuItems",
+    value: function getMenuItems() {
+      // In a real menu with a child DropdownMenu, `this.getMenu()` should never
+      // be null, but it is sometimes null in tests. To mitigate that, we just
+      // use `this.getContainer()` as the fallback `menuContainer`.
+      var menuContainer = this.getMenu() || this.getContainer();
+      return [].slice.call(menuContainer.querySelectorAll("[role=\"".concat(this.getItemType(), "\"]")));
+    }
+  }, {
+    key: "addEvents",
+    value: function addEvents() {
+      var _this3 = this;
+      ['click', 'touchstart', 'keyup'].forEach(function (event) {
+        return document.addEventListener(event, _this3.handleDocumentClick, true);
+      });
+    }
+  }, {
+    key: "removeEvents",
+    value: function removeEvents() {
+      var _this4 = this;
+      ['click', 'touchstart', 'keyup'].forEach(function (event) {
+        return document.removeEventListener(event, _this4.handleDocumentClick, true);
+      });
+    }
+  }, {
+    key: "toggle",
+    value: function toggle(e) {
+      if (this.props.disabled) {
+        return e && e.preventDefault();
+      }
+      return this.props.toggle(e);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _classNames,
+        _this5 = this;
+      var _omit = omit(this.props, ['toggle', 'disabled', 'inNavbar', 'a11y']),
+        className = _omit.className,
+        cssModule = _omit.cssModule,
+        direction = _omit.direction,
+        isOpen = _omit.isOpen,
+        group = _omit.group,
+        size = _omit.size,
+        nav = _omit.nav,
+        setActiveFromChild = _omit.setActiveFromChild,
+        active = _omit.active,
+        tag = _omit.tag,
+        menuRole = _omit.menuRole,
+        attrs = _objectWithoutProperties(_omit, _excluded);
+      var Tag = tag || (nav ? 'li' : 'div');
+      var subItemIsActive = false;
+      if (setActiveFromChild) {
+        React.Children.map(this.props.children[1].props.children, function (dropdownItem) {
+          if (dropdownItem && dropdownItem.props.active) subItemIsActive = true;
+        });
+      }
+      var classes = mapToCssModules(classNames(className, nav && active ? 'active' : false, setActiveFromChild && subItemIsActive ? 'active' : false, (_classNames = {
+        'btn-group': group
+      }, _defineProperty(_classNames, "btn-group-".concat(size), !!size), _defineProperty(_classNames, "dropdown", !group), _defineProperty(_classNames, "dropup", direction === 'up'), _defineProperty(_classNames, "dropstart", direction === 'start' || direction === 'left'), _defineProperty(_classNames, "dropend", direction === 'end' || direction === 'right'), _defineProperty(_classNames, "show", isOpen), _defineProperty(_classNames, 'nav-item', nav), _classNames)), cssModule);
+      if (this.context.insideInputGroup) {
+        return /*#__PURE__*/React.createElement(DropdownContext.Provider, {
+          value: this.getContextValue()
+        }, /*#__PURE__*/React.createElement(Manager, null, React.Children.map(this.props.children, function (child) {
+          return /*#__PURE__*/React.cloneElement(child, {
+            onKeyDown: _this5.handleKeyDown
+          });
+        })));
+      }
+      return /*#__PURE__*/React.createElement(DropdownContext.Provider, {
+        value: this.getContextValue()
+      }, /*#__PURE__*/React.createElement(Manager, null, /*#__PURE__*/React.createElement(Tag, _extends({}, attrs, _defineProperty({}, typeof Tag === 'string' ? 'ref' : 'innerRef', this.containerRef), {
+        onKeyDown: this.handleKeyDown,
+        className: classes
+      }))));
+    }
+  }]);
+  return Dropdown;
+}(React.Component);
+Dropdown.propTypes = propTypes;
+Dropdown.defaultProps = defaultProps;
+Dropdown.contextType = InputGroupContext;
+export default Dropdown;

node_modules/reactstrap/esm/DropdownContext.js

@@ -0,0 +1,13 @@
+import React from 'react';
+
+/**
+ * DropdownContext
+ * {
+ *  toggle: PropTypes.func.isRequired,
+ *  isOpen: PropTypes.bool.isRequired,
+ *  direction: PropTypes.oneOf(['up', 'down', 'start', 'end']).isRequired,
+ *  inNavbar: PropTypes.bool.isRequired,
+ *  disabled: PropTypes.bool
+ * }
+ */
+export var DropdownContext = /*#__PURE__*/React.createContext({});

node_modules/reactstrap/esm/DropdownItem.js

@@ -0,0 +1,134 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["className", "cssModule", "divider", "tag", "header", "active", "text"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { DropdownContext } from './DropdownContext';
+import { mapToCssModules, omit, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  active: PropTypes.bool,
+  disabled: PropTypes.bool,
+  divider: PropTypes.bool,
+  tag: tagPropType,
+  header: PropTypes.bool,
+  onClick: PropTypes.func,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  toggle: PropTypes.bool,
+  text: PropTypes.bool
+};
+var DropdownItem = /*#__PURE__*/function (_React$Component) {
+  _inherits(DropdownItem, _React$Component);
+  var _super = _createSuper(DropdownItem);
+  function DropdownItem(props) {
+    var _this;
+    _classCallCheck(this, DropdownItem);
+    _this = _super.call(this, props);
+    _this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
+    _this.getTabIndex = _this.getTabIndex.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(DropdownItem, [{
+    key: "onClick",
+    value: function onClick(e) {
+      var _this$props$toggle;
+      var _this$props = this.props,
+        disabled = _this$props.disabled,
+        header = _this$props.header,
+        divider = _this$props.divider,
+        text = _this$props.text;
+      if (disabled || header || divider || text) {
+        e.preventDefault();
+        return;
+      }
+      if (this.props.onClick) {
+        this.props.onClick(e);
+      }
+      if ((_this$props$toggle = this.props.toggle) !== null && _this$props$toggle !== void 0 ? _this$props$toggle : true) {
+        this.context.toggle(e);
+      }
+    }
+  }, {
+    key: "getRole",
+    value: function getRole() {
+      if (this.context.menuRole === 'listbox') {
+        return 'option';
+      }
+      return 'menuitem';
+    }
+  }, {
+    key: "getTabIndex",
+    value: function getTabIndex() {
+      var _this$props2 = this.props,
+        disabled = _this$props2.disabled,
+        header = _this$props2.header,
+        divider = _this$props2.divider,
+        text = _this$props2.text;
+      if (disabled || header || divider || text) {
+        return '-1';
+      }
+      return '0';
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var tabIndex = this.getTabIndex();
+      var role = tabIndex > -1 ? this.getRole() : undefined;
+      var _omit = omit(this.props, ['toggle']),
+        className = _omit.className,
+        cssModule = _omit.cssModule,
+        divider = _omit.divider,
+        _omit$tag = _omit.tag,
+        Tag = _omit$tag === void 0 ? 'button' : _omit$tag,
+        header = _omit.header,
+        active = _omit.active,
+        text = _omit.text,
+        props = _objectWithoutProperties(_omit, _excluded);
+      var classes = mapToCssModules(classNames(className, {
+        disabled: props.disabled,
+        'dropdown-item': !divider && !header && !text,
+        active: active,
+        'dropdown-header': header,
+        'dropdown-divider': divider,
+        'dropdown-item-text': text
+      }), cssModule);
+      if (Tag === 'button') {
+        if (header) {
+          Tag = 'h6';
+        } else if (divider) {
+          Tag = 'div';
+        } else if (props.href) {
+          Tag = 'a';
+        } else if (text) {
+          Tag = 'span';
+        }
+      }
+      return /*#__PURE__*/React.createElement(Tag, _extends({
+        type: Tag === 'button' && (props.onClick || this.props.toggle) ? 'button' : undefined
+      }, props, {
+        tabIndex: tabIndex,
+        role: role,
+        className: classes,
+        onClick: this.onClick
+      }));
+    }
+  }]);
+  return DropdownItem;
+}(React.Component);
+DropdownItem.propTypes = propTypes;
+DropdownItem.contextType = DropdownContext;
+export default DropdownItem;

node_modules/reactstrap/esm/DropdownMenu.js

@@ -0,0 +1,167 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["className", "cssModule", "dark", "end", "right", "tag", "flip", "modifiers", "persist", "strategy", "container", "updateOnSelect"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import classNames from 'classnames';
+import { Popper } from 'react-popper';
+import { DropdownContext } from './DropdownContext';
+import { mapToCssModules, tagPropType, targetPropType, getTarget, deprecated } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  children: PropTypes.node.isRequired,
+  dark: PropTypes.bool,
+  end: PropTypes.bool,
+  /** Flips the menu to the opposite side if there is not enough space to fit */
+  flip: PropTypes.bool,
+  modifiers: PropTypes.array,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  style: PropTypes.object,
+  persist: PropTypes.bool,
+  strategy: PropTypes.string,
+  container: targetPropType,
+  /** Update popper layout when a click event comes up. This leverages event bubbling. */
+  updateOnSelect: PropTypes.bool,
+  right: deprecated(PropTypes.bool, 'Please use "end" instead.')
+};
+var directionPositionMap = {
+  up: 'top',
+  left: 'left',
+  right: 'right',
+  start: 'left',
+  end: 'right',
+  down: 'bottom'
+};
+var DropdownMenu = /*#__PURE__*/function (_React$Component) {
+  _inherits(DropdownMenu, _React$Component);
+  var _super = _createSuper(DropdownMenu);
+  function DropdownMenu() {
+    _classCallCheck(this, DropdownMenu);
+    return _super.apply(this, arguments);
+  }
+  _createClass(DropdownMenu, [{
+    key: "getRole",
+    value: function getRole() {
+      if (this.context.menuRole === 'listbox') {
+        return 'listbox';
+      }
+      return 'menu';
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this = this;
+      var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        dark = _this$props.dark,
+        end = _this$props.end,
+        right = _this$props.right,
+        _this$props$tag = _this$props.tag,
+        tag = _this$props$tag === void 0 ? 'div' : _this$props$tag,
+        _this$props$flip = _this$props.flip,
+        flip = _this$props$flip === void 0 ? true : _this$props$flip,
+        _this$props$modifiers = _this$props.modifiers,
+        modifiers = _this$props$modifiers === void 0 ? [] : _this$props$modifiers,
+        persist = _this$props.persist,
+        strategy = _this$props.strategy,
+        container = _this$props.container,
+        updateOnSelect = _this$props.updateOnSelect,
+        attrs = _objectWithoutProperties(_this$props, _excluded);
+      var classes = mapToCssModules(classNames(className, 'dropdown-menu', {
+        'dropdown-menu-dark': dark,
+        'dropdown-menu-end': end || right,
+        show: this.context.isOpen
+      }), cssModule);
+      var Tag = tag;
+      if (persist || this.context.isOpen && !this.context.inNavbar) {
+        var position1 = directionPositionMap[this.context.direction] || 'bottom';
+        var position2 = end || right ? 'end' : 'start';
+        var poperPlacement = "".concat(position1, "-").concat(position2);
+        var poperModifiers = [].concat(_toConsumableArray(modifiers), [{
+          name: 'flip',
+          enabled: !!flip
+        }]);
+        var persistStyles = {};
+        if (persist) {
+          persistStyles.display = 'block';
+          persistStyles.visibility = this.context.isOpen ? 'visible' : 'hidden';
+        }
+        var popper = /*#__PURE__*/React.createElement(Popper, {
+          placement: poperPlacement,
+          modifiers: poperModifiers,
+          strategy: strategy
+        }, function (_ref) {
+          var ref = _ref.ref,
+            style = _ref.style,
+            placement = _ref.placement,
+            update = _ref.update;
+          var combinedStyle = _objectSpread(_objectSpread(_objectSpread({}, _this.props.style), persistStyles), style);
+          var handleRef = function handleRef(tagRef) {
+            // Send the ref to `react-popper`
+            ref(tagRef);
+            // Send the ref to the parent Dropdown so that clicks outside
+            // it will cause it to close
+            var onMenuRef = _this.context.onMenuRef;
+            if (onMenuRef) onMenuRef(tagRef);
+          };
+          return /*#__PURE__*/React.createElement(Tag, _extends({
+            tabIndex: "-1",
+            role: _this.getRole(),
+            ref: handleRef
+          }, attrs, {
+            style: combinedStyle,
+            "aria-hidden": !_this.context.isOpen,
+            className: classes,
+            "data-popper-placement": placement,
+            onClick: function onClick() {
+              return updateOnSelect && update();
+            }
+          }));
+        });
+        if (container) {
+          return /*#__PURE__*/ReactDOM.createPortal(popper, getTarget(container));
+        }
+        return popper;
+      }
+      var onMenuRef = this.context.onMenuRef;
+      return /*#__PURE__*/React.createElement(Tag, _extends({
+        tabIndex: "-1",
+        role: this.getRole()
+      }, attrs, {
+        ref: onMenuRef,
+        "aria-hidden": !this.context.isOpen,
+        className: classes,
+        "data-popper-placement": attrs.placement,
+        "data-bs-popper": "static"
+      }));
+    }
+  }]);
+  return DropdownMenu;
+}(React.Component);
+DropdownMenu.propTypes = propTypes;
+DropdownMenu.contextType = DropdownContext;
+export default DropdownMenu;

node_modules/reactstrap/esm/DropdownToggle.js

@@ -0,0 +1,142 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["className", "color", "cssModule", "caret", "split", "nav", "tag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Reference } from 'react-popper';
+import { DropdownContext } from './DropdownContext';
+import { mapToCssModules, tagPropType } from './utils';
+import Button from './Button';
+var propTypes = {
+  caret: PropTypes.bool,
+  color: PropTypes.string,
+  children: PropTypes.node,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  disabled: PropTypes.bool,
+  onClick: PropTypes.func,
+  'aria-haspopup': PropTypes.bool,
+  split: PropTypes.bool,
+  tag: tagPropType,
+  nav: PropTypes.bool,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+};
+var defaultProps = {
+  color: 'secondary',
+  'aria-haspopup': true
+};
+var DropdownToggle = /*#__PURE__*/function (_React$Component) {
+  _inherits(DropdownToggle, _React$Component);
+  var _super = _createSuper(DropdownToggle);
+  function DropdownToggle(props) {
+    var _this;
+    _classCallCheck(this, DropdownToggle);
+    _this = _super.call(this, props);
+    _this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(DropdownToggle, [{
+    key: "onClick",
+    value: function onClick(e) {
+      if (this.props.disabled || this.context.disabled) {
+        e.preventDefault();
+        return;
+      }
+      if (this.props.nav && !this.props.tag) {
+        e.preventDefault();
+      }
+      if (this.props.onClick) {
+        this.props.onClick(e);
+      }
+      this.context.toggle(e);
+    }
+  }, {
+    key: "getRole",
+    value: function getRole() {
+      return this.context.menuRole || this.props['aria-haspopup'];
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      var _this$props = this.props,
+        className = _this$props.className,
+        color = _this$props.color,
+        cssModule = _this$props.cssModule,
+        caret = _this$props.caret,
+        split = _this$props.split,
+        nav = _this$props.nav,
+        tag = _this$props.tag,
+        innerRef = _this$props.innerRef,
+        props = _objectWithoutProperties(_this$props, _excluded);
+      var ariaLabel = props['aria-label'] || 'Toggle Dropdown';
+      var classes = mapToCssModules(classNames(className, {
+        'dropdown-toggle': caret || split,
+        'dropdown-toggle-split': split,
+        'nav-link': nav
+      }), cssModule);
+      var children = typeof props.children !== 'undefined' ? props.children : /*#__PURE__*/React.createElement("span", {
+        className: "visually-hidden"
+      }, ariaLabel);
+      var Tag;
+      if (nav && !tag) {
+        Tag = 'a';
+        props.href = '#';
+      } else if (!tag) {
+        Tag = Button;
+        props.color = color;
+        props.cssModule = cssModule;
+      } else {
+        Tag = tag;
+      }
+
+      // extracted the rendering of the Tag component
+      var returnFunction = function returnFunction(_ref) {
+        var ref = _ref.ref;
+        var handleRef = function handleRef(tagRef) {
+          ref(tagRef);
+          var onToggleRef = _this2.context.onToggleRef;
+          if (onToggleRef) onToggleRef(tagRef);
+        };
+        return /*#__PURE__*/React.createElement(Tag, _extends({}, props, _defineProperty({}, typeof Tag === 'string' ? 'ref' : 'innerRef', handleRef), {
+          className: classes,
+          onClick: _this2.onClick,
+          "aria-expanded": _this2.context.isOpen,
+          "aria-haspopup": _this2.getRole(),
+          children: children
+        }));
+      };
+
+      // No Reference component if the component is in Navbar
+      if (this.context.inNavbar) {
+        return /*#__PURE__*/React.createElement(React.Fragment, null, returnFunction({
+          ref: this.context.onToggleRef
+        }));
+      }
+
+      // Normal rendering if component not in NavBar
+      return /*#__PURE__*/React.createElement(Reference, {
+        innerRef: innerRef
+      }, returnFunction);
+    }
+  }]);
+  return DropdownToggle;
+}(React.Component);
+DropdownToggle.propTypes = propTypes;
+DropdownToggle.defaultProps = defaultProps;
+DropdownToggle.contextType = DropdownContext;
+export default DropdownToggle;

node_modules/reactstrap/esm/Fade.js

@@ -0,0 +1,61 @@
+var _excluded = ["tag", "baseClass", "baseClassActive", "className", "cssModule", "children", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import React, { useRef } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Transition } from 'react-transition-group';
+import { addDefaultProps, mapToCssModules, omit, pick, tagPropType, TransitionPropTypeKeys, TransitionTimeouts } from './utils';
+var propTypes = _objectSpread(_objectSpread({}, Transition.propTypes), {}, {
+  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
+  tag: tagPropType,
+  baseClass: PropTypes.string,
+  baseClassActive: PropTypes.string,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+});
+var defaultProps = _objectSpread(_objectSpread({}, Transition.defaultProps), {}, {
+  timeout: TransitionTimeouts.Fade,
+  appear: true,
+  enter: true,
+  exit: true,
+  "in": true
+});
+function Fade(props) {
+  var ref = useRef(null);
+  var _addDefaultProps = addDefaultProps(defaultProps, props),
+    _addDefaultProps$tag = _addDefaultProps.tag,
+    Tag = _addDefaultProps$tag === void 0 ? 'div' : _addDefaultProps$tag,
+    _addDefaultProps$base = _addDefaultProps.baseClass,
+    baseClass = _addDefaultProps$base === void 0 ? 'fade' : _addDefaultProps$base,
+    _addDefaultProps$base2 = _addDefaultProps.baseClassActive,
+    baseClassActive = _addDefaultProps$base2 === void 0 ? 'show' : _addDefaultProps$base2,
+    className = _addDefaultProps.className,
+    cssModule = _addDefaultProps.cssModule,
+    children = _addDefaultProps.children,
+    _addDefaultProps$inne = _addDefaultProps.innerRef,
+    innerRef = _addDefaultProps$inne === void 0 ? ref : _addDefaultProps$inne,
+    otherProps = _objectWithoutProperties(_addDefaultProps, _excluded);
+  var transitionProps = pick(_objectSpread({
+    defaultProps: defaultProps
+  }, otherProps), TransitionPropTypeKeys);
+  var childProps = omit(otherProps, TransitionPropTypeKeys);
+  return /*#__PURE__*/React.createElement(Transition, _extends({
+    nodeRef: innerRef
+  }, transitionProps), function (status) {
+    var isActive = status === 'entered';
+    var classes = mapToCssModules(classNames(className, baseClass, isActive && baseClassActive), cssModule);
+    return /*#__PURE__*/React.createElement(Tag, _extends({
+      className: classes
+    }, childProps, {
+      ref: innerRef
+    }), children);
+  });
+}
+Fade.propTypes = propTypes;
+export default Fade;

node_modules/reactstrap/esm/Form.js

@@ -0,0 +1,72 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["className", "cssModule", "tag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  tag: tagPropType,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+var Form = /*#__PURE__*/function (_Component) {
+  _inherits(Form, _Component);
+  var _super = _createSuper(Form);
+  function Form(props) {
+    var _this;
+    _classCallCheck(this, Form);
+    _this = _super.call(this, props);
+    _this.getRef = _this.getRef.bind(_assertThisInitialized(_this));
+    _this.submit = _this.submit.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(Form, [{
+    key: "getRef",
+    value: function getRef(ref) {
+      if (this.props.innerRef) {
+        this.props.innerRef(ref);
+      }
+      this.ref = ref;
+    }
+  }, {
+    key: "submit",
+    value: function submit() {
+      if (this.ref) {
+        this.ref.submit();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        _this$props$tag = _this$props.tag,
+        Tag = _this$props$tag === void 0 ? 'form' : _this$props$tag,
+        innerRef = _this$props.innerRef,
+        attributes = _objectWithoutProperties(_this$props, _excluded);
+      var classes = mapToCssModules(className, cssModule);
+      return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+        ref: innerRef,
+        className: classes
+      }));
+    }
+  }]);
+  return Form;
+}(Component);
+Form.propTypes = propTypes;
+export default Form;

node_modules/reactstrap/esm/FormFeedback.js

@@ -0,0 +1,33 @@
+var _excluded = ["className", "cssModule", "valid", "tooltip", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  valid: PropTypes.bool,
+  tooltip: PropTypes.bool
+};
+function FormFeedback(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$valid = props.valid,
+    valid = _props$valid === void 0 ? undefined : _props$valid,
+    tooltip = props.tooltip,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var validMode = tooltip ? 'tooltip' : 'feedback';
+  var classes = mapToCssModules(classNames(className, valid ? "valid-".concat(validMode) : "invalid-".concat(validMode)), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+FormFeedback.propTypes = propTypes;
+export default FormFeedback;

node_modules/reactstrap/esm/FormGroup.js

@@ -0,0 +1,45 @@
+var _excluded = ["className", "cssModule", "row", "disabled", "check", "inline", "floating", "noMargin", "tag", "switch"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  row: PropTypes.bool,
+  check: PropTypes.bool,
+  "switch": PropTypes.bool,
+  inline: PropTypes.bool,
+  floating: PropTypes.bool,
+  noMargin: PropTypes.bool,
+  disabled: PropTypes.bool,
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function FormGroup(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    row = props.row,
+    disabled = props.disabled,
+    check = props.check,
+    inline = props.inline,
+    floating = props.floating,
+    noMargin = props.noMargin,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    switchProp = props["switch"],
+    attributes = _objectWithoutProperties(props, _excluded);
+  var formCheck = check || switchProp;
+  var classes = mapToCssModules(classNames(className, row ? 'row' : false, formCheck ? 'form-check' : false, switchProp ? 'form-switch' : false, formCheck || noMargin ? false : 'mb-3', formCheck && inline ? 'form-check-inline' : false, formCheck && disabled ? 'disabled' : false, floating && 'form-floating'), cssModule);
+  if (Tag === 'fieldset') {
+    attributes.disabled = disabled;
+  }
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+FormGroup.propTypes = propTypes;
+export default FormGroup;

node_modules/reactstrap/esm/FormText.js

@@ -0,0 +1,32 @@
+var _excluded = ["className", "cssModule", "inline", "color", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  inline: PropTypes.bool,
+  tag: tagPropType,
+  color: PropTypes.string,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function FormText(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    inline = props.inline,
+    _props$color = props.color,
+    color = _props$color === void 0 ? 'muted' : _props$color,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'small' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, !inline ? 'form-text' : false, color ? "text-".concat(color) : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+FormText.propTypes = propTypes;
+export default FormText;

node_modules/reactstrap/esm/Input.js

@@ -0,0 +1,122 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["className", "cssModule", "type", "bsSize", "valid", "invalid", "tag", "addon", "plaintext", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/* eslint react/prefer-stateless-function: 0 */
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, warnOnce, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  type: PropTypes.string,
+  size: PropTypes.oneOfType([PropTypes.number, PropTypes.string]),
+  bsSize: PropTypes.string,
+  valid: PropTypes.bool,
+  invalid: PropTypes.bool,
+  tag: tagPropType,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  plaintext: PropTypes.bool,
+  addon: PropTypes.bool,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+var Input = /*#__PURE__*/function (_React$Component) {
+  _inherits(Input, _React$Component);
+  var _super = _createSuper(Input);
+  function Input(props) {
+    var _this;
+    _classCallCheck(this, Input);
+    _this = _super.call(this, props);
+    _this.getRef = _this.getRef.bind(_assertThisInitialized(_this));
+    _this.focus = _this.focus.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(Input, [{
+    key: "getRef",
+    value: function getRef(ref) {
+      if (this.props.innerRef) {
+        this.props.innerRef(ref);
+      }
+      this.ref = ref;
+    }
+  }, {
+    key: "focus",
+    value: function focus() {
+      if (this.ref) {
+        this.ref.focus();
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        _this$props$type = _this$props.type,
+        type = _this$props$type === void 0 ? 'text' : _this$props$type,
+        bsSize = _this$props.bsSize,
+        valid = _this$props.valid,
+        invalid = _this$props.invalid,
+        tag = _this$props.tag,
+        addon = _this$props.addon,
+        plaintext = _this$props.plaintext,
+        innerRef = _this$props.innerRef,
+        attributes = _objectWithoutProperties(_this$props, _excluded);
+      var checkInput = ['switch', 'radio', 'checkbox'].indexOf(type) > -1;
+      var isNotaNumber = /\D/g;
+      var textareaInput = type === 'textarea';
+      var selectInput = type === 'select';
+      var rangeInput = type === 'range';
+      var Tag = tag || (selectInput || textareaInput ? type : 'input');
+      var formControlClass = 'form-control';
+      if (plaintext) {
+        formControlClass = "".concat(formControlClass, "-plaintext");
+        Tag = tag || 'input';
+      } else if (rangeInput) {
+        formControlClass = 'form-range';
+      } else if (selectInput) {
+        formControlClass = 'form-select';
+      } else if (checkInput) {
+        if (addon) {
+          formControlClass = null;
+        } else {
+          formControlClass = 'form-check-input';
+        }
+      }
+      if (attributes.size && isNotaNumber.test(attributes.size)) {
+        warnOnce('Please use the prop "bsSize" instead of the "size" to bootstrap\'s input sizing.');
+        bsSize = attributes.size;
+        delete attributes.size;
+      }
+      var classes = mapToCssModules(classNames(className, invalid && 'is-invalid', valid && 'is-valid', bsSize ? selectInput ? "form-select-".concat(bsSize) : "form-control-".concat(bsSize) : false, formControlClass), cssModule);
+      if (Tag === 'input' || tag && typeof tag === 'function') {
+        attributes.type = type === 'switch' ? 'checkbox' : type;
+      }
+      if (attributes.children && !(plaintext || type === 'select' || typeof Tag !== 'string' || Tag === 'select')) {
+        warnOnce("Input with a type of \"".concat(type, "\" cannot have children. Please use \"value\"/\"defaultValue\" instead."));
+        delete attributes.children;
+      }
+      return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+        ref: innerRef,
+        className: classes,
+        "aria-invalid": invalid
+      }));
+    }
+  }]);
+  return Input;
+}(React.Component);
+Input.propTypes = propTypes;
+export default Input;

node_modules/reactstrap/esm/InputGroup.js

@@ -0,0 +1,45 @@
+var _excluded = ["className", "cssModule", "tag", "type", "size"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import Dropdown from './Dropdown';
+import { InputGroupContext } from './InputGroupContext';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Sets size of InputGroup */
+  size: PropTypes.string,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  type: PropTypes.string
+};
+function InputGroup(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    type = props.type,
+    size = props.size,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'input-group', size ? "input-group-".concat(size) : null), cssModule);
+  if (props.type === 'dropdown') {
+    return /*#__PURE__*/React.createElement(Dropdown, _extends({}, attributes, {
+      className: classes
+    }));
+  }
+  return /*#__PURE__*/React.createElement(InputGroupContext.Provider, {
+    value: {
+      insideInputGroup: true
+    }
+  }, /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  })));
+}
+InputGroup.propTypes = propTypes;
+export default InputGroup;

node_modules/reactstrap/esm/InputGroupContext.js

@@ -0,0 +1,2 @@
+import React from 'react';
+export var InputGroupContext = /*#__PURE__*/React.createContext({});

node_modules/reactstrap/esm/InputGroupText.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function InputGroupText(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'span' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'input-group-text'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+InputGroupText.propTypes = propTypes;
+export default InputGroupText;

node_modules/reactstrap/esm/Label.js

@@ -0,0 +1,84 @@
+var _excluded = ["className", "cssModule", "hidden", "widths", "tag", "check", "size", "for"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType, isObject } from './utils';
+var colWidths = ['xs', 'sm', 'md', 'lg', 'xl', 'xxl'];
+var stringOrNumberProp = PropTypes.oneOfType([PropTypes.number, PropTypes.string]);
+var columnProps = PropTypes.oneOfType([PropTypes.bool, PropTypes.string, PropTypes.number, PropTypes.shape({
+  size: stringOrNumberProp,
+  order: stringOrNumberProp,
+  offset: stringOrNumberProp
+})]);
+var propTypes = {
+  children: PropTypes.node,
+  hidden: PropTypes.bool,
+  check: PropTypes.bool,
+  size: PropTypes.string,
+  "for": PropTypes.string,
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  xs: columnProps,
+  sm: columnProps,
+  md: columnProps,
+  lg: columnProps,
+  xl: columnProps,
+  xxl: columnProps,
+  widths: PropTypes.array
+};
+var getColumnSizeClass = function getColumnSizeClass(isXs, colWidth, colSize) {
+  if (colSize === true || colSize === '') {
+    return isXs ? 'col' : "col-".concat(colWidth);
+  }
+  if (colSize === 'auto') {
+    return isXs ? 'col-auto' : "col-".concat(colWidth, "-auto");
+  }
+  return isXs ? "col-".concat(colSize) : "col-".concat(colWidth, "-").concat(colSize);
+};
+function Label(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    hidden = props.hidden,
+    _props$widths = props.widths,
+    widths = _props$widths === void 0 ? colWidths : _props$widths,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'label' : _props$tag,
+    check = props.check,
+    size = props.size,
+    htmlFor = props["for"],
+    attributes = _objectWithoutProperties(props, _excluded);
+  var colClasses = [];
+  widths.forEach(function (colWidth, i) {
+    var columnProp = props[colWidth];
+    delete attributes[colWidth];
+    if (!columnProp && columnProp !== '') {
+      return;
+    }
+    var isXs = !i;
+    var colClass;
+    if (isObject(columnProp)) {
+      var _classNames;
+      var colSizeInterfix = isXs ? '-' : "-".concat(colWidth, "-");
+      colClass = getColumnSizeClass(isXs, colWidth, columnProp.size);
+      colClasses.push(mapToCssModules(classNames((_classNames = {}, _defineProperty(_classNames, colClass, columnProp.size || columnProp.size === ''), _defineProperty(_classNames, "order".concat(colSizeInterfix).concat(columnProp.order), columnProp.order || columnProp.order === 0), _defineProperty(_classNames, "offset".concat(colSizeInterfix).concat(columnProp.offset), columnProp.offset || columnProp.offset === 0), _classNames))), cssModule);
+    } else {
+      colClass = getColumnSizeClass(isXs, colWidth, columnProp);
+      colClasses.push(colClass);
+    }
+  });
+  var colFormLabel = size || colClasses.length;
+  var formLabel = !(check || colFormLabel);
+  var classes = mapToCssModules(classNames(className, hidden ? 'visually-hidden' : false, check ? 'form-check-label' : false, size ? "col-form-label-".concat(size) : false, colClasses, colFormLabel ? 'col-form-label' : false, formLabel ? 'form-label' : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({
+    htmlFor: htmlFor
+  }, attributes, {
+    className: classes
+  }));
+}
+Label.propTypes = propTypes;
+export default Label;

node_modules/reactstrap/esm/List.js

@@ -0,0 +1,34 @@
+var _excluded = ["className", "cssModule", "tag", "type"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Type of list `unstyled` or `inline` */
+  type: PropTypes.string
+};
+var List = /*#__PURE__*/forwardRef(function (props, ref) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'ul' : _props$tag,
+    type = props.type,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, type ? "list-".concat(type) : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: ref
+  }));
+});
+List.name = 'List';
+List.propTypes = propTypes;
+export default List;

node_modules/reactstrap/esm/ListGroup.js

@@ -0,0 +1,54 @@
+var _excluded = ["className", "cssModule", "tag", "flush", "horizontal", "numbered"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Remove borders to make the list appear flush */
+  flush: PropTypes.bool,
+  /** Make the list horizontal instead of vertical */
+  horizontal: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  /** Add number to the ListItems */
+  numbered: PropTypes.bool,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+var getHorizontalClass = function getHorizontalClass(horizontal) {
+  if (horizontal === false) {
+    return false;
+  }
+  if (horizontal === true || horizontal === 'xs') {
+    return 'list-group-horizontal';
+  }
+  return "list-group-horizontal-".concat(horizontal);
+};
+function ListGroup(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'ul' : _props$tag,
+    flush = props.flush,
+    _props$horizontal = props.horizontal,
+    horizontal = _props$horizontal === void 0 ? false : _props$horizontal,
+    _props$numbered = props.numbered,
+    numbered = _props$numbered === void 0 ? false : _props$numbered,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'list-group',
+  // list-group-horizontal cannot currently be mixed with list-group-flush
+  // we only try to apply horizontal classes if flush is false
+  flush ? 'list-group-flush' : getHorizontalClass(horizontal), {
+    'list-group-numbered': numbered
+  }), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+ListGroup.propTypes = propTypes;
+export default ListGroup;

node_modules/reactstrap/esm/ListGroupItem.js

@@ -0,0 +1,49 @@
+var _excluded = ["className", "cssModule", "tag", "active", "disabled", "action", "color"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add action prop to give effects while hovering over element */
+  action: PropTypes.bool,
+  /** Add active prop to make the current selection active */
+  active: PropTypes.bool,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Add background colour to the list item */
+  color: PropTypes.string,
+  /** Make the list item appear disabled */
+  disabled: PropTypes.bool,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+var handleDisabledOnClick = function handleDisabledOnClick(e) {
+  e.preventDefault();
+};
+function ListGroupItem(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'li' : _props$tag,
+    active = props.active,
+    disabled = props.disabled,
+    action = props.action,
+    color = props.color,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, active ? 'active' : false, disabled ? 'disabled' : false, action ? 'list-group-item-action' : false, color ? "list-group-item-".concat(color) : false, 'list-group-item'), cssModule);
+
+  // Prevent click event when disabled.
+  if (disabled) {
+    attributes.onClick = handleDisabledOnClick;
+  }
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+ListGroupItem.propTypes = propTypes;
+export default ListGroupItem;

node_modules/reactstrap/esm/ListGroupItemHeading.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function ListGroupItemHeading(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'h5' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'list-group-item-heading'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+ListGroupItemHeading.propTypes = propTypes;
+export default ListGroupItemHeading;

node_modules/reactstrap/esm/ListGroupItemText.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function ListGroupItemText(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'p' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'list-group-item-text'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+ListGroupItemText.propTypes = propTypes;
+export default ListGroupItemText;

node_modules/reactstrap/esm/ListInlineItem.js

@@ -0,0 +1,31 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { forwardRef } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+var ListInlineItem = /*#__PURE__*/forwardRef(function (props, ref) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'li' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'list-inline-item'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: ref
+  }));
+});
+ListInlineItem.name = 'ListInlineItem';
+ListInlineItem.propTypes = propTypes;
+export default ListInlineItem;

node_modules/reactstrap/esm/Media.js

@@ -0,0 +1,68 @@
+var _excluded = ["body", "bottom", "className", "cssModule", "heading", "left", "list", "middle", "object", "right", "tag", "top"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  body: PropTypes.bool,
+  bottom: PropTypes.bool,
+  children: PropTypes.node,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  heading: PropTypes.bool,
+  left: PropTypes.bool,
+  list: PropTypes.bool,
+  middle: PropTypes.bool,
+  object: PropTypes.bool,
+  right: PropTypes.bool,
+  tag: tagPropType,
+  top: PropTypes.bool
+};
+function Media(props) {
+  var body = props.body,
+    bottom = props.bottom,
+    className = props.className,
+    cssModule = props.cssModule,
+    heading = props.heading,
+    left = props.left,
+    list = props.list,
+    middle = props.middle,
+    object = props.object,
+    right = props.right,
+    tag = props.tag,
+    top = props.top,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var defaultTag;
+  if (heading) {
+    defaultTag = 'h4';
+  } else if (attributes.href) {
+    defaultTag = 'a';
+  } else if (attributes.src || object) {
+    defaultTag = 'img';
+  } else if (list) {
+    defaultTag = 'ul';
+  } else {
+    defaultTag = 'div';
+  }
+  var Tag = tag || defaultTag;
+  var classes = mapToCssModules(classNames(className, {
+    'media-body': body,
+    'media-heading': heading,
+    'media-left': left,
+    'media-right': right,
+    'media-top': top,
+    'media-bottom': bottom,
+    'media-middle': middle,
+    'media-object': object,
+    'media-list': list,
+    media: !body && !heading && !left && !right && !top && !bottom && !middle && !object && !list
+  }), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+Media.propTypes = propTypes;
+export default Media;

node_modules/reactstrap/esm/Modal.js

@@ -0,0 +1,498 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Portal from './Portal';
+import Fade from './Fade';
+import { getOriginalBodyPadding, conditionallyUpdateScrollbar, setScrollbarWidth, mapToCssModules, omit, focusableElements, TransitionTimeouts, keyCodes, targetPropType, getTarget } from './utils';
+function noop() {}
+var FadePropTypes = PropTypes.shape(Fade.propTypes);
+var propTypes = {
+  /** */
+  autoFocus: PropTypes.bool,
+  /** Add backdrop to modal */
+  backdrop: PropTypes.oneOfType([PropTypes.bool, PropTypes.oneOf(['static'])]),
+  /** add custom classname to backdrop */
+  backdropClassName: PropTypes.string,
+  backdropTransition: FadePropTypes,
+  /** Vertically center the modal */
+  centered: PropTypes.bool,
+  /** Add children for the modal to wrap */
+  children: PropTypes.node,
+  /** Add custom className for modal content */
+  contentClassName: PropTypes.string,
+  className: PropTypes.string,
+  container: targetPropType,
+  cssModule: PropTypes.object,
+  external: PropTypes.node,
+  /** Enable/Disable animation */
+  fade: PropTypes.bool,
+  /** Make the modal fullscreen */
+  fullscreen: PropTypes.oneOfType([PropTypes.bool, PropTypes.oneOf(['sm', 'md', 'lg', 'xl'])]),
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  /** The status of the modal, either open or close */
+  isOpen: PropTypes.bool,
+  /** Allow modal to be closed with escape key. */
+  keyboard: PropTypes.bool,
+  /** Identifies the element (or elements) that labels the current element. */
+  labelledBy: PropTypes.string,
+  modalClassName: PropTypes.string,
+  modalTransition: FadePropTypes,
+  /** Function to be triggered on close */
+  onClosed: PropTypes.func,
+  /** Function to be triggered on enter */
+  onEnter: PropTypes.func,
+  /** Function to be triggered on exit */
+  onExit: PropTypes.func,
+  /** Function to be triggered on open */
+  onOpened: PropTypes.func,
+  /** Returns focus to the element that triggered opening of the modal */
+  returnFocusAfterClose: PropTypes.bool,
+  /** Accessibility role */
+  role: PropTypes.string,
+  /** Make the modal scrollable */
+  scrollable: PropTypes.bool,
+  /** Two optional sizes `lg` and `sm` */
+  size: PropTypes.string,
+  /** Function to toggle modal visibility */
+  toggle: PropTypes.func,
+  trapFocus: PropTypes.bool,
+  /** Unmounts the modal when modal is closed */
+  unmountOnClose: PropTypes.bool,
+  wrapClassName: PropTypes.string,
+  zIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+};
+var propsToOmit = Object.keys(propTypes);
+var defaultProps = {
+  isOpen: false,
+  autoFocus: true,
+  centered: false,
+  scrollable: false,
+  role: 'dialog',
+  backdrop: true,
+  keyboard: true,
+  zIndex: 1050,
+  fade: true,
+  onOpened: noop,
+  onClosed: noop,
+  modalTransition: {
+    timeout: TransitionTimeouts.Modal
+  },
+  backdropTransition: {
+    mountOnEnter: true,
+    timeout: TransitionTimeouts.Fade // uses standard fade transition
+  },
+
+  unmountOnClose: true,
+  returnFocusAfterClose: true,
+  container: 'body',
+  trapFocus: false
+};
+var Modal = /*#__PURE__*/function (_React$Component) {
+  _inherits(Modal, _React$Component);
+  var _super = _createSuper(Modal);
+  function Modal(props) {
+    var _this;
+    _classCallCheck(this, Modal);
+    _this = _super.call(this, props);
+    _this._element = null;
+    _this._originalBodyPadding = null;
+    _this.getFocusableChildren = _this.getFocusableChildren.bind(_assertThisInitialized(_this));
+    _this.handleBackdropClick = _this.handleBackdropClick.bind(_assertThisInitialized(_this));
+    _this.handleBackdropMouseDown = _this.handleBackdropMouseDown.bind(_assertThisInitialized(_this));
+    _this.handleEscape = _this.handleEscape.bind(_assertThisInitialized(_this));
+    _this.handleStaticBackdropAnimation = _this.handleStaticBackdropAnimation.bind(_assertThisInitialized(_this));
+    _this.handleTab = _this.handleTab.bind(_assertThisInitialized(_this));
+    _this.onOpened = _this.onOpened.bind(_assertThisInitialized(_this));
+    _this.onClosed = _this.onClosed.bind(_assertThisInitialized(_this));
+    _this.manageFocusAfterClose = _this.manageFocusAfterClose.bind(_assertThisInitialized(_this));
+    _this.clearBackdropAnimationTimeout = _this.clearBackdropAnimationTimeout.bind(_assertThisInitialized(_this));
+    _this.trapFocus = _this.trapFocus.bind(_assertThisInitialized(_this));
+    _this.state = {
+      isOpen: false,
+      showStaticBackdropAnimation: false
+    };
+    return _this;
+  }
+  _createClass(Modal, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this$props = this.props,
+        isOpen = _this$props.isOpen,
+        autoFocus = _this$props.autoFocus,
+        onEnter = _this$props.onEnter;
+      if (isOpen) {
+        this.init();
+        this.setState({
+          isOpen: true
+        });
+        if (autoFocus) {
+          this.setFocus();
+        }
+      }
+      if (onEnter) {
+        onEnter();
+      }
+
+      // traps focus inside the Modal, even if the browser address bar is focused
+      document.addEventListener('focus', this.trapFocus, true);
+      this._isMounted = true;
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      if (this.props.isOpen && !prevProps.isOpen) {
+        this.init();
+        this.setState({
+          isOpen: true
+        });
+        // let render() renders Modal Dialog first
+        return;
+      }
+
+      // now Modal Dialog is rendered and we can refer this._element and this._dialog
+      if (this.props.autoFocus && this.state.isOpen && !prevState.isOpen) {
+        this.setFocus();
+      }
+      if (this._element && prevProps.zIndex !== this.props.zIndex) {
+        this._element.style.zIndex = this.props.zIndex;
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.clearBackdropAnimationTimeout();
+      if (this.props.onExit) {
+        this.props.onExit();
+      }
+      if (this._element) {
+        this.destroy();
+        if (this.props.isOpen || this.state.isOpen) {
+          this.close();
+        }
+      }
+      document.removeEventListener('focus', this.trapFocus, true);
+      this._isMounted = false;
+    }
+
+    // not mouseUp because scrollbar fires it, shouldn't close when user scrolls
+  }, {
+    key: "handleBackdropClick",
+    value: function handleBackdropClick(e) {
+      if (e.target === this._mouseDownElement) {
+        e.stopPropagation();
+        var backdrop = this._dialog ? this._dialog.parentNode : null;
+        if (backdrop && e.target === backdrop && this.props.backdrop === 'static') {
+          this.handleStaticBackdropAnimation();
+        }
+        if (!this.props.isOpen || this.props.backdrop !== true) return;
+        if (backdrop && e.target === backdrop && this.props.toggle) {
+          this.props.toggle(e);
+        }
+      }
+    }
+  }, {
+    key: "handleTab",
+    value: function handleTab(e) {
+      if (e.which !== 9) return;
+      if (this.modalIndex < Modal.openCount - 1) return; // last opened modal
+
+      var focusableChildren = this.getFocusableChildren();
+      var totalFocusable = focusableChildren.length;
+      if (totalFocusable === 0) return;
+      var currentFocus = this.getFocusedChild();
+      var focusedIndex = 0;
+      for (var i = 0; i < totalFocusable; i += 1) {
+        if (focusableChildren[i] === currentFocus) {
+          focusedIndex = i;
+          break;
+        }
+      }
+      if (e.shiftKey && focusedIndex === 0) {
+        e.preventDefault();
+        focusableChildren[totalFocusable - 1].focus();
+      } else if (!e.shiftKey && focusedIndex === totalFocusable - 1) {
+        e.preventDefault();
+        focusableChildren[0].focus();
+      }
+    }
+  }, {
+    key: "handleBackdropMouseDown",
+    value: function handleBackdropMouseDown(e) {
+      this._mouseDownElement = e.target;
+    }
+  }, {
+    key: "handleEscape",
+    value: function handleEscape(e) {
+      if (this.props.isOpen && e.keyCode === keyCodes.esc && this.props.toggle) {
+        if (this.props.keyboard) {
+          e.preventDefault();
+          e.stopPropagation();
+          this.props.toggle(e);
+        } else if (this.props.backdrop === 'static') {
+          e.preventDefault();
+          e.stopPropagation();
+          this.handleStaticBackdropAnimation();
+        }
+      }
+    }
+  }, {
+    key: "handleStaticBackdropAnimation",
+    value: function handleStaticBackdropAnimation() {
+      var _this2 = this;
+      this.clearBackdropAnimationTimeout();
+      this.setState({
+        showStaticBackdropAnimation: true
+      });
+      this._backdropAnimationTimeout = setTimeout(function () {
+        _this2.setState({
+          showStaticBackdropAnimation: false
+        });
+      }, 100);
+    }
+  }, {
+    key: "onOpened",
+    value: function onOpened(node, isAppearing) {
+      this.props.onOpened();
+      (this.props.modalTransition.onEntered || noop)(node, isAppearing);
+    }
+  }, {
+    key: "onClosed",
+    value: function onClosed(node) {
+      var unmountOnClose = this.props.unmountOnClose;
+      // so all methods get called before it is unmounted
+      this.props.onClosed();
+      (this.props.modalTransition.onExited || noop)(node);
+      if (unmountOnClose) {
+        this.destroy();
+      }
+      this.close();
+      if (this._isMounted) {
+        this.setState({
+          isOpen: false
+        });
+      }
+    }
+  }, {
+    key: "setFocus",
+    value: function setFocus() {
+      if (this._dialog && this._dialog.parentNode && typeof this._dialog.parentNode.focus === 'function') {
+        this._dialog.parentNode.focus();
+      }
+    }
+  }, {
+    key: "getFocusableChildren",
+    value: function getFocusableChildren() {
+      return this._element.querySelectorAll(focusableElements.join(', '));
+    }
+  }, {
+    key: "getFocusedChild",
+    value: function getFocusedChild() {
+      var currentFocus;
+      var focusableChildren = this.getFocusableChildren();
+      try {
+        currentFocus = document.activeElement;
+      } catch (err) {
+        currentFocus = focusableChildren[0];
+      }
+      return currentFocus;
+    }
+  }, {
+    key: "trapFocus",
+    value: function trapFocus(ev) {
+      if (!this.props.trapFocus) {
+        return;
+      }
+      if (!this._element) {
+        // element is not attached
+        return;
+      }
+      if (this._dialog && this._dialog.parentNode === ev.target) {
+        // initial focus when the Modal is opened
+        return;
+      }
+      if (this.modalIndex < Modal.openCount - 1) {
+        // last opened modal
+        return;
+      }
+      var children = this.getFocusableChildren();
+      for (var i = 0; i < children.length; i += 1) {
+        // focus is already inside the Modal
+        if (children[i] === ev.target) return;
+      }
+      if (children.length > 0) {
+        // otherwise focus the first focusable element in the Modal
+        ev.preventDefault();
+        ev.stopPropagation();
+        children[0].focus();
+      }
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      try {
+        this._triggeringElement = document.activeElement;
+      } catch (err) {
+        this._triggeringElement = null;
+      }
+      if (!this._element) {
+        this._element = document.createElement('div');
+        this._element.setAttribute('tabindex', '-1');
+        this._element.style.position = 'relative';
+        this._element.style.zIndex = this.props.zIndex;
+        this._mountContainer = getTarget(this.props.container);
+        this._mountContainer.appendChild(this._element);
+      }
+      this._originalBodyPadding = getOriginalBodyPadding();
+      if (Modal.openCount < 1) {
+        Modal.originalBodyOverflow = window.getComputedStyle(document.body).overflow;
+      }
+      conditionallyUpdateScrollbar();
+      if (Modal.openCount === 0) {
+        document.body.className = classNames(document.body.className, mapToCssModules('modal-open', this.props.cssModule));
+        document.body.style.overflow = 'hidden';
+      }
+      this.modalIndex = Modal.openCount;
+      Modal.openCount += 1;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (this._element) {
+        this._mountContainer.removeChild(this._element);
+        this._element = null;
+      }
+      this.manageFocusAfterClose();
+    }
+  }, {
+    key: "manageFocusAfterClose",
+    value: function manageFocusAfterClose() {
+      if (this._triggeringElement) {
+        var returnFocusAfterClose = this.props.returnFocusAfterClose;
+        if (this._triggeringElement.focus && returnFocusAfterClose) this._triggeringElement.focus();
+        this._triggeringElement = null;
+      }
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      if (Modal.openCount <= 1) {
+        var modalOpenClassName = mapToCssModules('modal-open', this.props.cssModule);
+        // Use regex to prevent matching `modal-open` as part of a different class, e.g. `my-modal-opened`
+        var modalOpenClassNameRegex = new RegExp("(^| )".concat(modalOpenClassName, "( |$)"));
+        document.body.className = document.body.className.replace(modalOpenClassNameRegex, ' ').trim();
+        document.body.style.overflow = Modal.originalBodyOverflow;
+      }
+      this.manageFocusAfterClose();
+      Modal.openCount = Math.max(0, Modal.openCount - 1);
+      setScrollbarWidth(this._originalBodyPadding);
+    }
+  }, {
+    key: "clearBackdropAnimationTimeout",
+    value: function clearBackdropAnimationTimeout() {
+      if (this._backdropAnimationTimeout) {
+        clearTimeout(this._backdropAnimationTimeout);
+        this._backdropAnimationTimeout = undefined;
+      }
+    }
+  }, {
+    key: "renderModalDialog",
+    value: function renderModalDialog() {
+      var _classNames,
+        _this3 = this;
+      var attributes = omit(this.props, propsToOmit);
+      var dialogBaseClass = 'modal-dialog';
+      return /*#__PURE__*/React.createElement("div", _extends({}, attributes, {
+        className: mapToCssModules(classNames(dialogBaseClass, this.props.className, (_classNames = {}, _defineProperty(_classNames, "modal-".concat(this.props.size), this.props.size), _defineProperty(_classNames, "".concat(dialogBaseClass, "-centered"), this.props.centered), _defineProperty(_classNames, "".concat(dialogBaseClass, "-scrollable"), this.props.scrollable), _defineProperty(_classNames, 'modal-fullscreen', this.props.fullscreen === true), _defineProperty(_classNames, "modal-fullscreen-".concat(this.props.fullscreen, "-down"), typeof this.props.fullscreen === 'string'), _classNames)), this.props.cssModule),
+        role: "document",
+        ref: function ref(c) {
+          _this3._dialog = c;
+        }
+      }), /*#__PURE__*/React.createElement("div", {
+        className: mapToCssModules(classNames('modal-content', this.props.contentClassName), this.props.cssModule)
+      }, this.props.children));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var unmountOnClose = this.props.unmountOnClose;
+      if (!!this._element && (this.state.isOpen || !unmountOnClose)) {
+        var isModalHidden = !!this._element && !this.state.isOpen && !unmountOnClose;
+        this._element.style.display = isModalHidden ? 'none' : 'block';
+        var _this$props2 = this.props,
+          wrapClassName = _this$props2.wrapClassName,
+          modalClassName = _this$props2.modalClassName,
+          backdropClassName = _this$props2.backdropClassName,
+          cssModule = _this$props2.cssModule,
+          isOpen = _this$props2.isOpen,
+          backdrop = _this$props2.backdrop,
+          role = _this$props2.role,
+          labelledBy = _this$props2.labelledBy,
+          external = _this$props2.external,
+          innerRef = _this$props2.innerRef;
+        var modalAttributes = {
+          onClick: this.handleBackdropClick,
+          onMouseDown: this.handleBackdropMouseDown,
+          onKeyUp: this.handleEscape,
+          onKeyDown: this.handleTab,
+          style: {
+            display: 'block'
+          },
+          'aria-labelledby': labelledBy,
+          'aria-modal': true,
+          role: role,
+          tabIndex: '-1'
+        };
+        var hasTransition = this.props.fade;
+        var modalTransition = _objectSpread(_objectSpread(_objectSpread({}, Fade.defaultProps), this.props.modalTransition), {}, {
+          baseClass: hasTransition ? this.props.modalTransition.baseClass : '',
+          timeout: hasTransition ? this.props.modalTransition.timeout : 0
+        });
+        var backdropTransition = _objectSpread(_objectSpread(_objectSpread({}, Fade.defaultProps), this.props.backdropTransition), {}, {
+          baseClass: hasTransition ? this.props.backdropTransition.baseClass : '',
+          timeout: hasTransition ? this.props.backdropTransition.timeout : 0
+        });
+        var Backdrop = backdrop && (hasTransition ? /*#__PURE__*/React.createElement(Fade, _extends({}, backdropTransition, {
+          "in": isOpen && !!backdrop,
+          cssModule: cssModule,
+          className: mapToCssModules(classNames('modal-backdrop', backdropClassName), cssModule)
+        })) : /*#__PURE__*/React.createElement("div", {
+          className: mapToCssModules(classNames('modal-backdrop', 'show', backdropClassName), cssModule)
+        }));
+        return /*#__PURE__*/React.createElement(Portal, {
+          node: this._element
+        }, /*#__PURE__*/React.createElement("div", {
+          className: mapToCssModules(wrapClassName)
+        }, /*#__PURE__*/React.createElement(Fade, _extends({}, modalAttributes, modalTransition, {
+          "in": isOpen,
+          onEntered: this.onOpened,
+          onExited: this.onClosed,
+          cssModule: cssModule,
+          className: mapToCssModules(classNames('modal', modalClassName, this.state.showStaticBackdropAnimation && 'modal-static'), cssModule),
+          innerRef: innerRef
+        }), external, this.renderModalDialog()), Backdrop));
+      }
+      return null;
+    }
+  }]);
+  return Modal;
+}(React.Component);
+Modal.propTypes = propTypes;
+Modal.defaultProps = defaultProps;
+Modal.openCount = 0;
+Modal.originalBodyOverflow = null;
+export default Modal;

node_modules/reactstrap/esm/ModalBody.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function ModalBody(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'modal-body'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+ModalBody.propTypes = propTypes;
+export default ModalBody;

node_modules/reactstrap/esm/ModalFooter.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function ModalFooter(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'modal-footer'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+ModalFooter.propTypes = propTypes;
+export default ModalFooter;

node_modules/reactstrap/esm/ModalHeader.js

@@ -0,0 +1,54 @@
+var _excluded = ["className", "cssModule", "children", "toggle", "tag", "wrapTag", "closeAriaLabel", "close"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Custom close button */
+  close: PropTypes.object,
+  closeAriaLabel: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Function to be triggered when close button is clicked */
+  toggle: PropTypes.func,
+  wrapTag: tagPropType
+};
+function ModalHeader(props) {
+  var closeButton;
+  var className = props.className,
+    cssModule = props.cssModule,
+    children = props.children,
+    toggle = props.toggle,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'h5' : _props$tag,
+    _props$wrapTag = props.wrapTag,
+    WrapTag = _props$wrapTag === void 0 ? 'div' : _props$wrapTag,
+    _props$closeAriaLabel = props.closeAriaLabel,
+    closeAriaLabel = _props$closeAriaLabel === void 0 ? 'Close' : _props$closeAriaLabel,
+    close = props.close,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'modal-header'), cssModule);
+  if (!close && toggle) {
+    closeButton = /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      onClick: toggle,
+      className: mapToCssModules('btn-close', cssModule),
+      "aria-label": closeAriaLabel
+    });
+  }
+  return /*#__PURE__*/React.createElement(WrapTag, _extends({}, attributes, {
+    className: classes
+  }), /*#__PURE__*/React.createElement(Tag, {
+    className: mapToCssModules('modal-title', cssModule)
+  }, children), close || closeButton);
+}
+ModalHeader.propTypes = propTypes;
+export default ModalHeader;

node_modules/reactstrap/esm/Nav.js

@@ -0,0 +1,70 @@
+var _excluded = ["className", "cssModule", "tabs", "pills", "vertical", "horizontal", "justified", "fill", "navbar", "card", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Adding card prop adds `.card-header-tabs` or `.card-header-pills` class */
+  card: PropTypes.bool,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** fills the nav to extend to full available width */
+  fill: PropTypes.bool,
+  /** Change the horizontal alignment of your nav */
+  horizontal: PropTypes.oneOf(['center', 'end']),
+  /**  All horizontal space will be occupied by nav links, but unlike the `fill` above, every nav item will be the same width. */
+  justified: PropTypes.bool,
+  /** Add navbar for a full-height and lightweight navigation */
+  navbar: PropTypes.bool,
+  /** Make NavItems look like pills */
+  pills: PropTypes.bool,
+  /** Make NavItems look like tabs */
+  tabs: PropTypes.bool,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Stack your navigation by changing the flex item direction */
+  vertical: PropTypes.oneOfType([PropTypes.bool, PropTypes.string])
+};
+var getVerticalClass = function getVerticalClass(vertical) {
+  if (vertical === false) {
+    return false;
+  }
+  if (vertical === true || vertical === 'xs') {
+    return 'flex-column';
+  }
+  return "flex-".concat(vertical, "-column");
+};
+function Nav(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    tabs = props.tabs,
+    pills = props.pills,
+    _props$vertical = props.vertical,
+    vertical = _props$vertical === void 0 ? false : _props$vertical,
+    horizontal = props.horizontal,
+    justified = props.justified,
+    fill = props.fill,
+    navbar = props.navbar,
+    card = props.card,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'ul' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, navbar ? 'navbar-nav' : 'nav', horizontal ? "justify-content-".concat(horizontal) : false, getVerticalClass(vertical), {
+    'nav-tabs': tabs,
+    'card-header-tabs': card && tabs,
+    'nav-pills': pills,
+    'card-header-pills': card && pills,
+    'nav-justified': justified,
+    'nav-fill': fill
+  }), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+Nav.propTypes = propTypes;
+export default Nav;

node_modules/reactstrap/esm/NavItem.js

@@ -0,0 +1,32 @@
+var _excluded = ["className", "cssModule", "active", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add active class to element */
+  active: PropTypes.bool,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function NavItem(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    active = props.active,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'li' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'nav-item', active ? 'active' : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+NavItem.propTypes = propTypes;
+export default NavItem;

node_modules/reactstrap/esm/NavLink.js

@@ -0,0 +1,85 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["className", "cssModule", "active", "tag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add active class to NavLink */
+  active: PropTypes.bool,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Disable the link */
+  disabled: PropTypes.bool,
+  href: PropTypes.any,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  /** Function to be triggered on click */
+  onClick: PropTypes.func,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+var NavLink = /*#__PURE__*/function (_React$Component) {
+  _inherits(NavLink, _React$Component);
+  var _super = _createSuper(NavLink);
+  function NavLink(props) {
+    var _this;
+    _classCallCheck(this, NavLink);
+    _this = _super.call(this, props);
+    _this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(NavLink, [{
+    key: "onClick",
+    value: function onClick(e) {
+      if (this.props.disabled) {
+        e.preventDefault();
+        return;
+      }
+      if (this.props.href === '#') {
+        e.preventDefault();
+      }
+      if (this.props.onClick) {
+        this.props.onClick(e);
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        active = _this$props.active,
+        _this$props$tag = _this$props.tag,
+        Tag = _this$props$tag === void 0 ? 'a' : _this$props$tag,
+        innerRef = _this$props.innerRef,
+        attributes = _objectWithoutProperties(_this$props, _excluded);
+      var classes = mapToCssModules(classNames(className, 'nav-link', {
+        disabled: attributes.disabled,
+        active: active
+      }), cssModule);
+      return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+        ref: innerRef,
+        onClick: this.onClick,
+        className: classes
+      }));
+    }
+  }]);
+  return NavLink;
+}(React.Component);
+NavLink.propTypes = propTypes;
+export default NavLink;

node_modules/reactstrap/esm/Navbar.js

@@ -0,0 +1,72 @@
+var _excluded = ["expand", "className", "cssModule", "light", "dark", "fixed", "sticky", "color", "container", "tag", "children"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Theme the navbar by adding a background color  */
+  color: PropTypes.string,
+  /** Use any of the responsive containers to change how wide the content in your navbar is presented. */
+  container: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** This prop is passed if the background is dark, to make the text lighter */
+  dark: PropTypes.bool,
+  /** Determine if to show toggler button */
+  expand: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  /** Make the navbar fixed at the top */
+  fixed: PropTypes.string,
+  /** Add `.navbar-light` class */
+  light: PropTypes.bool,
+  role: PropTypes.string,
+  /** Use `position: sticky` which isn't fully supported in every browser */
+  sticky: PropTypes.string,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+var getExpandClass = function getExpandClass(expand) {
+  if (expand === false) {
+    return false;
+  }
+  if (expand === true || expand === 'xs') {
+    return 'navbar-expand';
+  }
+  return "navbar-expand-".concat(expand);
+};
+function Navbar(props) {
+  var _classNames;
+  var _props$expand = props.expand,
+    expand = _props$expand === void 0 ? false : _props$expand,
+    className = props.className,
+    cssModule = props.cssModule,
+    light = props.light,
+    dark = props.dark,
+    fixed = props.fixed,
+    sticky = props.sticky,
+    color = props.color,
+    _props$container = props.container,
+    container = _props$container === void 0 ? 'fluid' : _props$container,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'nav' : _props$tag,
+    children = props.children,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'navbar', getExpandClass(expand), (_classNames = {
+    'navbar-light': light,
+    'navbar-dark': dark
+  }, _defineProperty(_classNames, "bg-".concat(color), color), _defineProperty(_classNames, "fixed-".concat(fixed), fixed), _defineProperty(_classNames, "sticky-".concat(sticky), sticky), _classNames)), cssModule);
+  var containerClass = container && container === true ? 'container' : "container-".concat(container);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }), container ? /*#__PURE__*/React.createElement("div", {
+    className: containerClass
+  }, children) : children);
+}
+Navbar.propTypes = propTypes;
+export default Navbar;

node_modules/reactstrap/esm/NavbarBrand.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function NavbarBrand(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'a' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'navbar-brand'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+NavbarBrand.propTypes = propTypes;
+export default NavbarBrand;

node_modules/reactstrap/esm/NavbarText.js

@@ -0,0 +1,31 @@
+var _excluded = ["className", "cssModule", "active", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  active: PropTypes.bool
+};
+function NavbarText(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    active = props.active,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'span' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'navbar-text'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+NavbarText.propTypes = propTypes;
+export default NavbarText;

node_modules/reactstrap/esm/NavbarToggler.js

@@ -0,0 +1,42 @@
+var _excluded = ["className", "cssModule", "children", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  type: PropTypes.string,
+  /** Pass children so this component can wrap the child elements */
+  children: PropTypes.node
+};
+function NavbarToggler(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    children = props.children,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'button' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'navbar-toggler'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({
+    "aria-label": "Toggle navigation"
+  }, _objectSpread({
+    type: 'button'
+  }, attributes), {
+    className: classes
+  }), children || /*#__PURE__*/React.createElement("span", {
+    className: mapToCssModules('navbar-toggler-icon', cssModule)
+  }));
+}
+NavbarToggler.propTypes = propTypes;
+export default NavbarToggler;

node_modules/reactstrap/esm/Offcanvas.js

@@ -0,0 +1,424 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import Portal from './Portal';
+import Fade from './Fade';
+import { TransitionTimeouts, conditionallyUpdateScrollbar, focusableElements, getOriginalBodyPadding, getTarget, keyCodes, mapToCssModules, omit, setScrollbarWidth, targetPropType } from './utils';
+function noop() {}
+var FadePropTypes = PropTypes.shape(Fade.propTypes);
+var propTypes = {
+  autoFocus: PropTypes.bool,
+  backdrop: PropTypes.bool,
+  backdropClassName: PropTypes.string,
+  backdropTransition: FadePropTypes,
+  children: PropTypes.node,
+  className: PropTypes.string,
+  container: targetPropType,
+  cssModule: PropTypes.object,
+  direction: PropTypes.oneOf(['start', 'end', 'bottom', 'top']),
+  fade: PropTypes.bool,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  isOpen: PropTypes.bool,
+  keyboard: PropTypes.bool,
+  labelledBy: PropTypes.string,
+  offcanvasTransition: FadePropTypes,
+  onClosed: PropTypes.func,
+  onEnter: PropTypes.func,
+  onExit: PropTypes.func,
+  style: PropTypes.object,
+  onOpened: PropTypes.func,
+  returnFocusAfterClose: PropTypes.bool,
+  role: PropTypes.string,
+  scrollable: PropTypes.bool,
+  toggle: PropTypes.func,
+  trapFocus: PropTypes.bool,
+  unmountOnClose: PropTypes.bool,
+  zIndex: PropTypes.oneOfType([PropTypes.number, PropTypes.string])
+};
+var propsToOmit = Object.keys(propTypes);
+var defaultProps = {
+  isOpen: false,
+  autoFocus: true,
+  direction: 'start',
+  scrollable: false,
+  role: 'dialog',
+  backdrop: true,
+  keyboard: true,
+  zIndex: 1050,
+  fade: true,
+  onOpened: noop,
+  onClosed: noop,
+  offcanvasTransition: {
+    timeout: TransitionTimeouts.Offcanvas
+  },
+  backdropTransition: {
+    mountOnEnter: true,
+    timeout: TransitionTimeouts.Fade // uses standard fade transition
+  },
+
+  unmountOnClose: true,
+  returnFocusAfterClose: true,
+  container: 'body',
+  trapFocus: false
+};
+var Offcanvas = /*#__PURE__*/function (_React$Component) {
+  _inherits(Offcanvas, _React$Component);
+  var _super = _createSuper(Offcanvas);
+  function Offcanvas(props) {
+    var _this;
+    _classCallCheck(this, Offcanvas);
+    _this = _super.call(this, props);
+    _this._element = null;
+    _this._originalBodyPadding = null;
+    _this.getFocusableChildren = _this.getFocusableChildren.bind(_assertThisInitialized(_this));
+    _this.handleBackdropClick = _this.handleBackdropClick.bind(_assertThisInitialized(_this));
+    _this.handleBackdropMouseDown = _this.handleBackdropMouseDown.bind(_assertThisInitialized(_this));
+    _this.handleEscape = _this.handleEscape.bind(_assertThisInitialized(_this));
+    _this.handleTab = _this.handleTab.bind(_assertThisInitialized(_this));
+    _this.onOpened = _this.onOpened.bind(_assertThisInitialized(_this));
+    _this.onClosed = _this.onClosed.bind(_assertThisInitialized(_this));
+    _this.manageFocusAfterClose = _this.manageFocusAfterClose.bind(_assertThisInitialized(_this));
+    _this.clearBackdropAnimationTimeout = _this.clearBackdropAnimationTimeout.bind(_assertThisInitialized(_this));
+    _this.trapFocus = _this.trapFocus.bind(_assertThisInitialized(_this));
+    _this._backdrop = /*#__PURE__*/React.createRef();
+    _this._dialog = /*#__PURE__*/React.createRef();
+    _this.state = {
+      isOpen: false
+    };
+    return _this;
+  }
+  _createClass(Offcanvas, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var _this$props = this.props,
+        isOpen = _this$props.isOpen,
+        autoFocus = _this$props.autoFocus,
+        onEnter = _this$props.onEnter;
+      if (isOpen) {
+        this.init();
+        this.setState({
+          isOpen: true
+        });
+        if (autoFocus) {
+          this.setFocus();
+        }
+      }
+      if (onEnter) {
+        onEnter();
+      }
+
+      // traps focus inside the Offcanvas, even if the browser address bar is focused
+      document.addEventListener('focus', this.trapFocus, true);
+      this._isMounted = true;
+    }
+  }, {
+    key: "componentDidUpdate",
+    value: function componentDidUpdate(prevProps, prevState) {
+      if (this.props.isOpen && !prevProps.isOpen) {
+        this.init();
+        this.setState({
+          isOpen: true
+        });
+        return;
+      }
+
+      // now Offcanvas Dialog is rendered and we can refer this._element and this._dialog
+      if (this.props.autoFocus && this.state.isOpen && !prevState.isOpen) {
+        this.setFocus();
+      }
+      if (this._element && prevProps.zIndex !== this.props.zIndex) {
+        this._element.style.zIndex = this.props.zIndex;
+      }
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this.clearBackdropAnimationTimeout();
+      if (this.props.onExit) {
+        this.props.onExit();
+      }
+      if (this._element) {
+        this.destroy();
+        if (this.props.isOpen || this.state.isOpen) {
+          this.close();
+        }
+      }
+      document.removeEventListener('focus', this.trapFocus, true);
+      this._isMounted = false;
+    }
+
+    // not mouseUp because scrollbar fires it, shouldn't close when user scrolls
+  }, {
+    key: "handleBackdropClick",
+    value: function handleBackdropClick(e) {
+      if (e.target === this._mouseDownElement) {
+        e.stopPropagation();
+        var backdrop = this._backdrop.current;
+        if (!this.props.isOpen || this.props.backdrop !== true) return;
+        if (backdrop && e.target === backdrop && this.props.toggle) {
+          this.props.toggle(e);
+        }
+      }
+    }
+  }, {
+    key: "handleTab",
+    value: function handleTab(e) {
+      if (e.which !== 9) return;
+      if (this.offcanvasIndex < Offcanvas.openCount - 1) return; // last opened offcanvas
+
+      var focusableChildren = this.getFocusableChildren();
+      var totalFocusable = focusableChildren.length;
+      if (totalFocusable === 0) return;
+      var currentFocus = this.getFocusedChild();
+      var focusedIndex = 0;
+      for (var i = 0; i < totalFocusable; i += 1) {
+        if (focusableChildren[i] === currentFocus) {
+          focusedIndex = i;
+          break;
+        }
+      }
+      if (e.shiftKey && focusedIndex === 0) {
+        e.preventDefault();
+        focusableChildren[totalFocusable - 1].focus();
+      } else if (!e.shiftKey && focusedIndex === totalFocusable - 1) {
+        e.preventDefault();
+        focusableChildren[0].focus();
+      }
+    }
+  }, {
+    key: "handleBackdropMouseDown",
+    value: function handleBackdropMouseDown(e) {
+      this._mouseDownElement = e.target;
+    }
+  }, {
+    key: "handleEscape",
+    value: function handleEscape(e) {
+      if (this.props.isOpen && e.keyCode === keyCodes.esc && this.props.toggle) {
+        if (this.props.keyboard) {
+          e.preventDefault();
+          e.stopPropagation();
+          this.props.toggle(e);
+        }
+      }
+    }
+  }, {
+    key: "onOpened",
+    value: function onOpened(node, isAppearing) {
+      this.props.onOpened();
+      (this.props.offcanvasTransition.onEntered || noop)(node, isAppearing);
+    }
+  }, {
+    key: "onClosed",
+    value: function onClosed(node) {
+      var unmountOnClose = this.props.unmountOnClose;
+      // so all methods get called before it is unmounted
+      this.props.onClosed();
+      (this.props.offcanvasTransition.onExited || noop)(node);
+      if (unmountOnClose) {
+        this.destroy();
+      }
+      this.close();
+      if (this._isMounted) {
+        this.setState({
+          isOpen: false
+        });
+      }
+    }
+  }, {
+    key: "setFocus",
+    value: function setFocus() {
+      if (this._dialog.current && typeof this._dialog.current.focus === 'function') {
+        this._dialog.current.focus();
+      }
+    }
+  }, {
+    key: "getFocusableChildren",
+    value: function getFocusableChildren() {
+      return this._element.querySelectorAll(focusableElements.join(', '));
+    }
+  }, {
+    key: "getFocusedChild",
+    value: function getFocusedChild() {
+      var currentFocus;
+      var focusableChildren = this.getFocusableChildren();
+      try {
+        currentFocus = document.activeElement;
+      } catch (err) {
+        currentFocus = focusableChildren[0];
+      }
+      return currentFocus;
+    }
+  }, {
+    key: "trapFocus",
+    value: function trapFocus(ev) {
+      if (!this.props.trapFocus) {
+        return;
+      }
+      if (!this._element) {
+        // element is not attached
+        return;
+      }
+      if (this._dialog.current === ev.target) {
+        // initial focus when the Offcanvas is opened
+        return;
+      }
+      if (this.offcanvasIndex < Offcanvas.openCount - 1) {
+        // last opened offcanvas
+        return;
+      }
+      var children = this.getFocusableChildren();
+      for (var i = 0; i < children.length; i += 1) {
+        // focus is already inside the Offcanvas
+        if (children[i] === ev.target) return;
+      }
+      if (children.length > 0) {
+        // otherwise focus the first focusable element in the Offcanvas
+        ev.preventDefault();
+        ev.stopPropagation();
+        children[0].focus();
+      }
+    }
+  }, {
+    key: "init",
+    value: function init() {
+      try {
+        this._triggeringElement = document.activeElement;
+      } catch (err) {
+        this._triggeringElement = null;
+      }
+      if (!this._element) {
+        this._element = document.createElement('div');
+        this._element.setAttribute('tabindex', '-1');
+        this._element.style.position = 'relative';
+        this._element.style.zIndex = this.props.zIndex;
+        this._mountContainer = getTarget(this.props.container);
+        this._mountContainer.appendChild(this._element);
+      }
+      this._originalBodyPadding = getOriginalBodyPadding();
+      conditionallyUpdateScrollbar();
+      if (Offcanvas.openCount === 0 && this.props.backdrop && !this.props.scrollable) {
+        document.body.style.overflow = 'hidden';
+      }
+      this.offcanvasIndex = Offcanvas.openCount;
+      Offcanvas.openCount += 1;
+    }
+  }, {
+    key: "destroy",
+    value: function destroy() {
+      if (this._element) {
+        this._mountContainer.removeChild(this._element);
+        this._element = null;
+      }
+      this.manageFocusAfterClose();
+    }
+  }, {
+    key: "manageFocusAfterClose",
+    value: function manageFocusAfterClose() {
+      if (this._triggeringElement) {
+        var returnFocusAfterClose = this.props.returnFocusAfterClose;
+        if (this._triggeringElement.focus && returnFocusAfterClose) this._triggeringElement.focus();
+        this._triggeringElement = null;
+      }
+    }
+  }, {
+    key: "close",
+    value: function close() {
+      this.manageFocusAfterClose();
+      Offcanvas.openCount = Math.max(0, Offcanvas.openCount - 1);
+      document.body.style.overflow = null;
+      setScrollbarWidth(this._originalBodyPadding);
+    }
+  }, {
+    key: "clearBackdropAnimationTimeout",
+    value: function clearBackdropAnimationTimeout() {
+      if (this._backdropAnimationTimeout) {
+        clearTimeout(this._backdropAnimationTimeout);
+        this._backdropAnimationTimeout = undefined;
+      }
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this$props2 = this.props,
+        direction = _this$props2.direction,
+        unmountOnClose = _this$props2.unmountOnClose;
+      if (!!this._element && (this.state.isOpen || !unmountOnClose)) {
+        var isOffcanvasHidden = !!this._element && !this.state.isOpen && !unmountOnClose;
+        this._element.style.display = isOffcanvasHidden ? 'none' : 'block';
+        var _this$props3 = this.props,
+          className = _this$props3.className,
+          backdropClassName = _this$props3.backdropClassName,
+          cssModule = _this$props3.cssModule,
+          isOpen = _this$props3.isOpen,
+          backdrop = _this$props3.backdrop,
+          role = _this$props3.role,
+          labelledBy = _this$props3.labelledBy,
+          style = _this$props3.style;
+        var offcanvasAttributes = {
+          onKeyUp: this.handleEscape,
+          onKeyDown: this.handleTab,
+          'aria-labelledby': labelledBy,
+          role: role,
+          tabIndex: '-1'
+        };
+        var hasTransition = this.props.fade;
+        var offcanvasTransition = _objectSpread(_objectSpread(_objectSpread({}, Fade.defaultProps), this.props.offcanvasTransition), {}, {
+          baseClass: hasTransition ? this.props.offcanvasTransition.baseClass : '',
+          timeout: hasTransition ? this.props.offcanvasTransition.timeout : 0
+        });
+        var backdropTransition = _objectSpread(_objectSpread(_objectSpread({}, Fade.defaultProps), this.props.backdropTransition), {}, {
+          baseClass: hasTransition ? this.props.backdropTransition.baseClass : '',
+          timeout: hasTransition ? this.props.backdropTransition.timeout : 0
+        });
+        var Backdrop = backdrop && (hasTransition ? /*#__PURE__*/React.createElement(Fade, _extends({}, backdropTransition, {
+          "in": isOpen && !!backdrop,
+          innerRef: this._backdrop,
+          cssModule: cssModule,
+          className: mapToCssModules(classNames('offcanvas-backdrop', backdropClassName), cssModule),
+          onClick: this.handleBackdropClick,
+          onMouseDown: this.handleBackdropMouseDown
+        })) : /*#__PURE__*/React.createElement("div", {
+          className: mapToCssModules(classNames('offcanvas-backdrop', 'show', backdropClassName), cssModule),
+          ref: this._backdrop,
+          onClick: this.handleBackdropClick,
+          onMouseDown: this.handleBackdropMouseDown
+        }));
+        var attributes = omit(this.props, propsToOmit);
+        return /*#__PURE__*/React.createElement(Portal, {
+          node: this._element
+        }, /*#__PURE__*/React.createElement(Fade, _extends({}, attributes, offcanvasAttributes, offcanvasTransition, {
+          "in": isOpen,
+          onEntered: this.onOpened,
+          onExited: this.onClosed,
+          cssModule: cssModule,
+          className: mapToCssModules(classNames('offcanvas', className, "offcanvas-".concat(direction)), cssModule),
+          innerRef: this._dialog,
+          style: _objectSpread(_objectSpread({}, style), {}, {
+            visibility: isOpen ? 'visible' : 'hidden'
+          })
+        }), this.props.children), Backdrop);
+      }
+      return null;
+    }
+  }]);
+  return Offcanvas;
+}(React.Component);
+Offcanvas.propTypes = propTypes;
+Offcanvas.defaultProps = defaultProps;
+Offcanvas.openCount = 0;
+export default Offcanvas;

node_modules/reactstrap/esm/OffcanvasBody.js

@@ -0,0 +1,26 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function OffcanvasBody(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'offcanvas-body'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+OffcanvasBody.propTypes = propTypes;
+export default OffcanvasBody;

node_modules/reactstrap/esm/OffcanvasHeader.js

@@ -0,0 +1,49 @@
+var _excluded = ["children", "className", "close", "closeAriaLabel", "cssModule", "tag", "toggle", "wrapTag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  close: PropTypes.object,
+  closeAriaLabel: PropTypes.string,
+  cssModule: PropTypes.object,
+  tag: tagPropType,
+  toggle: PropTypes.func,
+  wrapTag: tagPropType
+};
+function OffcanvasHeader(props) {
+  var closeButton;
+  var children = props.children,
+    className = props.className,
+    close = props.close,
+    _props$closeAriaLabel = props.closeAriaLabel,
+    closeAriaLabel = _props$closeAriaLabel === void 0 ? 'Close' : _props$closeAriaLabel,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'h5' : _props$tag,
+    toggle = props.toggle,
+    _props$wrapTag = props.wrapTag,
+    WrapTag = _props$wrapTag === void 0 ? 'div' : _props$wrapTag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'offcanvas-header'), cssModule);
+  if (!close && toggle) {
+    closeButton = /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      onClick: toggle,
+      className: mapToCssModules('btn-close', cssModule),
+      "aria-label": closeAriaLabel
+    });
+  }
+  return /*#__PURE__*/React.createElement(WrapTag, _extends({}, attributes, {
+    className: classes
+  }), /*#__PURE__*/React.createElement(Tag, {
+    className: mapToCssModules('offcanvas-title', cssModule)
+  }, children), close || closeButton);
+}
+OffcanvasHeader.propTypes = propTypes;
+export default OffcanvasHeader;

node_modules/reactstrap/esm/Pagination.js

@@ -0,0 +1,48 @@
+var _excluded = ["className", "listClassName", "cssModule", "size", "tag", "listTag", "aria-label"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Add custom class for list */
+  listClassName: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Make the Pagination bigger or smaller  */
+  size: PropTypes.string,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Set a custom element for list component */
+  listTag: tagPropType,
+  'aria-label': PropTypes.string
+};
+function Pagination(props) {
+  var className = props.className,
+    listClassName = props.listClassName,
+    cssModule = props.cssModule,
+    size = props.size,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'nav' : _props$tag,
+    _props$listTag = props.listTag,
+    ListTag = _props$listTag === void 0 ? 'ul' : _props$listTag,
+    _props$ariaLabel = props['aria-label'],
+    label = _props$ariaLabel === void 0 ? 'pagination' : _props$ariaLabel,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className), cssModule);
+  var listClasses = mapToCssModules(classNames(listClassName, 'pagination', _defineProperty({}, "pagination-".concat(size), !!size)), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, {
+    className: classes,
+    "aria-label": label
+  }, /*#__PURE__*/React.createElement(ListTag, _extends({}, attributes, {
+    className: listClasses
+  })));
+}
+Pagination.propTypes = propTypes;
+export default Pagination;

node_modules/reactstrap/esm/PaginationItem.js

@@ -0,0 +1,39 @@
+var _excluded = ["active", "className", "cssModule", "disabled", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Set item as active */
+  active: PropTypes.bool,
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Set item as disabled */
+  disabled: PropTypes.bool,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function PaginationItem(props) {
+  var active = props.active,
+    className = props.className,
+    cssModule = props.cssModule,
+    disabled = props.disabled,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'li' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'page-item', {
+    active: active,
+    disabled: disabled
+  }), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+PaginationItem.propTypes = propTypes;
+export default PaginationItem;

node_modules/reactstrap/esm/PaginationLink.js

@@ -0,0 +1,81 @@
+var _excluded = ["className", "cssModule", "next", "previous", "first", "last", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  'aria-label': PropTypes.string,
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Add to next button to add default aria label and icon */
+  next: PropTypes.bool,
+  /** Add to previous button to add default aria label and icon */
+  previous: PropTypes.bool,
+  /** Add to first button to add default aria label and icon */
+  first: PropTypes.bool,
+  /** Add to last button to add default aria label and icon */
+  last: PropTypes.bool,
+  /** Set a custom element for this component */
+  tag: tagPropType
+};
+function PaginationLink(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    next = props.next,
+    previous = props.previous,
+    first = props.first,
+    last = props.last,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'a' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'page-link'), cssModule);
+  var defaultAriaLabel;
+  if (previous) {
+    defaultAriaLabel = 'Previous';
+  } else if (next) {
+    defaultAriaLabel = 'Next';
+  } else if (first) {
+    defaultAriaLabel = 'First';
+  } else if (last) {
+    defaultAriaLabel = 'Last';
+  }
+  var ariaLabel = props['aria-label'] || defaultAriaLabel;
+  var defaultCaret;
+  if (previous) {
+    defaultCaret = "\u2039";
+  } else if (next) {
+    defaultCaret = "\u203A";
+  } else if (first) {
+    defaultCaret = "\xAB";
+  } else if (last) {
+    defaultCaret = "\xBB";
+  }
+  var children = props.children;
+  if (children && Array.isArray(children) && children.length === 0) {
+    children = null;
+  }
+  if (!attributes.href && Tag === 'a') {
+    Tag = 'button';
+  }
+  if (previous || next || first || last) {
+    children = [/*#__PURE__*/React.createElement("span", {
+      "aria-hidden": "true",
+      key: "caret"
+    }, children || defaultCaret), /*#__PURE__*/React.createElement("span", {
+      className: "visually-hidden",
+      key: "ariaLabel"
+    }, ariaLabel)];
+  }
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    "aria-label": ariaLabel
+  }), children);
+}
+PaginationLink.propTypes = propTypes;
+export default PaginationLink;

node_modules/reactstrap/esm/Placeholder.js

@@ -0,0 +1,45 @@
+var _excluded = ["className", "cssModule", "color", "innerRef", "tag", "animation", "size", "widths"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import Col, { getColumnClasses } from './Col';
+var propTypes = _objectSpread(_objectSpread({}, Col.propTypes), {}, {
+  /** Add custom color to the placeholder */
+  color: PropTypes.string,
+  /** Add custom tag. */
+  tag: tagPropType,
+  /** Apply either `glow` or `wave` animation. */
+  animation: PropTypes.oneOf(['glow', 'wave']),
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  /** Make the size larger */
+  size: PropTypes.oneOf(['lg', 'sm', 'xs'])
+});
+function Placeholder(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    color = props.color,
+    innerRef = props.innerRef,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'span' : _props$tag,
+    animation = props.animation,
+    size = props.size,
+    widths = props.widths,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var _getColumnClasses = getColumnClasses(attributes, cssModule, widths),
+    modifiedAttributes = _getColumnClasses.modifiedAttributes,
+    colClasses = _getColumnClasses.colClasses;
+  var classes = mapToCssModules(classNames(className, colClasses, 'placeholder' + (animation ? '-' + animation : ''), size ? 'placeholder-' + size : false, color ? 'bg-' + color : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, modifiedAttributes, {
+    className: classes,
+    ref: innerRef
+  }));
+}
+Placeholder.propTypes = propTypes;
+export default Placeholder;

node_modules/reactstrap/esm/PlaceholderButton.js

@@ -0,0 +1,40 @@
+var _excluded = ["cssModule", "className", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import Button from './Button';
+import { getColumnClasses } from './Col';
+var propTypes = {
+  size: PropTypes.string,
+  color: PropTypes.string,
+  outline: PropTypes.bool,
+  className: PropTypes.string,
+  tag: tagPropType,
+  cssModule: PropTypes.object
+};
+function PlaceholderButton(props) {
+  var cssModule = props.cssModule,
+    className = props.className,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? Button : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var _getColumnClasses = getColumnClasses(_objectSpread({
+      color: 'primary'
+    }, attributes), cssModule),
+    modifiedAttributes = _getColumnClasses.modifiedAttributes,
+    colClasses = _getColumnClasses.colClasses;
+  var classes = mapToCssModules(classNames('placeholder', className, colClasses), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, modifiedAttributes, {
+    className: classes,
+    disabled: true
+  }));
+}
+PlaceholderButton.propTypes = propTypes;
+export default PlaceholderButton;

node_modules/reactstrap/esm/Popover.js

@@ -0,0 +1,23 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import React from 'react';
+import classNames from 'classnames';
+import TooltipPopoverWrapper, { propTypes } from './TooltipPopoverWrapper';
+var defaultProps = {
+  placement: 'right',
+  placementPrefix: 'bs-popover',
+  trigger: 'click',
+  offset: [0, 8]
+};
+function Popover(props) {
+  var arrowClasses = classNames('popover-arrow', props.arrowClassName);
+  var popperClasses = classNames('popover', 'show', props.popperClassName);
+  var classes = classNames('popover-inner', props.innerClassName);
+  return /*#__PURE__*/React.createElement(TooltipPopoverWrapper, _extends({}, props, {
+    arrowClassName: arrowClasses,
+    popperClassName: popperClasses,
+    innerClassName: classes
+  }));
+}
+Popover.propTypes = propTypes;
+Popover.defaultProps = defaultProps;
+export default Popover;

node_modules/reactstrap/esm/PopoverBody.js

@@ -0,0 +1,26 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function PopoverBody(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'popover-body'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+PopoverBody.propTypes = propTypes;
+export default PopoverBody;

node_modules/reactstrap/esm/PopoverHeader.js

@@ -0,0 +1,26 @@
+var _excluded = ["className", "cssModule", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+function PopoverHeader(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'h3' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'popover-header'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+PopoverHeader.propTypes = propTypes;
+export default PopoverHeader;

node_modules/reactstrap/esm/PopperContent.js

@@ -0,0 +1,230 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["cssModule", "children", "isOpen", "flip", "target", "offset", "fallbackPlacements", "placementPrefix", "arrowClassName", "hideArrow", "popperClassName", "tag", "container", "modifiers", "strategy", "boundariesElement", "onClosed", "fade", "transition", "placement"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import ReactDOM from 'react-dom';
+import classNames from 'classnames';
+import { Popper as ReactPopper } from 'react-popper';
+import { getTarget, targetPropType, mapToCssModules, DOMElement, tagPropType } from './utils';
+import Fade from './Fade';
+function noop() {}
+var propTypes = {
+  children: PropTypes.oneOfType([PropTypes.node, PropTypes.func]).isRequired,
+  popperClassName: PropTypes.string,
+  placement: PropTypes.string,
+  placementPrefix: PropTypes.string,
+  arrowClassName: PropTypes.string,
+  hideArrow: PropTypes.bool,
+  tag: tagPropType,
+  isOpen: PropTypes.bool,
+  cssModule: PropTypes.object,
+  offset: PropTypes.arrayOf(PropTypes.number),
+  fallbackPlacements: PropTypes.array,
+  flip: PropTypes.bool,
+  container: targetPropType,
+  target: targetPropType.isRequired,
+  modifiers: PropTypes.array,
+  strategy: PropTypes.string,
+  boundariesElement: PropTypes.oneOfType([PropTypes.string, DOMElement]),
+  onClosed: PropTypes.func,
+  fade: PropTypes.bool,
+  transition: PropTypes.shape(Fade.propTypes)
+};
+var defaultProps = {
+  boundariesElement: 'scrollParent',
+  placement: 'auto',
+  hideArrow: false,
+  isOpen: false,
+  offset: [0, 0],
+  flip: true,
+  container: 'body',
+  modifiers: [],
+  onClosed: noop,
+  fade: true,
+  transition: _objectSpread({}, Fade.defaultProps)
+};
+var PopperContent = /*#__PURE__*/function (_React$Component) {
+  _inherits(PopperContent, _React$Component);
+  var _super = _createSuper(PopperContent);
+  function PopperContent(props) {
+    var _this;
+    _classCallCheck(this, PopperContent);
+    _this = _super.call(this, props);
+    _this.setTargetNode = _this.setTargetNode.bind(_assertThisInitialized(_this));
+    _this.getTargetNode = _this.getTargetNode.bind(_assertThisInitialized(_this));
+    _this.getRef = _this.getRef.bind(_assertThisInitialized(_this));
+    _this.onClosed = _this.onClosed.bind(_assertThisInitialized(_this));
+    _this.state = {
+      isOpen: props.isOpen
+    };
+    return _this;
+  }
+  _createClass(PopperContent, [{
+    key: "componentDidUpdate",
+    value: function componentDidUpdate() {
+      if (this._element && this._element.childNodes && this._element.childNodes[0] && this._element.childNodes[0].focus) {
+        this._element.childNodes[0].focus();
+      }
+    }
+  }, {
+    key: "onClosed",
+    value: function onClosed() {
+      this.props.onClosed();
+      this.setState({
+        isOpen: false
+      });
+    }
+  }, {
+    key: "getTargetNode",
+    value: function getTargetNode() {
+      return this.targetNode;
+    }
+  }, {
+    key: "getContainerNode",
+    value: function getContainerNode() {
+      return getTarget(this.props.container);
+    }
+  }, {
+    key: "getRef",
+    value: function getRef(ref) {
+      this._element = ref;
+    }
+  }, {
+    key: "setTargetNode",
+    value: function setTargetNode(node) {
+      this.targetNode = typeof node === 'string' ? getTarget(node) : node;
+    }
+  }, {
+    key: "renderChildren",
+    value: function renderChildren() {
+      var _this$props = this.props,
+        cssModule = _this$props.cssModule,
+        children = _this$props.children,
+        isOpen = _this$props.isOpen,
+        flip = _this$props.flip,
+        target = _this$props.target,
+        offset = _this$props.offset,
+        fallbackPlacements = _this$props.fallbackPlacements,
+        placementPrefix = _this$props.placementPrefix,
+        _arrowClassName = _this$props.arrowClassName,
+        hideArrow = _this$props.hideArrow,
+        _popperClassName = _this$props.popperClassName,
+        tag = _this$props.tag,
+        container = _this$props.container,
+        modifiers = _this$props.modifiers,
+        strategy = _this$props.strategy,
+        boundariesElement = _this$props.boundariesElement,
+        onClosed = _this$props.onClosed,
+        fade = _this$props.fade,
+        transition = _this$props.transition,
+        placement = _this$props.placement,
+        attrs = _objectWithoutProperties(_this$props, _excluded);
+      var arrowClassName = mapToCssModules(classNames('arrow', _arrowClassName), cssModule);
+      var popperClassName = mapToCssModules(classNames(_popperClassName, placementPrefix ? "".concat(placementPrefix, "-auto") : ''), this.props.cssModule);
+      var modifierNames = modifiers.map(function (m) {
+        return m.name;
+      });
+      var baseModifiers = [{
+        name: 'offset',
+        options: {
+          offset: offset
+        }
+      }, {
+        name: 'flip',
+        enabled: flip,
+        options: {
+          fallbackPlacements: fallbackPlacements
+        }
+      }, {
+        name: 'preventOverflow',
+        options: {
+          boundary: boundariesElement
+        }
+      }].filter(function (m) {
+        return !modifierNames.includes(m.name);
+      });
+      var extendedModifiers = [].concat(_toConsumableArray(baseModifiers), _toConsumableArray(modifiers));
+      var popperTransition = _objectSpread(_objectSpread(_objectSpread({}, Fade.defaultProps), transition), {}, {
+        baseClass: fade ? transition.baseClass : '',
+        timeout: fade ? transition.timeout : 0
+      });
+      return /*#__PURE__*/React.createElement(Fade, _extends({}, popperTransition, attrs, {
+        "in": isOpen,
+        onExited: this.onClosed,
+        tag: tag
+      }), /*#__PURE__*/React.createElement(ReactPopper, {
+        referenceElement: this.targetNode,
+        modifiers: extendedModifiers,
+        placement: placement,
+        strategy: strategy
+      }, function (_ref) {
+        var ref = _ref.ref,
+          style = _ref.style,
+          popperPlacement = _ref.placement,
+          isReferenceHidden = _ref.isReferenceHidden,
+          arrowProps = _ref.arrowProps,
+          update = _ref.update;
+        return /*#__PURE__*/React.createElement("div", {
+          ref: ref,
+          style: style,
+          className: popperClassName,
+          "data-popper-placement": popperPlacement,
+          "data-popper-reference-hidden": isReferenceHidden ? 'true' : undefined
+        }, typeof children === 'function' ? children({
+          update: update
+        }) : children, !hideArrow && /*#__PURE__*/React.createElement("span", {
+          ref: arrowProps.ref,
+          className: arrowClassName,
+          style: arrowProps.style
+        }));
+      }));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      this.setTargetNode(this.props.target);
+      if (this.state.isOpen) {
+        return this.props.container === 'inline' ? this.renderChildren() : /*#__PURE__*/ReactDOM.createPortal( /*#__PURE__*/React.createElement("div", {
+          ref: this.getRef
+        }, this.renderChildren()), this.getContainerNode());
+      }
+      return null;
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, state) {
+      if (props.isOpen && !state.isOpen) {
+        return {
+          isOpen: props.isOpen
+        };
+      }
+      return null;
+    }
+  }]);
+  return PopperContent;
+}(React.Component);
+PopperContent.propTypes = propTypes;
+PopperContent.defaultProps = defaultProps;
+export default PopperContent;

node_modules/reactstrap/esm/PopperTargetHelper.js

@@ -0,0 +1,13 @@
+import PropTypes from 'prop-types';
+import { getTarget, targetPropType } from './utils';
+function PopperTargetHelper(props, context) {
+  context.popperManager.setTargetNode(getTarget(props.target));
+  return null;
+}
+PopperTargetHelper.contextTypes = {
+  popperManager: PropTypes.object.isRequired
+};
+PopperTargetHelper.propTypes = {
+  target: targetPropType.isRequired
+};
+export default PopperTargetHelper;

node_modules/reactstrap/esm/Portal.js

@@ -0,0 +1,51 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import ReactDOM from 'react-dom';
+import PropTypes from 'prop-types';
+import { canUseDOM } from './utils';
+var propTypes = {
+  children: PropTypes.node.isRequired,
+  node: PropTypes.any
+};
+var Portal = /*#__PURE__*/function (_React$Component) {
+  _inherits(Portal, _React$Component);
+  var _super = _createSuper(Portal);
+  function Portal() {
+    _classCallCheck(this, Portal);
+    return _super.apply(this, arguments);
+  }
+  _createClass(Portal, [{
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      if (this.defaultNode) {
+        document.body.removeChild(this.defaultNode);
+      }
+      this.defaultNode = null;
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      if (!canUseDOM) {
+        return null;
+      }
+      if (!this.props.node && !this.defaultNode) {
+        this.defaultNode = document.createElement('div');
+        document.body.appendChild(this.defaultNode);
+      }
+      return /*#__PURE__*/ReactDOM.createPortal(this.props.children, this.props.node || this.defaultNode);
+    }
+  }]);
+  return Portal;
+}(React.Component);
+Portal.propTypes = propTypes;
+export default Portal;

node_modules/reactstrap/esm/Progress.js

@@ -0,0 +1,90 @@
+var _excluded = ["children", "className", "barClassName", "cssModule", "value", "min", "max", "animated", "striped", "color", "bar", "multi", "tag", "style", "barStyle", "barAriaValueText", "barAriaLabelledBy"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType, toNumber } from './utils';
+var propTypes = {
+  /** Enable animation to bar */
+  animated: PropTypes.bool,
+  bar: PropTypes.bool,
+  barAriaLabelledBy: PropTypes.string,
+  barAriaValueText: PropTypes.string,
+  barClassName: PropTypes.string,
+  barStyle: PropTypes.object,
+  children: PropTypes.node,
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change underlying component's CSS base class name */
+  cssModule: PropTypes.object,
+  /** Add custom color to the placeholder */
+  color: PropTypes.string,
+  /** Maximum value of progress */
+  max: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  /** Minimum value of progress, defaults to zero */
+  min: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  multi: PropTypes.bool,
+  /** Add stripes to progress bar */
+  striped: PropTypes.bool,
+  style: PropTypes.object,
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Current value of progress */
+  value: PropTypes.oneOfType([PropTypes.string, PropTypes.number])
+};
+function Progress(props) {
+  var children = props.children,
+    className = props.className,
+    barClassName = props.barClassName,
+    cssModule = props.cssModule,
+    _props$value = props.value,
+    value = _props$value === void 0 ? 0 : _props$value,
+    _props$min = props.min,
+    min = _props$min === void 0 ? 0 : _props$min,
+    _props$max = props.max,
+    max = _props$max === void 0 ? 100 : _props$max,
+    animated = props.animated,
+    striped = props.striped,
+    color = props.color,
+    bar = props.bar,
+    multi = props.multi,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    _props$style = props.style,
+    style = _props$style === void 0 ? {} : _props$style,
+    _props$barStyle = props.barStyle,
+    barStyle = _props$barStyle === void 0 ? {} : _props$barStyle,
+    barAriaValueText = props.barAriaValueText,
+    barAriaLabelledBy = props.barAriaLabelledBy,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var percent = toNumber(value) / toNumber(max) * 100;
+  var progressClasses = mapToCssModules(classNames(className, 'progress'), cssModule);
+  var progressBarClasses = mapToCssModules(classNames('progress-bar', bar ? className || barClassName : barClassName, animated ? 'progress-bar-animated' : null, color ? "bg-".concat(color) : null, striped || animated ? 'progress-bar-striped' : null), cssModule);
+  var progressBarProps = {
+    className: progressBarClasses,
+    style: _objectSpread(_objectSpread(_objectSpread({}, bar ? style : {}), barStyle), {}, {
+      width: "".concat(percent, "%")
+    }),
+    role: 'progressbar',
+    'aria-valuenow': value,
+    'aria-valuemin': min,
+    'aria-valuemax': max,
+    'aria-valuetext': barAriaValueText,
+    'aria-labelledby': barAriaLabelledBy,
+    children: children
+  };
+  if (bar) {
+    return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, progressBarProps));
+  }
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    style: style,
+    className: progressClasses
+  }), multi ? children : /*#__PURE__*/React.createElement("div", progressBarProps));
+}
+Progress.propTypes = propTypes;
+export default Progress;

node_modules/reactstrap/esm/Row.js

@@ -0,0 +1,49 @@
+var _excluded = ["className", "cssModule", "noGutters", "tag", "widths"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType, deprecated } from './utils';
+var rowColWidths = ['xs', 'sm', 'md', 'lg', 'xl', 'xxl'];
+var rowColsPropType = PropTypes.oneOfType([PropTypes.number, PropTypes.string]);
+var propTypes = {
+  tag: tagPropType,
+  noGutters: deprecated(PropTypes.bool, 'Please use Bootstrap 5 gutter utility classes. https://getbootstrap.com/docs/5.0/layout/gutters/'),
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  xs: rowColsPropType,
+  sm: rowColsPropType,
+  md: rowColsPropType,
+  lg: rowColsPropType,
+  xl: rowColsPropType,
+  xxl: rowColsPropType,
+  widths: PropTypes.array
+};
+function Row(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    noGutters = props.noGutters,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    _props$widths = props.widths,
+    widths = _props$widths === void 0 ? rowColWidths : _props$widths,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var colClasses = [];
+  widths.forEach(function (colWidth, i) {
+    var colSize = props[colWidth];
+    delete attributes[colWidth];
+    if (!colSize) {
+      return;
+    }
+    var isXs = !i;
+    colClasses.push(isXs ? "row-cols-".concat(colSize) : "row-cols-".concat(colWidth, "-").concat(colSize));
+  });
+  var classes = mapToCssModules(classNames(className, noGutters ? 'gx-0' : null, 'row', colClasses), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+}
+Row.propTypes = propTypes;
+export default Row;

node_modules/reactstrap/esm/Spinner.js

@@ -0,0 +1,47 @@
+var _excluded = ["className", "cssModule", "type", "size", "color", "children", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Set a custom element for this component */
+  tag: tagPropType,
+  /** Change animation of spinner */
+  type: PropTypes.oneOf(['border', 'grow']),
+  /** Change size of spinner */
+  size: PropTypes.oneOf(['sm']),
+  /** Change color of spinner */
+  color: PropTypes.oneOf(['primary', 'secondary', 'success', 'danger', 'warning', 'info', 'light', 'dark']),
+  /** Add custom class */
+  className: PropTypes.string,
+  /** Change existing className with a new className */
+  cssModule: PropTypes.object,
+  /** Pass children so this component can wrap the child elements */
+  children: PropTypes.string
+};
+function Spinner(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$type = props.type,
+    type = _props$type === void 0 ? 'border' : _props$type,
+    size = props.size,
+    color = props.color,
+    _props$children = props.children,
+    children = _props$children === void 0 ? 'Loading...' : _props$children,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, size ? "spinner-".concat(type, "-").concat(size) : false, "spinner-".concat(type), color ? "text-".concat(color) : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({
+    role: "status"
+  }, attributes, {
+    className: classes
+  }), children && /*#__PURE__*/React.createElement("span", {
+    className: mapToCssModules('visually-hidden', cssModule)
+  }, children));
+}
+Spinner.propTypes = propTypes;
+export default Spinner;

node_modules/reactstrap/esm/TabContent.js

@@ -0,0 +1,68 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { TabContext } from './TabContext';
+import { mapToCssModules, omit, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  activeTab: PropTypes.any,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+var TabContent = /*#__PURE__*/function (_Component) {
+  _inherits(TabContent, _Component);
+  var _super = _createSuper(TabContent);
+  function TabContent(props) {
+    var _this;
+    _classCallCheck(this, TabContent);
+    _this = _super.call(this, props);
+    _this.state = {
+      activeTab: _this.props.activeTab
+    };
+    return _this;
+  }
+  _createClass(TabContent, [{
+    key: "render",
+    value: function render() {
+      var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        _this$props$tag = _this$props.tag,
+        Tag = _this$props$tag === void 0 ? 'div' : _this$props$tag;
+      var attributes = omit(this.props, Object.keys(propTypes));
+      var classes = mapToCssModules(classNames('tab-content', className), cssModule);
+      return /*#__PURE__*/React.createElement(TabContext.Provider, {
+        value: {
+          activeTabId: this.state.activeTab
+        }
+      }, /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+        className: classes
+      })));
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(nextProps, prevState) {
+      if (prevState.activeTab !== nextProps.activeTab) {
+        return {
+          activeTab: nextProps.activeTab
+        };
+      }
+      return null;
+    }
+  }]);
+  return TabContent;
+}(Component);
+export default TabContent;
+TabContent.propTypes = propTypes;

node_modules/reactstrap/esm/TabContext.js

@@ -0,0 +1,9 @@
+import React from 'react';
+
+/**
+ * TabContext
+ * {
+ *  activeTabId: PropTypes.any
+ * }
+ */
+export var TabContext = /*#__PURE__*/React.createContext({});

node_modules/reactstrap/esm/TabPane.js

@@ -0,0 +1,35 @@
+var _excluded = ["className", "cssModule", "tabId", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { TabContext } from './TabContext';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  tabId: PropTypes.any
+};
+export default function TabPane(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    tabId = props.tabId,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var getClasses = function getClasses(activeTabId) {
+    return mapToCssModules(classNames('tab-pane', className, {
+      active: tabId === activeTabId
+    }), cssModule);
+  };
+  return /*#__PURE__*/React.createElement(TabContext.Consumer, null, function (_ref) {
+    var activeTabId = _ref.activeTabId;
+    return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+      className: getClasses(activeTabId)
+    }));
+  });
+}
+TabPane.propTypes = propTypes;

node_modules/reactstrap/esm/Table.js

@@ -0,0 +1,63 @@
+var _excluded = ["className", "cssModule", "size", "bordered", "borderless", "striped", "dark", "hover", "responsive", "tag", "responsiveTag", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  /** Adds border to all sides of table */
+  bordered: PropTypes.bool,
+  /** Removes all borders */
+  borderless: PropTypes.bool,
+  /** Adds custom class name to component */
+  className: PropTypes.string,
+  /**  */
+  cssModule: PropTypes.object,
+  /** Makes the table dark */
+  dark: PropTypes.bool,
+  /** Enables a hover state on the rows within `<tbody>` */
+  hover: PropTypes.bool,
+  innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.string, PropTypes.object]),
+  /** Responsive tables allow tables to be scrolled horizontally with ease */
+  responsive: PropTypes.oneOfType([PropTypes.bool, PropTypes.string]),
+  responsiveTag: tagPropType,
+  /** Make tables more compact by cutting cell padding in half when setting size as sm. */
+  size: PropTypes.string,
+  /** Adds zebra-striping to any table row within the `<tbody>` */
+  striped: PropTypes.bool,
+  /** Add custom tag to the component */
+  tag: tagPropType
+};
+function Table(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    size = props.size,
+    bordered = props.bordered,
+    borderless = props.borderless,
+    striped = props.striped,
+    dark = props.dark,
+    hover = props.hover,
+    responsive = props.responsive,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'table' : _props$tag,
+    _props$responsiveTag = props.responsiveTag,
+    ResponsiveTag = _props$responsiveTag === void 0 ? 'div' : _props$responsiveTag,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'table', size ? 'table-' + size : false, bordered ? 'table-bordered' : false, borderless ? 'table-borderless' : false, striped ? 'table-striped' : false, dark ? 'table-dark' : false, hover ? 'table-hover' : false), cssModule);
+  var table = /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    ref: innerRef,
+    className: classes
+  }));
+  if (responsive) {
+    var responsiveClassName = mapToCssModules(responsive === true ? 'table-responsive' : "table-responsive-".concat(responsive), cssModule);
+    return /*#__PURE__*/React.createElement(ResponsiveTag, {
+      className: responsiveClassName
+    }, table);
+  }
+  return table;
+}
+Table.propTypes = propTypes;
+export default Table;

node_modules/reactstrap/esm/Toast.js

@@ -0,0 +1,53 @@
+var _excluded = ["className", "cssModule", "tag", "isOpen", "children", "transition", "fade", "innerRef"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+import Fade from './Fade';
+var propTypes = {
+  children: PropTypes.node,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  fade: PropTypes.bool,
+  isOpen: PropTypes.bool,
+  tag: tagPropType,
+  transition: PropTypes.shape(Fade.propTypes),
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+};
+function Toast(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    _props$isOpen = props.isOpen,
+    isOpen = _props$isOpen === void 0 ? true : _props$isOpen,
+    children = props.children,
+    _props$transition = props.transition,
+    transition = _props$transition === void 0 ? _objectSpread(_objectSpread({}, Fade.defaultProps), {}, {
+      unmountOnExit: true
+    }) : _props$transition,
+    _props$fade = props.fade,
+    fade = _props$fade === void 0 ? true : _props$fade,
+    innerRef = props.innerRef,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'toast'), cssModule);
+  var toastTransition = _objectSpread(_objectSpread(_objectSpread({}, Fade.defaultProps), transition), {}, {
+    baseClass: fade ? transition.baseClass : '',
+    timeout: fade ? transition.timeout : 0
+  });
+  return /*#__PURE__*/React.createElement(Fade, _extends({}, attributes, toastTransition, {
+    tag: Tag,
+    className: classes,
+    "in": isOpen,
+    role: "alert",
+    innerRef: innerRef
+  }), children);
+}
+Toast.propTypes = propTypes;
+export default Toast;

node_modules/reactstrap/esm/ToastBody.js

@@ -0,0 +1,29 @@
+var _excluded = ["className", "cssModule", "innerRef", "tag"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+};
+function ToastBody(props) {
+  var className = props.className,
+    cssModule = props.cssModule,
+    innerRef = props.innerRef,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'div' : _props$tag,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'toast-body'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }));
+}
+ToastBody.propTypes = propTypes;
+export default ToastBody;

node_modules/reactstrap/esm/ToastHeader.js

@@ -0,0 +1,75 @@
+var _excluded = ["className", "cssModule", "children", "toggle", "tag", "wrapTag", "closeAriaLabel", "close", "tagClassName", "icon"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  icon: PropTypes.oneOfType([PropTypes.string, PropTypes.node]),
+  wrapTag: tagPropType,
+  toggle: PropTypes.func,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  children: PropTypes.node,
+  closeAriaLabel: PropTypes.string,
+  charCode: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
+  close: PropTypes.object,
+  tagClassName: PropTypes.string
+};
+function ToastHeader(props) {
+  var closeButton;
+  var icon;
+  var className = props.className,
+    cssModule = props.cssModule,
+    children = props.children,
+    toggle = props.toggle,
+    _props$tag = props.tag,
+    Tag = _props$tag === void 0 ? 'strong' : _props$tag,
+    _props$wrapTag = props.wrapTag,
+    WrapTag = _props$wrapTag === void 0 ? 'div' : _props$wrapTag,
+    _props$closeAriaLabel = props.closeAriaLabel,
+    closeAriaLabel = _props$closeAriaLabel === void 0 ? 'Close' : _props$closeAriaLabel,
+    close = props.close,
+    _props$tagClassName = props.tagClassName,
+    tagClassName = _props$tagClassName === void 0 ? 'me-auto' : _props$tagClassName,
+    iconProp = props.icon,
+    attributes = _objectWithoutProperties(props, _excluded);
+  var classes = mapToCssModules(classNames(className, 'toast-header'), cssModule);
+  if (!close && toggle) {
+    closeButton = /*#__PURE__*/React.createElement("button", {
+      type: "button",
+      onClick: toggle,
+      className: mapToCssModules('btn-close', cssModule),
+      "aria-label": closeAriaLabel
+    });
+  }
+  if (typeof iconProp === 'string') {
+    icon = /*#__PURE__*/React.createElement("svg", {
+      className: mapToCssModules("rounded text-".concat(iconProp)),
+      width: "20",
+      height: "20",
+      xmlns: "http://www.w3.org/2000/svg",
+      preserveAspectRatio: "xMidYMid slice",
+      focusable: "false",
+      role: "img"
+    }, /*#__PURE__*/React.createElement("rect", {
+      fill: "currentColor",
+      width: "100%",
+      height: "100%"
+    }));
+  } else if (iconProp) {
+    icon = iconProp;
+  }
+  return /*#__PURE__*/React.createElement(WrapTag, _extends({}, attributes, {
+    className: classes
+  }), icon, /*#__PURE__*/React.createElement(Tag, {
+    className: mapToCssModules(classNames(tagClassName, {
+      'ms-2': icon != null
+    }), cssModule)
+  }, children), close || closeButton);
+}
+ToastHeader.propTypes = propTypes;
+export default ToastHeader;

node_modules/reactstrap/esm/Tooltip.js

@@ -0,0 +1,24 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+import React from 'react';
+import classNames from 'classnames';
+import TooltipPopoverWrapper, { propTypes } from './TooltipPopoverWrapper';
+import { addDefaultProps } from './utils';
+var defaultProps = {
+  placement: 'top',
+  autohide: true,
+  placementPrefix: 'bs-tooltip',
+  trigger: 'hover focus'
+};
+function Tooltip(props) {
+  var arrowClasses = classNames('tooltip-arrow', props.arrowClassName);
+  var popperClasses = classNames('tooltip', 'show', props.popperClassName);
+  var classes = classNames('tooltip-inner', props.innerClassName);
+  var _props = addDefaultProps(defaultProps, props);
+  return /*#__PURE__*/React.createElement(TooltipPopoverWrapper, _extends({}, _props, {
+    arrowClassName: arrowClasses,
+    popperClassName: popperClasses,
+    innerClassName: classes
+  }));
+}
+Tooltip.propTypes = propTypes;
+export default Tooltip;

node_modules/reactstrap/esm/TooltipPopoverWrapper.js

@@ -0,0 +1,390 @@
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import PropTypes from 'prop-types';
+import PopperContent from './PopperContent';
+import { getTarget, targetPropType, omit, PopperPlacements, mapToCssModules, DOMElement } from './utils';
+export var propTypes = {
+  children: PropTypes.oneOfType([PropTypes.node, PropTypes.func]),
+  placement: PropTypes.oneOf(PopperPlacements),
+  target: targetPropType.isRequired,
+  container: targetPropType,
+  isOpen: PropTypes.bool,
+  disabled: PropTypes.bool,
+  hideArrow: PropTypes.bool,
+  boundariesElement: PropTypes.oneOfType([PropTypes.string, DOMElement]),
+  className: PropTypes.string,
+  innerClassName: PropTypes.string,
+  arrowClassName: PropTypes.string,
+  popperClassName: PropTypes.string,
+  cssModule: PropTypes.object,
+  toggle: PropTypes.func,
+  autohide: PropTypes.bool,
+  placementPrefix: PropTypes.string,
+  delay: PropTypes.oneOfType([PropTypes.shape({
+    show: PropTypes.number,
+    hide: PropTypes.number
+  }), PropTypes.number]),
+  modifiers: PropTypes.array,
+  strategy: PropTypes.string,
+  offset: PropTypes.arrayOf(PropTypes.number),
+  innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.string, PropTypes.object]),
+  trigger: PropTypes.string,
+  fade: PropTypes.bool,
+  flip: PropTypes.bool
+};
+var DEFAULT_DELAYS = {
+  show: 0,
+  hide: 50
+};
+var defaultProps = {
+  isOpen: false,
+  hideArrow: false,
+  autohide: false,
+  delay: DEFAULT_DELAYS,
+  toggle: function toggle() {},
+  trigger: 'click',
+  fade: true
+};
+function isInDOMSubtree(element, subtreeRoot) {
+  return subtreeRoot && (element === subtreeRoot || subtreeRoot.contains(element));
+}
+function isInDOMSubtrees(element) {
+  var subtreeRoots = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return subtreeRoots && subtreeRoots.length && subtreeRoots.filter(function (subTreeRoot) {
+    return isInDOMSubtree(element, subTreeRoot);
+  })[0];
+}
+var TooltipPopoverWrapper = /*#__PURE__*/function (_React$Component) {
+  _inherits(TooltipPopoverWrapper, _React$Component);
+  var _super = _createSuper(TooltipPopoverWrapper);
+  function TooltipPopoverWrapper(props) {
+    var _this;
+    _classCallCheck(this, TooltipPopoverWrapper);
+    _this = _super.call(this, props);
+    _this._targets = [];
+    _this.currentTargetElement = null;
+    _this.addTargetEvents = _this.addTargetEvents.bind(_assertThisInitialized(_this));
+    _this.handleDocumentClick = _this.handleDocumentClick.bind(_assertThisInitialized(_this));
+    _this.removeTargetEvents = _this.removeTargetEvents.bind(_assertThisInitialized(_this));
+    _this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
+    _this.showWithDelay = _this.showWithDelay.bind(_assertThisInitialized(_this));
+    _this.hideWithDelay = _this.hideWithDelay.bind(_assertThisInitialized(_this));
+    _this.onMouseOverTooltipContent = _this.onMouseOverTooltipContent.bind(_assertThisInitialized(_this));
+    _this.onMouseLeaveTooltipContent = _this.onMouseLeaveTooltipContent.bind(_assertThisInitialized(_this));
+    _this.show = _this.show.bind(_assertThisInitialized(_this));
+    _this.hide = _this.hide.bind(_assertThisInitialized(_this));
+    _this.onEscKeyDown = _this.onEscKeyDown.bind(_assertThisInitialized(_this));
+    _this.getRef = _this.getRef.bind(_assertThisInitialized(_this));
+    _this.state = {
+      isOpen: props.isOpen
+    };
+    _this._isMounted = false;
+    return _this;
+  }
+  _createClass(TooltipPopoverWrapper, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      this._isMounted = true;
+      this.updateTarget();
+    }
+  }, {
+    key: "componentWillUnmount",
+    value: function componentWillUnmount() {
+      this._isMounted = false;
+      this.removeTargetEvents();
+      this._targets = null;
+      this.clearShowTimeout();
+      this.clearHideTimeout();
+    }
+  }, {
+    key: "handleDocumentClick",
+    value: function handleDocumentClick(e) {
+      var triggers = this.props.trigger.split(' ');
+      if (triggers.indexOf('legacy') > -1 && (this.props.isOpen || isInDOMSubtrees(e.target, this._targets))) {
+        if (this._hideTimeout) {
+          this.clearHideTimeout();
+        }
+        if (this.props.isOpen && !isInDOMSubtree(e.target, this._popover)) {
+          this.hideWithDelay(e);
+        } else if (!this.props.isOpen) {
+          this.showWithDelay(e);
+        }
+      } else if (triggers.indexOf('click') > -1 && isInDOMSubtrees(e.target, this._targets)) {
+        if (this._hideTimeout) {
+          this.clearHideTimeout();
+        }
+        if (!this.props.isOpen) {
+          this.showWithDelay(e);
+        } else {
+          this.hideWithDelay(e);
+        }
+      }
+    }
+  }, {
+    key: "onMouseOverTooltipContent",
+    value: function onMouseOverTooltipContent() {
+      if (this.props.trigger.indexOf('hover') > -1 && !this.props.autohide) {
+        if (this._hideTimeout) {
+          this.clearHideTimeout();
+        }
+        if (this.state.isOpen && !this.props.isOpen) {
+          this.toggle();
+        }
+      }
+    }
+  }, {
+    key: "onMouseLeaveTooltipContent",
+    value: function onMouseLeaveTooltipContent(e) {
+      if (this.props.trigger.indexOf('hover') > -1 && !this.props.autohide) {
+        if (this._showTimeout) {
+          this.clearShowTimeout();
+        }
+        e.persist();
+        this._hideTimeout = setTimeout(this.hide.bind(this, e), this.getDelay('hide'));
+      }
+    }
+  }, {
+    key: "onEscKeyDown",
+    value: function onEscKeyDown(e) {
+      if (e.key === 'Escape') {
+        this.hide(e);
+      }
+    }
+  }, {
+    key: "getRef",
+    value: function getRef(ref) {
+      var innerRef = this.props.innerRef;
+      if (innerRef) {
+        if (typeof innerRef === 'function') {
+          innerRef(ref);
+        } else if (_typeof(innerRef) === 'object') {
+          innerRef.current = ref;
+        }
+      }
+      this._popover = ref;
+    }
+  }, {
+    key: "getDelay",
+    value: function getDelay(key) {
+      var delay = this.props.delay;
+      if (_typeof(delay) === 'object') {
+        return isNaN(delay[key]) ? DEFAULT_DELAYS[key] : delay[key];
+      }
+      return delay;
+    }
+  }, {
+    key: "getCurrentTarget",
+    value: function getCurrentTarget(target) {
+      if (!target) return null;
+      var index = this._targets.indexOf(target);
+      if (index >= 0) return this._targets[index];
+      return this.getCurrentTarget(target.parentElement);
+    }
+  }, {
+    key: "show",
+    value: function show(e) {
+      if (!this.props.isOpen) {
+        this.clearShowTimeout();
+        this.currentTargetElement = e ? e.currentTarget || this.getCurrentTarget(e.target) : null;
+        if (e && e.composedPath && typeof e.composedPath === 'function') {
+          var path = e.composedPath();
+          this.currentTargetElement = path && path[0] || this.currentTargetElement;
+        }
+        this.toggle(e);
+      }
+    }
+  }, {
+    key: "showWithDelay",
+    value: function showWithDelay(e) {
+      if (this._hideTimeout) {
+        this.clearHideTimeout();
+      }
+      this._showTimeout = setTimeout(this.show.bind(this, e), this.getDelay('show'));
+    }
+  }, {
+    key: "hide",
+    value: function hide(e) {
+      if (this.props.isOpen) {
+        this.clearHideTimeout();
+        this.currentTargetElement = null;
+        this.toggle(e);
+      }
+    }
+  }, {
+    key: "hideWithDelay",
+    value: function hideWithDelay(e) {
+      if (this._showTimeout) {
+        this.clearShowTimeout();
+      }
+      this._hideTimeout = setTimeout(this.hide.bind(this, e), this.getDelay('hide'));
+    }
+  }, {
+    key: "clearShowTimeout",
+    value: function clearShowTimeout() {
+      clearTimeout(this._showTimeout);
+      this._showTimeout = undefined;
+    }
+  }, {
+    key: "clearHideTimeout",
+    value: function clearHideTimeout() {
+      clearTimeout(this._hideTimeout);
+      this._hideTimeout = undefined;
+    }
+  }, {
+    key: "addEventOnTargets",
+    value: function addEventOnTargets(type, handler, isBubble) {
+      this._targets.forEach(function (target) {
+        target.addEventListener(type, handler, isBubble);
+      });
+    }
+  }, {
+    key: "removeEventOnTargets",
+    value: function removeEventOnTargets(type, handler, isBubble) {
+      this._targets.forEach(function (target) {
+        target.removeEventListener(type, handler, isBubble);
+      });
+    }
+  }, {
+    key: "addTargetEvents",
+    value: function addTargetEvents() {
+      if (this.props.trigger) {
+        var triggers = this.props.trigger.split(' ');
+        if (triggers.indexOf('manual') === -1) {
+          if (triggers.indexOf('click') > -1 || triggers.indexOf('legacy') > -1) {
+            document.addEventListener('click', this.handleDocumentClick, true);
+          }
+          if (this._targets && this._targets.length) {
+            if (triggers.indexOf('hover') > -1) {
+              this.addEventOnTargets('mouseover', this.showWithDelay, true);
+              this.addEventOnTargets('mouseout', this.hideWithDelay, true);
+            }
+            if (triggers.indexOf('focus') > -1) {
+              this.addEventOnTargets('focusin', this.show, true);
+              this.addEventOnTargets('focusout', this.hide, true);
+            }
+            this.addEventOnTargets('keydown', this.onEscKeyDown, true);
+          }
+        }
+      }
+    }
+  }, {
+    key: "removeTargetEvents",
+    value: function removeTargetEvents() {
+      if (this._targets) {
+        this.removeEventOnTargets('mouseover', this.showWithDelay, true);
+        this.removeEventOnTargets('mouseout', this.hideWithDelay, true);
+        this.removeEventOnTargets('keydown', this.onEscKeyDown, true);
+        this.removeEventOnTargets('focusin', this.show, true);
+        this.removeEventOnTargets('focusout', this.hide, true);
+      }
+      document.removeEventListener('click', this.handleDocumentClick, true);
+    }
+  }, {
+    key: "updateTarget",
+    value: function updateTarget() {
+      var newTarget = getTarget(this.props.target, true);
+      if (newTarget !== this._targets) {
+        this.removeTargetEvents();
+        this._targets = newTarget ? Array.from(newTarget) : [];
+        this.currentTargetElement = this.currentTargetElement || this._targets[0];
+        this.addTargetEvents();
+      }
+    }
+  }, {
+    key: "toggle",
+    value: function toggle(e) {
+      if (this.props.disabled || !this._isMounted) {
+        return e && e.preventDefault();
+      }
+      return this.props.toggle(e);
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this2 = this;
+      if (this.props.isOpen) {
+        this.updateTarget();
+      }
+      var target = this.currentTargetElement || this._targets[0];
+      if (!target) {
+        return null;
+      }
+      var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        innerClassName = _this$props.innerClassName,
+        isOpen = _this$props.isOpen,
+        hideArrow = _this$props.hideArrow,
+        boundariesElement = _this$props.boundariesElement,
+        placement = _this$props.placement,
+        placementPrefix = _this$props.placementPrefix,
+        arrowClassName = _this$props.arrowClassName,
+        popperClassName = _this$props.popperClassName,
+        container = _this$props.container,
+        modifiers = _this$props.modifiers,
+        strategy = _this$props.strategy,
+        offset = _this$props.offset,
+        fade = _this$props.fade,
+        flip = _this$props.flip,
+        children = _this$props.children;
+      var attributes = omit(this.props, Object.keys(propTypes));
+      var popperClasses = mapToCssModules(popperClassName, cssModule);
+      var classes = mapToCssModules(innerClassName, cssModule);
+      return /*#__PURE__*/React.createElement(PopperContent, {
+        className: className,
+        target: target,
+        isOpen: isOpen,
+        hideArrow: hideArrow,
+        boundariesElement: boundariesElement,
+        placement: placement,
+        placementPrefix: placementPrefix,
+        arrowClassName: arrowClassName,
+        popperClassName: popperClasses,
+        container: container,
+        modifiers: modifiers,
+        strategy: strategy,
+        offset: offset,
+        cssModule: cssModule,
+        fade: fade,
+        flip: flip
+      }, function (_ref) {
+        var update = _ref.update;
+        return /*#__PURE__*/React.createElement("div", _extends({}, attributes, {
+          ref: _this2.getRef,
+          className: classes,
+          role: "tooltip",
+          onMouseOver: _this2.onMouseOverTooltipContent,
+          onMouseLeave: _this2.onMouseLeaveTooltipContent,
+          onKeyDown: _this2.onEscKeyDown
+        }), typeof children === 'function' ? children({
+          update: update
+        }) : children);
+      });
+    }
+  }], [{
+    key: "getDerivedStateFromProps",
+    value: function getDerivedStateFromProps(props, state) {
+      if (props.isOpen && !state.isOpen) {
+        return {
+          isOpen: props.isOpen
+        };
+      }
+      return null;
+    }
+  }]);
+  return TooltipPopoverWrapper;
+}(React.Component);
+TooltipPopoverWrapper.propTypes = propTypes;
+TooltipPopoverWrapper.defaultProps = defaultProps;
+export default TooltipPopoverWrapper;

node_modules/reactstrap/esm/UncontrolledAccordion.js

@@ -0,0 +1,62 @@
+var _excluded = ["defaultOpen", "stayOpen"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
+import { tagPropType } from './utils';
+import Accordion from './Accordion';
+var propTypes = {
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func]),
+  children: PropTypes.node,
+  defaultOpen: PropTypes.oneOfType([PropTypes.array, PropTypes.string]),
+  stayOpen: PropTypes.bool
+};
+function UncontrolledAccordion(_ref) {
+  var defaultOpen = _ref.defaultOpen,
+    stayOpen = _ref.stayOpen,
+    props = _objectWithoutProperties(_ref, _excluded);
+  var _useState = useState(defaultOpen || (stayOpen ? [] : undefined)),
+    _useState2 = _slicedToArray(_useState, 2),
+    open = _useState2[0],
+    setOpen = _useState2[1];
+  var toggle = function toggle(id) {
+    if (stayOpen) {
+      if (open.includes(id)) {
+        setOpen(open.filter(function (accordionId) {
+          return accordionId !== id;
+        }));
+      } else {
+        setOpen([].concat(_toConsumableArray(open), [id]));
+      }
+    } else if (open === id) {
+      setOpen('');
+    } else {
+      setOpen(id);
+    }
+  };
+  return /*#__PURE__*/React.createElement(Accordion, _extends({}, _objectSpread({
+    tag: 'div'
+  }, props), {
+    open: open,
+    toggle: toggle
+  }));
+}
+UncontrolledAccordion.propTypes = propTypes;
+export default UncontrolledAccordion;

node_modules/reactstrap/esm/UncontrolledAlert.js

@@ -0,0 +1,48 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React, { Component } from 'react';
+import Alert from './Alert';
+var UncontrolledAlert = /*#__PURE__*/function (_Component) {
+  _inherits(UncontrolledAlert, _Component);
+  var _super = _createSuper(UncontrolledAlert);
+  function UncontrolledAlert(props) {
+    var _this;
+    _classCallCheck(this, UncontrolledAlert);
+    _this = _super.call(this, props);
+    _this.state = {
+      isOpen: true
+    };
+    _this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(UncontrolledAlert, [{
+    key: "toggle",
+    value: function toggle() {
+      this.setState(function (prevState) {
+        return {
+          isOpen: !prevState.isOpen
+        };
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(Alert, _extends({
+        isOpen: this.state.isOpen,
+        toggle: this.toggle
+      }, this.props));
+    }
+  }]);
+  return UncontrolledAlert;
+}(Component);
+export default UncontrolledAlert;

node_modules/reactstrap/esm/UncontrolledButtonDropdown.js

@@ -0,0 +1,57 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import ButtonDropdown from './ButtonDropdown';
+import { omit } from './utils';
+var omitKeys = ['defaultOpen'];
+var UncontrolledButtonDropdown = /*#__PURE__*/function (_Component) {
+  _inherits(UncontrolledButtonDropdown, _Component);
+  var _super = _createSuper(UncontrolledButtonDropdown);
+  function UncontrolledButtonDropdown(props) {
+    var _this;
+    _classCallCheck(this, UncontrolledButtonDropdown);
+    _this = _super.call(this, props);
+    _this.state = {
+      isOpen: props.defaultOpen || false
+    };
+    _this.toggle = _this.toggle.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(UncontrolledButtonDropdown, [{
+    key: "toggle",
+    value: function toggle() {
+      this.setState(function (prevState) {
+        return {
+          isOpen: !prevState.isOpen
+        };
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement(ButtonDropdown, _extends({
+        isOpen: this.state.isOpen,
+        toggle: this.toggle
+      }, omit(this.props, omitKeys)));
+    }
+  }]);
+  return UncontrolledButtonDropdown;
+}(Component);
+export { UncontrolledButtonDropdown as default };
+UncontrolledButtonDropdown.propTypes = _objectSpread({
+  defaultOpen: PropTypes.bool
+}, ButtonDropdown.propTypes);

node_modules/reactstrap/esm/UncontrolledCarousel.js

@@ -0,0 +1,148 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _excluded = ["defaultActiveIndex", "autoPlay", "indicators", "controls", "items", "goToIndex"];
+function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React, { Component } from 'react';
+import PropTypes from 'prop-types';
+import Carousel from './Carousel';
+import CarouselItem from './CarouselItem';
+import CarouselControl from './CarouselControl';
+import CarouselIndicators from './CarouselIndicators';
+import CarouselCaption from './CarouselCaption';
+var propTypes = {
+  items: PropTypes.array.isRequired,
+  indicators: PropTypes.bool,
+  controls: PropTypes.bool,
+  autoPlay: PropTypes.bool,
+  defaultActiveIndex: PropTypes.number,
+  activeIndex: PropTypes.number,
+  next: PropTypes.func,
+  previous: PropTypes.func,
+  goToIndex: PropTypes.func
+};
+var UncontrolledCarousel = /*#__PURE__*/function (_Component) {
+  _inherits(UncontrolledCarousel, _Component);
+  var _super = _createSuper(UncontrolledCarousel);
+  function UncontrolledCarousel(props) {
+    var _this;
+    _classCallCheck(this, UncontrolledCarousel);
+    _this = _super.call(this, props);
+    _this.animating = false;
+    _this.state = {
+      activeIndex: props.defaultActiveIndex || 0
+    };
+    _this.next = _this.next.bind(_assertThisInitialized(_this));
+    _this.previous = _this.previous.bind(_assertThisInitialized(_this));
+    _this.goToIndex = _this.goToIndex.bind(_assertThisInitialized(_this));
+    _this.onExiting = _this.onExiting.bind(_assertThisInitialized(_this));
+    _this.onExited = _this.onExited.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+  _createClass(UncontrolledCarousel, [{
+    key: "onExiting",
+    value: function onExiting() {
+      this.animating = true;
+    }
+  }, {
+    key: "onExited",
+    value: function onExited() {
+      this.animating = false;
+    }
+  }, {
+    key: "next",
+    value: function next() {
+      var _this2 = this;
+      if (this.animating) return;
+      this.setState(function (prevState) {
+        var nextIndex = prevState.activeIndex === _this2.props.items.length - 1 ? 0 : prevState.activeIndex + 1;
+        return {
+          activeIndex: nextIndex
+        };
+      });
+    }
+  }, {
+    key: "previous",
+    value: function previous() {
+      var _this3 = this;
+      if (this.animating) return;
+      this.setState(function (prevState) {
+        var nextIndex = prevState.activeIndex === 0 ? _this3.props.items.length - 1 : prevState.activeIndex - 1;
+        return {
+          activeIndex: nextIndex
+        };
+      });
+    }
+  }, {
+    key: "goToIndex",
+    value: function goToIndex(newIndex) {
+      if (this.animating) return;
+      this.setState({
+        activeIndex: newIndex
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var _this4 = this;
+      var _this$props = this.props,
+        defaultActiveIndex = _this$props.defaultActiveIndex,
+        _this$props$autoPlay = _this$props.autoPlay,
+        autoPlay = _this$props$autoPlay === void 0 ? true : _this$props$autoPlay,
+        _this$props$indicator = _this$props.indicators,
+        indicators = _this$props$indicator === void 0 ? true : _this$props$indicator,
+        _this$props$controls = _this$props.controls,
+        controls = _this$props$controls === void 0 ? true : _this$props$controls,
+        items = _this$props.items,
+        goToIndex = _this$props.goToIndex,
+        props = _objectWithoutProperties(_this$props, _excluded);
+      var activeIndex = this.state.activeIndex;
+      var slides = items.map(function (item) {
+        var key = item.key || item.src;
+        return /*#__PURE__*/React.createElement(CarouselItem, {
+          onExiting: _this4.onExiting,
+          onExited: _this4.onExited,
+          key: key
+        }, /*#__PURE__*/React.createElement("img", {
+          className: "d-block w-100",
+          src: item.src,
+          alt: item.altText
+        }), /*#__PURE__*/React.createElement(CarouselCaption, {
+          captionText: item.caption,
+          captionHeader: item.header || item.caption
+        }));
+      });
+      return /*#__PURE__*/React.createElement(Carousel, _extends({
+        activeIndex: activeIndex,
+        next: this.next,
+        previous: this.previous,
+        ride: autoPlay ? 'carousel' : undefined
+      }, props), indicators && /*#__PURE__*/React.createElement(CarouselIndicators, {
+        items: items,
+        activeIndex: props.activeIndex || activeIndex,
+        onClickHandler: goToIndex || this.goToIndex
+      }), slides, controls && /*#__PURE__*/React.createElement(CarouselControl, {
+        direction: "prev",
+        directionText: "Previous",
+        onClickHandler: props.previous || this.previous
+      }), controls && /*#__PURE__*/React.createElement(CarouselControl, {
+        direction: "next",
+        directionText: "Next",
+        onClickHandler: props.next || this.next
+      }));
+    }
+  }]);
+  return UncontrolledCarousel;
+}(Component);
+UncontrolledCarousel.propTypes = propTypes;
+export default UncontrolledCarousel;