0.2.0 - Mid migration

web/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.

web/node_modules/reactstrap/README.md

@@ -0,0 +1,279 @@
+[![reactstrap](https://cloud.githubusercontent.com/assets/399776/13906899/1de62f0c-ee9f-11e5-95c0-c515fee8e918.png)](https://reactstrap.github.io)
+
+[![CDNJS](https://img.shields.io/cdnjs/v/reactstrap.svg)](https://cdnjs.com/libraries/reactstrap) [![NPM Version](https://img.shields.io/npm/v/reactstrap.svg?branch=master)](https://www.npmjs.com/package/reactstrap) [![Build Status](https://travis-ci.org/reactstrap/reactstrap.svg?branch=master)](https://travis-ci.org/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 4.
+
+## 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)
+
+##### Optional Dependencies
+
+These libraries are not included in the main distribution file `reactstrap.min.js` and need to be manually
+included when using components that require transitions or popover effects (e.g. Tooltip, Modal, etc).
+
+  * [**react-transition-group**](https://www.npmjs.com/package/react-transition-group)
+  * [**react-popper**](https://www.npmjs.com/package/react-popper)
+
+
+### CDN
+
+If you prefer to include Reactstrap globally by marking `reactstrap` as external in your application, the
+`reactstrap` library provides various single-file distributions, which are hosted on the following CDNs:
+
+* [**cdnjs**](https://cdnjs.com/libraries/reactstrap)
+```html
+<!-- Main version -->
+<script src="https://cdnjs.cloudflare.com/ajax/libs/reactstrap/6.0.1/reactstrap.min.js"></script>
+
+<!-- All optional dependencies version -->
+<script src="https://cdnjs.cloudflare.com/ajax/libs/reactstrap/6.0.1/reactstrap.full.min.js"></script>
+```
+
+* [**unpkg**](https://unpkg.com/reactstrap/)
+```html
+<!-- Main version -->
+<script src="https://unpkg.com/reactstrap@6.0.1/dist/reactstrap.min.js"></script>
+
+<!-- All optional dependencies version -->
+<script src="https://unpkg.com/reactstrap@6.0.1/dist/reactstrap.full.min.js"></script>
+```
+
+> **Note**: To load a specific version of Reactstrap replace `6.0.1` with the version number.
+
+#### Versions
+
+Reactstrap has two primary distribution versions:
+
+1) `reactstrap.min.js`
+
+    This file **excludes** the optional dependencies – `react-popper` and `react-transition-group`.
+    This is the recommended approach (similar approach in Bootstrap's JavaScript components) for including
+    Reactstrap as it reduces the filesize and gives more flexibility in configuring needed dependencies.
+
+    **Recommended use cases:**
+
+      * Small, medium, or large applications
+      * Applications that do not use any transitions or popper components
+      * Applications that directly use `react-popper` or `react-transition-group` – Reactstrap and your application
+        will use the single global version included
+
+ 2) `reactstrap.full.min.js`
+
+    This file **includes** the optional dependencies – `react-popper` and `react-transition-group`
+
+    **Recommended use cases:**
+
+      * Small applications
+
+
+#### Example
+
+```html
+<!doctype html>
+<html lang="en">
+  <head>
+    <!-- Required dependencies -->
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/prop-types/15.6.1/prop-types.min.js"></script>
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/react/16.3.2/umd/react.production.min.js"></script>
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/react-dom/16.3.2/umd/react-dom.production.min.js"></script>
+    <!-- Optional dependencies -->
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/react-transition-group/2.2.1/react-transition-group.min.js"></script>
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.3/umd/popper.min.js"></script>
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/react-popper/0.10.4/umd/react-popper.min.js"></script>
+    <!-- Reactstrap -->
+    <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/reactstrap/6.0.1/reactstrap.min.js"></script>
+    <!-- Lastly, include your app's bundle -->
+    <script type="text/javascript" src="/assets/bundle.js"></script>
+  </head>
+  <body>
+    <div id="my-app" />
+  </body>
+</html>
+```
+
+## About the Project
+
+This library contains React Bootstrap 4 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 `sr-only` 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
+npm install
+```
+
+Run examples at [http://localhost:8080/](http://localhost:8080/) with webpack dev server:
+
+```sh
+npm start
+```
+
+Run tests & coverage report:
+
+```sh
+npm test
+```
+
+Watch tests:
+
+```sh
+npm run test-watch
+```
+
+## Releasing
+
+#### Create Release Branch
+
+Note: you must have the `GITHUB_TOKEN` environment variable set to a valid GitHub token with write access to your repo.
+
+To create a release branch and changelog, run the following command, optionally with a semantic release type (major, minor, patch) (if not provided, it will default to semver (it's best to let it default)):
+
+```bash
+./scripts/release <release-type>
+```
+
+Verify changelog in branch. Create a PR if everything looks good. Merge when tests are green.
+
+#### Tagging and Publishing
+
+Note: you must have write permission to this repo do perform this action
+
+Once the release branch is merged, checkout master and run:
+
+```bash
+./scripts/publish
+```
+
+This will build the current state of master, tag it based on the release version and push the tag up to GitHub. Travis will detect the new tag and publish to npm.
+
+_OR_
+
+You can create a new tag via the GitHub user interface. If you do it this way, make sure to use the correct version as the tag name (eg. `6.2.0`).
+
+## In the wild
+
+Organizations and projects using `reactstrap`
+
+- [availity-reactstrap-validation](https://availity.github.io/availity-reactstrap-validation/)
+- [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` 
+
+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!

web/node_modules/reactstrap/es/Alert.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+import { FadeProps } from './Fade';
+
+export interface UncontrolledAlertProps
+  extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  closeClassName?: string;
+  closeAriaLabel?: string;
+  cssModule?: CSSModule;
+  color?: string;
+  fade?: boolean;
+  tag?: React.ElementType;
+  transition?: FadeProps;
+  innerRef?: React.Ref<HTMLElement>;
+}
+export interface AlertProps extends UncontrolledAlertProps {
+  isOpen?: boolean;
+  toggle?: React.MouseEventHandler<any>;
+}
+
+declare class Alert extends React.Component<AlertProps> {}
+export default Alert;

web/node_modules/reactstrap/es/Alert.js

@@ -0,0 +1,82 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(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,
+  closeClassName: PropTypes.string,
+  closeAriaLabel: PropTypes.string,
+  cssModule: PropTypes.object,
+  color: PropTypes.string,
+  fade: PropTypes.bool,
+  isOpen: PropTypes.bool,
+  toggle: PropTypes.func,
+  tag: tagPropType,
+  transition: PropTypes.shape(Fade.propTypes),
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+};
+var defaultProps = {
+  color: 'success',
+  isOpen: true,
+  tag: 'div',
+  closeAriaLabel: 'Close',
+  fade: true,
+  transition: _objectSpread(_objectSpread({}, Fade.defaultProps), {}, {
+    unmountOnExit: true
+  })
+};
+
+function Alert(props) {
+  var className = props.className,
+      closeClassName = props.closeClassName,
+      closeAriaLabel = props.closeAriaLabel,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      color = props.color,
+      isOpen = props.isOpen,
+      toggle = props.toggle,
+      children = props.children,
+      transition = props.transition,
+      fade = props.fade,
+      innerRef = props.innerRef,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "closeClassName", "closeAriaLabel", "cssModule", "tag", "color", "isOpen", "toggle", "children", "transition", "fade", "innerRef"]);
+
+  var classes = mapToCssModules(classNames(className, 'alert', "alert-" + color, {
+    'alert-dismissible': toggle
+  }), cssModule);
+  var closeClasses = mapToCssModules(classNames('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
+  }, /*#__PURE__*/React.createElement("span", {
+    "aria-hidden": "true"
+  }, "\xD7")) : null, children);
+}
+
+Alert.propTypes = propTypes;
+Alert.defaultProps = defaultProps;
+export default Alert;

web/node_modules/reactstrap/es/Badge.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface BadgeProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  color?: string;
+  pill?: boolean;
+  tag?: React.ElementType;
+  innerRef?: React.Ref<HTMLElement>;
+  cssModule?: CSSModule;
+}
+
+declare class Badge extends React.Component<BadgeProps> {}
+export default Badge;

web/node_modules/reactstrap/es/Badge.js

@@ -0,0 +1,45 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  color: PropTypes.string,
+  pill: PropTypes.bool,
+  tag: tagPropType,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  children: PropTypes.node,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+var defaultProps = {
+  color: 'secondary',
+  pill: false,
+  tag: 'span'
+};
+
+var Badge = function Badge(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      color = props.color,
+      innerRef = props.innerRef,
+      pill = props.pill,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "color", "innerRef", "pill", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'badge', 'badge-' + color, pill ? 'badge-pill' : false), cssModule);
+
+  if (attributes.href && Tag === 'span') {
+    Tag = 'a';
+  }
+
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }));
+};
+
+Badge.propTypes = propTypes;
+Badge.defaultProps = defaultProps;
+export default Badge;

web/node_modules/reactstrap/es/Breadcrumb.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface BreadcrumbProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  listTag?: React.ElementType;
+  listClassName?: string;
+  cssModule?: CSSModule;
+}
+
+declare class Breadcrumb extends React.Component<BreadcrumbProps> {}
+export default Breadcrumb;

web/node_modules/reactstrap/es/Breadcrumb.js

@@ -0,0 +1,44 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  listTag: tagPropType,
+  className: PropTypes.string,
+  listClassName: PropTypes.string,
+  cssModule: PropTypes.object,
+  children: PropTypes.node,
+  'aria-label': PropTypes.string
+};
+var defaultProps = {
+  tag: 'nav',
+  listTag: 'ol',
+  'aria-label': 'breadcrumb'
+};
+
+var Breadcrumb = function Breadcrumb(props) {
+  var className = props.className,
+      listClassName = props.listClassName,
+      cssModule = props.cssModule,
+      children = props.children,
+      Tag = props.tag,
+      ListTag = props.listTag,
+      label = props['aria-label'],
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "listClassName", "cssModule", "children", "tag", "listTag", "aria-label"]);
+
+  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;
+Breadcrumb.defaultProps = defaultProps;
+export default Breadcrumb;

