Mail

frontend/node_modules/babel-loader/CHANGELOG.md

@@ -0,0 +1,169 @@
+# Changelog
+
+For changes in version v7.0.0 and up please go to [release](https://github.com/babel/babel-loader/releases)
+
+# Old Changelog
+
+## v6.4.1
+
+### 🐛 Bug Fix
+
+- Fixed reset of BABEL_ENV when options.forceEnv is used (#420) @nikopavlica
+
+## v6.4.0
+
+### 🚀 New Feature
+
+- added metadata passing from babel to webpack, which is currently used by react-intl (#398) @Ognian
+
+## v6.3.2
+
+### 😢 Regression
+
+- `forceEnv` was interfering with regular environment handling
+
+## v6.3.1
+
+### 🐛 Bug Fix
+
+ - The new `forceEnv` options wasn't working as expected (#379) @chrisvasz
+
+## v6.3.0
+
+### 🚀 New Feature
+
+- Add new config option `forceEnv` (#368) @moimael
+
+Allow to override BABEL_ENV/NODE_ENV at loader-level. Useful for isomorphic applications which have   separate babel config for client and server.
+
+### 🐛 Bug Fix
+
+- Update loader-utils dependency to ^0.2.16 to fix compatibility with webpack 2 (#371) @leonaves
+
+### 💅 Polish
+
+- Improve FS caching to do less sync calls which improves performance slightly (#375) @akx
+
+## v6.2.10
+
+Support for webpack 2.2-rc has been added in this release
+
+### 🐛 Bug Fix
+
+- If cache directory not writable, try to fallback to tmpdir before failing
+
+## v6.2.9
+
+### 😢 Regression
+
+Source maps on windows did not work correctly with v6.2.8.
+Thanks @josephst
+
+### 🏠 Internal
+
+- Add AppVeyor to run tests on windows @danez
+- Fix tests on windows (#343) @danez
+
+## v6.2.8
+
+### 🐛 Bug Fix
+
+- gzipped files should have `.gz` as the extension, not `.gzip` (#326) @bjornstar
+- fix options.sourceFileName gennerate bug (#260) @creeperyang
+
+### 📝 Documentation
+
+- Update README docs for cacheDirectory's actual behaviour (#245) @sohkai
+- updates docs re: transform-runtime (#197) @gbrassey
+
+### 🏠 Internal
+
+- Use eslint and nyc (#321) @danez
+- Adjust travis config (#320) @danez
+- Use babel to compile babel-loader (#319) @danez
+
+## v6.2.7
+
+### 😢 Regression
+
+Fallback to `os.tmpdir()` if no cachedir found (#318) (fixes #317) @danez
+
+Fixes an issue with v6.2.6 when using `babel-loader` as a global package.
+
+## v6.2.6
+
+### 🐛 Bug Fix
+
+- Use standard cache dir as default `cacheDirectory` (#301) @fson
+
+Use the common cache directory, `./node_modules/.cache/babel-loader`, as the default cache directory (when the cacheDirectory setting is enabled).
+
+```js
+query: {
+  cacheDirectory: true
+}
+```
+
+## v6.2.5
+
+- Don't show the call stack for a Babel error (such as when you have a syntax error)
+
+<img width="415" alt="screenshot 2016-08-15 15 24 37" src="https://cloud.githubusercontent.com/assets/30594/17664401/727ba098-62fc-11e6-9f12-42da0cf47f14.png">
+
+- resolve the .babelrc relative to the file path rather than the cwd (current working directory).
+
+ * fix: more concise formatting for Babel errors (#287) (Andrey Popp)
+ * fix(resolve-rc): resolve-rc relative file path (#253) (Luke Page)
+ * add babel-core and preset-2015 to dev dependencies (#273) (timse)
+ * chore(docs): add issue and pr templates (#280) (Joshua Wiens)
+ * chore(docs): fix badge formatting (Joshua Wiens)
+ * chore(ci): expand travis testing (#278) (Joshua Wiens)
+ * Update README: add env vars to cacheIdentifier (#267) (Dominik Ferber)
+ * add npm badge [skip ci] (Henry Zhu)
+ * update [skip ci] (Henry Zhu)
+ * remove jsx references as well [skip ci] (Henry Zhu)
+ * Save the transform to devDependencies (Ray Booysen)
+ * Remove 'react' preset (Jake Rios)
+ * Removed babel-preset-react from README.md (Ben Stephenson)
+
+## v6.2.4
+ * change allowed peer deps (all webpack 2 beta versions)
+
+## v6.2.3
+ * change allowed peer deps (2.0.7-beta)
+
+## v6.2.2
+  * Update peerDependencies to accept webpack 2 [#208](https://github.com/babel/babel-loader/pull/208)
+  * Remove duplicated dependencies
+
+## v6.2.0
+  * Pass true filenames [#106](https://github.com/babel/babel-loader/issues/106)
+  * Remove babel-core from devDependencies
+
+## v6.1.0
+
+  * Merge [PR #146](https://github.com/babel/babel-loader/pull/146) Set source file name relative to options.sourceRoot
+  * Merge [PR #136](https://github.com/babel/babel-loader/pull/136) use container-based infrastructure for faster build
+  * Merge [PR #121](https://github.com/babel/babel-loader/pull/121) Make babelrc configurable
+  * Merge [PR #113](https://github.com/babel/babel-loader/pull/113) Include BABEL_ENV || NODE_ENV in cacheIdentifier
+
+## v6.0.1
+
+  * Update to babel v6.
+
+## v5.3.1
+
+  * Merge [PR #85](https://github.com/babel/babel-loader/pull/85) - Don't override sourcemap if sourcesContent already exists.
+
+
+## v5.3.1
+
+  * Merge [PR #82](https://github.com/babel/babel-loader/pull/82) - Fallback global options to empty object to avoid conflicts with object-assign polyfill.
+
+## v5.3.0
+
+  * Merge [PR #79](https://github.com/babel/babel-loader/pull/79) - This should allow babel-loader to work with [enhanced-require](https://github.com/webpack/enhanced-require).
+
+## v5.2.0
+
+  * Include `.babelrc` file into the `cacheIdentifier` if it exists

frontend/node_modules/babel-loader/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014-2019 Luís Couto <hello@luiscouto.pt>
+
+MIT License
+
+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.

frontend/node_modules/babel-loader/README.md

@@ -0,0 +1,400 @@
+> This README is for babel-loader v8 + Babel v7
+> If you are using legacy Babel v6, see the [7.x branch](https://github.com/babel/babel-loader/tree/7.x) docs
+
+[![NPM Status](https://img.shields.io/npm/v/babel-loader.svg?style=flat)](https://www.npmjs.com/package/babel-loader)
+[![codecov](https://codecov.io/gh/babel/babel-loader/branch/main/graph/badge.svg)](https://codecov.io/gh/babel/babel-loader)
+
+<div align="center">
+  <a href="https://github.com/babel/babel">
+    <img src="https://rawgit.com/babel/logo/master/babel.svg" alt="Babel logo" width="200" height="200">
+  </a>
+  <a href="https://github.com/webpack/webpack">
+    <img src="https://webpack.js.org/assets/icon-square-big.svg" alt="webpack logo" width="200" height="200">
+  </a>
+</div>
+
+<h1 align="center">Babel Loader</h1>
+
+This package allows transpiling JavaScript files using [Babel](https://github.com/babel/babel) and [webpack](https://github.com/webpack/webpack).
+
+**Note**: Issues with the output should be reported on the Babel [Issues](https://github.com/babel/babel/issues) tracker.
+
+<h2 align="center">Install</h2>
+
+> webpack `4.x || 5.x` | babel-loader 8.x | babel 7.x
+
+```bash
+npm install -D babel-loader @babel/core @babel/preset-env webpack
+```
+
+<h2 align="center">Usage</h2>
+
+webpack documentation: [Loaders](https://webpack.js.org/loaders/)
+
+Within your webpack configuration object, you'll need to add the babel-loader to the list of modules, like so:
+
+```javascript
+module: {
+  rules: [
+    {
+      test: /\.m?js$/,
+      exclude: /node_modules/,
+      use: {
+        loader: 'babel-loader',
+        options: {
+          presets: [
+            ['@babel/preset-env', { targets: "defaults" }]
+          ]
+        }
+      }
+    }
+  ]
+}
+```
+
+### Options
+
+See the `babel` [options](https://babeljs.io/docs/en/options).
+
+You can pass options to the loader by using the [`options`](https://webpack.js.org/configuration/module/#ruleoptions--rulequery) property:
+
+```javascript
+module: {
+  rules: [
+    {
+      test: /\.m?js$/,
+      exclude: /node_modules/,
+      use: {
+        loader: 'babel-loader',
+        options: {
+          presets: [
+            ['@babel/preset-env', { targets: "defaults" }]
+          ],
+          plugins: ['@babel/plugin-proposal-class-properties']
+        }
+      }
+    }
+  ]
+}
+```
+
+This loader also supports the following loader-specific option:
+
+* `cacheDirectory`: Default `false`. When set, the given directory will be used to cache the results of the loader. Future webpack builds will attempt to read from the cache to avoid needing to run the potentially expensive Babel recompilation process on each run. If the value is set to `true` in options (`{cacheDirectory: true}`), the loader will use the default cache directory in `node_modules/.cache/babel-loader` or fallback to the default OS temporary file directory if no `node_modules` folder could be found in any root directory.
+
+* `cacheIdentifier`: Default is a string composed by the `@babel/core`'s version, the `babel-loader`'s version, the contents of `.babelrc` file if it exists, and the value of the environment variable `BABEL_ENV` with a fallback to the `NODE_ENV` environment variable. This can be set to a custom value to force cache busting if the identifier changes.
+
+* `cacheCompression`: Default `true`. When set, each Babel transform output will be compressed with Gzip. If you want to opt-out of cache compression, set it to `false` -- your project may benefit from this if it transpiles thousands of files.
+
+* `customize`: Default `null`. The path of a module that exports a `custom` callback [like the one that you'd pass to `.custom()`](#customized-loader). Since you already have to make a new file to use this, it is recommended that you instead use `.custom` to create a wrapper loader. Only use this if you _must_ continue using `babel-loader` directly, but still want to customize.
+
+* `metadataSubscribers`: Default `[]`. Takes an array of context function names. E.g. if you passed ['myMetadataPlugin'], you'd assign a subscriber function to `context.myMetadataPlugin` within your webpack plugin's hooks & that function will be called with `metadata`.
+
+## Troubleshooting
+
+### babel-loader is slow!
+
+Make sure you are transforming as few files as possible. Because you are probably matching `/\.m?js$/`, you might be transforming the `node_modules` folder or other unwanted source.
+
+To exclude `node_modules`, see the `exclude` option in the `loaders` config as documented above.
+
+You can also speed up babel-loader by as much as 2x by using the `cacheDirectory` option. This will cache transformations to the filesystem.
+
+### Some files in my node_modules are not transpiled for IE 11
+
+Although we typically recommend not compiling `node_modules`, you may need to when using libraries that do not support IE 11.
+
+For this, you can either use a combination of `test` and `not`, or [pass a function](https://webpack.js.org/configuration/module/#condition) to your `exclude` option. You can also use negative lookahead regex as suggested [here](https://github.com/webpack/webpack/issues/2031#issuecomment-294706065).
+
+```javascript
+{
+    test: /\.m?js$/,
+    exclude: {
+      and: [/node_modules/], // Exclude libraries in node_modules ...
+      not: [
+        // Except for a few of them that needs to be transpiled because they use modern syntax
+        /unfetch/,
+        /d3-array|d3-scale/,
+        /@hapi[\\/]joi-date/,
+      ]
+    },
+    use: {
+      loader: 'babel-loader',
+      options: {
+        presets: [
+          ['@babel/preset-env', { targets: "ie 11" }]
+        ]
+      }
+    }
+  }
+```
+
+### Babel is injecting helpers into each file and bloating my code!
+
+Babel uses very small helpers for common functions such as `_extend`. By default, this will be added to every file that requires it.
+
+You can instead require the Babel runtime as a separate module to avoid the duplication.
+
+The following configuration disables automatic per-file runtime injection in Babel, requiring `@babel/plugin-transform-runtime` instead and making all helper references use it.
+
+See the [docs](https://babeljs.io/docs/plugins/transform-runtime/) for more information.
+
+**NOTE**: You must run `npm install -D @babel/plugin-transform-runtime` to include this in your project and `@babel/runtime` itself as a dependency with `npm install @babel/runtime`.
+
+```javascript
+rules: [
+  // the 'transform-runtime' plugin tells Babel to
+  // require the runtime instead of inlining it.
+  {
+    test: /\.m?js$/,
+    exclude: /node_modules/,
+    use: {
+      loader: 'babel-loader',
+      options: {
+        presets: [
+          ['@babel/preset-env', { targets: "defaults" }]
+        ],
+        plugins: ['@babel/plugin-transform-runtime']
+      }
+    }
+  }
+]
+```
+
+#### **NOTE**: transform-runtime & custom polyfills (e.g. Promise library)
+
+Since [@babel/plugin-transform-runtime](https://github.com/babel/babel/tree/main/packages/babel-plugin-transform-runtime) includes a polyfill that includes a custom [regenerator-runtime](https://github.com/facebook/regenerator/blob/master/packages/regenerator-runtime/runtime.js) and [core-js](https://github.com/zloirock/core-js), the following usual shimming method using `webpack.ProvidePlugin` will not work:
+
+```javascript
+// ...
+        new webpack.ProvidePlugin({
+            'Promise': 'bluebird'
+        }),
+// ...
+```
+
+The following approach will not work either:
+
+```javascript
+require('@babel/runtime/core-js/promise').default = require('bluebird');
+
+var promise = new Promise;
+```
+
+which outputs to (using `runtime`):
+
+```javascript
+'use strict';
+
+var _Promise = require('@babel/runtime/core-js/promise')['default'];
+
+require('@babel/runtime/core-js/promise')['default'] = require('bluebird');
+
+var promise = new _Promise();
+```
+
+The previous `Promise` library is referenced and used before it is overridden.
+
+One approach is to have a "bootstrap" step in your application that would first override the default globals before your application:
+
+```javascript
+// bootstrap.js
+
+require('@babel/runtime/core-js/promise').default = require('bluebird');
+
+// ...
+
+require('./app');
+```
+
+### The Node.js API for `babel` has been moved to `babel-core`.
+
+If you receive this message, it means that you have the npm package `babel` installed and are using the short notation of the loader in the webpack config (which is not valid anymore as of webpack 2.x):
+```javascript
+  {
+    test: /\.m?js$/,
+    loader: 'babel',
+  }
+```
+
+webpack then tries to load the `babel` package instead of the `babel-loader`.
+
+To fix this, you should uninstall the npm package `babel`, as it is deprecated in Babel v6. (Instead, install `@babel/cli` or `@babel/core`.)
+In the case one of your dependencies is installing `babel` and you cannot uninstall it yourself, use the complete name of the loader in the webpack config:
+```javascript
+  {
+    test: /\.m?js$/,
+    loader: 'babel-loader',
+  }
+```
+
+### Exclude libraries that should not be transpiled
+
+`core-js` and `webpack/buildin` will cause errors if they are transpiled by Babel.
+
+You will need to exclude them form `babel-loader`.
+
+```js
+{
+  "loader": "babel-loader",
+  "options": {
+    "exclude": [
+      // \\ for Windows, / for macOS and Linux
+      /node_modules[\\/]core-js/,
+      /node_modules[\\/]webpack[\\/]buildin/,
+    ],
+    "presets": [
+      "@babel/preset-env"
+    ]
+  }
+}
+```
+
+### Top level function (IIFE) is still arrow (on Webpack 5)
+
+That function is injected by Webpack itself _after_ running `babel-loader`. By default Webpack asumes that your target environment supports some ES2015 features, but you can overwrite this behavior using the `output.environment` Webpack option ([documentation](https://webpack.js.org/configuration/output/#outputenvironment)).
+
+To avoid the top-level arrow function, you can use `output.environment.arrowFunction`:
+
+```js
+// webpack.config.js
+module.exports = {
+  // ...
+  output: {
+    // ...
+    environment: {
+      // ...
+      arrowFunction: false, // <-- this line does the trick
+    },
+  },
+};
+```
+
+## Customize config based on webpack target
+
+Webpack supports bundling multiple [targets](https://webpack.js.org/concepts/targets/). For cases where you may want different Babel configurations for each target (like `web` _and_ `node`), this loader provides a `target` property via Babel's [caller](https://babeljs.io/docs/en/config-files#apicallercb) API.
+
+For example, to change the environment targets passed to `@babel/preset-env` based on the webpack target:
+
+```javascript
+// babel.config.js
+
+module.exports = api => {
+  return {
+    plugins: [
+      "@babel/plugin-proposal-nullish-coalescing-operator",
+      "@babel/plugin-proposal-optional-chaining"
+    ],
+    presets: [
+      [
+        "@babel/preset-env",
+        {
+          useBuiltIns: "entry",
+          // caller.target will be the same as the target option from webpack
+          targets: api.caller(caller => caller && caller.target === "node")
+            ? { node: "current" }
+            : { chrome: "58", ie: "11" }
+        }
+      ]
+    ]
+  }
+}
+```
+
+## Customized Loader
+
+`babel-loader` exposes a loader-builder utility that allows users to add custom handling
+of Babel's configuration for each file that it processes.
+
+`.custom` accepts a callback that will be called with the loader's instance of
+`babel` so that tooling can ensure that it using exactly the same `@babel/core`
+instance as the loader itself.
+
+In cases where you want to customize without actually having a file to call `.custom`, you
+may also pass the `customize` option with a string pointing at a file that exports
+your `custom` callback function.
+
+### Example
+
+```js
+// Export from "./my-custom-loader.js" or whatever you want.
+module.exports = require("babel-loader").custom(babel => {
+  function myPlugin() {
+    return {
+      visitor: {},
+    };
+  }
+
+  return {
+    // Passed the loader options.
+    customOptions({ opt1, opt2, ...loader }) {
+      return {
+        // Pull out any custom options that the loader might have.
+        custom: { opt1, opt2 },
+
+        // Pass the options back with the two custom options removed.
+        loader,
+      };
+    },
+
+    // Passed Babel's 'PartialConfig' object.
+    config(cfg) {
+      if (cfg.hasFilesystemConfig()) {
+        // Use the normal config
+        return cfg.options;
+      }
+
+      return {
+        ...cfg.options,
+        plugins: [
+          ...(cfg.options.plugins || []),
+
+          // Include a custom plugin in the options.
+          myPlugin,
+        ],
+      };
+    },
+
+    result(result) {
+      return {
+        ...result,
+        code: result.code + "\n// Generated by some custom loader",
+      };
+    },
+  };
+});
+```
+
+```js
+// And in your Webpack config
+module.exports = {
+  // ..
+  module: {
+    rules: [{
+      // ...
+      loader: path.join(__dirname, 'my-custom-loader.js'),
+      // ...
+    }]
+  }
+};
+```
+
+### `customOptions(options: Object): { custom: Object, loader: Object }`
+
+Given the loader's options, split custom options out of `babel-loader`'s
+options.
+
+
+### `config(cfg: PartialConfig): Object`
+
+Given Babel's `PartialConfig` object, return the `options` object that should
+be passed to `babel.transform`.
+
+
+### `result(result: Result): Result`
+
+Given Babel's result object, allow loaders to make additional tweaks to it.
+
+
+## License
+[MIT](https://couto.mit-license.org/)

frontend/node_modules/babel-loader/lib/Error.js

@@ -0,0 +1,31 @@
+"use strict";
+
+const STRIP_FILENAME_RE = /^[^:]+: /;
+const format = err => {
+  if (err instanceof SyntaxError) {
+    err.name = "SyntaxError";
+    err.message = err.message.replace(STRIP_FILENAME_RE, "");
+    err.hideStack = true;
+  } else if (err instanceof TypeError) {
+    err.name = null;
+    err.message = err.message.replace(STRIP_FILENAME_RE, "");
+    err.hideStack = true;
+  }
+  return err;
+};
+class LoaderError extends Error {
+  constructor(err) {
+    super();
+    const {
+      name,
+      message,
+      codeFrame,
+      hideStack
+    } = format(err);
+    this.name = "BabelLoaderError";
+    this.message = `${name ? `${name}: ` : ""}${message}\n\n${codeFrame}\n`;
+    this.hideStack = hideStack;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+module.exports = LoaderError;

frontend/node_modules/babel-loader/lib/cache.js

@@ -0,0 +1,203 @@
+"use strict";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+/**
+ * Filesystem Cache
+ *
+ * Given a file and a transform function, cache the result into files
+ * or retrieve the previously cached files if the given file is already known.
+ *
+ * @see https://github.com/babel/babel-loader/issues/34
+ * @see https://github.com/babel/babel-loader/pull/41
+ */
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const zlib = require("zlib");
+const crypto = require("crypto");
+const findCacheDir = require("find-cache-dir");
+const {
+  promisify
+} = require("util");
+const transform = require("./transform");
+// Lazily instantiated when needed
+let defaultCacheDirectory = null;
+let hashType = "sha256";
+// use md5 hashing if sha256 is not available
+try {
+  crypto.createHash(hashType);
+} catch (err) {
+  hashType = "md5";
+}
+const readFile = promisify(fs.readFile);
+const writeFile = promisify(fs.writeFile);
+const gunzip = promisify(zlib.gunzip);
+const gzip = promisify(zlib.gzip);
+const makeDir = require("make-dir");
+
+/**
+ * Read the contents from the compressed file.
+ *
+ * @async
+ * @params {String} filename
+ * @params {Boolean} compress
+ */
+const read = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (filename, compress) {
+    const data = yield readFile(filename + (compress ? ".gz" : ""));
+    const content = compress ? yield gunzip(data) : data;
+    return JSON.parse(content.toString());
+  });
+  return function read(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+/**
+ * Write contents into a compressed file.
+ *
+ * @async
+ * @params {String} filename
+ * @params {Boolean} compress
+ * @params {String} result
+ */
+const write = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(function* (filename, compress, result) {
+    const content = JSON.stringify(result);
+    const data = compress ? yield gzip(content) : content;
+    return yield writeFile(filename + (compress ? ".gz" : ""), data);
+  });
+  return function write(_x3, _x4, _x5) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+/**
+ * Build the filename for the cached file
+ *
+ * @params {String} source  File source code
+ * @params {Object} options Options used
+ *
+ * @return {String}
+ */
+const filename = function (source, identifier, options) {
+  const hash = crypto.createHash(hashType);
+  const contents = JSON.stringify({
+    source,
+    options,
+    identifier
+  });
+  hash.update(contents);
+  return hash.digest("hex") + ".json";
+};
+
+/**
+ * Handle the cache
+ *
+ * @params {String} directory
+ * @params {Object} params
+ */
+const handleCache = /*#__PURE__*/function () {
+  var _ref3 = _asyncToGenerator(function* (directory, params) {
+    const {
+      source,
+      options = {},
+      cacheIdentifier,
+      cacheDirectory,
+      cacheCompression,
+      logger
+    } = params;
+    const file = path.join(directory, filename(source, cacheIdentifier, options));
+    try {
+      // No errors mean that the file was previously cached
+      // we just need to return it
+      logger.debug(`reading cache file '${file}'`);
+      return yield read(file, cacheCompression);
+    } catch (err) {
+      // conitnue if cache can't be read
+      logger.debug(`discarded cache as it can not be read`);
+    }
+    const fallback = typeof cacheDirectory !== "string" && directory !== os.tmpdir();
+
+    // Make sure the directory exists.
+    try {
+      logger.debug(`creating cache folder '${directory}'`);
+      yield makeDir(directory);
+    } catch (err) {
+      if (fallback) {
+        return handleCache(os.tmpdir(), params);
+      }
+      throw err;
+    }
+
+    // Otherwise just transform the file
+    // return it to the user asap and write it in cache
+    logger.debug(`applying Babel transform`);
+    const result = yield transform(source, options);
+
+    // Do not cache if there are external dependencies,
+    // since they might change and we cannot control it.
+    if (!result.externalDependencies.length) {
+      try {
+        logger.debug(`writing result to cache file '${file}'`);
+        yield write(file, cacheCompression, result);
+      } catch (err) {
+        if (fallback) {
+          // Fallback to tmpdir if node_modules folder not writable
+          return handleCache(os.tmpdir(), params);
+        }
+        throw err;
+      }
+    }
+    return result;
+  });
+  return function handleCache(_x6, _x7) {
+    return _ref3.apply(this, arguments);
+  };
+}();
+
+/**
+ * Retrieve file from cache, or create a new one for future reads
+ *
+ * @async
+ * @param  {Object}   params
+ * @param  {String}   params.cacheDirectory   Directory to store cached files
+ * @param  {String}   params.cacheIdentifier  Unique identifier to bust cache
+ * @param  {Boolean}  params.cacheCompression Whether compressing cached files
+ * @param  {String}   params.source   Original contents of the file to be cached
+ * @param  {Object}   params.options  Options to be given to the transform fn
+ *
+ * @example
+ *
+ *   const result = await cache({
+ *     cacheDirectory: '.tmp/cache',
+ *     cacheIdentifier: 'babel-loader-cachefile',
+ *     cacheCompression: false,
+ *     source: *source code from file*,
+ *     options: {
+ *       experimental: true,
+ *       runtime: true
+ *     },
+ *   });
+ */
+
+module.exports = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator(function* (params) {
+    let directory;
+    if (typeof params.cacheDirectory === "string") {
+      directory = params.cacheDirectory;
+    } else {
+      if (defaultCacheDirectory === null) {
+        defaultCacheDirectory = findCacheDir({
+          name: "babel-loader"
+        }) || os.tmpdir();
+      }
+      directory = defaultCacheDirectory;
+    }
+    return yield handleCache(directory, params);
+  });
+  return function (_x8) {
+    return _ref4.apply(this, arguments);
+  };
+}();

frontend/node_modules/babel-loader/lib/index.js

@@ -0,0 +1,232 @@
+"use strict";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+let babel;
+try {
+  babel = require("@babel/core");
+} catch (err) {
+  if (err.code === "MODULE_NOT_FOUND") {
+    err.message += "\n babel-loader@8 requires Babel 7.x (the package '@babel/core'). " + "If you'd like to use Babel 6.x ('babel-core'), you should install 'babel-loader@7'.";
+  }
+  throw err;
+}
+
+// Since we've got the reverse bridge package at @babel/core@6.x, give
+// people useful feedback if they try to use it alongside babel-loader.
+if (/^6\./.test(babel.version)) {
+  throw new Error("\n babel-loader@8 will not work with the '@babel/core@6' bridge package. " + "If you want to use Babel 6.x, install 'babel-loader@7'.");
+}
+const {
+  version
+} = require("../package.json");
+const cache = require("./cache");
+const transform = require("./transform");
+const injectCaller = require("./injectCaller");
+const schema = require("./schema");
+const {
+  isAbsolute
+} = require("path");
+const loaderUtils = require("loader-utils");
+const validateOptions = require("schema-utils");
+function subscribe(subscriber, metadata, context) {
+  if (context[subscriber]) {
+    context[subscriber](metadata);
+  }
+}
+module.exports = makeLoader();
+module.exports.custom = makeLoader;
+function makeLoader(callback) {
+  const overrides = callback ? callback(babel) : undefined;
+  return function (source, inputSourceMap) {
+    // Make the loader async
+    const callback = this.async();
+    loader.call(this, source, inputSourceMap, overrides).then(args => callback(null, ...args), err => callback(err));
+  };
+}
+function loader(_x, _x2, _x3) {
+  return _loader.apply(this, arguments);
+}
+function _loader() {
+  _loader = _asyncToGenerator(function* (source, inputSourceMap, overrides) {
+    const filename = this.resourcePath;
+    const logger = typeof this.getLogger === "function" ? this.getLogger("babel-loader") : {
+      debug: () => {}
+    };
+    let loaderOptions = loaderUtils.getOptions(this);
+    validateOptions(schema, loaderOptions, {
+      name: "Babel loader"
+    });
+    if (loaderOptions.customize != null) {
+      if (typeof loaderOptions.customize !== "string") {
+        throw new Error("Customized loaders must be implemented as standalone modules.");
+      }
+      if (!isAbsolute(loaderOptions.customize)) {
+        throw new Error("Customized loaders must be passed as absolute paths, since " + "babel-loader has no way to know what they would be relative to.");
+      }
+      if (overrides) {
+        throw new Error("babel-loader's 'customize' option is not available when already " + "using a customized babel-loader wrapper.");
+      }
+      logger.debug(`loading customize override: '${loaderOptions.customize}'`);
+      let override = require(loaderOptions.customize);
+      if (override.__esModule) override = override.default;
+      if (typeof override !== "function") {
+        throw new Error("Custom overrides must be functions.");
+      }
+      logger.debug("applying customize override to @babel/core");
+      overrides = override(babel);
+    }
+    let customOptions;
+    if (overrides && overrides.customOptions) {
+      logger.debug("applying overrides customOptions() to loader options");
+      const result = yield overrides.customOptions.call(this, loaderOptions, {
+        source,
+        map: inputSourceMap
+      });
+      customOptions = result.custom;
+      loaderOptions = result.loader;
+    }
+
+    // Deprecation handling
+    if ("forceEnv" in loaderOptions) {
+      console.warn("The option `forceEnv` has been removed in favor of `envName` in Babel 7.");
+    }
+    if (typeof loaderOptions.babelrc === "string") {
+      console.warn("The option `babelrc` should not be set to a string anymore in the babel-loader config. " + "Please update your configuration and set `babelrc` to true or false.\n" + "If you want to specify a specific babel config file to inherit config from " + "please use the `extends` option.\nFor more information about this options see " + "https://babeljs.io/docs/core-packages/#options");
+    }
+    logger.debug("normalizing loader options");
+    // Standardize on 'sourceMaps' as the key passed through to Webpack, so that
+    // users may safely use either one alongside our default use of
+    // 'this.sourceMap' below without getting error about conflicting aliases.
+    if (Object.prototype.hasOwnProperty.call(loaderOptions, "sourceMap") && !Object.prototype.hasOwnProperty.call(loaderOptions, "sourceMaps")) {
+      loaderOptions = Object.assign({}, loaderOptions, {
+        sourceMaps: loaderOptions.sourceMap
+      });
+      delete loaderOptions.sourceMap;
+    }
+    const programmaticOptions = Object.assign({}, loaderOptions, {
+      filename,
+      inputSourceMap: inputSourceMap || loaderOptions.inputSourceMap,
+      // Set the default sourcemap behavior based on Webpack's mapping flag,
+      // but allow users to override if they want.
+      sourceMaps: loaderOptions.sourceMaps === undefined ? this.sourceMap : loaderOptions.sourceMaps,
+      // Ensure that Webpack will get a full absolute path in the sourcemap
+      // so that it can properly map the module back to its internal cached
+      // modules.
+      sourceFileName: filename
+    });
+    // Remove loader related options
+    delete programmaticOptions.customize;
+    delete programmaticOptions.cacheDirectory;
+    delete programmaticOptions.cacheIdentifier;
+    delete programmaticOptions.cacheCompression;
+    delete programmaticOptions.metadataSubscribers;
+    if (!babel.loadPartialConfig) {
+      throw new Error(`babel-loader ^8.0.0-beta.3 requires @babel/core@7.0.0-beta.41, but ` + `you appear to be using "${babel.version}". Either update your ` + `@babel/core version, or pin you babel-loader version to 8.0.0-beta.2`);
+    }
+
+    // babel.loadPartialConfigAsync is available in v7.8.0+
+    const {
+      loadPartialConfigAsync = babel.loadPartialConfig
+    } = babel;
+    logger.debug("resolving Babel configs");
+    const config = yield loadPartialConfigAsync(injectCaller(programmaticOptions, this.target));
+    if (config) {
+      let options = config.options;
+      if (overrides && overrides.config) {
+        logger.debug("applying overrides config() to Babel config");
+        options = yield overrides.config.call(this, config, {
+          source,
+          map: inputSourceMap,
+          customOptions
+        });
+      }
+      if (options.sourceMaps === "inline") {
+        // Babel has this weird behavior where if you set "inline", we
+        // inline the sourcemap, and set 'result.map = null'. This results
+        // in bad behavior from Babel since the maps get put into the code,
+        // which Webpack does not expect, and because the map we return to
+        // Webpack is null, which is also bad. To avoid that, we override the
+        // behavior here so "inline" just behaves like 'true'.
+        options.sourceMaps = true;
+      }
+      const {
+        cacheDirectory = null,
+        cacheIdentifier = JSON.stringify({
+          options,
+          "@babel/core": transform.version,
+          "@babel/loader": version
+        }),
+        cacheCompression = true,
+        metadataSubscribers = []
+      } = loaderOptions;
+      let result;
+      if (cacheDirectory) {
+        logger.debug("cache is enabled");
+        result = yield cache({
+          source,
+          options,
+          transform,
+          cacheDirectory,
+          cacheIdentifier,
+          cacheCompression,
+          logger
+        });
+      } else {
+        logger.debug("cache is disabled, applying Babel transform");
+        result = yield transform(source, options);
+      }
+
+      // Availabe since Babel 7.12
+      // https://github.com/babel/babel/pull/11907
+      if (config.files) {
+        config.files.forEach(configFile => {
+          this.addDependency(configFile);
+          logger.debug(`added '${configFile}' to webpack dependencies`);
+        });
+      } else {
+        // .babelrc.json
+        if (typeof config.babelrc === "string") {
+          this.addDependency(config.babelrc);
+          logger.debug(`added '${config.babelrc}' to webpack dependencies`);
+        }
+        // babel.config.js
+        if (config.config) {
+          this.addDependency(config.config);
+          logger.debug(`added '${config.config}' to webpack dependencies`);
+        }
+      }
+      if (result) {
+        if (overrides && overrides.result) {
+          logger.debug("applying overrides result() to Babel transform results");
+          result = yield overrides.result.call(this, result, {
+            source,
+            map: inputSourceMap,
+            customOptions,
+            config,
+            options
+          });
+        }
+        const {
+          code,
+          map,
+          metadata,
+          externalDependencies
+        } = result;
+        externalDependencies == null ? void 0 : externalDependencies.forEach(dep => {
+          this.addDependency(dep);
+          logger.debug(`added '${dep}' to webpack dependencies`);
+        });
+        metadataSubscribers.forEach(subscriber => {
+          subscribe(subscriber, metadata, this);
+          logger.debug(`invoked metadata subscriber '${String(subscriber)}'`);
+        });
+        return [code, map];
+      }
+    }
+
+    // If the file was ignored, pass through the original content.
+    return [source, inputSourceMap];
+  });
+  return _loader.apply(this, arguments);
+}

frontend/node_modules/babel-loader/lib/injectCaller.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const babel = require("@babel/core");
+module.exports = function injectCaller(opts, target) {
+  if (!supportsCallerOption()) return opts;
+  return Object.assign({}, opts, {
+    caller: Object.assign({
+      name: "babel-loader",
+      // Provide plugins with insight into webpack target.
+      // https://github.com/babel/babel-loader/issues/787
+      target,
+      // Webpack >= 2 supports ESM and dynamic import.
+      supportsStaticESM: true,
+      supportsDynamicImport: true,
+      // Webpack 5 supports TLA behind a flag. We enable it by default
+      // for Babel, and then webpack will throw an error if the experimental
+      // flag isn't enabled.
+      supportsTopLevelAwait: true
+    }, opts.caller)
+  });
+};
+
+// TODO: We can remove this eventually, I'm just adding it so that people have
+// a little time to migrate to the newer RCs of @babel/core without getting
+// hard-to-diagnose errors about unknown 'caller' options.
+let supportsCallerOptionFlag = undefined;
+function supportsCallerOption() {
+  if (supportsCallerOptionFlag === undefined) {
+    try {
+      // Rather than try to match the Babel version, we just see if it throws
+      // when passed a 'caller' flag, and use that to decide if it is supported.
+      babel.loadPartialConfig({
+        caller: undefined,
+        babelrc: false,
+        configFile: false
+      });
+      supportsCallerOptionFlag = true;
+    } catch (err) {
+      supportsCallerOptionFlag = false;
+    }
+  }
+  return supportsCallerOptionFlag;
+}

frontend/node_modules/babel-loader/lib/schema.json

@@ -0,0 +1,28 @@
+{
+  "type": "object",
+  "properties": {
+    "cacheDirectory": {
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        }
+      ],
+      "default": false
+    },
+    "cacheIdentifier": {
+      "type": "string"
+    },
+    "cacheCompression": {
+      "type": "boolean",
+      "default": true
+    },
+    "customize": {
+      "type": "string",
+      "default": null
+    }
+  },
+  "additionalProperties": true
+}

frontend/node_modules/babel-loader/lib/transform.js

@@ -0,0 +1,51 @@
+"use strict";
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+const babel = require("@babel/core");
+const {
+  promisify
+} = require("util");
+const LoaderError = require("./Error");
+const transform = promisify(babel.transform);
+module.exports = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(function* (source, options) {
+    let result;
+    try {
+      result = yield transform(source, options);
+    } catch (err) {
+      throw err.message && err.codeFrame ? new LoaderError(err) : err;
+    }
+    if (!result) return null;
+
+    // We don't return the full result here because some entries are not
+    // really serializable. For a full list of properties see here:
+    // https://github.com/babel/babel/blob/main/packages/babel-core/src/transformation/index.js
+    // For discussion on this topic see here:
+    // https://github.com/babel/babel-loader/pull/629
+    const {
+      ast,
+      code,
+      map,
+      metadata,
+      sourceType,
+      externalDependencies
+    } = result;
+    if (map && (!map.sourcesContent || !map.sourcesContent.length)) {
+      map.sourcesContent = [source];
+    }
+    return {
+      ast,
+      code,
+      map,
+      metadata,
+      sourceType,
+      // Convert it from a Set to an Array to make it JSON-serializable.
+      externalDependencies: Array.from(externalDependencies || [])
+    };
+  });
+  return function (_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+module.exports.version = babel.version;

frontend/node_modules/babel-loader/node_modules/schema-utils/CHANGELOG.md

@@ -0,0 +1,286 @@
+# Changelog
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
+
+### [2.7.1](https://github.com/webpack/schema-utils/compare/v2.7.0...v2.7.1) (2020-08-31)
+
+
+### Bug Fixes
+
+* remove esModuleInterop from tsconfig ([#110](https://github.com/webpack/schema-utils/issues/110)) ([#111](https://github.com/webpack/schema-utils/issues/111)) ([2f40154](https://github.com/webpack/schema-utils/commit/2f40154b91e45b393258ae9dd8f10cc3b8590b7d))
+
+## [2.7.0](https://github.com/webpack/schema-utils/compare/v2.6.6...v2.7.0) (2020-05-29)
+
+
+### Features
+
+* improve hints ([a36e535](https://github.com/webpack/schema-utils/commit/a36e535faca1b01e27c3bfa3c8bee9227c3f836c))
+* smart not case ([#101](https://github.com/webpack/schema-utils/issues/101)) ([698d8b0](https://github.com/webpack/schema-utils/commit/698d8b05462d86aadb217e25a45c7b953a79a52e))
+
+
+### Bug Fixes
+
+* move @types/json-schema from devDependencies to dependencies ([#97](https://github.com/webpack/schema-utils/issues/97)) ([#98](https://github.com/webpack/schema-utils/issues/98)) ([945e67d](https://github.com/webpack/schema-utils/commit/945e67db5e19baf7ec7df72813b0739dd56f950d))
+
+### [2.6.6](https://github.com/webpack/schema-utils/compare/v2.6.5...v2.6.6) (2020-04-17)
+
+
+### Bug Fixes
+
+* improve perf
+
+### [2.6.5](https://github.com/webpack/schema-utils/compare/v2.6.4...v2.6.5) (2020-03-11)
+
+
+### Bug Fixes
+
+* correct dots at end of sentence ([7284beb](https://github.com/webpack/schema-utils/commit/7284bebe00cd570f1bef2c15951a07b9794038e6))
+
+### [2.6.4](https://github.com/webpack/schema-utils/compare/v2.6.3...v2.6.4) (2020-01-17)
+
+
+### Bug Fixes
+
+* change `initialised` to `initialized` ([#87](https://github.com/webpack/schema-utils/issues/87)) ([70f12d3](https://github.com/webpack/schema-utils/commit/70f12d33a8eaa27249bc9c1a27f886724cf91ea7))
+
+### [2.6.3](https://github.com/webpack/schema-utils/compare/v2.6.2...v2.6.3) (2020-01-17)
+
+
+### Bug Fixes
+
+* prefer the `baseDataPath` option from arguments ([#86](https://github.com/webpack/schema-utils/issues/86)) ([e236859](https://github.com/webpack/schema-utils/commit/e236859e85b28e35e1294f86fc1ff596a5031cea))
+
+### [2.6.2](https://github.com/webpack/schema-utils/compare/v2.6.1...v2.6.2) (2020-01-14)
+
+
+### Bug Fixes
+
+* better handle Windows absolute paths ([#85](https://github.com/webpack/schema-utils/issues/85)) ([1fa2930](https://github.com/webpack/schema-utils/commit/1fa2930a161e907b9fc53a7233d605910afdb883))
+
+### [2.6.1](https://github.com/webpack/schema-utils/compare/v2.6.0...v2.6.1) (2019-11-28)
+
+
+### Bug Fixes
+
+* typescript declarations ([#84](https://github.com/webpack/schema-utils/issues/84)) ([89d55a9](https://github.com/webpack/schema-utils/commit/89d55a9a8edfa6a8ac8b112f226bb3154e260319))
+
+## [2.6.0](https://github.com/webpack/schema-utils/compare/v2.5.0...v2.6.0) (2019-11-27)
+
+
+### Features
+
+* support configuration via title ([#81](https://github.com/webpack/schema-utils/issues/81)) ([afddc10](https://github.com/webpack/schema-utils/commit/afddc109f6891cd37a9f1835d50862d119a072bf))
+
+
+### Bug Fixes
+
+* typescript definitions ([#70](https://github.com/webpack/schema-utils/issues/70)) ([f38158d](https://github.com/webpack/schema-utils/commit/f38158d6d040e2c701622778ae8122fb26a4f990))
+
+## [2.5.0](https://github.com/webpack/schema-utils/compare/v2.4.1...v2.5.0) (2019-10-15)
+
+
+### Bug Fixes
+
+* rework format for maxLength, minLength ([#67](https://github.com/webpack/schema-utils/issues/67)) ([0d12259](https://github.com/webpack/schema-utils/commit/0d12259))
+* support all cases with one number in range ([#64](https://github.com/webpack/schema-utils/issues/64)) ([7fc8069](https://github.com/webpack/schema-utils/commit/7fc8069))
+* typescript definition and export naming ([#69](https://github.com/webpack/schema-utils/issues/69)) ([a435b79](https://github.com/webpack/schema-utils/commit/a435b79))
+
+
+### Features
+
+* "smart" numbers range ([62fb107](https://github.com/webpack/schema-utils/commit/62fb107))
+
+### [2.4.1](https://github.com/webpack/schema-utils/compare/v2.4.0...v2.4.1) (2019-09-27)
+
+
+### Bug Fixes
+
+* publish definitions ([#58](https://github.com/webpack/schema-utils/issues/58)) ([1885faa](https://github.com/webpack/schema-utils/commit/1885faa))
+
+## [2.4.0](https://github.com/webpack/schema-utils/compare/v2.3.0...v2.4.0) (2019-09-26)
+
+
+### Features
+
+* better errors when the `type` keyword doesn't exist ([0988be2](https://github.com/webpack/schema-utils/commit/0988be2))
+* support $data reference ([#56](https://github.com/webpack/schema-utils/issues/56)) ([d2f11d6](https://github.com/webpack/schema-utils/commit/d2f11d6))
+* types definitions ([#52](https://github.com/webpack/schema-utils/issues/52)) ([facb431](https://github.com/webpack/schema-utils/commit/facb431))
+
+## [2.3.0](https://github.com/webpack/schema-utils/compare/v2.2.0...v2.3.0) (2019-09-26)
+
+
+### Features
+
+* support `not` keyword ([#53](https://github.com/webpack/schema-utils/issues/53)) ([765f458](https://github.com/webpack/schema-utils/commit/765f458))
+
+## [2.2.0](https://github.com/webpack/schema-utils/compare/v2.1.0...v2.2.0) (2019-09-02)
+
+
+### Features
+
+* better error output for `oneOf` and `anyOf` ([#48](https://github.com/webpack/schema-utils/issues/48)) ([#50](https://github.com/webpack/schema-utils/issues/50)) ([332242f](https://github.com/webpack/schema-utils/commit/332242f))
+
+## [2.1.0](https://github.com/webpack-contrib/schema-utils/compare/v2.0.1...v2.1.0) (2019-08-07)
+
+
+### Bug Fixes
+
+* throw error on sparse arrays ([#47](https://github.com/webpack-contrib/schema-utils/issues/47)) ([b85ac38](https://github.com/webpack-contrib/schema-utils/commit/b85ac38))
+
+
+### Features
+
+* export `ValidateError` ([#46](https://github.com/webpack-contrib/schema-utils/issues/46)) ([ff781d7](https://github.com/webpack-contrib/schema-utils/commit/ff781d7))
+
+
+
+### [2.0.1](https://github.com/webpack-contrib/schema-utils/compare/v2.0.0...v2.0.1) (2019-07-18)
+
+
+### Bug Fixes
+
+* error message for empty object ([#44](https://github.com/webpack-contrib/schema-utils/issues/44)) ([0b4b4a2](https://github.com/webpack-contrib/schema-utils/commit/0b4b4a2))
+
+
+
+### [2.0.0](https://github.com/webpack-contrib/schema-utils/compare/v1.0.0...v2.0.0) (2019-07-17)
+
+
+### BREAKING CHANGES
+
+* drop support for Node.js < 8.9.0
+* drop support `errorMessage`, please use `description` for links.
+* api was changed, please look documentation.
+* error messages was fully rewritten.
+
+
+<a name="1.0.0"></a>
+# [1.0.0](https://github.com/webpack-contrib/schema-utils/compare/v0.4.7...v1.0.0) (2018-08-07)
+
+
+### Features
+
+* **src:** add support for custom error messages ([#33](https://github.com/webpack-contrib/schema-utils/issues/33)) ([1cbe4ef](https://github.com/webpack-contrib/schema-utils/commit/1cbe4ef))
+
+
+
+<a name="0.4.7"></a>
+## [0.4.7](https://github.com/webpack-contrib/schema-utils/compare/v0.4.6...v0.4.7) (2018-08-07)
+
+
+### Bug Fixes
+
+* **src:** `node >= v4.0.0` support ([#32](https://github.com/webpack-contrib/schema-utils/issues/32)) ([cb13dd4](https://github.com/webpack-contrib/schema-utils/commit/cb13dd4))
+
+
+
+<a name="0.4.6"></a>
+## [0.4.6](https://github.com/webpack-contrib/schema-utils/compare/v0.4.5...v0.4.6) (2018-08-06)
+
+
+### Bug Fixes
+
+* **package:** remove lockfile ([#28](https://github.com/webpack-contrib/schema-utils/issues/28)) ([69f1a81](https://github.com/webpack-contrib/schema-utils/commit/69f1a81))
+* **package:** remove unnecessary `webpack` dependency ([#26](https://github.com/webpack-contrib/schema-utils/issues/26)) ([532eaa5](https://github.com/webpack-contrib/schema-utils/commit/532eaa5))
+
+
+
+<a name="0.4.5"></a>
+## [0.4.5](https://github.com/webpack-contrib/schema-utils/compare/v0.4.4...v0.4.5) (2018-02-13)
+
+
+### Bug Fixes
+
+* **CHANGELOG:** update broken links ([4483b9f](https://github.com/webpack-contrib/schema-utils/commit/4483b9f))
+* **package:** update broken links ([f2494ba](https://github.com/webpack-contrib/schema-utils/commit/f2494ba))
+
+
+
+<a name="0.4.4"></a>
+## [0.4.4](https://github.com/webpack-contrib/schema-utils/compare/v0.4.3...v0.4.4) (2018-02-13)
+
+
+### Bug Fixes
+
+* **package:** update `dependencies` ([#22](https://github.com/webpack-contrib/schema-utils/issues/22)) ([3aecac6](https://github.com/webpack-contrib/schema-utils/commit/3aecac6))
+
+
+
+<a name="0.4.3"></a>
+## [0.4.3](https://github.com/webpack-contrib/schema-utils/compare/v0.4.2...v0.4.3) (2017-12-14)
+
+
+### Bug Fixes
+
+* **validateOptions:** throw `err` instead of `process.exit(1)` ([#17](https://github.com/webpack-contrib/schema-utils/issues/17)) ([c595eda](https://github.com/webpack-contrib/schema-utils/commit/c595eda))
+* **ValidationError:** never return `this` in the ctor ([#16](https://github.com/webpack-contrib/schema-utils/issues/16)) ([c723791](https://github.com/webpack-contrib/schema-utils/commit/c723791))
+
+
+
+<a name="0.4.2"></a>
+## [0.4.2](https://github.com/webpack-contrib/schema-utils/compare/v0.4.1...v0.4.2) (2017-11-09)
+
+
+### Bug Fixes
+
+* **validateOptions:** catch `ValidationError` and handle it internally ([#15](https://github.com/webpack-contrib/schema-utils/issues/15)) ([9c5ef5e](https://github.com/webpack-contrib/schema-utils/commit/9c5ef5e))
+
+
+
+<a name="0.4.1"></a>
+## [0.4.1](https://github.com/webpack-contrib/schema-utils/compare/v0.4.0...v0.4.1) (2017-11-03)
+
+
+### Bug Fixes
+
+* **ValidationError:** use `Error.captureStackTrace` for `err.stack` handling ([#14](https://github.com/webpack-contrib/schema-utils/issues/14)) ([a6fb974](https://github.com/webpack-contrib/schema-utils/commit/a6fb974))
+
+
+
+<a name="0.4.0"></a>
+# [0.4.0](https://github.com/webpack-contrib/schema-utils/compare/v0.3.0...v0.4.0) (2017-10-28)
+
+
+### Features
+
+* add support for `typeof`, `instanceof` (`{Function\|RegExp}`) ([#10](https://github.com/webpack-contrib/schema-utils/issues/10)) ([9f01816](https://github.com/webpack-contrib/schema-utils/commit/9f01816))
+
+
+
+<a name="0.3.0"></a>
+# [0.3.0](https://github.com/webpack-contrib/schema-utils/compare/v0.2.1...v0.3.0) (2017-04-29)
+
+
+### Features
+
+* add ValidationError ([#8](https://github.com/webpack-contrib/schema-utils/issues/8)) ([d48f0fb](https://github.com/webpack-contrib/schema-utils/commit/d48f0fb))
+
+
+
+<a name="0.2.1"></a>
+## [0.2.1](https://github.com/webpack-contrib/schema-utils/compare/v0.2.0...v0.2.1) (2017-03-13)
+
+
+### Bug Fixes
+
+* Include .babelrc to `files` ([28f0363](https://github.com/webpack-contrib/schema-utils/commit/28f0363))
+* Include source to `files` ([43b0f2f](https://github.com/webpack-contrib/schema-utils/commit/43b0f2f))
+
+
+
+<a name="0.2.0"></a>
+# [0.2.0](https://github.com/webpack-contrib/schema-utils/compare/v0.1.0...v0.2.0) (2017-03-12)
+
+<a name="0.1.0"></a>
+# 0.1.0 (2017-03-07)
+
+
+### Features
+
+* **validations:** add validateOptions module ([ae9b47b](https://github.com/webpack-contrib/schema-utils/commit/ae9b47b))
+
+
+
+# Change Log
+
+All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

frontend/node_modules/babel-loader/node_modules/schema-utils/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+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.

frontend/node_modules/babel-loader/node_modules/schema-utils/README.md

@@ -0,0 +1,276 @@
+<div align="center">
+  <a href="http://json-schema.org">
+    <img width="160" height="160"
+      src="https://raw.githubusercontent.com/webpack-contrib/schema-utils/master/.github/assets/logo.png">
+  </a>
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200"
+      src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+[![size][size]][size-url]
+
+# schema-utils
+
+Package for validate options in loaders and plugins.
+
+## Getting Started
+
+To begin, you'll need to install `schema-utils`:
+
+```console
+npm install schema-utils
+```
+
+## API
+
+**schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "option": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+```js
+import schema from './path/to/schema.json';
+import validate from 'schema-utils';
+
+const options = { option: true };
+const configuration = { name: 'Loader Name/Plugin Name/Name' };
+
+validate(schema, options, configuration);
+```
+
+### `schema`
+
+Type: `String`
+
+JSON schema.
+
+Simple example of schema:
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "This is description of option.",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+### `options`
+
+Type: `Object`
+
+Object with options.
+
+```js
+validate(
+  schema,
+  {
+    name: 123,
+  },
+  { name: 'MyPlugin' }
+);
+```
+
+### `configuration`
+
+Allow to configure validator.
+
+There is an alternative method to configure the `name` and`baseDataPath` options via the `title` property in the schema.
+For example:
+
+```json
+{
+  "title": "My Loader options",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "This is description of option.",
+      "type": "string"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+The last word used for the `baseDataPath` option, other words used for the `name` option.
+Based on the example above the `name` option equals `My Loader`, the `baseDataPath` option equals `options`.
+
+#### `name`
+
+Type: `Object`
+Default: `"Object"`
+
+Allow to setup name in validation errors.
+
+```js
+validate(schema, options, { name: 'MyPlugin' });
+```
+
+```shell
+Invalid configuration object. MyPlugin has been initialised using a configuration object that does not match the API schema.
+ - configuration.optionName should be a integer.
+```
+
+#### `baseDataPath`
+
+Type: `String`
+Default: `"configuration"`
+
+Allow to setup base data path in validation errors.
+
+```js
+validate(schema, options, { name: 'MyPlugin', baseDataPath: 'options' });
+```
+
+```shell
+Invalid options object. MyPlugin has been initialised using an options object that does not match the API schema.
+ - options.optionName should be a integer.
+```
+
+#### `postFormatter`
+
+Type: `Function`
+Default: `undefined`
+
+Allow to reformat errors.
+
+```js
+validate(schema, options, {
+  name: 'MyPlugin',
+  postFormatter: (formattedError, error) => {
+    if (error.keyword === 'type') {
+      return `${formattedError}\nAdditional Information.`;
+    }
+
+    return formattedError;
+  },
+});
+```
+
+```shell
+Invalid options object. MyPlugin has been initialized using an options object that does not match the API schema.
+ - options.optionName should be a integer.
+   Additional Information.
+```
+
+## Examples
+
+**schema.json**
+
+```json
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    },
+    "test": {
+      "anyOf": [
+        { "type": "array" },
+        { "type": "string" },
+        { "instanceof": "RegExp" }
+      ]
+    },
+    "transform": {
+      "instanceof": "Function"
+    },
+    "sourceMap": {
+      "type": "boolean"
+    }
+  },
+  "additionalProperties": false
+}
+```
+
+### `Loader`
+
+```js
+import { getOptions } from 'loader-utils';
+import validateOptions from 'schema-utils';
+
+import schema from 'path/to/schema.json';
+
+function loader(src, map) {
+  const options = getOptions(this) || {};
+
+  validateOptions(schema, options, {
+    name: 'Loader Name',
+    baseDataPath: 'options',
+  });
+
+  // Code...
+}
+
+export default loader;
+```
+
+### `Plugin`
+
+```js
+import validateOptions from 'schema-utils';
+
+import schema from 'path/to/schema.json';
+
+class Plugin {
+  constructor(options) {
+    validateOptions(schema, options, {
+      name: 'Plugin Name',
+      baseDataPath: 'options',
+    });
+
+    this.options = options;
+  }
+
+  apply(compiler) {
+    // Code...
+  }
+}
+
+export default Plugin;
+```
+
+## Contributing
+
+Please take a moment to read our contributing guidelines if you haven't yet done so.
+
+[CONTRIBUTING](./.github/CONTRIBUTING.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/schema-utils.svg
+[npm-url]: https://npmjs.com/package/schema-utils
+[node]: https://img.shields.io/node/v/schema-utils.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack/schema-utils.svg
+[deps-url]: https://david-dm.org/webpack/schema-utils
+[tests]: https://github.com/webpack/schema-utils/workflows/schema-utils/badge.svg
+[tests-url]: https://github.com/webpack/schema-utils/actions
+[cover]: https://codecov.io/gh/webpack/schema-utils/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack/schema-utils
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.com/badge?p=schema-utils
+[size-url]: https://packagephobia.com/result?p=schema-utils

frontend/node_modules/babel-loader/node_modules/schema-utils/declarations/ValidationError.d.ts

@@ -0,0 +1,88 @@
+export default ValidationError;
+export type JSONSchema6 = import('json-schema').JSONSchema6;
+export type JSONSchema7 = import('json-schema').JSONSchema7;
+export type Schema =
+  | (import('json-schema').JSONSchema4 & import('./validate').Extend)
+  | (import('json-schema').JSONSchema6 & import('./validate').Extend)
+  | (import('json-schema').JSONSchema7 & import('./validate').Extend);
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: import('./validate').PostFormatter | undefined;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: import('ajv').ErrorObject & {
+    children?: import('ajv').ErrorObject[] | undefined;
+  }
+) => string;
+export type SchemaUtilErrorObject = import('ajv').ErrorObject & {
+  children?: import('ajv').ErrorObject[] | undefined;
+};
+export type SPECIFICITY = number;
+declare class ValidationError extends Error {
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @param {Schema} schema
+   * @param {ValidationErrorConfiguration} configuration
+   */
+  constructor(
+    errors: Array<SchemaUtilErrorObject>,
+    schema: Schema,
+    configuration?: ValidationErrorConfiguration
+  );
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors: Array<SchemaUtilErrorObject>;
+  /** @type {Schema} */
+  schema: Schema;
+  /** @type {string} */
+  headerName: string;
+  /** @type {string} */
+  baseDataPath: string;
+  /** @type {PostFormatter | null} */
+  postFormatter: PostFormatter | null;
+  /**
+   * @param {string} path
+   * @returns {Schema}
+   */
+  getSchemaPart(path: string): Schema;
+  /**
+   * @param {Schema} schema
+   * @param {boolean} logic
+   * @param {Array<Object>} prevSchemas
+   * @returns {string}
+   */
+  formatSchema(
+    schema: Schema,
+    logic?: boolean,
+    prevSchemas?: Array<Object>
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @param {(boolean | Array<string>)=} additionalPath
+   * @param {boolean=} needDot
+   * @param {boolean=} logic
+   * @returns {string}
+   */
+  getSchemaPartText(
+    schemaPart?: Schema | undefined,
+    additionalPath?: (boolean | Array<string>) | undefined,
+    needDot?: boolean | undefined,
+    logic?: boolean | undefined
+  ): string;
+  /**
+   * @param {Schema=} schemaPart
+   * @returns {string}
+   */
+  getSchemaPartDescription(schemaPart?: Schema | undefined): string;
+  /**
+   * @param {SchemaUtilErrorObject} error
+   * @returns {string}
+   */
+  formatValidationError(error: SchemaUtilErrorObject): string;
+  /**
+   * @param {Array<SchemaUtilErrorObject>} errors
+   * @returns {string}
+   */
+  formatValidationErrors(errors: Array<SchemaUtilErrorObject>): string;
+}

frontend/node_modules/babel-loader/node_modules/schema-utils/declarations/index.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: typeof import('./validate').default;
+export = _exports;

frontend/node_modules/babel-loader/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts

@@ -0,0 +1,12 @@
+export default addAbsolutePathKeyword;
+export type Ajv = import('ajv').Ajv;
+export type ValidateFunction = import('ajv').ValidateFunction;
+export type SchemaUtilErrorObject = import('ajv').ErrorObject & {
+  children?: import('ajv').ErrorObject[] | undefined;
+};
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addAbsolutePathKeyword(ajv: Ajv): Ajv;

frontend/node_modules/babel-loader/node_modules/schema-utils/declarations/util/Range.d.ts

@@ -0,0 +1,82 @@
+export = Range;
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+declare class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(
+    side: 'left' | 'right',
+    exclusive: boolean
+  ): '>' | '>=' | '<' | '<=';
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatRight(value: number, logic: boolean, exclusive: boolean): string;
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+  static formatLeft(value: number, logic: boolean, exclusive: boolean): string;
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
+  static formatRange(
+    start: number,
+    end: number,
+    startExclusive: boolean,
+    endExclusive: boolean,
+    logic: boolean
+  ): string;
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
+  static getRangeValue(
+    values: Array<[number, boolean]>,
+    logic: boolean
+  ): [number, boolean];
+  /** @type {Array<RangeValue>} */
+  _left: Array<[number, boolean]>;
+  /** @type {Array<RangeValue>} */
+  _right: Array<[number, boolean]>;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  left(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+  right(value: number, exclusive?: boolean | undefined): void;
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+  format(logic?: boolean): string;
+}
+declare namespace Range {
+  export { RangeValue, RangeValueCallback };
+}
+type RangeValue = [number, boolean];
+type RangeValueCallback = (rangeValue: [number, boolean]) => boolean;

frontend/node_modules/babel-loader/node_modules/schema-utils/declarations/util/hints.d.ts

@@ -0,0 +1,6 @@
+export function stringHints(schema: Schema, logic: boolean): string[];
+export function numberHints(schema: Schema, logic: boolean): string[];
+export type Schema =
+  | (import('json-schema').JSONSchema4 & import('../validate').Extend)
+  | (import('json-schema').JSONSchema6 & import('../validate').Extend)
+  | (import('json-schema').JSONSchema7 & import('../validate').Extend);

frontend/node_modules/babel-loader/node_modules/schema-utils/declarations/validate.d.ts

@@ -0,0 +1,43 @@
+export default validate;
+export type JSONSchema4 = import('json-schema').JSONSchema4;
+export type JSONSchema6 = import('json-schema').JSONSchema6;
+export type JSONSchema7 = import('json-schema').JSONSchema7;
+export type ErrorObject = import('ajv').ErrorObject;
+export type Extend = {
+  formatMinimum?: number | undefined;
+  formatMaximum?: number | undefined;
+  formatExclusiveMinimum?: boolean | undefined;
+  formatExclusiveMaximum?: boolean | undefined;
+};
+export type Schema =
+  | (import('json-schema').JSONSchema4 & Extend)
+  | (import('json-schema').JSONSchema6 & Extend)
+  | (import('json-schema').JSONSchema7 & Extend);
+export type SchemaUtilErrorObject = import('ajv').ErrorObject & {
+  children?: import('ajv').ErrorObject[] | undefined;
+};
+export type PostFormatter = (
+  formattedError: string,
+  error: SchemaUtilErrorObject
+) => string;
+export type ValidationErrorConfiguration = {
+  name?: string | undefined;
+  baseDataPath?: string | undefined;
+  postFormatter?: PostFormatter | undefined;
+};
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+declare function validate(
+  schema: Schema,
+  options: Array<object> | object,
+  configuration?: ValidationErrorConfiguration | undefined
+): void;
+declare namespace validate {
+  export { ValidationError };
+  export { ValidationError as ValidateError };
+}
+import ValidationError from './ValidationError';

frontend/node_modules/babel-loader/node_modules/schema-utils/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+const validate = require('./validate');
+
+module.exports = validate.default;

frontend/node_modules/babel-loader/node_modules/schema-utils/dist/keywords/absolutePath.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/** @typedef {import("ajv").Ajv} Ajv */
+
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+
+/** @typedef {import("../validate").SchemaUtilErrorObject} SchemaUtilErrorObject */
+
+/**
+ * @param {string} message
+ * @param {object} schema
+ * @param {string} data
+ * @returns {SchemaUtilErrorObject}
+ */
+function errorMessage(message, schema, data) {
+  return {
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    dataPath: undefined,
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    schemaPath: undefined,
+    keyword: 'absolutePath',
+    params: {
+      absolutePath: data
+    },
+    message,
+    parentSchema: schema
+  };
+}
+/**
+ * @param {boolean} shouldBeAbsolute
+ * @param {object} schema
+ * @param {string} data
+ * @returns {SchemaUtilErrorObject}
+ */
+
+
+function getErrorFor(shouldBeAbsolute, schema, data) {
+  const message = shouldBeAbsolute ? `The provided value ${JSON.stringify(data)} is not an absolute path!` : `A relative path is expected. However, the provided value ${JSON.stringify(data)} is an absolute path!`;
+  return errorMessage(message, schema, data);
+}
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+
+
+function addAbsolutePathKeyword(ajv) {
+  ajv.addKeyword('absolutePath', {
+    errors: true,
+    type: 'string',
+
+    compile(schema, parentSchema) {
+      /** @type {ValidateFunction} */
+      const callback = data => {
+        let passes = true;
+        const isExclamationMarkPresent = data.includes('!');
+
+        if (isExclamationMarkPresent) {
+          callback.errors = [errorMessage(`The provided value ${JSON.stringify(data)} contains exclamation mark (!) which is not allowed because it's reserved for loader syntax.`, parentSchema, data)];
+          passes = false;
+        } // ?:[A-Za-z]:\\ - Windows absolute path
+        // \\\\ - Windows network absolute path
+        // \/ - Unix-like OS absolute path
+
+
+        const isCorrectAbsolutePath = schema === /^(?:[A-Za-z]:(\\|\/)|\\\\|\/)/.test(data);
+
+        if (!isCorrectAbsolutePath) {
+          callback.errors = [getErrorFor(schema, parentSchema, data)];
+          passes = false;
+        }
+
+        return passes;
+      };
+
+      callback.errors = [];
+      return callback;
+    }
+
+  });
+  return ajv;
+}
+
+var _default = addAbsolutePathKeyword;
+exports.default = _default;

frontend/node_modules/babel-loader/node_modules/schema-utils/dist/util/Range.js

@@ -0,0 +1,163 @@
+"use strict";
+
+/**
+ * @typedef {[number, boolean]} RangeValue
+ */
+
+/**
+ * @callback RangeValueCallback
+ * @param {RangeValue} rangeValue
+ * @returns {boolean}
+ */
+class Range {
+  /**
+   * @param {"left" | "right"} side
+   * @param {boolean} exclusive
+   * @returns {">" | ">=" | "<" | "<="}
+   */
+  static getOperator(side, exclusive) {
+    if (side === 'left') {
+      return exclusive ? '>' : '>=';
+    }
+
+    return exclusive ? '<' : '<=';
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+
+
+  static formatRight(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatLeft(value, !logic, !exclusive);
+    }
+
+    return `should be ${Range.getOperator('right', exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} value
+   * @param {boolean} logic is not logic applied
+   * @param {boolean} exclusive is range exclusive
+   * @returns {string}
+   */
+
+
+  static formatLeft(value, logic, exclusive) {
+    if (logic === false) {
+      return Range.formatRight(value, !logic, !exclusive);
+    }
+
+    return `should be ${Range.getOperator('left', exclusive)} ${value}`;
+  }
+  /**
+   * @param {number} start left side value
+   * @param {number} end right side value
+   * @param {boolean} startExclusive is range exclusive from left side
+   * @param {boolean} endExclusive is range exclusive from right side
+   * @param {boolean} logic is not logic applied
+   * @returns {string}
+   */
+
+
+  static formatRange(start, end, startExclusive, endExclusive, logic) {
+    let result = 'should be';
+    result += ` ${Range.getOperator(logic ? 'left' : 'right', logic ? startExclusive : !startExclusive)} ${start} `;
+    result += logic ? 'and' : 'or';
+    result += ` ${Range.getOperator(logic ? 'right' : 'left', logic ? endExclusive : !endExclusive)} ${end}`;
+    return result;
+  }
+  /**
+   * @param {Array<RangeValue>} values
+   * @param {boolean} logic is not logic applied
+   * @return {RangeValue} computed value and it's exclusive flag
+   */
+
+
+  static getRangeValue(values, logic) {
+    let minMax = logic ? Infinity : -Infinity;
+    let j = -1;
+    const predicate = logic ?
+    /** @type {RangeValueCallback} */
+    ([value]) => value <= minMax :
+    /** @type {RangeValueCallback} */
+    ([value]) => value >= minMax;
+
+    for (let i = 0; i < values.length; i++) {
+      if (predicate(values[i])) {
+        [minMax] = values[i];
+        j = i;
+      }
+    }
+
+    if (j > -1) {
+      return values[j];
+    }
+
+    return [Infinity, true];
+  }
+
+  constructor() {
+    /** @type {Array<RangeValue>} */
+    this._left = [];
+    /** @type {Array<RangeValue>} */
+
+    this._right = [];
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+
+
+  left(value, exclusive = false) {
+    this._left.push([value, exclusive]);
+  }
+  /**
+   * @param {number} value
+   * @param {boolean=} exclusive
+   */
+
+
+  right(value, exclusive = false) {
+    this._right.push([value, exclusive]);
+  }
+  /**
+   * @param {boolean} logic is not logic applied
+   * @return {string} "smart" range string representation
+   */
+
+
+  format(logic = true) {
+    const [start, leftExclusive] = Range.getRangeValue(this._left, logic);
+    const [end, rightExclusive] = Range.getRangeValue(this._right, !logic);
+
+    if (!Number.isFinite(start) && !Number.isFinite(end)) {
+      return '';
+    }
+
+    const realStart = leftExclusive ? start + 1 : start;
+    const realEnd = rightExclusive ? end - 1 : end; // e.g. 5 < x < 7, 5 < x <= 6, 6 <= x <= 6
+
+    if (realStart === realEnd) {
+      return `should be ${logic ? '' : '!'}= ${realStart}`;
+    } // e.g. 4 < x < ∞
+
+
+    if (Number.isFinite(start) && !Number.isFinite(end)) {
+      return Range.formatLeft(start, logic, leftExclusive);
+    } // e.g. ∞ < x < 4
+
+
+    if (!Number.isFinite(start) && Number.isFinite(end)) {
+      return Range.formatRight(end, logic, rightExclusive);
+    }
+
+    return Range.formatRange(start, end, leftExclusive, rightExclusive, logic);
+  }
+
+}
+
+module.exports = Range;

frontend/node_modules/babel-loader/node_modules/schema-utils/dist/util/hints.js

@@ -0,0 +1,105 @@
+"use strict";
+
+const Range = require('./Range');
+/** @typedef {import("../validate").Schema} Schema */
+
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
+
+
+module.exports.stringHints = function stringHints(schema, logic) {
+  const hints = [];
+  let type = 'string';
+  const currentSchema = { ...schema
+  };
+
+  if (!logic) {
+    const tmpLength = currentSchema.minLength;
+    const tmpFormat = currentSchema.formatMinimum;
+    const tmpExclusive = currentSchema.formatExclusiveMaximum;
+    currentSchema.minLength = currentSchema.maxLength;
+    currentSchema.maxLength = tmpLength;
+    currentSchema.formatMinimum = currentSchema.formatMaximum;
+    currentSchema.formatMaximum = tmpFormat;
+    currentSchema.formatExclusiveMaximum = !currentSchema.formatExclusiveMinimum;
+    currentSchema.formatExclusiveMinimum = !tmpExclusive;
+  }
+
+  if (typeof currentSchema.minLength === 'number') {
+    if (currentSchema.minLength === 1) {
+      type = 'non-empty string';
+    } else {
+      const length = Math.max(currentSchema.minLength - 1, 0);
+      hints.push(`should be longer than ${length} character${length > 1 ? 's' : ''}`);
+    }
+  }
+
+  if (typeof currentSchema.maxLength === 'number') {
+    if (currentSchema.maxLength === 0) {
+      type = 'empty string';
+    } else {
+      const length = currentSchema.maxLength + 1;
+      hints.push(`should be shorter than ${length} character${length > 1 ? 's' : ''}`);
+    }
+  }
+
+  if (currentSchema.pattern) {
+    hints.push(`should${logic ? '' : ' not'} match pattern ${JSON.stringify(currentSchema.pattern)}`);
+  }
+
+  if (currentSchema.format) {
+    hints.push(`should${logic ? '' : ' not'} match format ${JSON.stringify(currentSchema.format)}`);
+  }
+
+  if (currentSchema.formatMinimum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMinimum ? '>' : '>='} ${JSON.stringify(currentSchema.formatMinimum)}`);
+  }
+
+  if (currentSchema.formatMaximum) {
+    hints.push(`should be ${currentSchema.formatExclusiveMaximum ? '<' : '<='} ${JSON.stringify(currentSchema.formatMaximum)}`);
+  }
+
+  return [type].concat(hints);
+};
+/**
+ * @param {Schema} schema
+ * @param {boolean} logic
+ * @return {string[]}
+ */
+
+
+module.exports.numberHints = function numberHints(schema, logic) {
+  const hints = [schema.type === 'integer' ? 'integer' : 'number'];
+  const range = new Range();
+
+  if (typeof schema.minimum === 'number') {
+    range.left(schema.minimum);
+  }
+
+  if (typeof schema.exclusiveMinimum === 'number') {
+    range.left(schema.exclusiveMinimum, true);
+  }
+
+  if (typeof schema.maximum === 'number') {
+    range.right(schema.maximum);
+  }
+
+  if (typeof schema.exclusiveMaximum === 'number') {
+    range.right(schema.exclusiveMaximum, true);
+  }
+
+  const rangeFormat = range.format(logic);
+
+  if (rangeFormat) {
+    hints.push(rangeFormat);
+  }
+
+  if (typeof schema.multipleOf === 'number') {
+    hints.push(`should${logic ? '' : ' not'} be multiple of ${schema.multipleOf}`);
+  }
+
+  return hints;
+};

frontend/node_modules/babel-loader/node_modules/schema-utils/dist/validate.js

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _absolutePath = _interopRequireDefault(require("./keywords/absolutePath"));
+
+var _ValidationError = _interopRequireDefault(require("./ValidationError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Use CommonJS require for ajv libs so TypeScript consumers aren't locked into esModuleInterop (see #110).
+const Ajv = require('ajv');
+
+const ajvKeywords = require('ajv-keywords');
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+
+/** @typedef {import("ajv").ErrorObject} ErrorObject */
+
+/**
+ * @typedef {Object} Extend
+ * @property {number=} formatMinimum
+ * @property {number=} formatMaximum
+ * @property {boolean=} formatExclusiveMinimum
+ * @property {boolean=} formatExclusiveMaximum
+ */
+
+/** @typedef {(JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend} Schema */
+
+/** @typedef {ErrorObject & { children?: Array<ErrorObject>}} SchemaUtilErrorObject */
+
+/**
+ * @callback PostFormatter
+ * @param {string} formattedError
+ * @param {SchemaUtilErrorObject} error
+ * @returns {string}
+ */
+
+/**
+ * @typedef {Object} ValidationErrorConfiguration
+ * @property {string=} name
+ * @property {string=} baseDataPath
+ * @property {PostFormatter=} postFormatter
+ */
+
+
+const ajv = new Ajv({
+  allErrors: true,
+  verbose: true,
+  $data: true
+});
+ajvKeywords(ajv, ['instanceof', 'formatMinimum', 'formatMaximum', 'patternRequired']); // Custom keywords
+
+(0, _absolutePath.default)(ajv);
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+
+function validate(schema, options, configuration) {
+  let errors = [];
+
+  if (Array.isArray(options)) {
+    errors = Array.from(options, nestedOptions => validateObject(schema, nestedOptions));
+    errors.forEach((list, idx) => {
+      const applyPrefix =
+      /**
+       * @param {SchemaUtilErrorObject} error
+       */
+      error => {
+        // eslint-disable-next-line no-param-reassign
+        error.dataPath = `[${idx}]${error.dataPath}`;
+
+        if (error.children) {
+          error.children.forEach(applyPrefix);
+        }
+      };
+
+      list.forEach(applyPrefix);
+    });
+    errors = errors.reduce((arr, items) => {
+      arr.push(...items);
+      return arr;
+    }, []);
+  } else {
+    errors = validateObject(schema, options);
+  }
+
+  if (errors.length > 0) {
+    throw new _ValidationError.default(errors, schema, configuration);
+  }
+}
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+
+function validateObject(schema, options) {
+  const compiledSchema = ajv.compile(schema);
+  const valid = compiledSchema(options);
+  if (valid) return [];
+  return compiledSchema.errors ? filterErrors(compiledSchema.errors) : [];
+}
+/**
+ * @param {Array<ErrorObject>} errors
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+
+function filterErrors(errors) {
+  /** @type {Array<SchemaUtilErrorObject>} */
+  let newErrors = [];
+
+  for (const error of
+  /** @type {Array<SchemaUtilErrorObject>} */
+  errors) {
+    const {
+      dataPath
+    } = error;
+    /** @type {Array<SchemaUtilErrorObject>} */
+
+    let children = [];
+    newErrors = newErrors.filter(oldError => {
+      if (oldError.dataPath.includes(dataPath)) {
+        if (oldError.children) {
+          children = children.concat(oldError.children.slice(0));
+        } // eslint-disable-next-line no-undefined, no-param-reassign
+
+
+        oldError.children = undefined;
+        children.push(oldError);
+        return false;
+      }
+
+      return true;
+    });
+
+    if (children.length) {
+      error.children = children;
+    }
+
+    newErrors.push(error);
+  }
+
+  return newErrors;
+} // TODO change after resolve https://github.com/microsoft/TypeScript/issues/34994
+
+
+validate.ValidationError = _ValidationError.default;
+validate.ValidateError = _ValidationError.default;
+var _default = validate;
+exports.default = _default;

frontend/node_modules/babel-loader/node_modules/schema-utils/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "schema-utils",
+  "version": "2.7.1",
+  "description": "webpack Validation Utils",
+  "license": "MIT",
+  "repository": "webpack/schema-utils",
+  "author": "webpack Contrib (https://github.com/webpack-contrib)",
+  "homepage": "https://github.com/webpack/schema-utils",
+  "bugs": "https://github.com/webpack/schema-utils/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/index.js",
+  "types": "declarations/index.d.ts",
+  "engines": {
+    "node": ">= 8.9.0"
+  },
+  "scripts": {
+    "start": "npm run build -- -w",
+    "clean": "del-cli dist declarations",
+    "prebuild": "npm run clean",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir declarations && prettier \"declarations/**/*.ts\" --write",
+    "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "build": "npm-run-all -p \"build:**\"",
+    "commitlint": "commitlint --from=master",
+    "security": "npm audit",
+    "lint:prettier": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
+    "lint:js": "eslint --cache .",
+    "lint:types": "tsc --pretty --noEmit",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "npm run build",
+    "release": "standard-version",
+    "defaults": "webpack-defaults"
+  },
+  "files": [
+    "dist",
+    "declarations"
+  ],
+  "dependencies": {
+    "ajv": "^6.12.4",
+    "ajv-keywords": "^3.5.2",
+    "@types/json-schema": "^7.0.5"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.10.5",
+    "@babel/core": "^7.11.4",
+    "@babel/preset-env": "^7.11.0",
+    "@commitlint/cli": "^10.0.0",
+    "@commitlint/config-conventional": "^10.0.0",
+    "@webpack-contrib/defaults": "^6.3.0",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^25.5.1",
+    "cross-env": "^6.0.3",
+    "del": "^5.1.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.7.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-import": "^2.22.0",
+    "husky": "^4.2.5",
+    "jest": "^25.5.4",
+    "lint-staged": "^10.2.13",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^1.19.1",
+    "standard-version": "^9.0.0",
+    "typescript": "^4.0.2"
+  },
+  "keywords": [
+    "webpack"
+  ]
+}

frontend/node_modules/babel-loader/package.json

@@ -0,0 +1,128 @@
+{
+  "name": "babel-loader",
+  "version": "8.4.1",
+  "description": "babel module loader for webpack",
+  "files": [
+    "lib"
+  ],
+  "main": "lib/index.js",
+  "engines": {
+    "node": ">= 8.9"
+  },
+  "dependencies": {
+    "find-cache-dir": "^3.3.1",
+    "loader-utils": "^2.0.4",
+    "make-dir": "^3.1.0",
+    "schema-utils": "^2.6.5"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0",
+    "webpack": ">=2"
+  },
+  "devDependencies": {
+    "@ava/babel": "^1.0.1",
+    "@babel/cli": "^7.19.3",
+    "@babel/core": "^7.19.6",
+    "@babel/preset-env": "^7.19.4",
+    "ava": "^3.13.0",
+    "babel-eslint": "^10.0.1",
+    "babel-plugin-istanbul": "^6.0.0",
+    "babel-plugin-react-intl": "^8.2.15",
+    "cross-env": "^7.0.2",
+    "eslint": "^7.13.0",
+    "eslint-config-babel": "^9.0.0",
+    "eslint-config-prettier": "^6.3.0",
+    "eslint-plugin-flowtype": "^5.2.0",
+    "eslint-plugin-prettier": "^3.0.0",
+    "husky": "^4.3.0",
+    "lint-staged": "^10.5.1",
+    "nyc": "^15.1.0",
+    "pnp-webpack-plugin": "^1.6.4",
+    "prettier": "^2.1.2",
+    "react": "^17.0.1",
+    "react-intl": "^5.9.4",
+    "react-intl-webpack-plugin": "^0.3.0",
+    "rimraf": "^3.0.0",
+    "semver": "7.3.2",
+    "webpack": "^5.61.0"
+  },
+  "scripts": {
+    "clean": "rimraf lib/",
+    "build": "babel src/ --out-dir lib/ --copy-files",
+    "format": "prettier --write --trailing-comma all 'src/**/*.js' 'test/**/*.test.js' 'test/helpers/*.js' && prettier --write --trailing-comma es5 'scripts/*.js'",
+    "lint": "eslint src test",
+    "precommit": "lint-staged",
+    "prepublish": "yarn run clean && yarn run build",
+    "preversion": "yarn run test",
+    "test": "yarn run lint && cross-env BABEL_ENV=test yarn run build && yarn run test-only",
+    "test-only": "nyc ava"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel-loader.git"
+  },
+  "keywords": [
+    "webpack",
+    "loader",
+    "babel",
+    "es6",
+    "transpiler",
+    "module"
+  ],
+  "author": "Luis Couto <hello@luiscouto.pt>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/babel/babel-loader/issues"
+  },
+  "homepage": "https://github.com/babel/babel-loader",
+  "nyc": {
+    "all": true,
+    "include": [
+      "src/**/*.js"
+    ],
+    "reporter": [
+      "text",
+      "json"
+    ],
+    "sourceMap": false,
+    "instrument": false
+  },
+  "ava": {
+    "files": [
+      "test/**/*.test.js",
+      "!test/fixtures/**/*",
+      "!test/helpers/**/*"
+    ],
+    "babel": {
+      "compileAsTests": [
+        "test/helpers/**/*"
+      ]
+    }
+  },
+  "lint-staged": {
+    "scripts/*.js": [
+      "prettier --trailing-comma es5 --write",
+      "git add"
+    ],
+    "src/**/*.js": [
+      "prettier --trailing-comma all --write",
+      "git add"
+    ],
+    "test/**/*.test.js": [
+      "prettier --trailing-comma all --write",
+      "git add"
+    ],
+    "test/helpers/*.js": [
+      "prettier --trailing-comma all --write",
+      "git add"
+    ],
+    "package.json": [
+      "node ./scripts/yarn-install.js",
+      "git add yarn.lock"
+    ]
+  },
+  "resolutions": {
+    "nyc/node-preload": "0.2.0"
+  },
+  "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
+}