webpack-dev-server 5.2.1 → 5.2.3

package/lib/Server.js

@@ -1,9 +1,9 @@
 "use strict";
 
-const os = require("os");
-const path = require("path");
-const url = require("url");
-const util = require("util");
+const os = require("node:os");
+const path = require("node:path");
+const url = require("node:url");
+const util = require("node:util");
 const fs = require("graceful-fs");
 const ipaddr = require("ipaddr.js");
 const { validate } = require("schema-utils");
@@ -31,7 +31,7 @@ const schema = require("./options.json");
 /** @typedef {import("ipaddr.js").IPv4} IPv4 */
 /** @typedef {import("ipaddr.js").IPv6} IPv6 */
 /** @typedef {import("net").Socket} Socket */
-/** @typedef {import("http").Server} HTTPServer*/
+/** @typedef {import("http").Server} HTTPServer */
 /** @typedef {import("http").IncomingMessage} IncomingMessage */
 /** @typedef {import("http").ServerResponse} ServerResponse */
 /** @typedef {import("open").Options} OpenOptions */
@@ -41,10 +41,13 @@ const schema = require("./options.json");
 /** @typedef {import("express").Request} ExpressRequest */
 /** @typedef {import("express").Response} ExpressResponse */
 
-/** @typedef {(err?: any) => void} NextFunction */
+// eslint-disable-next-line jsdoc/no-restricted-syntax
+/** @typedef {any} EXPECTED_ANY */
+
+/** @typedef {(err?: EXPECTED_ANY) => void} NextFunction */
 /** @typedef {(req: IncomingMessage, res: ServerResponse) => void} SimpleHandleFunction */
 /** @typedef {(req: IncomingMessage, res: ServerResponse, next: NextFunction) => void} NextHandleFunction */
-/** @typedef {(err: any, req: IncomingMessage, res: ServerResponse, next: NextFunction) => void} ErrorHandleFunction */
+/** @typedef {(err: EXPECTED_ANY, req: IncomingMessage, res: ServerResponse, next: NextFunction) => void} ErrorHandleFunction */
 /** @typedef {SimpleHandleFunction | NextHandleFunction | ErrorHandleFunction} HandleFunction */
 
 /** @typedef {import("https").ServerOptions & { spdy?: { plain?: boolean | undefined, ssl?: boolean | undefined, 'x-forwarded-for'?: string | undefined, protocol?: string | undefined, protocols?: string[] | undefined }}} ServerOptions */