web/node_modules/reactstrap/es/BreadcrumbItem.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface BreadcrumbItemProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  active?: boolean;
+  cssModule?: CSSModule;
+}
+
+declare class BreadcrumbItem extends React.Component<BreadcrumbItemProps> {}
+export default BreadcrumbItem;

web/node_modules/reactstrap/es/BreadcrumbItem.js

@@ -0,0 +1,33 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  active: PropTypes.bool,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+var defaultProps = {
+  tag: 'li'
+};
+
+var BreadcrumbItem = function BreadcrumbItem(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      active = props.active,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "active", "tag"]);
+
+  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;
+BreadcrumbItem.defaultProps = defaultProps;
+export default BreadcrumbItem;

web/node_modules/reactstrap/es/Button.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface ButtonProps
+  extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+  [key: string]: any;
+  outline?: boolean;
+  active?: boolean;
+  block?: boolean;
+  color?: string;
+  tag?: React.ElementType;
+  innerRef?: React.Ref<HTMLButtonElement>;
+  size?: string;
+  cssModule?: CSSModule;
+  close?: boolean;
+}
+
+declare class Button extends React.Component<ButtonProps> {}
+export default Button;

web/node_modules/reactstrap/es/Button.js

@@ -0,0 +1,103 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  active: PropTypes.bool,
+  'aria-label': PropTypes.string,
+  block: PropTypes.bool,
+  color: PropTypes.string,
+  disabled: PropTypes.bool,
+  outline: PropTypes.bool,
+  tag: tagPropType,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  onClick: PropTypes.func,
+  size: PropTypes.string,
+  children: PropTypes.node,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  close: PropTypes.bool
+};
+var defaultProps = {
+  color: 'secondary',
+  tag: 'button'
+};
+
+var Button = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(Button, _React$Component);
+
+  function Button(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  var _proto = Button.prototype;
+
+  _proto.onClick = function onClick(e) {
+    if (this.props.disabled) {
+      e.preventDefault();
+      return;
+    }
+
+    if (this.props.onClick) {
+      return this.props.onClick(e);
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        active = _this$props.active,
+        ariaLabel = _this$props['aria-label'],
+        block = _this$props.block,
+        className = _this$props.className,
+        close = _this$props.close,
+        cssModule = _this$props.cssModule,
+        color = _this$props.color,
+        outline = _this$props.outline,
+        size = _this$props.size,
+        Tag = _this$props.tag,
+        innerRef = _this$props.innerRef,
+        attributes = _objectWithoutPropertiesLoose(_this$props, ["active", "aria-label", "block", "className", "close", "cssModule", "color", "outline", "size", "tag", "innerRef"]);
+
+    if (close && typeof attributes.children === 'undefined') {
+      attributes.children = /*#__PURE__*/React.createElement("span", {
+        "aria-hidden": true
+      }, "\xD7");
+    }
+
+    var btnOutlineColor = "btn" + (outline ? '-outline' : '') + "-" + color;
+    var classes = mapToCssModules(classNames(className, {
+      close: close
+    }, close || 'btn', close || btnOutlineColor, size ? "btn-" + size : false, block ? 'btn-block' : false, {
+      active: active,
+      disabled: this.props.disabled
+    }), cssModule);
+
+    if (attributes.href && Tag === 'button') {
+      Tag = 'a';
+    }
+
+    var defaultAriaLabel = close ? 'Close' : null;
+    return /*#__PURE__*/React.createElement(Tag, _extends({
+      type: Tag === 'button' && attributes.onClick ? 'button' : undefined
+    }, attributes, {
+      className: classes,
+      ref: innerRef,
+      onClick: this.onClick,
+      "aria-label": ariaLabel || defaultAriaLabel
+    }));
+  };
+
+  return Button;
+}(React.Component);
+
+Button.propTypes = propTypes;
+Button.defaultProps = defaultProps;
+export default Button;

web/node_modules/reactstrap/es/ButtonDropdown.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { UncontrolledDropdownProps, DropdownProps } from './Dropdown';
+export {
+  UncontrolledDropdownProps as UncontrolledButtonDropdownProps,
+  DropdownProps as ButtonDropdownProps,
+};
+
+declare class ButtonDropdown extends React.Component<DropdownProps> {}
+export default ButtonDropdown;

web/node_modules/reactstrap/es/ButtonDropdown.js

@@ -0,0 +1,16 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import React from 'react';
+import PropTypes from 'prop-types';
+import Dropdown from './Dropdown';
+var propTypes = {
+  children: PropTypes.node
+};
+
+var ButtonDropdown = function ButtonDropdown(props) {
+  return /*#__PURE__*/React.createElement(Dropdown, _extends({
+    group: true
+  }, props));
+};
+
+ButtonDropdown.propTypes = propTypes;
+export default ButtonDropdown;

web/node_modules/reactstrap/es/ButtonGroup.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface ButtonGroupProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+  size?: string;
+  vertical?: boolean;
+}
+
+declare class ButtonGroup extends React.Component<ButtonGroupProps> {}
+export default ButtonGroup;

web/node_modules/reactstrap/es/ButtonGroup.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  'aria-label': PropTypes.string,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  role: PropTypes.string,
+  size: PropTypes.string,
+  vertical: PropTypes.bool
+};
+var defaultProps = {
+  tag: 'div',
+  role: 'group'
+};
+
+var ButtonGroup = function ButtonGroup(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      size = props.size,
+      vertical = props.vertical,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "size", "vertical", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, size ? 'btn-group-' + size : false, vertical ? 'btn-group-vertical' : 'btn-group'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+ButtonGroup.propTypes = propTypes;
+ButtonGroup.defaultProps = defaultProps;
+export default ButtonGroup;

web/node_modules/reactstrap/es/ButtonToggle.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+
+type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+export interface ButtonToggleProps
+  extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'defaultValue'> {
+  [key: string]: any;
+  defaultValue?: boolean;
+}
+
+declare class ButtonToggle extends React.Component<ButtonToggleProps> {}
+export default ButtonToggle;

web/node_modules/reactstrap/es/ButtonToggle.js

@@ -0,0 +1,94 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import React from "react";
+import PropTypes from 'prop-types';
+import Button from "./Button";
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+var propTypes = {
+  onClick: PropTypes.func,
+  onBlur: PropTypes.func,
+  onFocus: PropTypes.func,
+  defaultValue: PropTypes.bool
+};
+var defaultProps = {
+  defaultValue: false
+};
+
+var ButtonToggle = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(ButtonToggle, _React$Component);
+
+  function ButtonToggle(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.state = {
+      toggled: props.defaultValue,
+      focus: false
+    };
+    _this.onBlur = _this.onBlur.bind(_assertThisInitialized(_this));
+    _this.onFocus = _this.onFocus.bind(_assertThisInitialized(_this));
+    _this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  var _proto = ButtonToggle.prototype;
+
+  _proto.onBlur = function onBlur(e) {
+    if (this.props.onBlur) {
+      this.props.onBlur(e);
+    }
+
+    this.setState({
+      focus: false
+    });
+  };
+
+  _proto.onFocus = function onFocus(e) {
+    if (this.props.onFocus) {
+      this.props.onFocus(e);
+    }
+
+    this.setState({
+      focus: true
+    });
+  };
+
+  _proto.onClick = function onClick(e) {
+    if (this.props.onClick) {
+      this.props.onClick(e);
+    }
+
+    this.setState(function (_ref) {
+      var toggled = _ref.toggled;
+      return {
+        toggled: !toggled
+      };
+    });
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        attributes = _objectWithoutPropertiesLoose(_this$props, ["className"]);
+
+    var classes = mapToCssModules(classNames(className, {
+      focus: this.state.focus
+    }), this.props.cssModule);
+    return /*#__PURE__*/React.createElement(Button, _extends({
+      active: this.state.toggled,
+      onBlur: this.onBlur,
+      onFocus: this.onFocus,
+      onClick: this.onClick,
+      className: classes
+    }, attributes));
+  };
+
+  return ButtonToggle;
+}(React.Component);
+
+ButtonToggle.propTypes = propTypes;
+ButtonToggle.defaultProps = defaultProps;
+export default ButtonToggle;

web/node_modules/reactstrap/es/ButtonToolbar.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface ButtonToolbarProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class ButtonToolbar extends React.Component<ButtonToolbarProps> {}
+export default ButtonToolbar;

web/node_modules/reactstrap/es/ButtonToolbar.js

@@ -0,0 +1,33 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  'aria-label': PropTypes.string,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  role: PropTypes.string
+};
+var defaultProps = {
+  tag: 'div',
+  role: 'toolbar'
+};
+
+var ButtonToolbar = function ButtonToolbar(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'btn-toolbar'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+ButtonToolbar.propTypes = propTypes;
+ButtonToolbar.defaultProps = defaultProps;
+export default ButtonToolbar;

web/node_modules/reactstrap/es/Card.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  inverse?: boolean;
+  color?: string;
+  body?: boolean;
+  outline?: boolean;
+  cssModule?: CSSModule;
+  innerRef?: React.Ref<HTMLElement>;
+}
+
+declare class Card extends React.Component<CardProps> {}
+export default Card;

web/node_modules/reactstrap/es/Card.js

@@ -0,0 +1,41 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  inverse: PropTypes.bool,
+  color: PropTypes.string,
+  body: PropTypes.bool,
+  outline: PropTypes.bool,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var Card = function Card(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      color = props.color,
+      body = props.body,
+      inverse = props.inverse,
+      outline = props.outline,
+      Tag = props.tag,
+      innerRef = props.innerRef,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "color", "body", "inverse", "outline", "tag", "innerRef"]);
+
+  var classes = mapToCssModules(classNames(className, 'card', inverse ? 'text-white' : false, body ? 'card-body' : false, color ? (outline ? 'border' : 'bg') + "-" + color : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }));
+};
+
+Card.propTypes = propTypes;
+Card.defaultProps = defaultProps;
+export default Card;

web/node_modules/reactstrap/es/CardBody.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardBodyProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+  innerRef?: React.Ref<HTMLElement>;
+}
+
+declare class CardBody extends React.Component<CardBodyProps> {}
+export default CardBody;

web/node_modules/reactstrap/es/CardBody.js

