0.2.0 - Mid migration

web/node_modules/classnames/HISTORY.md

@@ -0,0 +1,90 @@
+# Changelog
+
+## v2.3.0 / 2021-04-01
+
+- Added TypeScript types
+- Added consistent support for custom `.toString()` methods on arguments, thanks [Stanislav Titenko](https://github.com/resetko)
+
+## v2.2.6 / 2018-06-08
+
+- Fixed compatibility issue with usage in an es module environment
+
+## v2.2.5 / 2016-05-02
+
+- Improved performance of `dedupe` variant even further, thanks [Andres Suarez](https://github.com/zertosh)
+
+## v2.2.4 / 2016-04-25
+
+- Improved performance of `dedupe` variant by about 2x, thanks [Bartosz Gościński](https://github.com/bgoscinski)
+
+## v2.2.3 / 2016-01-05
+
+- Updated `bind` variant to use `[].join(' ')` as per the main script in 2.2.2
+
+## v2.2.2 / 2016-01-04
+
+- Switched from string concatenation to `[].join(' ')` for a slight performance gain in the main function.
+
+## v2.2.1 / 2015-11-26
+
+- Add deps parameter to the AMD module, fixes an issue using the Dojo loader, thanks [Chris Jordan](https://github.com/flipperkid)
+
+## v2.2.0 / 2015-10-18
+
+- added a new `bind` variant for use with [css-modules](https://github.com/css-modules/css-modules) and similar abstractions, thanks to [Kirill Yakovenko](https://github.com/blia)
+
+## v2.1.5 / 2015-09-30
+
+- reverted a new usage of `Object.keys` in `dedupe.js` that slipped through in the last release
+
+## v2.1.4 / 2015-09-30
+
+- new case added to benchmarks
+- safer `hasOwnProperty` check
+- AMD module is now named, so you can do the following:
+
+```
+define(["classnames"], function (classNames) {
+  var style = classNames("foo", "bar");
+  // ...
+});
+```
+
+## v2.1.3 / 2015-07-02
+
+- updated UMD wrapper to support AMD and CommonJS on the same pacge
+
+## v2.1.2 / 2015-05-28
+
+- added a proper UMD wrapper
+
+## v2.1.1 / 2015-05-06
+
+- minor performance improvement thanks to type caching
+- improved benchmarking and results output
+
+## v2.1.0 / 2015-05-05
+
+- added alternate `dedupe` version of classNames, which is slower (10x) but ensures that if a class is added then overridden by a falsy value in a subsequent argument, it is excluded from the result.
+
+## v2.0.0 / 2015-05-03
+
+- performance improvement; switched to `Array.isArray` for type detection, which is much faster in modern browsers. A polyfill is now required for IE8 support, see the Readme for details.
+
+## v1.2.2 / 2015-04-28
+
+- license comment updates to simiplify certain build scenarios
+
+## v1.2.1 / 2015-04-22
+
+- added safe exporting for requireJS usage
+- clarified Bower usage and instructions
+
+## v1.2.0 / 2015-03-17
+
+- added comprehensive support for array arguments, including nested arrays
+- simplified code slightly
+
+## Previous
+
+Please see the git history for the details of previous versions.

web/node_modules/classnames/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Jed Watson
+
+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/classnames/README.md

@@ -0,0 +1,198 @@
+Classnames
+===========
+
+[![NPM version](https://badgen.net/npm/v/classnames)](https://www.npmjs.com/package/classnames)
+[![Build status](https://badgen.net/travis/JedWatson/classnames)](https://travis-ci.org/JedWatson/classnames)
+[![NPM Weekly Downloads](https://badgen.net/npm/dw/classnames)](https://www.npmjs.com/package/classnames)
+[![License](https://badgen.net/npm/license/classnames)](https://www.npmjs.com/package/classnames)
+[![Supported by Thinkmill](https://thinkmill.github.io/badge/heart.svg)](https://thinkmill.com.au/?utm_source=github&utm_medium=badge&utm_campaign=classnames)
+
+A simple JavaScript utility for conditionally joining classNames together.
+
+Install with [npm](https://www.npmjs.com/), [Bower](https://bower.io/), or [Yarn](https://yarnpkg.com/):
+
+```bash
+# via npm
+npm install classnames
+
+# via Bower
+bower install classnames
+
+# or Yarn (note that it will automatically save the package to your `dependencies` in `package.json`)
+yarn add classnames
+```
+
+Use with [Node.js](https://nodejs.org/en/), [Browserify](https://browserify.org/), or [webpack](https://webpack.github.io/):
+
+```js
+var classNames = require('classnames');
+classNames('foo', 'bar'); // => 'foo bar'
+```
+
+Alternatively, you can simply include `index.js` on your page with a standalone `<script>` tag and it will export a global `classNames` method, or define the module if you are using RequireJS.
+
+### Project philosophy
+
+We take the stability and performance of this package seriously, because it is run millions of times a day in browsers all around the world. Updates are thoroughly reviewed for performance impacts before being released, and we have a comprehensive test suite.
+
+Classnames follows the [SemVer](https://semver.org/) standard for versioning.
+
+There is also a [Changelog](https://github.com/JedWatson/classnames/blob/master/HISTORY.md).
+
+## Usage
+
+The `classNames` function takes any number of arguments which can be a string or object.
+The argument `'foo'` is short for `{ foo: true }`. If the value associated with a given key is falsy, that key won't be included in the output.
+
+```js
+classNames('foo', 'bar'); // => 'foo bar'
+classNames('foo', { bar: true }); // => 'foo bar'
+classNames({ 'foo-bar': true }); // => 'foo-bar'
+classNames({ 'foo-bar': false }); // => ''
+classNames({ foo: true }, { bar: true }); // => 'foo bar'
+classNames({ foo: true, bar: true }); // => 'foo bar'
+
+// lots of arguments of various types
+classNames('foo', { bar: true, duck: false }, 'baz', { quux: true }); // => 'foo bar baz quux'
+
+// other falsy values are just ignored
+classNames(null, false, 'bar', undefined, 0, 1, { baz: null }, ''); // => 'bar 1'
+```
+
+Arrays will be recursively flattened as per the rules above:
+
+```js
+var arr = ['b', { c: true, d: false }];
+classNames('a', arr); // => 'a b c'
+```
+
+### Dynamic class names with ES2015
+
+If you're in an environment that supports [computed keys](https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer) (available in ES2015 and Babel) you can use dynamic class names:
+
+```js
+let buttonType = 'primary';
+classNames({ [`btn-${buttonType}`]: true });
+```
+
+### Usage with React.js
+
+This package is the official replacement for `classSet`, which was originally shipped in the React.js Addons bundle.
+
+One of its primary use cases is to make dynamic and conditional `className` props simpler to work with (especially more so than conditional string manipulation). So where you may have the following code to generate a `className` prop for a `<button>` in React:
+
+```js
+class Button extends React.Component {
+  // ...
+  render () {
+    var btnClass = 'btn';
+    if (this.state.isPressed) btnClass += ' btn-pressed';
+    else if (this.state.isHovered) btnClass += ' btn-over';
+    return <button className={btnClass}>{this.props.label}</button>;
+  }
+}
+```
+
+You can express the conditional classes more simply as an object:
+
+```js
+var classNames = require('classnames');
+
+class Button extends React.Component {
+  // ...
+  render () {
+    var btnClass = classNames({
+      btn: true,
+      'btn-pressed': this.state.isPressed,
+      'btn-over': !this.state.isPressed && this.state.isHovered
+    });
+    return <button className={btnClass}>{this.props.label}</button>;
+  }
+}
+```
+
+Because you can mix together object, array and string arguments, supporting optional `className` props is also simpler as only truthy arguments get included in the result:
+
+```js
+var btnClass = classNames('btn', this.props.className, {
+  'btn-pressed': this.state.isPressed,
+  'btn-over': !this.state.isPressed && this.state.isHovered
+});
+```
+
+
+### Alternate `dedupe` version
+
+There is an alternate version of `classNames` available which correctly dedupes classes and ensures that falsy classes specified in later arguments are excluded from the result set.
+
+This version is slower (about 5x) so it is offered as an opt-in.
+
+To use the dedupe version with Node.js, Browserify, or webpack:
+
+```js
+var classNames = require('classnames/dedupe');
+
+classNames('foo', 'foo', 'bar'); // => 'foo bar'
+classNames('foo', { foo: false, bar: true }); // => 'bar'
+```
+
+For standalone (global / AMD) use, include `dedupe.js` in a `<script>` tag on your page.
+
+
+### Alternate `bind` version (for [css-modules](https://github.com/css-modules/css-modules))
+
+If you are using [css-modules](https://github.com/css-modules/css-modules), or a similar approach to abstract class "names" and the real `className` values that are actually output to the DOM, you may want to use the `bind` variant.
+
+_Note that in ES2015 environments, it may be better to use the "dynamic class names" approach documented above._
+
+```js
+var classNames = require('classnames/bind');
+
+var styles = {
+  foo: 'abc',
+  bar: 'def',
+  baz: 'xyz'
+};
+
+var cx = classNames.bind(styles);
+
+var className = cx('foo', ['bar'], { baz: true }); // => "abc def xyz"
+```
+
+Real-world example:
+
+```js
+/* components/submit-button.js */
+import { Component } from 'react';
+import classNames from 'classnames/bind';
+import styles from './submit-button.css';
+
+let cx = classNames.bind(styles);
+
+export default class SubmitButton extends Component {
+  render () {
+    let text = this.props.store.submissionInProgress ? 'Processing...' : 'Submit';
+    let className = cx({
+      base: true,
+      inProgress: this.props.store.submissionInProgress,
+      error: this.props.store.errorOccurred,
+      disabled: this.props.form.valid,
+    });
+    return <button className={className}>{text}</button>;
+  }
+};
+
+```
+
+
+## Polyfills needed to support older browsers
+
+#### `classNames >=2.0.0`
+
+`Array.isArray`: see [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray) for details about unsupported older browsers (e.g. <= IE8) and a simple polyfill.
+
+
+## LICENSE [MIT](LICENSE)
+
+Copyright (c) 2018 Jed Watson.
+Copyright of the Typescript bindings are respective of each contributor listed in the definition file.

web/node_modules/classnames/bind.d.ts

@@ -0,0 +1,5 @@
+export * from './index';
+import { Argument } from './index';
+
+export type Binding = { [key: string]: string };
+export default function classNames(this: Binding | void, ...args: Argument[]): string;

web/node_modules/classnames/bind.js

@@ -0,0 +1,53 @@
+/*!
+  Copyright (c) 2018 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+	'use strict';
+
+	var hasOwn = {}.hasOwnProperty;
+
+	function classNames () {
+		var classes = [];
+
+		for (var i = 0; i < arguments.length; i++) {
+			var arg = arguments[i];
+			if (!arg) continue;
+
+			var argType = typeof arg;
+
+			if (argType === 'string' || argType === 'number') {
+				classes.push(this && this[arg] || arg);
+			} else if (Array.isArray(arg)) {
+				classes.push(classNames.apply(this, arg));
+			} else if (argType === 'object') {
+				if (arg.toString === Object.prototype.toString) {
+					for (var key in arg) {
+						if (hasOwn.call(arg, key) && arg[key]) {
+							classes.push(this && this[key] || key);
+						}
+					}
+				} else {
+					classes.push(arg.toString());
+				}
+			}
+		}
+
+		return classes.join(' ');
+	}
+
+	if (typeof module !== 'undefined' && module.exports) {
+		classNames.default = classNames;
+		module.exports = classNames;
+	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
+		// register as 'classnames', consistent with npm package name
+		define('classnames', [], function () {
+			return classNames;
+		});
+	} else {
+		window.classNames = classNames;
+	}
+}());

web/node_modules/classnames/dedupe.d.ts

@@ -0,0 +1,4 @@
+export * from './index';
+import classNames from './index';
+
+export default classNames;

web/node_modules/classnames/dedupe.js

@@ -0,0 +1,114 @@
+/*!
+  Copyright (c) 2018 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+	'use strict';
+
+	var classNames = (function () {
+		// don't inherit from Object so we can skip hasOwnProperty check later
+		// http://stackoverflow.com/questions/15518328/creating-js-object-with-object-createnull#answer-21079232
+		function StorageObject() {}
+		StorageObject.prototype = Object.create(null);
+
+		function _parseArray (resultSet, array) {
+			var length = array.length;
+
+			for (var i = 0; i < length; ++i) {
+				_parse(resultSet, array[i]);
+			}
+		}
+
+		var hasOwn = {}.hasOwnProperty;
+
+		function _parseNumber (resultSet, num) {
+			resultSet[num] = true;
+		}
+
+		function _parseObject (resultSet, object) {
+			if (object.toString === Object.prototype.toString) {
+				for (var k in object) {
+					if (hasOwn.call(object, k)) {
+						// set value to false instead of deleting it to avoid changing object structure
+						// https://www.smashingmagazine.com/2012/11/writing-fast-memory-efficient-javascript/#de-referencing-misconceptions
+						resultSet[k] = !!object[k];
+					}
+				}
+			} else {
+				resultSet[object.toString()] = true;
+			}
+		}
+
+		var SPACE = /\s+/;
+		function _parseString (resultSet, str) {
+			var array = str.split(SPACE);
+			var length = array.length;
+
+			for (var i = 0; i < length; ++i) {
+				resultSet[array[i]] = true;
+			}
+		}
+
+		function _parse (resultSet, arg) {
+			if (!arg) return;
+			var argType = typeof arg;
+
+			// 'foo bar'
+			if (argType === 'string') {
+				_parseString(resultSet, arg);
+
+			// ['foo', 'bar', ...]
+			} else if (Array.isArray(arg)) {
+				_parseArray(resultSet, arg);
+
+			// { 'foo': true, ... }
+			} else if (argType === 'object') {
+				_parseObject(resultSet, arg);
+
+			// '130'
+			} else if (argType === 'number') {
+				_parseNumber(resultSet, arg);
+			}
+		}
+
+		function _classNames () {
+			// don't leak arguments
+			// https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
+			var len = arguments.length;
+			var args = Array(len);
+			for (var i = 0; i < len; i++) {
+				args[i] = arguments[i];
+			}
+
+			var classSet = new StorageObject();
+			_parseArray(classSet, args);
+
+			var list = [];
+
+			for (var k in classSet) {
+				if (classSet[k]) {
+					list.push(k)
+				}
+			}
+
+			return list.join(' ');
+		}
+
+		return _classNames;
+	})();
+
+	if (typeof module !== 'undefined' && module.exports) {
+		classNames.default = classNames;
+		module.exports = classNames;
+	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
+		// register as 'classnames', consistent with npm package name
+		define('classnames', [], function () {
+			return classNames;
+		});
+	} else {
+		window.classNames = classNames;
+	}
+}());

web/node_modules/classnames/index.d.ts

@@ -0,0 +1,15 @@
+// LICENSE is MIT
+//
+// Copyright (c) 2018
+//   Dave Keen <http://www.keendevelopment.ch>
+//   Adi Dahiya <https://github.com/adidahiya>
+//   Jason Killian <https://github.com/JKillian>
+//   Sean Kelley <https://github.com/seansfkelley>
+//   Michal Adamczyk <https://github.com/mradamczyk>
+//   Marvin Hagemeister <https://github.com/marvinhagemeister>
+
+export type Value = string | number | boolean | undefined | null;
+export type Mapping = { [key: string]: any };
+export type Argument = Value | Mapping | Argument[];
+
+export default function classNames(...args: Argument[]): string;

web/node_modules/classnames/index.js

@@ -0,0 +1,58 @@
+/*!
+  Copyright (c) 2018 Jed Watson.
+  Licensed under the MIT License (MIT), see
+  http://jedwatson.github.io/classnames
+*/
+/* global define */
+
+(function () {
+	'use strict';
+
+	var hasOwn = {}.hasOwnProperty;
+
+	function classNames() {
+		var classes = [];
+
+		for (var i = 0; i < arguments.length; i++) {
+			var arg = arguments[i];
+			if (!arg) continue;
+
+			var argType = typeof arg;
+
+			if (argType === 'string' || argType === 'number') {
+				classes.push(arg);
+			} else if (Array.isArray(arg)) {
+				if (arg.length) {
+					var inner = classNames.apply(null, arg);
+					if (inner) {
+						classes.push(inner);
+					}
+				}
+			} else if (argType === 'object') {
+				if (arg.toString === Object.prototype.toString) {
+					for (var key in arg) {
+						if (hasOwn.call(arg, key) && arg[key]) {
+							classes.push(key);
+						}
+					}
+				} else {
+					classes.push(arg.toString());
+				}
+			}
+		}
+
+		return classes.join(' ');
+	}
+
+	if (typeof module !== 'undefined' && module.exports) {
+		classNames.default = classNames;
+		module.exports = classNames;
+	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
+		// register as 'classnames', consistent with npm package name
+		define('classnames', [], function () {
+			return classNames;
+		});
+	} else {
+		window.classNames = classNames;
+	}
+}());

web/node_modules/classnames/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "classnames",
+  "version": "2.3.1",
+  "description": "A simple utility for conditionally joining classNames together",
+  "main": "index.js",
+  "author": "Jed Watson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JedWatson/classnames.git"
+  },
+  "types": "./index.d.ts",
+  "scripts": {
+    "benchmarks": "node ./benchmarks/run",
+    "benchmarks-browserify": "./node_modules/.bin/browserify ./benchmarks/runInBrowser.js >./benchmarks/runInBrowser.bundle.js",
+    "test": "mocha tests/*.js"
+  },
+  "keywords": [
+    "react",
+    "css",
+    "classes",
+    "classname",
+    "classnames",
+    "util",
+    "utility"
+  ],
+  "devDependencies": {
+    "benchmark": "^2.1.4",
+    "browserify": "^17.0.0",
+    "mocha": "^8.3.2"
+  }
+}