Merge remote-tracking branch 'upstream/main'

frontend/node_modules/compression-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.

frontend/node_modules/compression-webpack-plugin/README.md

@@ -0,0 +1,487 @@
+<div align="center">
+  <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]
+[![cover][cover]][cover-url]
+[![chat][chat]][chat-url]
+[![size][size]][size-url]
+
+# compression-webpack-plugin
+
+Prepare compressed versions of assets to serve them with Content-Encoding.
+
+## Getting Started
+
+To begin, you'll need to install `compression-webpack-plugin`:
+
+```console
+$ npm install compression-webpack-plugin --save-dev
+```
+
+Then add the plugin to your `webpack` config. For example:
+
+**webpack.config.js**
+
+```js
+const CompressionPlugin = require("compression-webpack-plugin");
+
+module.exports = {
+  plugins: [new CompressionPlugin()],
+};
+```
+
+And run `webpack` via your preferred method.
+
+## Options
+
+|                        Name                         |                   Type                    |                            Default                            | Description                                                                                                   |
+| :-------------------------------------------------: | :---------------------------------------: | :-----------------------------------------------------------: | :------------------------------------------------------------------------------------------------------------ |
+|                 **[`test`](#test)**                 | `{String\|RegExp\|Array<String\|RegExp>}` |                          `undefined`                          | Include all assets that pass test assertion                                                                   |
+|              **[`include`](#include)**              | `{String\|RegExp\|Array<String\|RegExp>}` |                          `undefined`                          | Include all assets matching any of these conditions                                                           |
+|              **[`exclude`](#exclude)**              | `{String\|RegExp\|Array<String\|RegExp>}` |                          `undefined`                          | Exclude all assets matching any of these conditions                                                           |
+|            **[`algorithm`](#algorithm)**            |           `{String\|Function}`            |                            `gzip`                             | The compression algorithm/function                                                                            |
+|   **[`compressionOptions`](#compressionoptions)**   |                `{Object}`                 | maximum available compression level, for gzip: `{ level: 9 }` | Compression options for `algorithm`                                                                           |
+|            **[`threshold`](#threshold)**            |                `{Number}`                 |                              `0`                              | Only assets bigger than this size are processed (in bytes)                                                    |
+|             **[`minRatio`](#minratio)**             |                `{Number}`                 |                             `0.8`                             | Only assets that compress better than this ratio are processed (`minRatio = Compressed Size / Original Size`) |
+|             **[`filename`](#filename)**             |           `{String\|Function}`            |                       `[path][base].gz`                       | The target asset filename                                                                                     |
+| **[`deleteOriginalAssets`](#deleteoriginalassets)** |      `{Boolean\|'keep-source-map'}`       |                            `false`                            | Whether to delete the original assets or not                                                                  |
+|                **[`cache`](#cache)**                |                `{Boolean}`                |                            `true`                             | Enable file caching                                                                                           |
+
+### `test`
+
+Type: `String|RegExp|Array<String|RegExp>`
+Default: `undefined`
+
+Include all assets that pass test assertion.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      test: /\.js(\?.*)?$/i,
+    }),
+  ],
+};
+```
+
+### `include`
+
+Type: `String|RegExp|Array<String|RegExp>`
+Default: `undefined`
+
+Include all assets matching any of these conditions.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      include: /\/includes/,
+    }),
+  ],
+};
+```
+
+### `exclude`
+
+Type: `String|RegExp|Array<String|RegExp>`
+Default: `undefined`
+
+Exclude all assets matching any of these conditions.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      exclude: /\/excludes/,
+    }),
+  ],
+};
+```
+
+### `algorithm`
+
+Type: `String|Function`
+Default: `gzip`
+
+The compression algorithm/function.
+
+> ℹ️ If you use custom function for the `algorithm` option, the default value of the `compressionOptions` option is `{}`.
+
+#### `String`
+
+The algorithm is taken from [zlib](https://nodejs.org/api/zlib.html).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      algorithm: "gzip",
+    }),
+  ],
+};
+```
+
+#### `Function`
+
+Allow to specify a custom compression function.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      algorithm(input, compressionOptions, callback) {
+        return compressionFunction(input, compressionOptions, callback);
+      },
+    }),
+  ],
+};
+```
+
+### `compressionOptions`
+
+Type: `Object`
+Default: `{ level: 9 }`
+
+Compression options for `algorithm`.
+
+You can find all options here [zlib](https://nodejs.org/api/zlib.html#zlib_class_options).
+
+> ℹ️ If you use custom function for the `algorithm` option, the default value is `{}`.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      compressionOptions: { level: 1 },
+    }),
+  ],
+};
+```
+
+### `threshold`
+
+Type: `Number`
+Default: `0`
+
+Only assets bigger than this size are processed. In bytes.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      threshold: 8192,
+    }),
+  ],
+};
+```
+
+### `minRatio`
+
+Type: `Number`
+Default: `0.8`
+
+Only assets that compress better than this ratio are processed (`minRatio = Compressed Size / Original Size`).
+Example: you have `image.png` file with 1024b size, compressed version of file has 768b size, so `minRatio` equal `0.75`.
+In other words assets will be processed when the `Compressed Size / Original Size` value less `minRatio` value.
+
+You can use `1` value to process assets that are smaller than the original.
+
+Use a value of `Infinity` to process all assets even if they are larger than the original size or their original size is `0` bytes (useful when you are pre-zipping all assets for AWS).
+
+Use a value of `Number.MAX_SAFE_INTEGER` to process all assets even if they are larger than the original size, excluding assets with their original size is `0` bytes.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      // Compress all assets, including files with `0` bytes size
+      // minRatio: Infinity
+
+      // Compress all assets, excluding files with `0` bytes size
+      // minRatio: Number.MAX_SAFE_INTEGER
+
+      minRatio: 0.8,
+    }),
+  ],
+};
+```
+
+### `filename`
+
+Type: `String|Function`
+Default: `"[path][base].gz"`
+
+The target asset filename.
+
+#### `String`
+
+For example we have `assets/images/image.png?foo=bar#hash`:
+
+`[path]` is replaced with the directories to the original asset, included trailing `/` (`assets/images/`).
+
+`[file]` is replaced with the path of original asset (`assets/images/image.png`).
+
+`[base]` is replaced with the base (`[name]` + `[ext]`) of the original asset (`image.png`).
+
+`[name]` is replaced with the name of the original asset (`image`).
+
+`[ext]` is replaced with the extension of the original asset, included `.` (`.png`).
+
+`[query]` is replaced with the query of the original asset, included `?` (`?foo=bar`).
+
+`[fragment]` is replaced with the fragment (in the concept of URL it is called `hash`) of the original asset (`#hash`).
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      filename: "[path][base].gz",
+    }),
+  ],
+};
+```
+
+#### `Function`
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      filename(pathData) {
+        // The `pathData` argument contains all placeholders - `path`/`name`/`ext`/etc
+        // Available properties described above, for the `String` notation
+        if (/\.svg$/.test(pathData.file)) {
+          return "assets/svg/[path][base].gz";
+        }
+
+        return "assets/js/[path][base].gz";
+      },
+    }),
+  ],
+};
+```
+
+### `deleteOriginalAssets`
+
+Type: `Boolean | 'keep-source-map'`
+Default: `false`
+
+Whether to delete the original assets or not.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      deleteOriginalAssets: true,
+    }),
+  ],
+};
+```
+
+To exclude sourcemaps from compression
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      exclude: /.map$/
+      deleteOriginalAssets: 'keep-source-map',
+    }),
+  ],
+};
+```
+
+### `cache`
+
+> ⚠ Ignored in webpack 5! Please use https://webpack.js.org/configuration/other-options/#cache.
+
+Type: `Boolean|String`
+Default: `true`
+
+Enable file caching.
+The default path to cache directory: `node_modules/.cache/compression-webpack-plugin`.
+
+#### `Boolean`
+
+Enable/disable file caching.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      cache: true,
+    }),
+  ],
+};
+```
+
+#### `String`
+
+Enable file caching and set path to cache directory.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      cache: "path/to/cache",
+    }),
+  ],
+};
+```
+
+## Examples
+
+### Using Zopfli
+
+Prepare compressed versions of assets using `zopfli` library.
+
+> ℹ️ `@gfx/zopfli` require minimum `8` version of `node`.
+
+To begin, you'll need to install `@gfx/zopfli`:
+
+```console
+$ npm install @gfx/zopfli --save-dev
+```
+
+**webpack.config.js**
+
+```js
+const zopfli = require("@gfx/zopfli");
+
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      compressionOptions: {
+        numiterations: 15,
+      },
+      algorithm(input, compressionOptions, callback) {
+        return zopfli.gzip(input, compressionOptions, callback);
+      },
+    }),
+  ],
+};
+```
+
+### Using Brotli
+
+[Brotli](https://en.wikipedia.org/wiki/Brotli) is a compression algorithm originally developed by Google, and offers compression superior to gzip.
+
+Node 10.16.0 and later has [native support](https://nodejs.org/api/zlib.html#zlib_zlib_createbrotlicompress_options) for Brotli compression in its zlib module.
+
+We can take advantage of this built-in support for Brotli in Node 10.16.0 and later by just passing in the appropriate `algorithm` to the CompressionPlugin:
+
+**webpack.config.js**
+
+```js
+const zlib = require("zlib");
+
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      filename: "[path][base].br",
+      algorithm: "brotliCompress",
+      test: /\.(js|css|html|svg)$/,
+      compressionOptions: {
+        params: {
+          [zlib.constants.BROTLI_PARAM_QUALITY]: 11,
+        },
+      },
+      threshold: 10240,
+      minRatio: 0.8,
+      deleteOriginalAssets: false,
+    }),
+  ],
+};
+```
+
+**Note** Brotli’s `BROTLI_PARAM_QUALITY` option is functionally equivalent to zlib’s `level` option.
+You can find all Brotli’s options in [the relevant part of the zlib module documentation](https://nodejs.org/api/zlib.html#zlib_class_brotlioptions).
+
+### Multiple compressed versions of assets for different algorithm
+
+**webpack.config.js**
+
+```js
+const zlib = require("zlib");
+
+module.exports = {
+  plugins: [
+    new CompressionPlugin({
+      filename: "[path][base].gz",
+      algorithm: "gzip",
+      test: /\.js$|\.css$|\.html$/,
+      threshold: 10240,
+      minRatio: 0.8,
+    }),
+    new CompressionPlugin({
+      filename: "[path][base].br",
+      algorithm: "brotliCompress",
+      test: /\.(js|css|html|svg)$/,
+      compressionOptions: {
+        params: {
+          [zlib.constants.BROTLI_PARAM_QUALITY]: 11,
+        },
+      },
+      threshold: 10240,
+      minRatio: 0.8,
+    }),
+  ],
+};
+```
+
+## 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/compression-webpack-plugin.svg
+[npm-url]: https://npmjs.com/package/compression-webpack-plugin
+[node]: https://img.shields.io/node/v/compression-webpack-plugin.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack-contrib/compression-webpack-plugin.svg
+[deps-url]: https://david-dm.org/webpack-contrib/compression-webpack-plugin
+[tests]: https://github.com/webpack-contrib/compression-webpack-plugin/workflows/compression-webpack-plugin/badge.svg
+[tests-url]: https://github.com/webpack-contrib/compression-webpack-plugin/actions
+[cover]: https://codecov.io/gh/webpack-contrib/compression-webpack-plugin/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack-contrib/compression-webpack-plugin
+[chat]: https://img.shields.io/badge/gitter-webpack%2Fwebpack-brightgreen.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.now.sh/badge?p=compression-webpack-plugin
+[size-url]: https://packagephobia.now.sh/result?p=compression-webpack-plugin

frontend/node_modules/compression-webpack-plugin/dist/Webpack4Cache.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _os = _interopRequireDefault(require("os"));
+
+var _cacache = _interopRequireDefault(require("cacache"));
+
+var _findCacheDir = _interopRequireDefault(require("find-cache-dir"));
+
+var _serializeJavascript = _interopRequireDefault(require("serialize-javascript"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+class Webpack4Cache {
+  constructor(compilation, options, weakCache) {
+    this.cache = options.cache === true ? Webpack4Cache.getCacheDirectory() : options.cache;
+    this.weakCache = weakCache;
+  }
+
+  static getCacheDirectory() {
+    return (0, _findCacheDir.default)({
+      name: "compression-webpack-plugin"
+    }) || _os.default.tmpdir();
+  }
+
+  async get(cacheData, {
+    RawSource
+  }) {
+    if (!this.cache) {
+      // eslint-disable-next-line no-undefined
+      return undefined;
+    }
+
+    const weakOutput = this.weakCache.get(cacheData.inputSource);
+
+    if (weakOutput) {
+      return weakOutput;
+    } // eslint-disable-next-line no-param-reassign
+
+
+    cacheData.cacheIdent = cacheData.cacheIdent || (0, _serializeJavascript.default)(cacheData.cacheKeys);
+    let cachedResult;
+
+    try {
+      cachedResult = await _cacache.default.get(this.cache, cacheData.cacheIdent);
+    } catch (ignoreError) {
+      // eslint-disable-next-line no-undefined
+      return undefined;
+    }
+
+    return new RawSource(Buffer.from(JSON.parse(cachedResult.data).data));
+  }
+
+  async store(cacheData) {
+    if (!this.cache) {
+      // eslint-disable-next-line no-undefined
+      return undefined;
+    }
+
+    if (!this.weakCache.has(cacheData.inputSource)) {
+      this.weakCache.set(cacheData.inputSource, cacheData.output);
+    }
+
+    const {
+      cacheIdent,
+      output
+    } = cacheData;
+    return _cacache.default.put(this.cache, cacheIdent, JSON.stringify(output.source()));
+  }
+
+}
+
+exports.default = Webpack4Cache;

frontend/node_modules/compression-webpack-plugin/dist/Webpack5Cache.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+class Cache {
+  constructor(compilation) {
+    this.cache = compilation.getCache("CompressionWebpackPlugin");
+  }
+
+  async get(cacheData) {
+    // eslint-disable-next-line no-param-reassign
+    cacheData.eTag = cacheData.eTag || this.cache.getLazyHashedEtag(cacheData.inputSource);
+    return this.cache.getPromise(cacheData.name, cacheData.eTag);
+  }
+
+  async store(cacheData) {
+    return this.cache.storePromise(cacheData.name, cacheData.eTag, cacheData.output);
+  }
+
+}
+
+exports.default = Cache;

frontend/node_modules/compression-webpack-plugin/dist/cjs.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./index").default;

frontend/node_modules/compression-webpack-plugin/dist/index.js

@@ -0,0 +1,377 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _webpack = _interopRequireWildcard(require("webpack"));
+
+var _schemaUtils = require("schema-utils");
+
+var _serializeJavascript = _interopRequireDefault(require("serialize-javascript"));
+
+var _options = _interopRequireDefault(require("./options.json"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/
+const internalCreateHash = algorithm => {
+  try {
+    // eslint-disable-next-line global-require import/no-unresolved
+    const createHash = require("webpack/lib/util/createHash");
+
+    return createHash(algorithm);
+  } catch (err) {// Ignore
+  }
+
+  return require("crypto").createHash(algorithm);
+};
+
+const {
+  RawSource
+} = // eslint-disable-next-line global-require
+_webpack.default.sources || require("webpack-sources");
+
+class CompressionPlugin {
+  constructor(options = {}) {
+    (0, _schemaUtils.validate)(_options.default, options, {
+      name: "Compression Plugin",
+      baseDataPath: "options"
+    });
+    const {
+      test,
+      include,
+      exclude,
+      cache = true,
+      algorithm = "gzip",
+      compressionOptions = {},
+      filename = "[path][base].gz",
+      threshold = 0,
+      minRatio = 0.8,
+      deleteOriginalAssets = false
+    } = options;
+    this.options = {
+      test,
+      include,
+      exclude,
+      cache,
+      algorithm,
+      compressionOptions,
+      filename,
+      threshold,
+      minRatio,
+      deleteOriginalAssets
+    };
+    this.algorithm = this.options.algorithm;
+
+    if (typeof this.algorithm === "string") {
+      // eslint-disable-next-line global-require
+      const zlib = require("zlib");
+
+      this.algorithm = zlib[this.algorithm];
+
+      if (!this.algorithm) {
+        throw new Error(`Algorithm "${this.options.algorithm}" is not found in "zlib"`);
+      }
+
+      const defaultCompressionOptions = {
+        gzip: {
+          level: zlib.constants.Z_BEST_COMPRESSION
+        },
+        deflate: {
+          level: zlib.constants.Z_BEST_COMPRESSION
+        },
+        deflateRaw: {
+          level: zlib.constants.Z_BEST_COMPRESSION
+        },
+        brotliCompress: {
+          params: {
+            [zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY
+          }
+        }
+      }[algorithm] || {};
+      this.options.compressionOptions = { ...defaultCompressionOptions,
+        ...this.options.compressionOptions
+      };
+    }
+  } // eslint-disable-next-line consistent-return
+
+
+  static getAsset(compilation, name) {
+    // New API
+    if (compilation.getAsset) {
+      return compilation.getAsset(name);
+    }
+
+    if (compilation.assets[name]) {
+      return {
+        name,
+        source: compilation.assets[name],
+        info: {}
+      };
+    }
+  }
+
+  static emitAsset(compilation, name, source, assetInfo) {
+    // New API
+    if (compilation.emitAsset) {
+      compilation.emitAsset(name, source, assetInfo);
+    } // eslint-disable-next-line no-param-reassign
+
+
+    compilation.assets[name] = source;
+  }
+
+  static updateAsset(compilation, name, newSource, assetInfo) {
+    // New API
+    if (compilation.updateAsset) {
+      compilation.updateAsset(name, newSource, assetInfo);
+    } // eslint-disable-next-line no-param-reassign
+
+
+    compilation.assets[name] = newSource;
+  }
+
+  static deleteAsset(compilation, name) {
+    // New API
+    if (compilation.deleteAsset) {
+      compilation.deleteAsset(name);
+    } // eslint-disable-next-line no-param-reassign
+
+
+    delete compilation.assets[name];
+  }
+
+  runCompressionAlgorithm(input) {
+    return new Promise((resolve, reject) => {
+      this.algorithm(input, this.options.compressionOptions, (error, result) => {
+        if (error) {
+          return reject(error);
+        }
+
+        if (!Buffer.isBuffer(result)) {
+          // eslint-disable-next-line no-param-reassign
+          result = Buffer.from(result);
+        }
+
+        return resolve(result);
+      });
+    });
+  }
+
+  async compress(compilation, assets, CacheEngine, weakCache) {
+    const assetNames = Object.keys(typeof assets === "undefined" ? compilation.assets : assets).filter(assetName => // eslint-disable-next-line no-undefined
+    _webpack.ModuleFilenameHelpers.matchObject.bind(undefined, this.options)(assetName));
+
+    if (assetNames.length === 0) {
+      return Promise.resolve();
+    }
+
+    const scheduledTasks = [];
+    const cache = new CacheEngine(compilation, {
+      cache: this.options.cache
+    }, weakCache);
+
+    for (const name of assetNames) {
+      scheduledTasks.push((async () => {
+        const {
+          source: inputSource,
+          info
+        } = CompressionPlugin.getAsset(compilation, name);
+
+        if (info.compressed) {
+          return;
+        }
+
+        let relatedName;
+
+        if (typeof this.options.algorithm === "function") {
+          let filenameForRelatedName = this.options.filename;
+          const index = filenameForRelatedName.lastIndexOf("?");
+
+          if (index >= 0) {
+            filenameForRelatedName = filenameForRelatedName.substr(0, index);
+          }
+
+          relatedName = `${_path.default.extname(filenameForRelatedName).slice(1)}ed`;
+        } else if (this.options.algorithm === "gzip") {
+          relatedName = "gzipped";
+        } else {
+          relatedName = `${this.options.algorithm}ed`;
+        }
+
+        if (info.related && info.related[relatedName]) {
+          return;
+        }
+
+        let input = inputSource.source();
+
+        if (!Buffer.isBuffer(input)) {
+          input = Buffer.from(input);
+        }
+
+        if (input.length < this.options.threshold) {
+          return;
+        }
+
+        const cacheData = {
+          inputSource
+        };
+
+        if (CompressionPlugin.isWebpack4()) {
+          cacheData.cacheKeys = {
+            nodeVersion: process.version,
+            // eslint-disable-next-line global-require
+            "compression-webpack-plugin": require("../package.json").version,
+            algorithm: this.algorithm,
+            originalAlgorithm: this.options.algorithm,
+            compressionOptions: this.options.compressionOptions,
+            name,
+            contentHash: internalCreateHash("md4").update(input).digest("hex")
+          };
+        } else {
+          cacheData.name = (0, _serializeJavascript.default)({
+            name,
+            algorithm: this.options.algorithm,
+            compressionOptions: this.options.compressionOptions
+          });
+        }
+
+        let output = await cache.get(cacheData, {
+          RawSource
+        });
+
+        if (!output) {
+          try {
+            output = new RawSource(await this.runCompressionAlgorithm(input));
+          } catch (error) {
+            compilation.errors.push(error);
+            return;
+          }
+
+          cacheData.output = output;
+          await cache.store(cacheData);
+        }
+
+        if (output.source().length / input.length > this.options.minRatio) {
+          return;
+        }
+
+        const match = /^([^?#]*)(\?[^#]*)?(#.*)?$/.exec(name);
+        const [, replacerFile] = match;
+        const replacerQuery = match[2] || "";
+        const replacerFragment = match[3] || "";
+
+        const replacerExt = _path.default.extname(replacerFile);
+
+        const replacerBase = _path.default.basename(replacerFile);
+
+        const replacerName = replacerBase.slice(0, replacerBase.length - replacerExt.length);
+        const replacerPath = replacerFile.slice(0, replacerFile.length - replacerBase.length);
+        const pathData = {
+          file: replacerFile,
+          query: replacerQuery,
+          fragment: replacerFragment,
+          path: replacerPath,
+          base: replacerBase,
+          name: replacerName,
+          ext: replacerExt || ""
+        };
+        let newFilename = this.options.filename;
+
+        if (typeof newFilename === "function") {
+          newFilename = newFilename(pathData);
+        }
+
+        const newName = newFilename.replace(/\[(file|query|fragment|path|base|name|ext)]/g, (p0, p1) => pathData[p1]);
+        const newInfo = {
+          compressed: true
+        };
+
+        if (info.immutable && /(\[name]|\[base]|\[file])/.test(newFilename)) {
+          newInfo.immutable = true;
+        }
+
+        if (this.options.deleteOriginalAssets) {
+          if (this.options.deleteOriginalAssets === "keep-source-map") {
+            // TODO `...` required only for webpack@4
+            const updatedAssetInfo = { ...info,
+              related: { ...info.related,
+                sourceMap: null
+              }
+            };
+            CompressionPlugin.updateAsset(compilation, name, inputSource, updatedAssetInfo);
+          }
+
+          CompressionPlugin.deleteAsset(compilation, name);
+        } else {
+          // TODO `...` required only for webpack@4
+          const newOriginalInfo = { ...info,
+            related: {
+              [relatedName]: newName,
+              ...info.related
+            }
+          };
+          CompressionPlugin.updateAsset(compilation, name, inputSource, newOriginalInfo);
+        }
+
+        CompressionPlugin.emitAsset(compilation, newName, output, newInfo);
+      })());
+    }
+
+    return Promise.all(scheduledTasks);
+  }
+
+  static isWebpack4() {
+    return _webpack.version[0] === "4";
+  }
+
+  apply(compiler) {
+    const pluginName = this.constructor.name;
+
+    if (CompressionPlugin.isWebpack4()) {
+      // eslint-disable-next-line global-require
+      const CacheEngine = require("./Webpack4Cache").default;
+
+      const weakCache = new WeakMap();
+      compiler.hooks.emit.tapPromise({
+        name: pluginName
+      }, compilation => // eslint-disable-next-line no-undefined
+      this.compress(compilation, undefined, CacheEngine, weakCache));
+    } else {
+      // eslint-disable-next-line global-require
+      const CacheEngine = require("./Webpack5Cache").default;
+
+      compiler.hooks.thisCompilation.tap(pluginName, compilation => {
+        // eslint-disable-next-line global-require
+        const Compilation = require("webpack/lib/Compilation");
+
+        compilation.hooks.processAssets.tapPromise({
+          name: pluginName,
+          stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_TRANSFER
+        }, assets => this.compress(compilation, assets, CacheEngine));
+        compilation.hooks.statsPrinter.tap(pluginName, stats => {
+          stats.hooks.print.for("asset.info.compressed").tap("compression-webpack-plugin", (compressed, {
+            green,
+            formatFlag
+          }) => // eslint-disable-next-line no-undefined
+          compressed ? green(formatFlag("compressed")) : undefined);
+        });
+      });
+    }
+  }
+
+}
+
+var _default = CompressionPlugin;
+exports.default = _default;

frontend/node_modules/compression-webpack-plugin/dist/options.json

@@ -0,0 +1,121 @@
+{
+  "additionalProperties": false,
+  "definitions": {
+    "Rule": {
+      "description": "Filtering rule as regex or string.",
+      "anyOf": [
+        {
+          "instanceof": "RegExp",
+          "tsType": "RegExp"
+        },
+        {
+          "type": "string",
+          "minLength": 1
+        }
+      ]
+    },
+    "Rules": {
+      "description": "Filtering rules.",
+      "anyOf": [
+        {
+          "type": "array",
+          "items": {
+            "description": "A rule condition.",
+            "oneOf": [
+              {
+                "$ref": "#/definitions/Rule"
+              }
+            ]
+          }
+        },
+        {
+          "$ref": "#/definitions/Rule"
+        }
+      ]
+    }
+  },
+  "properties": {
+    "test": {
+      "description": "Include all assets that pass test assertion.",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "include": {
+      "description": "Include all assets matching any of these conditions.",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "exclude": {
+      "description": "Exclude all assets matching any of these conditions.",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "algorithm": {
+      "description": "The compression algorithm/function.",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "compressionOptions": {
+      "description": "Compression options for `algorithm`.",
+      "additionalProperties": true,
+      "type": "object"
+    },
+    "threshold": {
+      "description": "Only assets bigger than this size are processed. In bytes.",
+      "type": "number"
+    },
+    "minRatio": {
+      "description": "Only assets that compress better than this ratio are processed (`minRatio = Compressed Size / Original Size`).",
+      "type": "number"
+    },
+    "deleteOriginalAssets": {
+      "description": "Whether to delete the original assets or not.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "enum": ["keep-source-map"]
+        }
+      ]
+    },
+    "filename": {
+      "description": "The target asset filename.",
+      "anyOf": [
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "cache": {
+      "description": "Enable file caching. Ignored in webpack 5, for webpack 5 please use https://webpack.js.org/configuration/other-options/#cache.",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string"
+        }
+      ]
+    }
+  },
+  "type": "object"
+}

frontend/node_modules/compression-webpack-plugin/node_modules/schema-utils/CHANGELOG.md

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

frontend/node_modules/compression-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.

frontend/node_modules/compression-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

frontend/node_modules/compression-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;
+}

frontend/node_modules/compression-webpack-plugin/node_modules/schema-utils/declarations/index.d.ts

@@ -0,0 +1,12 @@
+import { validate } from "./validate";
+import { ValidationError } from "./validate";
+import { enableValidation } from "./validate";
+import { disableValidation } from "./validate";
+import { needValidate } from "./validate";
+export {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate,
+};

frontend/node_modules/compression-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;

frontend/node_modules/compression-webpack-plugin/node_modules/schema-utils/declarations/keywords/undefinedAsNull.d.ts

@@ -0,0 +1,8 @@
+export default addUndefinedAsNullKeyword;
+export type Ajv = import("ajv").Ajv;
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+declare function addUndefinedAsNullKeyword(ajv: Ajv): Ajv;

frontend/node_modules/compression-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;

frontend/node_modules/compression-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;

frontend/node_modules/compression-webpack-plugin/node_modules/schema-utils/declarations/validate.d.ts

@@ -0,0 +1,42 @@
+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 ValidateFunction = import("ajv").ValidateFunction;
+export type Extend = {
+  formatMinimum?: number | undefined;
+  formatMaximum?: number | undefined;
+  formatExclusiveMinimum?: boolean | undefined;
+  formatExclusiveMaximum?: boolean | undefined;
+  link?: string | undefined;
+  undefinedAsNull?: boolean | 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;
+export function enableValidation(): void;
+export function disableValidation(): void;
+export function needValidate(): boolean;
+import ValidationError from "./ValidationError";
+export { ValidationError };

frontend/node_modules/compression-webpack-plugin/node_modules/schema-utils/dist/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate
+} = require("./validate");
+
+module.exports = {
+  validate,
+  ValidationError,
+  enableValidation,
+  disableValidation,
+  needValidate
+};

frontend/node_modules/compression-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;

frontend/node_modules/compression-webpack-plugin/node_modules/schema-utils/dist/keywords/undefinedAsNull.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/** @typedef {import("ajv").Ajv} Ajv */
+
+/**
+ *
+ * @param {Ajv} ajv
+ * @param {string} keyword
+ * @param {any} definition
+ */
+function addKeyword(ajv, keyword, definition) {
+  let customRuleCode;
+
+  try {
+    // @ts-ignore
+    // eslint-disable-next-line global-require
+    customRuleCode = require("ajv/lib/dotjs/custom"); // @ts-ignore
+
+    const {
+      RULES
+    } = ajv;
+    let ruleGroup;
+
+    for (let i = 0; i < RULES.length; i++) {
+      const rg = RULES[i];
+
+      if (typeof rg.type === "undefined") {
+        ruleGroup = rg;
+        break;
+      }
+    }
+
+    const rule = {
+      keyword,
+      definition,
+      custom: true,
+      code: customRuleCode,
+      implements: definition.implements
+    };
+    ruleGroup.rules.unshift(rule);
+    RULES.custom[keyword] = rule;
+    RULES.keywords[keyword] = true;
+    RULES.all[keyword] = true;
+  } catch (e) {// Nothing, fallback
+  }
+}
+/**
+ *
+ * @param {Ajv} ajv
+ * @returns {Ajv}
+ */
+
+
+function addUndefinedAsNullKeyword(ajv) {
+  // There is workaround for old versions of ajv, where `before` is not implemented
+  addKeyword(ajv, "undefinedAsNull", {
+    modifying: true,
+
+    /**
+     * @param {boolean} kwVal
+     * @param {unknown} data
+     * @param {any} parentSchema
+     * @param {string} dataPath
+     * @param {unknown} parentData
+     * @param {number | string} parentDataProperty
+     * @return {boolean}
+     */
+    validate(kwVal, data, parentSchema, dataPath, parentData, parentDataProperty) {
+      if (kwVal && parentSchema && typeof parentSchema.enum !== "undefined" && parentData && typeof parentDataProperty === "number") {
+        const idx =
+        /** @type {number} */
+        parentDataProperty;
+        const parentDataRef =
+        /** @type {any[]} */
+        parentData;
+
+        if (typeof parentDataRef[idx] === "undefined") {
+          parentDataRef[idx] = null;
+        }
+      }
+
+      return true;
+    }
+
+  });
+  return ajv;
+}
+
+var _default = addUndefinedAsNullKeyword;
+exports.default = _default;

frontend/node_modules/compression-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;

frontend/node_modules/compression-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;
+};

frontend/node_modules/compression-webpack-plugin/node_modules/schema-utils/dist/validate.js

@@ -0,0 +1,258 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validate = validate;
+exports.enableValidation = enableValidation;
+exports.disableValidation = disableValidation;
+exports.needValidate = needValidate;
+Object.defineProperty(exports, "ValidationError", {
+  enumerable: true,
+  get: function () {
+    return _ValidationError.default;
+  }
+});
+
+var _absolutePath = _interopRequireDefault(require("./keywords/absolutePath"));
+
+var _undefinedAsNull = _interopRequireDefault(require("./keywords/undefinedAsNull"));
+
+var _ValidationError = _interopRequireDefault(require("./ValidationError"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * @template T
+ * @param fn {(function(): any) | undefined}
+ * @returns {function(): T}
+ */
+const memoize = fn => {
+  let cache = false;
+  /** @type {T} */
+
+  let result;
+  return () => {
+    if (cache) {
+      return result;
+    }
+
+    result =
+    /** @type {function(): any} */
+    fn();
+    cache = true; // Allow to clean up memory for fn
+    // and all dependent resources
+    // eslint-disable-next-line no-undefined, no-param-reassign
+
+    fn = undefined;
+    return result;
+  };
+};
+
+const getAjv = memoize(() => {
+  // Use CommonJS require for ajv libs so TypeScript consumers aren't locked into esModuleInterop (see #110).
+  // eslint-disable-next-line global-require
+  const Ajv = require("ajv"); // eslint-disable-next-line global-require
+
+
+  const ajvKeywords = require("ajv-keywords");
+
+  const ajv = new Ajv({
+    allErrors: true,
+    verbose: true,
+    $data: true
+  });
+  ajvKeywords(ajv, ["instanceof", "formatMinimum", "formatMaximum", "patternRequired"]); // Custom keywords
+
+  (0, _absolutePath.default)(ajv);
+  (0, _undefinedAsNull.default)(ajv);
+  return ajv;
+});
+/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
+
+/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
+
+/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+
+/** @typedef {import("ajv").ErrorObject} ErrorObject */
+
+/** @typedef {import("ajv").ValidateFunction} ValidateFunction */
+
+/**
+ * @typedef {Object} Extend
+ * @property {number=} formatMinimum
+ * @property {number=} formatMaximum
+ * @property {boolean=} formatExclusiveMinimum
+ * @property {boolean=} formatExclusiveMaximum
+ * @property {string=} link
+ * @property {boolean=} undefinedAsNull
+ */
+
+/** @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
+ */
+
+/**
+ * @param {SchemaUtilErrorObject} error
+ * @param {number} idx
+ * @returns {SchemaUtilErrorObject}
+ */
+
+function applyPrefix(error, idx) {
+  // eslint-disable-next-line no-param-reassign
+  error.dataPath = `[${idx}]${error.dataPath}`;
+
+  if (error.children) {
+    error.children.forEach(err => applyPrefix(err, idx));
+  }
+
+  return error;
+}
+
+let skipValidation = false; // We use `process.env.SKIP_VALIDATION` because you can have multiple `schema-utils` with different version,
+// so we want to disable it globally, `process.env` doesn't supported by browsers, so we have the local `skipValidation` variables
+// Enable validation
+
+function enableValidation() {
+  skipValidation = false; // Disable validation for any versions
+
+  if (process && process.env) {
+    process.env.SKIP_VALIDATION = "n";
+  }
+} // Disable validation
+
+
+function disableValidation() {
+  skipValidation = true;
+
+  if (process && process.env) {
+    process.env.SKIP_VALIDATION = "y";
+  }
+} // Check if we need to confirm
+
+
+function needValidate() {
+  if (skipValidation) {
+    return false;
+  }
+
+  if (process && process.env && process.env.SKIP_VALIDATION) {
+    const value = process.env.SKIP_VALIDATION.trim();
+
+    if (/^(?:y|yes|true|1|on)$/i.test(value)) {
+      return false;
+    }
+
+    if (/^(?:n|no|false|0|off)$/i.test(value)) {
+      return true;
+    }
+  }
+
+  return true;
+}
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @param {ValidationErrorConfiguration=} configuration
+ * @returns {void}
+ */
+
+
+function validate(schema, options, configuration) {
+  if (!needValidate()) {
+    return;
+  }
+
+  let errors = [];
+
+  if (Array.isArray(options)) {
+    for (let i = 0; i <= options.length - 1; i++) {
+      errors.push(...validateObject(schema, options[i]).map(err => applyPrefix(err, i)));
+    }
+  } else {
+    errors = validateObject(schema, options);
+  }
+
+  if (errors.length > 0) {
+    throw new _ValidationError.default(errors, schema, configuration);
+  }
+}
+/** @typedef {WeakMap<Schema, ValidateFunction>} */
+
+
+const schemaCache = new WeakMap();
+/**
+ * @param {Schema} schema
+ * @param {Array<object> | object} options
+ * @returns {Array<SchemaUtilErrorObject>}
+ */
+
+function validateObject(schema, options) {
+  let compiledSchema = schemaCache.get(schema);
+
+  if (!compiledSchema) {
+    compiledSchema = getAjv().compile(schema);
+    schemaCache.set(schema, compiledSchema);
+  }
+
+  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;
+}

frontend/node_modules/compression-webpack-plugin/node_modules/schema-utils/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "schema-utils",
+  "version": "3.3.0",
+  "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"
+  ]
+}

frontend/node_modules/compression-webpack-plugin/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "compression-webpack-plugin",
+  "version": "6.1.2",
+  "description": "Prepare compressed versions of assets to serve them with Content-Encoding",
+  "license": "MIT",
+  "repository": "webpack-contrib/compression-webpack-plugin",
+  "author": "Tobias Koppers @sokra",
+  "homepage": "https://github.com/webpack-contrib/compression-webpack-plugin",
+  "bugs": "https://github.com/webpack-contrib/compression-webpack-plugin/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/cjs.js",
+  "engines": {
+    "node": ">= 10.13.0"
+  },
+  "scripts": {
+    "start": "npm run build -- -w",
+    "clean": "del-cli dist",
+    "prebuild": "npm run clean",
+    "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "commitlint": "commitlint --from=master",
+    "security": "npm audit",
+    "lint:prettier": "prettier --list-different .",
+    "lint:js": "eslint --cache .",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "npm run build",
+    "release": "standard-version",
+    "defaults": "webpack-defaults"
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "webpack": "^4.0.0 || ^5.0.0"
+  },
+  "dependencies": {
+    "cacache": "^15.0.5",
+    "find-cache-dir": "^3.3.1",
+    "schema-utils": "^3.0.0",
+    "serialize-javascript": "^5.0.1",
+    "webpack-sources": "^1.4.3"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.12.1",
+    "@babel/core": "^7.12.3",
+    "@babel/preset-env": "^7.12.1",
+    "@commitlint/cli": "^11.0.0",
+    "@commitlint/config-conventional": "^11.0.0",
+    "@gfx/zopfli": "^1.0.15",
+    "@webpack-contrib/defaults": "^6.3.0",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^26.6.3",
+    "cross-env": "^7.0.2",
+    "del": "^6.0.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.13.0",
+    "eslint-config-prettier": "^6.15.0",
+    "eslint-plugin-import": "^2.22.1",
+    "file-loader": "^6.2.0",
+    "husky": "^4.3.0",
+    "jest": "^26.6.3",
+    "lint-staged": "^10.5.1",
+    "memfs": "^3.2.0",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.1.2",
+    "standard-version": "^9.0.0",
+    "webpack": "^5.4.0",
+    "workbox-webpack-plugin": "^6.0.0-alpha.3"
+  },
+  "keywords": [
+    "webpack"
+  ]
+}