0.2.0 - Mid migration

2025-07-01 05:32:18 +00:00 · 2022-04-25 14:47:15 +12:00 · 2022-04-25 14:47:15 +12:00 · 7e38fdbd7d
commit 7e38fdbd7d
parent 139e6a915e
42393 changed files with 5358157 additions and 62 deletions
--- a/web/node_modules/eslint-webpack-plugin/CHANGELOG.md
+++ b/web/node_modules/eslint-webpack-plugin/CHANGELOG.md
@ -0,0 +1,160 @@
+# 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.5.4](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.5.3...v2.5.4) (2021-04-19)
+
+
+### Bug Fixes
+
+* context with symbols ([#94](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/94)) ([6fc6874](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/6fc6874f4ee295eea372dcfa0a86799b355dab70))
+* resolve paths and normalize ([#97](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/97)) ([818b825](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/818b825db119dde0b53b24d96688f1af89344b29))
+* use `finishModules` if thread is less than or equal 1 ([#95](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/95)) ([c12e7be](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/c12e7be0be49f95fa8f2d9ae354acba3bd412b5c))
+
+### [2.5.3](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.5.2...v2.5.3) (2021-03-24)
+
+
+### Bug Fixes
+
+* allow multiple instances ([#92](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/92)) ([0cdd621](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/0cdd621be597c643cad6c4a41c7fed31c29fb1a5))
+* match hidden directories for path exclusions ([#87](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/87)) ([bb8750c](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/bb8750cb8a1cb4f6297a07b579ad4e394e11d968))
+
+### [2.5.2](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.5.1...v2.5.2) (2021-02-18)
+
+
+### Bug Fixes
+
+* **fail-on-error:** show eslint errors when failOnError is disabled ([#85](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/85)) ([69be533](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/69be5338a8f72ffdbee055ab926cf4d84047fd35))
+
+### [2.5.1](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.5.0...v2.5.1) (2021-02-12)
+
+
+### Bug Fixes
+
+* exclude node_modules root ([#80](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/80)) ([be0391e](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/be0391e28322e220cf628f842f35b3d800c284c0))
+* prevent lint all files ([#77](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/77)) ([f57cb8e](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/f57cb8e1f01c522e562f0af3460d900d7fbba94f))
+* update types ([#81](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/81)) ([90608da](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/90608da93f13ae2de70c2696d4284c1558a3f301))
+
+## [2.5.0](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.4.3...v2.5.0) (2021-02-04)
+
+
+### Refactor
+
+* Updates to emitError and emitWarning
+
+Setting only emitError to true will no longer exclusively print files with errors
+and disregard the files with warnings. Similarly, setting only emitWarning to true
+will no longer exclusively print files with warnings disregard the files with errors.
+
+* fix: use quiet to override emitError and emitWarning
+
+- quiet is essentially syntactic sugar for setting emitError to true
+and emitWarning to false
+
+### Bug Fixes
+
+* fails when `failOnError` or `failOnWarning` enabled ([#72](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/72)) ([8a72a8a](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/8a72a8ad26b8decb800f955d8f4d362f280c4d0f))
+* lint dirty modules only ([#67](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/67)) ([f7f372e](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/f7f372e800e75fcd2928655648fee01266c6d158))
+* threads multi-compiler ([#69](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/69)) ([cef4f74](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/cef4f7473707fb3f069ec44c54b5ed2d27d931f8))
+* types ([#66](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/66)) ([4daddf5](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/4daddf5335b2c78203482d7e7f6d82a909277212))
+* Fix emit warning error quiet (#46) ([d38165b](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/d38165bef1e2d73a9d53f42d80b926c9eab12707)), closes [#46](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/46) [#19](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/19) [#19](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/19)
+
+### [2.4.3](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.4.2...v2.4.3) (2021-01-19)
+
+
+### Bug Fixes
+
+* crash on `split` ([#62](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/62)) ([db38f61](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/db38f611965cfdec83984364e0b982bbd7a678e0))
+
+### [2.4.2](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.4.1...v2.4.2) (2021-01-19)
+
+
+### Bug Fixes
+
+* strip resource query ([#58](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/58)) ([f0a2d81](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/f0a2d81a4feecf87e13649f2930f773c04fa3814))
+
+### [2.4.1](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.4.0...v2.4.1) (2020-11-30)
+
+
+### Bug Fixes
+
+* [#43](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/43), [#44](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/44), [#45](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/45) ([#47](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/47)) ([4b8d4de](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/4b8d4def970381126f70c8407eb708c1c975bbf5))
+* recompile speedups ([#55](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/55)) ([d862d92](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/d862d9291853c6b7430a0dbdc965b16db0723925))
+
+## [2.4.0](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.3.0...v2.4.0) (2020-11-20)
+
+
+### Features
+
+* threads ([#39](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/39)) ([1e38fc7](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/1e38fc77fd575d9e56be0da6a206ded54a8f7c34))
+
+## [2.3.0](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.2.1...v2.3.0) (2020-11-13)
+
+
+### Features
+
+* exclude option ([#41](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/41)) ([dc2fac7](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/dc2fac7918c0733f26fa5a1683315bf439370559))
+
+### [2.2.1](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v2.2.0...v2.2.1) (2020-11-07)
+
+
+### Bug Fixes
+
+* folder pattern ([#36](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/36)) ([e79741e](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/e79741ee22d04c8c6e4d6f11d6869434ed5b339d))
+
+## [2.2.0](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v1.0.0...v2.2.0) (2020-11-04)
+
+
+### Features
+
+* feat: only use the import graph, update tests ([#28](https://github.com/webpack-contrib/eslint-webpack-plugin/pull/28)) ([47612f16](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/47612f16894f22f4b5c3848595bba48ca8eb9b0f))
+
+### Bug Fixes
+
+* fix: use compiler.outputFileSystem to write report
+
+* fix: use fs callback forms because webpack5 does not work with promisify on outputFileSystem methods
+
+* fix: do not accumulate more taps as watchRuns occur
+
+* fix: windows path escape, cleanup watch-fixture
+
+## [2.1.0](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v1.0.0...v2.1.0) (2020-07-30)
+
+
+### Features
+
+* support typescript ([#8](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/8)) ([6634d96](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/6634d96e7e80dd2d7097479f13a48115e0544f59))
+
+## [2.0.0](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v1.0.0...v2.0.0) (2020-07-26)
+
+
+### Features
+
+* ESLint class migration ([#11](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/11)) ([efd5e7d](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/efd5e7d01b8569c5dcb2808f618f56e4857fcf52)), closes [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10) [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10) [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10) [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10) [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10) [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10) [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10) [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10) [#10](https://github.com/webpack-contrib/eslint-webpack-plugin/issues/10)
+
+### ⚠ BREAKING CHANGES
+
+* minimum supported eslint version is `7`
+
+## [1.0.0](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v0.1.0...v1.0.0) (2020-05-04)
+
+### ⚠ BREAKING CHANGES
+
+* minimum supported Node.js version is `10.13`
+* minimum supported eslint version is `6.0.0`
+
+## [0.1.0](https://github.com/webpack-contrib/eslint-webpack-plugin/compare/v0.0.1...v0.1.0) (2019-12-20)
+
+
+### Features
+
+* support webpack 5 ([b7f3679](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/b7f3679a8d5e5166376caec2a28ed38d6772bcca))
+
+
+### Bug Fixes
+
+* hooks and callback error ([3e7c36e](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/3e7c36e78e7c05bb5559adced2f92317affbf1ff))
+* resolve file glob patterns ([d5c8820](https://github.com/webpack-contrib/eslint-webpack-plugin/commit/d5c8820d9467e8794a4aa3944bf6ded746d79411))
+
+### 0.0.1 (2019-11-12)
--- a/web/node_modules/eslint-webpack-plugin/LICENSE
+++ b/web/node_modules/eslint-webpack-plugin/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.
--- a/web/node_modules/eslint-webpack-plugin/README.md
+++ b/web/node_modules/eslint-webpack-plugin/README.md
@ -0,0 +1,241 @@
+<div align="center">
+  <a href="https://github.com/eslint/eslint"><img width="200" height="200" src="https://cdn.worldvectorlogo.com/logos/eslint.svg"></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]
+
+# eslint-webpack-plugin
+
+> A ESLint plugin for webpack
+
+## About plugin
+
+The plugin was born with the purpose of solving some problems of the [eslint-loader](https://github.com/webpack-contrib/eslint-loader).
+
+|                                  | eslint-webpack-plugin |      eslint-loader       |
+| -------------------------------- | :-------------------: | :----------------------: |
+| Easy configuration               |  :heavy_check_mark:   | :heavy_multiplication_x: |
+| Generate unique an output report |  :heavy_check_mark:   | :heavy_multiplication_x: |
+| Using cache directly from eslint |  :heavy_check_mark:   | :heavy_multiplication_x: |
+| Lint only changed files          |  :heavy_check_mark:   | :heavy_multiplication_x: |
+
+## Migrate from `eslint-loader`
+
+The loader `eslint-loader` will be deprecated soon, please use this plugin instead.
+
+Before:
+
+```js
+module.exports = {
+  // ...
+  module: {
+    rules: [
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: 'eslint-loader',
+        options: {
+          // eslint options (if necessary)
+        },
+      },
+    ],
+  },
+  // ...
+};
+```
+
+After:
+
+```js
+const ESLintPlugin = require('eslint-webpack-plugin');
+
+module.exports = {
+  // ...
+  plugins: [new ESLintPlugin(options)],
+  // ...
+};
+```
+
+## Install
+
+```bash
+npm install eslint-webpack-plugin --save-dev
+```
+
+**Note**: You also need to install `eslint >= 7` from npm, if you haven't already:
+
+```bash
+npm install eslint --save-dev
+```
+
+## Usage
+
+In your webpack configuration:
+
+```js
+const ESLintPlugin = require('eslint-webpack-plugin');
+
+module.exports = {
+  // ...
+  plugins: [new ESLintPlugin(options)],
+  // ...
+};
+```
+
+## Options
+
+You can pass [eslint options](https://eslint.org/docs/developer-guide/nodejs-api#%E2%97%86-new-eslint-options).
+
+Note that the config option you provide will be passed to the `ESLint` class.
+This is a different set of options than what you'd specify in `package.json` or `.eslintrc`.
+See the [eslint docs](https://eslint.org/docs/developer-guide/nodejs-api#%E2%97%86-new-eslint-options) for more details.
+
+**Warning**: In eslint-webpack-plugin version 1 the options were passed to the now deprecated [CLIEngine](https://eslint.org/docs/developer-guide/nodejs-api#cliengine).
+
+### `context`
+
+- Type: `String`
+- Default: `compiler.context`
+
+A string indicating the root of your files.
+
+### `eslintPath`
+
+- Type: `String`
+- Default: `eslint`
+
+Path to `eslint` instance that will be used for linting. If the `eslintPath` is a folder like a official eslint, or specify a `formatter` option. now you dont have to install `eslint`.
+
+### `extensions`
+
+- Type: `String|Array[String]`
+- Default: `'js'`
+
+Specify extensions that should be checked.
+
+### `exclude`
+
+- Type: `String|Array[String]`
+- Default: `'node_modules'`
+
+Specify the files and/or directories to exclude. Must be relative to `options.context`.
+
+### `files`
+
+- Type: `String|Array[String]`
+- Default: `null`
+
+Specify directories, files, or globs. Must be relative to `options.context`.
+Directories are traveresed recursively looking for files matching `options.extensions`.
+File and glob patterns ignore `options.extensions`.
+
+### `fix`
+
+- Type: `Boolean`
+- Default: `false`
+
+Will enable [ESLint autofix feature](https://eslint.org/docs/developer-guide/nodejs-api#%E2%97%86-eslint-outputfixes-results).
+
+**Be careful: this option will change source files.**
+
+### `formatter`
+
+- Type: `String|Function`
+- Default: `'stylish'`
+
+Accepts a function that will have one argument: an array of eslint messages (object). The function must return the output as a string. You can use official [eslint formatters](https://eslint.org/docs/user-guide/formatters/).
+
+### `lintDirtyModulesOnly`
+
+- Type: `Boolean`
+- Default: `false`
+
+Lint only changed files, skip lint on start.
+
+### `threads`
+
+- Type: `Boolean | Number`
+- Default: `false`
+
+Will run lint tasks across a thread pool. The pool size is automatic unless you specify a number.
+
+### Errors and Warning
+
+**By default the plugin will auto adjust error reporting depending on eslint errors/warnings counts.**
+You can still force this behavior by using `emitError` **or** `emitWarning` options:
+
+#### `emitError`
+
+- Type: `Boolean`
+- Default: `true`
+
+The errors found will always be emitted, to disable set to `false`.
+
+#### `emitWarning`
+
+- Type: `Boolean`
+- Default: `true`
+
+The warnings found will always be emitted, to disable set to `false`.
+
+#### `failOnError`
+
+- Type: `Boolean`
+- Default: `true`
+
+Will cause the module build to fail if there are any errors, to disable set to `false`.
+
+#### `failOnWarning`
+
+- Type: `Boolean`
+- Default: `false`
+
+Will cause the module build to fail if there are any warnings, if set to `true`.
+
+#### `quiet`
+
+- Type: `Boolean`
+- Default: `false`
+
+Will process and report errors only and ignore warnings, if set to `true`.
+
+#### `outputReport`
+
+- Type: `Boolean|Object`
+- Default: `false`
+
+Write the output of the errors to a file, for example a checkstyle xml file for use for reporting on Jenkins CI.
+
+The `filePath` is an absolute path or relative to the webpack config: `output.path`.
+You can pass in a different `formatter` for the output file,
+if none is passed in the default/configured formatter will be used.
+
+## Changelog
+
+[Changelog](CHANGELOG.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/eslint-webpack-plugin.svg
+[npm-url]: https://npmjs.com/package/eslint-webpack-plugin
+[node]: https://img.shields.io/node/v/eslint-webpack-plugin.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack-contrib/eslint-webpack-plugin.svg
+[deps-url]: https://david-dm.org/webpack-contrib/eslint-webpack-plugin
+[tests]: https://github.com/webpack-contrib/eslint-webpack-plugin/workflows/eslint-webpack-plugin/badge.svg
+[tests-url]: https://github.com/webpack-contrib/eslint-webpack-plugin/actions
+[cover]: https://codecov.io/gh/webpack-contrib/eslint-webpack-plugin/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/eslint-webpack-plugin
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.now.sh/badge?p=eslint-webpack-plugin
+[size-url]: https://packagephobia.now.sh/result?p=eslint-webpack-plugin
--- a/web/node_modules/eslint-webpack-plugin/declarations/ESLintError.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/declarations/ESLintError.d.ts
@ -0,0 +1,7 @@
+export default ESLintError;
+declare class ESLintError extends Error {
+  /**
+   * @param {string=} messages
+   */
+  constructor(messages?: string | undefined);
+}
--- a/web/node_modules/eslint-webpack-plugin/declarations/cjs.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/declarations/cjs.d.ts
@ -0,0 +1,3 @@
+declare const _exports: typeof plugin.default;
+export = _exports;
+import plugin = require('.');
--- a/web/node_modules/eslint-webpack-plugin/declarations/getESLint.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/declarations/getESLint.d.ts
@ -0,0 +1,49 @@
+/** @typedef {import('eslint').ESLint} ESLint */
+/** @typedef {import('eslint').ESLint.LintResult} LintResult */
+/** @typedef {import('./options').Options} Options */
+/** @typedef {() => Promise<void>} AsyncTask */
+/** @typedef {(files: string|string[]) => Promise<LintResult[]>} LintTask */
+/** @typedef {JestWorker & {lintFiles: LintTask}} Worker */
+/** @typedef {{threads: number, ESLint: ESLint, eslint: ESLint, lintFiles: LintTask, cleanup: AsyncTask}} Linter */
+/**
+ * @param {Options} options
+ * @returns {Linter}
+ */
+export function loadESLint(options: Options): Linter;
+/**
+ * @param {string|undefined} key
+ * @param {number} poolSize
+ * @param {Options} options
+ * @returns {Linter}
+ */
+export function loadESLintThreaded(
+  key: string | undefined,
+  poolSize: number,
+  options: Options
+): Linter;
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {Linter}
+ */
+export default function getESLint(
+  key: string | undefined,
+  { threads, ...options }: Options
+): Linter;
+export type ESLint = import('eslint').ESLint;
+export type LintResult = import('eslint').ESLint.LintResult;
+export type Options = import('./options').PluginOptions &
+  import('eslint').ESLint.Options;
+export type AsyncTask = () => Promise<void>;
+export type LintTask = (files: string | string[]) => Promise<LintResult[]>;
+export type Worker = JestWorker & {
+  lintFiles: LintTask;
+};
+export type Linter = {
+  threads: number;
+  ESLint: ESLint;
+  eslint: ESLint;
+  lintFiles: LintTask;
+  cleanup: AsyncTask;
+};
+import JestWorker from 'jest-worker';
--- a/web/node_modules/eslint-webpack-plugin/declarations/index.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/declarations/index.d.ts
@ -0,0 +1,27 @@
+export default ESLintWebpackPlugin;
+export type Compiler = import('webpack').Compiler;
+export type Options = import('./options').PluginOptions &
+  import('eslint').ESLint.Options;
+declare class ESLintWebpackPlugin {
+  /**
+   * @param {Options} options
+   */
+  constructor(options?: Options);
+  key: string;
+  options: import('./options').PluginOptions;
+  /**
+   * @param {Compiler} compiler
+   */
+  run(compiler: Compiler): Promise<void>;
+  /**
+   * @param {Compiler} compiler
+   * @returns {void}
+   */
+  apply(compiler: Compiler): void;
+  /**
+   *
+   * @param {Compiler} compiler
+   * @returns {string}
+   */
+  getContext(compiler: Compiler): string;
+}
--- a/web/node_modules/eslint-webpack-plugin/declarations/linter.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/declarations/linter.d.ts
@ -0,0 +1,39 @@
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @param {Compilation} compilation
+ * @returns {{lint: Linter, report: Reporter, threads: number}}
+ */
+export default function linter(
+  key: string | undefined,
+  options: Options,
+  compilation: Compilation
+): {
+  lint: Linter;
+  report: Reporter;
+  threads: number;
+};
+export type ESLint = import('eslint').ESLint;
+export type Formatter = import('eslint').ESLint.Formatter;
+export type LintResult = import('eslint').ESLint.LintResult;
+export type Compiler = import('webpack').Compiler;
+export type Compilation = import('webpack').Compilation;
+export type Source = import('webpack-sources/lib/Source');
+export type Options = import('./options').PluginOptions &
+  import('eslint').ESLint.Options;
+export type FormatterFunction = (
+  results: import('eslint').ESLint.LintResult[],
+  data?: import('eslint').ESLint.LintResultData | undefined
+) => string;
+export type GenerateReport = (compilation: Compilation) => Promise<void>;
+export type Report = {
+  errors?: ESLintError | undefined;
+  warnings?: ESLintError | undefined;
+  generateReportAsset?: GenerateReport | undefined;
+};
+export type Reporter = () => Promise<Report>;
+export type Linter = (files: string | string[]) => void;
+export type LintResultMap = {
+  [files: string]: import('eslint').ESLint.LintResult;
+};
+import ESLintError from './ESLintError';
--- a/web/node_modules/eslint-webpack-plugin/declarations/options.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/declarations/options.d.ts
@ -0,0 +1,72 @@
+/** @typedef {import("eslint").ESLint.Options} ESLintOptions */
+/** @typedef {import('eslint').ESLint.LintResult} LintResult */
+/** @typedef {import('eslint').ESLint.LintResultData} LintResultData */
+/**
+ * @callback FormatterFunction
+ * @param {LintResult[]} results
+ * @param {LintResultData=} data
+ * @returns {string}
+ */
+/**
+ * @typedef {Object} OutputReport
+ * @property {string=} filePath
+ * @property {string|FormatterFunction=} formatter
+ */
+/**
+ * @typedef {Object} PluginOptions
+ * @property {string=} context
+ * @property {boolean=} emitError
+ * @property {boolean=} emitWarning
+ * @property {string=} eslintPath
+ * @property {string|string[]=} exclude
+ * @property {string|string[]=} extensions
+ * @property {boolean=} failOnError
+ * @property {boolean=} failOnWarning
+ * @property {string|string[]=} files
+ * @property {boolean=} fix
+ * @property {string|FormatterFunction=} formatter
+ * @property {boolean=} lintDirtyModulesOnly
+ * @property {boolean=} quiet
+ * @property {OutputReport=} outputReport
+ * @property {number|boolean=} threads
+ */
+/** @typedef {PluginOptions & ESLintOptions} Options */
+/**
+ * @param {Options} pluginOptions
+ * @returns {PluginOptions}
+ */
+export function getOptions(pluginOptions: Options): PluginOptions;
+/**
+ * @param {Options} loaderOptions
+ * @returns {ESLintOptions}
+ */
+export function getESLintOptions(loaderOptions: Options): ESLintOptions;
+export type ESLintOptions = import('eslint').ESLint.Options;
+export type LintResult = import('eslint').ESLint.LintResult;
+export type LintResultData = import('eslint').ESLint.LintResultData;
+export type FormatterFunction = (
+  results: LintResult[],
+  data?: LintResultData | undefined
+) => string;
+export type OutputReport = {
+  filePath?: string | undefined;
+  formatter?: (string | FormatterFunction) | undefined;
+};
+export type PluginOptions = {
+  context?: string | undefined;
+  emitError?: boolean | undefined;
+  emitWarning?: boolean | undefined;
+  eslintPath?: string | undefined;
+  exclude?: (string | string[]) | undefined;
+  extensions?: (string | string[]) | undefined;
+  failOnError?: boolean | undefined;
+  failOnWarning?: boolean | undefined;
+  files?: (string | string[]) | undefined;
+  fix?: boolean | undefined;
+  formatter?: (string | FormatterFunction) | undefined;
+  lintDirtyModulesOnly?: boolean | undefined;
+  quiet?: boolean | undefined;
+  outputReport?: OutputReport | undefined;
+  threads?: (number | boolean) | undefined;
+};
+export type Options = PluginOptions & import('eslint').ESLint.Options;
--- a/web/node_modules/eslint-webpack-plugin/declarations/utils.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/declarations/utils.d.ts
@ -0,0 +1,16 @@
+/**
+ * @param {string|string[]} files
+ * @param {string} context
+ * @returns {string[]}
+ */
+export function parseFiles(files: string | string[], context: string): string[];
+/**
+ * @param {string|string[]} patterns
+ * @param {string|string[]} extensions
+ * @returns {string[]}
+ */
+export function parseFoldersToGlobs(
+  patterns: string | string[],
+  extensions?: string | string[]
+): string[];
+export function jsonStringifyReplacerSortKeys(_: string, value: any): any;
--- a/web/node_modules/eslint-webpack-plugin/declarations/worker.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/declarations/worker.d.ts
@ -0,0 +1,12 @@
+export type setupOptions = {
+  /**
+   * - import path of eslint
+   */
+  eslintPath?: string | undefined;
+  /**
+   * - linter options
+   */
+  eslintOptions?: ESLintOptions | undefined;
+};
+export type ESLint = import('eslint').ESLint;
+export type ESLintOptions = import('eslint').ESLint.Options;
--- a/web/node_modules/eslint-webpack-plugin/dist/ESLintError.js
+++ b/web/node_modules/eslint-webpack-plugin/dist/ESLintError.js
@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class ESLintError extends Error {
+  /**
+   * @param {string=} messages
+   */
+  constructor(messages) {
+    super(messages);
+    this.name = 'ESLintError';
+    this.stack = '';
+  }
+
+}
+
+var _default = ESLintError;
+exports.default = _default;
--- a/web/node_modules/eslint-webpack-plugin/dist/cjs.js
+++ b/web/node_modules/eslint-webpack-plugin/dist/cjs.js
@ -0,0 +1,5 @@
+"use strict";
+
+const plugin = require('./');
+
+module.exports = plugin.default;
--- a/web/node_modules/eslint-webpack-plugin/dist/getESLint.js
+++ b/web/node_modules/eslint-webpack-plugin/dist/getESLint.js
@ -0,0 +1,157 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadESLint = loadESLint;
+exports.loadESLintThreaded = loadESLintThreaded;
+exports.default = getESLint;
+
+var _os = require("os");
+
+var _jestWorker = _interopRequireDefault(require("jest-worker"));
+
+var _options = require("./options");
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/** @type {{[key: string]: any}} */
+const cache = {};
+/** @typedef {import('eslint').ESLint} ESLint */
+
+/** @typedef {import('eslint').ESLint.LintResult} LintResult */
+
+/** @typedef {import('./options').Options} Options */
+
+/** @typedef {() => Promise<void>} AsyncTask */
+
+/** @typedef {(files: string|string[]) => Promise<LintResult[]>} LintTask */
+
+/** @typedef {JestWorker & {lintFiles: LintTask}} Worker */
+
+/** @typedef {{threads: number, ESLint: ESLint, eslint: ESLint, lintFiles: LintTask, cleanup: AsyncTask}} Linter */
+
+/**
+ * @param {Options} options
+ * @returns {Linter}
+ */
+
+function loadESLint(options) {
+  const {
+    eslintPath
+  } = options;
+
+  const {
+    ESLint
+  } = require(eslintPath || 'eslint'); // Filter out loader options before passing the options to ESLint.
+
+
+  const eslint = new ESLint((0, _options.getESLintOptions)(options));
+  return {
+    threads: 1,
+    ESLint,
+    eslint,
+    lintFiles: async files => {
+      const results = await eslint.lintFiles(files); // istanbul ignore else
+
+      if (options.fix) {
+        await ESLint.outputFixes(results);
+      }
+
+      return results;
+    },
+    // no-op for non-threaded
+    cleanup: async () => {}
+  };
+}
+/**
+ * @param {string|undefined} key
+ * @param {number} poolSize
+ * @param {Options} options
+ * @returns {Linter}
+ */
+
+
+function loadESLintThreaded(key, poolSize, options) {
+  const cacheKey = getCacheKey(key, options);
+  const {
+    eslintPath = 'eslint'
+  } = options;
+
+  const source = require.resolve('./worker');
+
+  const workerOptions = {
+    enableWorkerThreads: true,
+    numWorkers: poolSize,
+    setupArgs: [{
+      eslintPath,
+      eslintOptions: (0, _options.getESLintOptions)(options)
+    }]
+  };
+  const local = loadESLint(options);
+  /** @type {Worker?} */
+  // prettier-ignore
+
+  let worker =
+  /** @type {Worker} */
+  new _jestWorker.default(source, workerOptions);
+  /** @type {Linter} */
+
+  const context = { ...local,
+    threads: poolSize,
+    lintFiles: async (files) => worker && (await worker.lintFiles(files)) ||
+    /* istanbul ignore next */
+    [],
+    cleanup: async () => {
+      cache[cacheKey] = local;
+
+      context.lintFiles = files => local.lintFiles(files);
+
+      if (worker) {
+        worker.end();
+        worker = null;
+      }
+    }
+  };
+  return context;
+}
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {Linter}
+ */
+
+
+function getESLint(key, {
+  threads,
+  ...options
+}) {
+  const max = typeof threads !== 'number' ? threads ? (0, _os.cpus)().length - 1 : 1 :
+  /* istanbul ignore next */
+  threads;
+  const cacheKey = getCacheKey(key, {
+    threads,
+    ...options
+  });
+
+  if (!cache[cacheKey]) {
+    cache[cacheKey] = max > 1 ? loadESLintThreaded(key, max, options) : loadESLint(options);
+  }
+
+  return cache[cacheKey];
+}
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @returns {string}
+ */
+
+
+function getCacheKey(key, options) {
+  return JSON.stringify({
+    key,
+    options
+  }, _utils.jsonStringifyReplacerSortKeys);
+}
--- a/web/node_modules/eslint-webpack-plugin/dist/index.js
+++ b/web/node_modules/eslint-webpack-plugin/dist/index.js
@ -0,0 +1,195 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _path = require("path");
+
+var _arrify = _interopRequireDefault(require("arrify"));
+
+var _micromatch = require("micromatch");
+
+var _options = require("./options");
+
+var _linter = _interopRequireDefault(require("./linter"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// @ts-ignore
+
+/** @typedef {import('webpack').Compiler} Compiler */
+
+/** @typedef {import('./options').Options} Options */
+const ESLINT_PLUGIN = 'ESLintWebpackPlugin';
+let counter = 0;
+
+class ESLintWebpackPlugin {
+  /**
+   * @param {Options} options
+   */
+  constructor(options = {}) {
+    this.key = ESLINT_PLUGIN;
+    this.options = (0, _options.getOptions)(options);
+    this.run = this.run.bind(this);
+  }
+  /**
+   * @param {Compiler} compiler
+   * @returns {void}
+   */
+
+
+  apply(compiler) {
+    // Generate key for each compilation,
+    // this differentiates one from the other when being cached.
+    this.key = compiler.name || `${this.key}_${counter += 1}`; // If `lintDirtyModulesOnly` is disabled,
+    // execute the linter on the build
+
+    if (!this.options.lintDirtyModulesOnly) {
+      compiler.hooks.run.tapPromise(this.key, this.run);
+    } // TODO: Figure out want `compiler.watching` is and how to use it in Webpack5.
+    // From my testing of compiler.watch() ... compiler.watching is always
+    // undefined (webpack 4 doesn't define it either) I'm leaving it out
+    // for now.
+
+
+    let isFirstRun = this.options.lintDirtyModulesOnly;
+    compiler.hooks.watchRun.tapPromise(this.key, c => {
+      if (isFirstRun) {
+        isFirstRun = false;
+        return Promise.resolve();
+      }
+
+      return this.run(c);
+    });
+  }
+  /**
+   * @param {Compiler} compiler
+   */
+
+
+  async run(compiler) {
+    // Do not re-hook
+    if ( // @ts-ignore
+    compiler.hooks.thisCompilation.taps.find(({
+      name
+    }) => name === this.key)) {
+      return;
+    }
+
+    const options = { ...this.options,
+      exclude: (0, _utils.parseFiles)(this.options.exclude || [], this.getContext(compiler)),
+      extensions: (0, _arrify.default)(this.options.extensions),
+      files: (0, _utils.parseFiles)(this.options.files || '', this.getContext(compiler))
+    };
+    const wanted = (0, _utils.parseFoldersToGlobs)(options.files, options.extensions);
+    const exclude = (0, _utils.parseFoldersToGlobs)(this.options.exclude ? options.exclude : '**/node_modules/**', []);
+    compiler.hooks.thisCompilation.tap(this.key, compilation => {
+      /** @type {import('./linter').Linter} */
+      let lint;
+      /** @type {import('./linter').Reporter} */
+
+      let report;
+      /** @type number */
+
+      let threads;
+
+      try {
+        ({
+          lint,
+          report,
+          threads
+        } = (0, _linter.default)(this.key, options, compilation));
+      } catch (e) {
+        compilation.errors.push(e);
+        return;
+      }
+      /** @type {string[]} */
+
+
+      const files = []; // @ts-ignore
+      // Add the file to be linted
+
+      compilation.hooks.succeedModule.tap(this.key, ({
+        resource
+      }) => {
+        if (resource) {
+          const [file] = resource.split('?');
+
+          if (file && !files.includes(file) && (0, _micromatch.isMatch)(file, wanted, {
+            dot: true
+          }) && !(0, _micromatch.isMatch)(file, exclude, {
+            dot: true
+          })) {
+            files.push(file);
+
+            if (threads > 1) {
+              lint(file);
+            }
+          }
+        }
+      }); // Lint all files added
+
+      compilation.hooks.finishModules.tap(this.key, () => {
+        if (files.length > 0 && threads <= 1) {
+          lint(files);
+        }
+      }); // await and interpret results
+
+      compilation.hooks.additionalAssets.tapPromise(this.key, processResults);
+
+      async function processResults() {
+        const {
+          errors,
+          warnings,
+          generateReportAsset
+        } = await report();
+
+        if (warnings && !options.failOnWarning) {
+          // @ts-ignore
+          compilation.warnings.push(warnings);
+        } else if (warnings && options.failOnWarning) {
+          // @ts-ignore
+          compilation.errors.push(warnings);
+        }
+
+        if (errors && options.failOnError) {
+          // @ts-ignore
+          compilation.errors.push(errors);
+        } else if (errors && !options.failOnError) {
+          // @ts-ignore
+          compilation.warnings.push(errors);
+        }
+
+        if (generateReportAsset) {
+          await generateReportAsset(compilation);
+        }
+      }
+    });
+  }
+  /**
+   *
+   * @param {Compiler} compiler
+   * @returns {string}
+   */
+
+
+  getContext(compiler) {
+    if (!this.options.context) {
+      return String(compiler.options.context);
+    }
+
+    if (!(0, _path.isAbsolute)(this.options.context)) {
+      return (0, _path.join)(String(compiler.options.context), this.options.context);
+    }
+
+    return this.options.context;
+  }
+
+}
+
+var _default = ESLintWebpackPlugin;
+exports.default = _default;
--- a/web/node_modules/eslint-webpack-plugin/dist/linter.js
+++ b/web/node_modules/eslint-webpack-plugin/dist/linter.js
@ -0,0 +1,341 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = linter;
+
+var _path = require("path");
+
+var _ESLintError = _interopRequireDefault(require("./ESLintError"));
+
+var _getESLint = _interopRequireDefault(require("./getESLint"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/** @typedef {import('eslint').ESLint} ESLint */
+
+/** @typedef {import('eslint').ESLint.Formatter} Formatter */
+
+/** @typedef {import('eslint').ESLint.LintResult} LintResult */
+
+/** @typedef {import('webpack').Compiler} Compiler */
+
+/** @typedef {import('webpack').Compilation} Compilation */
+
+/** @typedef {import('webpack-sources').Source} Source */
+
+/** @typedef {import('./options').Options} Options */
+
+/** @typedef {import('./options').FormatterFunction} FormatterFunction */
+
+/** @typedef {(compilation: Compilation) => Promise<void>} GenerateReport */
+
+/** @typedef {{errors?: ESLintError, warnings?: ESLintError, generateReportAsset?: GenerateReport}} Report */
+
+/** @typedef {() => Promise<Report>} Reporter */
+
+/** @typedef {(files: string|string[]) => void} Linter */
+
+/** @typedef {{[files: string]: LintResult}} LintResultMap */
+
+/** @type {WeakMap<Compiler, LintResultMap>} */
+const resultStorage = new WeakMap();
+/**
+ * @param {string|undefined} key
+ * @param {Options} options
+ * @param {Compilation} compilation
+ * @returns {{lint: Linter, report: Reporter, threads: number}}
+ */
+
+function linter(key, options, compilation) {
+  /** @type {ESLint} */
+  let eslint;
+  /** @type {(files: string|string[]) => Promise<LintResult[]>} */
+
+  let lintFiles;
+  /** @type {() => Promise<void>} */
+
+  let cleanup;
+  /** @type number */
+
+  let threads;
+  /** @type {Promise<LintResult[]>[]} */
+
+  const rawResults = [];
+  const crossRunResultStorage = getResultStorage(compilation);
+
+  try {
+    ({
+      eslint,
+      lintFiles,
+      cleanup,
+      threads
+    } = (0, _getESLint.default)(key, options));
+  } catch (e) {
+    throw new _ESLintError.default(e.message);
+  }
+
+  return {
+    lint,
+    report,
+    threads
+  };
+  /**
+   * @param {string | string[]} files
+   */
+
+  function lint(files) {
+    for (const file of asList(files)) {
+      delete crossRunResultStorage[file];
+    }
+
+    rawResults.push(lintFiles(files).catch(e => {
+      compilation.errors.push(e);
+      return [];
+    }));
+  }
+
+  async function report() {
+    // Filter out ignored files.
+    let results = await removeIgnoredWarnings(eslint, // Get the current results, resetting the rawResults to empty
+    await flatten(rawResults.splice(0, rawResults.length)));
+    await cleanup();
+
+    for (const result of results) {
+      crossRunResultStorage[result.filePath] = result;
+    }
+
+    results = Object.values(crossRunResultStorage); // do not analyze if there are no results or eslint config
+
+    if (!results || results.length < 1) {
+      return {};
+    }
+
+    const formatter = await loadFormatter(eslint, options.formatter);
+    const {
+      errors,
+      warnings
+    } = formatResults(formatter, parseResults(options, results));
+    return {
+      errors,
+      warnings,
+      generateReportAsset
+    };
+    /**
+     * @param {Compilation} compilation
+     * @returns {Promise<void>}
+     */
+
+    async function generateReportAsset({
+      compiler
+    }) {
+      const {
+        outputReport
+      } = options;
+      /**
+       * @param {string} name
+       * @param {string | Buffer} content
+       */
+
+      const save = (name, content) =>
+      /** @type {Promise<void>} */
+      new Promise((finish, bail) => {
+        const {
+          mkdir,
+          writeFile
+        } = compiler.outputFileSystem; // ensure directory exists
+        // @ts-ignore - the types for `outputFileSystem` are missing the 3 arg overload
+
+        mkdir((0, _path.dirname)(name), {
+          recursive: true
+        }, err => {
+          /* istanbul ignore if */
+          if (err) bail(err);else writeFile(name, content, err2 => {
+            /* istanbul ignore if */
+            if (err2) bail(err2);else finish();
+          });
+        });
+      });
+
+      if (!outputReport || !outputReport.filePath) {
+        return;
+      }
+
+      const content = outputReport.formatter ? (await loadFormatter(eslint, outputReport.formatter)).format(results) : formatter.format(results);
+      let {
+        filePath
+      } = outputReport;
+
+      if (!(0, _path.isAbsolute)(filePath)) {
+        filePath = (0, _path.join)(compiler.outputPath, filePath);
+      }
+
+      await save(filePath, content);
+    }
+  }
+}
+/**
+ * @param {Formatter} formatter
+ * @param {{ errors: LintResult[]; warnings: LintResult[]; }} results
+ * @returns {{errors?: ESLintError, warnings?: ESLintError}}
+ */
+
+
+function formatResults(formatter, results) {
+  let errors;
+  let warnings;
+
+  if (results.warnings.length > 0) {
+    warnings = new _ESLintError.default(formatter.format(results.warnings));
+  }
+
+  if (results.errors.length > 0) {
+    errors = new _ESLintError.default(formatter.format(results.errors));
+  }
+
+  return {
+    errors,
+    warnings
+  };
+}
+/**
+ * @param {Options} options
+ * @param {LintResult[]} results
+ * @returns {{errors: LintResult[], warnings: LintResult[]}}
+ */
+
+
+function parseResults(options, results) {
+  /** @type {LintResult[]} */
+  const errors = [];
+  /** @type {LintResult[]} */
+
+  const warnings = [];
+  results.forEach(file => {
+    if (fileHasErrors(file)) {
+      const messages = file.messages.filter(message => options.emitError && message.severity === 2);
+
+      if (messages.length > 0) {
+        errors.push({ ...file,
+          messages
+        });
+      }
+    }
+
+    if (fileHasWarnings(file)) {
+      const messages = file.messages.filter(message => options.emitWarning && message.severity === 1);
+
+      if (messages.length > 0) {
+        warnings.push({ ...file,
+          messages
+        });
+      }
+    }
+  });
+  return {
+    errors,
+    warnings
+  };
+}
+/**
+ * @param {LintResult} file
+ * @returns {boolean}
+ */
+
+
+function fileHasErrors(file) {
+  return file.errorCount > 0;
+}
+/**
+ * @param {LintResult} file
+ * @returns {boolean}
+ */
+
+
+function fileHasWarnings(file) {
+  return file.warningCount > 0;
+}
+/**
+ * @param {ESLint} eslint
+ * @param {string|FormatterFunction=} formatter
+ * @returns {Promise<Formatter>}
+ */
+
+
+async function loadFormatter(eslint, formatter) {
+  if (typeof formatter === 'function') {
+    return {
+      format: formatter
+    };
+  }
+
+  if (typeof formatter === 'string') {
+    try {
+      return eslint.loadFormatter(formatter);
+    } catch (_) {// Load the default formatter.
+    }
+  }
+
+  return eslint.loadFormatter();
+}
+/**
+ * @param {ESLint} eslint
+ * @param {LintResult[]} results
+ * @returns {Promise<LintResult[]>}
+ */
+
+
+async function removeIgnoredWarnings(eslint, results) {
+  const filterPromises = results.map(async result => {
+    // Short circuit the call to isPathIgnored.
+    //   fatal is false for ignored file warnings.
+    //   ruleId is unset for internal ESLint errors.
+    //   line is unset for warnings not involving file contents.
+    const ignored = result.messages.length === 0 || result.warningCount === 1 && result.errorCount === 0 && !result.messages[0].fatal && !result.messages[0].ruleId && !result.messages[0].line && (await eslint.isPathIgnored(result.filePath));
+    return ignored ? false : result;
+  }); // @ts-ignore
+
+  return (await Promise.all(filterPromises)).filter(result => !!result);
+}
+/**
+ * @param {Promise<LintResult[]>[]} results
+ * @returns {Promise<LintResult[]>}
+ */
+
+
+async function flatten(results) {
+  /**
+   * @param {LintResult[]} acc
+   * @param {LintResult[]} list
+   */
+  const flat = (acc, list) => [...acc, ...list];
+
+  return (await Promise.all(results)).reduce(flat, []);
+}
+/**
+ * @param {Compilation} compilation
+ * @returns {LintResultMap}
+ */
+
+
+function getResultStorage({
+  compiler
+}) {
+  let storage = resultStorage.get(compiler);
+
+  if (!storage) {
+    resultStorage.set(compiler, storage = {});
+  }
+
+  return storage;
+}
+/**
+ * @param {string | string[]} x
+ */
+
+
+function asList(x) {
+  /* istanbul ignore next */
+  return Array.isArray(x) ? x : [x];
+}
--- a/web/node_modules/eslint-webpack-plugin/dist/options.js
+++ b/web/node_modules/eslint-webpack-plugin/dist/options.js
@ -0,0 +1,103 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOptions = getOptions;
+exports.getESLintOptions = getESLintOptions;
+
+var _schemaUtils = require("schema-utils");
+
+var _options = _interopRequireDefault(require("./options.json"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// @ts-ignore
+
+/** @typedef {import("eslint").ESLint.Options} ESLintOptions */
+
+/** @typedef {import('eslint').ESLint.LintResult} LintResult */
+
+/** @typedef {import('eslint').ESLint.LintResultData} LintResultData */
+
+/**
+ * @callback FormatterFunction
+ * @param {LintResult[]} results
+ * @param {LintResultData=} data
+ * @returns {string}
+ */
+
+/**
+ * @typedef {Object} OutputReport
+ * @property {string=} filePath
+ * @property {string|FormatterFunction=} formatter
+ */
+
+/**
+ * @typedef {Object} PluginOptions
+ * @property {string=} context
+ * @property {boolean=} emitError
+ * @property {boolean=} emitWarning
+ * @property {string=} eslintPath
+ * @property {string|string[]=} exclude
+ * @property {string|string[]=} extensions
+ * @property {boolean=} failOnError
+ * @property {boolean=} failOnWarning
+ * @property {string|string[]=} files
+ * @property {boolean=} fix
+ * @property {string|FormatterFunction=} formatter
+ * @property {boolean=} lintDirtyModulesOnly
+ * @property {boolean=} quiet
+ * @property {OutputReport=} outputReport
+ * @property {number|boolean=} threads
+ */
+
+/** @typedef {PluginOptions & ESLintOptions} Options */
+
+/**
+ * @param {Options} pluginOptions
+ * @returns {PluginOptions}
+ */
+function getOptions(pluginOptions) {
+  const options = {
+    extensions: 'js',
+    emitError: true,
+    emitWarning: true,
+    failOnError: true,
+    ...pluginOptions,
+    ...(pluginOptions.quiet ? {
+      emitError: true,
+      emitWarning: false
+    } : {})
+  }; // @ts-ignore
+
+  (0, _schemaUtils.validate)(_options.default, options, {
+    name: 'ESLint Webpack Plugin',
+    baseDataPath: 'options'
+  });
+  return options;
+}
+/**
+ * @param {Options} loaderOptions
+ * @returns {ESLintOptions}
+ */
+
+
+function getESLintOptions(loaderOptions) {
+  const eslintOptions = { ...loaderOptions
+  }; // Keep the fix option because it is common to both the loader and ESLint.
+
+  const {
+    fix,
+    extensions,
+    ...eslintOnlyOptions
+  } = _options.default.properties; // No need to guard the for-in because schema.properties has hardcoded keys.
+  // eslint-disable-next-line guard-for-in
+
+  for (const option in eslintOnlyOptions) {
+    // @ts-ignore
+    delete eslintOptions[option];
+  }
+
+  return eslintOptions;
+}
--- a/web/node_modules/eslint-webpack-plugin/dist/options.json
+++ b/web/node_modules/eslint-webpack-plugin/dist/options.json
@ -0,0 +1,84 @@
+{
+  "type": "object",
+  "additionalProperties": true,
+  "properties": {
+    "context": {
+      "description": "A string indicating the root of your files.",
+      "type": "string"
+    },
+    "emitError": {
+      "description": "The errors found will always be emitted, to disable set to `false`.",
+      "type": "boolean"
+    },
+    "emitWarning": {
+      "description": "The warnings found will always be emitted, to disable set to `false`.",
+      "type": "boolean"
+    },
+    "eslintPath": {
+      "description": "Path to `eslint` instance that will be used for linting. If the `eslintPath` is a folder like a official eslint, or specify a `formatter` option. now you dont have to install `eslint`.",
+      "type": "string"
+    },
+    "exclude": {
+      "description": "Specify the files and/or directories to exclude. Must be relative to `options.context`.",
+      "anyOf": [{ "type": "string" }, { "type": "array" }]
+    },
+    "failOnError": {
+      "description": "Will cause the module build to fail if there are any errors, to disable set to `false`.",
+      "type": "boolean"
+    },
+    "failOnWarning": {
+      "description": "Will cause the module build to fail if there are any warnings, if set to `true`.",
+      "type": "boolean"
+    },
+    "files": {
+      "description": "Specify the files and/or directories to traverse. Must be relative to `options.context`.",
+      "anyOf": [{ "type": "string" }, { "type": "array" }]
+    },
+    "extensions": {
+      "description": "Specify extensions that should be checked.",
+      "anyOf": [{ "type": "string" }, { "type": "array" }]
+    },
+    "fix": {
+      "description": "Will enable ESLint autofix feature",
+      "type": "boolean"
+    },
+    "formatter": {
+      "description": "Accepts a function that will have one argument: an array of eslint messages (object). The function must return the output as a string.",
+      "anyOf": [{ "type": "string" }, { "instanceof": "Function" }]
+    },
+    "lintDirtyModulesOnly": {
+      "description": "Lint only changed files, skip lint on start.",
+      "type": "boolean"
+    },
+    "quiet": {
+      "description": "Will process and report errors only and ignore warnings, if set to `true`.",
+      "type": "boolean"
+    },
+    "outputReport": {
+      "description": "Write the output of the errors to a file, for example a checkstyle xml file for use for reporting on Jenkins CI",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "filePath": {
+              "description": "The `filePath` is relative to the webpack config: output.path",
+              "anyOf": [{ "type": "string" }]
+            },
+            "formatter": {
+              "description": "You can pass in a different formatter for the output file, if none is passed in the default/configured formatter will be used",
+              "anyOf": [{ "type": "string" }, { "instanceof": "Function" }]
+            }
+          }
+        }
+      ]
+    },
+    "threads": {
+      "description": "Default is false. Set to true for an auto-selected pool size based on number of cpus. Set to a number greater than 1 to set an explicit pool size. Set to false, 1, or less to disable and only run in main process.",
+      "anyOf": [{ "type": "number" }, { "type": "boolean" }]
+    }
+  }
+}
--- a/web/node_modules/eslint-webpack-plugin/dist/utils.js
+++ b/web/node_modules/eslint-webpack-plugin/dist/utils.js
@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseFiles = parseFiles;
+exports.parseFoldersToGlobs = parseFoldersToGlobs;
+exports.jsonStringifyReplacerSortKeys = void 0;
+
+var _path = require("path");
+
+var _fs = require("fs");
+
+var _normalizePath = _interopRequireDefault(require("normalize-path"));
+
+var _arrify = _interopRequireDefault(require("arrify"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// @ts-ignore
+// @ts-ignore
+
+/**
+ * @param {string|string[]} files
+ * @param {string} context
+ * @returns {string[]}
+ */
+function parseFiles(files, context) {
+  return (0, _arrify.default)(files).map(
+  /** @type {string} */
+  file => (0, _normalizePath.default)((0, _path.resolve)(context, file)));
+}
+/**
+ * @param {string|string[]} patterns
+ * @param {string|string[]} extensions
+ * @returns {string[]}
+ */
+
+
+function parseFoldersToGlobs(patterns, extensions = []) {
+  const extensionsList = (0, _arrify.default)(extensions);
+  const [prefix, postfix] = extensionsList.length > 1 ? ['{', '}'] : ['', ''];
+  const extensionsGlob = extensionsList.map(
+  /** @type {string} */
+  extension => extension.replace(/^\./u, '')).join(',');
+  return (0, _arrify.default)(patterns).map(
+  /** @type {string} */
+  pattern => {
+    try {
+      // The patterns are absolute because they are prepended with the context.
+      const stats = (0, _fs.statSync)(pattern);
+      /* istanbul ignore else */
+
+      if (stats.isDirectory()) {
+        return pattern.replace(/[/\\]*?$/u, `/**${extensionsGlob ? `/*.${prefix + extensionsGlob + postfix}` : ''}`);
+      }
+    } catch (_) {// Return the pattern as is on error.
+    }
+
+    return pattern;
+  });
+}
+/**
+ *
+ * @param {string} _ key, but unused
+ * @param {any} value
+ */
+
+
+const jsonStringifyReplacerSortKeys = (_, value) => {
+  /**
+   * @param {{ [x: string]: any; }} sorted
+   * @param {string | number} key
+   */
+  const insert = (sorted, key) => {
+    // eslint-disable-next-line no-param-reassign
+    sorted[key] = value[key];
+    return sorted;
+  };
+
+  return value instanceof Object && !(value instanceof Array) ? Object.keys(value).sort().reduce(insert, {}) : value;
+};
+
+exports.jsonStringifyReplacerSortKeys = jsonStringifyReplacerSortKeys;
--- a/web/node_modules/eslint-webpack-plugin/dist/worker.js
+++ b/web/node_modules/eslint-webpack-plugin/dist/worker.js
@ -0,0 +1,50 @@
+"use strict";
+
+/** @typedef {import('eslint').ESLint} ESLint */
+
+/** @typedef {import('eslint').ESLint.Options} ESLintOptions */
+Object.assign(module.exports, {
+  lintFiles,
+  setup
+});
+/** @type {{ new (arg0: import("eslint").ESLint.Options): import("eslint").ESLint; outputFixes: (arg0: import("eslint").ESLint.LintResult[]) => any; }} */
+
+let ESLint;
+/** @type {ESLint} */
+
+let eslint;
+/** @type {boolean} */
+
+let fix;
+/**
+ * @typedef {object} setupOptions
+ * @property {string=} eslintPath - import path of eslint
+ * @property {ESLintOptions=} eslintOptions - linter options
+ *
+ * @param {setupOptions} arg0 - setup worker
+ */
+
+function setup({
+  eslintPath,
+  eslintOptions = {}
+}) {
+  fix = !!(eslintOptions && eslintOptions.fix);
+  ({
+    ESLint
+  } = require(eslintPath || 'eslint'));
+  eslint = new ESLint(eslintOptions);
+}
+/**
+ * @param {string | string[]} files
+ */
+
+
+async function lintFiles(files) {
+  const result = await eslint.lintFiles(files); // if enabled, use eslint autofixing where possible
+
+  if (fix) {
+    await ESLint.outputFixes(result);
+  }
+
+  return result;
+}
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/LICENSE
+++ b/web/node_modules/eslint-webpack-plugin/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.
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/README.md
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/README.md
@ -0,0 +1,290 @@
+<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
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+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
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+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
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+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
+import schema from "./path/to/schema.json";
+import { validate } from "schema-utils";
+
+const options = { foo: "bar" };
+
+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 { validate } from "schema-utils";
+
+import schema from "path/to/schema.json";
+
+function loader(src, map) {
+  const options = getOptions(this);
+
+  validate(schema, options, {
+    name: "Loader Name",
+    baseDataPath: "options",
+  });
+
+  // Code...
+}
+
+export default loader;
+```
+
+### `Plugin`
+
+```js
+import { validate } from "schema-utils";
+
+import schema from "path/to/schema.json";
+
+class Plugin {
+  constructor(options) {
+    validate(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
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/ValidationError.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/ValidationError.d.ts
@ -0,0 +1,74 @@
+export default ValidationError;
+export type JSONSchema6 = import("json-schema").JSONSchema6;
+export type JSONSchema7 = import("json-schema").JSONSchema7;
+export type Schema = import("./validate").Schema;
+export type ValidationErrorConfiguration =
+  import("./validate").ValidationErrorConfiguration;
+export type PostFormatter = import("./validate").PostFormatter;
+export type SchemaUtilErrorObject = import("./validate").SchemaUtilErrorObject;
+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;
+}
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/index.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/index.d.ts
@ -0,0 +1,3 @@
+import { validate } from "./validate";
+import { ValidationError } from "./validate";
+export { validate, ValidationError };
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/keywords/absolutePath.d.ts
@ -0,0 +1,10 @@
+export default addAbsolutePathKeyword;
+export type Ajv = import("ajv").Ajv;
+export type ValidateFunction = import("ajv").ValidateFunction;
+export type SchemaUtilErrorObject = import("../validate").SchemaUtilErrorObject;
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addAbsolutePathKeyword(ajv: Ajv): Ajv;
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/util/Range.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/util/Range.d.ts
@ -0,0 +1,79 @@
+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<RangeValue>, logic: boolean): RangeValue;
+  /** @type {Array<RangeValue>} */
+  _left: Array<RangeValue>;
+  /** @type {Array<RangeValue>} */
+  _right: Array<RangeValue>;
+  /**
+   * @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: RangeValue) => boolean;
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/util/hints.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/util/hints.d.ts
@ -0,0 +1,3 @@
+export function stringHints(schema: Schema, logic: boolean): string[];
+export function numberHints(schema: Schema, logic: boolean): string[];
+export type Schema = import("../validate").Schema;
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/validate.d.ts
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/declarations/validate.d.ts
@ -0,0 +1,37 @@
+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;
+  link?: string | undefined;
+};
+export type Schema = (JSONSchema4 | JSONSchema6 | JSONSchema7) & Extend;
+export type SchemaUtilErrorObject = ErrorObject & {
+  children?: Array<ErrorObject>;
+};
+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}
+ */
+export function validate(
+  schema: Schema,
+  options: Array<object> | object,
+  configuration?: ValidationErrorConfiguration | undefined
+): void;
+import ValidationError from "./ValidationError";
+export { ValidationError };
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/ValidationError.js
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/ValidationError.js
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/index.js
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/index.js
@ -0,0 +1,11 @@
+"use strict";
+
+const {
+  validate,
+  ValidationError
+} = require("./validate");
+
+module.exports = {
+  validate,
+  ValidationError
+};
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/keywords/absolutePath.js
+++ b/web/node_modules/eslint-webpack-plugin/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;
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/util/Range.js
+++ b/web/node_modules/eslint-webpack-plugin/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;
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/util/hints.js
+++ b/web/node_modules/eslint-webpack-plugin/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;
+};
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/validate.js
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/dist/validate.js
@ -0,0 +1,163 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = validate;
+Object.defineProperty(exports, "ValidationError", {
+  enumerable: true,
+  get: function () {
+    return _ValidationError.default;
+  }
+});
+
+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
+ * @property {string=} link
+ */
+
+/** @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;
+}
--- a/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/package.json
+++ b/web/node_modules/eslint-webpack-plugin/node_modules/schema-utils/package.json
@ -0,0 +1,78 @@
+{
+  "name": "schema-utils",
+  "version": "3.1.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": ">= 10.13.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 --production",
+    "fmt:check": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
+    "lint:js": "eslint --cache .",
+    "lint:types": "tsc --pretty --noEmit",
+    "lint": "npm-run-all lint:js lint:types fmt:check",
+    "fmt": "npm run fmt:check -- --write",
+    "fix:js": "npm run lint:js -- --fix",
+    "fix": "npm-run-all fix:js fmt",
+    "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 && husky install",
+    "release": "standard-version"
+  },
+  "files": [
+    "dist",
+    "declarations"
+  ],
+  "dependencies": {
+    "@types/json-schema": "^7.0.8",
+    "ajv": "^6.12.5",
+    "ajv-keywords": "^3.5.2"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.14.3",
+    "@babel/core": "^7.14.6",
+    "@babel/preset-env": "^7.14.7",
+    "@commitlint/cli": "^12.1.4",
+    "@commitlint/config-conventional": "^12.1.4",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^27.0.6",
+    "cross-env": "^7.0.3",
+    "del": "^6.0.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.31.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.23.4",
+    "husky": "^6.0.0",
+    "jest": "^27.0.6",
+    "lint-staged": "^11.0.1",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.3.2",
+    "standard-version": "^9.3.1",
+    "typescript": "^4.3.5",
+    "webpack": "^5.45.1"
+  },
+  "keywords": [
+    "webpack"
+  ]
+}
--- a/web/node_modules/eslint-webpack-plugin/package.json
+++ b/web/node_modules/eslint-webpack-plugin/package.json
@ -0,0 +1,96 @@
+{
+  "name": "eslint-webpack-plugin",
+  "version": "2.5.4",
+  "description": "A ESLint plugin for webpack",
+  "license": "MIT",
+  "repository": "webpack-contrib/eslint-webpack-plugin",
+  "author": "Ricardo Gobbo de Souza <ricardogobbosouza@yahoo.com.br>",
+  "homepage": "https://github.com/webpack-contrib/eslint-webpack-plugin",
+  "bugs": "https://github.com/webpack-contrib/eslint-webpack-plugin/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/cjs.js",
+  "types": "declarations/index.d.ts",
+  "engines": {
+    "node": ">= 10.13.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 -w --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 --testTimeout=60000",
+    "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"
+  },
+  "files": [
+    "dist",
+    "declarations"
+  ],
+  "peerDependencies": {
+    "eslint": "^7.0.0",
+    "webpack": "^4.0.0 || ^5.0.0"
+  },
+  "dependencies": {
+    "@types/eslint": "^7.2.6",
+    "arrify": "^2.0.1",
+    "jest-worker": "^26.6.2",
+    "micromatch": "^4.0.2",
+    "normalize-path": "^3.0.0",
+    "schema-utils": "^3.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.12.10",
+    "@babel/core": "^7.12.10",
+    "@babel/preset-env": "^7.12.11",
+    "@commitlint/cli": "^11.0.0",
+    "@commitlint/config-conventional": "^11.0.0",
+    "@types/fs-extra": "^9.0.6",
+    "@types/micromatch": "^4.0.1",
+    "@types/normalize-path": "^3.0.0",
+    "@types/webpack": "^4.41.26",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-eslint": "^10.1.0",
+    "babel-jest": "^26.6.3",
+    "chokidar": "^3.5.1",
+    "cross-env": "^7.0.3",
+    "del": "^6.0.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.19.0",
+    "eslint-config-prettier": "^7.2.0",
+    "eslint-plugin-import": "^2.22.1",
+    "fs-extra": "^9.1.0",
+    "husky": "^4.3.8",
+    "jest": "^26.6.3",
+    "lint-staged": "^10.5.3",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.2.1",
+    "standard-version": "^9.1.0",
+    "typescript": "^4.1.3",
+    "webpack": "^5.19.0"
+  },
+  "keywords": [
+    "eslint",
+    "lint",
+    "linter",
+    "plugin",
+    "webpack"
+  ],
+  "jest": {
+    "testTimeout": 60000
+  }
+}