@@ -0,0 +1,33 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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])
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardBody = function CardBody(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      innerRef = props.innerRef,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "innerRef", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-body'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes,
+    ref: innerRef
+  }));
+};
+
+CardBody.propTypes = propTypes;
+CardBody.defaultProps = defaultProps;
+export default CardBody;

web/node_modules/reactstrap/es/CardColumns.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardColumnsProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardColumns extends React.Component<CardColumnsProps> {}
+export default CardColumns;

web/node_modules/reactstrap/es/CardColumns.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardColumns = function CardColumns(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-columns'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardColumns.propTypes = propTypes;
+CardColumns.defaultProps = defaultProps;
+export default CardColumns;

web/node_modules/reactstrap/es/CardDeck.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardDeckProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardDeck extends React.Component<CardDeckProps> {}
+export default CardDeck;

web/node_modules/reactstrap/es/CardDeck.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardDeck = function CardDeck(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-deck'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardDeck.propTypes = propTypes;
+CardDeck.defaultProps = defaultProps;
+export default CardDeck;

web/node_modules/reactstrap/es/CardFooter.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardFooterProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardFooter extends React.Component<CardFooterProps> {}
+export default CardFooter;

web/node_modules/reactstrap/es/CardFooter.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardFooter = function CardFooter(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-footer'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardFooter.propTypes = propTypes;
+CardFooter.defaultProps = defaultProps;
+export default CardFooter;

web/node_modules/reactstrap/es/CardGroup.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardGroupProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardGroup extends React.Component<CardGroupProps> {}
+export default CardGroup;

web/node_modules/reactstrap/es/CardGroup.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardGroup = function CardGroup(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-group'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardGroup.propTypes = propTypes;
+CardGroup.defaultProps = defaultProps;
+export default CardGroup;

web/node_modules/reactstrap/es/CardHeader.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardHeaderProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardHeader extends React.Component<CardHeaderProps> {}
+export default CardHeader;

web/node_modules/reactstrap/es/CardHeader.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardHeader = function CardHeader(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-header'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardHeader.propTypes = propTypes;
+CardHeader.defaultProps = defaultProps;
+export default CardHeader;

web/node_modules/reactstrap/es/CardImg.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardImgProps
+  extends React.ImgHTMLAttributes<HTMLImageElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  top?: boolean;
+  bottom?: boolean;
+  cssModule?: CSSModule;
+}
+
+declare class CardImg extends React.Component<CardImgProps> {}
+export default CardImg;

web/node_modules/reactstrap/es/CardImg.js

@@ -0,0 +1,44 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules, tagPropType } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  top: PropTypes.bool,
+  bottom: PropTypes.bool,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+var defaultProps = {
+  tag: 'img'
+};
+
+var CardImg = function CardImg(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      top = props.top,
+      bottom = props.bottom,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "top", "bottom", "tag"]);
+
+  var cardImgClassName = 'card-img';
+
+  if (top) {
+    cardImgClassName = 'card-img-top';
+  }
+
+  if (bottom) {
+    cardImgClassName = 'card-img-bottom';
+  }
+
+  var classes = mapToCssModules(classNames(className, cardImgClassName), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardImg.propTypes = propTypes;
+CardImg.defaultProps = defaultProps;
+export default CardImg;

web/node_modules/reactstrap/es/CardImgOverlay.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardImgOverlayProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardImgOverlay extends React.Component<CardImgOverlayProps> {}
+export default CardImgOverlay;

web/node_modules/reactstrap/es/CardImgOverlay.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardImgOverlay = function CardImgOverlay(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-img-overlay'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardImgOverlay.propTypes = propTypes;
+CardImgOverlay.defaultProps = defaultProps;
+export default CardImgOverlay;

web/node_modules/reactstrap/es/CardLink.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardLinkProps
+  extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  innerRef?: React.Ref<HTMLAnchorElement>;
+  cssModule?: CSSModule;
+}
+
+declare class CardLink extends React.Component<CardLinkProps> {}
+export default CardLink;

web/node_modules/reactstrap/es/CardLink.js

@@ -0,0 +1,33 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'a'
+};
+
+var CardLink = function CardLink(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      innerRef = props.innerRef,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag", "innerRef"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-link'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    ref: innerRef,
+    className: classes
+  }));
+};
+
+CardLink.propTypes = propTypes;
+CardLink.defaultProps = defaultProps;
+export default CardLink;

web/node_modules/reactstrap/es/CardSubtitle.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardSubtitleProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardSubtitle extends React.Component<CardSubtitleProps> {}
+export default CardSubtitle;

web/node_modules/reactstrap/es/CardSubtitle.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardSubtitle = function CardSubtitle(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-subtitle'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardSubtitle.propTypes = propTypes;
+CardSubtitle.defaultProps = defaultProps;
+export default CardSubtitle;

web/node_modules/reactstrap/es/CardText.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardTextProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardText extends React.Component<CardTextProps> {}
+export default CardText;

web/node_modules/reactstrap/es/CardText.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'p'
+};
+
+var CardText = function CardText(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-text'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardText.propTypes = propTypes;
+CardText.defaultProps = defaultProps;
+export default CardText;

web/node_modules/reactstrap/es/CardTitle.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CardTitleProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class CardTitle extends React.Component<CardTitleProps> {}
+export default CardTitle;

web/node_modules/reactstrap/es/CardTitle.js

@@ -0,0 +1,30 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var CardTitle = function CardTitle(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, 'card-title'), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+CardTitle.propTypes = propTypes;
+CardTitle.defaultProps = defaultProps;
+export default CardTitle;

web/node_modules/reactstrap/es/Carousel.d.ts

@@ -0,0 +1,33 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+interface CommonCarouselProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  activeIndex?: number;
+  keyboard?: boolean;
+  pause?: 'hover' | false;
+  ride?: 'carousel';
+  interval?: number | string | boolean;
+  mouseEnter?: () => void;
+  mouseExit?: () => void;
+  slide?: boolean;
+  cssModule?: CSSModule;
+  enableTouch?: boolean;
+}
+
+export interface CarouselProps extends CommonCarouselProps {
+  next: () => void;
+  previous: () => void;
+}
+
+export interface UncontrolledCarouselProps extends CommonCarouselProps {
+  items: any[];
+  next?: () => void;
+  previous?: () => void;
+  controls?: boolean;
+  indicators?: boolean;
+  autoPlay?: boolean;
+}
+
+declare class Carousel extends React.Component<CarouselProps> {}
+export default Carousel;

web/node_modules/reactstrap/es/Carousel.js

@@ -0,0 +1,320 @@
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import CarouselItem from './CarouselItem';
+import { mapToCssModules } from './utils';
+var SWIPE_THRESHOLD = 40;
+
+var Carousel = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(Carousel, _React$Component);
+
+  function Carousel(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _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: 'right',
+      indicatorClicked: false
+    };
+    return _this;
+  }
+
+  var _proto = Carousel.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    return {
+      direction: this.state.direction
+    };
+  };
+
+  _proto.componentDidMount = 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);
+  };
+
+  Carousel.getDerivedStateFromProps = 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 = 'right';
+      } else if (nextProps.activeIndex === activeIndex - 1) {
+        direction = 'left';
+      } else if (nextProps.activeIndex < activeIndex) {
+        direction = indicatorClicked ? 'left' : 'right';
+      } else if (nextProps.activeIndex !== activeIndex) {
+        direction = indicatorClicked ? 'right' : 'left';
+      }
+
+      newState = {
+        activeIndex: nextProps.activeIndex,
+        direction: direction,
+        indicatorClicked: false
+      };
+    }
+
+    return newState;
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps, prevState) {
+    if (prevState.activeIndex === this.state.activeIndex) return;
+    this.setInterval(this.props);
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.clearInterval();
+    document.removeEventListener('keyup', this.handleKeyPress);
+  };
+
+  _proto.setInterval = function (_setInterval) {
+    function setInterval() {
+      return _setInterval.apply(this, arguments);
+    }
+
+    setInterval.toString = function () {
+      return _setInterval.toString();
+    };
+
+    return setInterval;
+  }(function (props) {
+    if (props === void 0) {
+      props = this.props;
+    }
+
+    // make sure not to have multiple intervals going...
+    this.clearInterval();
+
+    if (props.interval) {
+      this.cycleInterval = setInterval(function () {
+        props.next();
+      }, parseInt(props.interval, 10));
+    }
+  });
+
+  _proto.clearInterval = function (_clearInterval) {
+    function clearInterval() {
+      return _clearInterval.apply(this, arguments);
+    }
+
+    clearInterval.toString = function () {
+      return _clearInterval.toString();
+    };
+
+    return clearInterval;
+  }(function () {
+    clearInterval(this.cycleInterval);
+  });
+
+  _proto.hoverStart = 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);
+    }
+  };
+
+  _proto.hoverEnd = 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);
+    }
+  };
+
+  _proto.handleKeyPress = function handleKeyPress(evt) {
+    if (this.props.keyboard) {
+      if (evt.keyCode === 37) {
+        this.props.previous();
+      } else if (evt.keyCode === 39) {
+        this.props.next();
+      }
+    }
+  };
+
+  _proto.handleTouchStart = function handleTouchStart(e) {
+    if (!this.props.enableTouch) {
+      return;
+    }
+
+    this.touchStartX = e.changedTouches[0].screenX;
+    this.touchStartY = e.changedTouches[0].screenY;
+  };
+
+  _proto.handleTouchEnd = 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();
+    }
+  };
+
+  _proto.renderItems = function renderItems(carouselItems, className) {
+    var _this2 = this;
+
+    var slide = this.props.slide;
+    return /*#__PURE__*/React.createElement("div", {
+      className: className
+    }, carouselItems.map(function (item, index) {
+      var isIn = index === _this2.state.activeIndex;
+      return /*#__PURE__*/React.cloneElement(item, {
+        in: isIn,
+        slide: slide
+      });
+    }));
+  };
+
+  _proto.render = function render() {
+    var _this3 = this;
+
+    var _this$props3 = this.props,
+        cssModule = _this$props3.cssModule,
+        slide = _this$props3.slide,
+        className = _this$props3.className;
+    var outerClasses = mapToCssModules(classNames(className, 'carousel', slide && 'slide'), 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", {
+        className: outerClasses,
+        onMouseEnter: this.hoverStart,
+        onMouseLeave: this.hoverEnd
+      }, this.renderItems(children, innerClasses));
+    } // Rendering slides and controls
+
+
+    if (children[0] instanceof Array) {
+      var _carouselItems = children[0];
+      var _controlLeft = children[1];
+      var _controlRight = children[2];
+      return /*#__PURE__*/React.createElement("div", {
+        className: outerClasses,
+        onMouseEnter: this.hoverStart,
+        onMouseLeave: this.hoverEnd
+      }, this.renderItems(_carouselItems, innerClasses), _controlLeft, _controlRight);
+    } // Rendering indicators, slides and controls
+
+
+    var indicators = children[0];
+
+    var wrappedOnClick = function wrappedOnClick(e) {
+      if (typeof indicators.props.onClickHandler === 'function') {
+        _this3.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", {
+      className: outerClasses,
+      onMouseEnter: this.hoverStart,
+      onMouseLeave: this.hoverEnd,
+      onTouchStart: this.handleTouchStart,
+      onTouchEnd: this.handleTouchEnd
+    }, wrappedIndicators, this.renderItems(carouselItems, innerClasses), controlLeft, controlRight);
+  };
+
+  return Carousel;
+}(React.Component);
+
+Carousel.propTypes = {
+  // the current active slide of the carousel
+  activeIndex: PropTypes.number,
+  // a function which should advance the carousel to the next slide (via activeIndex)
+  next: PropTypes.func.isRequired,
+  // a function which should advance the carousel to the previous slide (via activeIndex)
+  previous: PropTypes.func.isRequired,
+  // controls if the left and right arrow keys should control the carousel
+  keyboard: PropTypes.bool,
+
+  /* If set to "hover", pauses the cycling of the carousel on mouseenter and resumes the cycling of the carousel on
+   * mouseleave. If set to false, hovering over the carousel won't pause it. (default: "hover")
+   */
+  pause: PropTypes.oneOf(['hover', false]),
+  // Autoplays the carousel after the user manually cycles the first item. If "carousel", autoplays the carousel on load.
+  // This is how bootstrap defines it... I would prefer a bool named autoplay or something...
+  ride: PropTypes.oneOf(['carousel']),
+  // the interval at which the carousel automatically cycles (default: 5000)
+  // eslint-disable-next-line react/no-unused-prop-types
+  interval: PropTypes.oneOfType([PropTypes.number, PropTypes.string, PropTypes.bool]),
+  children: PropTypes.array,
+  // called when the mouse enters the Carousel
+  mouseEnter: PropTypes.func,
+  // called when the mouse exits the Carousel
+  mouseLeave: PropTypes.func,
+  // controls whether the slide animation on the Carousel works or not
+  slide: PropTypes.bool,
+  cssModule: PropTypes.object,
+  className: PropTypes.string,
+  enableTouch: PropTypes.bool
+};
+Carousel.defaultProps = {
+  interval: 5000,
+  pause: 'hover',
+  keyboard: true,
+  slide: true,
+  enableTouch: true
+};
+Carousel.childContextTypes = {
+  direction: PropTypes.string
+};
+export default Carousel;

