inital commit

node_modules/reactstrap/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016-Present Eddy Hernandez, Chris Burrell, Evan Sharp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/reactstrap/README.md

@@ -0,0 +1,170 @@
+[![reactstrap](https://cloud.githubusercontent.com/assets/399776/13906899/1de62f0c-ee9f-11e5-95c0-c515fee8e918.png)](https://reactstrap.github.io)
+
+[![NPM Version](https://img.shields.io/npm/v/reactstrap.svg?branch=master)](https://www.npmjs.com/package/reactstrap) [![Build Status](https://github.com/reactstrap/reactstrap/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/reactstrap/reactstrap) [![Coverage Status](https://coveralls.io/repos/github/reactstrap/reactstrap/badge.svg?branch=master)](https://coveralls.io/github/reactstrap/reactstrap?branch=master) [![License](https://img.shields.io/npm/l/reactstrap.svg)](https://github.com/reactstrap/reactstrap/blob/master/LICENSE)
+
+# reactstrap
+
+Stateless React Components for Bootstrap 5.
+
+If you're using Bootstrap 4, you'll need to use [Reactstrap v8](https://deploy-preview-2356--reactstrap.netlify.app/)
+
+## Getting Started
+
+Follow the [create-react-app instructions](https://create-react-app.dev/docs/getting-started) to get started and then follow the reactstrap version of [adding bootstrap](#adding-bootstrap).
+
+### tl;dr
+
+ ```
+npx create-react-app my-app
+cd my-app/
+npm start
+```
+or,  if npx (Node >= 6 and npm >= 5.2 ) not available 
+
+```
+npm install -g create-react-app
+
+create-react-app my-app
+cd my-app/
+npm start
+``` 
+
+Then open [http://localhost:3000/](http://localhost:3000/) to see your app. The initial structure of your app is setup. Next, let's [add reactstrap and bootstrap](#adding-bootstrap).
+
+### Adding Bootstrap
+
+Install reactstrap and Bootstrap from NPM. Reactstrap does not include Bootstrap CSS so this needs to be installed as well:
+
+```
+npm i bootstrap
+npm i reactstrap react react-dom
+```
+
+Import Bootstrap CSS in the ```src/index.js``` file:
+
+```js
+import 'bootstrap/dist/css/bootstrap.css';
+```
+
+Import required reactstrap components within ```src/App.js``` file or your custom component files:
+
+```js
+import { Button } from 'reactstrap';
+```
+
+Now you are ready to use the imported reactstrap components within your component hierarchy defined in the render
+method. Here is an example [`App.js`](https://gist.github.com/Thomas-Smyth/006fd507a7295f17a8473451938f9935) redone
+using reactstrap.
+
+### Dependencies
+
+##### Required Peer Dependencies
+
+These libraries are not bundled with Reactstrap and required at runtime:
+
+  * [**react**](https://www.npmjs.com/package/react)
+  * [**react-dom**](https://www.npmjs.com/package/react-dom)
+
+## About the Project
+
+This library contains React Bootstrap components that favor composition and control. The library does not depend on jQuery or Bootstrap javascript. However, [Poppers.js](https://popper.js.org/) via [react-popper](https://github.com/popperjs/react-popper) is relied upon for advanced positioning of content like Tooltips, Popovers, and auto-flipping Dropdowns.
+
+There are a few core concepts to understand in order to make the most out of this library.
+
+1. Your content is expected to be composed via props.children rather than using named props to pass in Components.
+
+    ```js
+    // Content passed in via props
+    const Example = (props) => {
+      return (
+        <p>This is a tooltip <TooltipTrigger tooltip={TooltipContent}>example</TooltipTrigger>!</p>
+      );
+    }
+
+    // Content passed in as children (Preferred)
+    const PreferredExample = (props) => {
+      return (
+        <p>
+          This is a <a href="#" id="TooltipExample">tooltip</a> example.
+          <Tooltip target="TooltipExample">
+            <TooltipContent/>
+          </Tooltip>
+        </p>
+      );
+    }
+    ```
+
+2. Attributes in this library are used to pass in state, conveniently apply modifier classes, enable advanced functionality (like tether), or automatically include non-content based elements.
+
+    Examples:
+
+    - `isOpen` - current state for items like dropdown, popover, tooltip
+    - `toggle` - callback for toggling `isOpen` in the controlling component
+    - `color` - applies color classes, ex: `<Button color="danger"/>`
+    - `size` - for controlling size classes. ex: `<Button size="sm"/>`
+    - `tag` - customize component output by passing in an element name or Component
+    - boolean based props (attributes) when possible for alternative style classes or `visually-hidden` content
+
+
+## [Documentation](https://reactstrap.github.io)
+
+https://reactstrap.github.io
+
+Documentation search is powered by [Algolia's DocSearch](https://community.algolia.com/docsearch/).
+
+## [CodeSandbox Examples](https://github.com/reactstrap/code-sandbox-examples)
+
+Here are some ready-to-go examples for [CodeSandbox](https://codesandbox.io/) that you can experiment with.
+
+https://github.com/reactstrap/code-sandbox-examples
+
+## [Contributing](CONTRIBUTING.md)
+
+## Development
+
+Install dependencies:
+
+```sh
+yarn install
+```
+
+Run examples at [http://localhost:8080/](http://localhost:8080/) with webpack dev server:
+
+```sh
+yarn start
+```
+
+Run tests & coverage report:
+
+```sh
+yarn cover
+```
+
+Watch tests:
+
+```sh
+yarn test
+```
+
+## Releasing
+
+Release branches/versioning/notes will be automatically created and maintained by the [release-please](https://github.com/googleapis/release-please) github action. When you're ready to publish the release, just merge the release branch. The release will be created, the new package will be published, and the updated docs will be deployed to https://reactstrap.github.io/.
+
+## In the wild
+
+Organizations and projects using `reactstrap`
+
+- [airframe-react](https://github.com/0wczar/airframe-react) - [demo](http://dashboards.webkom.co/react/airframe/) - Airframe provides all the components a developer needs to build data-intensive web apps using React.
+- [component-template](https://reactstrap.github.io/component-template/)
+- [video-react](https://video-react.github.io/)
+- [CoreUI-Free-Bootstrap-Admin-Template](https://github.com/mrholek/CoreUI-Free-Bootstrap-Admin-Template) - [demo](http://coreui.io/demo/React_Demo/#/)
+- [Admin dashboard example app built with reactstrap](https://github.com/reduction-admin/react-reduction) - [demo](https://reduction-admin.firebaseapp.com/)
+- [DevExtreme React Grid](https://devexpress.github.io/devextreme-reactive/react/grid/) - It's a stateless data grid built on top of `reactstrap` with paging, sorting, filtering, grouping, selection, editing and virtual scrolling features.
+- [DevExtreme React Chart](https://devexpress.github.io/devextreme-reactive/react/chart/) - A chart built on top of `reactstrap` that visualizes data using a variety of series types, including bar, line, area, scatter, pie, and more.
+- [reactstrap-scrollspy](https://github.com/keidrun/reactstrap-scrollspy/) - [demo](https://keidrun.github.io/reactstrap-scrollspy/)
+- [formstrap](https://github.com/pedox/formstrap/) - [demo](https://pedox.github.io/formstrap/) - Let your `reactstrap` input component integrate seamlessly using `Formik` 
+- [Jimu UI](https://developers.arcgis.com/experience-builder/api-reference/jimu-ui/) - [demo](https://developers.arcgis.com/experience-builder/storybook/?path=/story/welcome--page) - The UI library for [ArcGIS Experience Builder](https://developers.arcgis.com/experience-builder/)  mapping platform.
+
+Submit a PR to add to this list!
+
+Looking to build, document and publish reusable components built on top of `reactstrap`? Consider forking https://github.com/reactstrap/component-template to kickstart your project!

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;