Index: frontend/node_modules/terser-webpack-plugin/LICENSE
===================================================================
--- frontend/node_modules/terser-webpack-plugin/LICENSE	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/LICENSE	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -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.
Index: frontend/node_modules/terser-webpack-plugin/README.md
===================================================================
--- frontend/node_modules/terser-webpack-plugin/README.md	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/README.md	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1523 @@
+<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]
+[![tests][tests]][tests-url]
+[![cover][cover]][cover-url]
+[![discussion][discussion]][discussion-url]
+[![size][size]][size-url]
+
+# minimizer-webpack-plugin
+
+This plugin minifies your assets in a webpack build. It ships with several
+built-in minimizers covering JavaScript, JSON, HTML, and CSS — pick one
+with the [`minify`](#minify) option and target the right files with
+[`test`](#test).
+
+JavaScript minimizers:
+
+- [`terser`](https://github.com/terser/terser) — `MinimizerPlugin.terserMinify` (default). The same JavaScript-based minifier that webpack uses out of the box; produces small, well-tested output and supports the full set of `extractComments` modes.
+- [`uglify-js`](https://github.com/mishoo/UglifyJS) — `MinimizerPlugin.uglifyJsMinify`. ES5-only minifier, useful when you specifically need UglifyJS-compatible output. Requires `npm install --save-dev uglify-js`.
+- [`@swc/core`](https://github.com/swc-project/swc) — `MinimizerPlugin.swcMinify`. A very fast Rust-based JavaScript/TypeScript minifier. Requires `npm install --save-dev @swc/core`.
+- [`esbuild`](https://github.com/evanw/esbuild) — `MinimizerPlugin.esbuildMinify`. An extremely fast JS bundler/minifier; legal comments are always preserved (no `extractComments` support). Requires `npm install --save-dev esbuild`.
+
+JSON minimizer:
+
+- `JSON.stringify` — `MinimizerPlugin.jsonMinify`. Built in (no extra dependency); supports `space` and `replacer` options.
+
+HTML minimizers:
+
+- [`html-minifier-terser`](https://github.com/terser/html-minifier-terser) — `MinimizerPlugin.htmlMinifierTerser`. The default HTML minimizer. JavaScript-based, no native dependency. Requires `npm install --save-dev html-minifier-terser`.
+- [`@swc/html`](https://github.com/swc-project/swc) — `MinimizerPlugin.swcMinifyHtml` (full HTML documents) and `MinimizerPlugin.swcMinifyHtmlFragment` (HTML fragments, e.g. `<template>` content). Very fast Rust-based platform for the Web. Requires `npm install --save-dev @swc/html`.
+- [`@minify-html/node`](https://github.com/wilsonzlin/minify-html) — `MinimizerPlugin.minifyHtmlNode`. A Rust HTML minifier optimised for speed and effectiveness. Requires `npm install --save-dev @minify-html/node`.
+
+CSS minimizers:
+
+- [`cssnano`](https://cssnano.github.io/cssnano/) — `MinimizerPlugin.cssnanoMinify`. The default CSS minimizer. Built on top of [PostCSS](https://postcss.org/). Requires `npm install --save-dev cssnano postcss`.
+- [`csso`](https://github.com/css/csso) — `MinimizerPlugin.cssoMinify`. A CSS minifier with structural optimisations. Requires `npm install --save-dev csso`.
+- [`clean-css`](https://github.com/clean-css/clean-css) — `MinimizerPlugin.cleanCssMinify`. A widely-used CSS optimiser. Requires `npm install --save-dev clean-css`.
+- [`esbuild`](https://github.com/evanw/esbuild) — `MinimizerPlugin.esbuildMinifyCss`. Very fast CSS minification using esbuild's CSS loader. Requires `npm install --save-dev esbuild`.
+- [`lightningcss`](https://github.com/parcel-bundler/lightningcss) — `MinimizerPlugin.lightningCssMinify`. A Rust-based CSS parser, transformer, and minifier. Requires `npm install --save-dev lightningcss`.
+- [`@swc/css`](https://github.com/swc-project/swc) — `MinimizerPlugin.swcMinifyCss`. A very fast Rust-based CSS minifier. Requires `npm install --save-dev @swc/css`.
+
+All of the non-default minimizers are declared as **optional** peer
+dependencies — install only the ones you actually use. You can also stack
+multiple `MinimizerPlugin` instances in the same build to handle different
+file types with different minimizers (see [Examples](#examples)).
+
+## Getting Started
+
+Webpack v5 comes with the latest `minimizer-webpack-plugin` out of the box.
+If you are using Webpack v5 or above and wish to customize the options, you will still need to install `minimizer-webpack-plugin`.
+Using Webpack v4, you have to install `terser-webpack-plugin` v4 (`minimizer-webpack-plugin` is only published for Webpack v5+).
+
+To begin, you'll need to install `minimizer-webpack-plugin`:
+
+```console
+npm install minimizer-webpack-plugin --save-dev
+```
+
+or
+
+```console
+yarn add -D minimizer-webpack-plugin
+```
+
+or
+
+```console
+pnpm add -D minimizer-webpack-plugin
+```
+
+Then add the plugin to your `webpack` configuration. For example:
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [new MinimizerPlugin()],
+  },
+};
+```
+
+Finally, run `webpack` using the method you normally use (e.g., via CLI or an npm script).
+
+## Note about source maps
+
+**Works only with `source-map`, `inline-source-map`, `hidden-source-map` and `nosources-source-map` values for the [`devtool`](https://webpack.js.org/configuration/devtool/) option.**
+
+Why?
+
+- `eval` wraps modules in `eval("string")` and the minimizer does not handle strings.
+- `cheap` has no column information and the minimizer generates only a single line, which leaves only a single mapping.
+
+Using supported `devtool` values enable source map generation.
+
+## Options
+
+- **[`test`](#test)**
+- **[`include`](#include)**
+- **[`exclude`](#exclude)**
+- **[`parallel`](#parallel)**
+- **[`minify`](#minify)**
+- **[`minimizerOptions`](#minimizeroptions)**
+- **[`extractComments`](#extractcomments)**
+
+### `test`
+
+Type:
+
+```ts
+type test = string | RegExp | (string | RegExp)[];
+```
+
+Default: `/\.m?js(\?.*)?$/i`
+
+Test to match files against.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        test: /\.js(\?.*)?$/i,
+      }),
+    ],
+  },
+};
+```
+
+### `include`
+
+Type:
+
+```ts
+type include = string | RegExp | (string | RegExp)[];
+```
+
+Default: `undefined`
+
+Files to include.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        include: /\/includes/,
+      }),
+    ],
+  },
+};
+```
+
+### `exclude`
+
+Type:
+
+```ts
+type exclude = string | RegExp | (string | RegExp)[];
+```
+
+Default: `undefined`
+
+Files to exclude.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        exclude: /\/excludes/,
+      }),
+    ],
+  },
+};
+```
+
+### `parallel`
+
+Type:
+
+```ts
+type parallel = boolean | number;
+```
+
+Default: `true`
+
+Use multi-process parallel running to improve the build speed.
+
+Default number of concurrent runs: `os.cpus().length - 1` or `os.availableParallelism() - 1` (if this function is supported).
+
+> **Note**
+>
+> Parallelization can speedup your build significantly and is therefore **highly recommended**.
+
+> **Warning**
+>
+> If you use **Circle CI** or any other environment that doesn't provide the real available count of CPUs then you need to explicitly set up the number of CPUs to avoid `Error: Call retries were exceeded` (see [#143](https://github.com/webpack/minimizer-webpack-plugin/issues/143), [#202](https://github.com/webpack/minimizer-webpack-plugin/issues/202)).
+
+#### `boolean`
+
+Enable/disable multi-process parallel running.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        parallel: true,
+      }),
+    ],
+  },
+};
+```
+
+#### `number`
+
+Enable multi-process parallel running and set number of concurrent runs.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        parallel: 4,
+      }),
+    ],
+  },
+};
+```
+
+### `minify`
+
+Type:
+
+```ts
+type minifyFn = (
+  input: Record<string, string>,
+  sourceMap: import("@jridgewell/trace-mapping").SourceMapInput | undefined,
+  minifyOptions: {
+    module?: boolean | undefined;
+    ecma?: import("terser").ECMA | undefined;
+  },
+  extractComments:
+    | boolean
+    | "all"
+    | "some"
+    | RegExp
+    | ((
+        astNode: any,
+        comment: {
+          value: string;
+          type: "comment1" | "comment2" | "comment3" | "comment4";
+          pos: number;
+          line: number;
+          col: number;
+        },
+      ) => boolean)
+    | {
+        condition?:
+          | boolean
+          | "all"
+          | "some"
+          | RegExp
+          | ((
+              astNode: any,
+              comment: {
+                value: string;
+                type: "comment1" | "comment2" | "comment3" | "comment4";
+                pos: number;
+                line: number;
+                col: number;
+              },
+            ) => boolean)
+          | undefined;
+        filename?: string | ((fileData: any) => string) | undefined;
+        banner?:
+          | string
+          | boolean
+          | ((commentsFile: string) => string)
+          | undefined;
+      }
+    | undefined,
+) => Promise<{
+  code: string;
+  map?: import("@jridgewell/trace-mapping").SourceMapInput | undefined;
+  errors?: (string | Error)[] | undefined;
+  warnings?: (string | Error)[] | undefined;
+  extractedComments?: string[] | undefined;
+}>;
+
+type minify = minifyFn | minifyFn[];
+```
+
+Default: `MinimizerPlugin.terserMinify`
+
+Allows you to override the default minify function.
+By default plugin uses [terser](https://github.com/terser/terser) package.
+Useful for using and testing unpublished versions or forks.
+
+An array of functions can also be provided. Each minimizer can expose a
+`filter(name, info)` helper that decides whether it should run on a given
+asset; the plugin dispatches each asset only to the minimizers whose `filter`
+accepts it (or runs them all when no filter is set). All built-in minimizers
+ship with a `filter` that matches their natural extension, so a single plugin
+instance and a single worker pool can handle JS, CSS, HTML and JSON together
+without juggling multiple `MinimizerPlugin` instances — just widen `test` to
+let those asset types reach the dispatcher:
+
+```js
+new MinimizerPlugin({
+  test: /\.(?:[cm]?js|css|html?|json)(\?.*)?$/i,
+  minify: [
+    MinimizerPlugin.terserMinify,
+    MinimizerPlugin.cssnanoMinify,
+    MinimizerPlugin.htmlMinifierTerser,
+    MinimizerPlugin.jsonMinify,
+  ],
+});
+```
+
+When more than one minimizer in the array claims the same asset, the chain
+semantic still applies: the output of each accepting minimizer is fed as
+input to the next. The [`minimizerOptions`](#minimizeroptions) option may
+be an array (index-paired with `minify`) or a single object reused by every
+minimizer.
+
+The `test` option always defaults to `/\.[cm]?js(\?.*)?$/i`. When you mix
+asset types in a single plugin instance, widen `test` so non-JS assets reach
+the dispatcher (for example `test: /\.(?:[cm]?js|css|html?|json)(\?.*)?$/i`).
+
+> **Warning**
+>
+> **Always use `require` inside `minify` function when `parallel` option enabled**.
+
+#### `function`
+
+**webpack.config.js**
+
+```js
+// Can be async
+const minify = (input, sourceMap, minimizerOptions, extractsComments) => {
+  // The `minimizerOptions` argument contains options from the `minimizerOptions` plugin option
+  // You can use `minimizerOptions.myCustomOption`
+
+  // Custom logic for extract comments
+  const { map, code } = require("uglify-module") // Or require('./path/to/uglify-module')
+    .minify(input, {
+      /* Your options for minification */
+    });
+
+  return { map, code, warnings: [], errors: [], extractedComments: [] };
+};
+
+// Used to regenerate `fullhash`/`chunkhash` between different implementation
+// Example: you fix a bug in custom minimizer/custom function, but unfortunately webpack doesn't know about it, so you will get the same fullhash/chunkhash
+// to avoid this you can provide version of your custom minimizer
+// You don't need if you use only `contenthash`
+minify.getMinimizerVersion = () => {
+  let packageJson;
+
+  try {
+    packageJson = require("uglify-module/package.json");
+  } catch (error) {
+    // Ignore
+  }
+
+  return packageJson && packageJson.version;
+};
+
+// Restrict the minimizer to the assets it can actually handle. The plugin
+// skips assets for which `filter` returns `false` and (when an array of
+// minimizers is used) dispatches each asset only to the minimizers that
+// accept it. Returning `undefined` is treated as accept.
+minify.filter = (name) => /\.[cm]?js(\?.*)?$/i.test(name);
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minimizerOptions: {
+          myCustomOption: true,
+        },
+        minify,
+      }),
+    ],
+  },
+};
+```
+
+#### `array`
+
+If an array of functions is passed to the `minify` option, each asset is
+dispatched to the minimizers whose `filter` accepts it. When more than one
+minimizer accepts the same asset the output of each is fed as input to the
+next one (the chain semantic). The `minimizerOptions` option can be either an
+array of option objects (index-paired with `minify`) or a single object that
+will be shared by all minimizers. Warnings, errors and extracted comments
+from all running minimizers are merged together.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minify: [MinimizerPlugin.terserMinify, MinimizerPlugin.swcMinify],
+        // `minimizerOptions` can be an array of options, one per `minify` entry
+        minimizerOptions: [
+          // Options for `MinimizerPlugin.terserMinify`
+          { mangle: false },
+          // Options for `MinimizerPlugin.swcMinify`
+          {},
+        ],
+      }),
+    ],
+  },
+};
+```
+
+A single plugin instance can also handle multiple asset types — the built-in
+minimizers each ship with a `filter` matching their natural extension, so JS,
+CSS, HTML and JSON can all be minified by one shared worker pool:
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        // `test` still defaults to JS only, so widen it to catch every
+        // asset type you want the dispatcher to consider.
+        test: /\.(?:[cm]?js|css|html?|json)(\?.*)?$/i,
+        minify: [
+          MinimizerPlugin.terserMinify,
+          MinimizerPlugin.cssnanoMinify,
+          MinimizerPlugin.htmlMinifierTerser,
+          MinimizerPlugin.jsonMinify,
+        ],
+      }),
+    ],
+  },
+};
+```
+
+### `minimizerOptions`
+
+Type:
+
+```ts
+interface minimizerOptions {
+  compress?: boolean | CompressOptions;
+  ecma?: ECMA;
+  enclose?: boolean | string;
+  ie8?: boolean;
+  keep_classnames?: boolean | RegExp;
+  keep_fnames?: boolean | RegExp;
+  mangle?: boolean | MangleOptions;
+  module?: boolean;
+  nameCache?: object;
+  format?: FormatOptions;
+  /** @deprecated */
+  output?: FormatOptions;
+  parse?: ParseOptions;
+  safari10?: boolean;
+  sourceMap?: boolean | SourceMapOptions;
+  toplevel?: boolean;
+}
+
+type options = minimizerOptions | minimizerOptions[];
+```
+
+Default: [default](https://github.com/terser/terser#minify-options)
+
+Options for the active minimizer. With the default Terser minify, see Terser's
+[minify options](https://github.com/terser/terser#minify-options).
+
+When the [`minify`](#minify) option is an array of minimizers, `minimizerOptions`
+can also be an array. Each element is passed to the minimizer at the same
+index in the `minify` array. If a single object is provided instead, it is
+reused for every minimizer.
+
+> **Note**
+>
+> `terserOptions` is kept as a deprecated alias of `minimizerOptions` for
+> backwards compatibility — passing either is equivalent. If both are set,
+> `minimizerOptions` wins. Prefer `minimizerOptions` in new code.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minimizerOptions: {
+          ecma: undefined,
+          parse: {},
+          compress: {},
+          mangle: true, // Note `mangle.properties` is `false` by default.
+          module: false,
+          // Deprecated
+          output: null,
+          format: null,
+          toplevel: false,
+          nameCache: null,
+          ie8: false,
+          keep_classnames: undefined,
+          keep_fnames: false,
+          safari10: false,
+        },
+      }),
+    ],
+  },
+};
+```
+
+### `extractComments`
+
+Type:
+
+```ts
+type extractComments =
+  | boolean
+  | string
+  | RegExp
+  | ((
+      astNode: any,
+      comment: {
+        value: string;
+        type: "comment1" | "comment2" | "comment3" | "comment4";
+        pos: number;
+        line: number;
+        col: number;
+      },
+    ) => boolean)
+  | {
+      condition?:
+        | boolean
+        | "all"
+        | "some"
+        | RegExp
+        | ((
+            astNode: any,
+            comment: {
+              value: string;
+              type: "comment1" | "comment2" | "comment3" | "comment4";
+              pos: number;
+              line: number;
+              col: number;
+            },
+          ) => boolean)
+        | undefined;
+      filename?: string | ((fileData: any) => string) | undefined;
+      banner?:
+        | string
+        | boolean
+        | ((commentsFile: string) => string)
+        | undefined;
+    };
+```
+
+Default: `true`
+
+Whether comments shall be extracted to a separate file, (see [details](https://github.com/webpack/webpack/commit/71933e979e51c533b432658d5e37917f9e71595a)).
+
+By default, extract only comments using `/^\**!|@preserve|@license|@cc_on/i` RegExp condition and remove remaining comments.
+
+If the original file is named `foo.js`, then the comments will be stored to `foo.js.LICENSE.txt`.
+
+The `minimizerOptions.format.comments` option specifies whether the comment will be preserved - i.e., it is possible to preserve some comments (e.g. annotations) while extracting others, or even preserve comments that have already been extracted.
+
+#### `boolean`
+
+Enable/disable extracting comments.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        extractComments: true,
+      }),
+    ],
+  },
+};
+```
+
+#### `string`
+
+Extract `all` or `some` (use the `/^\**!|@preserve|@license|@cc_on/i` RegExp) comments.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        extractComments: "all",
+      }),
+    ],
+  },
+};
+```
+
+#### `RegExp`
+
+All comments that match the given expression will be extracted to a separate file.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        extractComments: /@extract/i,
+      }),
+    ],
+  },
+};
+```
+
+#### `function`
+
+All comments that match the given expression will be extracted to a separate file.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        extractComments: (astNode, comment) => {
+          if (/@extract/i.test(comment.value)) {
+            return true;
+          }
+
+          return false;
+        },
+      }),
+    ],
+  },
+};
+```
+
+#### `object`
+
+Allows you to customize condition for extracting comments, and specify the extracted file name and banner.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        extractComments: {
+          condition: /^\**!|@preserve|@license|@cc_on/i,
+          filename: (fileData) =>
+            // The "fileData" argument contains object with "filename", "basename", "query" and "hash"
+            `${fileData.filename}.LICENSE.txt${fileData.query}`,
+          banner: (licenseFile) =>
+            `License information can be found in ${licenseFile}`,
+        },
+      }),
+    ],
+  },
+};
+```
+
+##### `condition`
+
+Type:
+
+```ts
+type condition =
+  | boolean
+  | "all"
+  | "some"
+  | RegExp
+  | ((
+      astNode: any,
+      comment: {
+        value: string;
+        type: "comment1" | "comment2" | "comment3" | "comment4";
+        pos: number;
+        line: number;
+        col: number;
+      },
+    ) => boolean)
+  | undefined;
+```
+
+The condition that determines which comments should be extracted.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        extractComments: {
+          condition: "some",
+          filename: (fileData) =>
+            // The "fileData" argument contains object with "filename", "basename", "query" and "hash"
+            `${fileData.filename}.LICENSE.txt${fileData.query}`,
+          banner: (licenseFile) =>
+            `License information can be found in ${licenseFile}`,
+        },
+      }),
+    ],
+  },
+};
+```
+
+##### `filename`
+
+Type:
+
+```ts
+type filename = string | ((fileData: any) => string) | undefined;
+```
+
+Default: `[file].LICENSE.txt[query]`
+
+Available placeholders: `[file]`, `[query]` and `[filebase]` (`[base]` for webpack 5).
+
+The file where the extracted comments will be stored.
+
+Default is to append the suffix `.LICENSE.txt` to the original filename.
+
+> **Warning**
+>
+> We highly recommend using the `.txt` extension. Using `.js`/`.cjs`/`.mjs` extensions may conflict with existing assets, which leads to broken code.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        extractComments: {
+          condition: /^\**!|@preserve|@license|@cc_on/i,
+          filename: "extracted-comments.js",
+          banner: (licenseFile) =>
+            `License information can be found in ${licenseFile}`,
+        },
+      }),
+    ],
+  },
+};
+```
+
+##### `banner`
+
+Type:
+
+```ts
+type banner = string | boolean | ((commentsFile: string) => string) | undefined;
+```
+
+Default: `/*! For license information please see ${commentsFile} */`
+
+The banner text that points to the extracted file and will be added at the top of the original file.
+
+It can be `false` (no banner), a `String`, or a `function<(string) -> String>` that will be called with the filename where the extracted comments have been stored.
+
+The banner will be wrapped in a comment.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        extractComments: {
+          condition: true,
+          filename: (fileData) =>
+            // The "fileData" argument contains object with "filename", "basename", "query" and "hash"
+            `${fileData.filename}.LICENSE.txt${fileData.query}`,
+          banner: (commentsFile) =>
+            `My custom banner about license information ${commentsFile}`,
+        },
+      }),
+    ],
+  },
+};
+```
+
+## Examples
+
+### Preserve Comments
+
+Extract all legal comments (i.e. `/^\**!|@preserve|@license|@cc_on/i`) and preserve `/@license/i` comments.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minimizerOptions: {
+          format: {
+            comments: /@license/i,
+          },
+        },
+        extractComments: true,
+      }),
+    ],
+  },
+};
+```
+
+### Remove Comments
+
+If you want to build without comments, use this config:
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minimizerOptions: {
+          format: {
+            comments: false,
+          },
+        },
+        extractComments: false,
+      }),
+    ],
+  },
+};
+```
+
+### [`uglify-js`](https://github.com/mishoo/UglifyJS)
+
+[`UglifyJS`](https://github.com/mishoo/UglifyJS) is a JavaScript parser, minifier, compressor and beautifier toolkit.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minify: MinimizerPlugin.uglifyJsMinify,
+        // `minimizerOptions` will be passed to `uglify-js`
+        // Link to options - https://github.com/mishoo/UglifyJS#minify-options
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+### [`swc`](https://github.com/swc-project/swc)
+
+[`swc`](https://github.com/swc-project/swc) is a super-fast compiler written in `Rust`, producing widely supported JavaScript from modern standards and TypeScript.
+
+> **Warning**
+>
+> `extractComments` is supported with `@swc/core >= 1.15.30`.
+> Only serializable extract conditions are supported: booleans, `"some"`, `"all"`, string patterns, `RegExp` values without flags, or object conditions that resolve to those forms.
+> Function conditions and flagged regular expressions are not supported.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minify: MinimizerPlugin.swcMinify,
+        // `minimizerOptions` will be passed to `swc` (`@swc/core`)
+        // Link to options - https://swc.rs/docs/config-js-minify
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+### [`esbuild`](https://github.com/evanw/esbuild)
+
+[`esbuild`](https://github.com/evanw/esbuild) is an extremely fast JavaScript bundler and minifier.
+
+> **Warning**
+>
+> The `extractComments` option is not supported, and all legal comments (i.e. copyright, licenses and etc) will be preserved.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minify: MinimizerPlugin.esbuildMinify,
+        // `minimizerOptions` will be passed to `esbuild`
+        // Link to options - https://esbuild.github.io/api/#minify
+        // Note: the `minify` options is true by default (and override other `minify*` options), so if you want to disable the `minifyIdentifiers` option (or other `minify*` options) please use:
+        // minimizerOptions: {
+        //   minify: false,
+        //   minifyWhitespace: true,
+        //   minifyIdentifiers: false,
+        //   minifySyntax: true,
+        // },
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+### JSON
+
+Uses `JSON.stringify()` to minify your JSON files during the build process.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      // Keeps original terser plugin to minify JS files
+      "...",
+      // Will minify JSON files (they can come from copy-webpack-plugin or when you are using asset modules)
+      new MinimizerPlugin({
+        test: /\.json$/,
+        minify: MinimizerPlugin.jsonMinify,
+        // We are supporting `space` and `replacer` options, you can set them below
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+### HTML
+
+The plugin can minify HTML assets too. Pick one of the bundled HTML
+minimizers and set `test` to match your HTML files.
+
+Available HTML minimizers:
+
+- `MinimizerPlugin.htmlMinifierTerser` — uses [`html-minifier-terser`](https://github.com/terser/html-minifier-terser).
+- `MinimizerPlugin.swcMinifyHtml` — uses [`@swc/html`](https://github.com/swc-project/swc) for full HTML documents (with doctype and `<html>`/`<head>`/`<body>` tags).
+- `MinimizerPlugin.swcMinifyHtmlFragment` — uses [`@swc/html`](https://github.com/swc-project/swc) for HTML fragments (e.g. content inside `<template></template>` or partial HTML strings).
+- `MinimizerPlugin.minifyHtmlNode` — uses [`@minify-html/node`](https://github.com/wilsonzlin/minify-html).
+
+The HTML minimizers are optional peer dependencies — install only the one
+you actually use:
+
+```console
+npm install --save-dev html-minifier-terser
+# or
+npm install --save-dev @swc/html
+# or
+npm install --save-dev @minify-html/node
+```
+
+> **Note**
+>
+> HTML assets typically come from plugins like
+> [`copy-webpack-plugin`](https://github.com/webpack-contrib/copy-webpack-plugin),
+> [`html-webpack-plugin`](https://github.com/jantimon/html-webpack-plugin),
+> or webpack's [asset modules](https://webpack.js.org/guides/asset-modules/).
+
+> **Note**
+>
+> Whitespace handling differs between tools (defaults):
+>
+> - `@swc/html` — removes/collapses whitespace only in safe places (around `html`/`body`, inside `<head>`, between `<meta>`/`<script>`/`<link>` etc.).
+> - `html-minifier-terser` — always collapses multiple whitespaces to a single space (never removes entirely); configurable via [its options](https://github.com/terser/html-minifier-terser#options-quick-reference).
+> - `@minify-html/node` — see [its whitespace docs](https://github.com/wilsonzlin/minify-html#whitespace).
+
+#### `html-minifier-terser`
+
+[`html-minifier-terser`](https://github.com/terser/html-minifier-terser) is a JavaScript-based HTML minifier with no native dependency. It's the default HTML minimizer.
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      // Keeps the default Terser plugin for JS files
+      "...",
+      new MinimizerPlugin({
+        test: /\.html(\?.*)?$/i,
+        minify: MinimizerPlugin.htmlMinifierTerser,
+        // Options - https://github.com/terser/html-minifier-terser#options-quick-reference
+        minimizerOptions: {
+          collapseWhitespace: true,
+          removeComments: true,
+        },
+      }),
+    ],
+  },
+};
+```
+
+#### `@swc/html` — HTML documents
+
+Use `swcMinifyHtml` for complete HTML documents (i.e. with a doctype and `<html>`/`<head>`/`<body>` tags).
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      "...",
+      new MinimizerPlugin({
+        test: /\.html(\?.*)?$/i,
+        minify: MinimizerPlugin.swcMinifyHtml,
+        // Options - https://github.com/swc-project/bindings/blob/main/packages/html/index.ts
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+#### `@swc/html` — HTML fragments
+
+Use `swcMinifyHtmlFragment` for partial HTML — for example, content of `<template></template>` tags or HTML strings that get injected into another document.
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      "...",
+      new MinimizerPlugin({
+        test: /\.template\.html$/i,
+        minify: MinimizerPlugin.swcMinifyHtmlFragment,
+        // Options - https://github.com/swc-project/bindings/blob/main/packages/html/index.ts
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+> **Note**
+>
+> The difference between `swcMinifyHtml` and `swcMinifyHtmlFragment` is the
+> error reporting — invalid or broken syntax is reported at build time.
+
+#### `@minify-html/node`
+
+[`@minify-html/node`](https://github.com/wilsonzlin/minify-html) is a Rust HTML minifier.
+
+**webpack.config.js**
+
+```js
+const Minimizer = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      "...",
+      new Minimizer({
+        test: /\.html(\?.*)?$/i,
+        minify: Minimizer.minifyHtmlNode,
+        // Options - https://github.com/wilsonzlin/minify-html#minification
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+You can also stack multiple `MinimizerPlugin` instances to compress different files with different `minify` functions in the same build (e.g. JS with `terserMinify`, HTML with `htmlMinifierTerser`, JSON with `jsonMinify`).
+
+### CSS
+
+The plugin can minify CSS assets too. Pick one of the bundled CSS
+minimizers and set `test` to match your CSS files.
+
+Available CSS minimizers:
+
+- `MinimizerPlugin.cssnanoMinify` — uses [`cssnano`](https://cssnano.github.io/cssnano/) (via [`postcss`](https://postcss.org/)).
+- `MinimizerPlugin.cssoMinify` — uses [`csso`](https://github.com/css/csso).
+- `MinimizerPlugin.cleanCssMinify` — uses [`clean-css`](https://github.com/clean-css/clean-css).
+- `MinimizerPlugin.esbuildMinifyCss` — uses [`esbuild`](https://github.com/evanw/esbuild) with the CSS loader.
+- `MinimizerPlugin.lightningCssMinify` — uses [`lightningcss`](https://github.com/parcel-bundler/lightningcss).
+- `MinimizerPlugin.swcMinifyCss` — uses [`@swc/css`](https://github.com/swc-project/swc).
+
+The CSS minimizers are optional peer dependencies — install only the ones
+you actually use:
+
+```console
+npm install --save-dev cssnano postcss
+# or
+npm install --save-dev csso
+# or
+npm install --save-dev clean-css
+# or
+npm install --save-dev esbuild
+# or
+npm install --save-dev lightningcss
+# or
+npm install --save-dev @swc/css
+```
+
+> **Note**
+>
+> CSS assets typically come from plugins like
+> [`mini-css-extract-plugin`](https://github.com/webpack-contrib/mini-css-extract-plugin)
+> or webpack's [asset modules](https://webpack.js.org/guides/asset-modules/).
+
+#### `cssnano`
+
+[`cssnano`](https://cssnano.github.io/cssnano/) is the default CSS minimizer. It runs as a [PostCSS](https://postcss.org/) plugin.
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      // Keeps the default Terser plugin for JS files
+      "...",
+      new MinimizerPlugin({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.cssnanoMinify,
+        // Options - https://cssnano.github.io/cssnano/docs/config-file/
+        minimizerOptions: {
+          preset: "default",
+        },
+      }),
+    ],
+  },
+};
+```
+
+#### `csso`
+
+[`csso`](https://github.com/css/csso) is a CSS minifier with structural optimisations.
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      "...",
+      new MinimizerPlugin({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.cssoMinify,
+        // Options - https://github.com/css/csso#minifysource-options
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+#### `clean-css`
+
+[`clean-css`](https://github.com/clean-css/clean-css) is a widely-used CSS optimiser.
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      "...",
+      new MinimizerPlugin({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.cleanCssMinify,
+        // Options - https://github.com/clean-css/clean-css#constructor-options
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+#### `esbuild`
+
+[`esbuild`](https://github.com/evanw/esbuild) ships with a fast CSS minifier (used via its CSS loader).
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      "...",
+      new MinimizerPlugin({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.esbuildMinifyCss,
+        // Options - https://esbuild.github.io/api/#transform-api
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+#### `lightningcss`
+
+[`lightningcss`](https://github.com/parcel-bundler/lightningcss) is a Rust-based CSS parser, transformer, and minifier.
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      "...",
+      new MinimizerPlugin({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.lightningCssMinify,
+        // Options - https://lightningcss.dev/transpilation.html
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+#### `@swc/css`
+
+[`@swc/css`](https://github.com/swc-project/swc) is a Rust-based CSS minifier.
+
+**webpack.config.js**
+
+```js
+const MinimizerPlugin = require("minimizer-webpack-plugin");
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      "...",
+      new MinimizerPlugin({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.swcMinifyCss,
+        // Options - https://github.com/swc-project/bindings/blob/main/packages/css/index.ts
+        minimizerOptions: {},
+      }),
+    ],
+  },
+};
+```
+
+### Custom Minify Function
+
+Override the default minify function - use `uglify-js` for minification.
+
+**webpack.config.js**
+
+```js
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minify: (file, sourceMap) => {
+          // https://github.com/mishoo/UglifyJS2#minify-options
+          const uglifyJsOptions = {
+            /* your `uglify-js` package options */
+          };
+
+          if (sourceMap) {
+            uglifyJsOptions.sourceMap = {
+              content: sourceMap,
+            };
+          }
+
+          return require("uglify-js").minify(file, uglifyJsOptions);
+        },
+      }),
+    ],
+  },
+};
+```
+
+### Typescript
+
+With default Terser minify function:
+
+```ts
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin({
+        minimizerOptions: {
+          compress: true,
+        },
+      }),
+    ],
+  },
+};
+```
+
+With built-in minify functions:
+
+```ts
+import { type JsMinifyOptions as SwcOptions } from "@swc/core";
+import { type MinifyOptions as SwcCssOptions } from "@swc/css";
+import {
+  type FragmentOptions as SwcHtmlFragmentOptions,
+  type Options as SwcHtmlOptions,
+} from "@swc/html";
+import { type OptionsOutput as CleanCssOptions } from "clean-css";
+import { type Options as CssnanoOptions } from "cssnano";
+import { type CompressOptions as CssoOptions } from "csso";
+import { type TransformOptions as EsbuildOptions } from "esbuild";
+import { type Options as HtmlMinifierTerserOptions } from "html-minifier-terser";
+import { type TransformOptions as LightningCssOptions } from "lightningcss";
+import { type MinifyOptions as TerserOptions } from "terser";
+import { type MinifyOptions as UglifyJSOptions } from "uglify-js";
+
+module.exports = {
+  optimization: {
+    minimize: true,
+    minimizer: [
+      new MinimizerPlugin<SwcOptions>({
+        minify: MinimizerPlugin.swcMinify,
+        minimizerOptions: {
+          // `swc` options
+        },
+      }),
+      new MinimizerPlugin<UglifyJSOptions>({
+        minify: MinimizerPlugin.uglifyJsMinify,
+        minimizerOptions: {
+          // `uglif-js` options
+        },
+      }),
+      new MinimizerPlugin<EsbuildOptions>({
+        minify: MinimizerPlugin.esbuildMinify,
+        minimizerOptions: {
+          // `esbuild` options
+        },
+      }),
+
+      // Alternative usage:
+      new MinimizerPlugin<TerserOptions>({
+        minify: MinimizerPlugin.terserMinify,
+        minimizerOptions: {
+          // `terser` options
+        },
+      }),
+
+      // HTML minimizers
+      new MinimizerPlugin<HtmlMinifierTerserOptions>({
+        test: /\.html(\?.*)?$/i,
+        minify: MinimizerPlugin.htmlMinifierTerser,
+        minimizerOptions: {
+          // `html-minifier-terser` options
+        },
+      }),
+      new MinimizerPlugin<SwcHtmlOptions>({
+        test: /\.html(\?.*)?$/i,
+        minify: MinimizerPlugin.swcMinifyHtml,
+        minimizerOptions: {
+          // `@swc/html` options
+        },
+      }),
+      new MinimizerPlugin<SwcHtmlFragmentOptions>({
+        test: /\.template\.html$/i,
+        minify: MinimizerPlugin.swcMinifyHtmlFragment,
+        minimizerOptions: {
+          // `@swc/html` fragment options
+        },
+      }),
+
+      // CSS minimizers
+      new MinimizerPlugin<CssnanoOptions>({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.cssnanoMinify,
+        minimizerOptions: {
+          // `cssnano` options
+        },
+      }),
+      new MinimizerPlugin<CssoOptions>({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.cssoMinify,
+        minimizerOptions: {
+          // `csso` options
+        },
+      }),
+      new MinimizerPlugin<CleanCssOptions>({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.cleanCssMinify,
+        minimizerOptions: {
+          // `clean-css` options
+        },
+      }),
+      new MinimizerPlugin<EsbuildOptions>({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.esbuildMinifyCss,
+        minimizerOptions: {
+          // `esbuild` options (CSS loader)
+        },
+      }),
+      new MinimizerPlugin<LightningCssOptions>({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.lightningCssMinify,
+        minimizerOptions: {
+          // `lightningcss` options
+        },
+      }),
+      new MinimizerPlugin<SwcCssOptions>({
+        test: /\.css(\?.*)?$/i,
+        minify: MinimizerPlugin.swcMinifyCss,
+        minimizerOptions: {
+          // `@swc/css` options
+        },
+      }),
+    ],
+  },
+};
+```
+
+## Contributing
+
+We welcome all contributions!
+If you're new here, please take a moment to review our contributing guidelines before submitting issues or pull requests.
+
+[CONTRIBUTING](https://github.com/webpack/minimizer-webpack-plugin?tab=contributing-ov-file#contributing)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/minimizer-webpack-plugin.svg
+[npm-url]: https://npmjs.com/package/minimizer-webpack-plugin
+[node]: https://img.shields.io/node/v/minimizer-webpack-plugin.svg
+[node-url]: https://nodejs.org
+[tests]: https://github.com/webpack/minimizer-webpack-plugin/workflows/minimizer-webpack-plugin/badge.svg
+[tests-url]: https://github.com/webpack/minimizer-webpack-plugin/actions
+[cover]: https://codecov.io/gh/webpack/minimizer-webpack-plugin/branch/main/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack/minimizer-webpack-plugin
+[discussion]: https://img.shields.io/github/discussions/webpack/webpack
+[discussion-url]: https://github.com/webpack/webpack/discussions
+[size]: https://packagephobia.now.sh/badge?p=minimizer-webpack-plugin
+[size-url]: https://packagephobia.now.sh/result?p=minimizer-webpack-plugin
Index: frontend/node_modules/terser-webpack-plugin/dist/index.js
===================================================================
--- frontend/node_modules/terser-webpack-plugin/dist/index.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/dist/index.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,765 @@
+"use strict";
+
+const os = require("os");
+const path = require("path");
+const {
+  validate
+} = require("schema-utils");
+const {
+  minify
+} = require("./minify");
+const schema = require("./options.json");
+const {
+  cleanCssMinify,
+  cssnanoMinify,
+  cssoMinify,
+  esbuildMinify,
+  esbuildMinifyCss,
+  getEcmaVersion,
+  htmlMinifierTerser,
+  jsonMinify,
+  lightningCssMinify,
+  memoize,
+  minifyHtmlNode,
+  swcMinify,
+  swcMinifyCss,
+  swcMinifyHtml,
+  swcMinifyHtmlFragment,
+  terserMinify,
+  throttleAll,
+  uglifyJsMinify
+} = require("./utils");
+
+/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").Compilation} Compilation */
+/** @typedef {import("webpack").Asset} Asset */
+/** @typedef {import("webpack").AssetInfo} AssetInfo */
+/** @typedef {import("webpack").TemplatePath} TemplatePath */
+/** @typedef {import("jest-worker").Worker} JestWorker */
+/** @typedef {import("@jridgewell/trace-mapping").EncodedSourceMap & { sources: string[], sourcesContent?: string[], file: string }} RawSourceMap */
+/** @typedef {import("@jridgewell/trace-mapping").TraceMap} TraceMap */
+
+/** @typedef {RegExp | string} Rule */
+/** @typedef {Rule[] | Rule} Rules */
+
+// eslint-disable-next-line jsdoc/reject-any-type
+/** @typedef {any} EXPECTED_ANY */
+// eslint-disable-next-line jsdoc/require-property
+/** @typedef {object} EXPECTED_OBJECT */
+
+/**
+ * @callback ExtractCommentsFunction
+ * @param {EXPECTED_ANY} astNode ast Node
+ * @param {{ value: string, type: "comment1" | "comment2" | "comment3" | "comment4", pos: number, line: number, col: number }} comment comment node
+ * @returns {boolean} true when need to extract comment, otherwise false
+ */
+
+/**
+ * @typedef {boolean | "all" | "some" | RegExp | ExtractCommentsFunction} ExtractCommentsCondition
+ */
+
+/**
+ * @typedef {TemplatePath} ExtractCommentsFilename
+ */
+
+/**
+ * @typedef {boolean | string | ((commentsFile: string) => string)} ExtractCommentsBanner
+ */
+
+/**
+ * @typedef {object} ExtractCommentsObject
+ * @property {ExtractCommentsCondition=} condition condition which comments need to be expected
+ * @property {ExtractCommentsFilename=} filename filename for extracted comments
+ * @property {ExtractCommentsBanner=} banner banner in filename for extracted comments
+ */
+
+/**
+ * @typedef {ExtractCommentsCondition | ExtractCommentsObject} ExtractCommentsOptions
+ */
+
+/**
+ * @typedef {object} ErrorObject
+ * @property {string} message message
+ * @property {number=} line line number
+ * @property {number=} column column number
+ * @property {string=} stack error stack trace
+ */
+
+/**
+ * @typedef {object} MinimizedResult
+ * @property {string=} code code
+ * @property {RawSourceMap=} map source map
+ * @property {(Error | string)[]=} errors errors
+ * @property {(Error | string)[]=} warnings warnings
+ * @property {string[]=} extractedComments extracted comments
+ */
+
+/**
+ * @typedef {{ [file: string]: string }} Input
+ */
+
+/**
+ * @typedef {{ [key: string]: EXPECTED_ANY }} CustomOptions
+ */
+
+/**
+ * @template T
+ * @typedef {T extends infer U ? U : CustomOptions} InferDefaultType
+ */
+
+/**
+ * @template T
+ * @typedef {T extends EXPECTED_ANY[] ? { [P in keyof T]?: T[P] & InferDefaultType<T[P]> } : T & InferDefaultType<T>} MinimizerOptions
+ */
+
+/**
+ * @template T
+ * @callback BasicMinimizerImplementation
+ * @param {Input} input
+ * @param {RawSourceMap | undefined} sourceMap
+ * @param {MinimizerOptions<T>} minifyOptions
+ * @param {ExtractCommentsOptions | undefined} extractComments
+ * @returns {Promise<MinimizedResult> | MinimizedResult}
+ */
+
+/**
+ * @typedef {object} MinimizeFunctionHelpers
+ * @property {() => string | undefined=} getMinimizerVersion function that returns version of minimizer
+ * @property {() => boolean | undefined=} supportsWorkerThreads true when minimizer support worker threads, otherwise false
+ * @property {() => boolean | undefined=} supportsWorker true when minimizer support worker, otherwise false
+ * @property {(name: string, info?: AssetInfo) => boolean | undefined=} filter return true when the minimizer supports the asset, otherwise false. When an array of minimizers is configured, each asset is dispatched only to the minimizers whose `filter` accepts it. Assets rejected by every minimizer in the array are skipped entirely.
+ */
+
+/**
+ * @template T
+ * @typedef {T extends EXPECTED_ANY[] ? { [P in keyof T]: BasicMinimizerImplementation<T[P]> & MinimizeFunctionHelpers } : BasicMinimizerImplementation<T> & MinimizeFunctionHelpers} MinimizerImplementation
+ */
+
+/**
+ * @template T
+ * @typedef {object} InternalOptions
+ * @property {string} name name
+ * @property {string} input input
+ * @property {RawSourceMap | undefined} inputSourceMap input source map
+ * @property {ExtractCommentsOptions | undefined} extractComments extract comments option
+ * @property {{ implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> }} minimizer minimizer
+ * @property {boolean=} module true when code is a EC module, otherwise false
+ * @property {number | string=} ecma ecma version
+ */
+
+/**
+ * @template T
+ * @typedef {JestWorker & { transform: (options: string) => Promise<MinimizedResult>, minify: (options: InternalOptions<T>) => Promise<MinimizedResult> }} MinimizerWorker
+ */
+
+/**
+ * @typedef {undefined | boolean | number} Parallel
+ */
+
+/**
+ * @typedef {object} BasePluginOptions
+ * @property {Rules=} test test rule
+ * @property {Rules=} include include rile
+ * @property {Rules=} exclude exclude rule
+ * @property {ExtractCommentsOptions=} extractComments extract comments options
+ * @property {Parallel=} parallel parallel option
+ */
+
+/**
+ * @template T
+ * @typedef {T extends import("terser").MinifyOptions ? { minify?: MinimizerImplementation<T> | undefined, minimizerOptions?: MinimizerOptions<T> | undefined, terserOptions?: MinimizerOptions<T> | undefined } : { minify: MinimizerImplementation<T>, minimizerOptions?: MinimizerOptions<T> | undefined, terserOptions?: MinimizerOptions<T> | undefined }} DefinedDefaultMinimizerAndOptions
+ */
+
+/**
+ * @template T
+ * @typedef {BasePluginOptions & { minimizer: { implementation: MinimizerImplementation<T>, options: MinimizerOptions<T> } }} InternalPluginOptions
+ */
+
+const getTraceMapping = memoize(() => require("@jridgewell/trace-mapping"));
+const getSerializeJavascript = memoize(() => require("./serialize-javascript"));
+
+/**
+ * @template [T=import("terser").MinifyOptions]
+ */
+class TerserPlugin {
+  /**
+   * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>=} options options
+   */
+  constructor(options) {
+    validate(/** @type {Schema} */schema, options || {}, {
+      name: "Terser Plugin",
+      baseDataPath: "options"
+    });
+
+    // TODO handle json and etc in the next major release
+    // TODO make `minimizer` option instead `minify` and `terserOptions` in the next major release, also rename `terserMinify` to `terserMinimize`
+    const {
+      minify = (/** @type {MinimizerImplementation<T>} */
+      /** @type {unknown} */terserMinify),
+      minimizerOptions,
+      terserOptions,
+      test = /\.[cm]?js(\?.*)?$/i,
+      extractComments = true,
+      parallel = true,
+      include,
+      exclude
+    } = options || {};
+
+    // `terserOptions` is a deprecated alias of `minimizerOptions`; prefer the
+    // new name when both are provided.
+    const resolvedMinimizerOptions = /** @type {MinimizerOptions<T>} */
+
+    typeof minimizerOptions !== "undefined" ? minimizerOptions : terserOptions || {};
+
+    /**
+     * @private
+     * @type {InternalPluginOptions<T>}
+     */
+    this.options = {
+      test,
+      extractComments,
+      parallel,
+      include,
+      exclude,
+      minimizer: {
+        implementation: minify,
+        options: resolvedMinimizerOptions
+      }
+    };
+  }
+
+  /**
+   * @private
+   * @param {unknown} input Input to check
+   * @returns {boolean} Whether input is a source map
+   */
+  static isSourceMap(input) {
+    // All required options for `new TraceMap(...options)`
+    // https://github.com/jridgewell/trace-mapping#usage
+    return Boolean(input && typeof input === "object" && input !== null && "version" in input && "sources" in input && Array.isArray(input.sources) && "mappings" in input && typeof input.mappings === "string");
+  }
+
+  /**
+   * @private
+   * @param {unknown} warning warning
+   * @param {string} file file
+   * @returns {Error} built warning
+   */
+  static buildWarning(warning, file) {
+    /**
+     * @type {Error & { hideStack: true, file: string }}
+     */
+    // @ts-expect-error
+    const builtWarning = new Error(warning.toString());
+    builtWarning.name = "Warning";
+    builtWarning.hideStack = true;
+    builtWarning.file = file;
+    return builtWarning;
+  }
+
+  /**
+   * @private
+   * @param {Error | ErrorObject | string} error error
+   * @param {string} file file
+   * @param {TraceMap=} sourceMap source map
+   * @param {Compilation["requestShortener"]=} requestShortener request shortener
+   * @returns {Error} built error
+   */
+  static buildError(error, file, sourceMap, requestShortener) {
+    /**
+     * @type {Error & { file?: string }}
+     */
+    let builtError;
+    if (typeof error === "string") {
+      builtError = new Error(`${file} from Terser plugin\n${error}`);
+      builtError.file = file;
+      return builtError;
+    }
+    if (/** @type {ErrorObject} */error.line) {
+      const {
+        line,
+        column
+      } = /** @type {ErrorObject & { line: number, column: number }} */error;
+      const original = sourceMap && getTraceMapping().originalPositionFor(sourceMap, {
+        line,
+        column
+      });
+      if (original && original.source && requestShortener) {
+        builtError = new Error(`${file} from Terser plugin\n${error.message} [${requestShortener.shorten(original.source)}:${original.line},${original.column}][${file}:${line},${column}]${error.stack ? `\n${error.stack.split("\n").slice(1).join("\n")}` : ""}`);
+        builtError.file = file;
+        return builtError;
+      }
+      builtError = new Error(`${file} from Terser plugin\n${error.message} [${file}:${line},${column}]${error.stack ? `\n${error.stack.split("\n").slice(1).join("\n")}` : ""}`);
+      builtError.file = file;
+      return builtError;
+    }
+    if (error.stack) {
+      builtError = new Error(`${file} from Terser plugin\n${typeof error.message !== "undefined" ? error.message : ""}\n${error.stack}`);
+      builtError.file = file;
+      return builtError;
+    }
+    builtError = new Error(`${file} from Terser plugin\n${error.message}`);
+    builtError.file = file;
+    return builtError;
+  }
+
+  /**
+   * @private
+   * @param {Parallel} parallel value of the `parallel` option
+   * @returns {number} number of cores for parallelism
+   */
+  static getAvailableNumberOfCores(parallel) {
+    // In some cases cpus() returns undefined
+    // https://github.com/nodejs/node/issues/19022
+    const cpus =
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    typeof os.availableParallelism === "function" ?
+    // eslint-disable-next-line n/no-unsupported-features/node-builtins
+    {
+      length: os.availableParallelism()
+    } : os.cpus() || {
+      length: 1
+    };
+    return parallel === true || typeof parallel === "undefined" ? cpus.length - 1 : Math.min(parallel || 0, cpus.length - 1);
+  }
+
+  /**
+   * @private
+   * @param {Compiler} compiler compiler
+   * @param {Compilation} compilation compilation
+   * @param {Record<string, import("webpack").sources.Source>} assets assets
+   * @param {{ availableNumberOfCores: number }} optimizeOptions optimize options
+   * @returns {Promise<void>}
+   */
+  async optimize(compiler, compilation, assets, optimizeOptions) {
+    const cache = compilation.getCache("TerserWebpackPlugin");
+    let numberOfAssets = 0;
+
+    // Normalize the implementation list to an array so dispatch and the
+    // worker-pool capability checks below can iterate uniformly. The
+    // original shape on `this.options.minimizer.implementation` is preserved
+    // for chunk hashing.
+    const implementations = Array.isArray(this.options.minimizer.implementation) ? this.options.minimizer.implementation : [this.options.minimizer.implementation];
+
+    /**
+     * Collect the indices of minimizers whose `filter` accepts `name`.
+     * Filters returning `undefined` are treated as accept (matches the
+     * convention used by `supportsWorkerThreads`).
+     * @param {string} name asset name
+     * @param {AssetInfo} info asset info
+     * @returns {number[]} indices into `implementations` that accept the asset
+     */
+    const matchingMinimizers = (name, info) => {
+      const matched = [];
+      for (let i = 0; i < implementations.length; i++) {
+        const impl = implementations[i];
+        if (typeof impl.filter !== "function" ||
+        // eslint-disable-next-line unicorn/no-array-method-this-argument
+        impl.filter(name, info) !== false) {
+          matched.push(i);
+        }
+      }
+      return matched;
+    };
+    /** @type {Map<string, number[]>} */
+    const matchedByName = new Map();
+    const assetsForMinify = await Promise.all(Object.keys(assets).filter(name => {
+      const {
+        info
+      } = /** @type {Asset} */compilation.getAsset(name);
+      if (
+      // Skip double minimize assets from child compilation
+      info.minimized ||
+      // Skip minimizing for extracted comments assets
+      info.extractedComments) {
+        return false;
+      }
+      if (!compiler.webpack.ModuleFilenameHelpers.matchObject.bind(undefined, this.options)(name)) {
+        return false;
+      }
+
+      // Compute the matching minimizers once and carry the result to the
+      // per-asset task via `matchedByName` so the regexes don't run again.
+      const matched = matchingMinimizers(name, info);
+      if (matched.length === 0) {
+        return false;
+      }
+      matchedByName.set(name, matched);
+      return true;
+    }).map(async name => {
+      const {
+        info,
+        source
+      } = /** @type {Asset} */
+      compilation.getAsset(name);
+      const eTag = cache.getLazyHashedEtag(source);
+      const cacheItem = cache.getItemCache(name, eTag);
+      const output = await cacheItem.getPromise();
+      if (!output) {
+        numberOfAssets += 1;
+      }
+      return {
+        name,
+        info,
+        inputSource: source,
+        output,
+        cacheItem,
+        matched: (/** @type {number[]} */matchedByName.get(name))
+      };
+    }));
+    if (assetsForMinify.length === 0) {
+      return;
+    }
+
+    /** @type {undefined | (() => MinimizerWorker<T>)} */
+    let getWorker;
+    /** @type {undefined | MinimizerWorker<T>} */
+    let initializedWorker;
+    /** @type {undefined | number} */
+    let numberOfWorkers;
+    const needCreateWorker = optimizeOptions.availableNumberOfCores > 0 && implementations.every(impl => typeof impl.supportsWorker === "undefined" || typeof impl.supportsWorker === "function" && impl.supportsWorker());
+    if (needCreateWorker) {
+      // Do not create unnecessary workers when the number of files is less than the available cores, it saves memory
+      numberOfWorkers = Math.min(numberOfAssets, optimizeOptions.availableNumberOfCores);
+      getWorker = () => {
+        if (initializedWorker) {
+          return initializedWorker;
+        }
+        const {
+          Worker
+        } = require("jest-worker");
+        initializedWorker = /** @type {MinimizerWorker<T>} */
+
+        new Worker(require.resolve("./minify"), {
+          numWorkers: numberOfWorkers,
+          enableWorkerThreads: implementations.every(impl => typeof impl.supportsWorkerThreads === "undefined" || impl.supportsWorkerThreads() !== false)
+        });
+
+        // https://github.com/facebook/jest/issues/8872#issuecomment-524822081
+        const workerStdout = initializedWorker.getStdout();
+        if (workerStdout) {
+          workerStdout.on("data", chunk => process.stdout.write(chunk));
+        }
+        const workerStderr = initializedWorker.getStderr();
+        if (workerStderr) {
+          workerStderr.on("data", chunk => process.stderr.write(chunk));
+        }
+        return initializedWorker;
+      };
+    }
+    const {
+      SourceMapSource,
+      ConcatSource,
+      RawSource
+    } = compiler.webpack.sources;
+
+    /** @typedef {{ extractedCommentsSource: import("webpack").sources.RawSource, commentsFilename: string }} ExtractedCommentsInfo */
+    /** @type {Map<string, ExtractedCommentsInfo>} */
+    const allExtractedComments = new Map();
+    const scheduledTasks = [];
+    for (const asset of assetsForMinify) {
+      scheduledTasks.push(async () => {
+        const {
+          name,
+          inputSource,
+          info,
+          cacheItem,
+          matched
+        } = asset;
+        let {
+          output
+        } = asset;
+        if (!output) {
+          let input;
+          /** @type {RawSourceMap | undefined} */
+          let inputSourceMap;
+          const {
+            source: sourceFromInputSource,
+            map
+          } = inputSource.sourceAndMap();
+          input = sourceFromInputSource;
+          if (map) {
+            if (!TerserPlugin.isSourceMap(map)) {
+              compilation.warnings.push(new Error(`${name} contains invalid source map`));
+            } else {
+              inputSourceMap = /** @type {RawSourceMap} */map;
+            }
+          }
+          if (Buffer.isBuffer(input)) {
+            input = input.toString();
+          }
+
+          // Dispatch to only the minimizers whose `filter` accepted this
+          // asset (computed once when collecting `assetsForMinify`).
+          // `minify.js` already normalizes a single implementation into a
+          // one-element array, so we always hand it the matching subset.
+          // Options are sliced as references — `minify.js` overlays
+          // `module`/`ecma` without mutating the caller's object.
+          const assetImplementation = /** @type {MinimizerImplementation<T>} */
+          matched.map(i => implementations[i]);
+          const sourceOptions = this.options.minimizer.options;
+          const assetMinimizerOptions = /** @type {MinimizerOptions<T>} */
+
+          Array.isArray(sourceOptions) ? matched.map(i => sourceOptions[i] || {}) : sourceOptions;
+
+          /**
+           * @type {InternalOptions<T>}
+           */
+          const options = {
+            name,
+            input,
+            inputSourceMap,
+            minimizer: {
+              implementation: assetImplementation,
+              options: assetMinimizerOptions
+            },
+            extractComments: this.options.extractComments
+          };
+          if (typeof info.javascriptModule !== "undefined") {
+            options.module = info.javascriptModule;
+          } else if (/\.mjs(\?.*)?$/i.test(name)) {
+            options.module = true;
+          } else if (/\.cjs(\?.*)?$/i.test(name)) {
+            options.module = false;
+          }
+          options.ecma = getEcmaVersion(compiler.options.output.environment);
+          try {
+            output = await (getWorker ? getWorker().transform(getSerializeJavascript()(options)) : minify(options));
+          } catch (error) {
+            const hasSourceMap = inputSourceMap && TerserPlugin.isSourceMap(inputSourceMap);
+            compilation.errors.push(TerserPlugin.buildError(/** @type {Error | ErrorObject | string} */
+            error, name, hasSourceMap ? new (getTraceMapping().TraceMap)(/** @type {RawSourceMap} */
+            inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined));
+            return;
+          }
+          if (typeof output.code === "undefined") {
+            compilation.errors.push(new Error(`${name} from Terser plugin\nMinimizer doesn't return result`));
+          }
+          if (output.warnings && output.warnings.length > 0) {
+            output.warnings = output.warnings.map(
+            /**
+             * @param {Error | string} item a warning
+             * @returns {Error} built warning with extra info
+             */
+            item => TerserPlugin.buildWarning(item, name));
+          }
+          if (output.errors && output.errors.length > 0) {
+            const hasSourceMap = inputSourceMap && TerserPlugin.isSourceMap(inputSourceMap);
+            output.errors = output.errors.map(
+            /**
+             * @param {Error | string} item an error
+             * @returns {Error} built error with extra info
+             */
+            item => TerserPlugin.buildError(item, name, hasSourceMap ? new (getTraceMapping().TraceMap)(/** @type {RawSourceMap} */
+            inputSourceMap) : undefined, hasSourceMap ? compilation.requestShortener : undefined));
+          }
+          let shebang;
+
+          // Custom functions can return `undefined` or `null` when the
+          // minimizer only produced warnings, errors or extracted comments
+          if (typeof output.code !== "undefined" && output.code !== null) {
+            if (/** @type {ExtractCommentsObject} */
+            this.options.extractComments.banner !== false && output.extractedComments && output.extractedComments.length > 0 && output.code.startsWith("#!")) {
+              const firstNewlinePosition = output.code.indexOf("\n");
+              shebang = output.code.slice(0, Math.max(0, firstNewlinePosition));
+              output.code = output.code.slice(Math.max(0, firstNewlinePosition + 1));
+            }
+            if (output.map) {
+              output.source = new SourceMapSource(output.code, name, output.map, input, /** @type {RawSourceMap} */
+              inputSourceMap, true);
+            } else {
+              output.source = new RawSource(output.code);
+            }
+          }
+          if (output.extractedComments && output.extractedComments.length > 0) {
+            const commentsFilename = /** @type {ExtractCommentsObject} */
+            this.options.extractComments.filename || "[file].LICENSE.txt[query]";
+            let query = "";
+            let filename = name;
+            const querySplit = filename.indexOf("?");
+            if (querySplit >= 0) {
+              query = filename.slice(querySplit);
+              filename = filename.slice(0, querySplit);
+            }
+            const lastSlashIndex = filename.lastIndexOf("/");
+            const basename = lastSlashIndex === -1 ? filename : filename.slice(lastSlashIndex + 1);
+            const data = {
+              filename,
+              basename,
+              query
+            };
+            output.commentsFilename = compilation.getPath(commentsFilename, data);
+
+            // Banner only applies when we have a new source to prepend to
+            if (output.source && /** @type {ExtractCommentsObject} */
+            this.options.extractComments.banner !== false) {
+              let banner = /** @type {ExtractCommentsObject} */
+              this.options.extractComments.banner || `For license information please see ${path.relative(path.dirname(name), output.commentsFilename).replace(/\\/g, "/")}`;
+              if (typeof banner === "function") {
+                banner = banner(output.commentsFilename);
+              }
+              if (banner) {
+                output.source = new ConcatSource(shebang ? `${shebang}\n` : "", `/*! ${banner} */\n`, output.source);
+              }
+            }
+            const extractedCommentsString = output.extractedComments.sort().join("\n\n");
+            output.extractedCommentsSource = new RawSource(`${extractedCommentsString}\n`);
+          }
+          await cacheItem.storePromise({
+            source: output.source,
+            errors: output.errors,
+            warnings: output.warnings,
+            commentsFilename: output.commentsFilename,
+            extractedCommentsSource: output.extractedCommentsSource
+          });
+        }
+        if (output.warnings && output.warnings.length > 0) {
+          for (const warning of output.warnings) {
+            compilation.warnings.push(warning);
+          }
+        }
+        if (output.errors && output.errors.length > 0) {
+          for (const error of output.errors) {
+            compilation.errors.push(error);
+          }
+        }
+
+        // Emit extracted comments file even if the main asset was not
+        // rewritten (some minimizers only produce comments / warnings / errors)
+        if (output.extractedCommentsSource) {
+          allExtractedComments.set(name, {
+            extractedCommentsSource: output.extractedCommentsSource,
+            commentsFilename: (/** @type {string} */output.commentsFilename)
+          });
+        }
+        if (!output.source) {
+          return;
+        }
+
+        /** @type {AssetInfo} */
+        const newInfo = {
+          minimized: true
+        };
+        if (output.extractedCommentsSource) {
+          newInfo.related = {
+            license: (/** @type {string} */output.commentsFilename)
+          };
+        }
+        compilation.updateAsset(name, output.source, newInfo);
+      });
+    }
+    const limit = getWorker && numberOfAssets > 0 ? (/** @type {number} */numberOfWorkers) : scheduledTasks.length;
+    await throttleAll(limit, scheduledTasks);
+    if (initializedWorker) {
+      await initializedWorker.end();
+    }
+
+    /** @typedef {{ source: import("webpack").sources.Source, commentsFilename: string, from: string }} ExtractedCommentsInfoWithFrom */
+    await [...allExtractedComments].sort().reduce(
+    /**
+     * @param {Promise<unknown>} previousPromise previous result
+     * @param {[string, ExtractedCommentsInfo]} extractedComments extracted comments
+     * @returns {Promise<ExtractedCommentsInfoWithFrom>} extract comments with info
+     */
+    async (previousPromise, [from, value]) => {
+      const previous = /** @type {ExtractedCommentsInfoWithFrom | undefined} * */
+      await previousPromise;
+      const {
+        commentsFilename,
+        extractedCommentsSource
+      } = value;
+      if (previous && previous.commentsFilename === commentsFilename) {
+        const {
+          from: previousFrom,
+          source: prevSource
+        } = previous;
+        const mergedName = `${previousFrom}|${from}`;
+        const name = `${commentsFilename}|${mergedName}`;
+        const eTag = [prevSource, extractedCommentsSource].map(item => cache.getLazyHashedEtag(item)).reduce((previousValue, currentValue) => cache.mergeEtags(previousValue, currentValue));
+        let source = await cache.getPromise(name, eTag);
+        if (!source) {
+          source = new ConcatSource([...new Set([... /** @type {string} */prevSource.source().split("\n\n"), ... /** @type {string} */extractedCommentsSource.source().split("\n\n")])].join("\n\n"));
+          await cache.storePromise(name, eTag, source);
+        }
+        compilation.updateAsset(commentsFilename, source);
+        return {
+          source,
+          commentsFilename,
+          from: mergedName
+        };
+      }
+      const existingAsset = compilation.getAsset(commentsFilename);
+      if (existingAsset) {
+        return {
+          source: existingAsset.source,
+          commentsFilename,
+          from: commentsFilename
+        };
+      }
+      compilation.emitAsset(commentsFilename, extractedCommentsSource, {
+        extractedComments: true
+      });
+      return {
+        source: extractedCommentsSource,
+        commentsFilename,
+        from
+      };
+    }, /** @type {Promise<unknown>} */Promise.resolve());
+  }
+
+  /**
+   * @param {Compiler} compiler compiler
+   * @returns {void}
+   */
+  apply(compiler) {
+    const pluginName = this.constructor.name;
+    const availableNumberOfCores = TerserPlugin.getAvailableNumberOfCores(this.options.parallel);
+    compiler.hooks.compilation.tap(pluginName, compilation => {
+      const hooks = compiler.webpack.javascript.JavascriptModulesPlugin.getCompilationHooks(compilation);
+      /**
+       * @param {BasicMinimizerImplementation<EXPECTED_ANY> & MinimizeFunctionHelpers} impl implementation
+       * @returns {string} minimizer version or "0.0.0"
+       */
+      const getVersion = impl => typeof impl.getMinimizerVersion !== "undefined" ? impl.getMinimizerVersion() || "0.0.0" : "0.0.0";
+      const data = getSerializeJavascript()({
+        minimizer: Array.isArray(this.options.minimizer.implementation) ? this.options.minimizer.implementation.map(getVersion) : getVersion(/** @type {BasicMinimizerImplementation<EXPECTED_ANY> & MinimizeFunctionHelpers} */
+        this.options.minimizer.implementation),
+        options: this.options.minimizer.options
+      });
+      hooks.chunkHash.tap(pluginName, (chunk, hash) => {
+        hash.update("TerserPlugin");
+        hash.update(data);
+      });
+      compilation.hooks.processAssets.tapPromise({
+        name: pluginName,
+        stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE,
+        additionalAssets: true
+      }, assets => this.optimize(compiler, compilation, assets, {
+        availableNumberOfCores
+      }));
+      compilation.hooks.statsPrinter.tap(pluginName, stats => {
+        stats.hooks.print.for("asset.info.minimized").tap("minimizer-webpack-plugin", (minimized, {
+          green,
+          formatFlag
+        }) => minimized ? /** @type {(text: string) => string} */green(/** @type {(flag: string) => string} */formatFlag("minimized")) : "");
+      });
+    });
+  }
+}
+TerserPlugin.terserMinify = terserMinify;
+TerserPlugin.uglifyJsMinify = uglifyJsMinify;
+TerserPlugin.swcMinify = swcMinify;
+TerserPlugin.esbuildMinify = esbuildMinify;
+TerserPlugin.jsonMinify = jsonMinify;
+TerserPlugin.htmlMinifierTerser = htmlMinifierTerser;
+TerserPlugin.swcMinifyHtml = swcMinifyHtml;
+TerserPlugin.swcMinifyHtmlFragment = swcMinifyHtmlFragment;
+TerserPlugin.minifyHtmlNode = minifyHtmlNode;
+TerserPlugin.cssnanoMinify = cssnanoMinify;
+TerserPlugin.cssoMinify = cssoMinify;
+TerserPlugin.cleanCssMinify = cleanCssMinify;
+TerserPlugin.esbuildMinifyCss = esbuildMinifyCss;
+TerserPlugin.lightningCssMinify = lightningCssMinify;
+TerserPlugin.swcMinifyCss = swcMinifyCss;
+module.exports = TerserPlugin;
Index: frontend/node_modules/terser-webpack-plugin/dist/minify.js
===================================================================
--- frontend/node_modules/terser-webpack-plugin/dist/minify.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/dist/minify.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,335 @@
+"use strict";
+
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+/** @typedef {import("./index.js").CustomOptions} CustomOptions */
+/** @typedef {import("./index.js").RawSourceMap} RawSourceMap */
+/**
+ * @template T
+ * @typedef {import("./index.js").MinimizerOptions<T>} MinimizerOptions
+ */
+
+const VLQ_BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/**
+ * Encode a single integer as Base64 VLQ as used by the source-map spec.
+ * @param {number} value integer to encode
+ * @returns {string} encoded VLQ characters
+ */
+/* eslint-disable prefer-destructuring, no-eq-null, eqeqeq */
+/**
+ * @param {number} value integer to encode
+ * @returns {string} encoded VLQ characters
+ */
+function encodeVlq(value) {
+  let vlq = value < 0 ? -value << 1 | 1 : value << 1;
+  let out = "";
+  do {
+    let digit = vlq & 0b11111;
+    vlq >>>= 5;
+    if (vlq > 0) {
+      digit |= 0b100000;
+    }
+    out += VLQ_BASE64[digit];
+  } while (vlq > 0);
+  return out;
+}
+
+/**
+ * Encode decoded source-map mappings (per-line arrays of segments) back into
+ * the spec's `mappings` string.
+ * @param {number[][][]} decoded mappings as nested arrays of segments
+ * @returns {string} encoded `mappings` field
+ */
+function encodeMappings(decoded) {
+  let result = "";
+  let prevSourceIdx = 0;
+  let prevOriginalLine = 0;
+  let prevOriginalColumn = 0;
+  let prevNameIdx = 0;
+  for (let line = 0; line < decoded.length; line++) {
+    if (line > 0) {
+      result += ";";
+    }
+    let prevGeneratedColumn = 0;
+    const segments = decoded[line];
+    for (let i = 0; i < segments.length; i++) {
+      if (i > 0) {
+        result += ",";
+      }
+      const seg = segments[i];
+      result += encodeVlq(seg[0] - prevGeneratedColumn);
+      prevGeneratedColumn = seg[0];
+      if (seg.length >= 4) {
+        result += encodeVlq(seg[1] - prevSourceIdx);
+        prevSourceIdx = seg[1];
+        result += encodeVlq(seg[2] - prevOriginalLine);
+        prevOriginalLine = seg[2];
+        result += encodeVlq(seg[3] - prevOriginalColumn);
+        prevOriginalColumn = seg[3];
+        if (seg.length >= 5) {
+          result += encodeVlq(seg[4] - prevNameIdx);
+          prevNameIdx = seg[4];
+        }
+      }
+    }
+  }
+  return result;
+}
+
+/**
+ * Compose a freshly-produced source map with the input source map fed to
+ * the minimizer. `currentMap` represents `name → step-output` and
+ * `prevMap` represents `original → name`; the result represents
+ * `original → step-output`.
+ *
+ * TODO: replace with a webpack-sources helper once one is exposed —
+ * `SourceMapSource` already composes one level via `innerSourceMap`,
+ * see https://github.com/webpack/webpack-sources for the proposal to
+ * expose it as a public `composeSourceMaps` (or n-step `SourceMapSource`).
+ * @param {RawSourceMap | undefined} currentMap map produced by the minimizer
+ * @param {RawSourceMap | undefined} prevMap input source map fed to the minimizer
+ * @param {string} name name of the asset that the current map points to
+ * @returns {RawSourceMap | undefined} composed map
+ */
+function composeSourceMaps(currentMap, prevMap, name) {
+  if (!currentMap || !prevMap) {
+    return currentMap;
+  }
+
+  // Custom minimizers may return the map as a JSON string (e.g. terser's
+  // default output). `TraceMap` accepts both shapes, but we still hand
+  // back the original `currentMap` (string preserved) when the previous
+  // map can't be combined.
+  const {
+    TraceMap,
+    decodedMappings,
+    originalPositionFor,
+    sourceContentFor
+  } = require("@jridgewell/trace-mapping");
+  const current = new TraceMap(/** @type {import("@jridgewell/trace-mapping").SourceMapInput} */
+  /** @type {unknown} */currentMap);
+  const previous = new TraceMap(/** @type {import("@jridgewell/trace-mapping").SourceMapInput} */
+  /** @type {unknown} */prevMap);
+
+  /** @type {string[]} */
+  const sources = [];
+  /** @type {(string | null)[]} */
+  const sourcesContent = [];
+  /** @type {string[]} */
+  const names = [];
+  /** @type {Map<string, number>} */
+  const sourceIdx = new Map();
+  /** @type {Map<string, number>} */
+  const nameIdx = new Map();
+
+  /**
+   * @param {string | null | undefined} source source identifier
+   * @param {string | undefined} content source content (when available)
+   * @returns {number} index assigned in the composed map
+   */
+  const getSourceIdx = (source, content) => {
+    const key = source || "";
+    let idx = sourceIdx.get(key);
+    if (typeof idx === "undefined") {
+      idx = sources.length;
+      sources.push(key);
+      sourcesContent.push(typeof content === "string" ? content : null);
+      sourceIdx.set(key, idx);
+    } else if (typeof content === "string" && sourcesContent[idx] === null) {
+      sourcesContent[idx] = content;
+    }
+    return idx;
+  };
+
+  /**
+   * @param {string | null | undefined} value name
+   * @returns {number} index assigned in the composed map
+   */
+  const getNameIdx = value => {
+    if (typeof value !== "string") {
+      return -1;
+    }
+    let idx = nameIdx.get(value);
+    if (typeof idx === "undefined") {
+      idx = names.length;
+      names.push(value);
+      nameIdx.set(value, idx);
+    }
+    return idx;
+  };
+  const decoded = decodedMappings(current);
+  const currentSources = current.sources.map(
+  /**
+   * @param {string | null} source source from current map
+   * @returns {string} normalized source string
+   */
+  source => source || "");
+  const currentNames = current.names;
+
+  /** @type {number[][][]} */
+  const composed = [];
+  for (let line = 0; line < decoded.length; line++) {
+    /** @type {number[][]} */
+    const newSegments = [];
+    for (const rawSeg of decoded[line]) {
+      const seg = /** @type {number[]} */rawSeg;
+
+      // Single-element segment is just a generated column with no source info
+      if (seg.length < 4) {
+        newSegments.push([seg[0]]);
+        continue;
+      }
+      const sourceName = currentSources[seg[1]];
+      const origLine = /** @type {number} */seg[2];
+      const origCol = /** @type {number} */seg[3];
+      const segName = seg.length >= 5 ? currentNames[seg[4]] : (/** @type {string | null} */null);
+
+      // When the segment points back at our intermediate `name`, look up
+      // the original position in the previous map and emit a mapping that
+      // points all the way back. Otherwise keep the segment as-is.
+      if (sourceName === name) {
+        const orig = originalPositionFor(previous, {
+          line: origLine + 1,
+          column: origCol
+        });
+        if (typeof orig.source !== "string" || orig.line == null || orig.column == null) {
+          continue;
+        }
+        const content = sourceContentFor(previous, orig.source) || undefined;
+        const newSrcIdx = getSourceIdx(orig.source, content);
+        const finalName = typeof orig.name === "string" && orig.name ? orig.name : segName;
+        if (typeof finalName === "string") {
+          newSegments.push([seg[0], newSrcIdx, orig.line - 1, orig.column, getNameIdx(finalName)]);
+        } else {
+          newSegments.push([seg[0], newSrcIdx, orig.line - 1, orig.column]);
+        }
+      } else {
+        const content = sourceContentFor(current, sourceName) || undefined;
+        const newSrcIdx = getSourceIdx(sourceName, content);
+        if (typeof segName === "string") {
+          newSegments.push([seg[0], newSrcIdx, origLine, origCol, getNameIdx(segName)]);
+        } else {
+          newSegments.push([seg[0], newSrcIdx, origLine, origCol]);
+        }
+      }
+    }
+    composed.push(newSegments);
+  }
+  const result = /** @type {RawSourceMap} */
+
+  /** @type {unknown} */{
+    version: 3,
+    sources,
+    names,
+    mappings: encodeMappings(composed)
+  };
+  if (currentMap.file) {
+    result.file = currentMap.file;
+  }
+  if (sourcesContent.some(value => typeof value === "string")) {
+    result.sourcesContent = /** @type {string[]} */
+    /** @type {unknown} */sourcesContent;
+  }
+  return result;
+}
+/* eslint-enable prefer-destructuring, no-eq-null, eqeqeq */
+
+/**
+ * @template T
+ * @param {import("./index.js").InternalOptions<T>} options options
+ * @returns {Promise<MinimizedResult>} minified result
+ */
+async function minify(options) {
+  const {
+    name,
+    input,
+    inputSourceMap,
+    extractComments,
+    module,
+    ecma
+  } = options;
+  const {
+    implementation,
+    options: minimizerOptions
+  } = options.minimizer;
+  const implementations = Array.isArray(implementation) ? implementation : [implementation];
+
+  /** @type {string | undefined} */
+  let lastCode;
+  /** @type {RawSourceMap | undefined} */
+  let lastMap;
+  /** @type {(Error | string)[]} */
+  const warnings = [];
+  /** @type {(Error | string)[]} */
+  const errors = [];
+  /** @type {string[]} */
+  const extractedComments = [];
+  for (let i = 0; i < implementations.length; i++) {
+    const currentImplementation = /** @type {import("./index.js").BasicMinimizerImplementation<T> & import("./index.js").MinimizeFunctionHelpers} */
+    implementations[i];
+    const baseOptions = /** @type {import("./index.js").MinimizerOptions<T> & { module?: boolean, ecma?: number | string }} */
+
+    Array.isArray(minimizerOptions) ? minimizerOptions[i] || {} : minimizerOptions || {};
+    const currentInput = typeof lastCode === "string" ? lastCode : input;
+    const currentMap = typeof lastCode === "string" ? lastMap : inputSourceMap;
+
+    // Overlay `module` and `ecma` without mutating the caller's options so
+    // a single options object can be reused safely across assets.
+    const currentOptions = /** @type {import("./index.js").MinimizerOptions<T>} */
+    {
+      ...baseOptions,
+      module: baseOptions.module || module,
+      ecma: baseOptions.ecma || ecma
+    };
+    const result = await currentImplementation({
+      [name]: currentInput
+    }, currentMap, currentOptions, extractComments);
+    if (result.warnings && result.warnings.length > 0) {
+      warnings.push(...result.warnings);
+    }
+    if (result.errors && result.errors.length > 0) {
+      errors.push(...result.errors);
+    }
+    if (result.extractedComments && result.extractedComments.length > 0) {
+      extractedComments.push(...result.extractedComments);
+    }
+    if (typeof result.code === "string") {
+      lastCode = result.code;
+      // The minimizer's output map is `name → step-output`. Chain it with
+      // the previous accumulated map so that across an array of minimizers
+      // the final map points back to the original sources.
+      lastMap = composeSourceMaps(result.map, currentMap, name);
+    }
+  }
+  return {
+    code: lastCode,
+    map: lastMap,
+    warnings,
+    errors,
+    extractedComments
+  };
+}
+
+/**
+ * @param {string} options options
+ * @returns {Promise<MinimizedResult>} minified result
+ */
+async function transform(options) {
+  // 'use strict' => this === undefined (Clean Scope)
+  // Safer for possible security issues, albeit not critical at all here
+
+  const evaluatedOptions =
+  /**
+   * @template T
+   * @type {import("./index.js").InternalOptions<T>}
+   */
+
+  // eslint-disable-next-line no-new-func
+  new Function("exports", "require", "module", "__filename", "__dirname", `'use strict'\nreturn ${options}`) // eslint-disable-next-line n/exports-style
+  (exports, require, module, __filename, __dirname);
+  return minify(evaluatedOptions);
+}
+module.exports = {
+  minify,
+  transform
+};
Index: frontend/node_modules/terser-webpack-plugin/dist/options.json
===================================================================
--- frontend/node_modules/terser-webpack-plugin/dist/options.json	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/dist/options.json	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,205 @@
+{
+  "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"
+        }
+      ]
+    }
+  },
+  "title": "MinimizerPluginOptions",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "test": {
+      "description": "Include all modules that pass test assertion.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#test",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "include": {
+      "description": "Include all modules matching any of these conditions.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#include",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "exclude": {
+      "description": "Exclude all modules matching any of these conditions.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#exclude",
+      "oneOf": [
+        {
+          "$ref": "#/definitions/Rules"
+        }
+      ]
+    },
+    "minimizerOptions": {
+      "description": "Options for `terser` (by default) or custom `minify` function.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#minimizeroptions",
+      "anyOf": [
+        {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "additionalProperties": true,
+            "type": "object"
+          }
+        }
+      ]
+    },
+    "terserOptions": {
+      "description": "Deprecated alias for `minimizerOptions`. Options for `terser` (by default) or custom `minify` function.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#terseroptions",
+      "anyOf": [
+        {
+          "additionalProperties": true,
+          "type": "object"
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "additionalProperties": true,
+            "type": "object"
+          }
+        }
+      ]
+    },
+    "extractComments": {
+      "description": "Whether comments shall be extracted to a separate file.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#extractcomments",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string",
+          "minLength": 1
+        },
+        {
+          "instanceof": "RegExp"
+        },
+        {
+          "instanceof": "Function"
+        },
+        {
+          "additionalProperties": false,
+          "properties": {
+            "condition": {
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "instanceof": "RegExp"
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ],
+              "description": "Condition what comments you need extract.",
+              "link": "https://github.com/webpack/minimizer-webpack-plugin#condition"
+            },
+            "filename": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ],
+              "description": "The file where the extracted comments will be stored. Default is to append the suffix .LICENSE.txt to the original filename.",
+              "link": "https://github.com/webpack/minimizer-webpack-plugin#filename"
+            },
+            "banner": {
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "string",
+                  "minLength": 1
+                },
+                {
+                  "instanceof": "Function"
+                }
+              ],
+              "description": "The banner text that points to the extracted file and will be added on top of the original file",
+              "link": "https://github.com/webpack/minimizer-webpack-plugin#banner"
+            }
+          },
+          "type": "object"
+        }
+      ]
+    },
+    "parallel": {
+      "description": "Use multi-process parallel running to improve the build speed.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#parallel",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "integer"
+        }
+      ]
+    },
+    "minify": {
+      "description": "Allows you to override default minify function.",
+      "link": "https://github.com/webpack/minimizer-webpack-plugin#number",
+      "anyOf": [
+        {
+          "instanceof": "Function"
+        },
+        {
+          "type": "array",
+          "minItems": 1,
+          "items": {
+            "instanceof": "Function"
+          }
+        }
+      ]
+    }
+  }
+}
Index: frontend/node_modules/terser-webpack-plugin/dist/serialize-javascript.js
===================================================================
--- frontend/node_modules/terser-webpack-plugin/dist/serialize-javascript.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/dist/serialize-javascript.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,276 @@
+"use strict";
+
+// @ts-nocheck
+
+var g = typeof globalThis !== 'undefined' ? globalThis : global;
+var crypto = g.crypto || {};
+if (typeof crypto.getRandomValues !== 'function') {
+  var nodeCrypto = require('crypto');
+  crypto.getRandomValues = function (typedArray) {
+    var bytes = nodeCrypto.randomBytes(typedArray.byteLength);
+    new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength).set(bytes);
+    return typedArray;
+  };
+}
+/*
+Copyright (c) 2014, Yahoo! Inc. All rights reserved.
+Copyrights licensed under the New BSD License.
+See the accompanying LICENSE file for terms.
+*/
+
+'use strict';
+
+// Generate an internal UID to make the regexp pattern harder to guess.
+var UID_LENGTH = 16;
+var UID = generateUID();
+var PLACE_HOLDER_REGEXP = new RegExp('(\\\\)?"@__(F|R|D|M|S|A|U|I|B|L)-' + UID + '-(\\d+)__@"', 'g');
+var IS_NATIVE_CODE_REGEXP = /\{\s*\[native code\]\s*\}/g;
+var IS_PURE_FUNCTION = /function.*?\(/;
+var IS_ARROW_FUNCTION = /.*?=>.*?/;
+var UNSAFE_CHARS_REGEXP = /[<>\/\u2028\u2029]/g;
+// Regex to match </script> and variations (case-insensitive) for XSS protection
+// Matches </script followed by optional whitespace/attributes and >
+var SCRIPT_CLOSE_REGEXP = /<\/script[^>]*>/gi;
+var RESERVED_SYMBOLS = ['*', 'async'];
+
+// Mapping of unsafe HTML and invalid JavaScript line terminator chars to their
+// Unicode char counterparts which are safe to use in JavaScript strings.
+var ESCAPED_CHARS = {
+  '<': '\\u003C',
+  '>': '\\u003E',
+  '/': '\\u002F',
+  '\u2028': '\\u2028',
+  '\u2029': '\\u2029'
+};
+function escapeUnsafeChars(unsafeChar) {
+  return ESCAPED_CHARS[unsafeChar];
+}
+
+// Escape function body for XSS protection while preserving arrow function syntax
+function escapeFunctionBody(str) {
+  // Escape </script> sequences and variations (case-insensitive) - the main XSS risk
+  // Matches </script followed by optional whitespace/attributes and >
+  // This must be done first before other replacements
+  str = str.replace(SCRIPT_CLOSE_REGEXP, function (match) {
+    // Escape all <, /, and > characters in the closing script tag
+    return match.replace(/</g, '\\u003C').replace(/\//g, '\\u002F').replace(/>/g, '\\u003E');
+  });
+  // Escape line terminators (these are always unsafe)
+  str = str.replace(/\u2028/g, '\\u2028');
+  str = str.replace(/\u2029/g, '\\u2029');
+  return str;
+}
+function generateUID() {
+  var bytes = crypto.getRandomValues(new Uint8Array(UID_LENGTH));
+  var result = '';
+  for (var i = 0; i < UID_LENGTH; ++i) {
+    result += bytes[i].toString(16);
+  }
+  return result;
+}
+function deleteFunctions(obj) {
+  var functionKeys = [];
+  for (var key in obj) {
+    if (typeof obj[key] === "function") {
+      functionKeys.push(key);
+    }
+  }
+  for (var i = 0; i < functionKeys.length; i++) {
+    delete obj[functionKeys[i]];
+  }
+}
+module.exports = function serialize(obj, options) {
+  options || (options = {});
+
+  // Backwards-compatibility for `space` as the second argument.
+  if (typeof options === 'number' || typeof options === 'string') {
+    options = {
+      space: options
+    };
+  }
+  var functions = [];
+  var regexps = [];
+  var dates = [];
+  var maps = [];
+  var sets = [];
+  var arrays = [];
+  var undefs = [];
+  var infinities = [];
+  var bigInts = [];
+  var urls = [];
+
+  // Returns placeholders for functions and regexps (identified by index)
+  // which are later replaced by their string representation.
+  function replacer(key, value) {
+    // For nested function
+    if (options.ignoreFunction) {
+      deleteFunctions(value);
+    }
+    if (!value && value !== undefined && value !== BigInt(0)) {
+      return value;
+    }
+
+    // If the value is an object w/ a toJSON method, toJSON is called before
+    // the replacer runs, so we use this[key] to get the non-toJSONed value.
+    var origValue = this[key];
+    var type = typeof origValue;
+    if (type === 'object') {
+      if (origValue instanceof RegExp) {
+        return '@__R-' + UID + '-' + (regexps.push(origValue) - 1) + '__@';
+      }
+      if (origValue instanceof Date) {
+        return '@__D-' + UID + '-' + (dates.push(origValue) - 1) + '__@';
+      }
+      if (origValue instanceof Map) {
+        return '@__M-' + UID + '-' + (maps.push(origValue) - 1) + '__@';
+      }
+      if (origValue instanceof Set) {
+        return '@__S-' + UID + '-' + (sets.push(origValue) - 1) + '__@';
+      }
+      if (Array.isArray(origValue)) {
+        var isSparse = Object.keys(origValue).length !== origValue.length;
+        if (isSparse) {
+          return '@__A-' + UID + '-' + (arrays.push(origValue) - 1) + '__@';
+        }
+      }
+      if (origValue instanceof URL) {
+        return '@__L-' + UID + '-' + (urls.push(origValue) - 1) + '__@';
+      }
+    }
+    if (type === 'function') {
+      return '@__F-' + UID + '-' + (functions.push(origValue) - 1) + '__@';
+    }
+    if (type === 'undefined') {
+      return '@__U-' + UID + '-' + (undefs.push(origValue) - 1) + '__@';
+    }
+    if (type === 'number' && !isNaN(origValue) && !isFinite(origValue)) {
+      return '@__I-' + UID + '-' + (infinities.push(origValue) - 1) + '__@';
+    }
+    if (type === 'bigint') {
+      return '@__B-' + UID + '-' + (bigInts.push(origValue) - 1) + '__@';
+    }
+    return value;
+  }
+  function serializeFunc(fn, options) {
+    var serializedFn = fn.toString();
+    if (IS_NATIVE_CODE_REGEXP.test(serializedFn)) {
+      throw new TypeError('Serializing native function: ' + fn.name);
+    }
+
+    // Escape unsafe HTML characters in function body for XSS protection
+    // This must preserve arrow function syntax (=>) while escaping </script>
+    if (options && options.unsafe !== true) {
+      serializedFn = escapeFunctionBody(serializedFn);
+    }
+
+    // pure functions, example: {key: function() {}}
+    if (IS_PURE_FUNCTION.test(serializedFn)) {
+      return serializedFn;
+    }
+
+    // arrow functions, example: arg1 => arg1+5
+    if (IS_ARROW_FUNCTION.test(serializedFn)) {
+      return serializedFn;
+    }
+    var argsStartsAt = serializedFn.indexOf('(');
+    var def = serializedFn.substr(0, argsStartsAt).trim().split(' ').filter(function (val) {
+      return val.length > 0;
+    });
+    var nonReservedSymbols = def.filter(function (val) {
+      return RESERVED_SYMBOLS.indexOf(val) === -1;
+    });
+
+    // enhanced literal objects, example: {key() {}}
+    if (nonReservedSymbols.length > 0) {
+      return (def.indexOf('async') > -1 ? 'async ' : '') + 'function' + (def.join('').indexOf('*') > -1 ? '*' : '') + serializedFn.substr(argsStartsAt);
+    }
+
+    // arrow functions
+    return serializedFn;
+  }
+
+  // Check if the parameter is function
+  if (options.ignoreFunction && typeof obj === "function") {
+    obj = undefined;
+  }
+  // Protects against `JSON.stringify()` returning `undefined`, by serializing
+  // to the literal string: "undefined".
+  if (obj === undefined) {
+    return String(obj);
+  }
+  var str;
+
+  // Creates a JSON string representation of the value.
+  // NOTE: Node 0.12 goes into slow mode with extra JSON.stringify() args.
+  if (options.isJSON && !options.space) {
+    str = JSON.stringify(obj);
+  } else {
+    str = JSON.stringify(obj, options.isJSON ? null : replacer, options.space);
+  }
+
+  // Protects against `JSON.stringify()` returning `undefined`, by serializing
+  // to the literal string: "undefined".
+  if (typeof str !== 'string') {
+    return String(str);
+  }
+
+  // Replace unsafe HTML and invalid JavaScript line terminator chars with
+  // their safe Unicode char counterpart. This _must_ happen before the
+  // regexps and functions are serialized and added back to the string.
+  if (options.unsafe !== true) {
+    str = str.replace(UNSAFE_CHARS_REGEXP, escapeUnsafeChars);
+  }
+  if (functions.length === 0 && regexps.length === 0 && dates.length === 0 && maps.length === 0 && sets.length === 0 && arrays.length === 0 && undefs.length === 0 && infinities.length === 0 && bigInts.length === 0 && urls.length === 0) {
+    return str;
+  }
+
+  // Replaces all occurrences of function, regexp, date, map and set placeholders in the
+  // JSON string with their string representations. If the original value can
+  // not be found, then `undefined` is used.
+  return str.replace(PLACE_HOLDER_REGEXP, function (match, backSlash, type, valueIndex) {
+    // The placeholder may not be preceded by a backslash. This is to prevent
+    // replacing things like `"a\"@__R-<UID>-0__@"` and thus outputting
+    // invalid JS.
+    if (backSlash) {
+      return match;
+    }
+    if (type === 'D') {
+      // Validate ISO string format to prevent code injection via spoofed toISOString()
+      var isoStr = String(dates[valueIndex].toISOString());
+      if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z$/.test(isoStr)) {
+        throw new TypeError('Invalid Date ISO string');
+      }
+      return "new Date(\"" + isoStr + "\")";
+    }
+    if (type === 'R') {
+      // Sanitize flags to prevent code injection (only allow valid RegExp flag characters)
+      var flags = String(regexps[valueIndex].flags).replace(/[^gimsuydv]/g, '');
+      return "new RegExp(" + serialize(regexps[valueIndex].source) + ", \"" + flags + "\")";
+    }
+    if (type === 'M') {
+      return "new Map(" + serialize(Array.from(maps[valueIndex].entries()), options) + ")";
+    }
+    if (type === 'S') {
+      return "new Set(" + serialize(Array.from(sets[valueIndex].values()), options) + ")";
+    }
+    if (type === 'A') {
+      return "Array.prototype.slice.call(" + serialize(Object.assign({
+        length: arrays[valueIndex].length
+      }, arrays[valueIndex]), options) + ")";
+    }
+    if (type === 'U') {
+      return 'undefined';
+    }
+    if (type === 'I') {
+      return infinities[valueIndex];
+    }
+    if (type === 'B') {
+      return "BigInt(\"" + bigInts[valueIndex] + "\")";
+    }
+    if (type === 'L') {
+      return "new URL(" + serialize(urls[valueIndex].toString(), options) + ")";
+    }
+    var fn = functions[valueIndex];
+    return serializeFunc(fn, options);
+  });
+};
Index: frontend/node_modules/terser-webpack-plugin/dist/utils.js
===================================================================
--- frontend/node_modules/terser-webpack-plugin/dist/utils.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/dist/utils.js	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,1597 @@
+"use strict";
+
+/** @typedef {import("./index.js").ExtractCommentsOptions} ExtractCommentsOptions */
+/** @typedef {import("./index.js").ExtractCommentsFunction} ExtractCommentsFunction */
+/** @typedef {import("./index.js").ExtractCommentsCondition} ExtractCommentsCondition */
+/** @typedef {import("./index.js").Input} Input */
+/** @typedef {import("./index.js").MinimizedResult} MinimizedResult */
+/** @typedef {import("./index.js").CustomOptions} CustomOptions */
+/** @typedef {import("./index.js").RawSourceMap} RawSourceMap */
+/** @typedef {import("./index.js").EXPECTED_OBJECT} EXPECTED_OBJECT */
+
+/**
+ * @typedef {string[]} ExtractedComments
+ */
+
+const JS_FILE_RE = /\.[cm]?js(\?.*)?$/i;
+const JSON_FILE_RE = /\.json(\?.*)?$/i;
+const HTML_FILE_RE = /\.html?(\?.*)?$/i;
+const CSS_FILE_RE = /\.css(\?.*)?$/i;
+
+/**
+ * Map a webpack `output.environment` configuration to the highest
+ * ECMAScript version that the target is known to support. Returns `5`
+ * when no ES2015+ features are flagged.
+ * @param {NonNullable<NonNullable<import("webpack").Configuration["output"]>["environment"]>} environment environment
+ * @returns {number} ecma version (5, 2015, 2017 or 2020)
+ */
+function getEcmaVersion(environment) {
+  // ES2020 (11th edition)
+  if (environment.bigIntLiteral || environment.dynamicImport || environment.dynamicImportInWorker || environment.globalThis || environment.optionalChaining) {
+    return 2020;
+  }
+
+  // ES2017 (8th edition)
+  if (environment.asyncFunction) {
+    return 2017;
+  }
+
+  // ES2015 (6th edition)
+  if (environment.arrowFunction || environment.const || environment.destructuring || environment.forOf || environment.methodShorthand || environment.module || environment.templateLiteral) {
+    return 2015;
+  }
+  return 5;
+}
+const notSettled = Symbol("not-settled");
+
+/**
+ * @template T
+ * @typedef {() => Promise<T>} Task
+ */
+
+/**
+ * Run tasks with limited concurrency.
+ * @template T
+ * @param {number} limit Limit of tasks that run at once.
+ * @param {Task<T>[]} tasks List of tasks to run.
+ * @returns {Promise<T[]>} A promise that fulfills to an array of the results
+ */
+function throttleAll(limit, tasks) {
+  return new Promise((resolve, reject) => {
+    const result = Array.from({
+      length: tasks.length
+    }).fill(notSettled);
+    const entries = tasks.entries();
+    const next = () => {
+      const {
+        done,
+        value
+      } = entries.next();
+      if (done) {
+        const isLast = !result.includes(notSettled);
+        if (isLast) resolve(result);
+        return;
+      }
+      const [index, task] = value;
+
+      /**
+       * @param {T} resultValue Result value
+       */
+      const onFulfilled = resultValue => {
+        result[index] = resultValue;
+        next();
+      };
+      task().then(onFulfilled, reject);
+    };
+    for (let i = 0; i < limit; i++) {
+      next();
+    }
+  });
+}
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @param {ExtractCommentsOptions=} extractComments extract comments option
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function terserMinify(input, sourceMap, minimizerOptions, extractComments) {
+  /**
+   * @param {unknown} value value
+   * @returns {value is EXPECTED_OBJECT} true when value is object or function
+   */
+  const isObject = value => {
+    const type = typeof value;
+
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    return value != null && (type === "object" || type === "function");
+  };
+
+  /**
+   * @param {import("terser").MinifyOptions & { sourceMap: import("terser").SourceMapOptions | undefined } & ({ output: import("terser").FormatOptions & { beautify: boolean } } | { format: import("terser").FormatOptions & { beautify: boolean } })} terserOptions terser options
+   * @param {ExtractedComments} extractedComments extracted comments
+   * @returns {ExtractCommentsFunction} function to extract comments
+   */
+  const buildComments = (terserOptions, extractedComments) => {
+    /** @type {{ [index: string]: ExtractCommentsCondition }} */
+    const condition = {};
+    let comments;
+    if (terserOptions.format) {
+      ({
+        comments
+      } = terserOptions.format);
+    } else if (terserOptions.output) {
+      ({
+        comments
+      } = terserOptions.output);
+    }
+    condition.preserve = typeof comments !== "undefined" ? comments : false;
+    if (typeof extractComments === "boolean" && extractComments) {
+      condition.extract = "some";
+    } else if (typeof extractComments === "string" || extractComments instanceof RegExp) {
+      condition.extract = extractComments;
+    } else if (typeof extractComments === "function") {
+      condition.extract = extractComments;
+    } else if (extractComments && isObject(extractComments)) {
+      condition.extract = typeof extractComments.condition === "boolean" && extractComments.condition ? "some" : typeof extractComments.condition !== "undefined" ? extractComments.condition : "some";
+    } else {
+      // No extract
+      // Preserve using "commentsOpts" or "some"
+      condition.preserve = typeof comments !== "undefined" ? comments : "some";
+      condition.extract = false;
+    }
+
+    // Ensure that both conditions are functions
+    for (const key of ["preserve", "extract"]) {
+      /** @type {undefined | string} */
+      let regexStr;
+      /** @type {undefined | RegExp} */
+      let regex;
+      switch (typeof condition[key]) {
+        case "boolean":
+          condition[key] = condition[key] ? () => true : () => false;
+          break;
+        case "function":
+          break;
+        case "string":
+          if (condition[key] === "all") {
+            condition[key] = () => true;
+            break;
+          }
+          if (condition[key] === "some") {
+            condition[key] = /** @type {ExtractCommentsFunction} */
+            (astNode, comment) => (comment.type === "comment2" || comment.type === "comment1") && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value);
+            break;
+          }
+          regexStr = /** @type {string} */condition[key];
+          condition[key] = /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => new RegExp(/** @type {string} */regexStr).test(comment.value);
+          break;
+        default:
+          regex = /** @type {RegExp} */condition[key];
+          condition[key] = /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => /** @type {RegExp} */regex.test(comment.value);
+      }
+    }
+
+    // Redefine the comments function to extract and preserve
+    // comments according to the two conditions
+    return (astNode, comment) => {
+      if (/** @type {{ extract: ExtractCommentsFunction }} */
+      condition.extract(astNode, comment)) {
+        const commentText = comment.type === "comment2" ? `/*${comment.value}*/` : `//${comment.value}`;
+
+        // Don't include duplicate comments
+        if (!extractedComments.includes(commentText)) {
+          extractedComments.push(commentText);
+        }
+      }
+      return /** @type {{ preserve: ExtractCommentsFunction }} */condition.preserve(astNode, comment);
+    };
+  };
+
+  /**
+   * @param {import("terser").MinifyOptions=} terserOptions terser options
+   * @returns {import("terser").MinifyOptions & { sourceMap: import("terser").SourceMapOptions | undefined } & { compress: import("terser").CompressOptions } & ({ output: import("terser").FormatOptions & { beautify: boolean } } | { format: import("terser").FormatOptions & { beautify: boolean } })} built terser options
+   */
+  const buildTerserOptions = (terserOptions = {}) => (
+  // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+  {
+    ...terserOptions,
+    compress: typeof terserOptions.compress === "boolean" ? terserOptions.compress ? {} : false : {
+      ...terserOptions.compress
+    },
+    // ecma: terserOptions.ecma,
+    // ie8: terserOptions.ie8,
+    // keep_classnames: terserOptions.keep_classnames,
+    // keep_fnames: terserOptions.keep_fnames,
+    mangle:
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    terserOptions.mangle == null ? true : typeof terserOptions.mangle === "boolean" ? terserOptions.mangle : {
+      ...terserOptions.mangle
+    },
+    // module: terserOptions.module,
+    // nameCache: { ...terserOptions.toplevel },
+    // the `output` option is deprecated
+    ...(terserOptions.format ? {
+      format: {
+        beautify: false,
+        ...terserOptions.format
+      }
+    } : {
+      output: {
+        beautify: false,
+        ...terserOptions.output
+      }
+    }),
+    parse: {
+      ...terserOptions.parse
+    },
+    // safari10: terserOptions.safari10,
+    // Ignoring sourceMap from options
+    sourceMap: undefined
+    // toplevel: terserOptions.toplevel
+  });
+  let minify;
+  try {
+    ({
+      minify
+    } = require("terser"));
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `terser` options
+  const terserOptions = buildTerserOptions(minimizerOptions);
+
+  // Let terser generate a SourceMap. The dispatcher in `minify.js`
+  // chains the previous step's map onto this one.
+  if (sourceMap) {
+    terserOptions.sourceMap = {
+      asObject: true
+    };
+  }
+
+  /** @type {ExtractedComments} */
+  const extractedComments = [];
+  if (terserOptions.output) {
+    terserOptions.output.comments = buildComments(terserOptions, extractedComments);
+  } else if (terserOptions.format) {
+    terserOptions.format.comments = buildComments(terserOptions, extractedComments);
+  }
+  if (terserOptions.compress) {
+    // More optimizations
+    if (typeof terserOptions.compress.ecma === "undefined") {
+      terserOptions.compress.ecma = terserOptions.ecma;
+    }
+
+    // https://github.com/webpack/webpack/issues/16135
+    if (terserOptions.ecma === 5 && typeof terserOptions.compress.arrows === "undefined") {
+      terserOptions.compress.arrows = false;
+    }
+  }
+  const [[filename, code]] = Object.entries(input);
+  const result = await minify({
+    [filename]: code
+  }, terserOptions);
+  return {
+    code: (/** @type {string} * */result.code),
+    map: result.map ? (/** @type {RawSourceMap} * */result.map) : undefined,
+    extractedComments
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+terserMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("terser/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+ */
+terserMinify.supportsWorkerThreads = () => true;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a JavaScript file
+ */
+terserMinify.filter = name => JS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @param {ExtractCommentsOptions=} extractComments extract comments option
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function uglifyJsMinify(input, sourceMap, minimizerOptions, extractComments) {
+  /**
+   * @param {unknown} value value
+   * @returns {boolean} true when value is object or function
+   */
+  const isObject = value => {
+    const type = typeof value;
+
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    return value != null && (type === "object" || type === "function");
+  };
+
+  /**
+   * @param {import("uglify-js").MinifyOptions & { sourceMap: boolean | import("uglify-js").SourceMapOptions | undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean } }} uglifyJsOptions uglify-js options
+   * @param {ExtractedComments} extractedComments extracted comments
+   * @returns {ExtractCommentsFunction} extract comments function
+   */
+  const buildComments = (uglifyJsOptions, extractedComments) => {
+    /** @type {{ [index: string]: ExtractCommentsCondition }} */
+    const condition = {};
+    const {
+      comments
+    } = uglifyJsOptions.output;
+    condition.preserve = typeof comments !== "undefined" ? comments : false;
+    if (typeof extractComments === "boolean" && extractComments) {
+      condition.extract = "some";
+    } else if (typeof extractComments === "string" || extractComments instanceof RegExp) {
+      condition.extract = extractComments;
+    } else if (typeof extractComments === "function") {
+      condition.extract = extractComments;
+    } else if (extractComments && isObject(extractComments)) {
+      condition.extract = typeof extractComments.condition === "boolean" && extractComments.condition ? "some" : typeof extractComments.condition !== "undefined" ? extractComments.condition : "some";
+    } else {
+      // No extract
+      // Preserve using "commentsOpts" or "some"
+      condition.preserve = typeof comments !== "undefined" ? comments : "some";
+      condition.extract = false;
+    }
+
+    // Ensure that both conditions are functions
+    for (const key of ["preserve", "extract"]) {
+      /** @type {undefined | string} */
+      let regexStr;
+      /** @type {undefined | RegExp} */
+      let regex;
+      switch (typeof condition[key]) {
+        case "boolean":
+          condition[key] = condition[key] ? () => true : () => false;
+          break;
+        case "function":
+          break;
+        case "string":
+          if (condition[key] === "all") {
+            condition[key] = () => true;
+            break;
+          }
+          if (condition[key] === "some") {
+            condition[key] = /** @type {ExtractCommentsFunction} */
+            (astNode, comment) => (comment.type === "comment2" || comment.type === "comment1") && /@preserve|@lic|@cc_on|^\**!/i.test(comment.value);
+            break;
+          }
+          regexStr = /** @type {string} */condition[key];
+          condition[key] = /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => new RegExp(/** @type {string} */regexStr).test(comment.value);
+          break;
+        default:
+          regex = /** @type {RegExp} */condition[key];
+          condition[key] = /** @type {ExtractCommentsFunction} */
+          (astNode, comment) => /** @type {RegExp} */regex.test(comment.value);
+      }
+    }
+
+    // Redefine the comments function to extract and preserve
+    // comments according to the two conditions
+    return (astNode, comment) => {
+      if (/** @type {{ extract: ExtractCommentsFunction }} */
+      condition.extract(astNode, comment)) {
+        const commentText = comment.type === "comment2" ? `/*${comment.value}*/` : `//${comment.value}`;
+
+        // Don't include duplicate comments
+        if (!extractedComments.includes(commentText)) {
+          extractedComments.push(commentText);
+        }
+      }
+      return /** @type {{ preserve: ExtractCommentsFunction }} */condition.preserve(astNode, comment);
+    };
+  };
+
+  /**
+   * @param {import("uglify-js").MinifyOptions & { ecma?: number | string }=} uglifyJsOptions uglify-js options
+   * @returns {import("uglify-js").MinifyOptions & { sourceMap: boolean | import("uglify-js").SourceMapOptions | undefined } & { output: import("uglify-js").OutputOptions & { beautify: boolean } }} uglify-js options
+   */
+  const buildUglifyJsOptions = (uglifyJsOptions = {}) => {
+    if (typeof uglifyJsOptions.ecma !== "undefined") {
+      delete uglifyJsOptions.ecma;
+    }
+    if (typeof uglifyJsOptions.module !== "undefined") {
+      delete uglifyJsOptions.module;
+    }
+
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return {
+      ...uglifyJsOptions,
+      // warnings: uglifyJsOptions.warnings,
+      parse: {
+        ...uglifyJsOptions.parse
+      },
+      compress: typeof uglifyJsOptions.compress === "boolean" ? uglifyJsOptions.compress : {
+        ...uglifyJsOptions.compress
+      },
+      mangle:
+      // eslint-disable-next-line no-eq-null, eqeqeq
+      uglifyJsOptions.mangle == null ? true : typeof uglifyJsOptions.mangle === "boolean" ? uglifyJsOptions.mangle : {
+        ...uglifyJsOptions.mangle
+      },
+      output: {
+        beautify: false,
+        ...uglifyJsOptions.output
+      },
+      // Ignoring sourceMap from options
+
+      sourceMap: undefined
+      // toplevel: uglifyJsOptions.toplevel
+      // nameCache: { ...uglifyJsOptions.toplevel },
+      // ie8: uglifyJsOptions.ie8,
+      // keep_fnames: uglifyJsOptions.keep_fnames,
+    };
+  };
+  let minify;
+  try {
+    ({
+      minify
+    } = require("uglify-js"));
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `uglify-js` options
+  const uglifyJsOptions = buildUglifyJsOptions(minimizerOptions);
+
+  // Let `uglify-js` generate a SourceMap. The dispatcher in `minify.js`
+  // chains the previous step's map onto this one.
+  if (sourceMap) {
+    uglifyJsOptions.sourceMap = true;
+  }
+
+  /** @type {ExtractedComments} */
+  const extractedComments = [];
+
+  // @ts-expect-error wrong types in uglify-js
+  uglifyJsOptions.output.comments = buildComments(uglifyJsOptions, extractedComments);
+  const [[filename, code]] = Object.entries(input);
+  const result = await minify({
+    [filename]: code
+  }, uglifyJsOptions);
+  return {
+    code: result.code,
+    map: result.map ? JSON.parse(result.map) : undefined,
+    errors: result.error ? [result.error] : [],
+    warnings: result.warnings || [],
+    extractedComments
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+uglifyJsMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("uglify-js/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+ */
+uglifyJsMinify.supportsWorkerThreads = () => true;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a JavaScript file
+ */
+uglifyJsMinify.filter = name => JS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @param {ExtractCommentsOptions=} extractComments extract comments option
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function swcMinify(input, sourceMap, minimizerOptions, extractComments) {
+  /**
+   * @param {unknown} value value
+   * @returns {boolean} true when value is object or function
+   */
+  const isObject = value => {
+    const type = typeof value;
+
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    return value != null && (type === "object" || type === "function");
+  };
+
+  /**
+   * @param {unknown} extractCommentsOptions extract comments option
+   * @returns {Error} error for unsupported extract comments option
+   */
+  const createExtractCommentsError = extractCommentsOptions => new Error(`The 'extractComments' option for 'swcMinify' only supports booleans, "some", "all", string patterns, RegExp values without flags, or object conditions that resolve to those forms. Received: ${extractCommentsOptions instanceof RegExp ? extractCommentsOptions.toString() : typeof extractCommentsOptions}.`);
+
+  /**
+   * @param {unknown} extractCommentsOptions extract comments option
+   * @returns {{ extractComments: false | true | "some" | "all" | { regex: string }, useDefaultPreserveComments: boolean }} normalized swc extract comments options
+   */
+  const normalizeExtractComments = extractCommentsOptions => {
+    if (typeof extractCommentsOptions === "boolean") {
+      return {
+        extractComments: extractCommentsOptions,
+        useDefaultPreserveComments: !extractCommentsOptions
+      };
+    }
+    if (typeof extractCommentsOptions === "string") {
+      return {
+        extractComments: extractCommentsOptions === "some" || extractCommentsOptions === "all" ? extractCommentsOptions : {
+          regex: extractCommentsOptions
+        },
+        useDefaultPreserveComments: false
+      };
+    }
+    if (extractCommentsOptions instanceof RegExp) {
+      if (extractCommentsOptions.flags) {
+        throw createExtractCommentsError(extractCommentsOptions);
+      }
+      return {
+        extractComments: {
+          regex: extractCommentsOptions.source
+        },
+        useDefaultPreserveComments: false
+      };
+    }
+    if (typeof extractCommentsOptions === "function") {
+      throw createExtractCommentsError(extractCommentsOptions);
+    }
+    if (extractCommentsOptions && isObject(extractCommentsOptions)) {
+      const {
+        condition = "some"
+      } = /** @type {{ condition?: unknown }} */
+      extractCommentsOptions;
+      if (typeof condition === "boolean") {
+        return {
+          extractComments: condition ? "some" : false,
+          useDefaultPreserveComments: false
+        };
+      }
+      if (typeof condition === "string") {
+        return {
+          extractComments: condition === "some" || condition === "all" ? condition : {
+            regex: condition
+          },
+          useDefaultPreserveComments: false
+        };
+      }
+      if (condition instanceof RegExp) {
+        if (condition.flags) {
+          throw createExtractCommentsError(condition);
+        }
+        return {
+          extractComments: {
+            regex: condition.source
+          },
+          useDefaultPreserveComments: false
+        };
+      }
+      throw createExtractCommentsError(condition);
+    }
+    return {
+      extractComments: false,
+      useDefaultPreserveComments: false
+    };
+  };
+
+  /**
+   * @param {import("@swc/core").JsMinifyOptions=} swcOptions swc options
+   * @returns {import("@swc/core").JsMinifyOptions & { extractComments?: false | true | "some" | "all" | { regex: string } } & { sourceMap: undefined | boolean } & { compress: import("@swc/core").TerserCompressOptions }} built swc options
+   */
+  const buildSwcOptions = (swcOptions = {}) => (
+  // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+  {
+    ...swcOptions,
+    compress: typeof swcOptions.compress === "boolean" ? swcOptions.compress ? {} : false : {
+      ...swcOptions.compress
+    },
+    mangle:
+    // eslint-disable-next-line no-eq-null, eqeqeq
+    swcOptions.mangle == null ? true : typeof swcOptions.mangle === "boolean" ? swcOptions.mangle : {
+      ...swcOptions.mangle
+    },
+    format: {
+      ...swcOptions.format
+    },
+    // ecma: swcOptions.ecma,
+    // keep_classnames: swcOptions.keep_classnames,
+    // keep_fnames: swcOptions.keep_fnames,
+    // module: swcOptions.module,
+    // safari10: swcOptions.safari10,
+    // toplevel: swcOptions.toplevel
+
+    sourceMap: undefined
+  });
+  let swc;
+  try {
+    swc = require("@swc/core");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `swc` options
+  const swcOptions = buildSwcOptions(minimizerOptions);
+  const normalizedExtractComments = normalizeExtractComments(extractComments);
+  if (!swcOptions.format) {
+    swcOptions.format = {};
+  }
+
+  // Let `swc` generate a SourceMap.
+  if (sourceMap) {
+    swcOptions.sourceMap = true;
+  }
+  if (normalizedExtractComments.useDefaultPreserveComments && typeof swcOptions.format.comments === "undefined") {
+    swcOptions.format.comments = "some";
+  }
+  if (normalizedExtractComments.extractComments !== false) {
+    /** @type {import("@swc/core").JsMinifyOptions & { extractComments?: false | true | "some" | "all" | { regex: string } }} */
+    swcOptions.extractComments = normalizedExtractComments.extractComments;
+  }
+  if (swcOptions.compress) {
+    // More optimizations
+    if (typeof swcOptions.compress.ecma === "undefined") {
+      swcOptions.compress.ecma = swcOptions.ecma;
+    }
+
+    // https://github.com/webpack/webpack/issues/16135
+    if (swcOptions.ecma === 5 && typeof swcOptions.compress.arrows === "undefined") {
+      swcOptions.compress.arrows = false;
+    }
+  }
+  const [[filename, code]] = Object.entries(input);
+  const result = /** @type {import("@swc/core").Output & { extractedComments?: string[] }} */
+  await swc.minify(code, swcOptions);
+  let map;
+  if (result.map) {
+    map = JSON.parse(result.map);
+
+    // TODO workaround for swc because `filename` is not preset as in `swc` signature as for `terser`
+    map.sources = [filename];
+    delete map.sourcesContent;
+  }
+  return {
+    code: result.code,
+    map,
+    extractedComments: result.extractedComments || []
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+swcMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("@swc/core/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+ */
+swcMinify.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a JavaScript file
+ */
+swcMinify.filter = name => JS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function esbuildMinify(input, sourceMap, minimizerOptions) {
+  /**
+   * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean }=} esbuildOptions esbuild options
+   * @returns {import("esbuild").TransformOptions} built esbuild options
+   */
+  const buildEsbuildOptions = (esbuildOptions = {}) => {
+    delete esbuildOptions.ecma;
+    if (esbuildOptions.module) {
+      esbuildOptions.format = "esm";
+    }
+    delete esbuildOptions.module;
+
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return {
+      minify: true,
+      legalComments: "inline",
+      ...esbuildOptions,
+      sourcemap: false
+    };
+  };
+  let esbuild;
+  try {
+    esbuild = require("esbuild");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `esbuild` options
+  const esbuildOptions = buildEsbuildOptions(minimizerOptions);
+
+  // Let `esbuild` generate a SourceMap
+  if (sourceMap) {
+    esbuildOptions.sourcemap = true;
+    esbuildOptions.sourcesContent = false;
+  }
+  const [[filename, code]] = Object.entries(input);
+  esbuildOptions.sourcefile = filename;
+  const result = await esbuild.transform(code, esbuildOptions);
+  return {
+    code: result.code,
+    map: result.map ? JSON.parse(result.map) : undefined,
+    warnings: result.warnings.length > 0 ? result.warnings.map(item => {
+      const plugin = item.pluginName ? `\nPlugin Name: ${item.pluginName}` : "";
+      const location = item.location ? `\n\n${item.location.file}:${item.location.line}:${item.location.column}:\n  ${item.location.line} | ${item.location.lineText}\n\nSuggestion: ${item.location.suggestion}` : "";
+      const notes = item.notes.length > 0 ? `\n\nNotes:\n${item.notes.map(note => `${note.location ? `[${note.location.file}:${note.location.line}:${note.location.column}] ` : ""}${note.text}${note.location ? `\nSuggestion: ${note.location.suggestion}` : ""}${note.location ? `\nLine text:\n${note.location.lineText}\n` : ""}`).join("\n")}` : "";
+      return `${item.text} [${item.id}]${plugin}${location}${item.detail ? `\nDetails:\n${item.detail}` : ""}${notes}`;
+    }) : []
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+esbuildMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("esbuild/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+ */
+esbuildMinify.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a JavaScript file
+ */
+esbuildMinify.filter = name => JS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function jsonMinify(input, sourceMap, minimizerOptions) {
+  const options = /** @type {{ replacer?: Parameters<typeof JSON.stringify>[1], space?: Parameters<typeof JSON.stringify>[2] }} */
+  minimizerOptions;
+  const [[, code]] = Object.entries(input);
+  const result = JSON.stringify(JSON.parse(code), options.replacer, options.space);
+  return {
+    code: result
+  };
+}
+jsonMinify.getMinimizerVersion = () => "1.0.0";
+jsonMinify.supportsWorker = () => false;
+jsonMinify.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a JSON file
+ */
+jsonMinify.filter = name => JSON_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Minify HTML using `html-minifier-terser`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map (ignored for HTML)
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function htmlMinifierTerser(input, sourceMap, minimizerOptions) {
+  let htmlMinifier;
+  try {
+    htmlMinifier = require("html-minifier-terser");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[, code]] = Object.entries(input);
+  /** @type {import("html-minifier-terser").Options} */
+  const defaultMinimizerOptions = {
+    caseSensitive: true,
+    // `collapseBooleanAttributes` is not always safe, since this can break CSS attribute selectors and not safe for XHTML
+    collapseWhitespace: true,
+    conservativeCollapse: true,
+    keepClosingSlash: true,
+    // We need ability to use cssnano, or setup own function without extra dependencies
+    minifyCSS: true,
+    minifyJS: true,
+    // `minifyURLs` is unsafe, because we can't guarantee what the base URL is
+    // `removeAttributeQuotes` is not safe in some rare cases, also HTML spec recommends against doing this
+    removeComments: true,
+    // `removeEmptyAttributes` is not safe, can affect certain style or script behavior, look at https://github.com/webpack-contrib/html-loader/issues/323
+    // `removeRedundantAttributes` is not safe, can affect certain style or script behavior, look at https://github.com/webpack-contrib/html-loader/issues/323
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true
+    // `useShortDoctype` is not safe for XHTML
+  };
+  const result = await htmlMinifier.minify(code, {
+    ...defaultMinimizerOptions,
+    ...(/** @type {import("html-minifier-terser").Options} */minimizerOptions)
+  });
+  return {
+    code: result
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+htmlMinifierTerser.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("html-minifier-terser/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker threads are supported
+ */
+htmlMinifierTerser.supportsWorkerThreads = () => true;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like an HTML file
+ */
+htmlMinifierTerser.filter = name => HTML_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Minify HTML using `@minify-html/node`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map (ignored for HTML)
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function minifyHtmlNode(input, sourceMap, minimizerOptions) {
+  let minifyHtmlPkg;
+  try {
+    minifyHtmlPkg = require("@minify-html/node");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[, code]] = Object.entries(input);
+  const options = /** @type {Parameters<import("@minify-html/node").minify>[1]} */{
+    ...minimizerOptions
+  };
+  const result = await minifyHtmlPkg.minify(Buffer.from(code), options);
+  return {
+    code: result.toString()
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+minifyHtmlNode.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("@minify-html/node/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} false because `@minify-html/node` is a native binding
+ */
+minifyHtmlNode.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like an HTML file
+ */
+minifyHtmlNode.filter = name => HTML_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Map an `@swc/html` diagnostic to a regular `Error`.
+ * @param {EXPECTED_OBJECT} diagnostic diagnostic from `@swc/html`
+ * @returns {Error} error preserving `span` and `level` from the diagnostic
+ */
+function swcHtmlDiagnosticToError(diagnostic) {
+  const typed = /** @type {{ message: string, span?: unknown, level?: unknown }} */
+  diagnostic;
+  /** @type {Error & { span?: unknown, level?: unknown }} */
+  const error = new Error(typed.message);
+  error.span = typed.span;
+  error.level = typed.level;
+  return error;
+}
+
+/* istanbul ignore next */
+/**
+ * Minify a complete HTML document using `@swc/html`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map (ignored for HTML)
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function swcMinifyHtml(input, sourceMap, minimizerOptions) {
+  let swcMinifier;
+  try {
+    swcMinifier = require("@swc/html");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[, code]] = Object.entries(input);
+  const options = /** @type {import("@swc/html").Options} */{
+    ...minimizerOptions
+  };
+  const result = await swcMinifier.minify(Buffer.from(code), options);
+  return {
+    code: result.code,
+    errors: result.errors ? result.errors.map(swcHtmlDiagnosticToError) : undefined
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+swcMinifyHtml.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("@swc/html/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} false because `@swc/html` is a native binding
+ */
+swcMinifyHtml.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like an HTML file
+ */
+swcMinifyHtml.filter = name => HTML_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Minify an HTML fragment using `@swc/html`.
+ *
+ * Use this for partial HTML (e.g. inside `<template></template>` tags or
+ * HTML strings that are inserted into another document).
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map (ignored for HTML)
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function swcMinifyHtmlFragment(input, sourceMap, minimizerOptions) {
+  let swcMinifier;
+  try {
+    swcMinifier = require("@swc/html");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[, code]] = Object.entries(input);
+  const options = /** @type {import("@swc/html").FragmentOptions} */{
+    ...minimizerOptions
+  };
+  const result = await swcMinifier.minifyFragment(Buffer.from(code), options);
+  return {
+    code: result.code,
+    errors: result.errors ? result.errors.map(swcHtmlDiagnosticToError) : undefined
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+swcMinifyHtmlFragment.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("@swc/html/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} false because `@swc/html` is a native binding
+ */
+swcMinifyHtmlFragment.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like an HTML file
+ */
+swcMinifyHtmlFragment.filter = name => HTML_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Minify CSS using `cssnano` (via `postcss`).
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function cssnanoMinify(input, sourceMap, minimizerOptions = {
+  preset: "default"
+}) {
+  /**
+   * @template T
+   * @param {string} mod module to load
+   * @returns {Promise<T>} loaded module
+   */
+  const load = async mod => {
+    let exports;
+    try {
+      exports = require(mod);
+      return exports;
+    } catch (err) {
+      let importESM;
+      try {
+        // eslint-disable-next-line no-new-func
+        importESM = new Function("id", "return import(id);");
+      } catch (_err) {
+        importESM = null;
+      }
+      if (/** @type {Error & { code: string }} */
+      err.code === "ERR_REQUIRE_ESM" && importESM) {
+        exports = await importESM(mod);
+        return exports.default;
+      }
+      throw err;
+    }
+  };
+  let postcss;
+  let cssnano;
+  try {
+    postcss = require("postcss");
+    cssnano = require("cssnano");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[name, code]] = Object.entries(input);
+  /** @type {import("postcss").ProcessOptions} */
+  const postcssOptions = {
+    from: name,
+    ... /** @type {{ processorOptions?: import("postcss").ProcessOptions }} */minimizerOptions.processorOptions
+  };
+  if (typeof postcssOptions.parser === "string") {
+    try {
+      postcssOptions.parser = await load(postcssOptions.parser);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.parser}" parser failed: ${ /** @type {Error} */error.message}\n\n(@${name})`, {
+        cause: error
+      });
+    }
+  }
+  if (typeof postcssOptions.stringifier === "string") {
+    try {
+      postcssOptions.stringifier = await load(postcssOptions.stringifier);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.stringifier}" stringifier failed: ${ /** @type {Error} */error.message}\n\n(@${name})`, {
+        cause: error
+      });
+    }
+  }
+  if (typeof postcssOptions.syntax === "string") {
+    try {
+      postcssOptions.syntax = await load(postcssOptions.syntax);
+    } catch (error) {
+      throw new Error(`Loading PostCSS "${postcssOptions.syntax}" syntax failed: ${ /** @type {Error} */error.message}\n\n(@${name})`, {
+        cause: error
+      });
+    }
+  }
+  if (sourceMap) {
+    postcssOptions.map = {
+      annotation: false
+    };
+  }
+  const result = await postcss.default([cssnano(minimizerOptions)]).process(code, postcssOptions);
+  return {
+    code: result.css,
+    map: result.map ? (/** @type {RawSourceMap} */
+    /** @type {unknown} */result.map.toJSON()) : undefined,
+    warnings: result.warnings().map(String)
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+cssnanoMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("cssnano/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker threads are supported
+ */
+cssnanoMinify.supportsWorkerThreads = () => true;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a CSS file
+ */
+cssnanoMinify.filter = name => CSS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Minify CSS using `csso`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function cssoMinify(input, sourceMap, minimizerOptions) {
+  let csso;
+  try {
+    csso = require("csso");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[filename, code]] = Object.entries(input);
+  const result = csso.minify(code, {
+    filename,
+    sourceMap: Boolean(sourceMap),
+    ...minimizerOptions
+  });
+  return {
+    code: result.css,
+    map: result.map ? (/** @type {RawSourceMap} */
+    /** @type {{ toJSON(): RawSourceMap }} */result.map.toJSON()) : undefined
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+cssoMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("csso/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker threads are supported
+ */
+cssoMinify.supportsWorkerThreads = () => true;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a CSS file
+ */
+cssoMinify.filter = name => CSS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Minify CSS using `clean-css`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function cleanCssMinify(input, sourceMap, minimizerOptions) {
+  let CleanCSS;
+  try {
+    CleanCSS = require("clean-css");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[name, code]] = Object.entries(input);
+  const result = await new CleanCSS({
+    sourceMap: Boolean(sourceMap),
+    ...minimizerOptions,
+    returnPromise: true
+  }).minify({
+    [name]: {
+      styles: code
+    }
+  });
+  const generatedSourceMap = result.sourceMap ? (/** @type {RawSourceMap} */
+  /** @type {{ toJSON(): RawSourceMap }} */(/** @type {unknown} */result.sourceMap).toJSON()) : undefined;
+
+  // workaround for source maps on windows
+  if (generatedSourceMap) {
+    const isWindowsPathSep = require("path").sep === "\\";
+    generatedSourceMap.sources = generatedSourceMap.sources.map(
+    /**
+     * @param {string | null} item path item
+     * @returns {string} normalized path
+     */
+    item => isWindowsPathSep ? (item || "").replace(/\\/g, "/") : item || "");
+  }
+  return {
+    code: result.styles,
+    map: generatedSourceMap,
+    warnings: result.warnings
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+cleanCssMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("clean-css/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} true if worker threads are supported
+ */
+cleanCssMinify.supportsWorkerThreads = () => true;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a CSS file
+ */
+cleanCssMinify.filter = name => CSS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Minify CSS using `esbuild` (with the CSS loader).
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function esbuildMinifyCss(input, sourceMap, minimizerOptions) {
+  /**
+   * @param {import("esbuild").TransformOptions & { ecma?: string | number, module?: boolean }=} esbuildOptions esbuild options
+   * @returns {import("esbuild").TransformOptions} built esbuild options
+   */
+  const buildEsbuildOptions = (esbuildOptions = {}) => {
+    // `module` and `ecma` are JavaScript-only concepts; the dispatcher
+    // injects them for every minimizer, but esbuild's CSS transform
+    // rejects unknown options.
+    delete esbuildOptions.ecma;
+    delete esbuildOptions.module;
+
+    // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+    return {
+      loader: "css",
+      minify: true,
+      legalComments: "inline",
+      ...esbuildOptions,
+      sourcemap: false
+    };
+  };
+  let esbuild;
+  try {
+    esbuild = require("esbuild");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+
+  // Copy `esbuild` options
+  const esbuildOptions = buildEsbuildOptions(minimizerOptions);
+
+  // Let `esbuild` generate a SourceMap
+  if (sourceMap) {
+    esbuildOptions.sourcemap = true;
+    esbuildOptions.sourcesContent = false;
+  }
+  const [[filename, code]] = Object.entries(input);
+  esbuildOptions.sourcefile = filename;
+  const result = await esbuild.transform(code, esbuildOptions);
+  return {
+    code: result.code,
+    map: result.map ? JSON.parse(result.map) : undefined,
+    warnings: result.warnings.length > 0 ? result.warnings.map(item => {
+      const plugin = item.pluginName ? `\nPlugin Name: ${item.pluginName}` : "";
+      const location = item.location ? `\n\n${item.location.file}:${item.location.line}:${item.location.column}:\n  ${item.location.line} | ${item.location.lineText}\n\nSuggestion: ${item.location.suggestion}` : "";
+      const notes = item.notes.length > 0 ? `\n\nNotes:\n${item.notes.map(note => `${note.location ? `[${note.location.file}:${note.location.line}:${note.location.column}] ` : ""}${note.text}${note.location ? `\nSuggestion: ${note.location.suggestion}` : ""}${note.location ? `\nLine text:\n${note.location.lineText}\n` : ""}`).join("\n")}` : "";
+      return `${item.text} [${item.id}]${plugin}${location}${item.detail ? `\nDetails:\n${item.detail}` : ""}${notes}`;
+    }) : []
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+esbuildMinifyCss.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("esbuild/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} false because `esbuild` is a native binding
+ */
+esbuildMinifyCss.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a CSS file
+ */
+esbuildMinifyCss.filter = name => CSS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Minify CSS using `lightningcss`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function lightningCssMinify(input, sourceMap, minimizerOptions) {
+  let lightningCss;
+  try {
+    lightningCss = require("lightningcss");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[filename, code]] = Object.entries(input);
+  /**
+   * @param {Partial<import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>>=} lightningCssOptions lightning css options
+   * @returns {import("lightningcss").TransformOptions<import("lightningcss").CustomAtRules>} built lightning css options
+   */
+  const buildLightningCssOptions = (lightningCssOptions = {}) => (
+  // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+  {
+    minify: true,
+    ...lightningCssOptions,
+    sourceMap: false,
+    filename,
+    code: new Uint8Array(Buffer.from(code))
+  });
+
+  // Copy `lightningCss` options
+  const lightningCssOptions = buildLightningCssOptions(minimizerOptions);
+
+  // Let `lightningcss` generate a SourceMap. The dispatcher in
+  // `minify.js` chains the previous step's map onto this one.
+  if (sourceMap) {
+    lightningCssOptions.sourceMap = true;
+  }
+  const result = lightningCss.transform(lightningCssOptions);
+  return {
+    code: result.code.toString(),
+    map: result.map ? JSON.parse(result.map.toString()) : undefined
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+lightningCssMinify.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("lightningcss/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} false because `lightningcss` is a native binding
+ */
+lightningCssMinify.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a CSS file
+ */
+lightningCssMinify.filter = name => CSS_FILE_RE.test(name);
+
+/* istanbul ignore next */
+/**
+ * Map a `@swc/css` diagnostic to a regular `Error`.
+ * @param {EXPECTED_OBJECT} diagnostic diagnostic from `@swc/css`
+ * @returns {Error} error preserving `span` and `level` from the diagnostic
+ */
+function swcCssDiagnosticToError(diagnostic) {
+  const typed = /** @type {{ message: string, span?: unknown, level?: unknown }} */
+  diagnostic;
+  /** @type {Error & { span?: unknown, level?: unknown }} */
+  const error = new Error(typed.message);
+  error.span = typed.span;
+  error.level = typed.level;
+  return error;
+}
+
+/* istanbul ignore next */
+/**
+ * Minify CSS using `@swc/css`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+async function swcMinifyCss(input, sourceMap, minimizerOptions) {
+  let swc;
+  try {
+    swc = require("@swc/css");
+  } catch (err) {
+    return {
+      errors: [(/** @type {Error} */err)]
+    };
+  }
+  const [[filename, code]] = Object.entries(input);
+  /**
+   * @param {Partial<import("@swc/css").MinifyOptions>=} swcOptions swc options
+   * @returns {import("@swc/css").MinifyOptions} built swc options
+   */
+  const buildSwcOptions = (swcOptions = {}) => (
+  // Need deep copy objects to avoid https://github.com/terser/terser/issues/366
+  {
+    ...swcOptions,
+    filename
+  });
+
+  // Copy `swc` options
+  const swcOptions = buildSwcOptions(minimizerOptions);
+
+  // Let `swc` generate a SourceMap
+  if (sourceMap) {
+    swcOptions.sourceMap = true;
+  }
+  const result = await swc.minify(Buffer.from(code), swcOptions);
+  return {
+    code: result.code.toString(),
+    map: result.map ? JSON.parse(result.map.toString()) : undefined,
+    errors: result.errors ? result.errors.map(swcCssDiagnosticToError) : undefined
+  };
+}
+
+/**
+ * @returns {string | undefined} the minimizer version
+ */
+swcMinifyCss.getMinimizerVersion = () => {
+  let packageJson;
+  try {
+    packageJson = require("@swc/css/package.json");
+  } catch (_err) {
+    // Ignore
+  }
+  return packageJson && packageJson.version;
+};
+
+/**
+ * @returns {boolean | undefined} false because `@swc/css` is a native binding
+ */
+swcMinifyCss.supportsWorkerThreads = () => false;
+
+/**
+ * @param {string} name asset name
+ * @returns {boolean} true if `name` looks like a CSS file
+ */
+swcMinifyCss.filter = name => CSS_FILE_RE.test(name);
+
+/**
+ * @template T
+ * @typedef {() => T} FunctionReturning
+ */
+
+/**
+ * @template T
+ * @param {FunctionReturning<T>} fn memorized function
+ * @returns {FunctionReturning<T>} new function
+ */
+function memoize(fn) {
+  let cache = false;
+  /** @type {T} */
+  let result;
+  return () => {
+    if (cache) {
+      return result;
+    }
+    result = fn();
+    cache = true;
+    // Allow to clean up memory for fn
+    // and all dependent resources
+    /** @type {FunctionReturning<T> | undefined} */
+    fn = undefined;
+    return /** @type {T} */result;
+  };
+}
+module.exports = {
+  cleanCssMinify,
+  cssnanoMinify,
+  cssoMinify,
+  esbuildMinify,
+  esbuildMinifyCss,
+  getEcmaVersion,
+  htmlMinifierTerser,
+  jsonMinify,
+  lightningCssMinify,
+  memoize,
+  minifyHtmlNode,
+  swcMinify,
+  swcMinifyCss,
+  swcMinifyHtml,
+  swcMinifyHtmlFragment,
+  terserMinify,
+  throttleAll,
+  uglifyJsMinify
+};
Index: frontend/node_modules/terser-webpack-plugin/package.json
===================================================================
--- frontend/node_modules/terser-webpack-plugin/package.json	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/package.json	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,167 @@
+{
+  "name": "terser-webpack-plugin",
+  "version": "5.6.0",
+  "description": "Minimizer plugin for webpack",
+  "keywords": [
+    "uglify",
+    "uglify-js",
+    "uglify-es",
+    "terser",
+    "swc",
+    "esbuild",
+    "html",
+    "html-minifier",
+    "html-minifier-terser",
+    "css",
+    "cssnano",
+    "csso",
+    "clean-css",
+    "lightningcss",
+    "webpack",
+    "webpack-plugin",
+    "minification",
+    "compress",
+    "compressor",
+    "min",
+    "minification",
+    "minifier",
+    "minify",
+    "optimize",
+    "optimizer"
+  ],
+  "homepage": "https://github.com/webpack/minimizer-webpack-plugin",
+  "bugs": "https://github.com/webpack/minimizer-webpack-plugin/issues",
+  "repository": "webpack/minimizer-webpack-plugin",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "license": "MIT",
+  "author": "webpack Contrib Team",
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "dist",
+    "types"
+  ],
+  "scripts": {
+    "clean": "del-cli dist types",
+    "prebuild": "npm run clean",
+    "build:serialize-javascript": "node ./scripts/copy-serialize-javascript.js",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir types && prettier \"types/**/*.ts\" --write",
+    "build:code": "babel src -d dist --copy-files",
+    "build": "npm-run-all -p \"build:**\"",
+    "security": "npm audit --production",
+    "lint:serialize-javascript": "node ./scripts/copy-serialize-javascript.js --check",
+    "lint:prettier": "prettier --list-different .",
+    "lint:code": "eslint --cache .",
+    "lint:spelling": "cspell \"**/*.*\"",
+    "lint:types": "tsc --pretty --noEmit",
+    "lint": "npm-run-all -l -p \"lint:**\"",
+    "fix:code": "npm run lint:code -- --fix",
+    "fix:prettier": "npm run lint:prettier -- --write",
+    "fix": "npm-run-all -l fix:code fix:prettier",
+    "test:base": "jest",
+    "test:watch": "npm run test:base -- --watch",
+    "test:coverage": "npm run test:base -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "husky install && npm run build",
+    "version": "changeset version",
+    "release": "npm run build && changeset publish"
+  },
+  "dependencies": {
+    "@jridgewell/trace-mapping": "^0.3.25",
+    "jest-worker": "^27.4.5",
+    "schema-utils": "^4.3.0",
+    "terser": "^5.31.1"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.24.7",
+    "@babel/core": "^7.24.7",
+    "@babel/preset-env": "^7.29.5",
+    "@changesets/cli": "^2.30.0",
+    "@changesets/get-github-info": "^0.8.0",
+    "@minify-html/node": "^0.16.4",
+    "@swc/core": "^1.15.30",
+    "@swc/css": "^0.0.28",
+    "@swc/html": "^1.15.30",
+    "@types/clean-css": "^4.2.11",
+    "@types/csso": "^5.0.4",
+    "@types/html-minifier-terser": "^7.0.2",
+    "@types/node": "^24.2.1",
+    "@types/serialize-javascript": "^5.0.2",
+    "@types/uglify-js": "^3.17.5",
+    "clean-css": "^5.3.3",
+    "copy-webpack-plugin": "^9.0.1",
+    "cspell": "^6.31.2",
+    "cssnano": "^7.1.9",
+    "csso": "^5.0.5",
+    "del": "^6.0.0",
+    "del-cli": "^3.0.1",
+    "esbuild": "^0.27.3",
+    "eslint": "^9.29.0",
+    "eslint-config-webpack": "^4.5.1",
+    "file-loader": "^6.2.0",
+    "html-minifier-terser": "^7.2.0",
+    "husky": "^7.0.2",
+    "jest": "^27.5.1",
+    "lightningcss": "^1.32.0",
+    "lint-staged": "^13.2.3",
+    "memfs": "^3.4.13",
+    "npm-run-all": "^4.1.5",
+    "postcss": "^8.5.14",
+    "prettier": "^3.6.0",
+    "prettier-2": "npm:prettier@^2",
+    "serialize-javascript": "^7.0.5",
+    "typescript": "^6.0.3",
+    "uglify-js": "^3.19.3",
+    "webpack": "^5.101.0",
+    "webpack-cli": "^4.10.0",
+    "worker-loader": "^3.0.8"
+  },
+  "peerDependencies": {
+    "webpack": "^5.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@minify-html/node": {
+      "optional": true
+    },
+    "@swc/core": {
+      "optional": true
+    },
+    "@swc/css": {
+      "optional": true
+    },
+    "@swc/html": {
+      "optional": true
+    },
+    "clean-css": {
+      "optional": true
+    },
+    "cssnano": {
+      "optional": true
+    },
+    "csso": {
+      "optional": true
+    },
+    "esbuild": {
+      "optional": true
+    },
+    "html-minifier-terser": {
+      "optional": true
+    },
+    "lightningcss": {
+      "optional": true
+    },
+    "postcss": {
+      "optional": true
+    },
+    "uglify-js": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">= 10.13.0"
+  }
+}
Index: frontend/node_modules/terser-webpack-plugin/types/index.d.ts
===================================================================
--- frontend/node_modules/terser-webpack-plugin/types/index.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/types/index.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,342 @@
+export = TerserPlugin;
+/**
+ * @template [T=import("terser").MinifyOptions]
+ */
+declare class TerserPlugin<T = import("terser").MinifyOptions> {
+  /**
+   * @private
+   * @param {unknown} input Input to check
+   * @returns {boolean} Whether input is a source map
+   */
+  private static isSourceMap;
+  /**
+   * @private
+   * @param {unknown} warning warning
+   * @param {string} file file
+   * @returns {Error} built warning
+   */
+  private static buildWarning;
+  /**
+   * @private
+   * @param {Error | ErrorObject | string} error error
+   * @param {string} file file
+   * @param {TraceMap=} sourceMap source map
+   * @param {Compilation["requestShortener"]=} requestShortener request shortener
+   * @returns {Error} built error
+   */
+  private static buildError;
+  /**
+   * @private
+   * @param {Parallel} parallel value of the `parallel` option
+   * @returns {number} number of cores for parallelism
+   */
+  private static getAvailableNumberOfCores;
+  /**
+   * @param {BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>=} options options
+   */
+  constructor(
+    options?:
+      | (BasePluginOptions & DefinedDefaultMinimizerAndOptions<T>)
+      | undefined,
+  );
+  /**
+   * @private
+   * @type {InternalPluginOptions<T>}
+   */
+  private options;
+  /**
+   * @private
+   * @param {Compiler} compiler compiler
+   * @param {Compilation} compilation compilation
+   * @param {Record<string, import("webpack").sources.Source>} assets assets
+   * @param {{ availableNumberOfCores: number }} optimizeOptions optimize options
+   * @returns {Promise<void>}
+   */
+  private optimize;
+  /**
+   * @param {Compiler} compiler compiler
+   * @returns {void}
+   */
+  apply(compiler: Compiler): void;
+}
+declare namespace TerserPlugin {
+  export {
+    terserMinify,
+    uglifyJsMinify,
+    swcMinify,
+    esbuildMinify,
+    jsonMinify,
+    htmlMinifierTerser,
+    swcMinifyHtml,
+    swcMinifyHtmlFragment,
+    minifyHtmlNode,
+    cssnanoMinify,
+    cssoMinify,
+    cleanCssMinify,
+    esbuildMinifyCss,
+    lightningCssMinify,
+    swcMinifyCss,
+    Schema,
+    Compiler,
+    Compilation,
+    Asset,
+    AssetInfo,
+    TemplatePath,
+    JestWorker,
+    RawSourceMap,
+    TraceMap,
+    Rule,
+    Rules,
+    EXPECTED_ANY,
+    EXPECTED_OBJECT,
+    ExtractCommentsFunction,
+    ExtractCommentsCondition,
+    ExtractCommentsFilename,
+    ExtractCommentsBanner,
+    ExtractCommentsObject,
+    ExtractCommentsOptions,
+    ErrorObject,
+    MinimizedResult,
+    Input,
+    CustomOptions,
+    InferDefaultType,
+    MinimizerOptions,
+    BasicMinimizerImplementation,
+    MinimizeFunctionHelpers,
+    MinimizerImplementation,
+    InternalOptions,
+    MinimizerWorker,
+    Parallel,
+    BasePluginOptions,
+    DefinedDefaultMinimizerAndOptions,
+    InternalPluginOptions,
+  };
+}
+import { terserMinify } from "./utils";
+import { uglifyJsMinify } from "./utils";
+import { swcMinify } from "./utils";
+import { esbuildMinify } from "./utils";
+import { jsonMinify } from "./utils";
+import { htmlMinifierTerser } from "./utils";
+import { swcMinifyHtml } from "./utils";
+import { swcMinifyHtmlFragment } from "./utils";
+import { minifyHtmlNode } from "./utils";
+import { cssnanoMinify } from "./utils";
+import { cssoMinify } from "./utils";
+import { cleanCssMinify } from "./utils";
+import { esbuildMinifyCss } from "./utils";
+import { lightningCssMinify } from "./utils";
+import { swcMinifyCss } from "./utils";
+type Schema = import("schema-utils/declarations/validate").Schema;
+type Compiler = import("webpack").Compiler;
+type Compilation = import("webpack").Compilation;
+type Asset = import("webpack").Asset;
+type AssetInfo = import("webpack").AssetInfo;
+type TemplatePath = import("webpack").TemplatePath;
+type JestWorker = import("jest-worker").Worker;
+type RawSourceMap = import("@jridgewell/trace-mapping").EncodedSourceMap & {
+  sources: string[];
+  sourcesContent?: string[];
+  file: string;
+};
+type TraceMap = import("@jridgewell/trace-mapping").TraceMap;
+type Rule = RegExp | string;
+type Rules = Rule[] | Rule;
+type EXPECTED_ANY = any;
+type EXPECTED_OBJECT = object;
+type ExtractCommentsFunction = (
+  astNode: EXPECTED_ANY,
+  comment: {
+    value: string;
+    type: "comment1" | "comment2" | "comment3" | "comment4";
+    pos: number;
+    line: number;
+    col: number;
+  },
+) => boolean;
+type ExtractCommentsCondition =
+  | boolean
+  | "all"
+  | "some"
+  | RegExp
+  | ExtractCommentsFunction;
+type ExtractCommentsFilename = TemplatePath;
+type ExtractCommentsBanner =
+  | boolean
+  | string
+  | ((commentsFile: string) => string);
+type ExtractCommentsObject = {
+  /**
+   * condition which comments need to be expected
+   */
+  condition?: ExtractCommentsCondition | undefined;
+  /**
+   * filename for extracted comments
+   */
+  filename?: ExtractCommentsFilename | undefined;
+  /**
+   * banner in filename for extracted comments
+   */
+  banner?: ExtractCommentsBanner | undefined;
+};
+type ExtractCommentsOptions = ExtractCommentsCondition | ExtractCommentsObject;
+type ErrorObject = {
+  /**
+   * message
+   */
+  message: string;
+  /**
+   * line number
+   */
+  line?: number | undefined;
+  /**
+   * column number
+   */
+  column?: number | undefined;
+  /**
+   * error stack trace
+   */
+  stack?: string | undefined;
+};
+type MinimizedResult = {
+  /**
+   * code
+   */
+  code?: string | undefined;
+  /**
+   * source map
+   */
+  map?: RawSourceMap | undefined;
+  /**
+   * errors
+   */
+  errors?: (Error | string)[] | undefined;
+  /**
+   * warnings
+   */
+  warnings?: (Error | string)[] | undefined;
+  /**
+   * extracted comments
+   */
+  extractedComments?: string[] | undefined;
+};
+type Input = {
+  [file: string]: string;
+};
+type CustomOptions = {
+  [key: string]: EXPECTED_ANY;
+};
+type InferDefaultType<T> = T extends infer U ? U : CustomOptions;
+type MinimizerOptions<T> = T extends EXPECTED_ANY[]
+  ? { [P in keyof T]?: T[P] & InferDefaultType<T[P]> }
+  : T & InferDefaultType<T>;
+type BasicMinimizerImplementation<T> = (
+  input: Input,
+  sourceMap: RawSourceMap | undefined,
+  minifyOptions: MinimizerOptions<T>,
+  extractComments: ExtractCommentsOptions | undefined,
+) => Promise<MinimizedResult> | MinimizedResult;
+type MinimizeFunctionHelpers = {
+  /**
+   * function that returns version of minimizer
+   */
+  getMinimizerVersion?: (() => string | undefined) | undefined;
+  /**
+   * true when minimizer support worker threads, otherwise false
+   */
+  supportsWorkerThreads?: (() => boolean | undefined) | undefined;
+  /**
+   * true when minimizer support worker, otherwise false
+   */
+  supportsWorker?: (() => boolean | undefined) | undefined;
+  /**
+   * return true when the minimizer supports the asset, otherwise false. When an array of minimizers is configured, each asset is dispatched only to the minimizers whose `filter` accepts it. Assets rejected by every minimizer in the array are skipped entirely.
+   */
+  filter?:
+    | ((name: string, info?: AssetInfo) => boolean | undefined)
+    | undefined;
+};
+type MinimizerImplementation<T> = T extends EXPECTED_ANY[]
+  ? {
+      [P in keyof T]: BasicMinimizerImplementation<T[P]> &
+        MinimizeFunctionHelpers;
+    }
+  : BasicMinimizerImplementation<T> & MinimizeFunctionHelpers;
+type InternalOptions<T> = {
+  /**
+   * name
+   */
+  name: string;
+  /**
+   * input
+   */
+  input: string;
+  /**
+   * input source map
+   */
+  inputSourceMap: RawSourceMap | undefined;
+  /**
+   * extract comments option
+   */
+  extractComments: ExtractCommentsOptions | undefined;
+  /**
+   * minimizer
+   */
+  minimizer: {
+    implementation: MinimizerImplementation<T>;
+    options: MinimizerOptions<T>;
+  };
+  /**
+   * true when code is a EC module, otherwise false
+   */
+  module?: boolean | undefined;
+  /**
+   * ecma version
+   */
+  ecma?: (number | string) | undefined;
+};
+type MinimizerWorker<T> = JestWorker & {
+  transform: (options: string) => Promise<MinimizedResult>;
+  minify: (options: InternalOptions<T>) => Promise<MinimizedResult>;
+};
+type Parallel = undefined | boolean | number;
+type BasePluginOptions = {
+  /**
+   * test rule
+   */
+  test?: Rules | undefined;
+  /**
+   * include rile
+   */
+  include?: Rules | undefined;
+  /**
+   * exclude rule
+   */
+  exclude?: Rules | undefined;
+  /**
+   * extract comments options
+   */
+  extractComments?: ExtractCommentsOptions | undefined;
+  /**
+   * parallel option
+   */
+  parallel?: Parallel | undefined;
+};
+type DefinedDefaultMinimizerAndOptions<T> =
+  T extends import("terser").MinifyOptions
+    ? {
+        minify?: MinimizerImplementation<T> | undefined;
+        minimizerOptions?: MinimizerOptions<T> | undefined;
+        terserOptions?: MinimizerOptions<T> | undefined;
+      }
+    : {
+        minify: MinimizerImplementation<T>;
+        minimizerOptions?: MinimizerOptions<T> | undefined;
+        terserOptions?: MinimizerOptions<T> | undefined;
+      };
+type InternalPluginOptions<T> = BasePluginOptions & {
+  minimizer: {
+    implementation: MinimizerImplementation<T>;
+    options: MinimizerOptions<T>;
+  };
+};
Index: frontend/node_modules/terser-webpack-plugin/types/minify.d.ts
===================================================================
--- frontend/node_modules/terser-webpack-plugin/types/minify.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/types/minify.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,17 @@
+export type MinimizedResult = import("./index.js").MinimizedResult;
+export type CustomOptions = import("./index.js").CustomOptions;
+export type RawSourceMap = import("./index.js").RawSourceMap;
+export type MinimizerOptions<T> = import("./index.js").MinimizerOptions<T>;
+/**
+ * @template T
+ * @param {import("./index.js").InternalOptions<T>} options options
+ * @returns {Promise<MinimizedResult>} minified result
+ */
+export function minify<T>(
+  options: import("./index.js").InternalOptions<T>,
+): Promise<MinimizedResult>;
+/**
+ * @param {string} options options
+ * @returns {Promise<MinimizedResult>} minified result
+ */
+export function transform(options: string): Promise<MinimizedResult>;
Index: frontend/node_modules/terser-webpack-plugin/types/serialize-javascript.d.ts
===================================================================
--- frontend/node_modules/terser-webpack-plugin/types/serialize-javascript.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/types/serialize-javascript.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,2 @@
+declare function _exports(obj: any, options: any): any;
+export = _exports;
Index: frontend/node_modules/terser-webpack-plugin/types/utils.d.ts
===================================================================
--- frontend/node_modules/terser-webpack-plugin/types/utils.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
+++ frontend/node_modules/terser-webpack-plugin/types/utils.d.ts	(revision 9af201e94b5a79beb92a30858fc54de4bc3b9449)
@@ -0,0 +1,452 @@
+export type Task<T> = () => Promise<T>;
+export type FunctionReturning<T> = () => T;
+export type ExtractCommentsOptions =
+  import("./index.js").ExtractCommentsOptions;
+export type ExtractCommentsFunction =
+  import("./index.js").ExtractCommentsFunction;
+export type ExtractCommentsCondition =
+  import("./index.js").ExtractCommentsCondition;
+export type Input = import("./index.js").Input;
+export type MinimizedResult = import("./index.js").MinimizedResult;
+export type CustomOptions = import("./index.js").CustomOptions;
+export type RawSourceMap = import("./index.js").RawSourceMap;
+export type EXPECTED_OBJECT = import("./index.js").EXPECTED_OBJECT;
+export type ExtractedComments = string[];
+/**
+ * Minify CSS using `clean-css`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function cleanCssMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace cleanCssMinify {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} true if worker threads are supported
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a CSS file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * Minify CSS using `cssnano` (via `postcss`).
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function cssnanoMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace cssnanoMinify {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} true if worker threads are supported
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a CSS file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * Minify CSS using `csso`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function cssoMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace cssoMinify {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} true if worker threads are supported
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a CSS file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function esbuildMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace esbuildMinify {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a JavaScript file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * Minify CSS using `esbuild` (with the CSS loader).
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function esbuildMinifyCss(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace esbuildMinifyCss {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} false because `esbuild` is a native binding
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a CSS file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * Map a webpack `output.environment` configuration to the highest
+ * ECMAScript version that the target is known to support. Returns `5`
+ * when no ES2015+ features are flagged.
+ * @param {NonNullable<NonNullable<import("webpack").Configuration["output"]>["environment"]>} environment environment
+ * @returns {number} ecma version (5, 2015, 2017 or 2020)
+ */
+export function getEcmaVersion(
+  environment: NonNullable<
+    NonNullable<import("webpack").Configuration["output"]>["environment"]
+  >,
+): number;
+/**
+ * Minify HTML using `html-minifier-terser`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map (ignored for HTML)
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function htmlMinifierTerser(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace htmlMinifierTerser {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} true if worker threads are supported
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like an HTML file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function jsonMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace jsonMinify {
+  function getMinimizerVersion(): string;
+  function supportsWorker(): boolean;
+  function supportsWorkerThreads(): boolean;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a JSON file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * Minify CSS using `lightningcss`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function lightningCssMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace lightningCssMinify {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} false because `lightningcss` is a native binding
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a CSS file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * @template T
+ * @typedef {() => T} FunctionReturning
+ */
+/**
+ * @template T
+ * @param {FunctionReturning<T>} fn memorized function
+ * @returns {FunctionReturning<T>} new function
+ */
+export function memoize<T>(fn: FunctionReturning<T>): FunctionReturning<T>;
+/**
+ * Minify HTML using `@minify-html/node`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map (ignored for HTML)
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function minifyHtmlNode(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace minifyHtmlNode {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} false because `@minify-html/node` is a native binding
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like an HTML file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @param {ExtractCommentsOptions=} extractComments extract comments option
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function swcMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+  extractComments?: ExtractCommentsOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace swcMinify {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a JavaScript file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * Minify CSS using `@swc/css`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function swcMinifyCss(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace swcMinifyCss {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} false because `@swc/css` is a native binding
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a CSS file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * Minify a complete HTML document using `@swc/html`.
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map (ignored for HTML)
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function swcMinifyHtml(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace swcMinifyHtml {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} false because `@swc/html` is a native binding
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like an HTML file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * Minify an HTML fragment using `@swc/html`.
+ *
+ * Use this for partial HTML (e.g. inside `<template></template>` tags or
+ * HTML strings that are inserted into another document).
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map (ignored for HTML)
+ * @param {CustomOptions=} minimizerOptions options
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function swcMinifyHtmlFragment(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace swcMinifyHtmlFragment {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} false because `@swc/html` is a native binding
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like an HTML file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @param {ExtractCommentsOptions=} extractComments extract comments option
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function terserMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+  extractComments?: ExtractCommentsOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace terserMinify {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a JavaScript file
+   */
+  function filter(name: string): boolean;
+}
+/**
+ * @template T
+ * @typedef {() => Promise<T>} Task
+ */
+/**
+ * Run tasks with limited concurrency.
+ * @template T
+ * @param {number} limit Limit of tasks that run at once.
+ * @param {Task<T>[]} tasks List of tasks to run.
+ * @returns {Promise<T[]>} A promise that fulfills to an array of the results
+ */
+export function throttleAll<T>(limit: number, tasks: Task<T>[]): Promise<T[]>;
+/**
+ * @param {Input} input input
+ * @param {RawSourceMap=} sourceMap source map
+ * @param {CustomOptions=} minimizerOptions options
+ * @param {ExtractCommentsOptions=} extractComments extract comments option
+ * @returns {Promise<MinimizedResult>} minimized result
+ */
+export function uglifyJsMinify(
+  input: Input,
+  sourceMap?: RawSourceMap | undefined,
+  minimizerOptions?: CustomOptions | undefined,
+  extractComments?: ExtractCommentsOptions | undefined,
+): Promise<MinimizedResult>;
+export namespace uglifyJsMinify {
+  /**
+   * @returns {string | undefined} the minimizer version
+   */
+  function getMinimizerVersion(): string | undefined;
+  /**
+   * @returns {boolean | undefined} true if worker thread is supported, false otherwise
+   */
+  function supportsWorkerThreads(): boolean | undefined;
+  /**
+   * @param {string} name asset name
+   * @returns {boolean} true if `name` looks like a JavaScript file
+   */
+  function filter(name: string): boolean;
+}