web/node_modules/reactstrap/es/CarouselCaption.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CarouselCaptionProps
+  extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  captionHeader?: React.ReactNode;
+  captionText: React.ReactNode;
+  cssModule?: CSSModule;
+}
+
+declare class CarouselCaption extends React.Component<CarouselCaptionProps> {}
+export default CarouselCaption;

web/node_modules/reactstrap/es/CarouselCaption.js

@@ -0,0 +1,23 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+
+var CarouselCaption = 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 = {
+  captionHeader: PropTypes.node,
+  captionText: PropTypes.node.isRequired,
+  cssModule: PropTypes.object,
+  className: PropTypes.string
+};
+export default CarouselCaption;

web/node_modules/reactstrap/es/CarouselControl.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CarouselControlProps
+  extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  direction: 'prev' | 'next';
+  onClickHandler: () => void;
+  cssModule?: CSSModule;
+  directionText?: string;
+}
+
+export default class CarouselControl extends React.Component<
+  CarouselControlProps
+> {}

web/node_modules/reactstrap/es/CarouselControl.js

@@ -0,0 +1,48 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+
+var CarouselControl = function CarouselControl(props) {
+  var direction = props.direction,
+      onClickHandler = props.onClickHandler,
+      cssModule = props.cssModule,
+      directionText = props.directionText,
+      className = props.className;
+  var anchorClasses = mapToCssModules(classNames(className, "carousel-control-" + direction), cssModule);
+  var iconClasses = mapToCssModules(classNames("carousel-control-" + direction + "-icon"), cssModule);
+  var screenReaderClasses = mapToCssModules(classNames('sr-only'), 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", {
+      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 = {
+  direction: PropTypes.oneOf(['prev', 'next']).isRequired,
+  onClickHandler: PropTypes.func.isRequired,
+  cssModule: PropTypes.object,
+  directionText: PropTypes.string,
+  className: PropTypes.string
+};
+export default CarouselControl;

web/node_modules/reactstrap/es/CarouselIndicators.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CarouselIndicatorsProps
+  extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  items: object[];
+  activeIndex: number;
+  cssModule?: CSSModule;
+  onClickHandler: (idx: number) => void;
+}
+
+declare class CarouselIndicators extends React.Component<
+  CarouselIndicatorsProps
+> {}
+export default CarouselIndicators;

web/node_modules/reactstrap/es/CarouselIndicators.js

@@ -0,0 +1,38 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+
+var CarouselIndicators = function CarouselIndicators(props) {
+  var items = props.items,
+      activeIndex = props.activeIndex,
+      cssModule = props.cssModule,
+      onClickHandler = props.onClickHandler,
+      className = props.className;
+  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("li", {
+      key: "" + (item.key || Object.values(item).join('')),
+      onClick: function onClick(e) {
+        e.preventDefault();
+        onClickHandler(idx);
+      },
+      className: indicatorClasses
+    });
+  });
+  return /*#__PURE__*/React.createElement("ol", {
+    className: listClasses
+  }, indicators);
+};
+
+CarouselIndicators.propTypes = {
+  items: PropTypes.array.isRequired,
+  activeIndex: PropTypes.number.isRequired,
+  cssModule: PropTypes.object,
+  onClickHandler: PropTypes.func.isRequired,
+  className: PropTypes.string
+};
+export default CarouselIndicators;

web/node_modules/reactstrap/es/CarouselItem.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CarouselItemProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  in?: boolean;
+  cssModule?: CSSModule;
+  slide?: boolean;
+  onEnter?: () => void;
+  onEntering?: () => void;
+  onEntered?: () => void;
+  onExit?: () => void;
+  onExiting?: () => void;
+  onExited?: () => void;
+}
+
+declare class CarouselItem extends React.Component<CarouselItemProps> {}
+export default CarouselItem;

web/node_modules/reactstrap/es/CarouselItem.js

@@ -0,0 +1,126 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Transition } from 'react-transition-group';
+import { mapToCssModules, TransitionTimeouts, TransitionStatuses, tagPropType } from './utils';
+
+var CarouselItem = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(CarouselItem, _React$Component);
+
+  function CarouselItem(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _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;
+  }
+
+  var _proto = CarouselItem.prototype;
+
+  _proto.onEnter = function onEnter(node, isAppearing) {
+    this.setState({
+      startAnimation: false
+    });
+    this.props.onEnter(node, isAppearing);
+  };
+
+  _proto.onEntering = 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;
+  };
+
+  _proto.onExit = function onExit(node) {
+    this.setState({
+      startAnimation: false
+    });
+    this.props.onExit(node);
+  };
+
+  _proto.onExiting = function onExiting(node) {
+    this.setState({
+      startAnimation: true
+    });
+    node.dispatchEvent(new CustomEvent('slide.bs.carousel'));
+    this.props.onExiting(node);
+  };
+
+  _proto.onExited = function onExited(node) {
+    node.dispatchEvent(new CustomEvent('slid.bs.carousel'));
+    this.props.onExited(node);
+  };
+
+  _proto.render = function render() {
+    var _this2 = this;
+
+    var _this$props = this.props,
+        isIn = _this$props.in,
+        children = _this$props.children,
+        cssModule = _this$props.cssModule,
+        slide = _this$props.slide,
+        Tag = _this$props.tag,
+        className = _this$props.className,
+        transitionProps = _objectWithoutPropertiesLoose(_this$props, ["in", "children", "cssModule", "slide", "tag", "className"]);
+
+    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 === 'right' ? 'carousel-item-left' : 'carousel-item-right');
+      var orderClassName = status === TransitionStatuses.ENTERING && (direction === 'right' ? '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), {}, {
+  tag: tagPropType,
+  in: PropTypes.bool,
+  cssModule: PropTypes.object,
+  children: PropTypes.node,
+  slide: PropTypes.bool,
+  className: PropTypes.string
+});
+CarouselItem.defaultProps = _objectSpread(_objectSpread({}, Transition.defaultProps), {}, {
+  tag: 'div',
+  timeout: TransitionTimeouts.Carousel,
+  slide: true
+});
+CarouselItem.contextTypes = {
+  direction: PropTypes.string
+};
+export default CarouselItem;

web/node_modules/reactstrap/es/Col.d.ts

@@ -0,0 +1,29 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export type ColumnProps =
+  | string
+  | boolean
+  | number
+  | {
+      size?: boolean | number | string;
+      offset?: string | number;
+      order?: string | number;
+    };
+
+export interface ColProps extends React.HTMLAttributes<HTMLDivElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+  xs?: ColumnProps;
+  sm?: ColumnProps;
+  md?: ColumnProps;
+  lg?: ColumnProps;
+  xl?: ColumnProps;
+
+  // custom widths
+  widths?: string[];
+}
+
+declare class Col extends React.Component<ColProps> {}
+export default Col;

web/node_modules/reactstrap/es/Col.js