@@ -79,22 +82,22 @@ const schema = require("./options.json");
  */
 
 /**
- * @typedef {Object} WatchFiles
- * @property {string | string[]} paths
- * @property {WatchOptions & { aggregateTimeout?: number, ignored?: WatchOptions["ignored"], poll?: number | boolean }} [options]
+ * @typedef {object} WatchFiles
+ * @property {string | string[]} paths paths
+ * @property {(WatchOptions & { aggregateTimeout?: number, ignored?: WatchOptions["ignored"], poll?: number | boolean })=} options options
  */
 
 /**
- * @typedef {Object} Static
- * @property {string} [directory]
- * @property {string | string[]} [publicPath]
- * @property {boolean | ServeIndexOptions} [serveIndex]
- * @property {ServeStaticOptions} [staticOptions]
- * @property {boolean | WatchOptions & { aggregateTimeout?: number, ignored?: WatchOptions["ignored"], poll?: number | boolean }} [watch]
+ * @typedef {object} Static
+ * @property {string=} directory directory
+ * @property {(string | string[])=} publicPath public path
+ * @property {(boolean | ServeIndexOptions)=} serveIndex serve index
+ * @property {ServeStaticOptions=} staticOptions static options
+ * @property {(boolean | WatchOptions & { aggregateTimeout?: number, ignored?: WatchOptions["ignored"], poll?: number | boolean })=} watch watch and watch options
  */
 
 /**
- * @typedef {Object} NormalizedStatic
+ * @typedef {object} NormalizedStatic
  * @property {string} directory
  * @property {string[]} publicPath
  * @property {false | ServeIndexOptions} serveIndex
@@ -105,21 +108,21 @@ const schema = require("./options.json");
 /**
  * @template {BasicApplication} [A=ExpressApplication]
  * @template {BasicServer} [S=import("http").Server]
- * @typedef {"http" | "https" | "spdy" | "http2" | string | function(ServerOptions, A): S} ServerType
+ * @typedef {"http" | "https" | "spdy" | "http2" | string | ((serverOptions: ServerOptions, application: A) => S)} ServerType
  */
 
 /**
  * @template {BasicApplication} [A=ExpressApplication]
  * @template {BasicServer} [S=import("http").Server]
- * @typedef {Object} ServerConfiguration
- * @property {ServerType<A, S>} [type]
- * @property {ServerOptions} [options]
+ * @typedef {object} ServerConfiguration
+ * @property {ServerType<A, S>=} type type
+ * @property {ServerOptions=} options options
  */
 
 /**
- * @typedef {Object} WebSocketServerConfiguration
- * @property {"sockjs" | "ws" | string | Function} [type]
- * @property {Record<string, any>} [options]
+ * @typedef {object} WebSocketServerConfiguration
+ * @property {("sockjs" | "ws" | string | (() => WebSocketServerConfiguration))=} type type
+ * @property {Record<string, EXPECTED_ANY>=} options options
  */
 
 /**
@@ -150,31 +153,31 @@ const schema = require("./options.json");
  */
 
 /**
- * @typedef {Object} OpenApp
- * @property {string} [name]
- * @property {string[]} [arguments]
+ * @typedef {object} OpenApp
+ * @property {string=} name
+ * @property {string[]=} arguments
  */
 
 /**
- * @typedef {Object} Open
- * @property {string | string[] | OpenApp} [app]
- * @property {string | string[]} [target]
+ * @typedef {object} Open
+ * @property {(string | string[] | OpenApp)=} app
+ * @property {(string | string[])=} target target
  */
 
 /**
- * @typedef {Object} NormalizedOpen
+ * @typedef {object} NormalizedOpen
  * @property {string} target
  * @property {import("open").Options} options
  */
 
 /**
- * @typedef {Object} WebSocketURL
- * @property {string} [hostname]
- * @property {string} [password]
- * @property {string} [pathname]
- * @property {number | string} [port]
- * @property {string} [protocol]
- * @property {string} [username]
+ * @typedef {object} WebSocketURL
+ * @property {string=} hostname hostname
+ * @property {string=} password password
+ * @property {string=} pathname pathname
+ * @property {(number | string)=} port port
+ * @property {string=} protocol protocol
+ * @property {string=} username username
  */
 
 /**
@@ -182,13 +185,13 @@ const schema = require("./options.json");
  */
 
 /**
- * @typedef {Object} ClientConfiguration
- * @property {"log" | "info" | "warn" | "error" | "none" | "verbose"} [logging]
- * @property {boolean  | { warnings?: OverlayMessageOptions, errors?: OverlayMessageOptions, runtimeErrors?: OverlayMessageOptions }} [overlay]
- * @property {boolean} [progress]
- * @property {boolean | number} [reconnect]
- * @property {"ws" | "sockjs" | string} [webSocketTransport]
- * @property {string | WebSocketURL} [webSocketURL]
+ * @typedef {object} ClientConfiguration
+ * @property {"log" | "info" | "warn" | "error" | "none" | "verbose"=} logging logging
+ * @property {(boolean | { warnings?: OverlayMessageOptions, errors?: OverlayMessageOptions, runtimeErrors?: OverlayMessageOptions })=} overlay overlay
+ * @property {boolean=} progress progress
+ * @property {(boolean | number)=} reconnect reconnect
+ * @property {("ws" | "sockjs" | string)=} webSocketTransport web socket transport
+ * @property {(string | WebSocketURL)=} webSocketURL web socket URL
  */
 
 /**
@@ -213,29 +216,29 @@ const schema = require("./options.json");
 /**
  * @template {BasicApplication} [A=ExpressApplication]
  * @template {BasicServer} [S=import("http").Server]
- * @typedef {Object} Configuration
- * @property {boolean | string} [ipc]
- * @property {Host} [host]
- * @property {Port} [port]
- * @property {boolean | "only"} [hot]
- * @property {boolean} [liveReload]
- * @property {DevMiddlewareOptions<Request, Response>} [devMiddleware]
- * @property {boolean} [compress]
- * @property {"auto" | "all" | string | string[]} [allowedHosts]
- * @property {boolean | ConnectHistoryApiFallbackOptions} [historyApiFallback]
- * @property {boolean | Record<string, never> | BonjourOptions} [bonjour]
- * @property {string | string[] | WatchFiles | Array<string | WatchFiles>} [watchFiles]
- * @property {boolean | string | Static | Array<string | Static>} [static]
- * @property {ServerType<A, S> | ServerConfiguration<A, S>} [server]
- * @property {() => Promise<A>} [app]
- * @property {boolean | "sockjs" | "ws" | string | WebSocketServerConfiguration} [webSocketServer]
- * @property {ProxyConfigArray} [proxy]
- * @property {boolean | string | Open | Array<string | Open>} [open]
- * @property {boolean} [setupExitSignals]
- * @property {boolean | ClientConfiguration} [client]
- * @property {Headers | ((req: Request, res: Response, context: DevMiddlewareContext<Request, Response> | undefined) => Headers)} [headers]
- * @property {(devServer: Server<A, S>) => void} [onListening]
- * @property {(middlewares: Middleware[], devServer: Server<A, S>) => Middleware[]} [setupMiddlewares]
+ * @typedef {object} Configuration
+ * @property {(boolean | string)=} ipc
+ * @property {Host=} host
+ * @property {Port=} port
+ * @property {(boolean | "only")=} hot
+ * @property {boolean=} liveReload
+ * @property {DevMiddlewareOptions<Request, Response>=} devMiddleware
+ * @property {boolean=} compress
+ * @property {("auto" | "all" | string | string[])=} allowedHosts
+ * @property {(boolean | ConnectHistoryApiFallbackOptions)=} historyApiFallback
+ * @property {(boolean | Record<string, never> | BonjourOptions)=} bonjour
+ * @property {(string | string[] | WatchFiles | Array<string | WatchFiles>)=} watchFiles
+ * @property {(boolean | string | Static | Array<string | Static>)=} static
+ * @property {(ServerType<A, S> | ServerConfiguration<A, S>)=} server
+ * @property {(() => Promise<A>)=} app
+ * @property {(boolean | "sockjs" | "ws" | string | WebSocketServerConfiguration)=} webSocketServer
+ * @property {ProxyConfigArray=} proxy
+ * @property {(boolean | string | Open | Array<string | Open>)=} open
+ * @property {boolean=} setupExitSignals
+ * @property {(boolean | ClientConfiguration)=} client
+ * @property {(Headers | ((req: Request, res: Response, context: DevMiddlewareContext<Request, Response> | undefined) => Headers))=} headers
+ * @property {((devServer: Server<A, S>) => void)=} onListening
+ * @property {((middlewares: Middleware[], devServer: Server<A, S>) => Middleware[])=} setupMiddlewares
  */
 
 if (!process.env.WEBPACK_SERVE) {
@@ -244,36 +247,38 @@ if (!process.env.WEBPACK_SERVE) {
 
 /**
  * @template T
- * @param fn {(function(): any) | undefined}
- * @returns {function(): T}
+ * @typedef {() => T} FunctionReturning
+ */
+
+/**
+ * @template T
+ * @param {FunctionReturning<T>} fn memorized function
+ * @returns {FunctionReturning<T>} new function
  */
 const memoize = (fn) => {
   let cache = false;
-  /** @type {T} */
+  /** @type {T | undefined} */
   let result;
-
   return () => {
     if (cache) {
-      return result;
+      return /** @type {T} */ (result);
     }
 
-    result = /** @type {function(): any} */ (fn)();
+    result = fn();
     cache = true;
     // Allow to clean up memory for fn
     // and all dependent resources
-    // eslint-disable-next-line no-undefined
-    fn = undefined;
-
-    return result;
+    /** @type {FunctionReturning<T> | undefined} */
+    (fn) = undefined;
+    return /** @type {T} */ (result);
   };
 };
 
 const getExpress = memoize(() => require("express"));
 
 /**
- *
- * @param {OverlayMessageOptions} [setting]
- * @returns
+ * @param {OverlayMessageOptions=} setting overlay settings
+ * @returns {undefined | string | boolean} encoded overlay settings
  */
 const encodeOverlaySettings = (setting) =>
   typeof setting === "function"
@@ -283,24 +288,24 @@ const encodeOverlaySettings = (setting) =>
 // Working for overload, because typescript doesn't support this yes
 /**
  * @overload
- * @param {NextHandleFunction} fn
- * @returns {BasicApplication}
+ * @param {NextHandleFunction} fn function
+ * @returns {BasicApplication} application
  */
 /**
  * @overload
- * @param {HandleFunction} fn
- * @returns {BasicApplication}
+ * @param {HandleFunction} fn function
+ * @returns {BasicApplication} application
  */
 /**
  * @overload
- * @param {string} route
- * @param {NextHandleFunction} fn
- * @returns {BasicApplication}
+ * @param {string} route route
+ * @param {NextHandleFunction} fn function
+ * @returns {BasicApplication} application
  */
 /**
- * @param {string} route
- * @param {HandleFunction} fn
- * @returns {BasicApplication}
+ * @param {string} route route
+ * @param {HandleFunction} fn function
+ * @returns {BasicApplication} application
  */
 // eslint-disable-next-line no-unused-vars
 function useFn(route, fn) {
@@ -310,7 +315,7 @@ function useFn(route, fn) {
 const DEFAULT_ALLOWED_PROTOCOLS = /^(file|.+-extension):/i;
 
 /**
- * @typedef {Object} BasicApplication
+ * @typedef {object} BasicApplication
  * @property {typeof useFn} use
  */
 
@@ -320,10 +325,10 @@ const DEFAULT_ALLOWED_PROTOCOLS = /^(file|.+-extension):/i;
  */
 class Server {
   /**
-   * @param {Configuration<A, S>} options
-   * @param {Compiler | MultiCompiler} compiler
+   * @param {Configuration<A, S>} options options
+   * @param {Compiler | MultiCompiler} compiler compiler
    */
-  constructor(options = {}, compiler) {
+  constructor(options, compiler) {
     validate(/** @type {Schema} */ (schema), options, {
       name: "Dev Server",
       baseDataPath: "options",
@@ -332,7 +337,7 @@ class Server {
     this.compiler = compiler;
     /**
      * @type {ReturnType<Compiler["getInfrastructureLogger"]>}
-     * */
+     */
     this.logger = this.compiler.getInfrastructureLogger("webpack-dev-server");
     this.options = options;
     /**
@@ -341,7 +346,7 @@ class Server {
     this.staticWatchers = [];
     /**
      * @private
-     * @type {{ name: string | symbol, listener: (...args: any[]) => void}[] }}
+     * @type {{ name: string | symbol, listener: (...args: EXPECTED_ANY[]) => void}[] }}
      */
     this.listeners = [];
     // Keep track of websocket proxies for external websocket upgrade.
@@ -358,7 +363,7 @@ class Server {
      * @private
      * @type {string | undefined}
      */
-    // eslint-disable-next-line no-undefined
+
     this.currentHash = undefined;
   }
 
@@ -368,8 +373,7 @@ class Server {
 
   /**
    * @private
-   * @returns {StatsOptions}
-   * @constructor
+   * @returns {StatsOptions} default stats options
    */
   static get DEFAULT_STATS() {
     return {
@@ -382,8 +386,8 @@ class Server {
   }
 
   /**
-   * @param {string} URL
-   * @returns {boolean}
+   * @param {string} URL url
+   * @returns {boolean} true when URL is absolute, otherwise false
    */
   static isAbsoluteURL(URL) {
     // Don't match Windows paths `c:\`
@@ -397,16 +401,15 @@ class Server {
   }
 
   /**
-   * @param {string} gatewayOrFamily or family
-   * @param {boolean} [isInternal] ip should be internal
-   * @returns {string | undefined}
+   * @param {string} gatewayOrFamily gateway or family
+   * @param {boolean=} isInternal ip should be internal
+   * @returns {string | undefined} resolved IP
    */
   static findIp(gatewayOrFamily, isInternal) {
     if (gatewayOrFamily === "v4" || gatewayOrFamily === "v6") {
       let host;
 
       const networks = Object.values(os.networkInterfaces())
-        // eslint-disable-next-line no-shadow
         .flatMap((networks) => networks ?? [])
         .filter((network) => {
           if (!network || !network.address) {
@@ -463,6 +466,7 @@ class Server {
         if (
           net[0] &&
           net[0].kind() === gatewayIp.kind() &&
+          // eslint-disable-next-line unicorn/prefer-regexp-test
           gatewayIp.match(net)
         ) {
           return net[0].toString();
@@ -473,8 +477,8 @@ class Server {
 
   // TODO remove me in the next major release, we have `findIp`
   /**
-   * @param {"v4" | "v6"} family
-   * @returns {Promise<string | undefined>}
+   * @param {"v4" | "v6"} family family
+   * @returns {Promise<string | undefined>} internal API
    */
   static async internalIP(family) {
     return Server.findIp(family, false);
@@ -482,16 +486,16 @@ class Server {
 
   // TODO remove me in the next major release, we have `findIp`
   /**
-   * @param {"v4" | "v6"} family
-   * @returns {string | undefined}
+   * @param {"v4" | "v6"} family family
+   * @returns {string | undefined} internal IP
    */
   static internalIPSync(family) {
     return Server.findIp(family, false);
   }
 
   /**
-   * @param {Host} hostname
-   * @returns {Promise<string>}
+   * @param {Host} hostname hostname
+   * @returns {Promise<string>} resolved hostname
    */
   static async getHostname(hostname) {
     if (hostname === "local-ip") {
@@ -508,9 +512,9 @@ class Server {
   }
 
   /**
-   * @param {Port} port
-   * @param {string} host
-   * @returns {Promise<number | string>}
+   * @param {Port} port port
+   * @param {string} host host
+   * @returns {Promise<number | string>} free port
    */
   static async getFreePort(port, host) {
     if (typeof port !== "undefined" && port !== null && port !== "auto") {
@@ -518,17 +522,19 @@ class Server {
     }
 
     const pRetry = (await import("p-retry")).default;
+
     const getPort = require("./getPort");
+
     const basePort =
       typeof process.env.WEBPACK_DEV_SERVER_BASE_PORT !== "undefined"
-        ? parseInt(process.env.WEBPACK_DEV_SERVER_BASE_PORT, 10)
+        ? Number.parseInt(process.env.WEBPACK_DEV_SERVER_BASE_PORT, 10)
         : 8080;
 
     // Try to find unused port and listen on it for 3 times,
     // if port is not specified in options.
     const defaultPortRetry =
       typeof process.env.WEBPACK_DEV_SERVER_PORT_RETRY !== "undefined"
-        ? parseInt(process.env.WEBPACK_DEV_SERVER_PORT_RETRY, 10)
+        ? Number.parseInt(process.env.WEBPACK_DEV_SERVER_PORT_RETRY, 10)
         : 3;
 
     return pRetry(() => getPort(basePort, host), {
@@ -537,7 +543,7 @@ class Server {
   }
 
   /**
-   * @returns {string}
+   * @returns {string} path to cache dir
    */
   static findCacheDir() {
     const cwd = process.cwd();
@@ -551,12 +557,11 @@ class Server {
       try {
         if (fs.statSync(path.join(dir, "package.json")).isFile()) break;
         // eslint-disable-next-line no-empty
-      } catch (e) {}
+      } catch {}
 
       const parent = path.dirname(dir);
 
       if (dir === parent) {
-        // eslint-disable-next-line no-undefined
         dir = undefined;
         break;
       }
@@ -577,8 +582,8 @@ class Server {
 
   /**
    * @private
-   * @param {Compiler} compiler
-   * @returns bool
+   * @param {Compiler} compiler compiler
+   * @returns {boolean} true when target is `web`, otherwise false
    */
   static isWebTarget(compiler) {
     if (compiler.platform && compiler.platform.web) {
@@ -607,7 +612,7 @@ class Server {
       "electron-renderer",
       "nwjs",
       "node-webkit",
-      // eslint-disable-next-line no-undefined
+
       undefined,
       null,
     ];
@@ -621,7 +626,7 @@ class Server {
 
   /**
    * @private
-   * @param {Compiler} compiler
+   * @param {Compiler} compiler compiler
    */
   addAdditionalEntries(compiler) {
     /**
@@ -810,7 +815,6 @@ class Server {
     // use a hook to add entries if available
     for (const additionalEntry of additionalEntries) {
       new webpack.EntryPlugin(compiler.context, additionalEntry, {
-        // eslint-disable-next-line no-undefined
         name: undefined,
       }).apply(compiler);
     }
@@ -818,7 +822,7 @@ class Server {
 
   /**
    * @private
-   * @returns {Compiler["options"]}
+   * @returns {Compiler["options"]} compiler options
    */
   getCompilerOptions() {
     if (
@@ -854,7 +858,7 @@ class Server {
               "electron-preload",
               "electron-renderer",
               "node-webkit",
-              // eslint-disable-next-line no-undefined
+
               undefined,
               null,
             ].includes(/** @type {string} */ (config.options.target)),
@@ -880,8 +884,8 @@ class Server {
     const compilerOptions = this.getCompilerOptions();
     const compilerWatchOptions = compilerOptions.watchOptions;
     /**
-     * @param {WatchOptions & { aggregateTimeout?: number, ignored?: WatchOptions["ignored"], poll?: number | boolean }} watchOptions
-     * @returns {WatchOptions}
+     * @param {WatchOptions & { aggregateTimeout?: number, ignored?: WatchOptions["ignored"], poll?: number | boolean }} watchOptions watch options
+     * @returns {WatchOptions} normalized watch options
      */
     const getWatchOptions = (watchOptions = {}) => {
       const getPolling = () => {
@@ -933,19 +937,17 @@ class Server {
       };
     };
     /**
-     * @param {string | Static | undefined} [optionsForStatic]
-     * @returns {NormalizedStatic}
+     * @param {(string | Static | undefined)=} optionsForStatic for static
+     * @returns {NormalizedStatic} normalized options for static
      */
     const getStaticItem = (optionsForStatic) => {
-      const getDefaultStaticOptions = () => {
-        return {
-          directory: path.join(process.cwd(), "public"),
-          staticOptions: {},
-          publicPath: ["/"],
-          serveIndex: { icons: true },
-          watch: getWatchOptions(),
-        };
-      };
+      const getDefaultStaticOptions = () => ({
+        directory: path.join(process.cwd(), "public"),
+        staticOptions: {},
+        publicPath: ["/"],
+        serveIndex: { icons: true },
+        watch: getWatchOptions(),
+      });
 
       /** @type {NormalizedStatic} */
       let item;
@@ -970,7 +972,6 @@ class Server {
               ? { ...def.staticOptions, ...optionsForStatic.staticOptions }
               : def.staticOptions,
           publicPath:
-            // eslint-disable-next-line no-nested-ternary
             typeof optionsForStatic.publicPath !== "undefined"
               ? Array.isArray(optionsForStatic.publicPath)
                 ? optionsForStatic.publicPath
@@ -982,10 +983,8 @@ class Server {
             // If 'serveIndex' is an object, merge its properties with default 'serveIndex'
             // If 'serveIndex' is neither a boolean true nor an object, use it as-is
             // If 'serveIndex' is not defined in 'optionsForStatic', use default 'serveIndex'
-            // eslint-disable-next-line no-nested-ternary
             typeof optionsForStatic.serveIndex !== "undefined"
-              ? // eslint-disable-next-line no-nested-ternary
-                typeof optionsForStatic.serveIndex === "boolean" &&
+              ? typeof optionsForStatic.serveIndex === "boolean" &&
                 optionsForStatic.serveIndex
                 ? def.serveIndex
                 : typeof optionsForStatic.serveIndex === "object"
@@ -993,10 +992,8 @@ class Server {
                   : optionsForStatic.serveIndex
               : def.serveIndex,
           watch:
-            // eslint-disable-next-line no-nested-ternary
             typeof optionsForStatic.watch !== "undefined"
-              ? // eslint-disable-next-line no-nested-ternary
-                typeof optionsForStatic.watch === "boolean"
+              ? typeof optionsForStatic.watch === "boolean"
                 ? optionsForStatic.watch
                   ? def.watch
                   : false
@@ -1159,17 +1156,17 @@ class Server {
         /** @type {Array<keyof ServerOptions>} */
         (["ca", "cert", "crl", "key", "pfx"]);
 
-      for (const property of httpsProperties) {
+      for (const property_ of httpsProperties) {
+        const property = /** @type {keyof ServerOptions} */ (property_);
+
         if (typeof serverOptions[property] === "undefined") {
-          // eslint-disable-next-line no-continue
           continue;
         }
 
-        /** @type {any} */
         const value = serverOptions[property];
         /**
-         * @param {string | Buffer | undefined} item
-         * @returns {string | Buffer | undefined}
+         * @param {string | Buffer | undefined} item file to read
+         * @returns {string | Buffer | undefined} content of file
          */
         const readFile = (item) => {
           if (
@@ -1184,7 +1181,7 @@ class Server {
 
             try {
               stats = fs.lstatSync(fs.realpathSync(item)).isFile();
-            } catch (error) {
+            } catch {
               // Ignore error
             }
 
@@ -1193,10 +1190,18 @@ class Server {
           }
         };
 
-        /** @type {any} */
+        /** @type {EXPECTED_ANY} */
         (serverOptions)[property] = Array.isArray(value)
-          ? value.map((item) => readFile(item))
-          : readFile(value);
+          ? value.map((item) =>
+              readFile(
+                /** @type {string | Buffer | undefined} */
+                (item),
+              ),
+            )
+          : readFile(
+              /** @type {string | Buffer | undefined} */
+              (value),
+            );
       }
 
       let fakeCert;
@@ -1216,7 +1221,7 @@ class Server {
         if (certificateExists) {
           const certificateTtl = 1000 * 60 * 60 * 24;
           const certificateStat = await fs.promises.stat(certificatePath);
-          const now = Number(new Date());
+          const now = Date.now();
 
           // cert is more than 30 days old, kill it with fire
           if ((now - Number(certificateStat.ctime)) / certificateTtl > 30) {
@@ -1234,11 +1239,16 @@ class Server {
           this.logger.info("Generating SSL certificate...");
 
           const selfsigned = require("selfsigned");
+
           const attributes = [{ name: "commonName", value: "localhost" }];
-          const pems = selfsigned.generate(attributes, {
+          const notBeforeDate = new Date();
+          const notAfterDate = new Date();
+          notAfterDate.setDate(notAfterDate.getDate() + 30);
+          const pems = await selfsigned.generate(attributes, {
             algorithm: "sha256",
-            days: 30,
             keySize: 2048,
+            notBeforeDate,
+            notAfterDate,
             extensions: [
               {
                 name: "basicConstraints",
@@ -1313,8 +1323,8 @@ class Server {
         this.logger.info(`SSL certificate: ${certificatePath}`);
       }
 
-      serverOptions.key = serverOptions.key || fakeCert;
-      serverOptions.cert = serverOptions.cert || fakeCert;
+      serverOptions.key ||= fakeCert;
+      serverOptions.cert ||= fakeCert;
     }
 
     if (typeof options.ipc === "boolean") {
@@ -1331,8 +1341,8 @@ class Server {
     // https://github.com/webpack/webpack-dev-server/issues/1990
     const defaultOpenOptions = { wait: false };
     /**
-     * @param {any} target
-     * @returns {NormalizedOpen[]}
+     * @param {import("open").Options & { target?: string | string[] } & EXPECTED_ANY} target target
+     * @returns {NormalizedOpen[]} normalized open options
      */
     const getOpenItemsFromObject = ({ target, ...rest }) => {
       const normalizedOptions = { ...defaultOpenOptions, ...rest };
@@ -1346,9 +1356,10 @@ class Server {
       const normalizedTarget = typeof target === "undefined" ? "<url>" : target;
 
       if (Array.isArray(normalizedTarget)) {
-        return normalizedTarget.map((singleTarget) => {
-          return { target: singleTarget, options: normalizedOptions };
-        });
+        return normalizedTarget.map((singleTarget) => ({
+          target: singleTarget,
+          options: normalizedOptions,
+        }));
       }
 
       return [{ target: normalizedTarget, options: normalizedOptions }];
@@ -1379,7 +1390,7 @@ class Server {
       for (const item of options.open) {
         if (typeof item === "string") {
           result.push({ target: item, options: defaultOpenOptions });
-          // eslint-disable-next-line no-continue
+
           continue;
         }
 
@@ -1399,13 +1410,9 @@ class Server {
 
     /**
      * Assume a proxy configuration specified as:
-     * proxy: {
-     *   'context': { options }
-     * }
+     * proxy: { 'context': { options } }
      * OR
-     * proxy: {
-     *   'context': 'target'
-     * }
+     * proxy: { 'context': 'target' }
      */
     if (typeof options.proxy !== "undefined") {
       options.proxy = options.proxy.map((item) => {
@@ -1414,8 +1421,8 @@ class Server {
         }
 
         /**
-         * @param {"info" | "warn" | "error" | "debug" | "silent" | undefined | "none" | "log" | "verbose"} level
-         * @returns {"info" | "warn" | "error" | "debug" | "silent" | undefined}
+         * @param {"info" | "warn" | "error" | "debug" | "silent" | undefined | "none" | "log" | "verbose"} level level
+         * @returns {"info" | "warn" | "error" | "debug" | "silent" | undefined} log level for proxy
          */
         const getLogLevelForProxy = (level) => {
           if (level === "none") {
@@ -1540,7 +1547,7 @@ class Server {
 
   /**
    * @private
-   * @returns {string}
+   * @returns {string} client transport
    */
   getClientTransport() {
     let clientImplementation;
@@ -1552,7 +1559,7 @@ class Server {
         /** @type {WebSocketServerConfiguration} */
         (this.options.webSocketServer).type
       ) === "string" &&
-      // @ts-ignore
+      // @ts-expect-error
       (this.options.webSocketServer.type === "ws" ||
         /** @type {WebSocketServerConfiguration} */
         (this.options.webSocketServer).type === "sockjs");
@@ -1594,7 +1601,7 @@ class Server {
         } else {
           try {
             clientImplementation = require.resolve(clientTransport);
-          } catch (e) {
+          } catch {
             clientImplementationFound = false;
           }
         }
@@ -1619,7 +1626,7 @@ class Server {
   /**
    * @template T
    * @private
-   * @returns {T}
+   * @returns {T} server transport
    */
   getServerTransport() {
     let implementation;
@@ -1647,12 +1654,11 @@ class Server {
           implementation = require("./servers/WebsocketServer");
         } else {
           try {
-            // eslint-disable-next-line import/no-dynamic-require
             implementation = require(
               /** @type {WebSocketServerConfiguration} */
               (this.options.webSocketServer).type,
             );
-          } catch (error) {
+          } catch {
             implementationFound = false;
           }
         }
@@ -1680,13 +1686,13 @@ class Server {
   /**
    * @returns {string}
    */
-  // eslint-disable-next-line class-methods-use-this
+
   getClientEntry() {
     return require.resolve("../client/index.js");
   }
 
   /**
-   * @returns {string | void}
+   * @returns {string | void} client hot entry
    */
   getClientHotEntry() {
     if (this.options.hot === "only") {
@@ -1702,17 +1708,17 @@ class Server {
    */
   setupProgressPlugin() {
     const { ProgressPlugin } =
-      /** @type {MultiCompiler}*/
+      /** @type {MultiCompiler} */
       (this.compiler).compilers
-        ? /** @type {MultiCompiler}*/ (this.compiler).compilers[0].webpack
-        : /** @type {Compiler}*/ (this.compiler).webpack;
+        ? /** @type {MultiCompiler} */ (this.compiler).compilers[0].webpack
+        : /** @type {Compiler} */ (this.compiler).webpack;
 
     new ProgressPlugin(
       /**
-       * @param {number} percent
-       * @param {string} msg
-       * @param {string} addInfo
-       * @param {string} pluginName
+       * @param {number} percent percent
+       * @param {string} msg message
+       * @param {string} addInfo extra information
+       * @param {string} pluginName plugin name
        */
       (percent, msg, addInfo, pluginName) => {
         percent = Math.floor(percent * 100);
@@ -1757,7 +1763,6 @@ class Server {
 
       for (const compiler of compilers) {
         if (compiler.options.devServer === false) {
-          // eslint-disable-next-line no-continue
           continue;
         }
 
@@ -1771,12 +1776,14 @@ class Server {
 
         if (this.options.hot) {
           const HMRPluginExists = compiler.options.plugins.find(
-            (p) => p && p.constructor === webpack.HotModuleReplacementPlugin,
+            (plugin) =>
+              plugin &&
+              plugin.constructor === webpack.HotModuleReplacementPlugin,
           );
 
           if (HMRPluginExists) {
             this.logger.warn(
-              `"hot: true" automatically applies HMR plugin, you don't have to add it manually to your webpack configuration.`,
+              '"hot: true" automatically applies HMR plugin, you don\'t have to add it manually to your webpack configuration.',
             );
           } else {
             // Apply the HMR plugin
@@ -1804,9 +1811,11 @@ class Server {
 
       let needForceShutdown = false;
 
-      signals.forEach((signal) => {
+      for (const signal of signals) {
+        // eslint-disable-next-line no-loop-func
         const listener = () => {
           if (needForceShutdown) {
+            // eslint-disable-next-line n/no-process-exit
             process.exit();
           }
 
@@ -1819,9 +1828,11 @@ class Server {
           this.stopCallback(() => {
             if (typeof this.compiler.close === "function") {
               this.compiler.close(() => {
+                // eslint-disable-next-line n/no-process-exit
                 process.exit();
               });
             } else {
+              // eslint-disable-next-line n/no-process-exit
               process.exit();
             }
           });
@@ -1830,7 +1841,7 @@ class Server {
         this.listeners.push({ name: signal, listener });
 
         process.on(signal, listener);
-      });
+      }
     }
 
     // Proxy WebSocket without the initial http request
@@ -1854,26 +1865,32 @@ class Server {
    * @returns {Promise<void>}
    */
   async setupApp() {
-    /** @type {A | undefined}*/
+    /** @type {A | undefined} */
     this.app =
-      typeof this.options.app === "function"
-        ? await this.options.app()
-        : getExpress()();
+      /** @type {A} */
+      (
+        typeof this.options.app === "function"
+          ? await this.options.app()
+          : getExpress()()
+      );
   }
 
   /**
    * @private
-   * @param {Stats | MultiStats} statsObj
-   * @returns {StatsCompilation}
+   * @param {Stats | MultiStats} statsObj stats
+   * @returns {StatsCompilation} stats of compilation
    */
   getStats(statsObj) {
     const stats = Server.DEFAULT_STATS;
     const compilerOptions = this.getCompilerOptions();
 
-    // @ts-ignore
-    if (compilerOptions.stats && compilerOptions.stats.warningsFilter) {
-      // @ts-ignore
-      stats.warningsFilter = compilerOptions.stats.warningsFilter;
+    if (
+      compilerOptions.stats &&
+      /** @type {StatsOptions} */ (compilerOptions.stats).warningsFilter
+    ) {
+      stats.warningsFilter =
+        /** @type {StatsOptions} */
+        (compilerOptions.stats).warningsFilter;
     }
 
     return statsObj.toJson(stats);
@@ -1892,7 +1909,7 @@ class Server {
     this.compiler.hooks.done.tap(
       "webpack-dev-server",
       /**
-       * @param {Stats | MultiStats} stats
+       * @param {Stats | MultiStats} stats stats
        */
       (stats) => {
         if (this.webSocketServer) {
@@ -1952,9 +1969,9 @@ class Server {
     middlewares.push({
       name: "host-header-check",
       /**
-       * @param {Request} req
-       * @param {Response} res
-       * @param {NextFunction} next
+       * @param {Request} req request
+       * @param {Response} res response
+       * @param {NextFunction} next next function
        * @returns {void}
        */
       middleware: (req, res, next) => {
@@ -1977,15 +1994,22 @@ class Server {
     middlewares.push({
       name: "cross-origin-header-check",
       /**
-       * @param {Request} req
-       * @param {Response} res
-       * @param {NextFunction} next
+       * @param {Request} req request
+       * @param {Response} res response
+       * @param {NextFunction} next next function
        * @returns {void}
        */
       middleware: (req, res, next) => {
         const headers =
           /** @type {{ [key: string]: string | undefined }} */
           (req.headers);
+        const headerName = headers[":authority"] ? ":authority" : "host";
+
+        if (this.isValidHost(headers, headerName, false)) {
+          next();
+          return;
+        }
+
         if (
           headers["sec-fetch-mode"] === "no-cors" &&
           headers["sec-fetch-site"] === "cross-site"
@@ -2046,9 +2070,9 @@ class Server {
       name: "webpack-dev-server-sockjs-bundle",
       path: "/__webpack_dev_server__/sockjs.bundle.js",
       /**
-       * @param {Request} req
-       * @param {Response} res
-       * @param {NextFunction} next
+       * @param {Request} req request
+       * @param {Response} res response
+       * @param {NextFunction} next next function
        * @returns {void}
        */
       middleware: (req, res, next) => {
@@ -2074,7 +2098,7 @@ class Server {
         try {
           // TODO implement `inputFileSystem.createReadStream` in webpack
           stats = fs.statSync(clientPath);
-        } catch (err) {
+        } catch {
           next();
           return;
         }
@@ -2095,9 +2119,9 @@ class Server {
       name: "webpack-dev-server-invalidate",
       path: "/webpack-dev-server/invalidate",
       /**
-       * @param {Request} req
-       * @param {Response} res
-       * @param {NextFunction} next
+       * @param {Request} req request
+       * @param {Response} res response
+       * @param {NextFunction} next next function
        * @returns {void}
        */
       middleware: (req, res, next) => {
@@ -2116,9 +2140,9 @@ class Server {
       name: "webpack-dev-server-open-editor",
       path: "/webpack-dev-server/open-editor",
       /**
-       * @param {Request} req
-       * @param {Response} res
-       * @param {NextFunction} next
+       * @param {Request} req request
+       * @param {Response} res response
+       * @param {NextFunction} next next function
        * @returns {void}
        */
       middleware: (req, res, next) => {
@@ -2137,7 +2161,6 @@ class Server {
         const fileName = params.get("fileName");
 
         if (typeof fileName === "string") {
-          // @ts-ignore
           const launchEditor = require("launch-editor");
 
           launchEditor(fileName);
@@ -2151,9 +2174,9 @@ class Server {
       name: "webpack-dev-server-assets",
       path: "/webpack-dev-server",
       /**
-       * @param {Request} req
-       * @param {Response} res
-       * @param {NextFunction} next
+       * @param {Request} req request
+       * @param {Response} res response
+       * @param {NextFunction} next next function
        * @returns {void}
        */
       middleware: (req, res, next) => {
@@ -2189,13 +2212,12 @@ class Server {
                 (/** @type {MultiStats} */ (stats).toJson().children)
               : [/** @type {Stats} */ (stats).toJson()];
 
-          res.write(`<h1>Assets Report:</h1>`);
+          res.write("<h1>Assets Report:</h1>");
 
           for (const [index, item] of statsForPrint.entries()) {
             res.write("<div>");
 
             const name =
-              // eslint-disable-next-line no-nested-ternary
               typeof item.name !== "undefined"
                 ? item.name
                 : /** @type {MultiStats} */ (stats).stats
@@ -2235,8 +2257,8 @@ class Server {
       const { createProxyMiddleware } = require("http-proxy-middleware");
 
       /**
-       * @param {ProxyConfigArrayItem} proxyConfig
-       * @returns {RequestHandler | undefined}
+       * @param {ProxyConfigArrayItem} proxyConfig proxy config
+       * @returns {RequestHandler | undefined} request handler
        */
       const getProxyMiddleware = (proxyConfig) => {
         // It is possible to use the `bypass` method without a `target` or `router`.
@@ -2265,6 +2287,7 @@ class Server {
       };
 
       /**
+       * @example
        * Assume a proxy configuration specified as:
        * proxy: [
        *   {
@@ -2280,7 +2303,7 @@ class Server {
        *   }
        * ]
        */
-      this.options.proxy.forEach((proxyConfigOrCallback) => {
+      for (const proxyConfigOrCallback of this.options.proxy) {
         /**
          * @type {RequestHandler}
          */
@@ -2300,9 +2323,9 @@ class Server {
         }
 
         /**
-         * @param {Request} req
-         * @param {Response} res
-         * @param {NextFunction} next
+         * @param {Request} req request
+         * @param {Response} res response
+         * @param {NextFunction} next next function
          * @returns {Promise<void>}
          */
         const handler = async (req, res, next) => {
@@ -2312,9 +2335,9 @@ class Server {
             if (newProxyConfig !== proxyConfig) {
               proxyConfig = newProxyConfig;
 
-              const socket = req.socket != null ? req.socket : req.connection;
-              // @ts-ignore
-              const server = socket != null ? socket.server : null;
+              const socket = req.socket || req.connection;
+              // @ts-expect-error
+              const server = socket ? socket.server : null;
 
               if (server) {
                 server.removeAllListeners("close");
@@ -2372,15 +2395,15 @@ class Server {
           name: "http-proxy-middleware-error-handler",
           middleware:
             /**
-             * @param {Error} error
-             * @param {Request} req
-             * @param {Response} res
-             * @param {NextFunction} next
-             * @returns {any}
+             * @param {Error} error error
+             * @param {Request} req request
+             * @param {Response} res response
+             * @param {NextFunction} next next function
+             * @returns {Promise<void>} nothing
              */
             (error, req, res, next) => handler(req, res, next),
         });
-      });
+      }
 
       middlewares.push({
         name: "webpack-dev-middleware",
@@ -2409,6 +2432,7 @@ class Server {
 
     if (this.options.historyApiFallback) {
       const connectHistoryApiFallback = require("connect-history-api-fallback");
+
       const { historyApiFallback } = this.options;
 
       if (
@@ -2421,7 +2445,7 @@ class Server {
           (historyApiFallback).verbose
         )
       ) {
-        // @ts-ignore
+        // @ts-expect-error
         historyApiFallback.logger = this.logger.log.bind(
           this.logger,
           "[connect-history-api-fallback]",
@@ -2470,9 +2494,9 @@ class Server {
               name: "serve-index",
               path: publicPath,
               /**
-               * @param {Request} req
-               * @param {Response} res
-               * @param {NextFunction} next
+               * @param {Request} req request
+               * @param {Response} res response
+               * @param {NextFunction} next next function
                * @returns {void}
                */
               middleware: (req, res, next) => {
@@ -2498,9 +2522,9 @@ class Server {
     middlewares.push({
       name: "options-middleware",
       /**
-       * @param {Request} req
-       * @param {Response} res
-       * @param {NextFunction} next
+       * @param {Request} req request
+       * @param {Response} res response
+       * @param {NextFunction} next next function
        * @returns {void}
        */
       middleware: (req, res, next) => {
@@ -2578,7 +2602,7 @@ class Server {
       (this.options.server);
 
     if (typeof type === "function") {
-      /** @type {S | undefined}*/
+      /** @type {S | undefined} */
       this.server = await type(
         /** @type {ServerOptions} */
         (options),
@@ -2586,10 +2610,9 @@ class Server {
         (this.app),
       );
     } else {
-      // eslint-disable-next-line import/no-dynamic-require
       const serverType = require(/** @type {string} */ (type));
 
-      /** @type {S | undefined}*/
+      /** @type {S | undefined} */
       this.server =
         type === "http2"
           ? serverType.createSecureServer(
@@ -2608,7 +2631,7 @@ class Server {
     (this.server).on(
       "connection",
       /**
-       * @param {Socket} socket
+       * @param {Socket} socket connected socket
        */
       (socket) => {
         // Add socket to list
@@ -2625,7 +2648,7 @@ class Server {
     (this.server).on(
       "error",
       /**
-       * @param {Error} error
+       * @param {Error} error error
        */
       (error) => {
         throw error;
@@ -2645,13 +2668,12 @@ class Server {
     (this.webSocketServer).implementation.on(
       "connection",
       /**
-       * @param {ClientConnection} client
-       * @param {IncomingMessage} request
+       * @param {ClientConnection} client client
+       * @param {IncomingMessage} request request
        */
       (client, request) => {
         /** @type {{ [key: string]: string | undefined } | undefined} */
         const headers =
-          // eslint-disable-next-line no-nested-ternary
           typeof request !== "undefined"
             ? /** @type {{ [key: string]: string | undefined }} */
               (request.headers)
@@ -2659,8 +2681,7 @@ class Server {
                   /** @type {import("sockjs").Connection} */ (client).headers
                 ) !== "undefined"
               ? /** @type {import("sockjs").Connection} */ (client).headers
-              : // eslint-disable-next-line no-undefined
-                undefined;
+              : undefined;
 
         if (!headers) {
           this.logger.warn(
@@ -2757,7 +2778,7 @@ class Server {
 
   /**
    * @private
-   * @param {string} defaultOpenTarget
+   * @param {string} defaultOpenTarget default open target
    * @returns {Promise<void>}
    */
   async openBrowser(defaultOpenTarget) {
@@ -2809,6 +2830,7 @@ class Server {
    */
   runBonjour() {
     const { Bonjour } = require("bonjour-service");
+
     const type = this.isTlsServer ? "https" : "http";
 
     /**
@@ -2827,6 +2849,7 @@ class Server {
 
   /**
    * @private
+   * @param {() => void} callback callback
    * @returns {void}
    */
   stopBonjour(callback = () => {}) {
@@ -2846,11 +2869,11 @@ class Server {
    * @returns {Promise<void>}
    */
   async logStatus() {
-    const { isColorSupported, cyan, red } = require("colorette");
+    const { cyan, isColorSupported, red } = require("colorette");
 
     /**
-     * @param {Compiler["options"]} compilerOptions
-     * @returns {boolean}
+     * @param {Compiler["options"]} compilerOptions compiler options
+     * @returns {boolean} value of the color option
      */
     const getColorsOption = (compilerOptions) => {
       /**
@@ -2875,9 +2898,9 @@ class Server {
 
     const colors = {
       /**
-       * @param {boolean} useColor
-       * @param {string} msg
-       * @returns {string}
+       * @param {boolean} useColor need to use color?
+       * @param {string} msg message
+       * @returns {string} message with color
        */
       info(useColor, msg) {
         if (useColor) {
@@ -2887,9 +2910,9 @@ class Server {
         return msg;
       },
       /**
-       * @param {boolean} useColor
-       * @param {string} msg
-       * @returns {string}
+       * @param {boolean} useColor need to use color?
+       * @param {string} msg message
+       * @returns {string} message with colors
        */
       error(useColor, msg) {
         if (useColor) {
@@ -2911,8 +2934,8 @@ class Server {
         /** @type {import("net").AddressInfo} */
         (server.address());
       /**
-       * @param {string} newHostname
-       * @returns {string}
+       * @param {string} newHostname new hostname
+       * @returns {string} prettified URL
        */
       const prettyPrintURL = (newHostname) =>
         url.format({ protocol, hostname: newHostname, port, pathname: "/" });
@@ -2932,7 +2955,7 @@ class Server {
 
           try {
             isIP = ipaddr.parse(this.options.host);
-          } catch (error) {
+          } catch {
             // Ignore
           }
 
@@ -3066,9 +3089,9 @@ class Server {
 
   /**
    * @private
-   * @param {Request} req
-   * @param {Response} res
-   * @param {NextFunction} next
+   * @param {Request} req request
+   * @param {Response} res response
+   * @param {NextFunction} next next function
    */
   setHeaders(req, res, next) {
     let { headers } = this.options;
@@ -3078,23 +3101,22 @@ class Server {
         headers = headers(
           req,
           res,
-          // eslint-disable-next-line no-undefined
+
           this.middleware ? this.middleware.context : undefined,
         );
       }
 
       /**
-       * @type {{key: string, value: string}[]}
+       * @type {{ key: string, value: string }[]}
        */
       const allHeaders = [];
 
-      allHeaders.push({ key: "X_TEST", value: "TEST" });
-
       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] });
+          allHeaders.push({
+            key: name,
+            value: /** @type {string} */ (headers[name]),
+          });
         }
 
         headers = allHeaders;
@@ -3110,8 +3132,8 @@ class Server {
 
   /**
    * @private
-   * @param {string} value
-   * @returns {boolean}
+   * @param {string} value value
+   * @returns {boolean} true when host allowed, otherwise false
    */
   isHostAllowed(value) {
     const { allowedHosts } = this.options;
@@ -3125,26 +3147,21 @@ class Server {
     // always allow localhost host, for convenience
     // allow if value is in allowedHosts
     if (Array.isArray(allowedHosts) && allowedHosts.length > 0) {
-      for (let hostIdx = 0; hostIdx < allowedHosts.length; hostIdx++) {
-        /** @type {string} */
-        const allowedHost = allowedHosts[hostIdx];
-
+      for (const allowedHost of allowedHosts) {
         if (allowedHost === value) {
           return true;
         }
 
         // support "." as a subdomain wildcard
         // e.g. ".example.com" will allow "example.com", "www.example.com", "subdomain.example.com", etc
-        if (allowedHost[0] === ".") {
-          // "example.com"  (value === allowedHost.substring(1))
+        if (
+          allowedHost.startsWith(".") && // "example.com"  (value === allowedHost.substring(1))
           // "*.example.com"  (value.endsWith(allowedHost))
-          if (
-            value === allowedHost.substring(1) ||
+          (value === allowedHost.slice(1) ||
             /** @type {string} */
-            (value).endsWith(allowedHost)
-          ) {
-            return true;
-          }
+            (value).endsWith(allowedHost))
+        ) {
+          return true;
         }
       }
     }
@@ -3169,11 +3186,12 @@ class Server {
 
   /**
    * @private
-   * @param {{ [key: string]: string | undefined }} headers
-   * @param {string} headerToCheck
-   * @returns {boolean}
+   * @param {{ [key: string]: string | undefined }} headers headers
+   * @param {string} headerToCheck header to check
+   * @param {boolean} validateHost need to validate host
+   * @returns {boolean} true when host is valid, otherwise false
    */
-  isValidHost(headers, headerToCheck) {
+  isValidHost(headers, headerToCheck, validateHost = true) {
     if (this.options.allowedHosts === "all") {
       return true;
     }
@@ -3191,12 +3209,14 @@ class Server {
     }
 
     // use the node url-parser to retrieve the hostname from the host-header.
-    const hostname = url.parse(
+    // TODO resolve me in the next major release
+    // eslint-disable-next-line n/no-deprecated-api
+    const { hostname } = url.parse(
       // if header doesn't have scheme, add // for parsing.
       /^(.+:)?\/\//.test(header) ? header : `//${header}`,
       false,
       true,
-    ).hostname;
+    );
 
     if (hostname === null) {
       return false;
@@ -3215,25 +3235,21 @@ class Server {
     // For convenience, always allow localhost (hostname === 'localhost')
     // and its subdomains (hostname.endsWith(".localhost")).
     // allow hostname of listening address  (hostname === this.options.host)
-    const isValidHostname =
-      ipaddr.IPv4.isValid(hostname) ||
-      ipaddr.IPv6.isValid(hostname) ||
-      hostname === "localhost" ||
-      hostname.endsWith(".localhost") ||
-      hostname === this.options.host;
-
-    if (isValidHostname) {
-      return true;
-    }
-
-    // disallow
-    return false;
+    const isValidHostname = validateHost
+      ? ipaddr.IPv4.isValid(hostname) ||
+        ipaddr.IPv6.isValid(hostname) ||
+        hostname === "localhost" ||
+        hostname.endsWith(".localhost") ||
+        hostname === this.options.host
+      : false;
+
+    return isValidHostname;
   }
 
   /**
    * @private
-   * @param {{ [key: string]: string | undefined }} headers
-   * @returns {boolean}
+   * @param {{ [key: string]: string | undefined }} headers headers
+   * @returns {boolean} true when is same origin, otherwise false
    */
   isSameOrigin(headers) {
     if (this.options.allowedHosts === "all") {
@@ -3250,6 +3266,8 @@ class Server {
       return true;
     }
 
+    // TODO resolve me in the next major release
+    // eslint-disable-next-line n/no-deprecated-api
     const origin = url.parse(originHeader, false, true).hostname;
 
     if (origin === null) {
@@ -3270,6 +3288,7 @@ class Server {
       return true;
     }
 
+    // eslint-disable-next-line n/no-deprecated-api
     const host = url.parse(
       // if hostHeader doesn't have scheme, add // for parsing.
       /^(.+:)?\/\//.test(hostHeader) ? hostHeader : `//${hostHeader}`,
@@ -3289,12 +3308,11 @@ class Server {
   }
 
   /**
-   * @param {ClientConnection[]} clients
-   * @param {string} type
-   * @param {any} [data]
-   * @param {any} [params]
+   * @param {ClientConnection[]} clients clients
+   * @param {string} type type
+   * @param {EXPECTED_ANY=} data data
+   * @param {EXPECTED_ANY=} params params
    */
-  // eslint-disable-next-line class-methods-use-this
   sendMessage(clients, type, data, params) {
     for (const client of clients) {
       // `sockjs` uses `1` to indicate client is ready to accept data
@@ -3308,9 +3326,9 @@ class Server {
   // Send stats to a socket or multiple sockets
   /**
    * @private
-   * @param {ClientConnection[]} clients
-   * @param {StatsCompilation} stats
-   * @param {boolean} [force]
+   * @param {ClientConnection[]} clients clients
+   * @param {StatsCompilation} stats stats
+   * @param {boolean=} force force
    */
   sendStats(clients, stats, force) {
     const shouldEmit =
@@ -3364,11 +3382,12 @@ class Server {
   }
 
   /**
-   * @param {string | string[]} watchPath
-   * @param {WatchOptions} [watchOptions]
+   * @param {string | string[]} watchPath watch path
+   * @param {WatchOptions=} watchOptions watch options
    */
   watchFiles(watchPath, watchOptions) {
     const chokidar = require("chokidar");
+
     const watcher = chokidar.watch(watchPath, watchOptions);
 
     // disabling refreshing on changing the content
@@ -3388,7 +3407,7 @@ class Server {
   }
 
   /**
-   * @param {import("webpack-dev-middleware").Callback} [callback]
+   * @param {import("webpack-dev-middleware").Callback=} callback callback
    */
   invalidate(callback = () => {}) {
     if (this.middleware) {
@@ -3405,13 +3424,14 @@ class Server {
     if (this.options.ipc) {
       await /** @type {Promise<void>} */ (
         new Promise((resolve, reject) => {
-          const net = require("net");
+          const net = require("node:net");
+
           const socket = new net.Socket();
 
           socket.on(
             "error",
             /**
-             * @param {Error & { code?: string }} error
+             * @param {Error & { code?: string }} error error
              */
             (error) => {
               if (error.code === "ECONNREFUSED") {
@@ -3490,7 +3510,7 @@ class Server {
   }
 
   /**
-   * @param {(err?: Error) => void} [callback]
+   * @param {((err?: Error) => void)=} callback callback
    */
   startCallback(callback = () => {}) {
     this.start()
@@ -3545,7 +3565,6 @@ class Server {
         new Promise((resolve) => {
           /** @type {S} */
           (this.server).close(() => {
-            // eslint-disable-next-line no-undefined
             this.server = undefined;
             resolve();
           });
@@ -3561,7 +3580,7 @@ class Server {
       if (this.middleware) {
         await /** @type {Promise<void>} */ (
           new Promise((resolve, reject) => {
-            /** @type {import("webpack-dev-middleware").API<Request, Response>}*/
+            /** @type {import("webpack-dev-middleware").API<Request, Response>} */
             (this.middleware).close((error) => {
               if (error) {
                 reject(error);
@@ -3573,7 +3592,6 @@ class Server {
           })
         );
 
-        // eslint-disable-next-line no-undefined
         this.middleware = undefined;
       }
     }
@@ -3586,7 +3604,7 @@ class Server {
   }
 
   /**
-   * @param {(err?: Error) => void} [callback]
+   * @param {((err?: Error) => void)=} callback callback
    */
   stopCallback(callback = () => {}) {
     this.stop()