@rspack/dev-server 2.0.0-beta.6 → 2.0.0-rc.0

package/dist/831.js

@@ -0,0 +1,2641 @@
+import { createRequire } from "node:module";
+import { devMiddleware } from "@rspack/dev-middleware";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+import * as __rspack_external_node_fs_5ea92f0c from "node:fs";
+import * as __rspack_external_node_os_74b4b876 from "node:os";
+import * as __rspack_external_node_path_c5b9b54f from "node:path";
+import * as __rspack_external_node_url_e96de089 from "node:url";
+import * as __rspack_external_node_util_1b29d436 from "node:util";
+import * as __rspack_external_node_net_0373943e from "node:net";
+import * as __rspack_external_ws from "ws";
+var __webpack_modules__ = {};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    var getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+    var leafPrototypes;
+    __webpack_require__.t = function(value, mode) {
+        if (1 & mode) value = this(value);
+        if (8 & mode) return value;
+        if ('object' == typeof value && value) {
+            if (4 & mode && value.__esModule) return value;
+            if (16 & mode && 'function' == typeof value.then) return value;
+        }
+        var ns = Object.create(null);
+        __webpack_require__.r(ns);
+        var def = {};
+        leafPrototypes = leafPrototypes || [
+            null,
+            getProto({}),
+            getProto([]),
+            getProto(getProto)
+        ];
+        for(var current = 2 & mode && value; ('object' == typeof current || 'function' == typeof current) && !~leafPrototypes.indexOf(current); current = getProto(current))Object.getOwnPropertyNames(current).forEach((key)=>{
+            def[key] = ()=>value[key];
+        });
+        def['default'] = ()=>value;
+        __webpack_require__.d(ns, def);
+        return ns;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+var __webpack_require__temp = __webpack_require__;
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+(()=>{
+    var installedChunks = {
+        410: 0,
+        831: 0
+    };
+    var installChunk = (data)=>{
+        var __rspack_esm_ids = data.__rspack_esm_ids;
+        var __webpack_modules__ = data.__webpack_modules__;
+        var __rspack_esm_runtime = data.__rspack_esm_runtime;
+        var moduleId, chunkId, i = 0;
+        for(moduleId in __webpack_modules__)if (__webpack_require__.o(__webpack_modules__, moduleId)) __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
+        if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
+        for(; i < __rspack_esm_ids.length; i++){
+            chunkId = __rspack_esm_ids[i];
+            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
+            installedChunks[__rspack_esm_ids[i]] = 0;
+        }
+    };
+    __webpack_require__.C = installChunk;
+})();
+__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();
+            };
+        };
+    },
+    "./node_modules/.pnpm/ipaddr.js@2.3.0/node_modules/ipaddr.js/lib/ipaddr.js" (module) {
+        (function(root) {
+            'use strict';
+            const ipv4Part = '(0?\\d+|0x[a-f0-9]+)';
+            const ipv4Regexes = {
+                fourOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, 'i'),
+                threeOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}$`, 'i'),
+                twoOctet: new RegExp(`^${ipv4Part}\\.${ipv4Part}$`, 'i'),
+                longValue: new RegExp(`^${ipv4Part}$`, 'i')
+            };
+            const octalRegex = new RegExp("^0[0-7]+$", 'i');
+            const hexRegex = new RegExp("^0x[a-f0-9]+$", 'i');
+            const zoneIndex = '%[0-9a-z]{1,}';
+            const ipv6Part = '(?:[0-9a-f]+::?)+';
+            const ipv6Regexes = {
+                zoneIndex: new RegExp(zoneIndex, 'i'),
+                native: new RegExp(`^(::)?(${ipv6Part})?([0-9a-f]+)?(::)?(${zoneIndex})?$`, 'i'),
+                deprecatedTransitional: new RegExp(`^(?:::)(${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?)$`, 'i'),
+                transitional: new RegExp(`^((?:${ipv6Part})|(?:::)(?:${ipv6Part})?)${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}\\.${ipv4Part}(${zoneIndex})?$`, 'i')
+            };
+            function expandIPv6(string, parts) {
+                if (string.indexOf('::') !== string.lastIndexOf('::')) return null;
+                let colonCount = 0;
+                let lastColon = -1;
+                let zoneId = (string.match(ipv6Regexes.zoneIndex) || [])[0];
+                let replacement, replacementCount;
+                if (zoneId) {
+                    zoneId = zoneId.substring(1);
+                    string = string.replace(/%.+$/, '');
+                }
+                while((lastColon = string.indexOf(':', lastColon + 1)) >= 0)colonCount++;
+                if ('::' === string.substr(0, 2)) colonCount--;
+                if ('::' === string.substr(-2, 2)) colonCount--;
+                if (colonCount > parts) return null;
+                replacementCount = parts - colonCount;
+                replacement = ':';
+                while(replacementCount--)replacement += '0:';
+                string = string.replace('::', replacement);
+                if (':' === string[0]) string = string.slice(1);
+                if (':' === string[string.length - 1]) string = string.slice(0, -1);
+                parts = function() {
+                    const ref = string.split(':');
+                    const results = [];
+                    for(let i = 0; i < ref.length; i++)results.push(parseInt(ref[i], 16));
+                    return results;
+                }();
+                return {
+                    parts: parts,
+                    zoneId: zoneId
+                };
+            }
+            function matchCIDR(first, second, partSize, cidrBits) {
+                if (first.length !== second.length) throw new Error('ipaddr: cannot match CIDR for objects with different lengths');
+                let part = 0;
+                let shift;
+                while(cidrBits > 0){
+                    shift = partSize - cidrBits;
+                    if (shift < 0) shift = 0;
+                    if (first[part] >> shift !== second[part] >> shift) return false;
+                    cidrBits -= partSize;
+                    part += 1;
+                }
+                return true;
+            }
+            function parseIntAuto(string) {
+                if (hexRegex.test(string)) return parseInt(string, 16);
+                if ('0' === string[0] && !isNaN(parseInt(string[1], 10))) {
+                    if (octalRegex.test(string)) return parseInt(string, 8);
+                    throw new Error(`ipaddr: cannot parse ${string} as octal`);
+                }
+                return parseInt(string, 10);
+            }
+            function padPart(part, length) {
+                while(part.length < length)part = `0${part}`;
+                return part;
+            }
+            const ipaddr = {};
+            ipaddr.IPv4 = function() {
+                function IPv4(octets) {
+                    if (4 !== octets.length) throw new Error('ipaddr: ipv4 octet count should be 4');
+                    let i, octet;
+                    for(i = 0; i < octets.length; i++){
+                        octet = octets[i];
+                        if (!(0 <= octet && octet <= 255)) throw new Error('ipaddr: ipv4 octet should fit in 8 bits');
+                    }
+                    this.octets = octets;
+                }
+                IPv4.prototype.SpecialRanges = {
+                    unspecified: [
+                        [
+                            new IPv4([
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            8
+                        ]
+                    ],
+                    broadcast: [
+                        [
+                            new IPv4([
+                                255,
+                                255,
+                                255,
+                                255
+                            ]),
+                            32
+                        ]
+                    ],
+                    multicast: [
+                        [
+                            new IPv4([
+                                224,
+                                0,
+                                0,
+                                0
+                            ]),
+                            4
+                        ]
+                    ],
+                    linkLocal: [
+                        [
+                            new IPv4([
+                                169,
+                                254,
+                                0,
+                                0
+                            ]),
+                            16
+                        ]
+                    ],
+                    loopback: [
+                        [
+                            new IPv4([
+                                127,
+                                0,
+                                0,
+                                0
+                            ]),
+                            8
+                        ]
+                    ],
+                    carrierGradeNat: [
+                        [
+                            new IPv4([
+                                100,
+                                64,
+                                0,
+                                0
+                            ]),
+                            10
+                        ]
+                    ],
+                    private: [
+                        [
+                            new IPv4([
+                                10,
+                                0,
+                                0,
+                                0
+                            ]),
+                            8
+                        ],
+                        [
+                            new IPv4([
+                                172,
+                                16,
+                                0,
+                                0
+                            ]),
+                            12
+                        ],
+                        [
+                            new IPv4([
+                                192,
+                                168,
+                                0,
+                                0
+                            ]),
+                            16
+                        ]
+                    ],
+                    reserved: [
+                        [
+                            new IPv4([
+                                192,
+                                0,
+                                0,
+                                0
+                            ]),
+                            24
+                        ],
+                        [
+                            new IPv4([
+                                192,
+                                0,
+                                2,
+                                0
+                            ]),
+                            24
+                        ],
+                        [
+                            new IPv4([
+                                192,
+                                88,
+                                99,
+                                0
+                            ]),
+                            24
+                        ],
+                        [
+                            new IPv4([
+                                198,
+                                18,
+                                0,
+                                0
+                            ]),
+                            15
+                        ],
+                        [
+                            new IPv4([
+                                198,
+                                51,
+                                100,
+                                0
+                            ]),
+                            24
+                        ],
+                        [
+                            new IPv4([
+                                203,
+                                0,
+                                113,
+                                0
+                            ]),
+                            24
+                        ],
+                        [
+                            new IPv4([
+                                240,
+                                0,
+                                0,
+                                0
+                            ]),
+                            4
+                        ]
+                    ],
+                    as112: [
+                        [
+                            new IPv4([
+                                192,
+                                175,
+                                48,
+                                0
+                            ]),
+                            24
+                        ],
+                        [
+                            new IPv4([
+                                192,
+                                31,
+                                196,
+                                0
+                            ]),
+                            24
+                        ]
+                    ],
+                    amt: [
+                        [
+                            new IPv4([
+                                192,
+                                52,
+                                193,
+                                0
+                            ]),
+                            24
+                        ]
+                    ]
+                };
+                IPv4.prototype.kind = function() {
+                    return 'ipv4';
+                };
+                IPv4.prototype.match = function(other, cidrRange) {
+                    let ref;
+                    if (void 0 === cidrRange) {
+                        ref = other;
+                        other = ref[0];
+                        cidrRange = ref[1];
+                    }
+                    if ('ipv4' !== other.kind()) throw new Error('ipaddr: cannot match ipv4 address with non-ipv4 one');
+                    return matchCIDR(this.octets, other.octets, 8, cidrRange);
+                };
+                IPv4.prototype.prefixLengthFromSubnetMask = function() {
+                    let cidr = 0;
+                    let stop = false;
+                    const zerotable = {
+                        0: 8,
+                        128: 7,
+                        192: 6,
+                        224: 5,
+                        240: 4,
+                        248: 3,
+                        252: 2,
+                        254: 1,
+                        255: 0
+                    };
+                    let i, octet, zeros;
+                    for(i = 3; i >= 0; i -= 1){
+                        octet = this.octets[i];
+                        if (!(octet in zerotable)) return null;
+                        zeros = zerotable[octet];
+                        if (stop && 0 !== zeros) return null;
+                        if (8 !== zeros) stop = true;
+                        cidr += zeros;
+                    }
+                    return 32 - cidr;
+                };
+                IPv4.prototype.range = function() {
+                    return ipaddr.subnetMatch(this, this.SpecialRanges);
+                };
+                IPv4.prototype.toByteArray = function() {
+                    return this.octets.slice(0);
+                };
+                IPv4.prototype.toIPv4MappedAddress = function() {
+                    return ipaddr.IPv6.parse(`::ffff:${this.toString()}`);
+                };
+                IPv4.prototype.toNormalizedString = function() {
+                    return this.toString();
+                };
+                IPv4.prototype.toString = function() {
+                    return this.octets.join('.');
+                };
+                return IPv4;
+            }();
+            ipaddr.IPv4.broadcastAddressFromCIDR = function(string) {
+                try {
+                    const cidr = this.parseCIDR(string);
+                    const ipInterfaceOctets = cidr[0].toByteArray();
+                    const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+                    const octets = [];
+                    let i = 0;
+                    while(i < 4){
+                        octets.push(parseInt(ipInterfaceOctets[i], 10) | 255 ^ parseInt(subnetMaskOctets[i], 10));
+                        i++;
+                    }
+                    return new this(octets);
+                } catch (e) {
+                    throw new Error('ipaddr: the address does not have IPv4 CIDR format');
+                }
+            };
+            ipaddr.IPv4.isIPv4 = function(string) {
+                return null !== this.parser(string);
+            };
+            ipaddr.IPv4.isValid = function(string) {
+                try {
+                    new this(this.parser(string));
+                    return true;
+                } catch (e) {
+                    return false;
+                }
+            };
+            ipaddr.IPv4.isValidCIDR = function(string) {
+                try {
+                    this.parseCIDR(string);
+                    return true;
+                } catch (e) {
+                    return false;
+                }
+            };
+            ipaddr.IPv4.isValidFourPartDecimal = function(string) {
+                if (ipaddr.IPv4.isValid(string) && string.match(/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){3}$/)) return true;
+                return false;
+            };
+            ipaddr.IPv4.isValidCIDRFourPartDecimal = function(string) {
+                const match = string.match(/^(.+)\/(\d+)$/);
+                if (!ipaddr.IPv4.isValidCIDR(string) || !match) return false;
+                return ipaddr.IPv4.isValidFourPartDecimal(match[1]);
+            };
+            ipaddr.IPv4.networkAddressFromCIDR = function(string) {
+                let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets;
+                try {
+                    cidr = this.parseCIDR(string);
+                    ipInterfaceOctets = cidr[0].toByteArray();
+                    subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+                    octets = [];
+                    i = 0;
+                    while(i < 4){
+                        octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
+                        i++;
+                    }
+                    return new this(octets);
+                } catch (e) {
+                    throw new Error('ipaddr: the address does not have IPv4 CIDR format');
+                }
+            };
+            ipaddr.IPv4.parse = function(string) {
+                const parts = this.parser(string);
+                if (null === parts) throw new Error('ipaddr: string is not formatted like an IPv4 Address');
+                return new this(parts);
+            };
+            ipaddr.IPv4.parseCIDR = function(string) {
+                let match;
+                if (match = string.match(/^(.+)\/(\d+)$/)) {
+                    const maskLength = parseInt(match[2]);
+                    if (maskLength >= 0 && maskLength <= 32) {
+                        const parsed = [
+                            this.parse(match[1]),
+                            maskLength
+                        ];
+                        Object.defineProperty(parsed, 'toString', {
+                            value: function() {
+                                return this.join('/');
+                            }
+                        });
+                        return parsed;
+                    }
+                }
+                throw new Error('ipaddr: string is not formatted like an IPv4 CIDR range');
+            };
+            ipaddr.IPv4.parser = function(string) {
+                let match, part, value;
+                if (match = string.match(ipv4Regexes.fourOctet)) return function() {
+                    const ref = match.slice(1, 6);
+                    const results = [];
+                    for(let i = 0; i < ref.length; i++){
+                        part = ref[i];
+                        results.push(parseIntAuto(part));
+                    }
+                    return results;
+                }();
+                if (match = string.match(ipv4Regexes.longValue)) {
+                    value = parseIntAuto(match[1]);
+                    if (value > 0xffffffff || value < 0) throw new Error('ipaddr: address outside defined range');
+                    return (function() {
+                        const results = [];
+                        let shift;
+                        for(shift = 0; shift <= 24; shift += 8)results.push(value >> shift & 0xff);
+                        return results;
+                    })().reverse();
+                }
+                if (match = string.match(ipv4Regexes.twoOctet)) return function() {
+                    const ref = match.slice(1, 4);
+                    const results = [];
+                    value = parseIntAuto(ref[1]);
+                    if (value > 0xffffff || value < 0) throw new Error('ipaddr: address outside defined range');
+                    results.push(parseIntAuto(ref[0]));
+                    results.push(value >> 16 & 0xff);
+                    results.push(value >> 8 & 0xff);
+                    results.push(0xff & value);
+                    return results;
+                }();
+                if (match = string.match(ipv4Regexes.threeOctet)) return function() {
+                    const ref = match.slice(1, 5);
+                    const results = [];
+                    value = parseIntAuto(ref[2]);
+                    if (value > 0xffff || value < 0) throw new Error('ipaddr: address outside defined range');
+                    results.push(parseIntAuto(ref[0]));
+                    results.push(parseIntAuto(ref[1]));
+                    results.push(value >> 8 & 0xff);
+                    results.push(0xff & value);
+                    return results;
+                }();
+                return null;
+            };
+            ipaddr.IPv4.subnetMaskFromPrefixLength = function(prefix) {
+                prefix = parseInt(prefix);
+                if (prefix < 0 || prefix > 32) throw new Error('ipaddr: invalid IPv4 prefix length');
+                const octets = [
+                    0,
+                    0,
+                    0,
+                    0
+                ];
+                let j = 0;
+                const filledOctetCount = Math.floor(prefix / 8);
+                while(j < filledOctetCount){
+                    octets[j] = 255;
+                    j++;
+                }
+                if (filledOctetCount < 4) octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;
+                return new this(octets);
+            };
+            ipaddr.IPv6 = function() {
+                function IPv6(parts, zoneId) {
+                    let i, part;
+                    if (16 === parts.length) {
+                        this.parts = [];
+                        for(i = 0; i <= 14; i += 2)this.parts.push(parts[i] << 8 | parts[i + 1]);
+                    } else if (8 === parts.length) this.parts = parts;
+                    else throw new Error('ipaddr: ipv6 part count should be 8 or 16');
+                    for(i = 0; i < this.parts.length; i++){
+                        part = this.parts[i];
+                        if (!(0 <= part && part <= 0xffff)) throw new Error('ipaddr: ipv6 part should fit in 16 bits');
+                    }
+                    if (zoneId) this.zoneId = zoneId;
+                }
+                IPv6.prototype.SpecialRanges = {
+                    unspecified: [
+                        new IPv6([
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        128
+                    ],
+                    linkLocal: [
+                        new IPv6([
+                            0xfe80,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        10
+                    ],
+                    multicast: [
+                        new IPv6([
+                            0xff00,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        8
+                    ],
+                    loopback: [
+                        new IPv6([
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            1
+                        ]),
+                        128
+                    ],
+                    uniqueLocal: [
+                        new IPv6([
+                            0xfc00,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        7
+                    ],
+                    ipv4Mapped: [
+                        new IPv6([
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0xffff,
+                            0,
+                            0
+                        ]),
+                        96
+                    ],
+                    discard: [
+                        new IPv6([
+                            0x100,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        64
+                    ],
+                    rfc6145: [
+                        new IPv6([
+                            0,
+                            0,
+                            0,
+                            0,
+                            0xffff,
+                            0,
+                            0,
+                            0
+                        ]),
+                        96
+                    ],
+                    rfc6052: [
+                        new IPv6([
+                            0x64,
+                            0xff9b,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        96
+                    ],
+                    '6to4': [
+                        new IPv6([
+                            0x2002,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        16
+                    ],
+                    teredo: [
+                        new IPv6([
+                            0x2001,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        32
+                    ],
+                    benchmarking: [
+                        new IPv6([
+                            0x2001,
+                            0x2,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        48
+                    ],
+                    amt: [
+                        new IPv6([
+                            0x2001,
+                            0x3,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        32
+                    ],
+                    as112v6: [
+                        [
+                            new IPv6([
+                                0x2001,
+                                0x4,
+                                0x112,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            48
+                        ],
+                        [
+                            new IPv6([
+                                0x2620,
+                                0x4f,
+                                0x8000,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            48
+                        ]
+                    ],
+                    deprecated: [
+                        new IPv6([
+                            0x2001,
+                            0x10,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        28
+                    ],
+                    orchid2: [
+                        new IPv6([
+                            0x2001,
+                            0x20,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        28
+                    ],
+                    droneRemoteIdProtocolEntityTags: [
+                        new IPv6([
+                            0x2001,
+                            0x30,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0,
+                            0
+                        ]),
+                        28
+                    ],
+                    reserved: [
+                        [
+                            new IPv6([
+                                0x2001,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            23
+                        ],
+                        [
+                            new IPv6([
+                                0x2001,
+                                0xdb8,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0,
+                                0
+                            ]),
+                            32
+                        ]
+                    ]
+                };
+                IPv6.prototype.isIPv4MappedAddress = function() {
+                    return 'ipv4Mapped' === this.range();
+                };
+                IPv6.prototype.kind = function() {
+                    return 'ipv6';
+                };
+                IPv6.prototype.match = function(other, cidrRange) {
+                    let ref;
+                    if (void 0 === cidrRange) {
+                        ref = other;
+                        other = ref[0];
+                        cidrRange = ref[1];
+                    }
+                    if ('ipv6' !== other.kind()) throw new Error('ipaddr: cannot match ipv6 address with non-ipv6 one');
+                    return matchCIDR(this.parts, other.parts, 16, cidrRange);
+                };
+                IPv6.prototype.prefixLengthFromSubnetMask = function() {
+                    let cidr = 0;
+                    let stop = false;
+                    const zerotable = {
+                        0: 16,
+                        32768: 15,
+                        49152: 14,
+                        57344: 13,
+                        61440: 12,
+                        63488: 11,
+                        64512: 10,
+                        65024: 9,
+                        65280: 8,
+                        65408: 7,
+                        65472: 6,
+                        65504: 5,
+                        65520: 4,
+                        65528: 3,
+                        65532: 2,
+                        65534: 1,
+                        65535: 0
+                    };
+                    let part, zeros;
+                    for(let i = 7; i >= 0; i -= 1){
+                        part = this.parts[i];
+                        if (!(part in zerotable)) return null;
+                        zeros = zerotable[part];
+                        if (stop && 0 !== zeros) return null;
+                        if (16 !== zeros) stop = true;
+                        cidr += zeros;
+                    }
+                    return 128 - cidr;
+                };
+                IPv6.prototype.range = function() {
+                    return ipaddr.subnetMatch(this, this.SpecialRanges);
+                };
+                IPv6.prototype.toByteArray = function() {
+                    let part;
+                    const bytes = [];
+                    const ref = this.parts;
+                    for(let i = 0; i < ref.length; i++){
+                        part = ref[i];
+                        bytes.push(part >> 8);
+                        bytes.push(0xff & part);
+                    }
+                    return bytes;
+                };
+                IPv6.prototype.toFixedLengthString = function() {
+                    const addr = (function() {
+                        const results = [];
+                        for(let i = 0; i < this.parts.length; i++)results.push(padPart(this.parts[i].toString(16), 4));
+                        return results;
+                    }).call(this).join(':');
+                    let suffix = '';
+                    if (this.zoneId) suffix = `%${this.zoneId}`;
+                    return addr + suffix;
+                };
+                IPv6.prototype.toIPv4Address = function() {
+                    if (!this.isIPv4MappedAddress()) throw new Error('ipaddr: trying to convert a generic ipv6 address to ipv4');
+                    const ref = this.parts.slice(-2);
+                    const high = ref[0];
+                    const low = ref[1];
+                    return new ipaddr.IPv4([
+                        high >> 8,
+                        0xff & high,
+                        low >> 8,
+                        0xff & low
+                    ]);
+                };
+                IPv6.prototype.toNormalizedString = function() {
+                    const addr = (function() {
+                        const results = [];
+                        for(let i = 0; i < this.parts.length; i++)results.push(this.parts[i].toString(16));
+                        return results;
+                    }).call(this).join(':');
+                    let suffix = '';
+                    if (this.zoneId) suffix = `%${this.zoneId}`;
+                    return addr + suffix;
+                };
+                IPv6.prototype.toRFC5952String = function() {
+                    const regex = /((^|:)(0(:|$)){2,})/g;
+                    const string = this.toNormalizedString();
+                    let bestMatchIndex = 0;
+                    let bestMatchLength = -1;
+                    let match;
+                    while(match = regex.exec(string))if (match[0].length > bestMatchLength) {
+                        bestMatchIndex = match.index;
+                        bestMatchLength = match[0].length;
+                    }
+                    if (bestMatchLength < 0) return string;
+                    return `${string.substring(0, bestMatchIndex)}::${string.substring(bestMatchIndex + bestMatchLength)}`;
+                };
+                IPv6.prototype.toString = function() {
+                    return this.toRFC5952String();
+                };
+                return IPv6;
+            }();
+            ipaddr.IPv6.broadcastAddressFromCIDR = function(string) {
+                try {
+                    const cidr = this.parseCIDR(string);
+                    const ipInterfaceOctets = cidr[0].toByteArray();
+                    const subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+                    const octets = [];
+                    let i = 0;
+                    while(i < 16){
+                        octets.push(parseInt(ipInterfaceOctets[i], 10) | 255 ^ parseInt(subnetMaskOctets[i], 10));
+                        i++;
+                    }
+                    return new this(octets);
+                } catch (e) {
+                    throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`);
+                }
+            };
+            ipaddr.IPv6.isIPv6 = function(string) {
+                return null !== this.parser(string);
+            };
+            ipaddr.IPv6.isValid = function(string) {
+                if ('string' == typeof string && -1 === string.indexOf(':')) return false;
+                try {
+                    const addr = this.parser(string);
+                    new this(addr.parts, addr.zoneId);
+                    return true;
+                } catch (e) {
+                    return false;
+                }
+            };
+            ipaddr.IPv6.isValidCIDR = function(string) {
+                if ('string' == typeof string && -1 === string.indexOf(':')) return false;
+                try {
+                    this.parseCIDR(string);
+                    return true;
+                } catch (e) {
+                    return false;
+                }
+            };
+            ipaddr.IPv6.networkAddressFromCIDR = function(string) {
+                let cidr, i, ipInterfaceOctets, octets, subnetMaskOctets;
+                try {
+                    cidr = this.parseCIDR(string);
+                    ipInterfaceOctets = cidr[0].toByteArray();
+                    subnetMaskOctets = this.subnetMaskFromPrefixLength(cidr[1]).toByteArray();
+                    octets = [];
+                    i = 0;
+                    while(i < 16){
+                        octets.push(parseInt(ipInterfaceOctets[i], 10) & parseInt(subnetMaskOctets[i], 10));
+                        i++;
+                    }
+                    return new this(octets);
+                } catch (e) {
+                    throw new Error(`ipaddr: the address does not have IPv6 CIDR format (${e})`);
+                }
+            };
+            ipaddr.IPv6.parse = function(string) {
+                const addr = this.parser(string);
+                if (null === addr.parts) throw new Error('ipaddr: string is not formatted like an IPv6 Address');
+                return new this(addr.parts, addr.zoneId);
+            };
+            ipaddr.IPv6.parseCIDR = function(string) {
+                let maskLength, match, parsed;
+                if (match = string.match(/^(.+)\/(\d+)$/)) {
+                    maskLength = parseInt(match[2]);
+                    if (maskLength >= 0 && maskLength <= 128) {
+                        parsed = [
+                            this.parse(match[1]),
+                            maskLength
+                        ];
+                        Object.defineProperty(parsed, 'toString', {
+                            value: function() {
+                                return this.join('/');
+                            }
+                        });
+                        return parsed;
+                    }
+                }
+                throw new Error('ipaddr: string is not formatted like an IPv6 CIDR range');
+            };
+            ipaddr.IPv6.parser = function(string) {
+                let addr, i, match, octet, octets, zoneId;
+                if (match = string.match(ipv6Regexes.deprecatedTransitional)) return this.parser(`::ffff:${match[1]}`);
+                if (ipv6Regexes.native.test(string)) return expandIPv6(string, 8);
+                if (match = string.match(ipv6Regexes.transitional)) {
+                    zoneId = match[6] || '';
+                    addr = match[1];
+                    if (!match[1].endsWith('::')) addr = addr.slice(0, -1);
+                    addr = expandIPv6(addr + zoneId, 6);
+                    if (addr.parts) {
+                        octets = [
+                            parseInt(match[2]),
+                            parseInt(match[3]),
+                            parseInt(match[4]),
+                            parseInt(match[5])
+                        ];
+                        for(i = 0; i < octets.length; i++){
+                            octet = octets[i];
+                            if (!(0 <= octet && octet <= 255)) return null;
+                        }
+                        addr.parts.push(octets[0] << 8 | octets[1]);
+                        addr.parts.push(octets[2] << 8 | octets[3]);
+                        return {
+                            parts: addr.parts,
+                            zoneId: addr.zoneId
+                        };
+                    }
+                }
+                return null;
+            };
+            ipaddr.IPv6.subnetMaskFromPrefixLength = function(prefix) {
+                prefix = parseInt(prefix);
+                if (prefix < 0 || prefix > 128) throw new Error('ipaddr: invalid IPv6 prefix length');
+                const octets = [
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0,
+                    0
+                ];
+                let j = 0;
+                const filledOctetCount = Math.floor(prefix / 8);
+                while(j < filledOctetCount){
+                    octets[j] = 255;
+                    j++;
+                }
+                if (filledOctetCount < 16) octets[filledOctetCount] = Math.pow(2, prefix % 8) - 1 << 8 - prefix % 8;
+                return new this(octets);
+            };
+            ipaddr.fromByteArray = function(bytes) {
+                const length = bytes.length;
+                if (4 === length) return new ipaddr.IPv4(bytes);
+                if (16 === length) return new ipaddr.IPv6(bytes);
+                throw new Error('ipaddr: the binary input is neither an IPv6 nor IPv4 address');
+            };
+            ipaddr.isValid = function(string) {
+                return ipaddr.IPv6.isValid(string) || ipaddr.IPv4.isValid(string);
+            };
+            ipaddr.isValidCIDR = function(string) {
+                return ipaddr.IPv6.isValidCIDR(string) || ipaddr.IPv4.isValidCIDR(string);
+            };
+            ipaddr.parse = function(string) {
+                if (ipaddr.IPv6.isValid(string)) return ipaddr.IPv6.parse(string);
+                if (ipaddr.IPv4.isValid(string)) return ipaddr.IPv4.parse(string);
+                throw new Error('ipaddr: the address has neither IPv6 nor IPv4 format');
+            };
+            ipaddr.parseCIDR = function(string) {
+                try {
+                    return ipaddr.IPv6.parseCIDR(string);
+                } catch (e) {
+                    try {
+                        return ipaddr.IPv4.parseCIDR(string);
+                    } catch (e2) {
+                        throw new Error('ipaddr: the address has neither IPv6 nor IPv4 CIDR format');
+                    }
+                }
+            };
+            ipaddr.process = function(string) {
+                const addr = this.parse(string);
+                if ('ipv6' === addr.kind() && addr.isIPv4MappedAddress()) return addr.toIPv4Address();
+                return addr;
+            };
+            ipaddr.subnetMatch = function(address, rangeList, defaultName) {
+                let i, rangeName, rangeSubnets, subnet;
+                if (null == defaultName) defaultName = 'unicast';
+                for(rangeName in rangeList)if (Object.prototype.hasOwnProperty.call(rangeList, rangeName)) {
+                    rangeSubnets = rangeList[rangeName];
+                    if (rangeSubnets[0] && !(rangeSubnets[0] instanceof Array)) rangeSubnets = [
+                        rangeSubnets
+                    ];
+                    for(i = 0; i < rangeSubnets.length; i++){
+                        subnet = rangeSubnets[i];
+                        if (address.kind() === subnet[0].kind() && address.match.apply(address, subnet)) return rangeName;
+                    }
+                }
+                return defaultName;
+            };
+            if (module.exports) module.exports = ipaddr;
+            else root.ipaddr = ipaddr;
+        })(this);
+    },
+    async_hooks (module) {
+        module.exports = __rspack_createRequire_require("async_hooks");
+    },
+    child_process (module) {
+        module.exports = __rspack_createRequire_require("child_process");
+    },
+    crypto (module) {
+        module.exports = __rspack_createRequire_require("crypto");
+    },
+    fs (module) {
+        module.exports = __rspack_createRequire_require("fs");
+    },
+    os (module) {
+        module.exports = __rspack_createRequire_require("os");
+    },
+    path (module) {
+        module.exports = __rspack_createRequire_require("path");
+    },
+    stream (module) {
+        module.exports = __rspack_createRequire_require("stream");
+    },
+    tty (module) {
+        module.exports = __rspack_createRequire_require("tty");
+    },
+    url (module) {
+        module.exports = __rspack_createRequire_require("url");
+    },
+    util (module) {
+        module.exports = __rspack_createRequire_require("util");
+    },
+    zlib (module) {
+        module.exports = __rspack_createRequire_require("zlib");
+    }
+});
+const minPort = 1024;
+const maxPort = 65535;
+const getLocalHosts = ()=>{
+    const interfaces = __rspack_external_node_os_74b4b876.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 = __rspack_external_node_net_0373943e.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 __rspack_external_ws.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 ipaddr = __webpack_require__("./node_modules/.pnpm/ipaddr.js@2.3.0/node_modules/ipaddr.js/lib/ipaddr.js");
+var ipaddr_default = /*#__PURE__*/ __webpack_require__.n(ipaddr);
+const { styleText: styleText } = __rspack_external_node_util_1b29d436;
+const server_require = createRequire(import.meta.url);
+if (!process.env.RSPACK_SERVE) process.env.RSPACK_SERVE = 'true';
+const getConnect = async ()=>{
+    const { connect } = await import("connect-next");
+    return connect;
+};
+const getChokidar = ()=>import("chokidar");
+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(__rspack_external_node_os_74b4b876.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_default().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_default().parse(gatewayOrFamily);
+        for (const addresses of Object.values(__rspack_external_node_os_74b4b876.networkInterfaces()))for (const { cidr } of addresses){
+            const net = ipaddr_default().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");
+        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 (__rspack_external_node_fs_5ea92f0c.statSync(__rspack_external_node_path_c5b9b54f.join(dir, 'package.json')).isFile()) break;
+            } catch  {}
+            const parent = __rspack_external_node_path_c5b9b54f.dirname(dir);
+            if (dir === parent) {
+                dir = void 0;
+                break;
+            }
+            dir = parent;
+        }
+        if (!dir) return __rspack_external_node_path_c5b9b54f.resolve(cwd, '.cache/rspack-dev-server');
+        if ('1' === process.versions.pnp) return __rspack_external_node_path_c5b9b54f.resolve(dir, '.pnp/.cache/rspack-dev-server');
+        if ('3' === process.versions.pnp) return __rspack_external_node_path_c5b9b54f.resolve(dir, '.yarn/.cache/rspack-dev-server');
+        return __rspack_external_node_path_c5b9b54f.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: __rspack_external_node_path_c5b9b54f.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 = __rspack_external_node_fs_5ea92f0c.lstatSync(__rspack_external_node_fs_5ea92f0c.realpathSync(item)).isFile();
+                        } catch  {}
+                        return stats ? __rspack_external_node_fs_5ea92f0c.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 = __rspack_external_node_path_c5b9b54f.join(certificateDir, 'server.pem');
+                let certificateExists;
+                try {
+                    const certificate = await __rspack_external_node_fs_5ea92f0c.promises.stat(certificatePath);
+                    certificateExists = certificate.isFile();
+                } catch  {
+                    certificateExists = false;
+                }
+                if (certificateExists) {
+                    const certificateTtl = 86400000;
+                    const certificateStat = await __rspack_external_node_fs_5ea92f0c.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 __rspack_external_node_fs_5ea92f0c.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 __rspack_external_node_fs_5ea92f0c.promises.mkdir(certificateDir, {
+                        recursive: true
+                    });
+                    await __rspack_external_node_fs_5ea92f0c.promises.writeFile(certificatePath, pems.private + pems.cert, {
+                        encoding: 'utf8'
+                    });
+                }
+                fakeCert = await __rspack_external_node_fs_5ea92f0c.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\\' : __rspack_external_node_os_74b4b876.tmpdir();
+            const pipeName = 'webpack-dev-server.sock';
+            options.ipc = __rspack_external_node_path_c5b9b54f.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
+                }
+            ];
+        };
+        let normalizedOpens = [];
+        if (void 0 === options.open) ;
+        else if ('boolean' == typeof options.open) {
+            if (options.open) normalizedOpens = [
+                {
+                    target: '<url>',
+                    options: defaultOpenOptions
+                }
+            ];
+        } else if ('string' == typeof options.open) normalizedOpens = [
+            {
+                target: options.open,
+                options: defaultOpenOptions
+            }
+        ];
+        else if (Array.isArray(options.open)) for (const item of options.open){
+            if ('string' == typeof item) {
+                normalizedOpens.push({
+                    target: item,
+                    options: defaultOpenOptions
+                });
+                continue;
+            }
+            normalizedOpens.push(...getOpenItemsFromObject(item));
+        }
+        else normalizedOpens = [
+            ...getOpenItemsFromObject(options.open)
+        ];
+        options.open = normalizedOpens;
+        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;
+        let clientTransport = 'object' == typeof this.options.client && null !== this.options.client && void 0 !== this.options.client.webSocketTransport ? this.options.client.webSocketTransport : '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("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: '@rspack/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.2/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);
+                __rspack_external_node_util_1b29d436.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: '@rspack/dev-middleware',
+                middleware: this.middleware
+            });
+        }
+        const staticOptions = this.options.static;
+        const useStatic = staticOptions.length > 0;
+        const serveStatic = useStatic ? (await import("./0~serve-static.js").then(__webpack_require__.t.bind(__webpack_require__, "./node_modules/.pnpm/serve-static@2.2.1/node_modules/serve-static/index.js", 23))).default : null;
+        if (useStatic) for (const staticOption of staticOptions)for (const publicPath of staticOption.publicPath)middlewares.push({
+            name: 'serve-static',
+            path: publicPath,
+            middleware: serveStatic(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: '@rspack/dev-middleware',
+                middleware: this.middleware
+            });
+            if (useStatic) for (const staticOption of staticOptions)for (const publicPath of staticOption.publicPath)middlewares.push({
+                name: 'serve-static',
+                path: publicPath,
+                middleware: serveStatic(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) this.middleware = devMiddleware(this.compiler, this.options.devMiddleware);
+            return this.middleware;
+        };
+        for (const i of middlewares)if ('@rspack/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");
+        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)=>__rspack_external_node_url_e96de089.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_default().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(`  ${styleText('white', '➜')}  ${styleText([
+                'white',
+                'dim'
+            ], 'Local:')}    ${styleText('cyan', local)}`);
+            if (networkUrlIPv4) urlLogs.push(`  ${styleText('white', '➜')}  ${styleText([
+                'white',
+                'dim'
+            ], 'Network:')}  ${styleText('cyan', networkUrlIPv4)}`);
+            else if (networkUrlIPv6) urlLogs.push(`  ${styleText('white', '➜')}  ${styleText([
+                'white',
+                'dim'
+            ], 'Network:')}  ${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_default().IPv4.isValid(hostname) || ipaddr_default().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) {
+                    __rspack_external_node_fs_5ea92f0c.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 __rspack_external_node_fs_5ea92f0c.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 { __webpack_require__temp as __webpack_require__, Server as RspackDevServer };