@@ -0,0 +1,83 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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'];
+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,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  widths: PropTypes.array
+};
+var defaultProps = {
+  tag: 'div',
+  widths: colWidths
+};
+
+var getColumnSizeClass = function getColumnSizeClass(isXs, colWidth, colSize) {
+  if (colSize === true || colSize === '') {
+    return isXs ? 'col' : "col-" + colWidth;
+  } else if (colSize === 'auto') {
+    return isXs ? 'col-auto' : "col-" + colWidth + "-auto";
+  }
+
+  return isXs ? "col-" + colSize : "col-" + colWidth + "-" + colSize;
+};
+
+var Col = function Col(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      widths = props.widths,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "widths", "tag"]);
+
+  var colClasses = [];
+  widths.forEach(function (colWidth, i) {
+    var columnProp = props[colWidth];
+    delete attributes[colWidth];
+
+    if (!columnProp && columnProp !== '') {
+      return;
+    }
+
+    var isXs = !i;
+
+    if (isObject(columnProp)) {
+      var _classNames;
+
+      var colSizeInterfix = isXs ? '-' : "-" + colWidth + "-";
+      var colClass = getColumnSizeClass(isXs, colWidth, columnProp.size);
+      colClasses.push(mapToCssModules(classNames((_classNames = {}, _classNames[colClass] = columnProp.size || columnProp.size === '', _classNames["order" + colSizeInterfix + columnProp.order] = columnProp.order || columnProp.order === 0, _classNames["offset" + colSizeInterfix + columnProp.offset] = columnProp.offset || columnProp.offset === 0, _classNames)), cssModule));
+    } else {
+      var _colClass = getColumnSizeClass(isXs, colWidth, columnProp);
+
+      colClasses.push(_colClass);
+    }
+  });
+
+  if (!colClasses.length) {
+    colClasses.push('col');
+  }
+
+  var classes = mapToCssModules(classNames(className, colClasses), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+Col.propTypes = propTypes;
+Col.defaultProps = defaultProps;
+export default Col;

web/node_modules/reactstrap/es/Collapse.d.ts

@@ -0,0 +1,31 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface CollapseProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  isOpen?: boolean;
+  cssModule?: CSSModule;
+  tag?: React.ElementType;
+  navbar?: boolean;
+  delay?: {
+    show: number;
+    hide: number;
+  };
+  onOpened?: () => void;
+  onClosed?: () => void;
+  onEntering?: () => void;
+  onEntered?: () => void;
+  onExit?: () => void;
+  onExiting?: () => void;
+  onExited?: () => void;
+  innerRef?: React.Ref<HTMLElement>;
+}
+
+export interface UncontrolledCollapseProps extends CollapseProps {
+  defaultOpen?: boolean;
+  toggler: string;
+  toggleEvents?: string[];
+}
+
+declare class Collapse extends React.Component<CollapseProps> {}
+export default Collapse;

web/node_modules/reactstrap/es/Collapse.js

@@ -0,0 +1,146 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+var _transitionStatusToCl;
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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), {}, {
+  isOpen: PropTypes.bool,
+  children: PropTypes.oneOfType([PropTypes.arrayOf(PropTypes.node), PropTypes.node]),
+  tag: tagPropType,
+  className: PropTypes.node,
+  navbar: PropTypes.bool,
+  cssModule: PropTypes.object,
+  innerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.string, PropTypes.object])
+});
+
+var defaultProps = _objectSpread(_objectSpread({}, Transition.defaultProps), {}, {
+  isOpen: false,
+  appear: false,
+  enter: true,
+  exit: true,
+  tag: 'div',
+  timeout: TransitionTimeouts.Collapse
+});
+
+var transitionStatusToClassHash = (_transitionStatusToCl = {}, _transitionStatusToCl[TransitionStatuses.ENTERING] = 'collapsing', _transitionStatusToCl[TransitionStatuses.ENTERED] = 'collapse show', _transitionStatusToCl[TransitionStatuses.EXITING] = 'collapsing', _transitionStatusToCl[TransitionStatuses.EXITED] = 'collapse', _transitionStatusToCl);
+
+function getTransitionClass(status) {
+  return transitionStatusToClassHash[status] || 'collapse';
+}
+
+function getHeight(node) {
+  return node.scrollHeight;
+}
+
+var Collapse = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(Collapse, _Component);
+
+  function Collapse(props) {
+    var _this;
+
+    _this = _Component.call(this, props) || this;
+    _this.state = {
+      height: null
+    };
+    ['onEntering', 'onEntered', 'onExit', 'onExiting', 'onExited'].forEach(function (name) {
+      _this[name] = _this[name].bind(_assertThisInitialized(_this));
+    });
+    return _this;
+  }
+
+  var _proto = Collapse.prototype;
+
+  _proto.onEntering = function onEntering(node, isAppearing) {
+    this.setState({
+      height: getHeight(node)
+    });
+    this.props.onEntering(node, isAppearing);
+  };
+
+  _proto.onEntered = function onEntered(node, isAppearing) {
+    this.setState({
+      height: null
+    });
+    this.props.onEntered(node, isAppearing);
+  };
+
+  _proto.onExit = function onExit(node) {
+    this.setState({
+      height: getHeight(node)
+    });
+    this.props.onExit(node);
+  };
+
+  _proto.onExiting = function onExiting(node) {
+    // getting this variable triggers a reflow
+    var _unused = node.offsetHeight; // eslint-disable-line no-unused-vars
+
+    this.setState({
+      height: 0
+    });
+    this.props.onExiting(node);
+  };
+
+  _proto.onExited = function onExited(node) {
+    this.setState({
+      height: null
+    });
+    this.props.onExited(node);
+  };
+
+  _proto.render = function render() {
+    var _this2 = this;
+
+    var _this$props = this.props,
+        Tag = _this$props.tag,
+        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 = _objectWithoutPropertiesLoose(_this$props, ["tag", "isOpen", "className", "navbar", "cssModule", "children", "innerRef"]);
+
+    var height = this.state.height;
+    var transitionProps = pick(otherProps, TransitionPropTypeKeys);
+    var childProps = omit(otherProps, TransitionPropTypeKeys);
+    return /*#__PURE__*/React.createElement(Transition, _extends({}, transitionProps, {
+      in: isOpen,
+      onEntering: this.onEntering,
+      onEntered: this.onEntered,
+      onExit: this.onExit,
+      onExiting: this.onExiting,
+      onExited: this.onExited
+    }), function (status) {
+      var collapseClass = getTransitionClass(status);
+      var classes = mapToCssModules(classNames(className, collapseClass, navbar && 'navbar-collapse'), cssModule);
+      var style = height === null ? null : {
+        height: height
+      };
+      return /*#__PURE__*/React.createElement(Tag, _extends({}, childProps, {
+        style: _objectSpread(_objectSpread({}, childProps.style), style),
+        className: classes,
+        ref: _this2.props.innerRef
+      }), children);
+    });
+  };
+
+  return Collapse;
+}(Component);
+
+Collapse.propTypes = propTypes;
+Collapse.defaultProps = defaultProps;
+export default Collapse;

web/node_modules/reactstrap/es/Container.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface ContainerProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  fluid?: boolean | string;
+  cssModule?: CSSModule;
+}
+
+declare class Container extends React.Component<ContainerProps> {}
+export default Container;

web/node_modules/reactstrap/es/Container.js

@@ -0,0 +1,40 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var Container = function Container(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      fluid = props.fluid,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "fluid", "tag"]);
+
+  var containerClass = 'container';
+
+  if (fluid === true) {
+    containerClass = 'container-fluid';
+  } else if (fluid) {
+    containerClass = "container-" + fluid;
+  }
+
+  var classes = mapToCssModules(classNames(className, containerClass), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+Container.propTypes = propTypes;
+Container.defaultProps = defaultProps;
+export default Container;

web/node_modules/reactstrap/es/CustomFileInput.js

@@ -0,0 +1,113 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+var propTypes = {
+  className: PropTypes.string,
+  id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
+  label: PropTypes.node,
+  valid: PropTypes.bool,
+  invalid: PropTypes.bool,
+  bsSize: PropTypes.string,
+  htmlFor: PropTypes.string,
+  cssModule: PropTypes.object,
+  onChange: PropTypes.func,
+  children: PropTypes.oneOfType([PropTypes.node, PropTypes.array, PropTypes.func]),
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+};
+
+var CustomFileInput = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(CustomFileInput, _React$Component);
+
+  function CustomFileInput(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.state = {
+      files: null
+    };
+    _this.onChange = _this.onChange.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  var _proto = CustomFileInput.prototype;
+
+  _proto.onChange = function onChange(e) {
+    var input = e.target;
+    var onChange = this.props.onChange;
+    var files = this.getSelectedFiles(input);
+
+    if (typeof onChange === "function") {
+      onChange.apply(void 0, arguments);
+    }
+
+    this.setState({
+      files: files
+    });
+  };
+
+  _proto.getSelectedFiles = function getSelectedFiles(input) {
+    var multiple = this.props.multiple;
+
+    if (multiple && input.files) {
+      var files = [].slice.call(input.files);
+      return files.map(function (file) {
+        return file.name;
+      }).join(", ");
+    }
+
+    if (input.value.indexOf("fakepath") !== -1) {
+      var parts = input.value.split("\\");
+      return parts[parts.length - 1];
+    }
+
+    return input.value;
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        label = _this$props.label,
+        valid = _this$props.valid,
+        invalid = _this$props.invalid,
+        cssModule = _this$props.cssModule,
+        children = _this$props.children,
+        bsSize = _this$props.bsSize,
+        innerRef = _this$props.innerRef,
+        htmlFor = _this$props.htmlFor,
+        type = _this$props.type,
+        onChange = _this$props.onChange,
+        dataBrowse = _this$props.dataBrowse,
+        hidden = _this$props.hidden,
+        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "label", "valid", "invalid", "cssModule", "children", "bsSize", "innerRef", "htmlFor", "type", "onChange", "dataBrowse", "hidden"]);
+
+    var customClass = mapToCssModules(classNames(className, "custom-file"), cssModule);
+    var validationClassNames = mapToCssModules(classNames(invalid && "is-invalid", valid && "is-valid"), cssModule);
+    var labelHtmlFor = htmlFor || attributes.id;
+    var files = this.state.files;
+    return /*#__PURE__*/React.createElement("div", {
+      className: customClass,
+      hidden: hidden || false
+    }, /*#__PURE__*/React.createElement("input", _extends({
+      type: "file"
+    }, attributes, {
+      ref: innerRef,
+      "aria-invalid": invalid,
+      className: classNames(validationClassNames, mapToCssModules("custom-file-input", cssModule)),
+      onChange: this.onChange
+    })), /*#__PURE__*/React.createElement("label", {
+      className: mapToCssModules("custom-file-label", cssModule),
+      htmlFor: labelHtmlFor,
+      "data-browse": dataBrowse
+    }, files || label || "Choose file"), children);
+  };
+
+  return CustomFileInput;
+}(React.Component);
+
+CustomFileInput.propTypes = propTypes;
+export default CustomFileInput;

