@rspack/dev-server 2.0.0-beta.5 → 2.0.0-beta.6

package/dist/131.js

@@ -1,1474 +0,0 @@
-import * as __rspack_external_zlib from "zlib";
-import { __webpack_require__ } from "./rslib-runtime.js";
-import node_fs, { lstatSync, promises, readFileSync, realpathSync, statSync, unlinkSync } from "node:fs";
-import { createRequire } from "node:module";
-import node_os, { networkInterfaces, tmpdir } from "node:os";
-import node_path, { dirname, join, resolve as external_node_path_resolve } from "node:path";
-import { fileURLToPath, format } from "node:url";
-import { deprecate, promisify, styleText } from "node:util";
-import ipaddr from "ipaddr.js";
-import { createServer } from "node:net";
-import { WebSocketServer } from "ws";
-__webpack_require__.add({
-    "./node_modules/.pnpm/http-compression@1.1.2/node_modules/http-compression/src/index.js" (module, __unused_rspack_exports, __webpack_require__) {
-        const zlib = __webpack_require__("zlib");
-        const MIMES = /text|javascript|\/json|xml/i;
-        const noop = ()=>{};
-        const getChunkSize = (chunk, enc)=>chunk ? Buffer.byteLength(chunk, enc) : 0;
-        module.exports = ({ threshold = 1024, level = {
-            brotli: 0,
-            gzip: 1
-        }, brotli = true, gzip = true, mimes = MIMES } = {})=>{
-            const brotliOpts = 'object' == typeof brotli && brotli || {};
-            const gzipOpts = 'object' == typeof gzip && gzip || {};
-            if (brotli && !zlib.createBrotliCompress) brotli = false;
-            return (req, res, next = noop)=>{
-                const accept = req.headers['accept-encoding'];
-                const encoding = accept && (brotli && accept.match(/\bbr\b/) || gzip && accept.match(/\bgzip\b/) || [])[0];
-                if ('HEAD' === req.method || !encoding) return next();
-                let compress;
-                let pendingStatus;
-                let pendingListeners = [];
-                let started = false;
-                let size = 0;
-                function start() {
-                    started = true;
-                    size = 0 | res.getHeader('Content-Length') || size;
-                    const compressible = mimes.test(String(res.getHeader('Content-Type') || 'text/plain'));
-                    const cleartext = !res.getHeader('Content-Encoding');
-                    const listeners = pendingListeners || [];
-                    if (compressible && cleartext && size >= threshold) {
-                        res.setHeader('Content-Encoding', encoding);
-                        res.removeHeader('Content-Length');
-                        compress = 'br' === encoding ? zlib.createBrotliCompress({
-                            params: Object.assign({
-                                [zlib.constants.BROTLI_PARAM_QUALITY]: level.brotli,
-                                [zlib.constants.BROTLI_PARAM_SIZE_HINT]: size
-                            }, brotliOpts)
-                        }) : zlib.createGzip(Object.assign({
-                            level: level.gzip
-                        }, gzipOpts));
-                        compress.on('data', (chunk)=>false === write.call(res, chunk) && compress.pause());
-                        on.call(res, 'drain', ()=>compress.resume());
-                        compress.on('end', ()=>end.call(res));
-                        listeners.forEach((p)=>compress.on.apply(compress, p));
-                    } else {
-                        pendingListeners = null;
-                        listeners.forEach((p)=>on.apply(res, p));
-                    }
-                    writeHead.call(res, pendingStatus || res.statusCode);
-                }
-                const { end, write, on, writeHead } = res;
-                res.writeHead = function(status, reason, headers) {
-                    if ('string' != typeof reason) [headers, reason] = [
-                        reason,
-                        headers
-                    ];
-                    if (headers) for(const i in headers)res.setHeader(i, headers[i]);
-                    pendingStatus = status;
-                    return this;
-                };
-                res.write = function(chunk, enc) {
-                    size += getChunkSize(chunk, enc);
-                    if (!started) start();
-                    if (!compress) return write.apply(this, arguments);
-                    return compress.write.apply(compress, arguments);
-                };
-                res.end = function(chunk, enc) {
-                    if (arguments.length > 0 && 'function' != typeof chunk) size += getChunkSize(chunk, enc);
-                    if (!started) start();
-                    if (!compress) return end.apply(this, arguments);
-                    return compress.end.apply(compress, arguments);
-                };
-                res.on = function(type, listener) {
-                    if (pendingListeners && 'drain' === type) if (compress) compress.on(type, listener);
-                    else pendingListeners.push([
-                        type,
-                        listener
-                    ]);
-                    else on.call(this, type, listener);
-                    return this;
-                };
-                next();
-            };
-        };
-    },
-    zlib (module) {
-        module.exports = __rspack_external_zlib;
-    }
-});
-var external_node_util_namespaceObject = {};
-__webpack_require__.r(external_node_util_namespaceObject);
-__webpack_require__.d(external_node_util_namespaceObject, {
-    deprecate: ()=>deprecate,
-    promisify: ()=>promisify,
-    styleText: ()=>styleText
-});
-const minPort = 1024;
-const maxPort = 65535;
-const getLocalHosts = ()=>{
-    const interfaces = networkInterfaces();
-    const results = new Set([
-        void 0,
-        '0.0.0.0'
-    ]);
-    for (const _interface of Object.values(interfaces))if (_interface) for (const config of _interface)results.add(config.address);
-    return results;
-};
-const checkAvailablePort = (basePort, host)=>new Promise((resolve, reject)=>{
-        const server = createServer();
-        server.unref();
-        server.on('error', reject);
-        server.listen(basePort, host, ()=>{
-            const { port } = server.address();
-            server.close(()=>{
-                resolve(port);
-            });
-        });
-    });
-const getAvailablePort = async (port, hosts)=>{
-    const nonExistentInterfaceErrors = new Set([
-        'EADDRNOTAVAIL',
-        'EINVAL'
-    ]);
-    for (const host of hosts)try {
-        await checkAvailablePort(port, host);
-    } catch (error) {
-        if (!nonExistentInterfaceErrors.has(error.code || '')) throw error;
-    }
-    return port;
-};
-async function getPort(basePort, host) {
-    if (basePort < minPort || basePort > maxPort) throw new Error(`Port number must lie between ${minPort} and ${maxPort}`);
-    let port = basePort;
-    const localhosts = getLocalHosts();
-    const hosts = host && !localhosts.has(host) ? new Set([
-        host
-    ]) : localhosts;
-    const portUnavailableErrors = new Set([
-        'EADDRINUSE',
-        'EACCES'
-    ]);
-    while(port <= maxPort)try {
-        const availablePort = await getAvailablePort(port, hosts);
-        return availablePort;
-    } catch (error) {
-        if (!portUnavailableErrors.has(error.code || '')) throw error;
-        port += 1;
-    }
-    throw new Error('No available ports found');
-}
-class BaseServer {
-    server;
-    clients;
-    constructor(server){
-        this.server = server;
-        this.clients = [];
-    }
-}
-const servers_BaseServer = BaseServer;
-class WebsocketServer extends servers_BaseServer {
-    static heartbeatInterval = 1000;
-    implementation;
-    constructor(server){
-        super(server);
-        const options = {
-            ...this.server.options.webSocketServer.options,
-            clientTracking: false
-        };
-        const isNoServerMode = void 0 === options.port && void 0 === options.server;
-        if (isNoServerMode) options.noServer = true;
-        this.implementation = new WebSocketServer(options);
-        this.server.server.on('upgrade', (req, sock, head)=>{
-            if (!this.implementation.shouldHandle(req)) return;
-            this.implementation.handleUpgrade(req, sock, head, (connection)=>{
-                this.implementation.emit('connection', connection, req);
-            });
-        });
-        this.implementation.on('error', (err)=>{
-            this.server.logger.error(err.message);
-        });
-        const interval = setInterval(()=>{
-            for (const client of this.clients){
-                if (false === client.isAlive) {
-                    client.terminate();
-                    continue;
-                }
-                client.isAlive = false;
-                client.ping(()=>{});
-            }
-        }, WebsocketServer.heartbeatInterval);
-        this.implementation.on('connection', (client)=>{
-            this.clients.push(client);
-            client.isAlive = true;
-            client.on('pong', ()=>{
-                client.isAlive = true;
-            });
-            client.on('close', ()=>{
-                this.clients.splice(this.clients.indexOf(client), 1);
-            });
-            client.on('error', (err)=>{
-                this.server.logger.error(err.message);
-            });
-        });
-        this.implementation.on('close', ()=>{
-            clearInterval(interval);
-        });
-    }
-}
-const src = __webpack_require__("./node_modules/.pnpm/http-compression@1.1.2/node_modules/http-compression/src/index.js");
-var src_default = /*#__PURE__*/ __webpack_require__.n(src);
-const { styleText: server_styleText } = external_node_util_namespaceObject;
-const server_require = createRequire(import.meta.url);
-if (!process.env.WEBPACK_SERVE) process.env.WEBPACK_SERVE = 'true';
-const memoize = (fn)=>{
-    let cache = false;
-    let result;
-    let fnRef = fn;
-    return ()=>{
-        if (cache) return result;
-        result = fnRef();
-        cache = true;
-        fnRef = void 0;
-        return result;
-    };
-};
-const getConnect = async ()=>{
-    const { connect } = await import("connect-next");
-    return connect;
-};
-const getChokidar = memoize(()=>import("chokidar"));
-const getServeStatic = memoize(()=>server_require('serve-static'));
-const encodeOverlaySettings = (setting)=>'function' == typeof setting ? encodeURIComponent(setting.toString()) : setting;
-const DEFAULT_ALLOWED_PROTOCOLS = /^(file|.+-extension):/i;
-function parseHostnameFromHeader(header) {
-    try {
-        const parsedUrl = new URL(/^(.+:)?\/\//.test(header) ? header : `//${header}`, 'http://localhost/');
-        let { hostname } = parsedUrl;
-        if (hostname.startsWith('[') && hostname.endsWith(']')) hostname = hostname.slice(1, -1);
-        return hostname;
-    } catch  {
-        return null;
-    }
-}
-function isMultiCompiler(compiler) {
-    return Array.isArray(compiler.compilers);
-}
-class Server {
-    compiler;
-    logger;
-    options;
-    staticWatchers;
-    listeners;
-    webSocketProxies;
-    sockets;
-    currentHash;
-    isTlsServer = false;
-    webSocketServer;
-    middleware;
-    server;
-    app;
-    stats;
-    constructor(options, compiler){
-        this.compiler = compiler;
-        this.logger = this.compiler.getInfrastructureLogger('rspack-dev-server');
-        this.options = options;
-        this.staticWatchers = [];
-        this.listeners = [];
-        this.webSocketProxies = [];
-        this.sockets = [];
-        this.currentHash = void 0;
-    }
-    static get DEFAULT_STATS() {
-        return {
-            all: false,
-            hash: true,
-            warnings: true,
-            errors: true,
-            errorDetails: false
-        };
-    }
-    static isAbsoluteURL(URL1) {
-        if (/^[a-zA-Z]:\\/.test(URL1)) return false;
-        return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(URL1);
-    }
-    static findIp(gatewayOrFamily, isInternal) {
-        if ('v4' === gatewayOrFamily || 'v6' === gatewayOrFamily) {
-            let host;
-            const networks = Object.values(networkInterfaces()).flatMap((networks)=>networks ?? []).filter((network)=>{
-                if (!network || !network.address) return false;
-                if (network.family !== `IP${gatewayOrFamily}`) return false;
-                if (void 0 !== isInternal && network.internal !== isInternal) return false;
-                if ('v6' === gatewayOrFamily) {
-                    const range = ipaddr.parse(network.address).range();
-                    if ('ipv4Mapped' !== range && 'uniqueLocal' !== range && 'loopback' !== range) return false;
-                }
-                return network.address;
-            });
-            if (networks.length > 0) {
-                host = networks[0].address;
-                if (host.includes(':')) host = `[${host}]`;
-            }
-            return host;
-        }
-        const gatewayIp = ipaddr.parse(gatewayOrFamily);
-        for (const addresses of Object.values(networkInterfaces()))for (const { cidr } of addresses){
-            const net = ipaddr.parseCIDR(cidr);
-            if (net[0] && net[0].kind() === gatewayIp.kind() && gatewayIp.match(net)) return net[0].toString();
-        }
-    }
-    static async getHostname(hostname) {
-        if ('local-ip' === hostname) return Server.findIp('v4', false) || Server.findIp('v6', false) || '0.0.0.0';
-        if ('local-ipv4' === hostname) return Server.findIp('v4', false) || '0.0.0.0';
-        if ('local-ipv6' === hostname) return Server.findIp('v6', false) || '::';
-        return hostname;
-    }
-    static async getFreePort(port, host) {
-        if (null != port && 'auto' !== port) return port;
-        const { default: pRetry } = await import("./0~p-retry.js").then((mod)=>({
-                default: mod.pRetry
-            }));
-        const basePort = void 0 !== process.env.RSPACK_DEV_SERVER_BASE_PORT ? Number.parseInt(process.env.RSPACK_DEV_SERVER_BASE_PORT, 10) : 8080;
-        const defaultPortRetry = void 0 !== process.env.RSPACK_DEV_SERVER_PORT_RETRY ? Number.parseInt(process.env.RSPACK_DEV_SERVER_PORT_RETRY, 10) : 3;
-        return pRetry(()=>getPort(basePort, host), {
-            retries: defaultPortRetry
-        });
-    }
-    static findCacheDir() {
-        const cwd = process.cwd();
-        let dir = cwd;
-        for(;;){
-            try {
-                if (statSync(join(dir, 'package.json')).isFile()) break;
-            } catch  {}
-            const parent = dirname(dir);
-            if (dir === parent) {
-                dir = void 0;
-                break;
-            }
-            dir = parent;
-        }
-        if (!dir) return external_node_path_resolve(cwd, '.cache/rspack-dev-server');
-        if ('1' === process.versions.pnp) return external_node_path_resolve(dir, '.pnp/.cache/rspack-dev-server');
-        if ('3' === process.versions.pnp) return external_node_path_resolve(dir, '.yarn/.cache/rspack-dev-server');
-        return external_node_path_resolve(dir, 'node_modules/.cache/rspack-dev-server');
-    }
-    #addAdditionalEntries(compiler) {
-        const additionalEntries = [];
-        const isWebTarget = Boolean(compiler.platform.web);
-        if (this.options.client && isWebTarget) {
-            let webSocketURLStr = '';
-            if (this.options.webSocketServer) {
-                const webSocketURL = this.options.client.webSocketURL;
-                const webSocketServer = this.options.webSocketServer;
-                const searchParams = new URLSearchParams();
-                let protocol;
-                protocol = void 0 !== webSocketURL.protocol ? webSocketURL.protocol : this.isTlsServer ? 'wss:' : 'ws:';
-                searchParams.set('protocol', protocol);
-                if (void 0 !== webSocketURL.username) searchParams.set('username', webSocketURL.username);
-                if (void 0 !== webSocketURL.password) searchParams.set('password', webSocketURL.password);
-                let hostname;
-                const isWebSocketServerHostDefined = void 0 !== webSocketServer.options.host;
-                const isWebSocketServerPortDefined = void 0 !== webSocketServer.options.port;
-                hostname = void 0 !== webSocketURL.hostname ? webSocketURL.hostname : isWebSocketServerHostDefined ? webSocketServer.options.host : void 0 !== this.options.host ? this.options.host : '0.0.0.0';
-                searchParams.set('hostname', hostname);
-                let port;
-                port = void 0 !== webSocketURL.port ? webSocketURL.port : isWebSocketServerPortDefined ? webSocketServer.options.port : 'number' == typeof this.options.port ? this.options.port : 'string' == typeof this.options.port && 'auto' !== this.options.port ? Number(this.options.port) : '0';
-                searchParams.set('port', String(port));
-                let pathname = '';
-                if (void 0 !== webSocketURL.pathname) pathname = webSocketURL.pathname;
-                else if (void 0 !== webSocketServer.options.path) pathname = webSocketServer.options.path;
-                searchParams.set('pathname', pathname);
-                const client = this.options.client;
-                if (void 0 !== client.logging) searchParams.set('logging', client.logging);
-                if (void 0 !== client.progress) searchParams.set('progress', String(client.progress));
-                if (void 0 !== client.overlay) {
-                    const overlayString = 'boolean' == typeof client.overlay ? String(client.overlay) : JSON.stringify({
-                        ...client.overlay,
-                        errors: encodeOverlaySettings(client.overlay.errors),
-                        warnings: encodeOverlaySettings(client.overlay.warnings),
-                        runtimeErrors: encodeOverlaySettings(client.overlay.runtimeErrors)
-                    });
-                    searchParams.set('overlay', overlayString);
-                }
-                if (void 0 !== client.reconnect) searchParams.set('reconnect', 'number' == typeof client.reconnect ? String(client.reconnect) : '10');
-                if (void 0 !== this.options.hot) searchParams.set('hot', String(this.options.hot));
-                if (void 0 !== this.options.liveReload) searchParams.set('live-reload', String(this.options.liveReload));
-                webSocketURLStr = searchParams.toString();
-            }
-            additionalEntries.push(`${this.getClientEntry()}?${webSocketURLStr}`);
-        }
-        const clientHotEntry = this.getClientHotEntry();
-        if (clientHotEntry) additionalEntries.push(clientHotEntry);
-        for (const additionalEntry of additionalEntries)new compiler.rspack.EntryPlugin(compiler.context, additionalEntry, {
-            name: void 0
-        }).apply(compiler);
-    }
-    #getCompilerOptions() {
-        if (void 0 !== this.compiler.compilers) {
-            if (1 === this.compiler.compilers.length) return this.compiler.compilers[0].options;
-            const compilerWithDevServer = this.compiler.compilers.find((config)=>config.options.devServer);
-            if (compilerWithDevServer) return compilerWithDevServer.options;
-            const compilerWithWebTarget = this.compiler.compilers.find((compiler)=>Boolean(compiler.platform.web));
-            if (compilerWithWebTarget) return compilerWithWebTarget.options;
-            return this.compiler.compilers[0].options;
-        }
-        return this.compiler.options;
-    }
-    #shouldLogInfrastructureInfo() {
-        const compilerOptions = this.#getCompilerOptions();
-        const { level = 'info' } = compilerOptions.infrastructureLogging || {};
-        return 'info' === level || 'log' === level || 'verbose' === level;
-    }
-    async #normalizeOptions() {
-        const { options } = this;
-        const compilerOptions = this.#getCompilerOptions();
-        const compilerWatchOptions = compilerOptions.watchOptions;
-        const getWatchOptions = (watchOptions = {})=>{
-            const getPolling = ()=>{
-                if (void 0 !== watchOptions.usePolling) return watchOptions.usePolling;
-                if (void 0 !== watchOptions.poll) return Boolean(watchOptions.poll);
-                if (void 0 !== compilerWatchOptions.poll) return Boolean(compilerWatchOptions.poll);
-                return false;
-            };
-            const getInterval = ()=>{
-                if (void 0 !== watchOptions.interval) return watchOptions.interval;
-                if ('number' == typeof watchOptions.poll) return watchOptions.poll;
-                if ('number' == typeof compilerWatchOptions.poll) return compilerWatchOptions.poll;
-            };
-            const usePolling = getPolling();
-            const interval = getInterval();
-            const { poll: _poll, ...rest } = watchOptions;
-            return {
-                ignoreInitial: true,
-                persistent: true,
-                followSymlinks: false,
-                atomic: false,
-                alwaysStat: true,
-                ignorePermissionErrors: true,
-                usePolling,
-                ...void 0 !== interval ? {
-                    interval
-                } : {},
-                ...rest
-            };
-        };
-        const getStaticItem = (optionsForStatic)=>{
-            const getDefaultStaticOptions = ()=>({
-                    directory: join(process.cwd(), 'public'),
-                    staticOptions: {},
-                    publicPath: [
-                        '/'
-                    ],
-                    watch: getWatchOptions()
-                });
-            let item;
-            if (void 0 === optionsForStatic) item = getDefaultStaticOptions();
-            else if ('string' == typeof optionsForStatic) item = {
-                ...getDefaultStaticOptions(),
-                directory: optionsForStatic
-            };
-            else {
-                const def = getDefaultStaticOptions();
-                item = {
-                    directory: void 0 !== optionsForStatic.directory ? optionsForStatic.directory : def.directory,
-                    staticOptions: void 0 !== optionsForStatic.staticOptions ? {
-                        ...def.staticOptions,
-                        ...optionsForStatic.staticOptions
-                    } : def.staticOptions,
-                    publicPath: void 0 !== optionsForStatic.publicPath ? Array.isArray(optionsForStatic.publicPath) ? optionsForStatic.publicPath : [
-                        optionsForStatic.publicPath
-                    ] : def.publicPath,
-                    watch: void 0 !== optionsForStatic.watch ? 'boolean' == typeof optionsForStatic.watch ? optionsForStatic.watch ? def.watch : false : getWatchOptions(optionsForStatic.watch) : def.watch
-                };
-            }
-            if (Server.isAbsoluteURL(item.directory)) throw new Error('Using a URL as static.directory is not supported');
-            return item;
-        };
-        if (void 0 === options.allowedHosts) options.allowedHosts = 'auto';
-        else if ('string' == typeof options.allowedHosts && 'auto' !== options.allowedHosts && 'all' !== options.allowedHosts) options.allowedHosts = [
-            options.allowedHosts
-        ];
-        else if (Array.isArray(options.allowedHosts) && options.allowedHosts.includes('all')) options.allowedHosts = 'all';
-        if (void 0 === options.client || 'object' == typeof options.client && null !== options.client) {
-            if (!options.client) options.client = {};
-            if (void 0 === options.client.webSocketURL) options.client.webSocketURL = {};
-            else if ('string' == typeof options.client.webSocketURL) {
-                const parsedURL = new URL(options.client.webSocketURL);
-                options.client.webSocketURL = {
-                    protocol: parsedURL.protocol,
-                    hostname: parsedURL.hostname,
-                    port: parsedURL.port.length > 0 ? Number(parsedURL.port) : '',
-                    pathname: parsedURL.pathname,
-                    username: parsedURL.username,
-                    password: parsedURL.password
-                };
-            } else if ('string' == typeof options.client.webSocketURL.port) options.client.webSocketURL.port = Number(options.client.webSocketURL.port);
-            if (void 0 === options.client.overlay) options.client.overlay = true;
-            else if ('boolean' != typeof options.client.overlay) options.client.overlay = {
-                errors: true,
-                warnings: true,
-                ...options.client.overlay
-            };
-            if (void 0 === options.client.reconnect) options.client.reconnect = 10;
-            else if (true === options.client.reconnect) options.client.reconnect = 1 / 0;
-            else if (false === options.client.reconnect) options.client.reconnect = 0;
-            if (void 0 === options.client.logging) options.client.logging = compilerOptions.infrastructureLogging ? compilerOptions.infrastructureLogging.level : 'info';
-        }
-        if (void 0 === options.compress) options.compress = true;
-        if (void 0 === options.devMiddleware) options.devMiddleware = {};
-        if (void 0 === options.historyApiFallback) options.historyApiFallback = false;
-        else if ('boolean' == typeof options.historyApiFallback && options.historyApiFallback) options.historyApiFallback = {};
-        options.hot = 'boolean' == typeof options.hot || 'only' === options.hot ? options.hot : true;
-        if ('function' == typeof options.server || 'string' == typeof options.server) options.server = {
-            type: options.server,
-            options: {}
-        };
-        else {
-            const serverOptions = options.server || {};
-            options.server = {
-                type: serverOptions.type || 'http',
-                options: {
-                    ...serverOptions.options
-                }
-            };
-        }
-        const serverOptions = options.server.options;
-        if ('https' === options.server.type || 'http2' === options.server.type) {
-            if (void 0 === serverOptions.requestCert) serverOptions.requestCert = false;
-            const httpsProperties = [
-                'ca',
-                'cert',
-                'crl',
-                'key',
-                'pfx'
-            ];
-            for (const property of httpsProperties){
-                if (void 0 === serverOptions[property]) continue;
-                const value = serverOptions[property];
-                const readFile = (item)=>{
-                    if (Buffer.isBuffer(item) || 'object' == typeof item && null !== item && !Array.isArray(item)) return item;
-                    if (item) {
-                        let stats = null;
-                        try {
-                            stats = lstatSync(realpathSync(item)).isFile();
-                        } catch (error) {}
-                        return stats ? readFileSync(item) : item;
-                    }
-                };
-                serverOptions[property] = Array.isArray(value) ? value.map((item)=>readFile(item)) : readFile(value);
-            }
-            let fakeCert;
-            if (!serverOptions.key || !serverOptions.cert) {
-                const certificateDir = Server.findCacheDir();
-                const certificatePath = join(certificateDir, 'server.pem');
-                let certificateExists;
-                try {
-                    const certificate = await promises.stat(certificatePath);
-                    certificateExists = certificate.isFile();
-                } catch  {
-                    certificateExists = false;
-                }
-                if (certificateExists) {
-                    const certificateTtl = 86400000;
-                    const certificateStat = await promises.stat(certificatePath);
-                    const now = Number(new Date());
-                    if ((now - Number(certificateStat.ctime)) / certificateTtl > 30) {
-                        this.logger.info('SSL certificate is more than 30 days old. Removing...');
-                        await promises.rm(certificatePath, {
-                            recursive: true
-                        });
-                        certificateExists = false;
-                    }
-                }
-                if (!certificateExists) {
-                    this.logger.info('Generating SSL certificate...');
-                    let selfsigned;
-                    try {
-                        selfsigned = server_require('selfsigned');
-                    } catch (error) {
-                        if (error instanceof Error && 'MODULE_NOT_FOUND' === error.code) throw new Error('Cannot generate a self-signed certificate because optional peer dependency `selfsigned@^5.0.0` is not installed. Please install it and try again.');
-                        throw error;
-                    }
-                    const attributes = [
-                        {
-                            name: 'commonName',
-                            value: 'localhost'
-                        }
-                    ];
-                    const notBeforeDate = new Date();
-                    const notAfterDate = new Date(notBeforeDate);
-                    notAfterDate.setDate(notAfterDate.getDate() + 30);
-                    const pems = await selfsigned.generate(attributes, {
-                        algorithm: 'sha256',
-                        keySize: 2048,
-                        notBeforeDate,
-                        notAfterDate,
-                        extensions: [
-                            {
-                                name: 'basicConstraints',
-                                cA: true
-                            },
-                            {
-                                name: 'keyUsage',
-                                keyCertSign: true,
-                                digitalSignature: true,
-                                nonRepudiation: true,
-                                keyEncipherment: true,
-                                dataEncipherment: true
-                            },
-                            {
-                                name: 'extKeyUsage',
-                                serverAuth: true,
-                                clientAuth: true,
-                                codeSigning: true,
-                                timeStamping: true
-                            },
-                            {
-                                name: 'subjectAltName',
-                                altNames: [
-                                    {
-                                        type: 2,
-                                        value: 'localhost'
-                                    },
-                                    {
-                                        type: 2,
-                                        value: 'localhost.localdomain'
-                                    },
-                                    {
-                                        type: 2,
-                                        value: 'lvh.me'
-                                    },
-                                    {
-                                        type: 2,
-                                        value: '*.lvh.me'
-                                    },
-                                    {
-                                        type: 2,
-                                        value: '[::1]'
-                                    },
-                                    {
-                                        type: 7,
-                                        ip: '127.0.0.1'
-                                    },
-                                    {
-                                        type: 7,
-                                        ip: 'fe80::1'
-                                    }
-                                ]
-                            }
-                        ]
-                    });
-                    await promises.mkdir(certificateDir, {
-                        recursive: true
-                    });
-                    await promises.writeFile(certificatePath, pems.private + pems.cert, {
-                        encoding: 'utf8'
-                    });
-                }
-                fakeCert = await promises.readFile(certificatePath);
-                this.logger.info(`SSL certificate: ${certificatePath}`);
-            }
-            serverOptions.key = serverOptions.key || fakeCert;
-            serverOptions.cert = serverOptions.cert || fakeCert;
-        }
-        if ('boolean' == typeof options.ipc) {
-            const isWindows = 'win32' === process.platform;
-            const pipePrefix = isWindows ? '\\\\.\\pipe\\' : tmpdir();
-            const pipeName = 'webpack-dev-server.sock';
-            options.ipc = join(pipePrefix, pipeName);
-        }
-        options.liveReload = void 0 !== options.liveReload ? options.liveReload : true;
-        const defaultOpenOptions = {
-            wait: false
-        };
-        const getOpenItemsFromObject = ({ target, ...rest })=>{
-            const normalizedOptions = {
-                ...defaultOpenOptions,
-                ...rest
-            };
-            if ('string' == typeof normalizedOptions.app) normalizedOptions.app = {
-                name: normalizedOptions.app
-            };
-            const normalizedTarget = void 0 === target ? '<url>' : target;
-            if (Array.isArray(normalizedTarget)) return normalizedTarget.map((singleTarget)=>({
-                    target: singleTarget,
-                    options: normalizedOptions
-                }));
-            return [
-                {
-                    target: normalizedTarget,
-                    options: normalizedOptions
-                }
-            ];
-        };
-        if (void 0 === options.open) options.open = [];
-        else if ('boolean' == typeof options.open) options.open = options.open ? [
-            {
-                target: '<url>',
-                options: defaultOpenOptions
-            }
-        ] : [];
-        else if ('string' == typeof options.open) options.open = [
-            {
-                target: options.open,
-                options: defaultOpenOptions
-            }
-        ];
-        else if (Array.isArray(options.open)) {
-            const result = [];
-            for (const item of options.open){
-                if ('string' == typeof item) {
-                    result.push({
-                        target: item,
-                        options: defaultOpenOptions
-                    });
-                    continue;
-                }
-                result.push(...getOpenItemsFromObject(item));
-            }
-            options.open = result;
-        } else options.open = [
-            ...getOpenItemsFromObject(options.open)
-        ];
-        if ('string' == typeof options.port && 'auto' !== options.port) options.port = Number(options.port);
-        if (void 0 === options.setupExitSignals) options.setupExitSignals = true;
-        if (void 0 === options.static) options.static = [
-            getStaticItem()
-        ];
-        else if ('boolean' == typeof options.static) options.static = options.static ? [
-            getStaticItem()
-        ] : false;
-        else if ('string' == typeof options.static) options.static = [
-            getStaticItem(options.static)
-        ];
-        else if (Array.isArray(options.static)) options.static = options.static.map((item)=>getStaticItem(item));
-        else options.static = [
-            getStaticItem(options.static)
-        ];
-        if ('string' == typeof options.watchFiles) options.watchFiles = [
-            {
-                paths: options.watchFiles,
-                options: getWatchOptions()
-            }
-        ];
-        else if ('object' != typeof options.watchFiles || null === options.watchFiles || Array.isArray(options.watchFiles)) if (Array.isArray(options.watchFiles)) options.watchFiles = options.watchFiles.map((item)=>{
-            if ('string' == typeof item) return {
-                paths: item,
-                options: getWatchOptions()
-            };
-            return {
-                paths: item.paths,
-                options: getWatchOptions(item.options || {})
-            };
-        });
-        else options.watchFiles = [];
-        else options.watchFiles = [
-            {
-                paths: options.watchFiles.paths,
-                options: getWatchOptions(options.watchFiles.options || {})
-            }
-        ];
-        const defaultWebSocketServerType = 'ws';
-        const defaultWebSocketServerOptions = {
-            path: '/ws'
-        };
-        if (void 0 === options.webSocketServer) options.webSocketServer = {
-            type: defaultWebSocketServerType,
-            options: defaultWebSocketServerOptions
-        };
-        else if ('boolean' != typeof options.webSocketServer || options.webSocketServer) if ('string' == typeof options.webSocketServer || 'function' == typeof options.webSocketServer) options.webSocketServer = {
-            type: options.webSocketServer,
-            options: defaultWebSocketServerOptions
-        };
-        else {
-            options.webSocketServer = {
-                type: options.webSocketServer.type || defaultWebSocketServerType,
-                options: {
-                    ...defaultWebSocketServerOptions,
-                    ...options.webSocketServer.options
-                }
-            };
-            const webSocketServer = options.webSocketServer;
-            if ('string' == typeof webSocketServer.options.port) webSocketServer.options.port = Number(webSocketServer.options.port);
-        }
-        else options.webSocketServer = false;
-    }
-    #getClientTransport() {
-        let clientImplementation;
-        let clientImplementationFound = true;
-        const isKnownWebSocketServerImplementation = this.options.webSocketServer && 'string' == typeof this.options.webSocketServer.type && 'ws' === this.options.webSocketServer.type;
-        let clientTransport;
-        clientTransport = this.options.client ? void 0 !== this.options.client.webSocketTransport ? this.options.client.webSocketTransport : isKnownWebSocketServerImplementation ? this.options.webSocketServer.type : 'ws' : 'ws';
-        switch(typeof clientTransport){
-            case 'string':
-                if ('sockjs' === clientTransport) throw new Error("SockJS support has been removed. Please set client.webSocketTransport to 'ws' or provide a custom transport implementation path.");
-                if ('ws' === clientTransport) clientImplementation = server_require.resolve('../client/clients/WebSocketClient');
-                else try {
-                    clientImplementation = server_require.resolve(clientTransport);
-                } catch  {
-                    clientImplementationFound = false;
-                }
-                break;
-            default:
-                clientImplementationFound = false;
-        }
-        if (!clientImplementationFound) throw new Error(`${!isKnownWebSocketServerImplementation ? 'When you use custom web socket implementation you must explicitly specify client.webSocketTransport. ' : ''}client.webSocketTransport must be a string denoting a default implementation (e.g. 'ws') or a full path to a JS file via require.resolve(...) which exports a class `);
-        return clientImplementation;
-    }
-    #getServerTransport() {
-        let implementation;
-        let implementationFound = true;
-        switch(typeof this.options.webSocketServer.type){
-            case 'string':
-                if ('sockjs' === this.options.webSocketServer.type) throw new Error("SockJS support has been removed. Please set webSocketServer to 'ws' or provide a custom WebSocket server implementation.");
-                if ('ws' === this.options.webSocketServer.type) implementation = WebsocketServer;
-                else try {
-                    implementation = server_require(this.options.webSocketServer.type);
-                } catch  {
-                    implementationFound = false;
-                }
-                break;
-            case 'function':
-                implementation = this.options.webSocketServer.type;
-                break;
-            default:
-                implementationFound = false;
-        }
-        if (!implementationFound) throw new Error("webSocketServer (webSocketServer.type) must be a string denoting a default implementation (e.g. 'ws'), a full path to a JS file which exports a class extending BaseServer (webpack-dev-server/lib/servers/BaseServer.js) via require.resolve(...), or the class itself which extends BaseServer");
-        return implementation;
-    }
-    getClientEntry() {
-        return server_require.resolve('@rspack/dev-server/client/index');
-    }
-    getClientHotEntry() {
-        if ('only' === this.options.hot) return server_require.resolve('@rspack/core/hot/only-dev-server');
-        if (this.options.hot) return server_require.resolve('@rspack/core/hot/dev-server');
-    }
-    #setupProgressPlugin() {
-        const { ProgressPlugin } = this.compiler.compilers ? this.compiler.compilers[0].webpack : this.compiler.webpack;
-        new ProgressPlugin((percent, msg)=>{
-            const percentValue = Math.floor(100 * percent);
-            let msgValue = msg;
-            if (100 === percentValue) msgValue = 'Compilation completed';
-            const payload = {
-                percent: percentValue,
-                msg: msgValue
-            };
-            if (this.webSocketServer) this.sendMessage(this.webSocketServer.clients, 'progress-update', payload);
-            if (this.server) this.server.emit('progress-update', payload);
-        }).apply(this.compiler);
-    }
-    async #initialize() {
-        const compilers = isMultiCompiler(this.compiler) ? this.compiler.compilers : [
-            this.compiler
-        ];
-        for (const compiler of compilers){
-            const mode = compiler.options.mode || process.env.NODE_ENV;
-            if (this.options.hot) {
-                if ('production' === mode) this.logger.warn("Hot Module Replacement (HMR) is enabled for the production build. \nMake sure to disable HMR for production by setting `devServer.hot` to `false` in the configuration.");
-                compiler.options.resolve.alias = {
-                    'ansi-html-community': server_require.resolve('@rspack/dev-server/client/utils/ansiHTML'),
-                    ...compiler.options.resolve.alias
-                };
-            }
-        }
-        this.#setupHooks();
-        await this.#setupApp();
-        await this.#createServer();
-        if (this.options.webSocketServer) {
-            const compilers = this.compiler.compilers || [
-                this.compiler
-            ];
-            for (const compiler of compilers){
-                if (false === compiler.options.devServer) continue;
-                this.#addAdditionalEntries(compiler);
-                const { ProvidePlugin, HotModuleReplacementPlugin } = compiler.rspack;
-                new ProvidePlugin({
-                    __rspack_dev_server_client__: this.#getClientTransport()
-                }).apply(compiler);
-                if (this.options.hot) {
-                    const HMRPluginExists = compiler.options.plugins.find((plugin)=>plugin && plugin.constructor === HotModuleReplacementPlugin);
-                    if (HMRPluginExists) this.logger.warn('"hot: true" automatically applies HMR plugin, you don\'t have to add it manually to your webpack configuration.');
-                    else {
-                        const plugin = new HotModuleReplacementPlugin();
-                        plugin.apply(compiler);
-                    }
-                }
-            }
-            if (this.options.client && this.options.client.progress) this.#setupProgressPlugin();
-        }
-        await this.#setupWatchFiles();
-        await this.#setupWatchStaticFiles();
-        await this.#setupMiddlewares();
-        if (this.options.setupExitSignals) {
-            const signals = [
-                'SIGINT',
-                'SIGTERM'
-            ];
-            let needForceShutdown = false;
-            for (const signal of signals){
-                const listener = ()=>{
-                    if (needForceShutdown) process.exit();
-                    this.logger.info('Gracefully shutting down. Press ^C again to force exit...');
-                    needForceShutdown = true;
-                    this.stopCallback(()=>{
-                        if ('function' == typeof this.compiler.close) this.compiler.close(()=>{
-                            process.exit();
-                        });
-                        else process.exit();
-                    });
-                };
-                this.listeners.push({
-                    name: signal,
-                    listener
-                });
-                process.on(signal, listener);
-            }
-        }
-        const webSocketProxies = this.webSocketProxies;
-        for (const webSocketProxy of webSocketProxies)this.server.on('upgrade', webSocketProxy.upgrade);
-    }
-    async #setupApp() {
-        this.app = 'function' == typeof this.options.app ? await this.options.app() : (await getConnect())();
-    }
-    #getStats(statsObj) {
-        const stats = Server.DEFAULT_STATS;
-        const compilerOptions = this.#getCompilerOptions();
-        if (compilerOptions.stats && compilerOptions.stats.warningsFilter) stats.warningsFilter = compilerOptions.stats.warningsFilter;
-        return statsObj.toJson(stats);
-    }
-    #setupHooks() {
-        this.compiler.hooks.invalid.tap('rspack-dev-server', ()=>{
-            if (this.webSocketServer) this.sendMessage(this.webSocketServer.clients, 'invalid');
-        });
-        this.compiler.hooks.done.tap('rspack-dev-server', (stats)=>{
-            if (this.webSocketServer) this.#sendStats(this.webSocketServer.clients, this.#getStats(stats));
-            this.stats = stats;
-        });
-    }
-    async #setupWatchStaticFiles() {
-        const watchFiles = this.options.static;
-        if (watchFiles.length > 0) {
-            for (const item of watchFiles)if (item.watch) await this.watchFiles(item.directory, item.watch);
-        }
-    }
-    async #setupWatchFiles() {
-        const watchFiles = this.options.watchFiles;
-        if (watchFiles.length > 0) for (const item of watchFiles)await this.watchFiles(item.paths, item.options);
-    }
-    async #setupMiddlewares() {
-        let middlewares = [];
-        middlewares.push({
-            name: 'host-header-check',
-            middleware: (req, res, next)=>{
-                const headers = req.headers;
-                const headerName = headers[':authority'] ? ':authority' : 'host';
-                if (this.isValidHost(headers, headerName)) return void next();
-                res.statusCode = 403;
-                res.end('Invalid Host header');
-            }
-        });
-        middlewares.push({
-            name: 'cross-origin-header-check',
-            middleware: (req, res, next)=>{
-                const headers = req.headers;
-                const headerName = headers[':authority'] ? ':authority' : 'host';
-                if (this.isValidHost(headers, headerName, false)) return void next();
-                if ('no-cors' === headers['sec-fetch-mode'] && 'cross-site' === headers['sec-fetch-site']) {
-                    res.statusCode = 403;
-                    res.end('Cross-Origin request blocked');
-                    return;
-                }
-                next();
-            }
-        });
-        const isHTTP2 = 'http2' === this.options.server.type;
-        if (isHTTP2) middlewares.push({
-            name: 'http2-status-message-patch',
-            middleware: (_req, res, next)=>{
-                Object.defineProperty(res, 'statusMessage', {
-                    get () {
-                        return '';
-                    },
-                    set () {}
-                });
-                next();
-            }
-        });
-        if (this.options.compress) middlewares.push({
-            name: 'compression',
-            middleware: src_default()()
-        });
-        if (void 0 !== this.options.headers) middlewares.push({
-            name: 'set-headers',
-            middleware: this.#setHeaders.bind(this)
-        });
-        middlewares.push({
-            name: 'webpack-dev-middleware',
-            middleware: this.middleware
-        });
-        middlewares.push({
-            name: 'rspack-dev-server-invalidate',
-            path: '/rspack-dev-server/invalidate',
-            middleware: (req, res, next)=>{
-                if ('GET' !== req.method && 'HEAD' !== req.method) return void next();
-                this.invalidate();
-                res.end();
-            }
-        });
-        middlewares.push({
-            name: 'rspack-dev-server-open-editor',
-            path: '/rspack-dev-server/open-editor',
-            middleware: async (req, res, next)=>{
-                if ('GET' !== req.method && 'HEAD' !== req.method) return void next();
-                if (!req.url) return void next();
-                const resolveUrl = new URL(req.url, `http://${req.headers.host}`);
-                const params = new URLSearchParams(resolveUrl.search);
-                const fileName = params.get('fileName');
-                if ('string' == typeof fileName) {
-                    const { default: launchEditor } = await import("./0~launch-editor.js").then(__webpack_require__.t.bind(__webpack_require__, "./node_modules/.pnpm/launch-editor@2.13.1/node_modules/launch-editor/index.js", 23));
-                    launchEditor(fileName);
-                }
-                res.end();
-            }
-        });
-        middlewares.push({
-            name: 'rspack-dev-server-assets',
-            path: '/rspack-dev-server',
-            middleware: (req, res, next)=>{
-                if ('GET' !== req.method && 'HEAD' !== req.method) return void next();
-                if (!this.middleware) return void next();
-                this.middleware.waitUntilValid((stats)=>{
-                    res.setHeader('Content-Type', 'text/html; charset=utf-8');
-                    if ('HEAD' === req.method) return void res.end();
-                    res.write('<!DOCTYPE html><html><head><meta charset="utf-8"/></head><body>');
-                    const statsForPrint = void 0 !== stats.stats ? stats.toJson({
-                        assets: true
-                    }).children : [
-                        stats.toJson({
-                            assets: true
-                        })
-                    ];
-                    res.write('<h1>Assets Report:</h1>');
-                    for (const [index, item] of statsForPrint?.entries() ?? []){
-                        res.write('<div>');
-                        const name = void 0 !== item.name ? item.name : stats.stats ? `unnamed[${index}]` : 'unnamed';
-                        res.write(`<h2>Compilation: ${name}</h2>`);
-                        res.write('<ul>');
-                        const publicPath = 'auto' === item.publicPath ? '' : item.publicPath;
-                        const assets = item.assets;
-                        for (const asset of assets ?? []){
-                            const assetName = asset.name;
-                            const assetURL = `${publicPath}${assetName}`;
-                            res.write(`<li>
-              <strong><a href="${assetURL}" target="_blank">${assetName}</a></strong>
-            </li>`);
-                        }
-                        res.write('</ul>');
-                        res.write('</div>');
-                    }
-                    res.end('</body></html>');
-                });
-            }
-        });
-        if (this.options.proxy) {
-            const { createProxyMiddleware } = server_require('http-proxy-middleware');
-            const getProxyMiddleware = (proxyConfig)=>{
-                const { context, ...proxyOptions } = proxyConfig;
-                const pathFilter = proxyOptions.pathFilter ?? context;
-                if (void 0 !== pathFilter) proxyOptions.pathFilter = pathFilter;
-                if (void 0 === proxyOptions.logger) proxyOptions.logger = this.logger;
-                if (proxyOptions.target || proxyOptions.router) return createProxyMiddleware(proxyOptions);
-                deprecate(()=>{}, `Invalid proxy configuration:\n\n${JSON.stringify(proxyConfig, null, 2)}\n\nThe use of proxy object notation as proxy routes has been removed.\nPlease use the 'router' or 'context' options. Read more at https://github.com/chimurai/http-proxy-middleware`, 'DEP_WEBPACK_DEV_SERVER_PROXY_ROUTES_ARGUMENT')();
-            };
-            for (const proxyConfigOrCallback of this.options.proxy){
-                let proxyMiddleware;
-                let proxyConfig = 'function' == typeof proxyConfigOrCallback ? proxyConfigOrCallback() : proxyConfigOrCallback;
-                proxyMiddleware = getProxyMiddleware(proxyConfig);
-                if (proxyConfig.ws && proxyMiddleware) this.webSocketProxies.push(proxyMiddleware);
-                const handler = async (req, res, next)=>{
-                    if ('function' == typeof proxyConfigOrCallback) {
-                        const newProxyConfig = proxyConfigOrCallback(req, res, next);
-                        if (newProxyConfig !== proxyConfig) {
-                            proxyConfig = newProxyConfig;
-                            const socket = req.socket || req.connection;
-                            const server = socket ? socket.server : null;
-                            if (server) server.removeAllListeners('close');
-                            proxyMiddleware = getProxyMiddleware(proxyConfig);
-                        }
-                    }
-                    if (proxyMiddleware) return proxyMiddleware(req, res, next);
-                    next();
-                };
-                middlewares.push({
-                    name: 'http-proxy-middleware',
-                    middleware: handler
-                });
-                middlewares.push({
-                    name: 'http-proxy-middleware-error-handler',
-                    middleware: (error, req, res, next)=>handler(req, res, next)
-                });
-            }
-            middlewares.push({
-                name: 'webpack-dev-middleware',
-                middleware: this.middleware
-            });
-        }
-        const staticOptions = this.options.static;
-        if (staticOptions.length > 0) for (const staticOption of staticOptions)for (const publicPath of staticOption.publicPath)middlewares.push({
-            name: 'serve-static',
-            path: publicPath,
-            middleware: getServeStatic()(staticOption.directory, staticOption.staticOptions)
-        });
-        if (this.options.historyApiFallback) {
-            const connectHistoryApiFallback = server_require('connect-history-api-fallback');
-            const { historyApiFallback } = this.options;
-            if (void 0 === historyApiFallback && !historyApiFallback.verbose) historyApiFallback.logger = this.logger.log.bind(this.logger, '[connect-history-api-fallback]');
-            middlewares.push({
-                name: 'connect-history-api-fallback',
-                middleware: connectHistoryApiFallback(historyApiFallback)
-            });
-            middlewares.push({
-                name: 'webpack-dev-middleware',
-                middleware: this.middleware
-            });
-            if (staticOptions.length > 0) for (const staticOption of staticOptions)for (const publicPath of staticOption.publicPath)middlewares.push({
-                name: 'serve-static',
-                path: publicPath,
-                middleware: getServeStatic()(staticOption.directory, staticOption.staticOptions)
-            });
-        }
-        middlewares.push({
-            name: 'options-middleware',
-            middleware: (req, res, next)=>{
-                if ('OPTIONS' === req.method) {
-                    res.statusCode = 204;
-                    res.setHeader('Content-Length', '0');
-                    res.end();
-                    return;
-                }
-                next();
-            }
-        });
-        if ('function' == typeof this.options.setupMiddlewares) middlewares = this.options.setupMiddlewares(middlewares, this);
-        const lazyInitDevMiddleware = ()=>{
-            if (!this.middleware) {
-                const webpackDevMiddleware = server_require('webpack-dev-middleware');
-                this.middleware = webpackDevMiddleware(this.compiler, this.options.devMiddleware);
-            }
-            return this.middleware;
-        };
-        for (const i of middlewares)if ('webpack-dev-middleware' === i.name) {
-            const item = i;
-            if (void 0 === item.middleware) item.middleware = lazyInitDevMiddleware();
-        }
-        for (const middleware of middlewares)if ('function' == typeof middleware) this.app.use(middleware);
-        else if (void 0 !== middleware.path) this.app.use(middleware.path, middleware.middleware);
-        else this.app.use(middleware.middleware);
-    }
-    async #createServer() {
-        const { type, options } = this.options.server;
-        if ('function' == typeof type) this.server = await type(options, this.app);
-        else {
-            const serverType = server_require(type);
-            this.server = 'http2' === type ? serverType.createSecureServer({
-                ...options,
-                allowHTTP1: true
-            }, this.app) : serverType.createServer(options, this.app);
-        }
-        this.isTlsServer = void 0 !== this.server.setSecureContext;
-        this.server.on('connection', (socket)=>{
-            this.sockets.push(socket);
-            socket.once('close', ()=>{
-                this.sockets.splice(this.sockets.indexOf(socket), 1);
-            });
-        });
-        this.server.on('error', (error)=>{
-            throw error;
-        });
-    }
-    #createWebSocketServer() {
-        this.webSocketServer = new (this.#getServerTransport())(this);
-        (this.webSocketServer?.implementation).on('connection', (client, request)=>{
-            const headers = void 0 !== request ? request.headers : void 0;
-            if (!headers) this.logger.warn('webSocketServer implementation must pass headers for the "connection" event');
-            if (!headers || !this.isValidHost(headers, 'host') || !this.isValidHost(headers, 'origin') || !this.#isSameOrigin(headers)) {
-                this.sendMessage([
-                    client
-                ], 'error', 'Invalid Host/Origin header');
-                client.close();
-                return;
-            }
-            if (true === this.options.hot || 'only' === this.options.hot) this.sendMessage([
-                client
-            ], 'hot');
-            if (this.options.liveReload) this.sendMessage([
-                client
-            ], 'liveReload');
-            if (this.options.client && this.options.client.progress) this.sendMessage([
-                client
-            ], 'progress', this.options.client.progress);
-            if (this.options.client && this.options.client.reconnect) this.sendMessage([
-                client
-            ], 'reconnect', this.options.client.reconnect);
-            if (this.options.client && this.options.client.overlay) {
-                const overlayConfig = this.options.client.overlay;
-                this.sendMessage([
-                    client
-                ], 'overlay', 'object' == typeof overlayConfig ? {
-                    ...overlayConfig,
-                    errors: overlayConfig.errors && encodeOverlaySettings(overlayConfig.errors),
-                    warnings: overlayConfig.warnings && encodeOverlaySettings(overlayConfig.warnings),
-                    runtimeErrors: overlayConfig.runtimeErrors && encodeOverlaySettings(overlayConfig.runtimeErrors)
-                } : overlayConfig);
-            }
-            if (!this.stats) return;
-            this.#sendStats([
-                client
-            ], this.#getStats(this.stats), true);
-        });
-    }
-    async #openBrowser(defaultOpenTarget) {
-        const { default: open } = await import("./0~open.js").then((mod)=>({
-                default: mod.node_modules_open
-            }));
-        Promise.all(this.options.open.map((item)=>{
-            let openTarget;
-            openTarget = '<url>' === item.target ? defaultOpenTarget : Server.isAbsoluteURL(item.target) ? item.target : new URL(item.target, defaultOpenTarget).toString();
-            return open(openTarget, item.options).catch(()=>{
-                const app = item.options.app;
-                this.logger.warn(`Unable to open "${openTarget}" page${app ? ` in "${app.name}" app${app.arguments ? ` with "${app.arguments.join(' ')}" arguments` : ''}` : ''}. If you are running in a headless environment, please do not use the "open" option or related flags like "--open", "--open-target", and "--open-app-name".`);
-            });
-        }));
-    }
-    async #logStatus() {
-        const server = this.server;
-        if (this.options.ipc) this.logger.info(`Project is running at: "${server?.address()}"`);
-        else {
-            const protocol = this.isTlsServer ? 'https' : 'http';
-            const addressInfo = server?.address();
-            if (!addressInfo) return;
-            const { address, port } = addressInfo;
-            const prettyPrintURL = (newHostname)=>format({
-                    protocol,
-                    hostname: newHostname,
-                    port,
-                    pathname: '/'
-                });
-            let localhost;
-            let loopbackIPv4;
-            let loopbackIPv6;
-            let networkUrlIPv4;
-            let networkUrlIPv6;
-            if ('localhost' === this.options.host) localhost = prettyPrintURL('localhost');
-            const parsedIP = ipaddr.parse(address);
-            if ('unspecified' === parsedIP.range()) {
-                localhost = prettyPrintURL('localhost');
-                loopbackIPv6 = prettyPrintURL('::1');
-                const networkIPv4 = Server.findIp('v4', false);
-                if (networkIPv4) networkUrlIPv4 = prettyPrintURL(networkIPv4);
-                const networkIPv6 = Server.findIp('v6', false);
-                if (networkIPv6) networkUrlIPv6 = prettyPrintURL(networkIPv6);
-            } else if ('loopback' === parsedIP.range()) {
-                if ('ipv4' === parsedIP.kind()) loopbackIPv4 = prettyPrintURL(parsedIP.toString());
-                else if ('ipv6' === parsedIP.kind()) loopbackIPv6 = prettyPrintURL(parsedIP.toString());
-            } else {
-                networkUrlIPv4 = 'ipv6' === parsedIP.kind() && parsedIP.isIPv4MappedAddress() ? prettyPrintURL(parsedIP.toIPv4Address().toString()) : prettyPrintURL(address);
-                if ('ipv6' === parsedIP.kind()) networkUrlIPv6 = prettyPrintURL(address);
-            }
-            const urlLogs = [];
-            const local = localhost || loopbackIPv4 || loopbackIPv6;
-            if (local) urlLogs.push(`  ${server_styleText('white', '➜')}  ${server_styleText([
-                'white',
-                'dim'
-            ], 'Local:')}    ${server_styleText('cyan', local)}`);
-            if (networkUrlIPv4) urlLogs.push(`  ${server_styleText('white', '➜')}  ${server_styleText([
-                'white',
-                'dim'
-            ], 'Network:')}  ${server_styleText('cyan', networkUrlIPv4)}`);
-            else if (networkUrlIPv6) urlLogs.push(`  ${server_styleText('white', '➜')}  ${server_styleText([
-                'white',
-                'dim'
-            ], 'Network:')}  ${server_styleText('cyan', networkUrlIPv6)}`);
-            if (urlLogs.length && this.#shouldLogInfrastructureInfo()) console.log(`${urlLogs.join('\n')}\n`);
-            if (this.options.open?.length > 0) {
-                const openTarget = prettyPrintURL(this.options.host && '0.0.0.0' !== this.options.host && '::' !== this.options.host ? this.options.host : 'localhost');
-                await this.#openBrowser(openTarget);
-            }
-        }
-    }
-    #setHeaders(req, res, next) {
-        let { headers } = this.options;
-        if (headers) {
-            if ('function' == typeof headers) headers = headers(req, res, this.middleware ? this.middleware.context : void 0);
-            const allHeaders = [];
-            if (!Array.isArray(headers)) {
-                for(const name in headers)allHeaders.push({
-                    key: name,
-                    value: headers[name]
-                });
-                headers = allHeaders;
-            }
-            for (const { key, value } of headers)res.setHeader(key, value);
-        }
-        next();
-    }
-    #isHostAllowed(value) {
-        const { allowedHosts } = this.options;
-        if ('all' === allowedHosts) return true;
-        if (Array.isArray(allowedHosts) && allowedHosts.length > 0) for (const allowedHost of allowedHosts){
-            if (allowedHost === value) return true;
-            if (allowedHost.startsWith('.') && (value === allowedHost.slice(1) || value.endsWith(allowedHost))) return true;
-        }
-        if (this.options.client && void 0 !== this.options.client.webSocketURL) return this.options.client.webSocketURL === value;
-        return false;
-    }
-    isValidHost(headers, headerToCheck, validateHost = true) {
-        if ('all' === this.options.allowedHosts) return true;
-        const header = headers[headerToCheck];
-        if (!header) return false;
-        if (DEFAULT_ALLOWED_PROTOCOLS.test(header)) return true;
-        const hostname = parseHostnameFromHeader(header);
-        if (null === hostname) return false;
-        if (this.#isHostAllowed(hostname)) return true;
-        const isValidHostname = validateHost ? ipaddr.IPv4.isValid(hostname) || ipaddr.IPv6.isValid(hostname) || 'localhost' === hostname || hostname.endsWith('.localhost') || hostname === this.options.host : false;
-        return isValidHostname;
-    }
-    #isSameOrigin(headers) {
-        if ('all' === this.options.allowedHosts) return true;
-        const originHeader = headers.origin;
-        if (!originHeader) return 'all' === this.options.allowedHosts;
-        if (DEFAULT_ALLOWED_PROTOCOLS.test(originHeader)) return true;
-        const origin = parseHostnameFromHeader(originHeader);
-        if (null === origin) return false;
-        if (this.#isHostAllowed(origin)) return true;
-        const hostHeader = headers.host;
-        if (!hostHeader) return 'all' === this.options.allowedHosts;
-        if (DEFAULT_ALLOWED_PROTOCOLS.test(hostHeader)) return true;
-        const host = parseHostnameFromHeader(hostHeader);
-        if (null === host) return false;
-        if (this.#isHostAllowed(host)) return true;
-        return origin === host;
-    }
-    sendMessage(clients, type, data, params) {
-        for (const client of clients)if (1 === client.readyState) client.send(JSON.stringify({
-            type,
-            data,
-            params
-        }));
-    }
-    #sendStats(clients, stats, force) {
-        if (!stats) return;
-        const shouldEmit = !force && stats && (!stats.errors || 0 === stats.errors.length) && (!stats.warnings || 0 === stats.warnings.length) && this.currentHash === stats.hash;
-        if (shouldEmit) return void this.sendMessage(clients, 'still-ok');
-        this.currentHash = stats.hash;
-        this.sendMessage(clients, 'hash', stats.hash);
-        if (stats.errors?.length > 0 || stats.warnings?.length > 0) {
-            const hasErrors = stats.errors?.length > 0;
-            if (stats.warnings?.length > 0) {
-                let params;
-                if (hasErrors) params = {
-                    preventReloading: true
-                };
-                this.sendMessage(clients, 'warnings', stats.warnings, params);
-            }
-            if (stats.errors?.length > 0) this.sendMessage(clients, 'errors', stats.errors);
-        } else this.sendMessage(clients, 'ok');
-    }
-    async watchFiles(watchPath, watchOptions) {
-        const { watch } = await getChokidar();
-        const watcher = watch(watchPath, watchOptions);
-        if (this.options.liveReload) watcher.on('change', (item)=>{
-            if (this.webSocketServer) this.sendMessage(this.webSocketServer.clients, 'static-changed', item);
-        });
-        this.staticWatchers.push(watcher);
-    }
-    invalidate(callback = ()=>{}) {
-        if (this.middleware) this.middleware.invalidate(callback);
-    }
-    async start() {
-        await this.#normalizeOptions();
-        if (this.options.ipc) await new Promise((resolve, reject)=>{
-            const net = server_require('node:net');
-            const socket = new net.Socket();
-            socket.on('error', (error)=>{
-                if ('ECONNREFUSED' === error.code) {
-                    unlinkSync(this.options.ipc);
-                    resolve();
-                    return;
-                }
-                if ('ENOENT' === error.code) return void resolve();
-                reject(error);
-            });
-            socket.connect({
-                path: this.options.ipc
-            }, ()=>{
-                throw new Error(`IPC "${this.options.ipc}" is already used`);
-            });
-        });
-        else {
-            this.options.host = await Server.getHostname(this.options.host);
-            this.options.port = await Server.getFreePort(this.options.port, this.options.host);
-        }
-        await this.#initialize();
-        const listenOptions = this.options.ipc ? {
-            path: this.options.ipc
-        } : {
-            host: this.options.host,
-            port: this.options.port
-        };
-        await new Promise((resolve)=>{
-            this.server.listen(listenOptions, ()=>{
-                resolve();
-            });
-        });
-        if (this.options.ipc) {
-            const READ_WRITE = 438;
-            await promises.chmod(this.options.ipc, READ_WRITE);
-        }
-        if (this.options.webSocketServer) this.#createWebSocketServer();
-        await this.#logStatus();
-        if ('function' == typeof this.options.onListening) this.options.onListening(this);
-    }
-    startCallback(callback = ()=>{}) {
-        this.start().then(()=>callback(), callback).catch(callback);
-    }
-    async stop() {
-        this.webSocketProxies = [];
-        await Promise.all(this.staticWatchers.map((watcher)=>watcher.close()));
-        this.staticWatchers = [];
-        if (this.webSocketServer) await new Promise((resolve)=>{
-            this.webSocketServer.implementation.close(()=>{
-                this.webSocketServer = null;
-                resolve();
-            });
-            for (const client of this.webSocketServer.clients)client.terminate();
-            this.webSocketServer.clients = [];
-        });
-        if (this.server) {
-            await new Promise((resolve)=>{
-                this.server.close(()=>{
-                    this.server = void 0;
-                    resolve();
-                });
-                for (const socket of this.sockets)socket.destroy();
-                this.sockets = [];
-            });
-            if (this.middleware) {
-                await new Promise((resolve, reject)=>{
-                    this.middleware.close((error)=>{
-                        if (error) return void reject(error);
-                        resolve();
-                    });
-                });
-                this.middleware = void 0;
-            }
-        }
-        for (const item of this.listeners)process.removeListener(item.name, item.listener);
-    }
-    stopCallback(callback = ()=>{}) {
-        this.stop().then(()=>callback(), callback).catch(callback);
-    }
-}
-export { Server as RspackDevServer, fileURLToPath, node_fs, node_os, node_path, promisify };