up n_m

node_modules/webpack-dev-middleware/LICENSE

@@ -0,0 +1,20 @@
+Copyright JS Foundation and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/webpack-dev-middleware/README.md

@@ -0,0 +1,542 @@
+<div align="center">
+  <a href="https://github.com/webpack/webpack">
+    <img width="200" height="200" src="https://webpack.js.org/assets/icon-square-big.svg">
+  </a>
+</div>
+
+[![npm][npm]][npm-url]
+[![node][node]][node-url]
+[![deps][deps]][deps-url]
+[![tests][tests]][tests-url]
+[![coverage][cover]][cover-url]
+[![chat][chat]][chat-url]
+[![size][size]][size-url]
+
+# webpack-dev-middleware
+
+An express-style development middleware for use with [webpack](https://webpack.js.org)
+bundles and allows for serving of the files emitted from webpack.
+This should be used for **development only**.
+
+Some of the benefits of using this middleware include:
+
+- No files are written to disk, rather it handles files in memory
+- If files changed in watch mode, the middleware delays requests until compiling
+  has completed.
+- Supports hot module reload (HMR).
+
+## Getting Started
+
+First thing's first, install the module:
+
+```console
+npm install webpack-dev-middleware --save-dev
+```
+
+_Note: We do not recommend installing this module globally._
+
+## Usage
+
+```js
+const webpack = require("webpack");
+const middleware = require("webpack-dev-middleware");
+const compiler = webpack({
+  // webpack options
+});
+const express = require("express");
+const app = express();
+
+app.use(
+  middleware(compiler, {
+    // webpack-dev-middleware options
+  })
+);
+
+app.listen(3000, () => console.log("Example app listening on port 3000!"));
+```
+
+See [below](#other-servers) for an example of use with fastify.
+
+## Options
+
+|                    Name                     |           Type            |                    Default                    | Description                                                                                                          |
+| :-----------------------------------------: | :-----------------------: | :-------------------------------------------: | :------------------------------------------------------------------------------------------------------------------- |
+|          **[`methods`](#methods)**          |          `Array`          |              `[ 'GET', 'HEAD' ]`              | Allows to pass the list of HTTP request methods accepted by the middleware                                           |
+|          **[`headers`](#headers)**          | `Array\|Object\|Function` |                  `undefined`                  | Allows to pass custom HTTP headers on each request.                                                                  |
+|            **[`index`](#index)**            |     `Boolean\|String`     |                 `index.html`                  | If `false` (but not `undefined`), the server will not respond to requests to the root URL.                           |
+|        **[`mimeTypes`](#mimetypes)**        |         `Object`          |                  `undefined`                  | Allows to register custom mime types or extension mappings.                                                          |
+|       **[`publicPath`](#publicpath)**       |         `String`          |  `output.publicPath` (from a configuration)   | The public path that the middleware is bound to.                                                                     |
+|            **[`stats`](#stats)**            | `Boolean\|String\|Object` |        `stats` (from a configuration)         | Stats options object or preset name.                                                                                 |
+| **[`serverSideRender`](#serversiderender)** |         `Boolean`         |                  `undefined`                  | Instructs the module to enable or disable the server-side rendering mode.                                            |
+|      **[`writeToDisk`](#writetodisk)**      |    `Boolean\|Function`    |                    `false`                    | Instructs the module to write files to the configured location on disk as specified in your `webpack` configuration. |
+| **[`outputFileSystem`](#outputfilesystem)** |         `Object`          | [`memfs`](https://github.com/streamich/memfs) | Set the default file system which will be used by webpack as primary destination of generated files.                 |
+
+The middleware accepts an `options` Object. The following is a property reference for the Object.
+
+### methods
+
+Type: `Array`  
+Default: `[ 'GET', 'HEAD' ]`
+
+This property allows a user to pass the list of HTTP request methods accepted by the middleware\*\*.
+
+### headers
+
+Type: `Array|Object|Function`
+Default: `undefined`
+
+This property allows a user to pass custom HTTP headers on each request.
+eg. `{ "X-Custom-Header": "yes" }`
+
+or
+
+```js
+webpackDevMiddleware(compiler, {
+  headers: () => {
+    return {
+      "Last-Modified": new Date(),
+    };
+  },
+});
+```
+
+or
+
+```js
+webpackDevMiddleware(compiler, {
+  headers: (req, res, context) => {
+    res.setHeader("Last-Modified", new Date());
+  },
+});
+```
+
+or
+
+```js
+webpackDevMiddleware(compiler, {
+  headers: [
+    {
+      key: "X-custom-header"
+      value: "foo"
+    },
+    {
+      key: "Y-custom-header",
+      value: "bar"
+    }
+  ]
+  },
+});
+```
+
+or
+
+```js
+webpackDevMiddleware(compiler, {
+  headers: () => [
+    {
+      key: "X-custom-header"
+      value: "foo"
+    },
+    {
+      key: "Y-custom-header",
+      value: "bar"
+    }
+  ]
+  },
+});
+```
+
+### index
+
+Type: `Boolean|String`
+Default: `index.html`
+
+If `false` (but not `undefined`), the server will not respond to requests to the root URL.
+
+### mimeTypes
+
+Type: `Object`  
+Default: `undefined`
+
+This property allows a user to register custom mime types or extension mappings.
+eg. `mimeTypes: { phtml: 'text/html' }`.
+
+Please see the documentation for [`mime-types`](https://github.com/jshttp/mime-types) for more information.
+
+### publicPath
+
+Type: `String`
+Default: `output.publicPath` (from a configuration)
+
+The public path that the middleware is bound to.
+
+_Best Practice: use the same `publicPath` defined in your webpack config. For more information about `publicPath`, please see [the webpack documentation](https://webpack.js.org/guides/public-path)._
+
+### stats
+
+Type: `Boolean|String|Object`
+Default: `stats` (from a configuration)
+
+Stats options object or preset name.
+
+### serverSideRender
+
+Type: `Boolean`  
+Default: `undefined`
+
+Instructs the module to enable or disable the server-side rendering mode.
+Please see [Server-Side Rendering](#server-side-rendering) for more information.
+
+### writeToDisk
+
+Type: `Boolean|Function`  
+Default: `false`
+
+If `true`, the option will instruct the module to write files to the configured location on disk as specified in your `webpack` config file.
+_Setting `writeToDisk: true` won't change the behavior of the `webpack-dev-middleware`, and bundle files accessed through the browser will still be served from memory._
+This option provides the same capabilities as the [`WriteFilePlugin`](https://github.com/gajus/write-file-webpack-plugin/pulls).
+
+This option also accepts a `Function` value, which can be used to filter which files are written to disk.
+The function follows the same premise as [`Array#filter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) in which a return value of `false` _will not_ write the file, and a return value of `true` _will_ write the file to disk. eg.
+
+```js
+const webpack = require("webpack");
+const configuration = {
+  /* Webpack configuration */
+};
+const compiler = webpack(configuration);
+
+middleware(compiler, {
+  writeToDisk: (filePath) => {
+    return /superman\.css$/.test(filePath);
+  },
+});
+```
+
+### outputFileSystem
+
+Type: `Object`  
+Default: [memfs](https://github.com/streamich/memfs)
+
+Set the default file system which will be used by webpack as primary destination of generated files.
+This option isn't affected by the [writeToDisk](#writeToDisk) option.
+
+You have to provide `.join()` and `mkdirp` method to the `outputFileSystem` instance manually for compatibility with `webpack@4`.
+
+This can be done simply by using `path.join`:
+
+```js
+const webpack = require("webpack");
+const path = require("path");
+const myOutputFileSystem = require("my-fs");
+const mkdirp = require("mkdirp");
+
+myOutputFileSystem.join = path.join.bind(path); // no need to bind
+myOutputFileSystem.mkdirp = mkdirp.bind(mkdirp); // no need to bind
+
+const compiler = webpack({
+  /* Webpack configuration */
+});
+
+middleware(compiler, { outputFileSystem: myOutputFileSystem });
+```
+
+## API
+
+`webpack-dev-middleware` also provides convenience methods that can be use to
+interact with the middleware at runtime:
+
+### `close(callback)`
+
+Instructs `webpack-dev-middleware` instance to stop watching for file changes.
+
+#### Parameters
+
+##### `callback`
+
+Type: `Function`
+Required: `No`
+
+A function executed once the middleware has stopped watching.
+
+```js
+const express = require("express");
+const webpack = require("webpack");
+const compiler = webpack({
+  /* Webpack configuration */
+});
+const middleware = require("webpack-dev-middleware");
+const instance = middleware(compiler);
+
+const app = new express();
+
+app.use(instance);
+
+setTimeout(() => {
+  // Says `webpack` to stop watch changes
+  instance.close();
+}, 1000);
+```
+
+### `invalidate(callback)`
+
+Instructs `webpack-dev-middleware` instance to recompile the bundle, e.g. after a change to the configuration.
+
+#### Parameters
+
+##### `callback`
+
+Type: `Function`
+Required: `No`
+
+A function executed once the middleware has invalidated.
+
+```js
+const express = require("express");
+const webpack = require("webpack");
+const compiler = webpack({
+  /* Webpack configuration */
+});
+const middleware = require("webpack-dev-middleware");
+const instance = middleware(compiler);
+
+const app = new express();
+
+app.use(instance);
+
+setTimeout(() => {
+  // After a short delay the configuration is changed and a banner plugin is added to the config
+  new webpack.BannerPlugin("A new banner").apply(compiler);
+
+  // Recompile the bundle with the banner plugin:
+  instance.invalidate();
+}, 1000);
+```
+
+### `waitUntilValid(callback)`
+
+Executes a callback function when the compiler bundle is valid, typically after
+compilation.
+
+#### Parameters
+
+##### `callback`
+
+Type: `Function`
+Required: `No`
+
+A function executed when the bundle becomes valid.
+If the bundle is valid at the time of calling, the callback is executed immediately.
+
+```js
+const express = require("express");
+const webpack = require("webpack");
+const compiler = webpack({
+  /* Webpack configuration */
+});
+const middleware = require("webpack-dev-middleware");
+const instance = middleware(compiler);
+
+const app = new express();
+
+app.use(instance);
+
+instance.waitUntilValid(() => {
+  console.log("Package is in a valid state");
+});
+```
+
+### `getFilenameFromUrl(url)`
+
+Get filename from URL.
+
+#### Parameters
+
+##### `url`
+
+Type: `String`
+Required: `Yes`
+
+URL for the requested file.
+
+```js
+const express = require("express");
+const webpack = require("webpack");
+const compiler = webpack({
+  /* Webpack configuration */
+});
+const middleware = require("webpack-dev-middleware");
+const instance = middleware(compiler);
+
+const app = new express();
+
+app.use(instance);
+
+instance.waitUntilValid(() => {
+  const filename = instance.getFilenameFromUrl("/bundle.js");
+
+  console.log(`Filename is ${filename}`);
+});
+```
+
+## Known Issues
+
+### Multiple Successive Builds
+
+Watching will frequently cause multiple compilations
+as the bundle changes during compilation. This is due in part to cross-platform
+differences in file watchers, so that webpack doesn't loose file changes when
+watched files change rapidly. If you run into this situation, please make use of
+the [`TimeFixPlugin`](https://github.com/egoist/time-fix-plugin).
+
+## Server-Side Rendering
+
+_Note: this feature is experimental and may be removed or changed completely in the future._
+
+In order to develop an app using server-side rendering, we need access to the
+[`stats`](https://github.com/webpack/docs/wiki/node.js-api#stats), which is
+generated with each build.
+
+With server-side rendering enabled, `webpack-dev-middleware` sets the `stats` to `res.locals.webpack.devMiddleware.context.stats`
+and the filesystem to `res.locals.webpack.devMiddleware.context.outputFileSystem` before invoking the next middleware,
+allowing a developer to render the page body and manage the response to clients.
+
+_Note: Requests for bundle files will still be handled by
+`webpack-dev-middleware` and all requests will be pending until the build
+process is finished with server-side rendering enabled._
+
+Example Implementation:
+
+```js
+const express = require("express");
+const webpack = require("webpack");
+const compiler = webpack({
+  /* Webpack configuration */
+});
+const isObject = require("is-object");
+const middleware = require("webpack-dev-middleware");
+
+const app = new express();
+
+// This function makes server rendering of asset references consistent with different webpack chunk/entry configurations
+function normalizeAssets(assets) {
+  if (isObject(assets)) {
+    return Object.values(assets);
+  }
+
+  return Array.isArray(assets) ? assets : [assets];
+}
+
+app.use(middleware(compiler, { serverSideRender: true }));
+
+// The following middleware would not be invoked until the latest build is finished.
+app.use((req, res) => {
+  const { devMiddleware } = res.locals.webpack;
+  const outputFileSystem = devMiddleware.context.outputFileSystem;
+  const jsonWebpackStats = devMiddleware.context.stats.toJson();
+  const { assetsByChunkName, outputPath } = jsonWebpackStats;
+
+  // Then use `assetsByChunkName` for server-side rendering
+  // For example, if you have only one main chunk:
+  res.send(`
+<html>
+  <head>
+    <title>My App</title>
+    <style>
+    ${normalizeAssets(assetsByChunkName.main)
+      .filter((path) => path.endsWith(".css"))
+      .map((path) => outputFileSystem.readFileSync(path.join(outputPath, path)))
+      .join("\n")}
+    </style>
+  </head>
+  <body>
+    <div id="root"></div>
+    ${normalizeAssets(assetsByChunkName.main)
+      .filter((path) => path.endsWith(".js"))
+      .map((path) => `<script src="${path}"></script>`)
+      .join("\n")}
+  </body>
+</html>
+  `);
+});
+```
+
+## Support
+
+We do our best to keep Issues in the repository focused on bugs, features, and
+needed modifications to the code for the module. Because of that, we ask users
+with general support, "how-to", or "why isn't this working" questions to try one
+of the other support channels that are available.
+
+Your first-stop-shop for support for webpack-dev-server should by the excellent
+[documentation][docs-url] for the module. If you see an opportunity for improvement
+of those docs, please head over to the [webpack.js.org repo][wjo-url] and open a
+pull request.
+
+From there, we encourage users to visit the [webpack Gitter chat][chat-url] and
+talk to the fine folks there. If your quest for answers comes up dry in chat,
+head over to [StackOverflow][stack-url] and do a quick search or open a new
+question. Remember; It's always much easier to answer questions that include your
+`webpack.config.js` and relevant files!
+
+If you're twitter-savvy you can tweet [#webpack][hash-url] with your question
+and someone should be able to reach out and lend a hand.
+
+If you have discovered a :bug:, have a feature suggestion, or would like to see
+a modification, please feel free to create an issue on Github. _Note: The issue
+template isn't optional, so please be sure not to remove it, and please fill it
+out completely._
+
+## Other servers
+
+Examples of use with other servers will follow here.
+
+### Fastify
+
+Fastify interop will require the use of `fastify-express` instead of `middie` for providing middleware support. As the authors of `fastify-express` recommend, this should only be used as a stopgap while full Fastify support is worked on.
+
+```js
+const fastify = require("fastify")();
+const webpack = require("webpack");
+const webpackConfig = require("./webpack.config.js");
+const devMiddleware = require("webpack-dev-middleware");
+
+const compiler = webpack(webpackConfig);
+const { publicPath } = webpackConfig.output;
+
+(async () => {
+  await fastify.register(require("fastify-express"));
+  await fastify.use(devMiddleware(compiler, { publicPath }));
+  await fastify.listen(3000);
+})();
+```
+
+## Contributing
+
+Please take a moment to read our contributing guidelines if you haven't yet done so.
+
+[CONTRIBUTING](./CONTRIBUTING.md)
+
+## License
+
+[MIT](./LICENSE)
+
+[npm]: https://img.shields.io/npm/v/webpack-dev-middleware.svg
+[npm-url]: https://npmjs.com/package/webpack-dev-middleware
+[node]: https://img.shields.io/node/v/webpack-dev-middleware.svg
+[node-url]: https://nodejs.org
+[deps]: https://david-dm.org/webpack/webpack-dev-middleware.svg
+[deps-url]: https://david-dm.org/webpack/webpack-dev-middleware
+[tests]: https://github.com/webpack/webpack-dev-middleware/workflows/webpack-dev-middleware/badge.svg
+[tests-url]: https://github.com/webpack/webpack-dev-middleware/actions
+[cover]: https://codecov.io/gh/webpack/webpack-dev-middleware/branch/master/graph/badge.svg
+[cover-url]: https://codecov.io/gh/webpack/webpack-dev-middleware
+[chat]: https://badges.gitter.im/webpack/webpack.svg
+[chat-url]: https://gitter.im/webpack/webpack
+[size]: https://packagephobia.com/badge?p=webpack-dev-middleware
+[size-url]: https://packagephobia.com/result?p=webpack-dev-middleware
+[docs-url]: https://webpack.js.org/guides/development/#using-webpack-dev-middleware
+[hash-url]: https://twitter.com/search?q=webpack
+[middleware-url]: https://github.com/webpack/webpack-dev-middleware
+[stack-url]: https://stackoverflow.com/questions/tagged/webpack-dev-middleware
+[wjo-url]: https://github.com/webpack/webpack.js.org

node_modules/webpack-dev-middleware/dist/index.js

@@ -0,0 +1,305 @@
+"use strict";
+
+const {
+  validate
+} = require("schema-utils");
+
+const mime = require("mime-types");
+
+const middleware = require("./middleware");
+
+const getFilenameFromUrl = require("./utils/getFilenameFromUrl");
+
+const setupHooks = require("./utils/setupHooks");
+
+const setupWriteToDisk = require("./utils/setupWriteToDisk");
+
+const setupOutputFileSystem = require("./utils/setupOutputFileSystem");
+
+const ready = require("./utils/ready");
+
+const schema = require("./options.json");
+
+const noop = () => {};
+/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
+
+/** @typedef {import("webpack").Compiler} Compiler */
+
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+
+/** @typedef {import("webpack").Configuration} Configuration */
+
+/** @typedef {import("webpack").Stats} Stats */
+
+/** @typedef {import("webpack").MultiStats} MultiStats */
+
+/**
+ * @typedef {Object} ExtendedServerResponse
+ * @property {{ webpack?: { devMiddleware?: Context<IncomingMessage, ServerResponse> } }} [locals]
+ */
+
+/** @typedef {import("http").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("http").ServerResponse & ExtendedServerResponse} ServerResponse */
+
+/**
+ * @callback NextFunction
+ * @param {any} [err]
+ * @return {void}
+ */
+
+/**
+ * @typedef {NonNullable<Configuration["watchOptions"]>} WatchOptions
+ */
+
+/**
+ * @typedef {Compiler["watching"]} Watching
+ */
+
+/**
+ * @typedef {ReturnType<Compiler["watch"]>} MultiWatching
+ */
+
+/**
+ * @typedef {Compiler["outputFileSystem"] & { createReadStream?: import("fs").createReadStream, statSync?: import("fs").statSync, lstat?: import("fs").lstat, readFileSync?: import("fs").readFileSync }} OutputFileSystem
+ */
+
+/** @typedef {ReturnType<Compiler["getInfrastructureLogger"]>} Logger */
+
+/**
+ * @callback Callback
+ * @param {Stats | MultiStats} [stats]
+ */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Object} Context
+ * @property {boolean} state
+ * @property {Stats | MultiStats | undefined} stats
+ * @property {Callback[]} callbacks
+ * @property {Options<Request, Response>} options
+ * @property {Compiler | MultiCompiler} compiler
+ * @property {Watching | MultiWatching} watching
+ * @property {Logger} logger
+ * @property {OutputFileSystem} outputFileSystem
+ */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Record<string, string | number> | Array<{ key: string, value: number | string }> | ((req: Request, res: Response, context: Context<Request, Response>) =>  void | undefined | Record<string, string | number>) | undefined} Headers
+ */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Object} Options
+ * @property {{[key: string]: string}} [mimeTypes]
+ * @property {boolean | ((targetPath: string) => boolean)} [writeToDisk]
+ * @property {string} [methods]
+ * @property {Headers<Request, Response>} [headers]
+ * @property {NonNullable<Configuration["output"]>["publicPath"]} [publicPath]
+ * @property {Configuration["stats"]} [stats]
+ * @property {boolean} [serverSideRender]
+ * @property {OutputFileSystem} [outputFileSystem]
+ * @property {boolean | string} [index]
+ */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @callback Middleware
+ * @param {Request} req
+ * @param {Response} res
+ * @param {NextFunction} next
+ * @return {Promise<void>}
+ */
+
+/**
+ * @callback GetFilenameFromUrl
+ * @param {string} url
+ * @returns {string | undefined}
+ */
+
+/**
+ * @callback WaitUntilValid
+ * @param {Callback} callback
+ */
+
+/**
+ * @callback Invalidate
+ * @param {Callback} callback
+ */
+
+/**
+ * @callback Close
+ * @param {(err: Error | null | undefined) => void} callback
+ */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Object} AdditionalMethods
+ * @property {GetFilenameFromUrl} getFilenameFromUrl
+ * @property {WaitUntilValid} waitUntilValid
+ * @property {Invalidate} invalidate
+ * @property {Close} close
+ * @property {Context<Request, Response>} context
+ */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Middleware<Request, Response> & AdditionalMethods<Request, Response>} API
+ */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {Compiler | MultiCompiler} compiler
+ * @param {Options<Request, Response>} [options]
+ * @returns {API<Request, Response>}
+ */
+
+
+function wdm(compiler, options = {}) {
+  validate(
+  /** @type {Schema} */
+  schema, options, {
+    name: "Dev Middleware",
+    baseDataPath: "options"
+  });
+  const {
+    mimeTypes
+  } = options;
+
+  if (mimeTypes) {
+    const {
+      types
+    } = mime; // mimeTypes from user provided options should take priority
+    // over existing, known types
+    // @ts-ignore
+
+    mime.types = { ...types,
+      ...mimeTypes
+    };
+  }
+  /**
+   * @type {Context<Request, Response>}
+   */
+
+
+  const context = {
+    state: false,
+    // eslint-disable-next-line no-undefined
+    stats: undefined,
+    callbacks: [],
+    options,
+    compiler,
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    watching: undefined,
+    logger: compiler.getInfrastructureLogger("webpack-dev-middleware"),
+    // @ts-ignore
+    // eslint-disable-next-line no-undefined
+    outputFileSystem: undefined
+  };
+  setupHooks(context);
+
+  if (options.writeToDisk) {
+    setupWriteToDisk(context);
+  }
+
+  setupOutputFileSystem(context); // Start watching
+
+  if (
+  /** @type {Compiler} */
+  context.compiler.watching) {
+    context.watching =
+    /** @type {Compiler} */
+    context.compiler.watching;
+  } else {
+    /**
+     * @type {WatchOptions | WatchOptions[]}
+     */
+    let watchOptions;
+    /**
+     * @param {Error | null | undefined} error
+     */
+
+    const errorHandler = error => {
+      if (error) {
+        // TODO: improve that in future
+        // For example - `writeToDisk` can throw an error and right now it is ends watching.
+        // We can improve that and keep watching active, but it is require API on webpack side.
+        // Let's implement that in webpack@5 because it is rare case.
+        context.logger.error(error);
+      }
+    };
+
+    if (Array.isArray(
+    /** @type {MultiCompiler} */
+    context.compiler.compilers)) {
+      watchOptions =
+      /** @type {MultiCompiler} */
+      context.compiler.compilers.map(
+      /**
+       * @param {Compiler} childCompiler
+       * @returns {WatchOptions}
+       */
+      childCompiler => childCompiler.options.watchOptions || {});
+      context.watching =
+      /** @type {MultiWatching} */
+      context.compiler.watch(
+      /** @type {WatchOptions}} */
+      watchOptions, errorHandler);
+    } else {
+      watchOptions =
+      /** @type {Compiler} */
+      context.compiler.options.watchOptions || {};
+      context.watching =
+      /** @type {Watching} */
+      context.compiler.watch(watchOptions, errorHandler);
+    }
+  }
+
+  const instance =
+  /** @type {API<Request, Response>} */
+  middleware(context); // API
+
+  /** @type {API<Request, Response>} */
+
+  instance.getFilenameFromUrl =
+  /**
+   * @param {string} url
+   * @returns {string|undefined}
+   */
+  url => getFilenameFromUrl(context, url);
+  /** @type {API<Request, Response>} */
+
+
+  instance.waitUntilValid = (callback = noop) => {
+    ready(context, callback);
+  };
+  /** @type {API<Request, Response>} */
+
+
+  instance.invalidate = (callback = noop) => {
+    ready(context, callback);
+    context.watching.invalidate();
+  };
+  /** @type {API<Request, Response>} */
+
+
+  instance.close = (callback = noop) => {
+    context.watching.close(callback);
+  };
+  /** @type {API<Request, Response>} */
+
+
+  instance.context = context;
+  return instance;
+}
+
+module.exports = wdm;

node_modules/webpack-dev-middleware/dist/middleware.js

@@ -0,0 +1,249 @@
+"use strict";
+
+const path = require("path");
+
+const mime = require("mime-types");
+
+const parseRange = require("range-parser");
+
+const getFilenameFromUrl = require("./utils/getFilenameFromUrl");
+
+const {
+  getHeaderNames,
+  getHeaderFromRequest,
+  getHeaderFromResponse,
+  setHeaderForResponse,
+  setStatusCode,
+  send,
+  sendError
+} = require("./utils/compatibleAPI");
+
+const ready = require("./utils/ready");
+/** @typedef {import("./index.js").NextFunction} NextFunction */
+
+/** @typedef {import("./index.js").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("./index.js").ServerResponse} ServerResponse */
+
+/**
+ * @param {string} type
+ * @param {number} size
+ * @param {import("range-parser").Range} [range]
+ * @returns {string}
+ */
+
+
+function getValueContentRangeHeader(type, size, range) {
+  return `${type} ${range ? `${range.start}-${range.end}` : "*"}/${size}`;
+}
+/**
+ * @param {string | number} title
+ * @param {string} body
+ * @returns {string}
+ */
+
+
+function createHtmlDocument(title, body) {
+  return `${"<!DOCTYPE html>\n" + '<html lang="en">\n' + "<head>\n" + '<meta charset="utf-8">\n' + "<title>"}${title}</title>\n` + `</head>\n` + `<body>\n` + `<pre>${body}</pre>\n` + `</body>\n` + `</html>\n`;
+}
+
+const BYTES_RANGE_REGEXP = /^ *bytes/i;
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("./index.js").Context<Request, Response>} context
+ * @return {import("./index.js").Middleware<Request, Response>}
+ */
+
+function wrapper(context) {
+  return async function middleware(req, res, next) {
+    const acceptedMethods = context.options.methods || ["GET", "HEAD"]; // fixes #282. credit @cexoso. in certain edge situations res.locals is undefined.
+    // eslint-disable-next-line no-param-reassign
+
+    res.locals = res.locals || {};
+
+    if (req.method && !acceptedMethods.includes(req.method)) {
+      await goNext();
+      return;
+    }
+
+    ready(context, processRequest, req);
+
+    async function goNext() {
+      if (!context.options.serverSideRender) {
+        return next();
+      }
+
+      return new Promise(resolve => {
+        ready(context, () => {
+          /** @type {any} */
+          // eslint-disable-next-line no-param-reassign
+          res.locals.webpack = {
+            devMiddleware: context
+          };
+          resolve(next());
+        }, req);
+      });
+    }
+
+    async function processRequest() {
+      /** @type {import("./utils/getFilenameFromUrl").Extra} */
+      const extra = {};
+      const filename = getFilenameFromUrl(context,
+      /** @type {string} */
+      req.url, extra);
+
+      if (!filename) {
+        await goNext();
+        return;
+      }
+
+      if (extra.errorCode) {
+        if (extra.errorCode === 403) {
+          context.logger.error(`Malicious path "${filename}".`);
+        }
+
+        sendError(req, res, extra.errorCode);
+        return;
+      }
+
+      let {
+        headers
+      } = context.options;
+
+      if (typeof headers === "function") {
+        // @ts-ignore
+        headers = headers(req, res, context);
+      }
+      /**
+       * @type {{key: string, value: string | number}[]}
+       */
+
+
+      const allHeaders = [];
+
+      if (typeof headers !== "undefined") {
+        if (!Array.isArray(headers)) {
+          // eslint-disable-next-line guard-for-in
+          for (const name in headers) {
+            // @ts-ignore
+            allHeaders.push({
+              key: name,
+              value: headers[name]
+            });
+          }
+
+          headers = allHeaders;
+        }
+
+        headers.forEach(
+        /**
+         * @param {{key: string, value: any}} header
+         */
+        header => {
+          setHeaderForResponse(res, header.key, header.value);
+        });
+      }
+
+      if (!getHeaderFromResponse(res, "Content-Type")) {
+        // content-type name(like application/javascript; charset=utf-8) or false
+        const contentType = mime.contentType(path.extname(filename)); // Only set content-type header if media type is known
+        // https://tools.ietf.org/html/rfc7231#section-3.1.1.5
+
+        if (contentType) {
+          setHeaderForResponse(res, "Content-Type", contentType);
+        }
+      }
+
+      if (!getHeaderFromResponse(res, "Accept-Ranges")) {
+        setHeaderForResponse(res, "Accept-Ranges", "bytes");
+      }
+
+      const rangeHeader = getHeaderFromRequest(req, "range");
+      let start;
+      let end;
+
+      if (rangeHeader && BYTES_RANGE_REGEXP.test(rangeHeader)) {
+        const size = await new Promise(resolve => {
+          /** @type {import("fs").lstat} */
+          context.outputFileSystem.lstat(filename, (error, stats) => {
+            if (error) {
+              context.logger.error(error);
+              return;
+            }
+
+            resolve(stats.size);
+          });
+        });
+        const parsedRanges = parseRange(size, rangeHeader, {
+          combine: true
+        });
+
+        if (parsedRanges === -1) {
+          const message = "Unsatisfiable range for 'Range' header.";
+          context.logger.error(message);
+          const existingHeaders = getHeaderNames(res);
+
+          for (let i = 0; i < existingHeaders.length; i++) {
+            res.removeHeader(existingHeaders[i]);
+          }
+
+          setStatusCode(res, 416);
+          setHeaderForResponse(res, "Content-Range", getValueContentRangeHeader("bytes", size));
+          setHeaderForResponse(res, "Content-Type", "text/html; charset=utf-8");
+          const document = createHtmlDocument(416, `Error: ${message}`);
+          const byteLength = Buffer.byteLength(document);
+          setHeaderForResponse(res, "Content-Length", Buffer.byteLength(document));
+          send(req, res, document, byteLength);
+          return;
+        } else if (parsedRanges === -2) {
+          context.logger.error("A malformed 'Range' header was provided. A regular response will be sent for this request.");
+        } else if (parsedRanges.length > 1) {
+          context.logger.error("A 'Range' header with multiple ranges was provided. Multiple ranges are not supported, so a regular response will be sent for this request.");
+        }
+
+        if (parsedRanges !== -2 && parsedRanges.length === 1) {
+          // Content-Range
+          setStatusCode(res, 206);
+          setHeaderForResponse(res, "Content-Range", getValueContentRangeHeader("bytes", size,
+          /** @type {import("range-parser").Ranges} */
+          parsedRanges[0]));
+          [{
+            start,
+            end
+          }] = parsedRanges;
+        }
+      }
+
+      const isFsSupportsStream = typeof context.outputFileSystem.createReadStream === "function";
+      let bufferOtStream;
+      let byteLength;
+
+      try {
+        if (typeof start !== "undefined" && typeof end !== "undefined" && isFsSupportsStream) {
+          bufferOtStream =
+          /** @type {import("fs").createReadStream} */
+          context.outputFileSystem.createReadStream(filename, {
+            start,
+            end
+          });
+          byteLength = end - start + 1;
+        } else {
+          bufferOtStream =
+          /** @type {import("fs").readFileSync} */
+          context.outputFileSystem.readFileSync(filename);
+          ({
+            byteLength
+          } = bufferOtStream);
+        }
+      } catch (_ignoreError) {
+        await goNext();
+        return;
+      }
+
+      send(req, res, bufferOtStream, byteLength);
+    }
+  };
+}
+
+module.exports = wrapper;

node_modules/webpack-dev-middleware/dist/options.json

@@ -0,0 +1,125 @@
+{
+  "type": "object",
+  "properties": {
+    "mimeTypes": {
+      "description": "Allows a user to register custom mime types or extension mappings.",
+      "link": "https://github.com/webpack/webpack-dev-middleware#mimetypes",
+      "type": "object"
+    },
+    "writeToDisk": {
+      "description": "Allows to write generated files on disk.",
+      "link": "https://github.com/webpack/webpack-dev-middleware#writetodisk",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "methods": {
+      "description": "Allows to pass the list of HTTP request methods accepted by the middleware.",
+      "link": "https://github.com/webpack/webpack-dev-middleware#methods",
+      "type": "array",
+      "items": {
+        "type": "string",
+        "minlength": "1"
+      }
+    },
+    "headers": {
+      "anyOf": [
+        {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "key": {
+                "description": "key of header.",
+                "type": "string"
+              },
+              "value": {
+                "description": "value of header.",
+                "type": "string"
+              }
+            }
+          },
+          "minItems": 1
+        },
+        {
+          "type": "object"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ],
+      "description": "Allows to pass custom HTTP headers on each request",
+      "link": "https://github.com/webpack/webpack-dev-middleware#headers"
+    },
+    "publicPath": {
+      "description": "The `publicPath` specifies the public URL address of the output files when referenced in a browser.",
+      "link": "https://github.com/webpack/webpack-dev-middleware#publicpath",
+      "anyOf": [
+        {
+          "enum": ["auto"]
+        },
+        {
+          "type": "string"
+        },
+        {
+          "instanceof": "Function"
+        }
+      ]
+    },
+    "stats": {
+      "description": "Stats options object or preset name.",
+      "link": "https://github.com/webpack/webpack-dev-middleware#stats",
+      "anyOf": [
+        {
+          "enum": [
+            "none",
+            "summary",
+            "errors-only",
+            "errors-warnings",
+            "minimal",
+            "normal",
+            "detailed",
+            "verbose"
+          ]
+        },
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object",
+          "additionalProperties": true
+        }
+      ]
+    },
+    "serverSideRender": {
+      "description": "Instructs the module to enable or disable the server-side rendering mode.",
+      "link": "https://github.com/webpack/webpack-dev-middleware#serversiderender",
+      "type": "boolean"
+    },
+    "outputFileSystem": {
+      "description": "Set the default file system which will be used by webpack as primary destination of generated files.",
+      "link": "https://github.com/webpack/webpack-dev-middleware#outputfilesystem",
+      "type": "object"
+    },
+    "index": {
+      "description": "Allows to serve an index of the directory.",
+      "link": "https://github.com/webpack/webpack-dev-middleware#index",
+      "anyOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "string",
+          "minlength": "1"
+        }
+      ]
+    }
+  },
+  "additionalProperties": false
+}

node_modules/webpack-dev-middleware/dist/utils/compatibleAPI.js

@@ -0,0 +1,292 @@
+"use strict";
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @typedef {Object} ExpectedRequest
+ * @property {(name: string) => string | undefined} get
+ */
+
+/**
+ * @typedef {Object} ExpectedResponse
+ * @property {(name: string) => string | string[] | undefined} get
+ * @property {(name: string, value: number | string | string[]) => void} set
+ * @property {(status: number) => void} status
+ * @property {(data: any) => void} send
+ */
+
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ * @returns {string[]}
+ */
+function getHeaderNames(res) {
+  if (typeof res.getHeaderNames !== "function") {
+    // @ts-ignore
+    // eslint-disable-next-line no-underscore-dangle
+    return Object.keys(res._headers || {});
+  }
+
+  return res.getHeaderNames();
+}
+/**
+ * @template {IncomingMessage} Request
+ * @param {Request} req
+ * @param {string} name
+ * @returns {string | undefined}
+ */
+
+
+function getHeaderFromRequest(req, name) {
+  // Express API
+  if (typeof
+  /** @type {Request & ExpectedRequest} */
+  req.get === "function") {
+    return (
+      /** @type {Request & ExpectedRequest} */
+      req.get(name)
+    );
+  } // Node.js API
+  // @ts-ignore
+
+
+  return req.headers[name];
+}
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ * @param {string} name
+ * @returns {number | string | string[] | undefined}
+ */
+
+
+function getHeaderFromResponse(res, name) {
+  // Express API
+  if (typeof
+  /** @type {Response & ExpectedResponse} */
+  res.get === "function") {
+    return (
+      /** @type {Response & ExpectedResponse} */
+      res.get(name)
+    );
+  } // Node.js API
+
+
+  return res.getHeader(name);
+}
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ * @param {string} name
+ * @param {number | string | string[]} value
+ * @returns {void}
+ */
+
+
+function setHeaderForResponse(res, name, value) {
+  // Express API
+  if (typeof
+  /** @type {Response & ExpectedResponse} */
+  res.set === "function") {
+    /** @type {Response & ExpectedResponse} */
+    res.set(name, typeof value === "number" ? String(value) : value);
+    return;
+  } // Node.js API
+
+
+  res.setHeader(name, value);
+}
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ * @param {number} code
+ */
+
+
+function setStatusCode(res, code) {
+  if (typeof
+  /** @type {Response & ExpectedResponse} */
+  res.status === "function") {
+    /** @type {Response & ExpectedResponse} */
+    res.status(code);
+    return;
+  } // eslint-disable-next-line no-param-reassign
+
+
+  res.statusCode = code;
+}
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {Request} req
+ * @param {Response} res
+ * @param {string | Buffer | import("fs").ReadStream} bufferOtStream
+ * @param {number} byteLength
+ */
+
+
+function send(req, res, bufferOtStream, byteLength) {
+  if (typeof
+  /** @type {import("fs").ReadStream} */
+  bufferOtStream.pipe === "function") {
+    setHeaderForResponse(res, "Content-Length", byteLength);
+
+    if (req.method === "HEAD") {
+      res.end();
+      return;
+    }
+    /** @type {import("fs").ReadStream} */
+
+
+    bufferOtStream.pipe(res);
+    return;
+  }
+
+  if (typeof
+  /** @type {Response & ExpectedResponse} */
+  res.send === "function") {
+    /** @type {Response & ExpectedResponse} */
+    res.send(bufferOtStream);
+    return;
+  } // Only Node.js API used
+
+
+  res.setHeader("Content-Length", byteLength);
+
+  if (req.method === "HEAD") {
+    res.end();
+  } else {
+    res.end(bufferOtStream);
+  }
+}
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ */
+
+
+function clearHeadersForResponse(res) {
+  const headers = getHeaderNames(res);
+
+  for (let i = 0; i < headers.length; i++) {
+    res.removeHeader(headers[i]);
+  }
+}
+
+const matchHtmlRegExp = /["'&<>]/;
+/**
+ * @param {string} string raw HTML
+ * @returns {string} escaped HTML
+ */
+
+function escapeHtml(string) {
+  const str = `${string}`;
+  const match = matchHtmlRegExp.exec(str);
+
+  if (!match) {
+    return str;
+  }
+
+  let escape;
+  let html = "";
+  let index = 0;
+  let lastIndex = 0;
+
+  for (({
+    index
+  } = match); index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      // "
+      case 34:
+        escape = "&quot;";
+        break;
+      // &
+
+      case 38:
+        escape = "&amp;";
+        break;
+      // '
+
+      case 39:
+        escape = "&#39;";
+        break;
+      // <
+
+      case 60:
+        escape = "&lt;";
+        break;
+      // >
+
+      case 62:
+        escape = "&gt;";
+        break;
+
+      default:
+        // eslint-disable-next-line no-continue
+        continue;
+    }
+
+    if (lastIndex !== index) {
+      html += str.substring(lastIndex, index);
+    }
+
+    lastIndex = index + 1;
+    html += escape;
+  }
+
+  return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+/** @type {Record<number, string>} */
+
+
+const statuses = {
+  400: "Bad Request",
+  403: "Forbidden",
+  404: "Not Found",
+  416: "Range Not Satisfiable",
+  500: "Internal Server Error"
+};
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {Request} req response
+ * @param {Response} res response
+ * @param {number} status status
+ * @returns {void}
+ */
+
+function sendError(req, res, status) {
+  const content = statuses[status] || String(status);
+  const document = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Error</title>
+</head>
+<body>
+<pre>${escapeHtml(content)}</pre>
+</body>
+</html>`; // Clear existing headers
+
+  clearHeadersForResponse(res); // Send basic response
+
+  setStatusCode(res, status);
+  setHeaderForResponse(res, "Content-Type", "text/html; charset=utf-8");
+  setHeaderForResponse(res, "Content-Security-Policy", "default-src 'none'");
+  setHeaderForResponse(res, "X-Content-Type-Options", "nosniff");
+  const byteLength = Buffer.byteLength(document);
+  setHeaderForResponse(res, "Content-Length", byteLength);
+  res.end(document);
+}
+
+module.exports = {
+  getHeaderNames,
+  getHeaderFromRequest,
+  getHeaderFromResponse,
+  setHeaderForResponse,
+  setStatusCode,
+  send,
+  sendError
+};

node_modules/webpack-dev-middleware/dist/utils/getFilenameFromUrl.js

@@ -0,0 +1,195 @@
+"use strict";
+
+const path = require("path");
+
+const {
+  parse
+} = require("url");
+
+const querystring = require("querystring");
+
+const getPaths = require("./getPaths");
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+
+const cacheStore = new WeakMap();
+/**
+ * @template T
+ * @param {Function} fn
+ * @param {{ cache?: Map<string, { data: T }> } | undefined} cache
+ * @param {(value: T) => T} callback
+ * @returns {any}
+ */
+// @ts-ignore
+
+const mem = (fn, {
+  cache = new Map()
+} = {}, callback) => {
+  /**
+   * @param {any} arguments_
+   * @return {any}
+   */
+  const memoized = (...arguments_) => {
+    const [key] = arguments_;
+    const cacheItem = cache.get(key);
+
+    if (cacheItem) {
+      return cacheItem.data;
+    }
+
+    let result = fn.apply(void 0, arguments_);
+    result = callback(result);
+    cache.set(key, {
+      data: result
+    });
+    return result;
+  };
+
+  cacheStore.set(memoized, cache);
+  return memoized;
+}; // eslint-disable-next-line no-undefined
+
+
+const memoizedParse = mem(parse, undefined, value => {
+  if (value.pathname) {
+    // eslint-disable-next-line no-param-reassign
+    value.pathname = decode(value.pathname);
+  }
+
+  return value;
+});
+const UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
+/**
+ * @typedef {Object} Extra
+ * @property {import("fs").Stats=} stats
+ * @property {number=} errorCode
+ */
+
+/**
+ * decodeURIComponent.
+ *
+ * Allows V8 to only deoptimize this fn instead of all of send().
+ *
+ * @param {string} input
+ * @returns {string}
+ */
+
+function decode(input) {
+  return querystring.unescape(input);
+}
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ * @param {string} url
+ * @param {Extra=} extra
+ * @returns {string | undefined}
+ */
+
+
+function getFilenameFromUrl(context, url, extra = {}) {
+  const {
+    options
+  } = context;
+  const paths = getPaths(context);
+  /** @type {string | undefined} */
+
+  let foundFilename;
+  /** @type {URL} */
+
+  let urlObject;
+
+  try {
+    // The `url` property of the `request` is contains only  `pathname`, `search` and `hash`
+    urlObject = memoizedParse(url, false, true);
+  } catch (_ignoreError) {
+    return;
+  }
+
+  for (const {
+    publicPath,
+    outputPath
+  } of paths) {
+    /** @type {string | undefined} */
+    let filename;
+    /** @type {URL} */
+
+    let publicPathObject;
+
+    try {
+      publicPathObject = memoizedParse(publicPath !== "auto" && publicPath ? publicPath : "/", false, true);
+    } catch (_ignoreError) {
+      // eslint-disable-next-line no-continue
+      continue;
+    }
+
+    const {
+      pathname
+    } = urlObject;
+    const {
+      pathname: publicPathPathname
+    } = publicPathObject;
+
+    if (pathname && pathname.startsWith(publicPathPathname)) {
+      // Null byte(s)
+      if (pathname.includes("\0")) {
+        // eslint-disable-next-line no-param-reassign
+        extra.errorCode = 400;
+        return;
+      } // ".." is malicious
+
+
+      if (UP_PATH_REGEXP.test(path.normalize(`./${pathname}`))) {
+        // eslint-disable-next-line no-param-reassign
+        extra.errorCode = 403;
+        return;
+      } // Strip the `pathname` property from the `publicPath` option from the start of requested url
+      // `/complex/foo.js` => `foo.js`
+      // and add outputPath
+      // `foo.js` => `/home/user/my-project/dist/foo.js`
+
+
+      filename = path.join(outputPath, pathname.slice(publicPathPathname.length));
+
+      try {
+        // eslint-disable-next-line no-param-reassign
+        extra.stats =
+        /** @type {import("fs").statSync} */
+        context.outputFileSystem.statSync(filename);
+      } catch (_ignoreError) {
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+
+      if (extra.stats.isFile()) {
+        foundFilename = filename;
+        break;
+      } else if (extra.stats.isDirectory() && (typeof options.index === "undefined" || options.index)) {
+        const indexValue = typeof options.index === "undefined" || typeof options.index === "boolean" ? "index.html" : options.index;
+        filename = path.join(filename, indexValue);
+
+        try {
+          // eslint-disable-next-line no-param-reassign
+          extra.stats =
+          /** @type {import("fs").statSync} */
+          context.outputFileSystem.statSync(filename);
+        } catch (__ignoreError) {
+          // eslint-disable-next-line no-continue
+          continue;
+        }
+
+        if (extra.stats.isFile()) {
+          foundFilename = filename;
+          break;
+        }
+      }
+    }
+  } // eslint-disable-next-line consistent-return
+
+
+  return foundFilename;
+}
+
+module.exports = getFilenameFromUrl;

node_modules/webpack-dev-middleware/dist/utils/getPaths.js

@@ -0,0 +1,49 @@
+"use strict";
+
+/** @typedef {import("webpack").Compiler} Compiler */
+
+/** @typedef {import("webpack").Stats} Stats */
+
+/** @typedef {import("webpack").MultiStats} MultiStats */
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ */
+function getPaths(context) {
+  const {
+    stats,
+    options
+  } = context;
+  /** @type {Stats[]} */
+
+  const childStats =
+  /** @type {MultiStats} */
+  stats.stats ?
+  /** @type {MultiStats} */
+  stats.stats : [
+  /** @type {Stats} */
+  stats];
+  const publicPaths = [];
+
+  for (const {
+    compilation
+  } of childStats) {
+    // The `output.path` is always present and always absolute
+    const outputPath = compilation.getPath(compilation.outputOptions.path || "");
+    const publicPath = options.publicPath ? compilation.getPath(options.publicPath) : compilation.outputOptions.publicPath ? compilation.getPath(compilation.outputOptions.publicPath) : "";
+    publicPaths.push({
+      outputPath,
+      publicPath
+    });
+  }
+
+  return publicPaths;
+}
+
+module.exports = getPaths;

node_modules/webpack-dev-middleware/dist/utils/ready.js

@@ -0,0 +1,26 @@
+"use strict";
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ * @param {(...args: any[]) => any} callback
+ * @param {Request} [req]
+ * @returns {void}
+ */
+function ready(context, callback, req) {
+  if (context.state) {
+    callback(context.stats);
+    return;
+  }
+
+  const name = req && req.url || callback.name;
+  context.logger.info(`wait until bundle finished${name ? `: ${name}` : ""}`);
+  context.callbacks.push(callback);
+}
+
+module.exports = ready;

node_modules/webpack-dev-middleware/dist/utils/setupHooks.js

@@ -0,0 +1,216 @@
+"use strict";
+
+const webpack = require("webpack");
+
+const {
+  isColorSupported
+} = require("colorette");
+/** @typedef {import("webpack").Configuration} Configuration */
+
+/** @typedef {import("webpack").Compiler} Compiler */
+
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+
+/** @typedef {import("webpack").Stats} Stats */
+
+/** @typedef {import("webpack").MultiStats} MultiStats */
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/** @typedef {Configuration["stats"]} StatsOptions */
+
+/** @typedef {{ children: Configuration["stats"][] }} MultiStatsOptions */
+
+/** @typedef {Exclude<Configuration["stats"], boolean | string | undefined>} NormalizedStatsOptions */
+// TODO remove `color` after dropping webpack v4
+
+/** @typedef {{ children: StatsOptions[], colors?: any }} MultiNormalizedStatsOptions */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ */
+
+
+function setupHooks(context) {
+  function invalid() {
+    if (context.state) {
+      context.logger.log("Compilation starting...");
+    } // We are now in invalid state
+    // eslint-disable-next-line no-param-reassign
+
+
+    context.state = false; // eslint-disable-next-line no-param-reassign, no-undefined
+
+    context.stats = undefined;
+  } // @ts-ignore
+
+
+  const statsForWebpack4 = webpack.Stats && webpack.Stats.presetToOptions;
+  /**
+   * @param {Configuration["stats"]} statsOptions
+   * @returns {NormalizedStatsOptions}
+   */
+
+  function normalizeStatsOptions(statsOptions) {
+    if (statsForWebpack4) {
+      if (typeof statsOptions === "undefined") {
+        // eslint-disable-next-line no-param-reassign
+        statsOptions = {};
+      } else if (typeof statsOptions === "boolean" || typeof statsOptions === "string") {
+        // @ts-ignore
+        // eslint-disable-next-line no-param-reassign
+        statsOptions = webpack.Stats.presetToOptions(statsOptions);
+      } // @ts-ignore
+
+
+      return statsOptions;
+    }
+
+    if (typeof statsOptions === "undefined") {
+      // eslint-disable-next-line no-param-reassign
+      statsOptions = {
+        preset: "normal"
+      };
+    } else if (typeof statsOptions === "boolean") {
+      // eslint-disable-next-line no-param-reassign
+      statsOptions = statsOptions ? {
+        preset: "normal"
+      } : {
+        preset: "none"
+      };
+    } else if (typeof statsOptions === "string") {
+      // eslint-disable-next-line no-param-reassign
+      statsOptions = {
+        preset: statsOptions
+      };
+    }
+
+    return statsOptions;
+  }
+  /**
+   * @param {Stats | MultiStats} stats
+   */
+
+
+  function done(stats) {
+    // We are now on valid state
+    // eslint-disable-next-line no-param-reassign
+    context.state = true; // eslint-disable-next-line no-param-reassign
+
+    context.stats = stats; // Do the stuff in nextTick, because bundle may be invalidated if a change happened while compiling
+
+    process.nextTick(() => {
+      const {
+        compiler,
+        logger,
+        options,
+        state,
+        callbacks
+      } = context; // Check if still in valid state
+
+      if (!state) {
+        return;
+      }
+
+      logger.log("Compilation finished");
+      const isMultiCompilerMode = Boolean(
+      /** @type {MultiCompiler} */
+      compiler.compilers);
+      /**
+       * @type {StatsOptions | MultiStatsOptions | NormalizedStatsOptions | MultiNormalizedStatsOptions}
+       */
+
+      let statsOptions;
+
+      if (typeof options.stats !== "undefined") {
+        statsOptions = isMultiCompilerMode ? {
+          children:
+          /** @type {MultiCompiler} */
+          compiler.compilers.map(() => options.stats)
+        } : options.stats;
+      } else {
+        statsOptions = isMultiCompilerMode ? {
+          children:
+          /** @type {MultiCompiler} */
+          compiler.compilers.map(child => child.options.stats)
+        } :
+        /** @type {Compiler} */
+        compiler.options.stats;
+      }
+
+      if (isMultiCompilerMode) {
+        /** @type {MultiNormalizedStatsOptions} */
+        statsOptions.children =
+        /** @type {MultiStatsOptions} */
+        statsOptions.children.map(
+        /**
+         * @param {StatsOptions} childStatsOptions
+         * @return {NormalizedStatsOptions}
+         */
+        childStatsOptions => {
+          // eslint-disable-next-line no-param-reassign
+          childStatsOptions = normalizeStatsOptions(childStatsOptions);
+
+          if (typeof childStatsOptions.colors === "undefined") {
+            // eslint-disable-next-line no-param-reassign
+            childStatsOptions.colors = isColorSupported;
+          }
+
+          return childStatsOptions;
+        });
+      } else {
+        /** @type {NormalizedStatsOptions} */
+        statsOptions = normalizeStatsOptions(
+        /** @type {StatsOptions} */
+        statsOptions);
+
+        if (typeof statsOptions.colors === "undefined") {
+          statsOptions.colors = isColorSupported;
+        }
+      } // TODO webpack@4 doesn't support `{ children: [{ colors: true }, { colors: true }] }` for stats
+
+
+      if (
+      /** @type {MultiCompiler} */
+      compiler.compilers && statsForWebpack4) {
+        /** @type {MultiNormalizedStatsOptions} */
+        statsOptions.colors =
+        /** @type {MultiNormalizedStatsOptions} */
+        statsOptions.children.some(
+        /**
+         * @param {StatsOptions} child
+         */
+        // @ts-ignore
+        child => child.colors);
+      }
+
+      const printedStats = stats.toString(statsOptions); // Avoid extra empty line when `stats: 'none'`
+
+      if (printedStats) {
+        // eslint-disable-next-line no-console
+        console.log(printedStats);
+      } // eslint-disable-next-line no-param-reassign
+
+
+      context.callbacks = []; // Execute callback that are delayed
+
+      callbacks.forEach(
+      /**
+       * @param {(...args: any[]) => Stats | MultiStats} callback
+       */
+      callback => {
+        callback(stats);
+      });
+    });
+  }
+
+  context.compiler.hooks.watchRun.tap("webpack-dev-middleware", invalid);
+  context.compiler.hooks.invalid.tap("webpack-dev-middleware", invalid);
+  context.compiler.hooks.done.tap("webpack-dev-middleware", done);
+}
+
+module.exports = setupHooks;

node_modules/webpack-dev-middleware/dist/utils/setupOutputFileSystem.js

@@ -0,0 +1,58 @@
+"use strict";
+
+const path = require("path");
+
+const memfs = require("memfs");
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ */
+
+
+function setupOutputFileSystem(context) {
+  let outputFileSystem;
+
+  if (context.options.outputFileSystem) {
+    const {
+      outputFileSystem: outputFileSystemFromOptions
+    } = context.options; // Todo remove when we drop webpack@4 support
+
+    if (typeof outputFileSystemFromOptions.join !== "function") {
+      throw new Error("Invalid options: options.outputFileSystem.join() method is expected");
+    } // Todo remove when we drop webpack@4 support
+    // @ts-ignore
+
+
+    if (typeof outputFileSystemFromOptions.mkdirp !== "function") {
+      throw new Error("Invalid options: options.outputFileSystem.mkdirp() method is expected");
+    }
+
+    outputFileSystem = outputFileSystemFromOptions;
+  } else {
+    outputFileSystem = memfs.createFsFromVolume(new memfs.Volume()); // TODO: remove when we drop webpack@4 support
+    // @ts-ignore
+
+    outputFileSystem.join = path.join.bind(path);
+  }
+
+  const compilers =
+  /** @type {MultiCompiler} */
+  context.compiler.compilers || [context.compiler];
+
+  for (const compiler of compilers) {
+    compiler.outputFileSystem = outputFileSystem;
+  } // @ts-ignore
+  // eslint-disable-next-line no-param-reassign
+
+
+  context.outputFileSystem = outputFileSystem;
+}
+
+module.exports = setupOutputFileSystem;

node_modules/webpack-dev-middleware/dist/utils/setupWriteToDisk.js

@@ -0,0 +1,111 @@
+"use strict";
+
+const fs = require("fs");
+
+const path = require("path");
+/** @typedef {import("webpack").Compiler} Compiler */
+
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+
+/** @typedef {import("webpack").Compilation} Compilation */
+
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ */
+
+
+function setupWriteToDisk(context) {
+  /**
+   * @type {Compiler[]}
+   */
+  const compilers =
+  /** @type {MultiCompiler} */
+  context.compiler.compilers || [context.compiler];
+
+  for (const compiler of compilers) {
+    compiler.hooks.emit.tap("DevMiddleware",
+    /**
+     * @param {Compilation} compilation
+     */
+    compilation => {
+      // @ts-ignore
+      if (compiler.hasWebpackDevMiddlewareAssetEmittedCallback) {
+        return;
+      }
+
+      compiler.hooks.assetEmitted.tapAsync("DevMiddleware", (file, info, callback) => {
+        /**
+         * @type {string}
+         */
+        let targetPath;
+        /**
+         * @type {Buffer}
+         */
+
+        let content; // webpack@5
+
+        if (info.compilation) {
+          ({
+            targetPath,
+            content
+          } = info);
+        } else {
+          let targetFile = file;
+          const queryStringIdx = targetFile.indexOf("?");
+
+          if (queryStringIdx >= 0) {
+            targetFile = targetFile.slice(0, queryStringIdx);
+          }
+
+          let {
+            outputPath
+          } = compiler;
+          outputPath = compilation.getPath(outputPath, {}); // @ts-ignore
+
+          content = info;
+          targetPath = path.join(outputPath, targetFile);
+        }
+
+        const {
+          writeToDisk: filter
+        } = context.options;
+        const allowWrite = filter && typeof filter === "function" ? filter(targetPath) : true;
+
+        if (!allowWrite) {
+          return callback();
+        }
+
+        const dir = path.dirname(targetPath);
+        const name = compiler.options.name ? `Child "${compiler.options.name}": ` : "";
+        return fs.mkdir(dir, {
+          recursive: true
+        }, mkdirError => {
+          if (mkdirError) {
+            context.logger.error(`${name}Unable to write "${dir}" directory to disk:\n${mkdirError}`);
+            return callback(mkdirError);
+          }
+
+          return fs.writeFile(targetPath, content, writeFileError => {
+            if (writeFileError) {
+              context.logger.error(`${name}Unable to write "${targetPath}" asset to disk:\n${writeFileError}`);
+              return callback(writeFileError);
+            }
+
+            context.logger.log(`${name}Asset written to disk: "${targetPath}"`);
+            return callback();
+          });
+        });
+      }); // @ts-ignore
+
+      compiler.hasWebpackDevMiddlewareAssetEmittedCallback = true;
+    });
+  }
+}
+
+module.exports = setupWriteToDisk;

node_modules/webpack-dev-middleware/node_modules/mime-db/HISTORY.md

@@ -0,0 +1,507 @@
+1.52.0 / 2022-02-21
+===================
+
+  * Add extensions from IANA for more `image/*` types
+  * Add extension `.asc` to `application/pgp-keys`
+  * Add extensions to various XML types
+  * Add new upstream MIME types
+
+1.51.0 / 2021-11-08
+===================
+
+  * Add new upstream MIME types
+  * Mark `image/vnd.microsoft.icon` as compressible
+  * Mark `image/vnd.ms-dds` as compressible
+
+1.50.0 / 2021-09-15
+===================
+
+  * Add deprecated iWorks mime types and extensions
+  * Add new upstream MIME types
+
+1.49.0 / 2021-07-26
+===================
+
+  * Add extension `.trig` to `application/trig`
+  * Add new upstream MIME types
+
+1.48.0 / 2021-05-30
+===================
+
+  * Add extension `.mvt` to `application/vnd.mapbox-vector-tile`
+  * Add new upstream MIME types
+  * Mark `text/yaml` as compressible
+
+1.47.0 / 2021-04-01
+===================
+
+  * Add new upstream MIME types
+  * Remove ambigious extensions from IANA for `application/*+xml` types
+  * Update primary extension to `.es` for `application/ecmascript`
+
+1.46.0 / 2021-02-13
+===================
+
+  * Add extension `.amr` to `audio/amr`
+  * Add extension `.m4s` to `video/iso.segment`
+  * Add extension `.opus` to `audio/ogg`
+  * Add new upstream MIME types
+
+1.45.0 / 2020-09-22
+===================
+
+  * Add `application/ubjson` with extension `.ubj`
+  * Add `image/avif` with extension `.avif`
+  * Add `image/ktx2` with extension `.ktx2`
+  * Add extension `.dbf` to `application/vnd.dbf`
+  * Add extension `.rar` to `application/vnd.rar`
+  * Add extension `.td` to `application/urc-targetdesc+xml`
+  * Add new upstream MIME types
+  * Fix extension of `application/vnd.apple.keynote` to be `.key`
+
+1.44.0 / 2020-04-22
+===================
+
+  * Add charsets from IANA
+  * Add extension `.cjs` to `application/node`
+  * Add new upstream MIME types
+
+1.43.0 / 2020-01-05
+===================
+
+  * Add `application/x-keepass2` with extension `.kdbx`
+  * Add extension `.mxmf` to `audio/mobile-xmf`
+  * Add extensions from IANA for `application/*+xml` types
+  * Add new upstream MIME types
+
+1.42.0 / 2019-09-25
+===================
+
+  * Add `image/vnd.ms-dds` with extension `.dds`
+  * Add new upstream MIME types
+  * Remove compressible from `multipart/mixed`
+
+1.41.0 / 2019-08-30
+===================
+
+  * Add new upstream MIME types
+  * Add `application/toml` with extension `.toml`
+  * Mark `font/ttf` as compressible
+
+1.40.0 / 2019-04-20
+===================
+
+  * Add extensions from IANA for `model/*` types
+  * Add `text/mdx` with extension `.mdx`
+
+1.39.0 / 2019-04-04
+===================
+
+  * Add extensions `.siv` and `.sieve` to `application/sieve`
+  * Add new upstream MIME types
+
+1.38.0 / 2019-02-04
+===================
+
+  * Add extension `.nq` to `application/n-quads`
+  * Add extension `.nt` to `application/n-triples`
+  * Add new upstream MIME types
+  * Mark `text/less` as compressible
+
+1.37.0 / 2018-10-19
+===================
+
+  * Add extensions to HEIC image types
+  * Add new upstream MIME types
+
+1.36.0 / 2018-08-20
+===================
+
+  * Add Apple file extensions from IANA
+  * Add extensions from IANA for `image/*` types
+  * Add new upstream MIME types
+
+1.35.0 / 2018-07-15
+===================
+
+  * Add extension `.owl` to `application/rdf+xml`
+  * Add new upstream MIME types
+    - Removes extension `.woff` from `application/font-woff`
+
+1.34.0 / 2018-06-03
+===================
+
+  * Add extension `.csl` to `application/vnd.citationstyles.style+xml`
+  * Add extension `.es` to `application/ecmascript`
+  * Add new upstream MIME types
+  * Add `UTF-8` as default charset for `text/turtle`
+  * Mark all XML-derived types as compressible
+
+1.33.0 / 2018-02-15
+===================
+
+  * Add extensions from IANA for `message/*` types
+  * Add new upstream MIME types
+  * Fix some incorrect OOXML types
+  * Remove `application/font-woff2`
+
+1.32.0 / 2017-11-29
+===================
+
+  * Add new upstream MIME types
+  * Update `text/hjson` to registered `application/hjson`
+  * Add `text/shex` with extension `.shex`
+
+1.31.0 / 2017-10-25
+===================
+
+  * Add `application/raml+yaml` with extension `.raml`
+  * Add `application/wasm` with extension `.wasm`
+  * Add new `font` type from IANA
+  * Add new upstream font extensions
+  * Add new upstream MIME types
+  * Add extensions for JPEG-2000 images
+
+1.30.0 / 2017-08-27
+===================
+
+  * Add `application/vnd.ms-outlook`
+  * Add `application/x-arj`
+  * Add extension `.mjs` to `application/javascript`
+  * Add glTF types and extensions
+  * Add new upstream MIME types
+  * Add `text/x-org`
+  * Add VirtualBox MIME types
+  * Fix `source` records for `video/*` types that are IANA
+  * Update `font/opentype` to registered `font/otf`
+
+1.29.0 / 2017-07-10
+===================
+
+  * Add `application/fido.trusted-apps+json`
+  * Add extension `.wadl` to `application/vnd.sun.wadl+xml`
+  * Add new upstream MIME types
+  * Add `UTF-8` as default charset for `text/css`
+
+1.28.0 / 2017-05-14
+===================
+
+  * Add new upstream MIME types
+  * Add extension `.gz` to `application/gzip`
+  * Update extensions `.md` and `.markdown` to be `text/markdown`
+
+1.27.0 / 2017-03-16
+===================
+
+  * Add new upstream MIME types
+  * Add `image/apng` with extension `.apng`
+
+1.26.0 / 2017-01-14
+===================
+
+  * Add new upstream MIME types
+  * Add extension `.geojson` to `application/geo+json`
+
+1.25.0 / 2016-11-11
+===================
+
+  * Add new upstream MIME types
+
+1.24.0 / 2016-09-18
+===================
+
+  * Add `audio/mp3`
+  * Add new upstream MIME types
+
+1.23.0 / 2016-05-01
+===================
+
+  * Add new upstream MIME types
+  * Add extension `.3gpp` to `audio/3gpp`
+
+1.22.0 / 2016-02-15
+===================
+
+  * Add `text/slim`
+  * Add extension `.rng` to `application/xml`
+  * Add new upstream MIME types
+  * Fix extension of `application/dash+xml` to be `.mpd`
+  * Update primary extension to `.m4a` for `audio/mp4`
+
+1.21.0 / 2016-01-06
+===================
+
+  * Add Google document types
+  * Add new upstream MIME types
+
+1.20.0 / 2015-11-10
+===================
+
+  * Add `text/x-suse-ymp`
+  * Add new upstream MIME types
+
+1.19.0 / 2015-09-17
+===================
+
+  * Add `application/vnd.apple.pkpass`
+  * Add new upstream MIME types
+
+1.18.0 / 2015-09-03
+===================
+
+  * Add new upstream MIME types
+
+1.17.0 / 2015-08-13
+===================
+
+  * Add `application/x-msdos-program`
+  * Add `audio/g711-0`
+  * Add `image/vnd.mozilla.apng`
+  * Add extension `.exe` to `application/x-msdos-program`
+
+1.16.0 / 2015-07-29
+===================
+
+  * Add `application/vnd.uri-map`
+
+1.15.0 / 2015-07-13
+===================
+
+  * Add `application/x-httpd-php`
+
+1.14.0 / 2015-06-25
+===================
+
+  * Add `application/scim+json`
+  * Add `application/vnd.3gpp.ussd+xml`
+  * Add `application/vnd.biopax.rdf+xml`
+  * Add `text/x-processing`
+
+1.13.0 / 2015-06-07
+===================
+
+  * Add nginx as a source
+  * Add `application/x-cocoa`
+  * Add `application/x-java-archive-diff`
+  * Add `application/x-makeself`
+  * Add `application/x-perl`
+  * Add `application/x-pilot`
+  * Add `application/x-redhat-package-manager`
+  * Add `application/x-sea`
+  * Add `audio/x-m4a`
+  * Add `audio/x-realaudio`
+  * Add `image/x-jng`
+  * Add `text/mathml`
+
+1.12.0 / 2015-06-05
+===================
+
+  * Add `application/bdoc`
+  * Add `application/vnd.hyperdrive+json`
+  * Add `application/x-bdoc`
+  * Add extension `.rtf` to `text/rtf`
+
+1.11.0 / 2015-05-31
+===================
+
+  * Add `audio/wav`
+  * Add `audio/wave`
+  * Add extension `.litcoffee` to `text/coffeescript`
+  * Add extension `.sfd-hdstx` to `application/vnd.hydrostatix.sof-data`
+  * Add extension `.n-gage` to `application/vnd.nokia.n-gage.symbian.install`
+
+1.10.0 / 2015-05-19
+===================
+
+  * Add `application/vnd.balsamiq.bmpr`
+  * Add `application/vnd.microsoft.portable-executable`
+  * Add `application/x-ns-proxy-autoconfig`
+
+1.9.1 / 2015-04-19
+==================
+
+  * Remove `.json` extension from `application/manifest+json`
+    - This is causing bugs downstream
+
+1.9.0 / 2015-04-19
+==================
+
+  * Add `application/manifest+json`
+  * Add `application/vnd.micro+json`
+  * Add `image/vnd.zbrush.pcx`
+  * Add `image/x-ms-bmp`
+
+1.8.0 / 2015-03-13
+==================
+
+  * Add `application/vnd.citationstyles.style+xml`
+  * Add `application/vnd.fastcopy-disk-image`
+  * Add `application/vnd.gov.sk.xmldatacontainer+xml`
+  * Add extension `.jsonld` to `application/ld+json`
+
+1.7.0 / 2015-02-08
+==================
+
+  * Add `application/vnd.gerber`
+  * Add `application/vnd.msa-disk-image`
+
+1.6.1 / 2015-02-05
+==================
+
+  * Community extensions ownership transferred from `node-mime`
+
+1.6.0 / 2015-01-29
+==================
+
+  * Add `application/jose`
+  * Add `application/jose+json`
+  * Add `application/json-seq`
+  * Add `application/jwk+json`
+  * Add `application/jwk-set+json`
+  * Add `application/jwt`
+  * Add `application/rdap+json`
+  * Add `application/vnd.gov.sk.e-form+xml`
+  * Add `application/vnd.ims.imsccv1p3`
+
+1.5.0 / 2014-12-30
+==================
+
+  * Add `application/vnd.oracle.resource+json`
+  * Fix various invalid MIME type entries
+    - `application/mbox+xml`
+    - `application/oscp-response`
+    - `application/vwg-multiplexed`
+    - `audio/g721`
+
+1.4.0 / 2014-12-21
+==================
+
+  * Add `application/vnd.ims.imsccv1p2`
+  * Fix various invalid MIME type entries
+    - `application/vnd-acucobol`
+    - `application/vnd-curl`
+    - `application/vnd-dart`
+    - `application/vnd-dxr`
+    - `application/vnd-fdf`
+    - `application/vnd-mif`
+    - `application/vnd-sema`
+    - `application/vnd-wap-wmlc`
+    - `application/vnd.adobe.flash-movie`
+    - `application/vnd.dece-zip`
+    - `application/vnd.dvb_service`
+    - `application/vnd.micrografx-igx`
+    - `application/vnd.sealed-doc`
+    - `application/vnd.sealed-eml`
+    - `application/vnd.sealed-mht`
+    - `application/vnd.sealed-ppt`
+    - `application/vnd.sealed-tiff`
+    - `application/vnd.sealed-xls`
+    - `application/vnd.sealedmedia.softseal-html`
+    - `application/vnd.sealedmedia.softseal-pdf`
+    - `application/vnd.wap-slc`
+    - `application/vnd.wap-wbxml`
+    - `audio/vnd.sealedmedia.softseal-mpeg`
+    - `image/vnd-djvu`
+    - `image/vnd-svf`
+    - `image/vnd-wap-wbmp`
+    - `image/vnd.sealed-png`
+    - `image/vnd.sealedmedia.softseal-gif`
+    - `image/vnd.sealedmedia.softseal-jpg`
+    - `model/vnd-dwf`
+    - `model/vnd.parasolid.transmit-binary`
+    - `model/vnd.parasolid.transmit-text`
+    - `text/vnd-a`
+    - `text/vnd-curl`
+    - `text/vnd.wap-wml`
+  * Remove example template MIME types
+    - `application/example`
+    - `audio/example`
+    - `image/example`
+    - `message/example`
+    - `model/example`
+    - `multipart/example`
+    - `text/example`
+    - `video/example`
+
+1.3.1 / 2014-12-16
+==================
+
+  * Fix missing extensions
+    - `application/json5`
+    - `text/hjson`
+
+1.3.0 / 2014-12-07
+==================
+
+  * Add `application/a2l`
+  * Add `application/aml`
+  * Add `application/atfx`
+  * Add `application/atxml`
+  * Add `application/cdfx+xml`
+  * Add `application/dii`
+  * Add `application/json5`
+  * Add `application/lxf`
+  * Add `application/mf4`
+  * Add `application/vnd.apache.thrift.compact`
+  * Add `application/vnd.apache.thrift.json`
+  * Add `application/vnd.coffeescript`
+  * Add `application/vnd.enphase.envoy`
+  * Add `application/vnd.ims.imsccv1p1`
+  * Add `text/csv-schema`
+  * Add `text/hjson`
+  * Add `text/markdown`
+  * Add `text/yaml`
+
+1.2.0 / 2014-11-09
+==================
+
+  * Add `application/cea`
+  * Add `application/dit`
+  * Add `application/vnd.gov.sk.e-form+zip`
+  * Add `application/vnd.tmd.mediaflex.api+xml`
+  * Type `application/epub+zip` is now IANA-registered
+
+1.1.2 / 2014-10-23
+==================
+
+  * Rebuild database for `application/x-www-form-urlencoded` change
+
+1.1.1 / 2014-10-20
+==================
+
+  * Mark `application/x-www-form-urlencoded` as compressible.
+
+1.1.0 / 2014-09-28
+==================
+
+  * Add `application/font-woff2`
+
+1.0.3 / 2014-09-25
+==================
+
+  * Fix engine requirement in package
+
+1.0.2 / 2014-09-25
+==================
+
+  * Add `application/coap-group+json`
+  * Add `application/dcd`
+  * Add `application/vnd.apache.thrift.binary`
+  * Add `image/vnd.tencent.tap`
+  * Mark all JSON-derived types as compressible
+  * Update `text/vtt` data
+
+1.0.1 / 2014-08-30
+==================
+
+  * Fix extension ordering
+
+1.0.0 / 2014-08-30
+==================
+
+  * Add `application/atf`
+  * Add `application/merge-patch+json`
+  * Add `multipart/x-mixed-replace`
+  * Add `source: 'apache'` metadata
+  * Add `source: 'iana'` metadata
+  * Remove badly-assumed charset data

node_modules/webpack-dev-middleware/node_modules/mime-db/LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+Copyright (c) 2015-2022 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+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.

node_modules/webpack-dev-middleware/node_modules/mime-db/README.md

@@ -0,0 +1,100 @@
+# mime-db
+
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Downloads][npm-downloads-image]][npm-url]
+[![Node.js Version][node-image]][node-url]
+[![Build Status][ci-image]][ci-url]
+[![Coverage Status][coveralls-image]][coveralls-url]
+
+This is a large database of mime types and information about them.
+It consists of a single, public JSON file and does not include any logic,
+allowing it to remain as un-opinionated as possible with an API.
+It aggregates data from the following sources:
+
+- http://www.iana.org/assignments/media-types/media-types.xhtml
+- http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types
+- http://hg.nginx.org/nginx/raw-file/default/conf/mime.types
+
+## Installation
+
+```bash
+npm install mime-db
+```
+
+### Database Download
+
+If you're crazy enough to use this in the browser, you can just grab the
+JSON file using [jsDelivr](https://www.jsdelivr.com/). It is recommended to
+replace `master` with [a release tag](https://github.com/jshttp/mime-db/tags)
+as the JSON format may change in the future.
+
+```
+https://cdn.jsdelivr.net/gh/jshttp/mime-db@master/db.json
+```
+
+## Usage
+
+```js
+var db = require('mime-db')
+
+// grab data on .js files
+var data = db['application/javascript']
+```
+
+## Data Structure
+
+The JSON file is a map lookup for lowercased mime types.
+Each mime type has the following properties:
+
+- `.source` - where the mime type is defined.
+    If not set, it's probably a custom media type.
+    - `apache` - [Apache common media types](http://svn.apache.org/repos/asf/httpd/httpd/trunk/docs/conf/mime.types)
+    - `iana` - [IANA-defined media types](http://www.iana.org/assignments/media-types/media-types.xhtml)
+    - `nginx` - [nginx media types](http://hg.nginx.org/nginx/raw-file/default/conf/mime.types)
+- `.extensions[]` - known extensions associated with this mime type.
+- `.compressible` - whether a file of this type can be gzipped.
+- `.charset` - the default charset associated with this type, if any.
+
+If unknown, every property could be `undefined`.
+
+## Contributing
+
+To edit the database, only make PRs against `src/custom-types.json` or
+`src/custom-suffix.json`.
+
+The `src/custom-types.json` file is a JSON object with the MIME type as the
+keys and the values being an object with the following keys:
+
+- `compressible` - leave out if you don't know, otherwise `true`/`false` to
+  indicate whether the data represented by the type is typically compressible.
+- `extensions` - include an array of file extensions that are associated with
+  the type.
+- `notes` - human-readable notes about the type, typically what the type is.
+- `sources` - include an array of URLs of where the MIME type and the associated
+  extensions are sourced from. This needs to be a [primary source](https://en.wikipedia.org/wiki/Primary_source);
+  links to type aggregating sites and Wikipedia are _not acceptable_.
+
+To update the build, run `npm run build`.
+
+### Adding Custom Media Types
+
+The best way to get new media types included in this library is to register
+them with the IANA. The community registration procedure is outlined in
+[RFC 6838 section 5](http://tools.ietf.org/html/rfc6838#section-5). Types
+registered with the IANA are automatically pulled into this library.
+
+If that is not possible / feasible, they can be added directly here as a
+"custom" type. To do this, it is required to have a primary source that
+definitively lists the media type. If an extension is going to be listed as
+associateed with this media type, the source must definitively link the
+media type and extension as well.
+
+[ci-image]: https://badgen.net/github/checks/jshttp/mime-db/master?label=ci
+[ci-url]: https://github.com/jshttp/mime-db/actions?query=workflow%3Aci
+[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/mime-db/master
+[coveralls-url]: https://coveralls.io/r/jshttp/mime-db?branch=master
+[node-image]: https://badgen.net/npm/node/mime-db
+[node-url]: https://nodejs.org/en/download
+[npm-downloads-image]: https://badgen.net/npm/dm/mime-db
+[npm-url]: https://npmjs.org/package/mime-db
+[npm-version-image]: https://badgen.net/npm/v/mime-db

node_modules/webpack-dev-middleware/node_modules/mime-db/index.js

@@ -0,0 +1,12 @@
+/*!
+ * mime-db
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015-2022 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+/**
+ * Module exports.
+ */
+
+module.exports = require('./db.json')

node_modules/webpack-dev-middleware/node_modules/mime-db/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "mime-db",
+  "description": "Media Type Database",
+  "version": "1.52.0",
+  "contributors": [
+    "Douglas Christopher Wilson <doug@somethingdoug.com>",
+    "Jonathan Ong <me@jongleberry.com> (http://jongleberry.com)",
+    "Robert Kieffer <robert@broofa.com> (http://github.com/broofa)"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "mime",
+    "db",
+    "type",
+    "types",
+    "database",
+    "charset",
+    "charsets"
+  ],
+  "repository": "jshttp/mime-db",
+  "devDependencies": {
+    "bluebird": "3.7.2",
+    "co": "4.6.0",
+    "cogent": "1.0.1",
+    "csv-parse": "4.16.3",
+    "eslint": "7.32.0",
+    "eslint-config-standard": "15.0.1",
+    "eslint-plugin-import": "2.25.4",
+    "eslint-plugin-markdown": "2.2.1",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-promise": "5.1.1",
+    "eslint-plugin-standard": "4.1.0",
+    "gnode": "0.1.2",
+    "media-typer": "1.1.0",
+    "mocha": "9.2.1",
+    "nyc": "15.1.0",
+    "raw-body": "2.5.0",
+    "stream-to-array": "2.3.0"
+  },
+  "files": [
+    "HISTORY.md",
+    "LICENSE",
+    "README.md",
+    "db.json",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "scripts": {
+    "build": "node scripts/build",
+    "fetch": "node scripts/fetch-apache && gnode scripts/fetch-iana && node scripts/fetch-nginx",
+    "lint": "eslint .",
+    "test": "mocha --reporter spec --bail --check-leaks test/",
+    "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+    "test-cov": "nyc --reporter=html --reporter=text npm test",
+    "update": "npm run fetch && npm run build",
+    "version": "node scripts/version-history.js && git add HISTORY.md"
+  }
+}

node_modules/webpack-dev-middleware/node_modules/mime-types/HISTORY.md

@@ -0,0 +1,397 @@
+2.1.35 / 2022-03-12
+===================
+
+  * deps: mime-db@1.52.0
+    - Add extensions from IANA for more `image/*` types
+    - Add extension `.asc` to `application/pgp-keys`
+    - Add extensions to various XML types
+    - Add new upstream MIME types
+
+2.1.34 / 2021-11-08
+===================
+
+  * deps: mime-db@1.51.0
+    - Add new upstream MIME types
+
+2.1.33 / 2021-10-01
+===================
+
+  * deps: mime-db@1.50.0
+    - Add deprecated iWorks mime types and extensions
+    - Add new upstream MIME types
+
+2.1.32 / 2021-07-27
+===================
+
+  * deps: mime-db@1.49.0
+    - Add extension `.trig` to `application/trig`
+    - Add new upstream MIME types
+
+2.1.31 / 2021-06-01
+===================
+
+  * deps: mime-db@1.48.0
+    - Add extension `.mvt` to `application/vnd.mapbox-vector-tile`
+    - Add new upstream MIME types
+
+2.1.30 / 2021-04-02
+===================
+
+  * deps: mime-db@1.47.0
+    - Add extension `.amr` to `audio/amr`
+    - Remove ambigious extensions from IANA for `application/*+xml` types
+    - Update primary extension to `.es` for `application/ecmascript`
+
+2.1.29 / 2021-02-17
+===================
+
+  * deps: mime-db@1.46.0
+    - Add extension `.amr` to `audio/amr`
+    - Add extension `.m4s` to `video/iso.segment`
+    - Add extension `.opus` to `audio/ogg`
+    - Add new upstream MIME types
+
+2.1.28 / 2021-01-01
+===================
+
+  * deps: mime-db@1.45.0
+    - Add `application/ubjson` with extension `.ubj`
+    - Add `image/avif` with extension `.avif`
+    - Add `image/ktx2` with extension `.ktx2`
+    - Add extension `.dbf` to `application/vnd.dbf`
+    - Add extension `.rar` to `application/vnd.rar`
+    - Add extension `.td` to `application/urc-targetdesc+xml`
+    - Add new upstream MIME types
+    - Fix extension of `application/vnd.apple.keynote` to be `.key`
+
+2.1.27 / 2020-04-23
+===================
+
+  * deps: mime-db@1.44.0
+    - Add charsets from IANA
+    - Add extension `.cjs` to `application/node`
+    - Add new upstream MIME types
+
+2.1.26 / 2020-01-05
+===================
+
+  * deps: mime-db@1.43.0
+    - Add `application/x-keepass2` with extension `.kdbx`
+    - Add extension `.mxmf` to `audio/mobile-xmf`
+    - Add extensions from IANA for `application/*+xml` types
+    - Add new upstream MIME types
+
+2.1.25 / 2019-11-12
+===================
+
+  * deps: mime-db@1.42.0
+    - Add new upstream MIME types
+    - Add `application/toml` with extension `.toml`
+    - Add `image/vnd.ms-dds` with extension `.dds`
+
+2.1.24 / 2019-04-20
+===================
+
+  * deps: mime-db@1.40.0
+    - Add extensions from IANA for `model/*` types
+    - Add `text/mdx` with extension `.mdx`
+
+2.1.23 / 2019-04-17
+===================
+
+  * deps: mime-db@~1.39.0
+    - Add extensions `.siv` and `.sieve` to `application/sieve`
+    - Add new upstream MIME types
+
+2.1.22 / 2019-02-14
+===================
+
+  * deps: mime-db@~1.38.0
+    - Add extension `.nq` to `application/n-quads`
+    - Add extension `.nt` to `application/n-triples`
+    - Add new upstream MIME types
+
+2.1.21 / 2018-10-19
+===================
+
+  * deps: mime-db@~1.37.0
+    - Add extensions to HEIC image types
+    - Add new upstream MIME types
+
+2.1.20 / 2018-08-26
+===================
+
+  * deps: mime-db@~1.36.0
+    - Add Apple file extensions from IANA
+    - Add extensions from IANA for `image/*` types
+    - Add new upstream MIME types
+
+2.1.19 / 2018-07-17
+===================
+
+  * deps: mime-db@~1.35.0
+    - Add extension `.csl` to `application/vnd.citationstyles.style+xml`
+    - Add extension `.es` to `application/ecmascript`
+    - Add extension `.owl` to `application/rdf+xml`
+    - Add new upstream MIME types
+    - Add UTF-8 as default charset for `text/turtle`
+
+2.1.18 / 2018-02-16
+===================
+
+  * deps: mime-db@~1.33.0
+    - Add `application/raml+yaml` with extension `.raml`
+    - Add `application/wasm` with extension `.wasm`
+    - Add `text/shex` with extension `.shex`
+    - Add extensions for JPEG-2000 images
+    - Add extensions from IANA for `message/*` types
+    - Add new upstream MIME types
+    - Update font MIME types
+    - Update `text/hjson` to registered `application/hjson`
+
+2.1.17 / 2017-09-01
+===================
+
+  * deps: mime-db@~1.30.0
+    - Add `application/vnd.ms-outlook`
+    - Add `application/x-arj`
+    - Add extension `.mjs` to `application/javascript`
+    - Add glTF types and extensions
+    - Add new upstream MIME types
+    - Add `text/x-org`
+    - Add VirtualBox MIME types
+    - Fix `source` records for `video/*` types that are IANA
+    - Update `font/opentype` to registered `font/otf`
+
+2.1.16 / 2017-07-24
+===================
+
+  * deps: mime-db@~1.29.0
+    - Add `application/fido.trusted-apps+json`
+    - Add extension `.wadl` to `application/vnd.sun.wadl+xml`
+    - Add extension `.gz` to `application/gzip`
+    - Add new upstream MIME types
+    - Update extensions `.md` and `.markdown` to be `text/markdown`
+
+2.1.15 / 2017-03-23
+===================
+
+  * deps: mime-db@~1.27.0
+    - Add new mime types
+    - Add `image/apng`
+
+2.1.14 / 2017-01-14
+===================
+
+  * deps: mime-db@~1.26.0
+    - Add new mime types
+
+2.1.13 / 2016-11-18
+===================
+
+  * deps: mime-db@~1.25.0
+    - Add new mime types
+
+2.1.12 / 2016-09-18
+===================
+
+  * deps: mime-db@~1.24.0
+    - Add new mime types
+    - Add `audio/mp3`
+
+2.1.11 / 2016-05-01
+===================
+
+  * deps: mime-db@~1.23.0
+    - Add new mime types
+
+2.1.10 / 2016-02-15
+===================
+
+  * deps: mime-db@~1.22.0
+    - Add new mime types
+    - Fix extension of `application/dash+xml`
+    - Update primary extension for `audio/mp4`
+
+2.1.9 / 2016-01-06
+==================
+
+  * deps: mime-db@~1.21.0
+    - Add new mime types
+
+2.1.8 / 2015-11-30
+==================
+
+  * deps: mime-db@~1.20.0
+    - Add new mime types
+
+2.1.7 / 2015-09-20
+==================
+
+  * deps: mime-db@~1.19.0
+    - Add new mime types
+
+2.1.6 / 2015-09-03
+==================
+
+  * deps: mime-db@~1.18.0
+    - Add new mime types
+
+2.1.5 / 2015-08-20
+==================
+
+  * deps: mime-db@~1.17.0
+    - Add new mime types
+
+2.1.4 / 2015-07-30
+==================
+
+  * deps: mime-db@~1.16.0
+    - Add new mime types
+
+2.1.3 / 2015-07-13
+==================
+
+  * deps: mime-db@~1.15.0
+    - Add new mime types
+
+2.1.2 / 2015-06-25
+==================
+
+  * deps: mime-db@~1.14.0
+    - Add new mime types
+
+2.1.1 / 2015-06-08
+==================
+
+  * perf: fix deopt during mapping
+
+2.1.0 / 2015-06-07
+==================
+
+  * Fix incorrectly treating extension-less file name as extension
+    - i.e. `'path/to/json'` will no longer return `application/json`
+  * Fix `.charset(type)` to accept parameters
+  * Fix `.charset(type)` to match case-insensitive
+  * Improve generation of extension to MIME mapping
+  * Refactor internals for readability and no argument reassignment
+  * Prefer `application/*` MIME types from the same source
+  * Prefer any type over `application/octet-stream`
+  * deps: mime-db@~1.13.0
+    - Add nginx as a source
+    - Add new mime types
+
+2.0.14 / 2015-06-06
+===================
+
+  * deps: mime-db@~1.12.0
+    - Add new mime types
+
+2.0.13 / 2015-05-31
+===================
+
+  * deps: mime-db@~1.11.0
+    - Add new mime types
+
+2.0.12 / 2015-05-19
+===================
+
+  * deps: mime-db@~1.10.0
+    - Add new mime types
+
+2.0.11 / 2015-05-05
+===================
+
+  * deps: mime-db@~1.9.1
+    - Add new mime types
+
+2.0.10 / 2015-03-13
+===================
+
+  * deps: mime-db@~1.8.0
+    - Add new mime types
+
+2.0.9 / 2015-02-09
+==================
+
+  * deps: mime-db@~1.7.0
+    - Add new mime types
+    - Community extensions ownership transferred from `node-mime`
+
+2.0.8 / 2015-01-29
+==================
+
+  * deps: mime-db@~1.6.0
+    - Add new mime types
+
+2.0.7 / 2014-12-30
+==================
+
+  * deps: mime-db@~1.5.0
+    - Add new mime types
+    - Fix various invalid MIME type entries
+
+2.0.6 / 2014-12-30
+==================
+
+  * deps: mime-db@~1.4.0
+    - Add new mime types
+    - Fix various invalid MIME type entries
+    - Remove example template MIME types
+
+2.0.5 / 2014-12-29
+==================
+
+  * deps: mime-db@~1.3.1
+    - Fix missing extensions
+
+2.0.4 / 2014-12-10
+==================
+
+  * deps: mime-db@~1.3.0
+    - Add new mime types
+
+2.0.3 / 2014-11-09
+==================
+
+  * deps: mime-db@~1.2.0
+    - Add new mime types
+
+2.0.2 / 2014-09-28
+==================
+
+  * deps: mime-db@~1.1.0
+    - Add new mime types
+    - Update charsets
+
+2.0.1 / 2014-09-07
+==================
+
+  * Support Node.js 0.6
+
+2.0.0 / 2014-09-02
+==================
+
+  * Use `mime-db`
+  * Remove `.define()`
+
+1.0.2 / 2014-08-04
+==================
+
+  * Set charset=utf-8 for `text/javascript`
+
+1.0.1 / 2014-06-24
+==================
+
+  * Add `text/jsx` type
+
+1.0.0 / 2014-05-12
+==================
+
+  * Return `false` for unknown types
+  * Set charset=utf-8 for `application/json`
+
+0.1.0 / 2014-05-02
+==================
+
+  * Initial release

node_modules/webpack-dev-middleware/node_modules/mime-types/LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+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.

node_modules/webpack-dev-middleware/node_modules/mime-types/README.md

@@ -0,0 +1,113 @@
+# mime-types
+
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Downloads][npm-downloads-image]][npm-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![Build Status][ci-image]][ci-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+The ultimate javascript content-type utility.
+
+Similar to [the `mime@1.x` module](https://www.npmjs.com/package/mime), except:
+
+- __No fallbacks.__ Instead of naively returning the first available type,
+  `mime-types` simply returns `false`, so do
+  `var type = mime.lookup('unrecognized') || 'application/octet-stream'`.
+- No `new Mime()` business, so you could do `var lookup = require('mime-types').lookup`.
+- No `.define()` functionality
+- Bug fixes for `.lookup(path)`
+
+Otherwise, the API is compatible with `mime` 1.x.
+
+## Install
+
+This is a [Node.js](https://nodejs.org/en/) module available through the
+[npm registry](https://www.npmjs.com/). Installation is done using the
+[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+```sh
+$ npm install mime-types
+```
+
+## Adding Types
+
+All mime types are based on [mime-db](https://www.npmjs.com/package/mime-db),
+so open a PR there if you'd like to add mime types.
+
+## API
+
+```js
+var mime = require('mime-types')
+```
+
+All functions return `false` if input is invalid or not found.
+
+### mime.lookup(path)
+
+Lookup the content-type associated with a file.
+
+```js
+mime.lookup('json') // 'application/json'
+mime.lookup('.md') // 'text/markdown'
+mime.lookup('file.html') // 'text/html'
+mime.lookup('folder/file.js') // 'application/javascript'
+mime.lookup('folder/.htaccess') // false
+
+mime.lookup('cats') // false
+```
+
+### mime.contentType(type)
+
+Create a full content-type header given a content-type or extension.
+When given an extension, `mime.lookup` is used to get the matching
+content-type, otherwise the given content-type is used. Then if the
+content-type does not already have a `charset` parameter, `mime.charset`
+is used to get the default charset and add to the returned content-type.
+
+```js
+mime.contentType('markdown') // 'text/x-markdown; charset=utf-8'
+mime.contentType('file.json') // 'application/json; charset=utf-8'
+mime.contentType('text/html') // 'text/html; charset=utf-8'
+mime.contentType('text/html; charset=iso-8859-1') // 'text/html; charset=iso-8859-1'
+
+// from a full path
+mime.contentType(path.extname('/path/to/file.json')) // 'application/json; charset=utf-8'
+```
+
+### mime.extension(type)
+
+Get the default extension for a content-type.
+
+```js
+mime.extension('application/octet-stream') // 'bin'
+```
+
+### mime.charset(type)
+
+Lookup the implied default charset of a content-type.
+
+```js
+mime.charset('text/markdown') // 'UTF-8'
+```
+
+### var type = mime.types[extension]
+
+A map of content-types by extension.
+
+### [extensions...] = mime.extensions[type]
+
+A map of extensions by content-type.
+
+## License
+
+[MIT](LICENSE)
+
+[ci-image]: https://badgen.net/github/checks/jshttp/mime-types/master?label=ci
+[ci-url]: https://github.com/jshttp/mime-types/actions/workflows/ci.yml
+[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/mime-types/master
+[coveralls-url]: https://coveralls.io/r/jshttp/mime-types?branch=master
+[node-version-image]: https://badgen.net/npm/node/mime-types
+[node-version-url]: https://nodejs.org/en/download
+[npm-downloads-image]: https://badgen.net/npm/dm/mime-types
+[npm-url]: https://npmjs.org/package/mime-types
+[npm-version-image]: https://badgen.net/npm/v/mime-types

node_modules/webpack-dev-middleware/node_modules/mime-types/index.js

@@ -0,0 +1,188 @@
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var db = require('mime-db')
+var extname = require('path').extname
+
+/**
+ * Module variables.
+ * @private
+ */
+
+var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/
+var TEXT_TYPE_REGEXP = /^text\//i
+
+/**
+ * Module exports.
+ * @public
+ */
+
+exports.charset = charset
+exports.charsets = { lookup: charset }
+exports.contentType = contentType
+exports.extension = extension
+exports.extensions = Object.create(null)
+exports.lookup = lookup
+exports.types = Object.create(null)
+
+// Populate the extensions/types maps
+populateMaps(exports.extensions, exports.types)
+
+/**
+ * Get the default charset for a MIME type.
+ *
+ * @param {string} type
+ * @return {boolean|string}
+ */
+
+function charset (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
+
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
+  var mime = match && db[match[1].toLowerCase()]
+
+  if (mime && mime.charset) {
+    return mime.charset
+  }
+
+  // default text/* to utf-8
+  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+    return 'UTF-8'
+  }
+
+  return false
+}
+
+/**
+ * Create a full Content-Type header given a MIME type or extension.
+ *
+ * @param {string} str
+ * @return {boolean|string}
+ */
+
+function contentType (str) {
+  // TODO: should this even be in this module?
+  if (!str || typeof str !== 'string') {
+    return false
+  }
+
+  var mime = str.indexOf('/') === -1
+    ? exports.lookup(str)
+    : str
+
+  if (!mime) {
+    return false
+  }
+
+  // TODO: use content-type or other module
+  if (mime.indexOf('charset') === -1) {
+    var charset = exports.charset(mime)
+    if (charset) mime += '; charset=' + charset.toLowerCase()
+  }
+
+  return mime
+}
+
+/**
+ * Get the default extension for a MIME type.
+ *
+ * @param {string} type
+ * @return {boolean|string}
+ */
+
+function extension (type) {
+  if (!type || typeof type !== 'string') {
+    return false
+  }
+
+  // TODO: use media-typer
+  var match = EXTRACT_TYPE_REGEXP.exec(type)
+
+  // get extensions
+  var exts = match && exports.extensions[match[1].toLowerCase()]
+
+  if (!exts || !exts.length) {
+    return false
+  }
+
+  return exts[0]
+}
+
+/**
+ * Lookup the MIME type for a file path/extension.
+ *
+ * @param {string} path
+ * @return {boolean|string}
+ */
+
+function lookup (path) {
+  if (!path || typeof path !== 'string') {
+    return false
+  }
+
+  // get the extension ("ext" or ".ext" or full path)
+  var extension = extname('x.' + path)
+    .toLowerCase()
+    .substr(1)
+
+  if (!extension) {
+    return false
+  }
+
+  return exports.types[extension] || false
+}
+
+/**
+ * Populate the extensions and types maps.
+ * @private
+ */
+
+function populateMaps (extensions, types) {
+  // source preference (least -> most)
+  var preference = ['nginx', 'apache', undefined, 'iana']
+
+  Object.keys(db).forEach(function forEachMimeType (type) {
+    var mime = db[type]
+    var exts = mime.extensions
+
+    if (!exts || !exts.length) {
+      return
+    }
+
+    // mime -> extensions
+    extensions[type] = exts
+
+    // extension -> mime
+    for (var i = 0; i < exts.length; i++) {
+      var extension = exts[i]
+
+      if (types[extension]) {
+        var from = preference.indexOf(db[types[extension]].source)
+        var to = preference.indexOf(mime.source)
+
+        if (types[extension] !== 'application/octet-stream' &&
+          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+          // skip the remapping
+          continue
+        }
+      }
+
+      // set the extension -> mime
+      types[extension] = type
+    }
+  })
+}

node_modules/webpack-dev-middleware/node_modules/mime-types/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "mime-types",
+  "description": "The ultimate javascript content-type utility.",
+  "version": "2.1.35",
+  "contributors": [
+    "Douglas Christopher Wilson <doug@somethingdoug.com>",
+    "Jeremiah Senkpiel <fishrock123@rocketmail.com> (https://searchbeam.jit.su)",
+    "Jonathan Ong <me@jongleberry.com> (http://jongleberry.com)"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "mime",
+    "types"
+  ],
+  "repository": "jshttp/mime-types",
+  "dependencies": {
+    "mime-db": "1.52.0"
+  },
+  "devDependencies": {
+    "eslint": "7.32.0",
+    "eslint-config-standard": "14.1.1",
+    "eslint-plugin-import": "2.25.4",
+    "eslint-plugin-markdown": "2.2.1",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-promise": "5.2.0",
+    "eslint-plugin-standard": "4.1.0",
+    "mocha": "9.2.2",
+    "nyc": "15.1.0"
+  },
+  "files": [
+    "HISTORY.md",
+    "LICENSE",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "scripts": {
+    "lint": "eslint .",
+    "test": "mocha --reporter spec test/test.js",
+    "test-ci": "nyc --reporter=lcov --reporter=text npm test",
+    "test-cov": "nyc --reporter=html --reporter=text npm test"
+  }
+}

node_modules/webpack-dev-middleware/node_modules/range-parser/HISTORY.md

@@ -0,0 +1,56 @@
+1.2.1 / 2019-05-10
+==================
+
+  * Improve error when `str` is not a string
+
+1.2.0 / 2016-06-01
+==================
+
+  * Add `combine` option to combine overlapping ranges
+
+1.1.0 / 2016-05-13
+==================
+
+  * Fix incorrectly returning -1 when there is at least one valid range
+  * perf: remove internal function
+
+1.0.3 / 2015-10-29
+==================
+
+  * perf: enable strict mode
+
+1.0.2 / 2014-09-08
+==================
+
+  * Support Node.js 0.6
+
+1.0.1 / 2014-09-07
+==================
+
+  * Move repository to jshttp
+
+1.0.0 / 2013-12-11
+==================
+
+  * Add repository to package.json
+  * Add MIT license
+
+0.0.4 / 2012-06-17
+==================
+
+  * Change ret -1 for unsatisfiable and -2 when invalid
+
+0.0.3 / 2012-06-17
+==================
+
+  * Fix last-byte-pos default to len - 1
+
+0.0.2 / 2012-06-14
+==================
+
+  * Add `.type`
+
+0.0.1 / 2012-06-11
+==================
+
+  * Initial release

node_modules/webpack-dev-middleware/node_modules/range-parser/LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2012-2014 TJ Holowaychuk <tj@vision-media.ca>
+Copyright (c) 2015-2016 Douglas Christopher Wilson <doug@somethingdoug.com
+
+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.

node_modules/webpack-dev-middleware/node_modules/range-parser/README.md

@@ -0,0 +1,84 @@
+# range-parser
+
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Downloads][npm-downloads-image]][npm-url]
+[![Node.js Version][node-image]][node-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Range header field parser.
+
+## Installation
+
+This is a [Node.js](https://nodejs.org/en/) module available through the
+[npm registry](https://www.npmjs.com/). Installation is done using the
+[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+```sh
+$ npm install range-parser
+```
+
+## API
+
+<!-- eslint-disable no-unused-vars -->
+
+```js
+var parseRange = require('range-parser')
+```
+
+### parseRange(size, header, options)
+
+Parse the given `header` string where `size` is the maximum size of the resource.
+An array of ranges will be returned or negative numbers indicating an error parsing.
+
+  * `-2` signals a malformed header string
+  * `-1` signals an unsatisfiable range
+
+<!-- eslint-disable no-undef -->
+
+```js
+// parse header from request
+var range = parseRange(size, req.headers.range)
+
+// the type of the range
+if (range.type === 'bytes') {
+  // the ranges
+  range.forEach(function (r) {
+    // do something with r.start and r.end
+  })
+}
+```
+
+#### Options
+
+These properties are accepted in the options object.
+
+##### combine
+
+Specifies if overlapping & adjacent ranges should be combined, defaults to `false`.
+When `true`, ranges will be combined and returned as if they were specified that
+way in the header.
+
+<!-- eslint-disable no-undef -->
+
+```js
+parseRange(100, 'bytes=50-55,0-10,5-10,56-60', { combine: true })
+// => [
+//      { start: 0,  end: 10 },
+//      { start: 50, end: 60 }
+//    ]
+```
+
+## License
+
+[MIT](LICENSE)
+
+[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/range-parser/master
+[coveralls-url]: https://coveralls.io/r/jshttp/range-parser?branch=master
+[node-image]: https://badgen.net/npm/node/range-parser
+[node-url]: https://nodejs.org/en/download
+[npm-downloads-image]: https://badgen.net/npm/dm/range-parser
+[npm-url]: https://npmjs.org/package/range-parser
+[npm-version-image]: https://badgen.net/npm/v/range-parser
+[travis-image]: https://badgen.net/travis/jshttp/range-parser/master
+[travis-url]: https://travis-ci.org/jshttp/range-parser

node_modules/webpack-dev-middleware/node_modules/range-parser/index.js

@@ -0,0 +1,162 @@
+/*!
+ * range-parser
+ * Copyright(c) 2012-2014 TJ Holowaychuk
+ * Copyright(c) 2015-2016 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = rangeParser
+
+/**
+ * Parse "Range" header `str` relative to the given file `size`.
+ *
+ * @param {Number} size
+ * @param {String} str
+ * @param {Object} [options]
+ * @return {Array}
+ * @public
+ */
+
+function rangeParser (size, str, options) {
+  if (typeof str !== 'string') {
+    throw new TypeError('argument str must be a string')
+  }
+
+  var index = str.indexOf('=')
+
+  if (index === -1) {
+    return -2
+  }
+
+  // split the range string
+  var arr = str.slice(index + 1).split(',')
+  var ranges = []
+
+  // add ranges type
+  ranges.type = str.slice(0, index)
+
+  // parse all ranges
+  for (var i = 0; i < arr.length; i++) {
+    var range = arr[i].split('-')
+    var start = parseInt(range[0], 10)
+    var end = parseInt(range[1], 10)
+
+    // -nnn
+    if (isNaN(start)) {
+      start = size - end
+      end = size - 1
+    // nnn-
+    } else if (isNaN(end)) {
+      end = size - 1
+    }
+
+    // limit last-byte-pos to current length
+    if (end > size - 1) {
+      end = size - 1
+    }
+
+    // invalid or unsatisifiable
+    if (isNaN(start) || isNaN(end) || start > end || start < 0) {
+      continue
+    }
+
+    // add range
+    ranges.push({
+      start: start,
+      end: end
+    })
+  }
+
+  if (ranges.length < 1) {
+    // unsatisifiable
+    return -1
+  }
+
+  return options && options.combine
+    ? combineRanges(ranges)
+    : ranges
+}
+
+/**
+ * Combine overlapping & adjacent ranges.
+ * @private
+ */
+
+function combineRanges (ranges) {
+  var ordered = ranges.map(mapWithIndex).sort(sortByRangeStart)
+
+  for (var j = 0, i = 1; i < ordered.length; i++) {
+    var range = ordered[i]
+    var current = ordered[j]
+
+    if (range.start > current.end + 1) {
+      // next range
+      ordered[++j] = range
+    } else if (range.end > current.end) {
+      // extend range
+      current.end = range.end
+      current.index = Math.min(current.index, range.index)
+    }
+  }
+
+  // trim ordered array
+  ordered.length = j + 1
+
+  // generate combined range
+  var combined = ordered.sort(sortByRangeIndex).map(mapWithoutIndex)
+
+  // copy ranges type
+  combined.type = ranges.type
+
+  return combined
+}
+
+/**
+ * Map function to add index value to ranges.
+ * @private
+ */
+
+function mapWithIndex (range, index) {
+  return {
+    start: range.start,
+    end: range.end,
+    index: index
+  }
+}
+
+/**
+ * Map function to remove index value from ranges.
+ * @private
+ */
+
+function mapWithoutIndex (range) {
+  return {
+    start: range.start,
+    end: range.end
+  }
+}
+
+/**
+ * Sort function to sort ranges by index.
+ * @private
+ */
+
+function sortByRangeIndex (a, b) {
+  return a.index - b.index
+}
+
+/**
+ * Sort function to sort ranges by start position.
+ * @private
+ */
+
+function sortByRangeStart (a, b) {
+  return a.start - b.start
+}

node_modules/webpack-dev-middleware/node_modules/range-parser/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "range-parser",
+  "author": "TJ Holowaychuk <tj@vision-media.ca> (http://tjholowaychuk.com)",
+  "description": "Range header field string parser",
+  "version": "1.2.1",
+  "contributors": [
+    "Douglas Christopher Wilson <doug@somethingdoug.com>",
+    "James Wyatt Cready <wyatt.cready@lanetix.com>",
+    "Jonathan Ong <me@jongleberry.com> (http://jongleberry.com)"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "range",
+    "parser",
+    "http"
+  ],
+  "repository": "jshttp/range-parser",
+  "devDependencies": {
+    "deep-equal": "1.0.1",
+    "eslint": "5.16.0",
+    "eslint-config-standard": "12.0.0",
+    "eslint-plugin-markdown": "1.0.0",
+    "eslint-plugin-import": "2.17.2",
+    "eslint-plugin-node": "8.0.1",
+    "eslint-plugin-promise": "4.1.1",
+    "eslint-plugin-standard": "4.0.0",
+    "mocha": "6.1.4",
+    "nyc": "14.1.1"
+  },
+  "files": [
+    "HISTORY.md",
+    "LICENSE",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "scripts": {
+    "lint": "eslint --plugin markdown --ext js,md .",
+    "test": "mocha --reporter spec",
+    "test-cov": "nyc --reporter=html --reporter=text npm test",
+    "test-travis": "nyc --reporter=text npm test"
+  }
+}

node_modules/webpack-dev-middleware/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "webpack-dev-middleware",
+  "version": "5.3.4",
+  "description": "A development middleware for webpack",
+  "license": "MIT",
+  "repository": "webpack/webpack-dev-middleware",
+  "author": "Tobias Koppers @sokra",
+  "homepage": "https://github.com/webpack/webpack-dev-middleware",
+  "bugs": "https://github.com/webpack/webpack-dev-middleware/issues",
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/webpack"
+  },
+  "main": "dist/index.js",
+  "types": "types/index.d.ts",
+  "engines": {
+    "node": ">= 12.13.0"
+  },
+  "scripts": {
+    "commitlint": "commitlint --from=master",
+    "security": "npm audit --production",
+    "fmt:check": "prettier \"{**/*,*}.{js,json,md,yml,css}\" --list-different",
+    "lint:js": "eslint --cache src test",
+    "lint:types": "tsc --pretty --noEmit",
+    "lint": "npm-run-all lint:js fmt:check",
+    "fmt": "npm run fmt:check -- --write",
+    "fix:js": "npm run lint:js -- --fix",
+    "fix": "npm-run-all fix:js fmt",
+    "clean": "del-cli dist types",
+    "prebuild": "npm run clean",
+    "build:types": "tsc --declaration --emitDeclarationOnly --outDir types && prettier \"types/**/*.ts\" --write",
+    "build:code": "cross-env NODE_ENV=production babel src -d dist --copy-files",
+    "build": "npm-run-all -p \"build:**\"",
+    "test:only": "cross-env NODE_ENV=test jest",
+    "test:watch": "npm run test:only -- --watch",
+    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
+    "pretest": "npm run lint",
+    "test": "npm run test:coverage",
+    "prepare": "husky install && npm run build",
+    "release": "standard-version"
+  },
+  "files": [
+    "dist",
+    "types"
+  ],
+  "peerDependencies": {
+    "webpack": "^4.0.0 || ^5.0.0"
+  },
+  "dependencies": {
+    "colorette": "^2.0.10",
+    "memfs": "^3.4.3",
+    "mime-types": "^2.1.31",
+    "range-parser": "^1.2.1",
+    "schema-utils": "^4.0.0"
+  },
+  "devDependencies": {
+    "@babel/cli": "^7.16.7",
+    "@babel/core": "^7.16.7",
+    "@babel/preset-env": "^7.16.7",
+    "@commitlint/cli": "^17.0.0",
+    "@commitlint/config-conventional": "^17.0.0",
+    "@types/connect": "^3.4.35",
+    "@types/express": "^4.17.13",
+    "@types/mime-types": "^2.1.1",
+    "@types/node": "^12.20.43",
+    "@webpack-contrib/eslint-config-webpack": "^3.0.0",
+    "babel-jest": "^28.1.0",
+    "chokidar": "^3.5.1",
+    "connect": "^3.7.0",
+    "cross-env": "^7.0.3",
+    "deepmerge": "^4.2.2",
+    "del": "^6.0.0",
+    "del-cli": "^4.0.0",
+    "eslint": "^8.6.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.4",
+    "execa": "^5.1.1",
+    "express": "^4.17.1",
+    "file-loader": "^6.2.0",
+    "husky": "^7.0.0",
+    "jest": "^28.1.0",
+    "lint-staged": "^12.1.7",
+    "npm-run-all": "^4.1.5",
+    "prettier": "^2.5.0",
+    "standard-version": "^9.3.0",
+    "strip-ansi": "^6.0.0",
+    "supertest": "^6.1.3",
+    "typescript": "4.5.5",
+    "webpack": "^5.68.0"
+  },
+  "keywords": [
+    "webpack",
+    "middleware",
+    "development"
+  ]
+}

node_modules/webpack-dev-middleware/types/index.d.ts

@@ -0,0 +1,257 @@
+/// <reference types="node" />
+export = wdm;
+/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+/** @typedef {import("webpack").Configuration} Configuration */
+/** @typedef {import("webpack").Stats} Stats */
+/** @typedef {import("webpack").MultiStats} MultiStats */
+/**
+ * @typedef {Object} ExtendedServerResponse
+ * @property {{ webpack?: { devMiddleware?: Context<IncomingMessage, ServerResponse> } }} [locals]
+ */
+/** @typedef {import("http").IncomingMessage} IncomingMessage */
+/** @typedef {import("http").ServerResponse & ExtendedServerResponse} ServerResponse */
+/**
+ * @callback NextFunction
+ * @param {any} [err]
+ * @return {void}
+ */
+/**
+ * @typedef {NonNullable<Configuration["watchOptions"]>} WatchOptions
+ */
+/**
+ * @typedef {Compiler["watching"]} Watching
+ */
+/**
+ * @typedef {ReturnType<Compiler["watch"]>} MultiWatching
+ */
+/**
+ * @typedef {Compiler["outputFileSystem"] & { createReadStream?: import("fs").createReadStream, statSync?: import("fs").statSync, lstat?: import("fs").lstat, readFileSync?: import("fs").readFileSync }} OutputFileSystem
+ */
+/** @typedef {ReturnType<Compiler["getInfrastructureLogger"]>} Logger */
+/**
+ * @callback Callback
+ * @param {Stats | MultiStats} [stats]
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Object} Context
+ * @property {boolean} state
+ * @property {Stats | MultiStats | undefined} stats
+ * @property {Callback[]} callbacks
+ * @property {Options<Request, Response>} options
+ * @property {Compiler | MultiCompiler} compiler
+ * @property {Watching | MultiWatching} watching
+ * @property {Logger} logger
+ * @property {OutputFileSystem} outputFileSystem
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Record<string, string | number> | Array<{ key: string, value: number | string }> | ((req: Request, res: Response, context: Context<Request, Response>) =>  void | undefined | Record<string, string | number>) | undefined} Headers
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Object} Options
+ * @property {{[key: string]: string}} [mimeTypes]
+ * @property {boolean | ((targetPath: string) => boolean)} [writeToDisk]
+ * @property {string} [methods]
+ * @property {Headers<Request, Response>} [headers]
+ * @property {NonNullable<Configuration["output"]>["publicPath"]} [publicPath]
+ * @property {Configuration["stats"]} [stats]
+ * @property {boolean} [serverSideRender]
+ * @property {OutputFileSystem} [outputFileSystem]
+ * @property {boolean | string} [index]
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @callback Middleware
+ * @param {Request} req
+ * @param {Response} res
+ * @param {NextFunction} next
+ * @return {Promise<void>}
+ */
+/**
+ * @callback GetFilenameFromUrl
+ * @param {string} url
+ * @returns {string | undefined}
+ */
+/**
+ * @callback WaitUntilValid
+ * @param {Callback} callback
+ */
+/**
+ * @callback Invalidate
+ * @param {Callback} callback
+ */
+/**
+ * @callback Close
+ * @param {(err: Error | null | undefined) => void} callback
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Object} AdditionalMethods
+ * @property {GetFilenameFromUrl} getFilenameFromUrl
+ * @property {WaitUntilValid} waitUntilValid
+ * @property {Invalidate} invalidate
+ * @property {Close} close
+ * @property {Context<Request, Response>} context
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @typedef {Middleware<Request, Response> & AdditionalMethods<Request, Response>} API
+ */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {Compiler | MultiCompiler} compiler
+ * @param {Options<Request, Response>} [options]
+ * @returns {API<Request, Response>}
+ */
+declare function wdm<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends ServerResponse
+>(
+  compiler: Compiler | MultiCompiler,
+  options?: Options<Request_1, Response_1> | undefined
+): API<Request_1, Response_1>;
+declare namespace wdm {
+  export {
+    Schema,
+    Compiler,
+    MultiCompiler,
+    Configuration,
+    Stats,
+    MultiStats,
+    ExtendedServerResponse,
+    IncomingMessage,
+    ServerResponse,
+    NextFunction,
+    WatchOptions,
+    Watching,
+    MultiWatching,
+    OutputFileSystem,
+    Logger,
+    Callback,
+    Context,
+    Headers,
+    Options,
+    Middleware,
+    GetFilenameFromUrl,
+    WaitUntilValid,
+    Invalidate,
+    Close,
+    AdditionalMethods,
+    API,
+  };
+}
+type ServerResponse = import("http").ServerResponse & ExtendedServerResponse;
+type Compiler = import("webpack").Compiler;
+type MultiCompiler = import("webpack").MultiCompiler;
+type Options<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends ServerResponse
+> = {
+  mimeTypes?:
+    | {
+        [key: string]: string;
+      }
+    | undefined;
+  writeToDisk?: boolean | ((targetPath: string) => boolean) | undefined;
+  methods?: string | undefined;
+  headers?: Headers<Request_1, Response_1>;
+  publicPath?: NonNullable<Configuration["output"]>["publicPath"];
+  stats?: Configuration["stats"];
+  serverSideRender?: boolean | undefined;
+  outputFileSystem?: OutputFileSystem | undefined;
+  index?: string | boolean | undefined;
+};
+type API<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends ServerResponse
+> = Middleware<Request_1, Response_1> &
+  AdditionalMethods<Request_1, Response_1>;
+type Schema = import("schema-utils/declarations/validate").Schema;
+type Configuration = import("webpack").Configuration;
+type Stats = import("webpack").Stats;
+type MultiStats = import("webpack").MultiStats;
+type ExtendedServerResponse = {
+  locals?:
+    | {
+        webpack?:
+          | {
+              devMiddleware?:
+                | Context<import("http").IncomingMessage, ServerResponse>
+                | undefined;
+            }
+          | undefined;
+      }
+    | undefined;
+};
+type IncomingMessage = import("http").IncomingMessage;
+type NextFunction = (err?: any) => void;
+type WatchOptions = NonNullable<Configuration["watchOptions"]>;
+type Watching = Compiler["watching"];
+type MultiWatching = ReturnType<Compiler["watch"]>;
+type OutputFileSystem = Compiler["outputFileSystem"] & {
+  createReadStream?: typeof import("fs").createReadStream;
+  statSync?: typeof import("fs").statSync;
+  lstat?: typeof import("fs").lstat;
+  readFileSync?: typeof import("fs").readFileSync;
+};
+type Logger = ReturnType<Compiler["getInfrastructureLogger"]>;
+type Callback = (
+  stats?: import("webpack").Stats | import("webpack").MultiStats | undefined
+) => any;
+type Context<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends ServerResponse
+> = {
+  state: boolean;
+  stats: Stats | MultiStats | undefined;
+  callbacks: Callback[];
+  options: Options<Request_1, Response_1>;
+  compiler: Compiler | MultiCompiler;
+  watching: Watching | MultiWatching;
+  logger: Logger;
+  outputFileSystem: OutputFileSystem;
+};
+type Headers<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends ServerResponse
+> =
+  | Record<string, string | number>
+  | {
+      key: string;
+      value: number | string;
+    }[]
+  | ((
+      req: Request_1,
+      res: Response_1,
+      context: Context<Request_1, Response_1>
+    ) => void | undefined | Record<string, string | number>)
+  | undefined;
+type Middleware<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends ServerResponse
+> = (req: Request_1, res: Response_1, next: NextFunction) => Promise<void>;
+type GetFilenameFromUrl = (url: string) => string | undefined;
+type WaitUntilValid = (callback: Callback) => any;
+type Invalidate = (callback: Callback) => any;
+type Close = (callback: (err: Error | null | undefined) => void) => any;
+type AdditionalMethods<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends ServerResponse
+> = {
+  getFilenameFromUrl: GetFilenameFromUrl;
+  waitUntilValid: WaitUntilValid;
+  invalidate: Invalidate;
+  close: Close;
+  context: Context<Request_1, Response_1>;
+};

node_modules/webpack-dev-middleware/types/middleware.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+export = wrapper;
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("./index.js").Context<Request, Response>} context
+ * @return {import("./index.js").Middleware<Request, Response>}
+ */
+declare function wrapper<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("./index.js").ServerResponse
+>(
+  context: import("./index.js").Context<Request_1, Response_1>
+): import("./index.js").Middleware<Request_1, Response_1>;
+declare namespace wrapper {
+  export { NextFunction, IncomingMessage, ServerResponse };
+}
+type NextFunction = import("./index.js").NextFunction;
+type IncomingMessage = import("./index.js").IncomingMessage;
+type ServerResponse = import("./index.js").ServerResponse;

node_modules/webpack-dev-middleware/types/utils/compatibleAPI.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="node" />
+export type IncomingMessage = import("../index.js").IncomingMessage;
+export type ServerResponse = import("../index.js").ServerResponse;
+export type ExpectedRequest = {
+  get: (name: string) => string | undefined;
+};
+export type ExpectedResponse = {
+  get: (name: string) => string | string[] | undefined;
+  set: (name: string, value: number | string | string[]) => void;
+  status: (status: number) => void;
+  send: (data: any) => void;
+};
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/**
+ * @typedef {Object} ExpectedRequest
+ * @property {(name: string) => string | undefined} get
+ */
+/**
+ * @typedef {Object} ExpectedResponse
+ * @property {(name: string) => string | string[] | undefined} get
+ * @property {(name: string, value: number | string | string[]) => void} set
+ * @property {(status: number) => void} status
+ * @property {(data: any) => void} send
+ */
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ * @returns {string[]}
+ */
+export function getHeaderNames<
+  Response_1 extends import("../index.js").ServerResponse
+>(res: Response_1): string[];
+/**
+ * @template {IncomingMessage} Request
+ * @param {Request} req
+ * @param {string} name
+ * @returns {string | undefined}
+ */
+export function getHeaderFromRequest<
+  Request_1 extends import("http").IncomingMessage
+>(req: Request_1, name: string): string | undefined;
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ * @param {string} name
+ * @returns {number | string | string[] | undefined}
+ */
+export function getHeaderFromResponse<
+  Response_1 extends import("../index.js").ServerResponse
+>(res: Response_1, name: string): number | string | string[] | undefined;
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ * @param {string} name
+ * @param {number | string | string[]} value
+ * @returns {void}
+ */
+export function setHeaderForResponse<
+  Response_1 extends import("../index.js").ServerResponse
+>(res: Response_1, name: string, value: number | string | string[]): void;
+/**
+ * @template {ServerResponse} Response
+ * @param {Response} res
+ * @param {number} code
+ */
+export function setStatusCode<
+  Response_1 extends import("../index.js").ServerResponse
+>(res: Response_1, code: number): void;
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {Request} req
+ * @param {Response} res
+ * @param {string | Buffer | import("fs").ReadStream} bufferOtStream
+ * @param {number} byteLength
+ */
+export function send<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("../index.js").ServerResponse
+>(
+  req: Request_1,
+  res: Response_1,
+  bufferOtStream: string | Buffer | import("fs").ReadStream,
+  byteLength: number
+): void;
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {Request} req response
+ * @param {Response} res response
+ * @param {number} status status
+ * @returns {void}
+ */
+export function sendError<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("../index.js").ServerResponse
+>(req: Request_1, res: Response_1, status: number): void;

node_modules/webpack-dev-middleware/types/utils/getFilenameFromUrl.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+export = getFilenameFromUrl;
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ * @param {string} url
+ * @param {Extra=} extra
+ * @returns {string | undefined}
+ */
+declare function getFilenameFromUrl<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("../index.js").ServerResponse
+>(
+  context: import("../index.js").Context<Request_1, Response_1>,
+  url: string,
+  extra?: Extra | undefined
+): string | undefined;
+declare namespace getFilenameFromUrl {
+  export { Extra, IncomingMessage, ServerResponse };
+}
+type Extra = {
+  stats?: import("fs").Stats | undefined;
+  errorCode?: number | undefined;
+};
+type IncomingMessage = import("../index.js").IncomingMessage;
+type ServerResponse = import("../index.js").ServerResponse;

node_modules/webpack-dev-middleware/types/utils/getPaths.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+export = getPaths;
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").Stats} Stats */
+/** @typedef {import("webpack").MultiStats} MultiStats */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ */
+declare function getPaths<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("../index.js").ServerResponse
+>(
+  context: import("../index.js").Context<Request_1, Response_1>
+): {
+  outputPath: string;
+  publicPath: string;
+}[];
+declare namespace getPaths {
+  export { Compiler, Stats, MultiStats, IncomingMessage, ServerResponse };
+}
+type Compiler = import("webpack").Compiler;
+type Stats = import("webpack").Stats;
+type MultiStats = import("webpack").MultiStats;
+type IncomingMessage = import("../index.js").IncomingMessage;
+type ServerResponse = import("../index.js").ServerResponse;

node_modules/webpack-dev-middleware/types/utils/ready.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+export = ready;
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ * @param {(...args: any[]) => any} callback
+ * @param {Request} [req]
+ * @returns {void}
+ */
+declare function ready<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("../index.js").ServerResponse
+>(
+  context: import("../index.js").Context<Request_1, Response_1>,
+  callback: (...args: any[]) => any,
+  req?: Request_1 | undefined
+): void;
+declare namespace ready {
+  export { IncomingMessage, ServerResponse };
+}
+type IncomingMessage = import("../index.js").IncomingMessage;
+type ServerResponse = import("../index.js").ServerResponse;

node_modules/webpack-dev-middleware/types/utils/setupHooks.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+export = setupHooks;
+/** @typedef {import("webpack").Configuration} Configuration */
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+/** @typedef {import("webpack").Stats} Stats */
+/** @typedef {import("webpack").MultiStats} MultiStats */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/** @typedef {Configuration["stats"]} StatsOptions */
+/** @typedef {{ children: Configuration["stats"][] }} MultiStatsOptions */
+/** @typedef {Exclude<Configuration["stats"], boolean | string | undefined>} NormalizedStatsOptions */
+/** @typedef {{ children: StatsOptions[], colors?: any }} MultiNormalizedStatsOptions */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ */
+declare function setupHooks<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("../index.js").ServerResponse
+>(context: import("../index.js").Context<Request_1, Response_1>): void;
+declare namespace setupHooks {
+  export {
+    Configuration,
+    Compiler,
+    MultiCompiler,
+    Stats,
+    MultiStats,
+    IncomingMessage,
+    ServerResponse,
+    StatsOptions,
+    MultiStatsOptions,
+    NormalizedStatsOptions,
+    MultiNormalizedStatsOptions,
+  };
+}
+type Configuration = import("webpack").Configuration;
+type Compiler = import("webpack").Compiler;
+type MultiCompiler = import("webpack").MultiCompiler;
+type Stats = import("webpack").Stats;
+type MultiStats = import("webpack").MultiStats;
+type IncomingMessage = import("../index.js").IncomingMessage;
+type ServerResponse = import("../index.js").ServerResponse;
+type StatsOptions = Configuration["stats"];
+type MultiStatsOptions = {
+  children: Configuration["stats"][];
+};
+type NormalizedStatsOptions = Exclude<
+  Configuration["stats"],
+  boolean | string | undefined
+>;
+type MultiNormalizedStatsOptions = {
+  children: StatsOptions[];
+  colors?: any;
+};

node_modules/webpack-dev-middleware/types/utils/setupOutputFileSystem.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+export = setupOutputFileSystem;
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ */
+declare function setupOutputFileSystem<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("../index.js").ServerResponse
+>(context: import("../index.js").Context<Request_1, Response_1>): void;
+declare namespace setupOutputFileSystem {
+  export { MultiCompiler, IncomingMessage, ServerResponse };
+}
+type MultiCompiler = import("webpack").MultiCompiler;
+type IncomingMessage = import("../index.js").IncomingMessage;
+type ServerResponse = import("../index.js").ServerResponse;

node_modules/webpack-dev-middleware/types/utils/setupWriteToDisk.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+export = setupWriteToDisk;
+/** @typedef {import("webpack").Compiler} Compiler */
+/** @typedef {import("webpack").MultiCompiler} MultiCompiler */
+/** @typedef {import("webpack").Compilation} Compilation */
+/** @typedef {import("../index.js").IncomingMessage} IncomingMessage */
+/** @typedef {import("../index.js").ServerResponse} ServerResponse */
+/**
+ * @template {IncomingMessage} Request
+ * @template {ServerResponse} Response
+ * @param {import("../index.js").Context<Request, Response>} context
+ */
+declare function setupWriteToDisk<
+  Request_1 extends import("http").IncomingMessage,
+  Response_1 extends import("../index.js").ServerResponse
+>(context: import("../index.js").Context<Request_1, Response_1>): void;
+declare namespace setupWriteToDisk {
+  export {
+    Compiler,
+    MultiCompiler,
+    Compilation,
+    IncomingMessage,
+    ServerResponse,
+  };
+}
+type Compiler = import("webpack").Compiler;
+type MultiCompiler = import("webpack").MultiCompiler;
+type Compilation = import("webpack").Compilation;
+type IncomingMessage = import("../index.js").IncomingMessage;
+type ServerResponse = import("../index.js").ServerResponse;