web/node_modules/reactstrap/es/CustomInput.d.ts

@@ -0,0 +1,30 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+export type CustomInputType =
+  | 'select'
+  | 'file'
+  | 'radio'
+  | 'checkbox'
+  | 'switch'
+  | 'range';
+
+export interface CustomInputProps
+  extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'id'> {
+  [key: string]: any;
+  id: string | number;
+  type: CustomInputType;
+  label?: React.ReactNode;
+  inline?: boolean;
+  valid?: boolean;
+  invalid?: boolean;
+  bsSize?: 'lg' | 'sm';
+  htmlFor?: string;
+  cssModule?: CSSModule;
+  innerRef?: React.Ref<HTMLElement>;
+}
+
+declare class CustomInput extends React.Component<CustomInputProps> {}
+export default CustomInput;

web/node_modules/reactstrap/es/CustomInput.js

@@ -0,0 +1,86 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { mapToCssModules } from './utils';
+import CustomFileInput from './CustomFileInput';
+var propTypes = {
+  className: PropTypes.string,
+  id: PropTypes.oneOfType([PropTypes.string, PropTypes.number]).isRequired,
+  type: PropTypes.string.isRequired,
+  label: PropTypes.node,
+  inline: PropTypes.bool,
+  valid: PropTypes.bool,
+  invalid: PropTypes.bool,
+  bsSize: PropTypes.string,
+  htmlFor: PropTypes.string,
+  cssModule: PropTypes.object,
+  children: PropTypes.oneOfType([PropTypes.node, PropTypes.array, PropTypes.func]),
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.string, PropTypes.func])
+};
+
+function CustomInput(props) {
+  var className = props.className,
+      label = props.label,
+      inline = props.inline,
+      valid = props.valid,
+      invalid = props.invalid,
+      cssModule = props.cssModule,
+      children = props.children,
+      bsSize = props.bsSize,
+      innerRef = props.innerRef,
+      htmlFor = props.htmlFor,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "label", "inline", "valid", "invalid", "cssModule", "children", "bsSize", "innerRef", "htmlFor"]);
+
+  var type = attributes.type;
+  var customClass = mapToCssModules(classNames(className, "custom-" + type, bsSize ? "custom-" + type + "-" + bsSize : false), cssModule);
+  var validationClassNames = mapToCssModules(classNames(invalid && "is-invalid", valid && "is-valid"), cssModule);
+  var labelHtmlFor = htmlFor || attributes.id;
+
+  if (type === "select") {
+    var _type = attributes.type,
+        _rest = _objectWithoutPropertiesLoose(attributes, ["type"]);
+
+    return /*#__PURE__*/React.createElement("select", _extends({}, _rest, {
+      ref: innerRef,
+      className: classNames(validationClassNames, customClass),
+      "aria-invalid": invalid
+    }), children);
+  }
+
+  if (type === "file") {
+    return /*#__PURE__*/React.createElement(CustomFileInput, props);
+  }
+
+  if (type !== "checkbox" && type !== "radio" && type !== "switch") {
+    return /*#__PURE__*/React.createElement("input", _extends({}, attributes, {
+      ref: innerRef,
+      "aria-invalid": invalid,
+      className: classNames(validationClassNames, customClass)
+    }));
+  }
+
+  var wrapperClasses = classNames(customClass, mapToCssModules(classNames("custom-control", {
+    "custom-control-inline": inline
+  }), cssModule));
+
+  var hidden = attributes.hidden,
+      rest = _objectWithoutPropertiesLoose(attributes, ["hidden"]);
+
+  return /*#__PURE__*/React.createElement("div", {
+    className: wrapperClasses,
+    hidden: hidden || false
+  }, /*#__PURE__*/React.createElement("input", _extends({}, rest, {
+    type: type === "switch" ? "checkbox" : type,
+    ref: innerRef,
+    "aria-invalid": invalid,
+    className: classNames(validationClassNames, mapToCssModules("custom-control-input", cssModule))
+  })), /*#__PURE__*/React.createElement("label", {
+    className: mapToCssModules("custom-control-label", cssModule),
+    htmlFor: labelHtmlFor
+  }, label), children);
+}
+
+CustomInput.propTypes = propTypes;
+export default CustomInput;

web/node_modules/reactstrap/es/Dropdown.d.ts

@@ -0,0 +1,34 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export type Direction = 'up' | 'down' | 'left' | 'right';
+
+export interface DropdownProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  a11y?: boolean;
+  disabled?: boolean;
+  direction?: Direction;
+  group?: boolean;
+  isOpen?: boolean;
+  nav?: boolean;
+  active?: boolean;
+  addonType?: boolean | 'prepend' | 'append';
+  size?: string;
+  tag?: React.ElementType;
+  toggle?: React.KeyboardEventHandler<any> | React.MouseEventHandler<any>;
+  cssModule?: CSSModule;
+  inNavbar?: boolean;
+  setActiveFromChild?: boolean;
+}
+
+export interface UncontrolledDropdownProps extends DropdownProps {
+  defaultOpen?: boolean;
+  onToggle?: (
+    event: React.KeyboardEvent | React.MouseEvent,
+    isOpen: boolean
+  ) => void;
+}
+
+declare class Dropdown extends React.Component<DropdownProps> {}
+
+export default Dropdown;

web/node_modules/reactstrap/es/Dropdown.js

@@ -0,0 +1,285 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+
+/* 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';
+var propTypes = {
+  a11y: PropTypes.bool,
+  disabled: PropTypes.bool,
+  direction: PropTypes.oneOf(['up', 'down', 'left', 'right']),
+  group: PropTypes.bool,
+  isOpen: PropTypes.bool,
+  nav: PropTypes.bool,
+  active: PropTypes.bool,
+  addonType: PropTypes.oneOfType([PropTypes.bool, PropTypes.oneOf(['prepend', 'append'])]),
+  size: PropTypes.string,
+  tag: tagPropType,
+  toggle: PropTypes.func,
+  children: PropTypes.node,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  inNavbar: PropTypes.bool,
+  setActiveFromChild: PropTypes.bool
+};
+var defaultProps = {
+  a11y: true,
+  isOpen: false,
+  direction: 'down',
+  nav: false,
+  active: false,
+  addonType: 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) {
+  _inheritsLoose(Dropdown, _React$Component);
+
+  function Dropdown(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _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.containerRef = /*#__PURE__*/React.createRef();
+    _this.menuRef = /*#__PURE__*/React.createRef();
+    return _this;
+  }
+
+  var _proto = Dropdown.prototype;
+
+  _proto.handleMenuRef = function handleMenuRef(menuRef) {
+    this.menuRef.current = menuRef;
+  };
+
+  _proto.getContextValue = 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
+    };
+  };
+
+  _proto.componentDidMount = function componentDidMount() {
+    this.handleProps();
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    if (this.props.isOpen !== prevProps.isOpen) {
+      this.handleProps();
+    }
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.removeEvents();
+  };
+
+  _proto.getContainer = function getContainer() {
+    return this.containerRef.current;
+  };
+
+  _proto.getMenu = function getMenu() {
+    return this.menuRef.current;
+  };
+
+  _proto.getMenuCtrl = function getMenuCtrl() {
+    if (this._$menuCtrl) return this._$menuCtrl;
+    this._$menuCtrl = this.getContainer().querySelector('[aria-expanded]');
+    return this._$menuCtrl;
+  };
+
+  _proto.getMenuItems = 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="menuitem"]'));
+  };
+
+  _proto.addEvents = function addEvents() {
+    var _this2 = this;
+
+    ['click', 'touchstart', 'keyup'].forEach(function (event) {
+      return document.addEventListener(event, _this2.handleDocumentClick, true);
+    });
+  };
+
+  _proto.removeEvents = function removeEvents() {
+    var _this3 = this;
+
+    ['click', 'touchstart', 'keyup'].forEach(function (event) {
+      return document.removeEventListener(event, _this3.handleDocumentClick, true);
+    });
+  };
+
+  _proto.handleDocumentClick = 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 clickIsInContainer = container.contains(e.target) && container !== e.target;
+    var clickIsInMenu = menu && menu.contains(e.target) && menu !== e.target;
+
+    if ((clickIsInContainer || clickIsInMenu) && (e.type !== 'keyup' || e.which === keyCodes.tab)) {
+      return;
+    }
+
+    this.toggle(e);
+  };
+
+  _proto.handleKeyDown = function handleKeyDown(e) {
+    var _this4 = this;
+
+    var isTargetMenuItem = e.target.getAttribute('role') === 'menuitem';
+    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 () {
+          return _this4.getMenuItems()[0].focus();
+        });
+      } else if (this.props.isOpen && isTab) {
+        // 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()[0].focus();
+      } else if (this.props.isOpen && e.which === keyCodes.esc) {
+        this.toggle(e);
+      }
+    }
+
+    if (this.props.isOpen && e.target.getAttribute('role') === 'menuitem') {
+      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;
+          }
+        }
+      }
+    }
+  };
+
+  _proto.handleProps = function handleProps() {
+    if (this.props.isOpen) {
+      this.addEvents();
+    } else {
+      this.removeEvents();
+    }
+  };
+
+  _proto.toggle = function toggle(e) {
+    if (this.props.disabled) {
+      return e && e.preventDefault();
+    }
+
+    return this.props.toggle(e);
+  };
+
+  _proto.render = function render() {
+    var _classNames, _ref;
+
+    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,
+        addonType = _omit.addonType,
+        tag = _omit.tag,
+        attrs = _objectWithoutPropertiesLoose(_omit, ["className", "cssModule", "direction", "isOpen", "group", "size", "nav", "setActiveFromChild", "active", "addonType", "tag"]);
+
+    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, direction !== 'down' && "drop" + direction, nav && active ? 'active' : false, setActiveFromChild && subItemIsActive ? 'active' : false, (_classNames = {}, _classNames["input-group-" + addonType] = addonType, _classNames['btn-group'] = group, _classNames["btn-group-" + size] = !!size, _classNames.dropdown = !group && !addonType, _classNames.show = isOpen, _classNames['nav-item'] = nav, _classNames)), cssModule);
+    return /*#__PURE__*/React.createElement(DropdownContext.Provider, {
+      value: this.getContextValue()
+    }, /*#__PURE__*/React.createElement(Manager, null, /*#__PURE__*/React.createElement(Tag, _extends({}, attrs, (_ref = {}, _ref[typeof Tag === 'string' ? 'ref' : 'innerRef'] = this.containerRef, _ref), {
+      onKeyDown: this.handleKeyDown,
+      className: classes
+    }))));
+  };
+
+  return Dropdown;
+}(React.Component);
+
+Dropdown.propTypes = propTypes;
+Dropdown.defaultProps = defaultProps;
+export default Dropdown;

