@rspack/dev-server 1.2.1 → 2.0.0-beta.2

package/dist/131.js

@@ -0,0 +1,1398 @@
+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";
+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 { 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 getExpress = memoize(()=>server_require('express'));
+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, ...rest } = watchOptions;
+            return {
+                ignoreInitial: true,
+                persistent: true,
+                followSymlinks: false,
+                atomic: false,
+                alwaysStat: true,
+                ignorePermissionErrors: true,
+                usePolling,
+                interval,
+                ignored: watchOptions.ignored,
+                ...rest
+            };
+        };
+        const getStaticItem = (optionsForStatic)=>{
+            const getDefaultStaticOptions = ()=>({
+                    directory: join(process.cwd(), 'public'),
+                    staticOptions: {},
+                    publicPath: [
+                        '/'
+                    ],
+                    serveIndex: {
+                        icons: true
+                    },
+                    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,
+                    serveIndex: void 0 !== optionsForStatic.serveIndex ? 'boolean' == typeof optionsForStatic.serveIndex && optionsForStatic.serveIndex ? def.serveIndex : 'object' == typeof optionsForStatic.serveIndex ? {
+                        ...def.serveIndex,
+                        ...optionsForStatic.serveIndex
+                    } : optionsForStatic.serveIndex : def.serveIndex,
+                    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();
+        }
+        this.setupWatchFiles();
+        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() : getExpress()();
+    }
+    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;
+        });
+    }
+    setupWatchStaticFiles() {
+        const watchFiles = this.options.static;
+        if (watchFiles.length > 0) {
+            for (const item of watchFiles)if (item.watch) this.watchFiles(item.directory, item.watch);
+        }
+    }
+    setupWatchFiles() {
+        const watchFiles = this.options.watchFiles;
+        if (watchFiles.length > 0) for (const item of watchFiles)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) {
+            const { default: compression } = await import("compression");
+            middlewares.push({
+                name: 'compression',
+                middleware: compression()
+            });
+        }
+        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: 'express-static',
+            path: publicPath,
+            middleware: getExpress().static(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: 'express-static',
+                path: publicPath,
+                middleware: getExpress().static(staticOption.directory, staticOption.staticOptions)
+            });
+        }
+        if (staticOptions.length > 0) {
+            const serveIndex = server_require('serve-index');
+            for (const staticOption of staticOptions)for (const publicPath of staticOption.publicPath)if (staticOption.serveIndex) middlewares.push({
+                name: 'serve-index',
+                path: publicPath,
+                middleware: (req, res, next)=>{
+                    if ('GET' !== req.method && 'HEAD' !== req.method) return next();
+                    serveIndex(staticOption.directory, staticOption.serveIndex)(req, res, next);
+                }
+            });
+        }
+        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');
+    }
+    watchFiles(watchPath, watchOptions) {
+        const chokidar = server_require('chokidar');
+        const watcher = chokidar.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 };