web/node_modules/reactstrap/es/DropdownContext.js

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

web/node_modules/reactstrap/es/DropdownItem.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface DropdownItemProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  active?: boolean;
+  disabled?: boolean;
+  divider?: boolean;
+  tag?: React.ElementType;
+  header?: boolean;
+  cssModule?: CSSModule;
+  href?: string;
+  toggle?: boolean;
+  text?: boolean;
+}
+
+declare class DropdownItem extends React.Component<DropdownItemProps> {}
+export default DropdownItem;

web/node_modules/reactstrap/es/DropdownItem.js

@@ -0,0 +1,128 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+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 defaultProps = {
+  tag: 'button',
+  toggle: true
+};
+
+var DropdownItem = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(DropdownItem, _React$Component);
+
+  function DropdownItem(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
+    _this.getTabIndex = _this.getTabIndex.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  var _proto = DropdownItem.prototype;
+
+  _proto.onClick = function onClick(e) {
+    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.context.toggle(e);
+    }
+  };
+
+  _proto.getTabIndex = 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';
+  };
+
+  _proto.render = function render() {
+    var tabIndex = this.getTabIndex();
+    var role = tabIndex > -1 ? 'menuitem' : undefined;
+
+    var _omit = omit(this.props, ['toggle']),
+        className = _omit.className,
+        cssModule = _omit.cssModule,
+        divider = _omit.divider,
+        Tag = _omit.tag,
+        header = _omit.header,
+        active = _omit.active,
+        text = _omit.text,
+        props = _objectWithoutPropertiesLoose(_omit, ["className", "cssModule", "divider", "tag", "header", "active", "text"]);
+
+    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.defaultProps = defaultProps;
+DropdownItem.contextType = DropdownContext;
+export default DropdownItem;

web/node_modules/reactstrap/es/DropdownMenu.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import * as Popper from 'popper.js';
+import { CSSModule } from './index';
+
+export interface DropdownMenuProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  right?: boolean;
+  flip?: boolean;
+  modifiers?: Popper.Modifiers;
+  cssModule?: CSSModule;
+  persist?: boolean;
+  positionFixed?: boolean;
+  container?: string | HTMLElement | React.RefObject<HTMLElement>;
+}
+
+declare class DropdownMenu extends React.Component<DropdownMenuProps> {}
+export default DropdownMenu;

web/node_modules/reactstrap/es/DropdownMenu.js

@@ -0,0 +1,137 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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 } from './utils';
+var propTypes = {
+  tag: tagPropType,
+  children: PropTypes.node.isRequired,
+  right: PropTypes.bool,
+  flip: PropTypes.bool,
+  modifiers: PropTypes.object,
+  className: PropTypes.string,
+  cssModule: PropTypes.object,
+  persist: PropTypes.bool,
+  positionFixed: PropTypes.bool,
+  container: targetPropType
+};
+var defaultProps = {
+  tag: 'div',
+  flip: true
+};
+var noFlipModifier = {
+  flip: {
+    enabled: false
+  }
+};
+var directionPositionMap = {
+  up: 'top',
+  left: 'left',
+  right: 'right',
+  down: 'bottom'
+};
+
+var DropdownMenu = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(DropdownMenu, _React$Component);
+
+  function DropdownMenu() {
+    return _React$Component.apply(this, arguments) || this;
+  }
+
+  var _proto = DropdownMenu.prototype;
+
+  _proto.render = function render() {
+    var _this = this;
+
+    var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        right = _this$props.right,
+        tag = _this$props.tag,
+        flip = _this$props.flip,
+        modifiers = _this$props.modifiers,
+        persist = _this$props.persist,
+        positionFixed = _this$props.positionFixed,
+        container = _this$props.container,
+        attrs = _objectWithoutPropertiesLoose(_this$props, ["className", "cssModule", "right", "tag", "flip", "modifiers", "persist", "positionFixed", "container"]);
+
+    var classes = mapToCssModules(classNames(className, 'dropdown-menu', {
+      'dropdown-menu-right': 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 = right ? 'end' : 'start';
+      var poperPlacement = position1 + "-" + position2;
+      var poperModifiers = !flip ? _objectSpread(_objectSpread({}, modifiers), noFlipModifier) : modifiers;
+      var popperPositionFixed = !!positionFixed;
+      var popper = /*#__PURE__*/React.createElement(Popper, {
+        placement: poperPlacement,
+        modifiers: poperModifiers,
+        positionFixed: popperPositionFixed
+      }, function (_ref) {
+        var ref = _ref.ref,
+            style = _ref.style,
+            placement = _ref.placement;
+
+        var combinedStyle = _objectSpread(_objectSpread({}, _this.props.style), 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: "menu",
+          ref: handleRef
+        }, attrs, {
+          style: combinedStyle,
+          "aria-hidden": !_this.context.isOpen,
+          className: classes,
+          "x-placement": placement
+        }));
+      });
+
+      if (container) {
+        return /*#__PURE__*/ReactDOM.createPortal(popper, getTarget(container));
+      } else {
+        return popper;
+      }
+    }
+
+    return /*#__PURE__*/React.createElement(Tag, _extends({
+      tabIndex: "-1",
+      role: "menu"
+    }, attrs, {
+      "aria-hidden": !this.context.isOpen,
+      className: classes,
+      "x-placement": attrs.placement
+    }));
+  };
+
+  return DropdownMenu;
+}(React.Component);
+
+;
+DropdownMenu.propTypes = propTypes;
+DropdownMenu.defaultProps = defaultProps;
+DropdownMenu.contextType = DropdownContext;
+export default DropdownMenu;

web/node_modules/reactstrap/es/DropdownToggle.d.ts

@@ -0,0 +1,20 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface DropdownToggleProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  caret?: boolean;
+  color?: string;
+  cssModule?: CSSModule;
+  disabled?: boolean;
+  outline?: boolean;
+  'data-toggle'?: string;
+  'aria-haspopup'?: boolean;
+  split?: boolean;
+  tag?: React.ElementType;
+  nav?: boolean;
+  size?: string;
+}
+
+declare class DropdownToggle extends React.Component<DropdownToggleProps> {}
+export default DropdownToggle;

web/node_modules/reactstrap/es/DropdownToggle.js

@@ -0,0 +1,126 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+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
+};
+var defaultProps = {
+  'aria-haspopup': true,
+  color: 'secondary'
+};
+
+var DropdownToggle = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(DropdownToggle, _React$Component);
+
+  function DropdownToggle(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.onClick = _this.onClick.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  var _proto = DropdownToggle.prototype;
+
+  _proto.onClick = 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);
+  };
+
+  _proto.render = 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 = _objectWithoutPropertiesLoose(_this$props, ["className", "color", "cssModule", "caret", "split", "nav", "tag", "innerRef"]);
+
+    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: "sr-only"
+    }, ariaLabel);
+    var Tag;
+
+    if (nav && !tag) {
+      Tag = 'a';
+      props.href = '#';
+    } else if (!tag) {
+      Tag = Button;
+      props.color = color;
+      props.cssModule = cssModule;
+    } else {
+      Tag = tag;
+    }
+
+    if (this.context.inNavbar) {
+      return /*#__PURE__*/React.createElement(Tag, _extends({}, props, {
+        className: classes,
+        onClick: this.onClick,
+        "aria-expanded": this.context.isOpen,
+        children: children
+      }));
+    }
+
+    return /*#__PURE__*/React.createElement(Reference, {
+      innerRef: innerRef
+    }, function (_ref) {
+      var _ref2;
+
+      var ref = _ref.ref;
+      return /*#__PURE__*/React.createElement(Tag, _extends({}, props, (_ref2 = {}, _ref2[typeof Tag === 'string' ? 'ref' : 'innerRef'] = ref, _ref2), {
+        className: classes,
+        onClick: _this2.onClick,
+        "aria-expanded": _this2.context.isOpen,
+        children: children
+      }));
+    });
+  };
+
+  return DropdownToggle;
+}(React.Component);
+
+DropdownToggle.propTypes = propTypes;
+DropdownToggle.defaultProps = defaultProps;
+DropdownToggle.contextType = DropdownContext;
+export default DropdownToggle;

web/node_modules/reactstrap/es/Fade.d.ts

@@ -0,0 +1,23 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface FadeProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  in?: boolean;
+  baseClass?: string;
+  baseClassIn?: string;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+  transitionAppearTimeout?: number;
+  transitionEnterTimeout?: number;
+  transitionLeaveTimeout?: number;
+  transitionAppear?: boolean;
+  transitionEnter?: boolean;
+  transitionLeave?: boolean;
+  onLeave?: () => void;
+  onEnter?: () => void;
+  innerRef?: React.Ref<HTMLElement>;
+}
+
+declare class Fade extends React.Component<FadeProps> {}
+export default Fade;

web/node_modules/reactstrap/es/Fade.js

@@ -0,0 +1,61 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+import React from 'react';
+import PropTypes from 'prop-types';
+import classNames from 'classnames';
+import { Transition } from 'react-transition-group';
+import { mapToCssModules, omit, pick, TransitionPropTypeKeys, TransitionTimeouts, tagPropType } 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), {}, {
+  tag: 'div',
+  baseClass: 'fade',
+  baseClassActive: 'show',
+  timeout: TransitionTimeouts.Fade,
+  appear: true,
+  enter: true,
+  exit: true,
+  in: true
+});
+
+function Fade(props) {
+  var Tag = props.tag,
+      baseClass = props.baseClass,
+      baseClassActive = props.baseClassActive,
+      className = props.className,
+      cssModule = props.cssModule,
+      children = props.children,
+      innerRef = props.innerRef,
+      otherProps = _objectWithoutPropertiesLoose(props, ["tag", "baseClass", "baseClassActive", "className", "cssModule", "children", "innerRef"]);
+
+  var transitionProps = pick(otherProps, TransitionPropTypeKeys);
+  var childProps = omit(otherProps, TransitionPropTypeKeys);
+  return /*#__PURE__*/React.createElement(Transition, 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;
+Fade.defaultProps = defaultProps;
+export default Fade;

web/node_modules/reactstrap/es/Form.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface FormProps extends React.FormHTMLAttributes<HTMLFormElement> {
+  [key: string]: any;
+  inline?: boolean;
+  tag?: React.ElementType;
+  innerRef?: React.Ref<HTMLFormElement>;
+  cssModule?: CSSModule;
+}
+
+declare class Form extends React.Component<FormProps> {}
+export default Form;

web/node_modules/reactstrap/es/Form.js

@@ -0,0 +1,70 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+import React, { Component } 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,
+  innerRef: PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.string]),
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+var defaultProps = {
+  tag: 'form'
+};
+
+var Form = /*#__PURE__*/function (_Component) {
+  _inheritsLoose(Form, _Component);
+
+  function Form(props) {
+    var _this;
+
+    _this = _Component.call(this, props) || this;
+    _this.getRef = _this.getRef.bind(_assertThisInitialized(_this));
+    _this.submit = _this.submit.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  var _proto = Form.prototype;
+
+  _proto.getRef = function getRef(ref) {
+    if (this.props.innerRef) {
+      this.props.innerRef(ref);
+    }
+
+    this.ref = ref;
+  };
+
+  _proto.submit = function submit() {
+    if (this.ref) {
+      this.ref.submit();
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        inline = _this$props.inline,
+        Tag = _this$props.tag,
+        innerRef = _this$props.innerRef,
+        attributes = _objectWithoutPropertiesLoose(_this$props, ["className", "cssModule", "inline", "tag", "innerRef"]);
+
+    var classes = mapToCssModules(classNames(className, inline ? 'form-inline' : false), cssModule);
+    return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+      ref: innerRef,
+      className: classes
+    }));
+  };
+
+  return Form;
+}(Component);
+
+Form.propTypes = propTypes;
+Form.defaultProps = defaultProps;
+export default Form;

web/node_modules/reactstrap/es/FormFeedback.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface FormFeedbackProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: string;
+  cssModule?: CSSModule;
+  valid?: boolean;
+  tooltip?: boolean;
+}
+
+declare class FormFeedback extends React.Component<FormFeedbackProps> {}
+export default FormFeedback;

web/node_modules/reactstrap/es/FormFeedback.js

@@ -0,0 +1,37 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'div',
+  valid: undefined
+};
+
+var FormFeedback = function FormFeedback(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      valid = props.valid,
+      tooltip = props.tooltip,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "valid", "tooltip", "tag"]);
+
+  var validMode = tooltip ? 'tooltip' : 'feedback';
+  var classes = mapToCssModules(classNames(className, valid ? "valid-" + validMode : "invalid-" + validMode), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+FormFeedback.propTypes = propTypes;
+FormFeedback.defaultProps = defaultProps;
+export default FormFeedback;

web/node_modules/reactstrap/es/FormGroup.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface FormGroupProps extends React.HTMLAttributes<HTMLDivElement> {
+  [key: string]: any;
+  row?: boolean;
+  check?: boolean;
+  inline?: boolean;
+  disabled?: boolean;
+  tag?: React.ElementType;
+  cssModule?: CSSModule;
+}
+
+declare class FormGroup extends React.Component<FormGroupProps> {}
+export default FormGroup;

web/node_modules/reactstrap/es/FormGroup.js

@@ -0,0 +1,44 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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,
+  inline: PropTypes.bool,
+  disabled: PropTypes.bool,
+  tag: tagPropType,
+  className: PropTypes.string,
+  cssModule: PropTypes.object
+};
+var defaultProps = {
+  tag: 'div'
+};
+
+var FormGroup = function FormGroup(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      row = props.row,
+      disabled = props.disabled,
+      check = props.check,
+      inline = props.inline,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "row", "disabled", "check", "inline", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, row ? 'row' : false, check ? 'form-check' : 'form-group', check && inline ? 'form-check-inline' : false, check && disabled ? 'disabled' : false), cssModule);
+
+  if (Tag === 'fieldset') {
+    attributes.disabled = disabled;
+  }
+
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+FormGroup.propTypes = propTypes;
+FormGroup.defaultProps = defaultProps;
+export default FormGroup;

web/node_modules/reactstrap/es/FormText.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface FormTextProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  inline?: boolean;
+  tag?: React.ElementType;
+  color?: string;
+  cssModule?: CSSModule;
+}
+
+declare class FormText extends React.Component<FormTextProps> {}
+export default FormText;

web/node_modules/reactstrap/es/FormText.js

@@ -0,0 +1,36 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+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
+};
+var defaultProps = {
+  tag: 'small',
+  color: 'muted'
+};
+
+var FormText = function FormText(props) {
+  var className = props.className,
+      cssModule = props.cssModule,
+      inline = props.inline,
+      color = props.color,
+      Tag = props.tag,
+      attributes = _objectWithoutPropertiesLoose(props, ["className", "cssModule", "inline", "color", "tag"]);
+
+  var classes = mapToCssModules(classNames(className, !inline ? 'form-text' : false, color ? "text-" + color : false), cssModule);
+  return /*#__PURE__*/React.createElement(Tag, _extends({}, attributes, {
+    className: classes
+  }));
+};
+
+FormText.propTypes = propTypes;
+FormText.defaultProps = defaultProps;
+export default FormText;

web/node_modules/reactstrap/es/Input.d.ts

@@ -0,0 +1,46 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export type InputType =
+  | 'text'
+  | 'email'
+  | 'select'
+  | 'file'
+  | 'radio'
+  | 'checkbox'
+  | 'textarea'
+  | 'button'
+  | 'reset'
+  | 'submit'
+  | 'date'
+  | 'datetime-local'
+  | 'hidden'
+  | 'image'
+  | 'month'
+  | 'number'
+  | 'range'
+  | 'search'
+  | 'tel'
+  | 'url'
+  | 'week'
+  | 'password'
+  | 'datetime'
+  | 'time'
+  | 'color';
+
+export interface InputProps
+  extends React.InputHTMLAttributes<HTMLInputElement> {
+  [key: string]: any;
+  type?: InputType;
+  bsSize?: 'lg' | 'sm';
+  valid?: boolean;
+  invalid?: boolean;
+  tag?: React.ElementType;
+  innerRef?: React.Ref<HTMLInputElement | HTMLTextAreaElement>;
+  plaintext?: boolean;
+  addon?: boolean;
+  cssModule?: CSSModule;
+}
+
+declare class Input extends React.Component<InputProps> {}
+export default Input;

web/node_modules/reactstrap/es/Input.js

@@ -0,0 +1,124 @@
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _objectWithoutPropertiesLoose from "@babel/runtime/helpers/esm/objectWithoutPropertiesLoose";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inheritsLoose from "@babel/runtime/helpers/esm/inheritsLoose";
+
+/* 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 defaultProps = {
+  type: 'text'
+};
+
+var Input = /*#__PURE__*/function (_React$Component) {
+  _inheritsLoose(Input, _React$Component);
+
+  function Input(props) {
+    var _this;
+
+    _this = _React$Component.call(this, props) || this;
+    _this.getRef = _this.getRef.bind(_assertThisInitialized(_this));
+    _this.focus = _this.focus.bind(_assertThisInitialized(_this));
+    return _this;
+  }
+
+  var _proto = Input.prototype;
+
+  _proto.getRef = function getRef(ref) {
+    if (this.props.innerRef) {
+      this.props.innerRef(ref);
+    }
+
+    this.ref = ref;
+  };
+
+  _proto.focus = function focus() {
+    if (this.ref) {
+      this.ref.focus();
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        className = _this$props.className,
+        cssModule = _this$props.cssModule,
+        type = _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 = _objectWithoutPropertiesLoose(_this$props, ["className", "cssModule", "type", "bsSize", "valid", "invalid", "tag", "addon", "plaintext", "innerRef"]);
+
+    var checkInput = ['radio', 'checkbox'].indexOf(type) > -1;
+    var isNotaNumber = new RegExp('\\D', 'g');
+    var fileInput = type === 'file';
+    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 = formControlClass + "-plaintext";
+      Tag = tag || 'input';
+    } else if (fileInput) {
+      formControlClass = formControlClass + "-file";
+    } else if (rangeInput) {
+      formControlClass = formControlClass + "-range";
+    } 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 ? "form-control-" + bsSize : false, formControlClass), cssModule);
+
+    if (Tag === 'input' || tag && typeof tag === 'function') {
+      attributes.type = type;
+    }
+
+    if (attributes.children && !(plaintext || type === 'select' || typeof Tag !== 'string' || Tag === 'select')) {
+      warnOnce("Input with a type of \"" + 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;
+Input.defaultProps = defaultProps;
+export default Input;

web/node_modules/reactstrap/es/InputGroup.d.ts

@@ -0,0 +1,12 @@
+import * as React from 'react';
+import { CSSModule } from './index';
+
+export interface InputGroupProps extends React.HTMLAttributes<HTMLElement> {
+  [key: string]: any;
+  tag?: React.ElementType;
+  size?: string;
+  cssModule?: CSSModule;
+}
+
+declare class InputGroup extends React.Component<InputGroupProps> {}
+export default InputGroup;