@rsbuild/core 1.4.11 → 1.4.13

package/dist/index.js

@@ -1,5 +1,5 @@
 /*! For license information please see index.js.LICENSE.txt */
-let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin, isDockerCached, cachedResult;
+let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin, isDockerCached, cachedResult, hmrClientPath, overlayClientPath;
 import { createRequire } from "node:module";
 import { logger } from "../compiled/rslog/index.js";
 import node_path, { dirname, isAbsolute as external_node_path_isAbsolute, join, posix, relative, sep } from "node:path";
@@ -9,15 +9,13 @@ import node_fs, { constants as external_node_fs_constants, existsSync } from "no
 import { EventEmitter } from "events";
 import node_os, { constants as external_node_os_constants } from "node:os";
 import node_process from "node:process";
-import rspack_chain from "../compiled/rspack-chain/index.js";
 import { isPromise, isRegExp } from "node:util/types";
 import { promisify as external_node_util_promisify } from "node:util";
-import { lookup } from "../compiled/mrmime/index.js";
 import node_zlib from "node:zlib";
 import { Buffer as external_node_buffer_Buffer } from "node:buffer";
 import node_child_process, { execFile } from "node:child_process";
 import promises from "node:fs/promises";
-var EsmMode, __webpack_modules__ = {
+var superClass, superClass1, EsmMode, __webpack_modules__ = {
     "../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         let clone = __webpack_require__("../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js"), typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"), isPlainObject = __webpack_require__("../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js");
         module.exports = function cloneDeep(val, instanceClone) {
@@ -176,6 +174,298 @@ var EsmMode, __webpack_modules__ = {
             return null != val && 'object' == typeof val && !1 === Array.isArray(val);
         };
     },
+    "../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/array.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.arrayToString = void 0, exports.arrayToString = (array, space, next)=>{
+            let values = array.map(function(value, index) {
+                let result = next(value, index);
+                return void 0 === result ? String(result) : space + result.split("\n").join(`\n${space}`);
+            }).join(space ? ",\n" : ","), eol = space && values ? "\n" : "";
+            return `[${eol}${values}${eol}]`;
+        };
+    },
+    "../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/function.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.FunctionParser = exports.dedentFunction = exports.functionToString = exports.USED_METHOD_KEY = void 0;
+        let quote_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/quote.js"), METHOD_NAMES_ARE_QUOTED = '"' === ({
+            " " () {}
+        })[" "].toString().charAt(0), FUNCTION_PREFIXES = {
+            Function: "function ",
+            GeneratorFunction: "function* ",
+            AsyncFunction: "async function ",
+            AsyncGeneratorFunction: "async function* "
+        }, METHOD_PREFIXES = {
+            Function: "",
+            GeneratorFunction: "*",
+            AsyncFunction: "async ",
+            AsyncGeneratorFunction: "async *"
+        }, TOKENS_PRECEDING_REGEXPS = new Set("case delete else in instanceof new return throw typeof void , ; : + - ! ~ & | ^ * / % < > ? =".split(" "));
+        function dedentFunction(fnString) {
+            let found;
+            for (let line of fnString.split("\n").slice(1)){
+                let m = /^[\s\t]+/.exec(line);
+                if (!m) return fnString;
+                let [str] = m;
+                void 0 === found ? found = str : str.length < found.length && (found = str);
+            }
+            return found ? fnString.split(`\n${found}`).join("\n") : fnString;
+        }
+        exports.USED_METHOD_KEY = new WeakSet(), exports.functionToString = (fn, space, next, key)=>{
+            let name = "string" == typeof key ? key : void 0;
+            return void 0 !== name && exports.USED_METHOD_KEY.add(fn), new FunctionParser(fn, space, next, name).stringify();
+        }, exports.dedentFunction = dedentFunction;
+        class FunctionParser {
+            constructor(fn, indent, next, key){
+                this.fn = fn, this.indent = indent, this.next = next, this.key = key, this.pos = 0, this.hadKeyword = !1, this.fnString = Function.prototype.toString.call(fn), this.fnType = fn.constructor.name, this.keyQuote = void 0 === key ? "" : quote_1.quoteKey(key, next), this.keyPrefix = void 0 === key ? "" : `${this.keyQuote}:${indent ? " " : ""}`, this.isMethodCandidate = void 0 !== key && ("" === this.fn.name || this.fn.name === key);
+            }
+            stringify() {
+                let value = this.tryParse();
+                return value ? dedentFunction(value) : `${this.keyPrefix}void ${this.next(this.fnString)}`;
+            }
+            getPrefix() {
+                return this.isMethodCandidate && !this.hadKeyword ? METHOD_PREFIXES[this.fnType] + this.keyQuote : this.keyPrefix + FUNCTION_PREFIXES[this.fnType];
+            }
+            tryParse() {
+                if ("}" !== this.fnString[this.fnString.length - 1]) return this.keyPrefix + this.fnString;
+                if (this.fn.name) {
+                    let result = this.tryStrippingName();
+                    if (result) return result;
+                }
+                let prevPos = this.pos;
+                if ("class" === this.consumeSyntax()) return this.fnString;
+                if (this.pos = prevPos, this.tryParsePrefixTokens()) {
+                    let result = this.tryStrippingName();
+                    if (result) return result;
+                    let offset = this.pos;
+                    switch(this.consumeSyntax("WORD_LIKE")){
+                        case "WORD_LIKE":
+                            this.isMethodCandidate && !this.hadKeyword && (offset = this.pos);
+                        case "()":
+                            if ("=>" === this.fnString.substr(this.pos, 2)) return this.keyPrefix + this.fnString;
+                            this.pos = offset;
+                        case '"':
+                        case "'":
+                        case "[]":
+                            return this.getPrefix() + this.fnString.substr(this.pos);
+                    }
+                }
+            }
+            tryStrippingName() {
+                if (METHOD_NAMES_ARE_QUOTED) return;
+                let start = this.pos, prefix = this.fnString.substr(this.pos, this.fn.name.length);
+                if (prefix === this.fn.name && (this.pos += prefix.length, "()" === this.consumeSyntax() && "{}" === this.consumeSyntax() && this.pos === this.fnString.length)) return (this.isMethodCandidate || !quote_1.isValidVariableName(prefix)) && (start += prefix.length), this.getPrefix() + this.fnString.substr(start);
+                this.pos = start;
+            }
+            tryParsePrefixTokens() {
+                let posPrev = this.pos;
+                switch(this.hadKeyword = !1, this.fnType){
+                    case "AsyncFunction":
+                        if ("async" !== this.consumeSyntax()) return !1;
+                        posPrev = this.pos;
+                    case "Function":
+                        return "function" === this.consumeSyntax() ? this.hadKeyword = !0 : this.pos = posPrev, !0;
+                    case "AsyncGeneratorFunction":
+                        if ("async" !== this.consumeSyntax()) return !1;
+                    case "GeneratorFunction":
+                        let token = this.consumeSyntax();
+                        return "function" === token && (token = this.consumeSyntax(), this.hadKeyword = !0), "*" === token;
+                }
+            }
+            consumeSyntax(wordLikeToken) {
+                let m = this.consumeMatch(/^(?:([A-Za-z_0-9$\xA0-\uFFFF]+)|=>|\+\+|\-\-|.)/);
+                if (!m) return;
+                let [token, match] = m;
+                if (this.consumeWhitespace(), match) return wordLikeToken || match;
+                switch(token){
+                    case "(":
+                        return this.consumeSyntaxUntil("(", ")");
+                    case "[":
+                        return this.consumeSyntaxUntil("[", "]");
+                    case "{":
+                        return this.consumeSyntaxUntil("{", "}");
+                    case "`":
+                        return this.consumeTemplate();
+                    case '"':
+                        return this.consumeRegExp(/^(?:[^\\"]|\\.)*"/, '"');
+                    case "'":
+                        return this.consumeRegExp(/^(?:[^\\']|\\.)*'/, "'");
+                }
+                return token;
+            }
+            consumeSyntaxUntil(startToken, endToken) {
+                let isRegExpAllowed = !0;
+                for(;;){
+                    let token = this.consumeSyntax();
+                    if (token === endToken) return startToken + endToken;
+                    if (!token || ")" === token || "]" === token || "}" === token) return;
+                    "/" === token && isRegExpAllowed && this.consumeMatch(/^(?:\\.|[^\\\/\n[]|\[(?:\\.|[^\]])*\])+\/[a-z]*/) ? (isRegExpAllowed = !1, this.consumeWhitespace()) : isRegExpAllowed = TOKENS_PRECEDING_REGEXPS.has(token);
+                }
+            }
+            consumeMatch(re) {
+                let m = re.exec(this.fnString.substr(this.pos));
+                return m && (this.pos += m[0].length), m;
+            }
+            consumeRegExp(re, token) {
+                let m = re.exec(this.fnString.substr(this.pos));
+                if (m) return this.pos += m[0].length, this.consumeWhitespace(), token;
+            }
+            consumeTemplate() {
+                for(;;){
+                    if (this.consumeMatch(/^(?:[^`$\\]|\\.|\$(?!{))*/), "`" === this.fnString[this.pos]) return this.pos++, this.consumeWhitespace(), "`";
+                    if (!("${" === this.fnString.substr(this.pos, 2) && (this.pos += 2, this.consumeWhitespace(), this.consumeSyntaxUntil("{", "}")))) return;
+                }
+            }
+            consumeWhitespace() {
+                this.consumeMatch(/^(?:\s|\/\/.*|\/\*[^]*?\*\/)*/);
+            }
+        }
+        exports.FunctionParser = FunctionParser;
+    },
+    "../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        exports.stringify = void 0;
+        let stringify_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/stringify.js"), quote_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/quote.js"), ROOT_SENTINEL = Symbol("root");
+        exports.stringify = function(value, replacer, indent, options = {}) {
+            var replacer1;
+            let space = "string" == typeof indent ? indent : " ".repeat(indent || 0), path = [], stack = new Set(), tracking = new Map(), unpack = new Map(), valueCount = 0, { maxDepth = 100, references = !1, skipUndefinedProperties = !1, maxValues = 100000 } = options, valueToString = (replacer1 = replacer) ? (value, space, next, key)=>replacer1(value, space, (value)=>stringify_1.toString(value, space, next, key), key) : stringify_1.toString, onNext = (value, key)=>{
+                if (++valueCount > maxValues || skipUndefinedProperties && void 0 === value || path.length > maxDepth) return;
+                if (void 0 === key) return valueToString(value, space, onNext, key);
+                path.push(key);
+                let result = builder(value, key === ROOT_SENTINEL ? void 0 : key);
+                return path.pop(), result;
+            }, builder = references ? (value, key)=>{
+                if (null !== value && ("object" == typeof value || "function" == typeof value || "symbol" == typeof value)) {
+                    if (tracking.has(value)) return unpack.set(path.slice(1), tracking.get(value)), valueToString(void 0, space, onNext, key);
+                    tracking.set(value, path.slice(1));
+                }
+                return valueToString(value, space, onNext, key);
+            } : (value, key)=>{
+                if (stack.has(value)) return;
+                stack.add(value);
+                let result = valueToString(value, space, onNext, key);
+                return stack.delete(value), result;
+            }, result = onNext(value, ROOT_SENTINEL);
+            if (unpack.size) {
+                let sp = space ? " " : "", eol = space ? "\n" : "", wrapper = `var x${sp}=${sp}${result};${eol}`;
+                for (let [key, value] of unpack.entries()){
+                    let keyPath = quote_1.stringifyPath(key, onNext), valuePath = quote_1.stringifyPath(value, onNext);
+                    wrapper += `x${keyPath}${sp}=${sp}x${valuePath};${eol}`;
+                }
+                return `(function${sp}()${sp}{${eol}${wrapper}return x;${eol}}())`;
+            }
+            return result;
+        };
+    },
+    "../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/object.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.objectToString = void 0;
+        let quote_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/quote.js"), function_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/function.js"), array_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/array.js");
+        exports.objectToString = (value, space, next, key)=>{
+            if ("function" == typeof Buffer && Buffer.isBuffer(value)) return `Buffer.from(${next(value.toString("base64"))}, 'base64')`;
+            if ("object" == typeof global && value === global) return globalToString(value, space, next, key);
+            let toString = OBJECT_TYPES[Object.prototype.toString.call(value)];
+            return toString ? toString(value, space, next, key) : void 0;
+        };
+        let globalToString = (value, space, next)=>`Function(${next("return this")})()`, OBJECT_TYPES = {
+            "[object Array]": array_1.arrayToString,
+            "[object Object]": (obj, indent, next, key)=>{
+                let eol = indent ? "\n" : "", space = indent ? " " : "", values = Object.keys(obj).reduce(function(values, key) {
+                    let fn = obj[key], result = next(fn, key);
+                    if (void 0 === result) return values;
+                    let value = result.split("\n").join(`\n${indent}`);
+                    return function_1.USED_METHOD_KEY.has(fn) ? values.push(`${indent}${value}`) : values.push(`${indent}${quote_1.quoteKey(key, next)}:${space}${value}`), values;
+                }, []).join(`,${eol}`);
+                return "" === values ? "{}" : `{${eol}${values}${eol}}`;
+            },
+            "[object Error]": (error, space, next)=>`new Error(${next(error.message)})`,
+            "[object Date]": (date)=>`new Date(${date.getTime()})`,
+            "[object String]": (str, space, next)=>`new String(${next(str.toString())})`,
+            "[object Number]": (num)=>`new Number(${num})`,
+            "[object Boolean]": (bool)=>`new Boolean(${bool})`,
+            "[object Set]": (set, space, next)=>`new Set(${next(Array.from(set))})`,
+            "[object Map]": (map, space, next)=>`new Map(${next(Array.from(map))})`,
+            "[object RegExp]": String,
+            "[object global]": globalToString,
+            "[object Window]": globalToString
+        };
+    },
+    "../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/quote.js": function(__unused_webpack_module, exports) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.stringifyPath = exports.quoteKey = exports.isValidVariableName = exports.IS_VALID_IDENTIFIER = exports.quoteString = void 0;
+        let ESCAPABLE = /[\\\'\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, META_CHARS = new Map([
+            [
+                "\b",
+                "\\b"
+            ],
+            [
+                "\t",
+                "\\t"
+            ],
+            [
+                "\n",
+                "\\n"
+            ],
+            [
+                "\f",
+                "\\f"
+            ],
+            [
+                "\r",
+                "\\r"
+            ],
+            [
+                "'",
+                "\\'"
+            ],
+            [
+                '"',
+                '\\"'
+            ],
+            [
+                "\\",
+                "\\\\"
+            ]
+        ]);
+        function escapeChar(char) {
+            return META_CHARS.get(char) || `\\u${`0000${char.charCodeAt(0).toString(16)}`.slice(-4)}`;
+        }
+        exports.quoteString = function(str) {
+            return `'${str.replace(ESCAPABLE, escapeChar)}'`;
+        };
+        let RESERVED_WORDS = new Set("break else new var case finally return void catch for switch while continue function this with default if throw delete in try do instanceof typeof abstract enum int short boolean export interface static byte extends long super char final native synchronized class float package throws const goto private transient debugger implements protected volatile double import public let yield".split(" "));
+        function isValidVariableName(name) {
+            return "string" == typeof name && !RESERVED_WORDS.has(name) && exports.IS_VALID_IDENTIFIER.test(name);
+        }
+        exports.IS_VALID_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/, exports.isValidVariableName = isValidVariableName, exports.quoteKey = function(key, next) {
+            return isValidVariableName(key) ? key : next(key);
+        }, exports.stringifyPath = function(path, next) {
+            let result = "";
+            for (let key of path)isValidVariableName(key) ? result += `.${key}` : result += `[${next(key)}]`;
+            return result;
+        };
+    },
+    "../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/stringify.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.toString = void 0;
+        let quote_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/quote.js"), object_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/object.js"), function_1 = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/function.js"), PRIMITIVE_TYPES = {
+            string: quote_1.quoteString,
+            number: (value)=>Object.is(value, -0) ? "-0" : String(value),
+            boolean: String,
+            symbol: (value, space, next)=>{
+                let key = Symbol.keyFor(value);
+                return void 0 !== key ? `Symbol.for(${next(key)})` : `Symbol(${next(value.description)})`;
+            },
+            bigint: (value, space, next)=>`BigInt(${next(String(value))})`,
+            undefined: String,
+            object: object_1.objectToString,
+            function: function_1.functionToString
+        };
+        exports.toString = (value, space, next, key)=>null === value ? "null" : PRIMITIVE_TYPES[typeof value](value, space, next, key);
+    },
     "../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js": function(module) {
         var toString = Object.prototype.toString;
         function ctorName(val) {
@@ -765,7 +1055,737 @@ __webpack_require__.r(provider_helpers_namespaceObject), __webpack_require__.d(p
     setHTMLPlugin: ()=>setHTMLPlugin
 });
 let rspack_rspack = createRequire(import.meta.url)('@rspack/core');
-var cjs = __webpack_require__("../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js"), cjs_default = __webpack_require__.n(cjs);
+var cjs = __webpack_require__("../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js"), cjs_default = __webpack_require__.n(cjs), dist = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/index.js");
+function createMap(superClass) {
+    return class extends superClass {
+        extend(methods) {
+            return this.shorthands = methods, methods.forEach((method)=>{
+                this[method] = (value)=>this.set(method, value);
+            }), this;
+        }
+        clear() {
+            return this.store.clear(), this;
+        }
+        delete(key) {
+            return this.store.delete(key), this;
+        }
+        order() {
+            let entries = [
+                ...this.store
+            ].reduce((acc, [key, value])=>(acc[key] = value, acc), {}), names = Object.keys(entries), order = [
+                ...names
+            ];
+            return names.forEach((name)=>{
+                if (!entries[name]) return;
+                let { __before, __after } = entries[name];
+                __before && order.includes(__before) ? (order.splice(order.indexOf(name), 1), order.splice(order.indexOf(__before), 0, name)) : __after && order.includes(__after) && (order.splice(order.indexOf(name), 1), order.splice(order.indexOf(__after) + 1, 0, name));
+            }), {
+                entries,
+                order
+            };
+        }
+        entries() {
+            let { entries, order } = this.order();
+            if (order.length) return entries;
+        }
+        values() {
+            let { entries, order } = this.order();
+            return order.map((name)=>entries[name]);
+        }
+        get(key) {
+            return this.store.get(key);
+        }
+        getOrCompute(key, fn) {
+            return this.has(key) || this.set(key, fn()), this.get(key);
+        }
+        has(key) {
+            return this.store.has(key);
+        }
+        set(key, value) {
+            return this.store.set(key, value), this;
+        }
+        merge(obj, omit = []) {
+            return Object.keys(obj).forEach((key)=>{
+                if (omit.includes(key)) return;
+                let value = obj[key];
+                (Array.isArray(value) || 'object' == typeof value) && null !== value && this.has(key) ? this.set(key, cjs(this.get(key), value)) : this.set(key, value);
+            }), this;
+        }
+        clean(obj) {
+            return Object.keys(obj).reduce((acc, key)=>{
+                let value = obj[key];
+                return void 0 === value || Array.isArray(value) && !value.length || '[object Object]' === Object.prototype.toString.call(value) && !Object.keys(value).length || (acc[key] = value), acc;
+            }, {});
+        }
+        when(condition, whenTruthy = Function.prototype, whenFalsy = Function.prototype) {
+            return condition ? whenTruthy(this) : whenFalsy(this), this;
+        }
+        constructor(...args){
+            super(...args), this.store = new Map();
+        }
+    };
+}
+function createChainable(superClass) {
+    return class extends superClass {
+        batch(handler) {
+            return handler(this), this;
+        }
+        end() {
+            return this.parent;
+        }
+        constructor(parent){
+            super(), this.parent = parent;
+        }
+    };
+}
+let ChainedMap = createMap(createChainable(Object)), ChainedValueMap = (superClass = createMap(createChainable(class extends Function {
+    classCall() {
+        throw Error('not implemented');
+    }
+    constructor(){
+        return super(), new Proxy(this, {
+            apply: (target, thisArg, args)=>target.classCall(...args)
+        });
+    }
+})), class extends superClass {
+    set(...args) {
+        return this.useMap = !0, this.value = void 0, super.set(...args);
+    }
+    clear() {
+        return this.value = void 0, super.clear();
+    }
+    classCall(value) {
+        return this.clear(), this.useMap = !1, this.value = value, this.parent;
+    }
+    entries() {
+        return this.useMap ? super.entries() : this.value;
+    }
+    values() {
+        return this.useMap ? super.values() : this.value;
+    }
+    constructor(...args){
+        super(...args), this.value = void 0, this.useMap = !0;
+    }
+}), ChainedSet = (superClass1 = createChainable(Object), class extends superClass1 {
+    add(value) {
+        return this.store.add(value), this;
+    }
+    prepend(value) {
+        return this.store = new Set([
+            value,
+            ...this.store
+        ]), this;
+    }
+    clear() {
+        return this.store.clear(), this;
+    }
+    delete(value) {
+        return this.store.delete(value), this;
+    }
+    values() {
+        return [
+            ...this.store
+        ];
+    }
+    has(value) {
+        return this.store.has(value);
+    }
+    merge(arr) {
+        return void 0 !== arr && (this.store = new Set([
+            ...this.store,
+            ...arr
+        ])), this;
+    }
+    when(condition, whenTruthy = Function.prototype, whenFalsy = Function.prototype) {
+        return condition ? whenTruthy(this) : whenFalsy(this), this;
+    }
+    constructor(...args){
+        super(...args), this.store = new Set();
+    }
+}), Orderable = (Class)=>class extends Class {
+        before(name) {
+            if (this.__after) throw Error(`Unable to set .before(${JSON.stringify(name)}) with existing value for .after()`);
+            return this.__before = name, this;
+        }
+        after(name) {
+            if (this.__before) throw Error(`Unable to set .after(${JSON.stringify(name)}) with existing value for .before()`);
+            return this.__after = name, this;
+        }
+        merge(obj, omit = []) {
+            return obj.before && this.before(obj.before), obj.after && this.after(obj.after), super.merge(obj, [
+                ...omit,
+                'before',
+                'after'
+            ]);
+        }
+    }, src_Plugin = Orderable(class extends ChainedMap {
+    use(plugin, args = []) {
+        return this.set('plugin', plugin).set('args', args);
+    }
+    tap(f) {
+        if (!this.has('plugin')) throw Error(`Cannot call .tap() on a plugin that has not yet been defined. Call ${this.type}('${this.name}').use(<Plugin>) first.`);
+        return this.set('args', f(this.get('args') || [])), this;
+    }
+    set(key, value) {
+        if ('args' === key && !Array.isArray(value)) throw Error('args must be an array of arguments');
+        return super.set(key, value);
+    }
+    merge(obj, omit = []) {
+        return 'plugin' in obj && this.set('plugin', obj.plugin), 'args' in obj && this.set('args', obj.args), super.merge(obj, [
+            ...omit,
+            'args',
+            'plugin'
+        ]);
+    }
+    toConfig() {
+        let init = this.get('init'), plugin = this.get('plugin'), args = this.get('args'), pluginPath = null;
+        if (void 0 === plugin) throw Error(`Invalid ${this.type} configuration: ${this.type}('${this.name}').use(<Plugin>) was not called to specify the plugin`);
+        'string' == typeof plugin && (plugin = require(pluginPath = plugin));
+        let constructorName = plugin.__expression ? `(${plugin.__expression})` : plugin.name, config = init(plugin, args);
+        return Object.defineProperties(config, {
+            __pluginName: {
+                value: this.name
+            },
+            __pluginType: {
+                value: this.type
+            },
+            __pluginArgs: {
+                value: args
+            },
+            __pluginConstructorName: {
+                value: constructorName
+            },
+            __pluginPath: {
+                value: pluginPath
+            }
+        }), config;
+    }
+    constructor(parent, name, type = 'plugin'){
+        super(parent), this.name = name, this.type = type, this.extend([
+            'init'
+        ]), this.init((Plugin, args = [])=>'function' == typeof Plugin ? new Plugin(...args) : Plugin);
+    }
+}), childMaps = [
+    'alias',
+    'fallback',
+    'byDependency',
+    'extensionAlias'
+], childSets = [
+    'aliasFields',
+    'conditionNames',
+    "descriptionFiles",
+    'extensions',
+    'mainFields',
+    'mainFiles',
+    'exportsFields',
+    'importsFields',
+    'restrictions',
+    'roots',
+    'modules'
+];
+class Resolve_class extends ChainedMap {
+    plugin(name) {
+        return this.plugins.getOrCompute(name, ()=>new src_Plugin(this, name, 'resolve.plugin'));
+    }
+    get(key) {
+        return childMaps.includes(key) ? this[key].entries() : childSets.includes(key) ? this[key].values() : super.get(key);
+    }
+    toConfig() {
+        let config = Object.assign(this.entries() || {}, {
+            plugins: this.plugins.values().map((plugin)=>plugin.toConfig())
+        });
+        return childMaps.forEach((key)=>{
+            config[key] = this[key].entries();
+        }), childSets.forEach((key)=>{
+            config[key] = this[key].values();
+        }), this.clean(config);
+    }
+    merge(obj, omit = []) {
+        !omit.includes('plugin') && 'plugin' in obj && Object.keys(obj.plugin).forEach((name)=>this.plugin(name).merge(obj.plugin[name]));
+        let omissions = [
+            ...childMaps,
+            ...childSets
+        ];
+        return omissions.forEach((key)=>{
+            !omit.includes(key) && key in obj && this[key].merge(obj[key]);
+        }), super.merge(obj, [
+            ...omit,
+            ...omissions,
+            'plugin'
+        ]);
+    }
+    constructor(parent){
+        super(parent), childMaps.forEach((key)=>{
+            this[key] = new ChainedMap(this);
+        }), childSets.forEach((key)=>{
+            this[key] = new ChainedSet(this);
+        }), this.plugins = new ChainedMap(this), this.extend([
+            'cachePredicate',
+            'cacheWithContext',
+            'enforceExtension',
+            'symlinks',
+            'unsafeCache',
+            'preferRelative',
+            'preferAbsolute',
+            'tsConfig'
+        ]);
+    }
+}
+class ResolveLoader_class extends Resolve_class {
+    toConfig() {
+        return this.clean({
+            modules: this.modules.values(),
+            moduleExtensions: this.moduleExtensions.values(),
+            packageMains: this.packageMains.values(),
+            ...super.toConfig()
+        });
+    }
+    merge(obj, omit = []) {
+        let omissions = [
+            'modules',
+            'moduleExtensions',
+            'packageMains'
+        ];
+        return omissions.forEach((key)=>{
+            !omit.includes(key) && key in obj && this[key].merge(obj[key]);
+        }), super.merge(obj, [
+            ...omit,
+            ...omissions
+        ]);
+    }
+    constructor(parent){
+        super(parent), this.modules = new ChainedSet(this), this.moduleExtensions = new ChainedSet(this), this.packageMains = new ChainedSet(this);
+    }
+}
+class Output_class extends ChainedMap {
+    constructor(parent){
+        super(parent), this.extend([
+            'auxiliaryComment',
+            'charset',
+            'chunkFilename',
+            'chunkLoadTimeout',
+            'chunkLoadingGlobal',
+            'chunkLoading',
+            'chunkFormat',
+            'enabledChunkLoadingTypes',
+            'crossOriginLoading',
+            'devtoolFallbackModuleFilenameTemplate',
+            'devtoolModuleFilenameTemplate',
+            'devtoolNamespace',
+            'filename',
+            'assetModuleFilename',
+            'globalObject',
+            'uniqueName',
+            'hashDigest',
+            'hashDigestLength',
+            'hashFunction',
+            'hashSalt',
+            'hotUpdateChunkFilename',
+            'hotUpdateGlobal',
+            'hotUpdateMainFilename',
+            'library',
+            'libraryExport',
+            'libraryTarget',
+            'importFunctionName',
+            'path',
+            'pathinfo',
+            'publicPath',
+            "scriptType",
+            'sourceMapFilename',
+            'sourcePrefix',
+            'strictModuleErrorHandling',
+            'strictModuleExceptionHandling',
+            'umdNamedDefine',
+            'workerChunkLoading',
+            'enabledLibraryTypes',
+            'environment',
+            'compareBeforeEmit',
+            'wasmLoading',
+            'webassemblyModuleFilename',
+            'enabledWasmLoadingTypes',
+            'iife',
+            'module',
+            'clean'
+        ]);
+    }
+}
+class DevServer_class extends ChainedMap {
+    toConfig() {
+        return this.clean({
+            allowedHosts: this.allowedHosts.values(),
+            ...this.entries() || {}
+        });
+    }
+    merge(obj, omit = []) {
+        return !omit.includes('allowedHosts') && 'allowedHosts' in obj && this.allowedHosts.merge(obj.allowedHosts), super.merge(obj, [
+            'allowedHosts'
+        ]);
+    }
+    constructor(parent){
+        super(parent), this.allowedHosts = new ChainedSet(this), this.extend([
+            'after',
+            'before',
+            'bonjour',
+            'clientLogLevel',
+            'compress',
+            'contentBase',
+            'contentBasePublicPath',
+            'disableHostCheck',
+            'filename',
+            'headers',
+            'historyApiFallback',
+            'host',
+            'hot',
+            'hotOnly',
+            'http2',
+            'https',
+            'index',
+            'injectClient',
+            'injectHot',
+            'inline',
+            'lazy',
+            'liveReload',
+            'mimeTypes',
+            'noInfo',
+            'onListening',
+            'open',
+            'openPage',
+            'overlay',
+            'pfx',
+            'pfxPassphrase',
+            'port',
+            'proxy',
+            'progress',
+            'public',
+            'publicPath',
+            'quiet',
+            'serveIndex',
+            'setup',
+            'socket',
+            'sockHost',
+            'sockPath',
+            'sockPort',
+            'staticOptions',
+            'stats',
+            'stdin',
+            'transportMode',
+            'useLocalIp',
+            'watchContentBase',
+            'watchOptions',
+            'writeToDisk'
+        ]);
+    }
+}
+let Use = Orderable(class extends ChainedMap {
+    tap(f) {
+        return this.options(f(this.get('options'))), this;
+    }
+    merge(obj, omit = []) {
+        return !omit.includes('loader') && 'loader' in obj && this.loader(obj.loader), !omit.includes('options') && 'options' in obj && this.options(cjs(this.store.get('options') || {}, obj.options)), super.merge(obj, [
+            ...omit,
+            'loader',
+            'options'
+        ]);
+    }
+    toConfig() {
+        let config = this.clean(this.entries() || {});
+        return Object.defineProperties(config, {
+            __useName: {
+                value: this.name
+            },
+            __ruleNames: {
+                value: this.parent && this.parent.names
+            },
+            __ruleTypes: {
+                value: this.parent && this.parent.ruleTypes
+            }
+        }), config;
+    }
+    constructor(parent, name){
+        super(parent), this.name = name, this.extend([
+            'loader',
+            'options',
+            'parallel'
+        ]);
+    }
+});
+function toArray(arr) {
+    return Array.isArray(arr) ? arr : [
+        arr
+    ];
+}
+let Rule_Rule = Orderable(class extends ChainedMap {
+    use(name) {
+        return this.uses.getOrCompute(name, ()=>new Use(this, name));
+    }
+    rule(name) {
+        return this.rules.getOrCompute(name, ()=>new Rule_Rule(this, name, 'rule'));
+    }
+    oneOf(name) {
+        return this.oneOfs.getOrCompute(name, ()=>new Rule_Rule(this, name, 'oneOf'));
+    }
+    pre() {
+        return this.enforce('pre');
+    }
+    post() {
+        return this.enforce('post');
+    }
+    toConfig() {
+        let config = this.clean(Object.assign(this.entries() || {}, {
+            include: this.include.values(),
+            exclude: this.exclude.values(),
+            rules: this.rules.values().map((rule)=>rule.toConfig()),
+            oneOf: this.oneOfs.values().map((oneOf)=>oneOf.toConfig()),
+            use: this.uses.values().map((use)=>use.toConfig()),
+            resolve: this.resolve.toConfig()
+        }));
+        return Object.defineProperties(config, {
+            __ruleNames: {
+                value: this.names
+            },
+            __ruleTypes: {
+                value: this.ruleTypes
+            }
+        }), config;
+    }
+    merge(obj, omit = []) {
+        return !omit.includes('include') && 'include' in obj && this.include.merge(toArray(obj.include)), !omit.includes('exclude') && 'exclude' in obj && this.exclude.merge(toArray(obj.exclude)), !omit.includes('use') && 'use' in obj && Object.keys(obj.use).forEach((name)=>this.use(name).merge(obj.use[name])), !omit.includes('rules') && 'rules' in obj && Object.keys(obj.rules).forEach((name)=>this.rule(name).merge(obj.rules[name])), !omit.includes('oneOf') && 'oneOf' in obj && Object.keys(obj.oneOf).forEach((name)=>this.oneOf(name).merge(obj.oneOf[name])), !omit.includes('resolve') && 'resolve' in obj && this.resolve.merge(obj.resolve), !omit.includes('test') && 'test' in obj && this.test(obj.test instanceof RegExp || 'function' == typeof obj.test ? obj.test : new RegExp(obj.test)), super.merge(obj, [
+            ...omit,
+            'include',
+            'exclude',
+            'use',
+            'rules',
+            'oneOf',
+            'resolve',
+            'test'
+        ]);
+    }
+    constructor(parent, name, ruleType = 'rule'){
+        super(parent), this.ruleName = name, this.names = [], this.ruleType = ruleType, this.ruleTypes = [];
+        let rule = this;
+        for(; rule instanceof Rule_Rule;)this.names.unshift(rule.ruleName), this.ruleTypes.unshift(rule.ruleType), rule = rule.parent;
+        this.uses = new ChainedMap(this), this.include = new ChainedSet(this), this.exclude = new ChainedSet(this), this.rules = new ChainedMap(this), this.oneOfs = new ChainedMap(this), this.resolve = new Resolve_class(this), this.resolve.extend([
+            'fullySpecified'
+        ]), this.extend([
+            'dependency',
+            'enforce',
+            'issuer',
+            'issuerLayer',
+            'layer',
+            'mimetype',
+            'parser',
+            'generator',
+            'resource',
+            'resourceFragment',
+            'resourceQuery',
+            'sideEffects',
+            'with',
+            'test',
+            'type'
+        ]);
+    }
+});
+class Module_class extends ChainedMap {
+    defaultRule(name) {
+        return this.defaultRules.getOrCompute(name, ()=>new Rule_Rule(this, name, 'defaultRule'));
+    }
+    rule(name) {
+        return this.rules.getOrCompute(name, ()=>new Rule_Rule(this, name, 'rule'));
+    }
+    toConfig() {
+        return this.clean(Object.assign(this.entries() || {}, {
+            defaultRules: this.defaultRules.values().map((r)=>r.toConfig()),
+            generator: this.generator.entries(),
+            parser: this.parser.entries(),
+            rules: this.rules.values().map((r)=>r.toConfig())
+        }));
+    }
+    merge(obj, omit = []) {
+        return !omit.includes('rule') && 'rule' in obj && Object.keys(obj.rule).forEach((name)=>this.rule(name).merge(obj.rule[name])), !omit.includes('defaultRule') && 'defaultRule' in obj && Object.keys(obj.defaultRule).forEach((name)=>this.defaultRule(name).merge(obj.defaultRule[name])), super.merge(obj, [
+            'rule',
+            'defaultRule'
+        ]);
+    }
+    constructor(parent){
+        super(parent), this.rules = new ChainedMap(this), this.defaultRules = new ChainedMap(this), this.generator = new ChainedMap(this), this.parser = new ChainedMap(this), this.extend([
+            'noParse',
+            'unsafeCache',
+            'wrappedContextCritical',
+            'exprContextRegExp',
+            'wrappedContextRecursive',
+            'strictExportPresence',
+            'wrappedContextRegExp'
+        ]);
+    }
+}
+class Optimization_class extends ChainedMap {
+    minimizer(name) {
+        if (Array.isArray(name)) throw Error("optimization.minimizer() no longer supports being passed an array. Either switch to the new syntax (https://github.com/neutrinojs/webpack-chain#config-optimization-minimizers-adding) or downgrade to webpack-chain 4. If using Vue this likely means a Vue plugin has not yet been updated to support Vue CLI 4+.");
+        return this.minimizers.getOrCompute(name, ()=>new src_Plugin(this, name, 'optimization.minimizer'));
+    }
+    toConfig() {
+        return this.clean(Object.assign(this.entries() || {}, {
+            splitChunks: this.splitChunks.entries(),
+            minimizer: this.minimizers.values().map((plugin)=>plugin.toConfig())
+        }));
+    }
+    merge(obj, omit = []) {
+        return !omit.includes('minimizer') && 'minimizer' in obj && Object.keys(obj.minimizer).forEach((name)=>this.minimizer(name).merge(obj.minimizer[name])), super.merge(obj, [
+            ...omit,
+            'minimizer'
+        ]);
+    }
+    constructor(parent){
+        super(parent), this.minimizers = new ChainedMap(this), this.splitChunks = new ChainedValueMap(this), this.extend([
+            'minimize',
+            'runtimeChunk',
+            'emitOnErrors',
+            'moduleIds',
+            'chunkIds',
+            'nodeEnv',
+            'mangleWasmImports',
+            'removeAvailableModules',
+            'removeEmptyChunks',
+            'mergeDuplicateChunks',
+            'flagIncludedChunks',
+            'providedExports',
+            'usedExports',
+            'concatenateModules',
+            'sideEffects',
+            'portableRecords',
+            'mangleExports',
+            'innerGraph',
+            'realContentHash',
+            'avoidEntryIife'
+        ]);
+    }
+}
+class Performance_class extends ChainedValueMap {
+    constructor(parent){
+        super(parent), this.extend([
+            'assetFilter',
+            'hints',
+            'maxAssetSize',
+            'maxEntrypointSize'
+        ]);
+    }
+}
+let castArray = (value)=>Array.isArray(value) ? value : [
+        value
+    ];
+class src_class extends ChainedMap {
+    static toString(config, { verbose = !1, configPrefix = 'config' } = {}) {
+        return (0, dist.stringify)(config, (value, indent, stringify)=>{
+            if (value && value.__pluginName) {
+                let prefix = `/* ${configPrefix}.${value.__pluginType}('${value.__pluginName}') */\n`, constructorExpression = value.__pluginPath ? `(require(${stringify(value.__pluginPath)}))` : value.__pluginConstructorName;
+                if (constructorExpression) {
+                    let args = stringify(value.__pluginArgs).slice(1, -1);
+                    return `${prefix}new ${constructorExpression}(${args})`;
+                }
+                return prefix + stringify(value.__pluginArgs && value.__pluginArgs.length ? {
+                    args: value.__pluginArgs
+                } : {});
+            }
+            if (value && value.__ruleNames) {
+                let ruleTypes = value.__ruleTypes;
+                return `/* ${configPrefix}.module${value.__ruleNames.map((r, index)=>`.${ruleTypes ? ruleTypes[index] : 'rule'}('${r}')`).join('')}${value.__useName ? `.use('${value.__useName}')` : ""} */\n` + stringify(value);
+            }
+            return value && value.__expression ? value.__expression : 'function' == typeof value && !verbose && value.toString().length > 100 ? "function () { /* omitted long function */ }" : stringify(value);
+        }, 2);
+    }
+    entry(name) {
+        return this.entryPoints.getOrCompute(name, ()=>new ChainedSet(this));
+    }
+    plugin(name) {
+        return this.plugins.getOrCompute(name, ()=>new src_Plugin(this, name));
+    }
+    toConfig() {
+        let entryPoints = this.entryPoints.entries() || {}, baseConfig = this.entries() || {};
+        return this.clean(Object.assign(baseConfig, {
+            node: this.node.entries(),
+            output: this.output.entries(),
+            resolve: this.resolve.toConfig(),
+            resolveLoader: this.resolveLoader.toConfig(),
+            devServer: this.devServer.toConfig(),
+            module: this.module.toConfig(),
+            optimization: this.optimization.toConfig(),
+            plugins: this.plugins.values().map((plugin)=>plugin.toConfig()),
+            performance: this.performance.entries(),
+            entry: ((entryPoints)=>{
+                let entry = Object.keys(entryPoints).reduce((acc, key)=>Object.assign(acc, {
+                        [key]: entryPoints[key].values()
+                    }), {}), formattedEntry = {};
+                for (let [entryName, entryValue] of Object.entries(entry)){
+                    let entryImport = [], entryDescription = null;
+                    for (let item of castArray(entryValue)){
+                        if ('string' == typeof item) {
+                            entryImport.push(item);
+                            continue;
+                        }
+                        item.import && entryImport.push(...castArray(item.import)), entryDescription ? Object.assign(entryDescription, item) : entryDescription = item;
+                    }
+                    formattedEntry[entryName] = entryDescription ? {
+                        ...entryDescription,
+                        import: entryImport
+                    } : entryImport;
+                }
+                return formattedEntry;
+            })(entryPoints)
+        }));
+    }
+    toString(options) {
+        return this.constructor.toString(this.toConfig(), options);
+    }
+    merge(obj = {}, omit = []) {
+        let omissions = [
+            'node',
+            'output',
+            'resolve',
+            'resolveLoader',
+            'devServer',
+            'optimization',
+            'performance',
+            'module'
+        ];
+        return !omit.includes('entry') && 'entry' in obj && Object.keys(obj.entry).forEach((name)=>this.entry(name).merge([].concat(obj.entry[name]))), !omit.includes('plugin') && 'plugin' in obj && Object.keys(obj.plugin).forEach((name)=>this.plugin(name).merge(obj.plugin[name])), omissions.forEach((key)=>{
+            !omit.includes(key) && key in obj && this[key].merge(obj[key]);
+        }), super.merge(obj, [
+            ...omit,
+            ...omissions,
+            'entry',
+            'plugin'
+        ]);
+    }
+    constructor(){
+        super(), this.entryPoints = new ChainedMap(this), this.output = new Output_class(this), this.module = new Module_class(this), this.resolve = new Resolve_class(this), this.resolveLoader = new ResolveLoader_class(this), this.optimization = new Optimization_class(this), this.plugins = new ChainedMap(this), this.devServer = new DevServer_class(this), this.performance = new Performance_class(this), this.node = new ChainedValueMap(this), this.extend([
+            'context',
+            'mode',
+            'devtool',
+            'target',
+            'watch',
+            'watchOptions',
+            'externals',
+            'externalsType',
+            'externalsPresets',
+            'stats',
+            'experiments',
+            'amd',
+            'bail',
+            'cache',
+            'dependencies',
+            'ignoreWarnings',
+            'loader',
+            'parallelism',
+            'profile',
+            'recordsPath',
+            'recordsInputPath',
+            'recordsOutputPath',
+            'name',
+            'infrastructureLogging',
+            'snapshot'
+        ]);
+    }
+}
 let constants_filename = fileURLToPath(import.meta.url), constants_dirname = dirname(constants_filename), ROOT_DIST_DIR = 'dist', LOADER_PATH = join(constants_dirname), STATIC_PATH = join(constants_dirname, '../static'), COMPILED_PATH = join(constants_dirname, '../compiled'), RSBUILD_OUTPUTS_PATH = '.rsbuild', DEFAULT_DEV_HOST = '0.0.0.0', DEFAULT_ASSET_PREFIX = '/', DEFAULT_WEB_BROWSERSLIST = [
     'chrome >= 87',
     'edge >= 88',
@@ -986,7 +2006,16 @@ function formatStatsMessages(stats, verbose) {
 let getAllStatsErrors = (statsData)=>{
     var _statsData_errors, _statsData_children;
     return statsData.errorsCount && (null == (_statsData_errors = statsData.errors) ? void 0 : _statsData_errors.length) === 0 ? null == (_statsData_children = statsData.children) ? void 0 : _statsData_children.reduce((errors, curr)=>errors.concat(curr.errors || []), []) : statsData.errors;
-}, getAllStatsWarnings = (statsData)=>{
+}, getAssetsFromStats = (stats)=>stats.toJson({
+        all: !1,
+        assets: !0,
+        cachedAssets: !0,
+        groupAssetsByInfo: !1,
+        groupAssetsByPath: !1,
+        groupAssetsByChunk: !1,
+        groupAssetsByExtension: !1,
+        groupAssetsByEmitStatus: !1
+    }).assets || [], getAllStatsWarnings = (statsData)=>{
     var _statsData_warnings, _statsData_children;
     return statsData.warningsCount && (null == (_statsData_warnings = statsData.warnings) ? void 0 : _statsData_warnings.length) === 0 ? null == (_statsData_children = statsData.children) ? void 0 : _statsData_children.reduce((warnings, curr)=>warnings.concat(curr.warnings || []), []) : statsData.warnings;
 };
@@ -1031,7 +2060,7 @@ function formatStats(statsData, hasErrors) {
 }
 let rspackMinVersion = '1.2.4', setNodeEnv = (env)=>{
     process.env.NODE_ENV = env;
-}, isFunction = (func)=>'function' == typeof func, isObject = (obj)=>'[object Object]' === Object.prototype.toString.call(obj), isPlainObject = (obj)=>null !== obj && 'object' == typeof obj && Object.getPrototypeOf(obj) === Object.prototype, castArray = (arr)=>void 0 === arr ? [] : Array.isArray(arr) ? arr : [
+}, isFunction = (func)=>'function' == typeof func, isObject = (obj)=>'[object Object]' === Object.prototype.toString.call(obj), isPlainObject = (obj)=>null !== obj && 'object' == typeof obj && Object.getPrototypeOf(obj) === Object.prototype, helpers_castArray = (arr)=>void 0 === arr ? [] : Array.isArray(arr) ? arr : [
         arr
     ], cloneDeep = (value)=>null == value ? value : cjs_default()({}, value, {
         isMergeableObject: isPlainObject
@@ -1126,10 +2155,10 @@ function toArr(any) {
 isDebug() && (logger.level = 'verbose'), logger.override({
     debug: (message, ...args)=>{
         if ('verbose' !== logger.level) return;
-        let time = picocolors.gray(`${function() {
+        let time = picocolors.gray(function() {
             let now = new Date(), hours = String(now.getHours()).padStart(2, '0'), minutes = String(now.getMinutes()).padStart(2, '0'), seconds = String(now.getSeconds()).padStart(2, '0');
             return `${hours}:${minutes}:${seconds}`;
-        }()}`);
+        }());
         console.log(`  ${picocolors.magenta('rsbuild')} ${time} ${message}`, ...args);
     }
 });
@@ -1448,9 +2477,11 @@ function createEnvironmentAsyncHook() {
     };
     return {
         tapEnvironment,
-        tap: (handler)=>tapEnvironment({
+        tap: (handler)=>{
+            tapEnvironment({
                 handler
-            }),
+            });
+        },
         callChain: async ({ environment, args: params })=>{
             for (let callback of [
                 ...preGroup,
@@ -1564,13 +2595,13 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
     };
     onBeforeCompile({
         compiler,
-        beforeCompile: async ()=>await context.hooks.onBeforeBuild.callBatch({
+        beforeCompile: async ()=>context.hooks.onBeforeBuild.callBatch({
                 bundlerConfigs,
                 environments: context.environments,
                 isWatch,
                 isFirstCompile
             }),
-        beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callBatch({
+        beforeEnvironmentCompiler: async (buildIndex)=>context.hooks.onBeforeEnvironmentCompile.callBatch({
                 environment: environmentList[buildIndex].name,
                 args: [
                     {
@@ -1611,7 +2642,7 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
     };
     onBeforeCompile({
         compiler,
-        beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callBatch({
+        beforeEnvironmentCompiler: async (buildIndex)=>context.hooks.onBeforeEnvironmentCompile.callBatch({
                 environment: environmentList[buildIndex].name,
                 args: [
                     {
@@ -1720,8 +2751,8 @@ let configCache = {}, OVERRIDE_PATHS = [
         y
     ];
     if (pair.some(Array.isArray)) return 'output.copy' !== path || pair.every(Array.isArray) ? [
-        ...castArray(x),
-        ...castArray(y)
+        ...helpers_castArray(x),
+        ...helpers_castArray(y)
     ] : Array.isArray(x) ? merge({
         patterns: x
     }, y, path) : merge(x, {
@@ -1815,7 +2846,8 @@ let configCache = {}, OVERRIDE_PATHS = [
                 wasm: 'static/wasm',
                 image: 'static/image',
                 media: 'static/media',
-                assets: 'static/assets'
+                assets: 'static/assets',
+                favicon: './'
             },
             assetPrefix: DEFAULT_ASSET_PREFIX,
             filename: {},
@@ -1959,7 +2991,7 @@ async function initPlugins({ context, pluginManager }) {
         let { name, setup } = instance;
         if (!(removedPlugins.has(name) || environment && (null == (_removedEnvPlugins_environment = removedEnvPlugins[environment]) ? void 0 : _removedEnvPlugins_environment.has(name)))) {
             if (instance.apply && context.action) if (isFunction(instance.apply)) {
-                if (!1 === instance.apply(context.originalConfig, {
+                if (!instance.apply(context.originalConfig, {
                     action: context.action
                 })) continue;
             } else {
@@ -2094,7 +3126,7 @@ async function updateEnvironmentContext(context, configs) {
 async function createContext(options, userConfig) {
     let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0, bundlerType = userConfig.provider ? 'webpack' : 'rspack';
     return {
-        version: "1.4.11",
+        version: "1.4.13",
         rootPath,
         distPath: '',
         cachePath,
@@ -2171,7 +3203,7 @@ async function outputInspectConfigFiles({ rawBundlerConfigs, rawEnvironmentConfi
     logger.success(`config inspection completed, generated files: \n\n${fileInfos}\n`);
 }
 function stringifyConfig(config, verbose) {
-    return (0, rspack_chain.toString)(config, {
+    return src_class.toString(config, {
         verbose
     });
 }
@@ -2271,14 +3303,14 @@ var webpack_merge_dist = __webpack_require__("../../node_modules/.pnpm/webpack-m
 async function modifyBundlerChain(context, utils) {
     var _utils_environment_config_tools;
     logger.debug('modify bundler chain');
-    let bundlerChain = new rspack_chain(), [modifiedBundlerChain] = await context.hooks.modifyBundlerChain.callChain({
+    let bundlerChain = new src_class(), [modifiedBundlerChain] = await context.hooks.modifyBundlerChain.callChain({
         environment: utils.environment.name,
         args: [
             bundlerChain,
             utils
         ]
     });
-    if (null == (_utils_environment_config_tools = utils.environment.config.tools) ? void 0 : _utils_environment_config_tools.bundlerChain) for (let item of castArray(utils.environment.config.tools.bundlerChain))await item(modifiedBundlerChain, utils);
+    if (null == (_utils_environment_config_tools = utils.environment.config.tools) ? void 0 : _utils_environment_config_tools.bundlerChain) for (let item of helpers_castArray(utils.environment.config.tools.bundlerChain))await item(modifiedBundlerChain, utils);
     return logger.debug('modify bundler chain done'), modifiedBundlerChain;
 }
 let configChain_CHAIN_ID = {
@@ -2397,19 +3429,19 @@ async function getConfigUtils(config, chainUtils) {
         ...chainUtils,
         mergeConfig: webpack_merge_dist.merge,
         addRules (rules) {
-            let ruleArr = castArray(rules);
+            let ruleArr = helpers_castArray(rules);
             config.module || (config.module = {}), config.module.rules || (config.module.rules = []), config.module.rules.unshift(...ruleArr);
         },
         appendRules (rules) {
-            let ruleArr = castArray(rules);
+            let ruleArr = helpers_castArray(rules);
             config.module || (config.module = {}), config.module.rules || (config.module.rules = []), config.module.rules.push(...ruleArr);
         },
         prependPlugins (plugins) {
-            let pluginArr = castArray(plugins);
+            let pluginArr = helpers_castArray(plugins);
             config.plugins || (config.plugins = []), config.plugins.unshift(...pluginArr);
         },
         appendPlugins (plugins) {
-            let pluginArr = castArray(plugins);
+            let pluginArr = helpers_castArray(plugins);
             config.plugins || (config.plugins = []), config.plugins.push(...pluginArr);
         },
         removePlugin (pluginName) {
@@ -2421,7 +3453,7 @@ function getChainUtils(target, environment) {
     return {
         rspack: rspack_rspack,
         environment,
-        env: process.env.NODE_ENV,
+        env: process.env.NODE_ENV || '',
         target,
         isDev: 'development' === environment.config.mode,
         isProd: 'production' === environment.config.mode,
@@ -2452,6 +3484,14 @@ async function generateRspackConfig({ target, context, environment }) {
     }
     return config.devServer && logger.warn(`${picocolors.dim('[rsbuild:config]')} Find invalid Rspack config: "${picocolors.yellow('devServer')}". Note that Rspack's "devServer" config is not supported by Rsbuild. You can use Rsbuild's "dev" config to configure the Rsbuild dev server.`), rspackConfig;
 }
+let allowedEnvironmentDevKeys = [
+    'hmr',
+    'liveReload',
+    'writeToDisk',
+    'assetPrefix',
+    'progressBar',
+    'lazyCompilation'
+];
 async function modifyRsbuildConfig(context) {
     var _context_config_plugins, _modified_plugins;
     logger.debug('modify Rsbuild config');
@@ -2485,7 +3525,7 @@ async function initRsbuildConfig({ context, pluginManager }) {
             ...createDefaultConfig(),
             mode: (()=>{
                 if (config.mode) return config.mode;
-                let nodeEnv = process.env.NODE_ENV;
+                let nodeEnv = process.env.NODE_ENV || '';
                 return 'production' === nodeEnv || 'development' === nodeEnv ? nodeEnv : 'none';
             })()
         }, config), { watchFiles } = mergedConfig.dev;
@@ -2518,13 +3558,7 @@ async function initRsbuildConfig({ context, pluginManager }) {
                     applyEnvironmentDefaultConfig({
                         ...mergeRsbuildConfig({
                             ...rsbuildSharedConfig,
-                            dev: pick(dev, [
-                                'writeToDisk',
-                                'hmr',
-                                'assetPrefix',
-                                'progressBar',
-                                'lazyCompilation'
-                            ])
+                            dev: pick(dev, allowedEnvironmentDevKeys)
                         }, config)
                     })
                 ]));
@@ -2536,24 +3570,18 @@ async function initRsbuildConfig({ context, pluginManager }) {
         return {
             [defaultEnvironmentName]: applyEnvironmentDefaultConfig({
                 ...rsbuildSharedConfig,
-                dev: pick(dev, [
-                    'hmr',
-                    'assetPrefix',
-                    'progressBar',
-                    'lazyCompilation',
-                    'writeToDisk'
-                ])
+                dev: pick(dev, allowedEnvironmentDevKeys)
             })
         };
-    })(normalizedBaseConfig, context.rootPath, context.specifiedEnvironments), { dev: { hmr: _hmr, assetPrefix: _assetPrefix, progressBar: _progressBar, lazyCompilation: _lazyCompilation, writeToDisk: _writeToDisk, ...rsbuildSharedDev }, server } = normalizedBaseConfig, tsconfigPaths = new Set();
+    })(normalizedBaseConfig, context.rootPath, context.specifiedEnvironments), tsconfigPaths = new Set();
     for (let [name, config] of Object.entries(mergedEnvironments)){
         let environmentConfig = await modifyEnvironmentConfig(context, config, name), normalizedEnvironmentConfig = {
             ...environmentConfig,
             dev: {
-                ...environmentConfig.dev,
-                ...rsbuildSharedDev
+                ...normalizedBaseConfig.dev,
+                ...environmentConfig.dev
             },
-            server
+            server: normalizedBaseConfig.server
         }, { tsconfigPath } = normalizedEnvironmentConfig.source;
         if (tsconfigPath) {
             let absoluteTsconfigPath = ensureAbsolutePath(context.rootPath, tsconfigPath);
@@ -2747,7 +3775,7 @@ let RSPACK_BUILD_ERROR = 'Rspack build failed.', build_build = async (initOption
 };
 var main = __webpack_require__("../../node_modules/.pnpm/dotenv-expand@12.0.2/node_modules/dotenv-expand/lib/main.js");
 let DOTENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
-function loadEnv({ cwd = process.cwd(), mode = process.env.NODE_ENV, prefixes = [
+function loadEnv({ cwd = process.cwd(), mode = process.env.NODE_ENV || '', prefixes = [
     'PUBLIC_'
 ], processEnv = process.env } = {}) {
     if ('local' === mode) throw Error(`${picocolors.dim('[rsbuild:loadEnv]')} ${picocolors.yellow('local')} cannot be used as a value for env mode, because ${picocolors.yellow('.env.local')} represents a temporary local file. Please use another value.`);
@@ -2792,7 +3820,7 @@ let chainStaticAssetRule = ({ emit, rule, maxSize, filename, assetType })=>{
     let generatorOptions = {
         filename
     };
-    !1 === emit && (generatorOptions.emit = !1), rule.oneOf(`${assetType}-asset-url`).type('asset/resource').resourceQuery(/^\?(__inline=false|url)$/).set('generator', generatorOptions), rule.oneOf(`${assetType}-asset-inline`).type('asset/inline').resourceQuery(INLINE_QUERY_REGEX), rule.oneOf(`${assetType}-asset-raw`).type('asset/source').resourceQuery(RAW_QUERY_REGEX), rule.oneOf(`${assetType}-asset`).type('asset').parser({
+    emit || (generatorOptions.emit = !1), rule.oneOf(`${assetType}-asset-url`).type('asset/resource').resourceQuery(/^\?(__inline=false|url)$/).set('generator', generatorOptions), rule.oneOf(`${assetType}-asset-inline`).type('asset/inline').resourceQuery(INLINE_QUERY_REGEX), rule.oneOf(`${assetType}-asset-raw`).type('asset/source').resourceQuery(RAW_QUERY_REGEX), rule.oneOf(`${assetType}-asset`).type('asset').parser({
         dataUrlCondition: {
             maxSize
         }
@@ -2864,7 +3892,7 @@ let addTrailingSep = (dir)=>dir.endsWith(sep) ? dir : dir + sep, isStrictSubdir
 }, parseMinifyOptions = (config)=>{
     let isProd = 'production' === config.mode, { minify } = config.output;
     if ('boolean' == typeof minify) {
-        let shouldMinify = !0 === minify && isProd;
+        let shouldMinify = minify && isProd;
         return {
             minifyJs: shouldMinify,
             minifyCss: shouldMinify
@@ -2916,12 +3944,12 @@ let getPostcssLoaderOptions = async ({ config, root, postcssrcCache })=>{
         config: config.tools.postcss,
         ctx: {
             addPlugins (plugins) {
-                extraPlugins.push(...castArray(plugins));
+                extraPlugins.push(...helpers_castArray(plugins));
             }
         }
     });
     finalOptions.postcssOptions ||= {};
-    let updatePostcssOptions = (options)=>(options.plugins ||= [], extraPlugins.length && options.plugins.push(...extraPlugins), options.plugins = options.plugins.map((plugin)=>'function' == typeof plugin && !0 === plugin.postcss ? plugin() : plugin), options.config = !1, options), { postcssOptions } = finalOptions;
+    let updatePostcssOptions = (options)=>(options.plugins ||= [], extraPlugins.length && options.plugins.push(...extraPlugins), options.plugins = options.plugins.map((plugin)=>'function' == typeof plugin && plugin.postcss ? plugin() : plugin), options.config = !1, options), { postcssOptions } = finalOptions;
     if ('function' == typeof postcssOptions) {
         let postcssOptionsWrapper = (loaderContext)=>{
             let options = postcssOptions(loaderContext);
@@ -2966,16 +3994,7 @@ async function printFileSizes(options, stats, rootPath, environmentName) {
     }, getAssets = async ()=>{
         let distPath = stats.compilation.outputOptions.path;
         if (!distPath) return [];
-        let filteredAssets = (stats.toJson({
-            all: !1,
-            assets: !0,
-            cachedAssets: !0,
-            groupAssetsByInfo: !1,
-            groupAssetsByPath: !1,
-            groupAssetsByChunk: !1,
-            groupAssetsByExtension: !1,
-            groupAssetsByEmitStatus: !1
-        }).assets || []).filter((asset)=>{
+        let filteredAssets = getAssetsFromStats(stats).filter((asset)=>{
             let assetInfo = {
                 name: asset.name,
                 size: asset.size
@@ -3085,22 +4104,26 @@ let entryNameSymbol = Symbol('entryName'), VOID_TAGS = [
         }));
 class RsbuildHtmlPlugin {
     apply(compiler) {
-        let emitFavicon = async (compilation, favicon)=>{
+        let emitFavicon = async ({ compilation, favicon, faviconDistPath })=>{
             let buffer, name = node_path.basename(favicon);
             if (compilation.assets[name]) return name;
             if (!compilation.inputFileSystem) return addCompilationError(compilation, `${picocolors.dim('[rsbuild:html]')} Failed to read the favicon file as ${picocolors.yellow('compilation.inputFileSystem')} is not available.`), null;
-            let filename = node_path.isAbsolute(favicon) ? favicon : node_path.join(compilation.compiler.context, favicon);
+            let inputFilename = node_path.isAbsolute(favicon) ? favicon : node_path.join(compilation.compiler.context, favicon);
             try {
-                if (!(buffer = await external_node_util_promisify(compilation.inputFileSystem.readFile)(filename))) throw Error('Buffer is undefined');
+                if (!(buffer = await external_node_util_promisify(compilation.inputFileSystem.readFile)(inputFilename))) throw Error('Buffer is undefined');
             } catch (error) {
-                return logger.debug(`read favicon error: ${error}`), addCompilationError(compilation, `${picocolors.dim('[rsbuild:html]')} Failed to read the favicon file at ${picocolors.yellow(filename)}.`), null;
+                return logger.debug(`read favicon error: ${error}`), addCompilationError(compilation, `${picocolors.dim('[rsbuild:html]')} Failed to read the favicon file at ${picocolors.yellow(inputFilename)}.`), null;
             }
-            let source = new compiler.webpack.sources.RawSource(buffer, !1);
-            return compilation.emitAsset(name, source), name;
-        }, addFavicon = async (headTags, favicon, compilation, publicPath)=>{
+            let source = new compiler.webpack.sources.RawSource(buffer, !1), outputFilename = node_path.posix.join(faviconDistPath, name);
+            return compilation.emitAsset(outputFilename, source), outputFilename;
+        }, addFavicon = async ({ headTags, favicon, faviconDistPath, compilation, publicPath })=>{
             let href = favicon;
             if (!isURL(favicon)) {
-                let name = await emitFavicon(compilation, favicon);
+                let name = await emitFavicon({
+                    compilation,
+                    favicon,
+                    faviconDistPath
+                });
                 if (null === name) return;
                 href = ensureAssetPrefix(name, publicPath);
             }
@@ -3124,7 +4147,7 @@ class RsbuildHtmlPlugin {
             hooks.alterAssetTagGroups.tapPromise(this.name, async (data)=>{
                 let extraData = getExtraDataByPlugin(data.plugin);
                 if (!extraData) return data;
-                let { headTags, bodyTags } = data, { favicon, context, tagConfig, entryName, environment, templateContent } = extraData;
+                let { headTags, bodyTags } = data, { favicon, faviconDistPath, context, tagConfig, entryName, environment, templateContent } = extraData;
                 if (!(templateContent && /<title/i.test(templateContent) && /<\/title/i.test(templateContent))) {
                     var _data_plugin_options;
                     ((headTags, title = '')=>{
@@ -3137,7 +4160,13 @@ class RsbuildHtmlPlugin {
                         });
                     })(headTags, null == (_data_plugin_options = data.plugin.options) ? void 0 : _data_plugin_options.title);
                 }
-                favicon && await addFavicon(headTags, favicon, compilation, data.publicPath);
+                favicon && await addFavicon({
+                    headTags,
+                    favicon,
+                    faviconDistPath,
+                    compilation,
+                    publicPath: data.publicPath
+                });
                 let tags = {
                     headTags: headTags.map(formatBasicTag),
                     bodyTags: bodyTags.map(formatBasicTag)
@@ -3652,10 +4681,10 @@ function printServerURLs({ urls: originalUrls, port, routes, protocol, printUrls
         }
         let message = '', maxNameLength = Math.max(...routes.map((r)=>r.entryName.length));
         return urls.forEach(({ label, url }, index)=>{
-            for (let r of (index > 0 && (message += '\n'), message += `  ${`\u{279C}  ${label}`}\n`, routes))message += `  ${picocolors.dim('-')} ${picocolors.dim(r.entryName.padEnd(maxNameLength + 4))}${picocolors.cyan(normalizeUrl(`${url}${r.pathname}`))}\n`;
+            for (let r of (index > 0 && (message += '\n'), message += `  \u{279C}  ${label}\n`, routes))message += `  ${picocolors.dim('-')} ${picocolors.dim(r.entryName.padEnd(maxNameLength + 4))}${picocolors.cyan(normalizeUrl(`${url}${r.pathname}`))}\n`;
         }), message;
     }(urls, routes);
-    return !1 === trailingLineBreak && message.endsWith('\n') && (message = message.slice(0, -1)), logger.log(message), message;
+    return !trailingLineBreak && message.endsWith('\n') && (message = message.slice(0, -1)), logger.log(message), message;
 }
 let getPort = async ({ host, port, strictPort, tryLimits = 20 })=>{
     'string' == typeof port && (port = Number.parseInt(port, 10)), strictPort && (tryLimits = 1);
@@ -3756,7 +4785,9 @@ function getServerTerminator(server) {
         listened = !0;
     }), ()=>new Promise((resolve, reject)=>{
             for (let socket of pendingSockets)socket.destroy();
-            listened ? server.close((err)=>err ? reject(err) : resolve()) : resolve();
+            listened ? server.close((err)=>{
+                err ? reject(err) : resolve();
+            }) : resolve();
         });
 }
 let supportedChromiumBrowsers = [
@@ -3820,7 +4851,7 @@ async function server_open_open({ https, port, routes, config, clearCache }) {
         } : Array.isArray(open) ? {
             targets: open
         } : {
-            targets: open.target ? castArray(open.target) : [],
+            targets: open.target ? helpers_castArray(open.target) : [],
             before: open.before
         };
     })(config);
@@ -3929,8 +4960,8 @@ class HtmlResourceHintsPlugin {
                         return chunks;
                     }(compilation, options.type), sortedFilteredFiles = ((files, include, exclude)=>{
                         let includeRegExp = [], excludeRegExp = [], includeFn = [], excludeFn = [];
-                        if (include) for (let item of castArray(include))'string' == typeof item ? includeRegExp.push(new RegExp(item)) : isFunction(item) ? includeFn.push(item) : includeRegExp.push(item);
-                        if (exclude) for (let item of castArray(exclude))'string' == typeof item ? excludeRegExp.push(new RegExp(item)) : isFunction(item) ? excludeFn.push(item) : excludeRegExp.push(item);
+                        if (include) for (let item of helpers_castArray(include))'string' == typeof item ? includeRegExp.push(new RegExp(item)) : isFunction(item) ? includeFn.push(item) : includeRegExp.push(item);
+                        if (exclude) for (let item of helpers_castArray(exclude))'string' == typeof item ? excludeRegExp.push(new RegExp(item)) : isFunction(item) ? excludeFn.push(item) : excludeRegExp.push(item);
                         return files.filter((file)=>{
                             let includeMatched = !1;
                             for (let item of includeRegExp)item.test(file) && (includeMatched = !0);
@@ -4210,16 +5241,23 @@ async function getResolvedClientConfig(clientConfig, serverConfig) {
         port: serverConfig.port
     };
 }
-let getCompilationMiddleware = async (compiler, options)=>{
-    let { default: rsbuildDevMiddleware } = await import("../compiled/rsbuild-dev-middleware/index.js"), { clientPaths, callbacks, devConfig, serverConfig } = options, resolvedClientConfig = await getResolvedClientConfig(devConfig.client, serverConfig);
+let compilationMiddleware_require = createRequire(import.meta.url), getCompilationMiddleware = async (compiler, options)=>{
+    let { default: rsbuildDevMiddleware } = await import("../compiled/rsbuild-dev-middleware/index.js"), { callbacks, devConfig, serverConfig } = options, resolvedClientConfig = await getResolvedClientConfig(devConfig.client, serverConfig);
     return applyToCompiler(compiler, (compiler, index)=>{
-        var _Object_values_find;
-        let token = null == (_Object_values_find = Object.values(options.environments).find((env)=>env.index === index)) ? void 0 : _Object_values_find.webSocketToken;
-        token && (clientPaths && function({ compiler, clientPaths, devConfig, resolvedClientConfig, token }) {
-            if (((compiler)=>{
+        let environment = Object.values(options.environments).find((env)=>env.index === index);
+        if (!environment) return;
+        let token = environment.webSocketToken;
+        token && (!function({ config, compiler, devConfig, resolvedClientConfig, token }) {
+            if (!((compiler)=>{
                 let { target } = compiler.options;
                 return !!target && (Array.isArray(target) ? target.includes('web') : 'web' === target);
-            })(compiler)) for (let clientPath of (new compiler.webpack.DefinePlugin({
+            })(compiler)) return;
+            let clientPaths = function(devConfig) {
+                var _devConfig_client;
+                let clientPaths = [];
+                return (devConfig.hmr || devConfig.liveReload) && (hmrClientPath || (hmrClientPath = compilationMiddleware_require.resolve('@rsbuild/core/client/hmr')), clientPaths.push(hmrClientPath), (null == (_devConfig_client = devConfig.client) ? void 0 : _devConfig_client.overlay) && (overlayClientPath || (overlayClientPath = compilationMiddleware_require.resolve('@rsbuild/core/client/overlay')), clientPaths.push(overlayClientPath))), clientPaths;
+            }(config.dev);
+            if (clientPaths.length) for (let clientPath of (new compiler.webpack.DefinePlugin({
                 RSBUILD_WEB_SOCKET_TOKEN: JSON.stringify(token),
                 RSBUILD_CLIENT_CONFIG: JSON.stringify(devConfig.client),
                 RSBUILD_RESOLVED_CLIENT_CONFIG: JSON.stringify(resolvedClientConfig),
@@ -4229,10 +5267,10 @@ let getCompilationMiddleware = async (compiler, options)=>{
             }).apply(compiler);
         }({
             compiler,
-            clientPaths,
             devConfig,
             resolvedClientConfig,
-            token
+            token,
+            config: environment.config
         }), (({ compiler, token, callbacks: { onDone, onInvalid } })=>{
             if (((compiler)=>{
                 let { target } = compiler.options;
@@ -4330,9 +5368,6 @@ class SocketServer {
             socket && this.send(socket, messageStr);
         } else for (let socket of this.sockets.values())this.send(socket, messageStr);
     }
-    singleWrite(socket, message) {
-        this.send(socket, JSON.stringify(message));
-    }
     async close() {
         for (let socket of (this.clearHeartbeatTimer(), this.wsServer.removeAllListeners(), this.wsServer.clients))socket.terminate();
         for (let socket of this.sockets.values())socket.close();
@@ -4347,8 +5382,6 @@ class SocketServer {
             socket.isAlive = !0;
         }), this.sockets.set(token, socket), socket.on('close', ()=>{
             this.sockets.delete(token);
-        }), (this.options.hmr || this.options.liveReload) && this.singleWrite(socket, {
-            type: 'hot'
         }), this.stats && this.sendStats({
             force: !0,
             token
@@ -4387,13 +5420,13 @@ class SocketServer {
         let initialChunks = this.initialChunks[token], shouldReload = !!statsJson.entrypoints && !!initialChunks && !(initialChunks.size === newInitialChunks.size && [
             ...initialChunks
         ].every((value)=>newInitialChunks.has(value)));
-        if (this.initialChunks[token] = newInitialChunks, shouldReload) return this.sockWrite({
+        if (this.initialChunks[token] = newInitialChunks, shouldReload) return void this.sockWrite({
             type: 'static-changed'
         }, token);
-        if (!force && statsJson && !statsJson.errorsCount && statsJson.assets && statsJson.assets.every((asset)=>!asset.emitted)) return this.sockWrite({
+        if (!force && statsJson && !statsJson.errorsCount && statsJson.assets && statsJson.assets.every((asset)=>!asset.emitted)) return void this.sockWrite({
             type: 'ok'
         }, token);
-        if (this.sockWrite({
+        if (statsJson.hash && this.sockWrite({
             type: 'hash',
             data: statsJson.hash
         }, token), statsJson.errorsCount) {
@@ -4401,7 +5434,7 @@ class SocketServer {
                 errors: getAllStatsErrors(statsJson),
                 warnings: []
             });
-            return this.sockWrite({
+            this.sockWrite({
                 type: 'errors',
                 data: {
                     text: formattedErrors,
@@ -4561,20 +5594,22 @@ class SocketServer {
                     }(formattedErrors, root)
                 }
             }, token);
+            return;
         }
         if (statsJson.warningsCount) {
             let { warnings: formattedWarnings } = formatStatsMessages({
                 warnings: getAllStatsWarnings(statsJson),
                 errors: []
             });
-            return this.sockWrite({
+            this.sockWrite({
                 type: 'warnings',
                 data: {
                     text: formattedWarnings
                 }
             }, token);
+            return;
         }
-        return this.sockWrite({
+        this.sockWrite({
             type: 'ok'
         }, token);
     }
@@ -4603,7 +5638,6 @@ function compilationManager_define_property(obj, key, value) {
         writable: !0
     }) : obj[key] = value, obj;
 }
-let compilationManager_require = createRequire(import.meta.url);
 class CompilationManager {
     async init() {
         await this.setupCompilationMiddleware(), await this.socketServer.prepare();
@@ -4625,25 +5659,17 @@ class CompilationManager {
         });
     }
     async setupCompilationMiddleware() {
-        let { devConfig, serverConfig, publicPaths, environments } = this, clientPaths = function(devConfig) {
-            var _devConfig_client;
-            let clientPaths = [];
-            return (devConfig.hmr || devConfig.liveReload) && (clientPaths.push(compilationManager_require.resolve('@rsbuild/core/client/hmr')), (null == (_devConfig_client = devConfig.client) ? void 0 : _devConfig_client.overlay) && clientPaths.push(`${compilationManager_require.resolve('@rsbuild/core/client/overlay')}`)), clientPaths;
-        }(devConfig), middleware = await getCompilationMiddleware(this.compiler, {
+        let { devConfig, serverConfig, publicPaths, environments } = this, middleware = await getCompilationMiddleware(this.compiler, {
             callbacks: {
                 onInvalid: (token, fileName)=>{
                     if ('string' == typeof fileName && fileName.endsWith('.html')) return void this.socketServer.sockWrite({
                         type: 'static-changed'
                     }, token);
-                    this.socketServer.sockWrite({
-                        type: 'invalid'
-                    }, token);
                 },
                 onDone: (token, stats)=>{
                     this.socketServer.updateStats(stats, token);
                 }
             },
-            clientPaths,
             devConfig,
             serverConfig,
             environments
@@ -4673,10 +5699,10 @@ class CompilationManager {
 }
 let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i, gzipMiddleware = ({ filter, level = node_zlib.constants.Z_BEST_SPEED } = {})=>(req, res, next)=>{
         let gzip, writeHeadStatus;
-        if (filter && !1 === filter(req, res)) return void next();
+        if (filter && !filter(req, res)) return void next();
         let accept = req.headers['accept-encoding'], encoding = 'string' == typeof accept && ENCODING_REGEX.test(accept);
         if ('HEAD' === req.method || !encoding) return void next();
-        let started = !1, { end, write, on, writeHead } = res, listeners = [], start = ()=>{
+        let started = !1, on = res.on.bind(res), end = res.end.bind(res), write = res.write.bind(res), writeHead = res.writeHead.bind(res), listeners = [], start = ()=>{
             if (!started) {
                 if (started = !0, ((res)=>{
                     if (res.getHeader('Content-Encoding')) return !1;
@@ -4687,22 +5713,77 @@ let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xm
                 })(res)) for (let listener of (res.setHeader('Content-Encoding', 'gzip'), res.removeHeader('Content-Length'), (gzip = node_zlib.createGzip({
                     level
                 })).on('data', (chunk)=>{
-                    !1 === write.call(res, chunk) && gzip.pause();
-                }), on.call(res, 'drain', ()=>gzip.resume()), gzip.on('end', ()=>{
-                    end.call(res);
+                    write(chunk) || gzip.pause();
+                }), on('drain', ()=>gzip.resume()), gzip.on('end', ()=>{
+                    end();
                 }), listeners))gzip.on.apply(gzip, listener);
                 else for (let listener of listeners)on.apply(res, listener);
-                writeHead.call(res, writeHeadStatus ?? res.statusCode);
+                writeHead(writeHeadStatus ?? res.statusCode);
             }
         };
         res.writeHead = (status, reason, headers)=>{
             if (reason) for (let [key, value] of Object.entries(headers || reason))res.setHeader(key, value);
             return writeHeadStatus = status, res;
-        }, res.write = (...args)=>(start(), gzip ? gzip.write(...args) : write.apply(res, args)), res.end = (...args)=>(start(), gzip ? gzip.end(...args) : end.apply(res, args)), res.on = (type, listener)=>(started ? gzip && 'drain' === type ? gzip.on(type, listener) : on.call(res, type, listener) : listeners.push([
+        }, res.write = (...args)=>(start(), gzip ? gzip.write(...args) : write.apply(res, args)), res.end = (...args)=>(start(), gzip ? gzip.end(...args) : end.apply(res, args)), res.on = (type, listener)=>(started ? gzip && 'drain' === type ? gzip.on(type, listener) : on(type, listener) : listeners.push([
                 type,
                 listener
             ]), res), next();
-    }, faviconFallbackMiddleware = (req, res, next)=>{
+    };
+function historyApiFallbackMiddleware(options = {}) {
+    return (req, _res, next)=>{
+        let rewriteTarget, { headers } = req;
+        if (!req.url) return void next();
+        if ('GET' !== req.method && 'HEAD' !== req.method) {
+            logger.debug('Not rewriting', req.method, req.url, 'because the method is not GET or HEAD.'), next();
+            return;
+        }
+        if (!headers || 'string' != typeof headers.accept) {
+            logger.debug('Not rewriting', req.method, req.url, 'because the client did not send an HTTP accept header.'), next();
+            return;
+        }
+        if (0 === headers.accept.indexOf('application/json')) {
+            logger.debug('Not rewriting', req.method, req.url, 'because the client prefers JSON.'), next();
+            return;
+        }
+        let rewrites = options.rewrites || [], htmlAcceptHeaders = options.htmlAcceptHeaders || [
+            'text/html',
+            '*/*'
+        ], { accept } = headers;
+        if (!htmlAcceptHeaders.some((item)=>accept.includes(item))) {
+            logger.debug('Not rewriting', req.method, req.url, 'because the client does not accept HTML.'), next();
+            return;
+        }
+        let parsedUrl = function(req) {
+            let proto = req.headers['x-forwarded-proto'] || 'http', host = req.headers['x-forwarded-host'] || req.headers.host || 'localhost';
+            try {
+                return new external_node_url_URL(req.url || '/', `${proto}://${host}`);
+            } catch  {
+                return null;
+            }
+        }(req);
+        if (null === parsedUrl) return void next();
+        for (let rewrite of rewrites){
+            var _parsedUrl_pathname;
+            let match = null == (_parsedUrl_pathname = parsedUrl.pathname) ? void 0 : _parsedUrl_pathname.match(rewrite.from);
+            if (!match) continue;
+            let rule = rewrite.to;
+            '/' !== (rewriteTarget = 'string' == typeof rule ? rule : rule({
+                parsedUrl,
+                match,
+                request: req
+            })).charAt(0) && logger.debug('We recommend using an absolute path for the rewrite target.', 'Received a non-absolute rewrite target', rewriteTarget, 'for URL', req.url), logger.debug('Rewriting', req.method, req.url, 'to', rewriteTarget), req.url = rewriteTarget, next();
+            return;
+        }
+        let { pathname } = parsedUrl;
+        if (pathname && pathname.lastIndexOf('.') > pathname.lastIndexOf('/') && !0 !== options.disableDotRule) {
+            logger.debug('Not rewriting', req.method, req.url, 'because the path includes a dot (.) character.'), next();
+            return;
+        }
+        let index = options.index || '/index.html';
+        logger.debug('Rewriting', req.method, req.url, 'to', index), req.url = index, next();
+    };
+}
+let faviconFallbackMiddleware = (req, res, next)=>{
     '/favicon.ico' === req.url ? (res.statusCode = 204, res.end()) : next();
 }, getRequestLoggerMiddleware = async ()=>{
     let { default: onFinished } = await import("../compiled/on-finished/index.js");
@@ -4732,7 +5813,10 @@ let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xm
 }, postfixRE = /[?#].*$/, getUrlPathname = (url)=>url.replace(postfixRE, ''), getBaseMiddleware = ({ base })=>async (req, res, next)=>{
         var _req_headers_accept;
         let url = req.url, pathname = getUrlPathname(url);
-        if (pathname.startsWith(base)) return req.url = stripBase(url, base), next();
+        if (pathname.startsWith(base)) {
+            req.url = stripBase(url, base), next();
+            return;
+        }
         let redirectPath = addTrailingSlash(url) !== base ? joinUrlSegments(base, url) : base;
         if ('/' === pathname || '/index.html' === pathname) {
             res.writeHead(302, {
@@ -4815,10 +5899,10 @@ let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xm
         '/__open-in-editor',
         launchEditorMiddleware()
     ]), middlewares.push((({ environments })=>async (req, res, next)=>{
-            if ('/rsbuild-dev-server' === getUrlPathname(req.url)) {
-                res.writeHead(200, {
-                    'Content-Type': 'text/html; charset=utf-8'
-                }), res.write(`<!DOCTYPE html>
+            if ('/rsbuild-dev-server' !== getUrlPathname(req.url)) return void next();
+            res.writeHead(200, {
+                'Content-Type': 'text/html; charset=utf-8'
+            }), res.write(`<!DOCTYPE html>
 <html>
   <head>
     <meta charset="utf-8"/>
@@ -4861,35 +5945,35 @@ let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xm
     <h1>Assets Report</h1>
   </body>
 </html>`);
-                try {
-                    for(let key in environments){
-                        let list = [];
-                        res.write(`<h2>Environment: ${key}</h2>`);
-                        let environment = environments[key], { assets = [] } = (await environment.getStats()).toJson();
-                        for (let asset of (res.write('<ul>'), assets))list.push(`<li><a target="_blank" href="${null == asset ? void 0 : asset.name}">${null == asset ? void 0 : asset.name}</a></li>`);
-                        res.write(null == list ? void 0 : list.join('')), res.write('</ul>');
-                    }
-                    res.end('</body></html>');
-                } catch (err) {
-                    logger.error(err), res.writeHead(500), res.end('Failed to list the files');
+            try {
+                for(let key in environments){
+                    res.write(`<h2>Environment: ${key}</h2>`);
+                    let list = [], environment = environments[key], stats = await environment.getStats(), assets = getAssetsFromStats(stats);
+                    for (let asset of (res.write('<ul>'), assets))list.push(`<li><a target="_blank" href="${null == asset ? void 0 : asset.name}">${null == asset ? void 0 : asset.name}</a></li>`);
+                    res.write(null == list ? void 0 : list.join('')), res.write('</ul>');
                 }
-            } else next();
+                res.end('</body></html>');
+            } catch (err) {
+                logger.error(err), res.writeHead(500), res.end('Failed to list the files');
+            }
         })({
         environments: devServerAPI.environments
     })), compilationManager && (middlewares.push(compilationManager.middleware), upgradeEvents.push(compilationManager.socketServer.upgrade), middlewares.push((req, res, next)=>{
         var _req_url;
         (null == (_req_url = req.url) ? void 0 : _req_url.endsWith('.hot-update.json')) && 'OPTIONS' !== req.method ? (res.statusCode = 404, res.end()) : next();
     })), compilationManager && middlewares.push((({ distPath, compilationManager })=>async (req, res, next)=>{
-            if (!maybeHTMLRequest(req)) return next();
-            let pathname = getUrlPathname(req.url), rewrite = (newUrl)=>(req.url = newUrl, compilationManager.middleware(req, res, (...args)=>{
+            if (!maybeHTMLRequest(req)) return void next();
+            let pathname = getUrlPathname(req.url), rewrite = (newUrl)=>{
+                req.url = newUrl, compilationManager.middleware(req, res, (...args)=>{
                     next(...args);
-                }));
+                });
+            };
             if (pathname.endsWith('/')) {
                 let newUrl = `${pathname}index.html`, filePath = node_path.join(distPath, newUrl);
-                if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) return rewrite(newUrl);
+                if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) return void rewrite(newUrl);
             } else if (!node_path.extname(pathname)) {
                 let newUrl = `${pathname}.html`, filePath = node_path.join(distPath, newUrl);
-                if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) return rewrite(newUrl);
+                if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) return void rewrite(newUrl);
             }
             next();
         })({
@@ -4903,23 +5987,22 @@ let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xm
         middlewares.push(assetMiddleware);
     }
     for (let callback of postCallbacks)callback();
-    if (compilationManager && middlewares.push((({ htmlFallback, distPath, compilationManager })=>async (req, res, next)=>{
-            if (!maybeHTMLRequest(req) || '/favicon.ico' === req.url || 'index' !== htmlFallback) return next();
+    return compilationManager && middlewares.push((({ htmlFallback, distPath, compilationManager })=>async (req, res, next)=>{
+            if (!maybeHTMLRequest(req) || '/favicon.ico' === req.url || 'index' !== htmlFallback) return void next();
             let filePath = node_path.join(distPath, 'index.html');
             if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) {
                 let newUrl = '/index.html';
-                return 'verbose' === logger.level && logger.debug(`${req.method} ${picocolors.gray(`${req.url} ${picocolors.yellow('fallback')} to ${newUrl}`)}`), req.url = newUrl, compilationManager.middleware(req, res, (...args)=>next(...args));
+                'verbose' === logger.level && logger.debug(`${req.method} ${picocolors.gray(`${req.url} ${picocolors.yellow('fallback')} to ${newUrl}`)}`), req.url = newUrl, compilationManager.middleware(req, res, (...args)=>{
+                    next(...args);
+                });
+                return;
             }
             next();
         })({
         compilationManager,
         distPath: context.distPath,
         htmlFallback: server.htmlFallback
-    })), server.historyApiFallback) {
-        let { default: connectHistoryApiFallback } = await import("../compiled/connect-history-api-fallback/index.js"), historyApiFallbackMiddleware = connectHistoryApiFallback(!0 === server.historyApiFallback ? {} : server.historyApiFallback);
-        middlewares.push(historyApiFallbackMiddleware), (null == compilationManager ? void 0 : compilationManager.middleware) && middlewares.push(compilationManager.middleware);
-    }
-    return middlewares.push(faviconFallbackMiddleware), {
+    })), server.historyApiFallback && (middlewares.push(historyApiFallbackMiddleware(!0 === server.historyApiFallback ? {} : server.historyApiFallback)), (null == compilationManager ? void 0 : compilationManager.middleware) && middlewares.push(compilationManager.middleware)), middlewares.push(faviconFallbackMiddleware), {
         onUpgrade: (...args)=>{
             for (let cb of upgradeEvents)cb(...args);
         }
@@ -4932,7 +6015,7 @@ let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xm
             'sockWrite',
             'environments'
         ]), before = [], after = [];
-        for (let handler of castArray(setupMiddlewares))handler({
+        for (let handler of helpers_castArray(setupMiddlewares))handler({
             unshift: (...handlers)=>before.unshift(...handlers),
             push: (...handlers)=>after.push(...handlers)
         }, serverOptions);
@@ -4961,12 +6044,12 @@ let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xm
             'default',
             ...Object.keys(something)
         ])
-    ], m = new SyntheticModule(exports, ()=>{
-        for (let name of exports)m.setExport(name, 'default' === name ? something : something[name]);
+    ], syntheticModule = new SyntheticModule(exports, ()=>{
+        for (let name of exports)syntheticModule.setExport(name, 'default' === name ? something : something[name]);
     }, {
         context
     });
-    return unlinked || (await m.link(()=>{}), m.instantiate && m.instantiate(), await m.evaluate()), m;
+    return unlinked || (await syntheticModule.link(()=>{}), await syntheticModule.evaluate()), syntheticModule;
 };
 function basic_define_property(obj, key, value) {
     return key in obj ? Object.defineProperty(obj, key, {
@@ -5123,16 +6206,13 @@ class EsmRunner extends CommonJsRunner {
                 initializeImportMeta: (meta, _)=>{
                     meta.url = pathToFileURL(file.path).href;
                 },
-                importModuleDynamically: async (specifier, module)=>{
-                    let result = await _require(node_path.dirname(file.path), specifier, {
+                importModuleDynamically: async (specifier, module)=>asModule(await _require(node_path.dirname(file.path), specifier, {
                         esmMode: type_EsmMode.Evaluated
-                    });
-                    return await asModule(result, module.context);
-                }
+                    }), module.context)
             }), esmCache.set(file.path, esm)), context.esmMode === type_EsmMode.Unlinked) ? esm : (async ()=>{
-                if (await esm.link(async (specifier, referencingModule)=>await asModule(await _require(node_path.dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : fileURLToPath(referencingModule.url)), specifier, {
+                if (await esm.link(async (specifier, referencingModule)=>asModule(await _require(node_path.dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : fileURLToPath(referencingModule.url)), specifier, {
                         esmMode: type_EsmMode.Unlinked
-                    }), referencingModule.context, !0)), esm.instantiate && esm.instantiate(), await esm.evaluate(), context.esmMode === type_EsmMode.Evaluated) return esm;
+                    }), referencingModule.context, !0)), await esm.evaluate(), context.esmMode === type_EsmMode.Evaluated) return esm;
                 let ns = esm.namespace;
                 return ns.default && ns.default instanceof Promise ? ns.default : ns;
             })();
@@ -5264,7 +6344,7 @@ async function watchDevFiles(devConfig, compilationManager, root) {
     let { watchFiles } = devConfig;
     if (!watchFiles) return;
     let watchers = [];
-    for (let { paths, options, type } of castArray(watchFiles)){
+    for (let { paths, options, type } of helpers_castArray(watchFiles)){
         let watchOptions = prepareWatchOptions(paths, options, type), watcher = await startWatchFiles(watchOptions, compilationManager, root);
         watcher && watchers.push(watcher);
     }
@@ -5564,13 +6644,9 @@ class RsbuildProdServer {
                 ...'object' == typeof compress ? compress : void 0
             }));
         }
-        if (base && '/' !== base && this.middlewares.use(getBaseMiddleware({
+        base && '/' !== base && this.middlewares.use(getBaseMiddleware({
             base
-        })), await this.applyStaticAssetMiddleware(), historyApiFallback) {
-            let { default: connectHistoryApiFallback } = await import("../compiled/connect-history-api-fallback/index.js"), historyApiFallbackMiddleware = connectHistoryApiFallback(!0 === historyApiFallback ? {} : historyApiFallback);
-            this.middlewares.use(historyApiFallbackMiddleware), await this.applyStaticAssetMiddleware();
-        }
-        this.middlewares.use(faviconFallbackMiddleware), this.middlewares.use(optionsFallbackMiddleware), this.middlewares.use(notFoundMiddleware);
+        })), await this.applyStaticAssetMiddleware(), historyApiFallback && (this.middlewares.use(historyApiFallbackMiddleware(!0 === historyApiFallback ? {} : historyApiFallback)), await this.applyStaticAssetMiddleware()), this.middlewares.use(faviconFallbackMiddleware), this.middlewares.use(optionsFallbackMiddleware), this.middlewares.use(notFoundMiddleware);
     }
     async applyStaticAssetMiddleware() {
         let { output: { path, assetPrefixes }, serverConfig: { htmlFallback } } = this.options, { default: sirv } = await import("../compiled/sirv/index.js"), assetMiddleware = sirv(path, {
@@ -5717,7 +6793,7 @@ async function applyDefaultPlugins(pluginManager, context) {
                                 entryPoint.add(rest);
                             } else entryPoint.add(item);
                         };
-                        preEntry.forEach(addEntry), injectCoreJsEntry && addEntry(createVirtualModule('import "core-js";')), castArray(entry[entryName]).forEach(addEntry);
+                        preEntry.forEach(addEntry), injectCoreJsEntry && addEntry(createVirtualModule('import "core-js";')), helpers_castArray(entry[entryName]).forEach(addEntry);
                     }
                 }), api.onBeforeCreateCompiler(({ bundlerConfigs })=>{
                     if (bundlerConfigs.every((config)=>!config.entry)) throw Error(`${picocolors.dim('[rsbuild:config]')} Could not find any entry module, please make sure that ${picocolors.yellow('src/index.(ts|js|tsx|jsx|mts|cts|mjs|cjs)')} exists, or customize entry through the ${picocolors.yellow('source.entry')} configuration.`);
@@ -5795,7 +6871,7 @@ async function applyDefaultPlugins(pluginManager, context) {
                         let { dev, output, server } = config, publicPath = DEFAULT_ASSET_PREFIX;
                         if (isDev) {
                             if ('string' == typeof dev.assetPrefix) publicPath = dev.assetPrefix;
-                            else if (!0 === dev.assetPrefix) {
+                            else if (dev.assetPrefix) {
                                 let protocol = (null == (_context_devServer1 = context.devServer) ? void 0 : _context_devServer1.https) ? 'https' : 'http', hostname = (null == (_context_devServer2 = context.devServer) ? void 0 : _context_devServer2.hostname) || DEFAULT_DEV_HOST;
                                 publicPath = hostname === DEFAULT_DEV_HOST ? `${protocol}://localhost:<port>/` : `${protocol}://${hostname}:<port>/`, server.base && '/' !== server.base && (publicPath = urlJoin(publicPath, server.base));
                             }
@@ -5882,7 +6958,7 @@ async function applyDefaultPlugins(pluginManager, context) {
                                 mergedAlias[pkgName] = pkgPath;
                             }
                             for (let name of Object.keys(mergedAlias)){
-                                let formattedValues = castArray(mergedAlias[name]).map((value)=>'string' == typeof value && value.startsWith('.') ? ensureAbsolutePath(rootPath, value) : value);
+                                let formattedValues = helpers_castArray(mergedAlias[name]).map((value)=>'string' == typeof value && value.startsWith('.') ? ensureAbsolutePath(rootPath, value) : value);
                                 chain.resolve.alias.set(name, 1 === formattedValues.length ? formattedValues[0] : formattedValues);
                             }
                         }({
@@ -6076,11 +7152,12 @@ async function applyDefaultPlugins(pluginManager, context) {
                         let extraData = {
                             entryName,
                             context: context,
-                            environment
+                            environment,
+                            faviconDistPath: config.output.distPath.favicon
                         };
                         extraDataMap.set(entryName, extraData), templateContent && (extraData.templateContent = templateContent);
                         let tagConfig = ((config)=>{
-                            let tags = castArray(config.html.tags).filter(Boolean);
+                            let tags = helpers_castArray(config.html.tags).filter(Boolean);
                             if (tags.length) return {
                                 append: !0,
                                 hash: !1,
@@ -6157,7 +7234,7 @@ async function applyDefaultPlugins(pluginManager, context) {
                 }, async ({ compilation, environment, sources })=>{
                     let { config } = environment, { appIcon } = config.html;
                     if (!appIcon) return;
-                    let distDir = config.output.distPath.image, manifestFile = appIcon.filename ?? 'manifest.webmanifest', publicPath = getPublicPathFromCompiler(compilation), icons = appIcon.icons.map((icon)=>((icon, distDir, publicPath)=>{
+                    let { lookup } = await import("../compiled/mrmime/index.js"), distDir = config.output.distPath.image, manifestFile = appIcon.filename ?? 'manifest.webmanifest', publicPath = getPublicPathFromCompiler(compilation), icons = appIcon.icons.map((icon)=>((icon, distDir, publicPath, lookup)=>{
                             let { src, size } = icon, cached = iconFormatMap.get(src);
                             if (cached) return cached;
                             let sizes = `${size}x${size}`;
@@ -6181,7 +7258,7 @@ async function applyDefaultPlugins(pluginManager, context) {
                                 mimeType: lookup(absolutePath)
                             };
                             return iconFormatMap.set(src, formatted), formatted;
-                        })(icon, distDir, publicPath)), tags = [];
+                        })(icon, distDir, publicPath, lookup)), tags = [];
                     for (let icon of icons){
                         if ('web-app-manifest' === icon.target && !appIcon.name) {
                             addCompilationError(compilation, `${picocolors.dim('[rsbuild:app-icon]')} ${picocolors.yellow('"appIcon.name"')} is required when ${picocolors.yellow('"target"')} is ${picocolors.yellow('"web-app-manifest"')}.`);
@@ -6593,7 +7670,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             let finalPluginImport = ((options)=>{
                                 if (!options) return [];
                                 let imports = [];
-                                for (let item of castArray(options))isFunction(item) ? imports = item(imports) ?? imports : imports.push(item);
+                                for (let item of helpers_castArray(options))isFunction(item) ? imports = item(imports) ?? imports : imports.push(item);
                                 return imports;
                             })(pluginImport);
                             (null == finalPluginImport ? void 0 : finalPluginImport.length) && (swcConfig.rspackExperiments ??= {}, swcConfig.rspackExperiments.import ??= [], swcConfig.rspackExperiments.import.push(...finalPluginImport));
@@ -6610,7 +7687,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                 default:
                                     throw Error(`${picocolors.dim('[rsbuild:swc]')} Unknown decorators version: ${picocolors.yellow(version)}`);
                             }
-                        }(swcConfig, config), castArray(target).includes('web') || target.includes('web-worker')) {
+                        }(swcConfig, config), helpers_castArray(target).includes('web') || target.includes('web-worker')) {
                             let polyfillMode = config.output.polyfill;
                             if ('off' === polyfillMode) swcConfig.env.mode = void 0;
                             else {
@@ -6831,7 +7908,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     if (prefetch) {
                         let options = !0 === prefetch ? {} : prefetch;
                         excludes.length && (options.exclude = options.exclude ? [
-                            ...castArray(options.exclude),
+                            ...helpers_castArray(options.exclude),
                             ...excludes
                         ] : excludes), chain.plugin(CHAIN_ID.PLUGIN.HTML_PREFETCH).use(HtmlResourceHintsPlugin, [
                             options,
@@ -6842,7 +7919,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     if (preload) {
                         let options = !0 === preload ? {} : preload;
                         excludes.length && (options.exclude = options.exclude ? [
-                            ...castArray(options.exclude),
+                            ...helpers_castArray(options.exclude),
                             ...excludes
                         ] : excludes), chain.plugin(CHAIN_ID.PLUGIN.HTML_PRELOAD).use(HtmlResourceHintsPlugin, [
                             options,
@@ -7174,7 +8251,7 @@ async function createRsbuild(options = {}) {
             ...envs.publicVars,
             ...config.source.define
         }, 0 !== envs.filePaths.length && (config.dev ||= {}, config.dev.watchFiles = [
-            ...config.dev.watchFiles ? castArray(config.dev.watchFiles) : [],
+            ...config.dev.watchFiles ? helpers_castArray(config.dev.watchFiles) : [],
             {
                 paths: envs.filePaths,
                 type: 'reload-server'
@@ -7393,42 +8470,60 @@ async function createRsbuild(options = {}) {
                 onAfterStartProdServer: hooks.onAfterStartProdServer.tap,
                 onBeforeStartProdServer: hooks.onBeforeStartProdServer.tap,
                 modifyRsbuildConfig: hooks.modifyRsbuildConfig.tap,
-                modifyHTML: (handler)=>hooks.modifyHTML.tapEnvironment({
+                modifyHTML: (handler)=>{
+                    hooks.modifyHTML.tapEnvironment({
                         environment,
                         handler
-                    }),
-                modifyHTMLTags: (handler)=>hooks.modifyHTMLTags.tapEnvironment({
+                    });
+                },
+                modifyHTMLTags: (handler)=>{
+                    hooks.modifyHTMLTags.tapEnvironment({
                         environment,
                         handler
-                    }),
-                modifyBundlerChain: (handler)=>hooks.modifyBundlerChain.tapEnvironment({
+                    });
+                },
+                modifyBundlerChain: (handler)=>{
+                    hooks.modifyBundlerChain.tapEnvironment({
                         environment,
                         handler
-                    }),
-                modifyRspackConfig: (handler)=>hooks.modifyRspackConfig.tapEnvironment({
+                    });
+                },
+                modifyRspackConfig: (handler)=>{
+                    hooks.modifyRspackConfig.tapEnvironment({
                         environment,
                         handler
-                    }),
-                modifyWebpackChain: (handler)=>hooks.modifyWebpackChain.tapEnvironment({
+                    });
+                },
+                modifyWebpackChain: (handler)=>{
+                    hooks.modifyWebpackChain.tapEnvironment({
                         environment,
                         handler
-                    }),
-                modifyWebpackConfig: (handler)=>hooks.modifyWebpackConfig.tapEnvironment({
+                    });
+                },
+                modifyWebpackConfig: (handler)=>{
+                    hooks.modifyWebpackConfig.tapEnvironment({
                         environment,
                         handler
-                    }),
-                modifyEnvironmentConfig: (handler)=>hooks.modifyEnvironmentConfig.tapEnvironment({
+                    });
+                },
+                modifyEnvironmentConfig: (handler)=>{
+                    hooks.modifyEnvironmentConfig.tapEnvironment({
                         environment,
                         handler
-                    }),
-                onAfterEnvironmentCompile: (handler)=>hooks.onAfterEnvironmentCompile.tapEnvironment({
+                    });
+                },
+                onAfterEnvironmentCompile: (handler)=>{
+                    hooks.onAfterEnvironmentCompile.tapEnvironment({
                         environment,
                         handler
-                    }),
-                onBeforeEnvironmentCompile: (handler)=>hooks.onBeforeEnvironmentCompile.tapEnvironment({
+                    });
+                },
+                onBeforeEnvironmentCompile: (handler)=>{
+                    hooks.onBeforeEnvironmentCompile.tapEnvironment({
                         environment,
                         handler
-                    })
+                    });
+                }
             });
     }({
         context,
@@ -7469,7 +8564,7 @@ async function createRsbuild(options = {}) {
             return startProdServer(context, config, options);
         },
         startDevServer: (...args)=>(context.action = 'dev', process.env.NODE_ENV || setNodeEnv('development'), providerInstance.startDevServer(...args)),
-        createCompiler: (...args)=>(context.action || (context.action = 'development' === process.env.NODE_ENV ? 'dev' : 'build'), providerInstance.createCompiler(...args)),
+        createCompiler: (...args)=>(context.action || (context.action = 'development' === (process.env.NODE_ENV || '') ? 'dev' : 'build'), providerInstance.createCompiler(...args)),
         createDevServer: (...args)=>(context.action = 'dev', process.env.NODE_ENV || setNodeEnv('development'), providerInstance.createDevServer(...args)),
         ...pick(pluginManager, [
             'addPlugins',
@@ -7573,7 +8668,7 @@ async function loadConfig_loadConfig({ cwd = process.cwd(), path, envMode, meta,
         throw logger.error(`Failed to load file with jiti: ${picocolors.dim(configFilePath)}`), err;
     }
     if ('function' == typeof configExport) {
-        let command = process.argv[2], nodeEnv = process.env.NODE_ENV, result = await configExport({
+        let command = process.argv[2], nodeEnv = process.env.NODE_ENV || '', result = await configExport({
             env: nodeEnv,
             command,
             envMode: envMode || nodeEnv,
@@ -7600,17 +8695,17 @@ let commonOpts = {}, init_loadConfig = async (root)=>{
         loader: commonOpts.configLoader
     });
     return config.dev ||= {}, config.source ||= {}, config.server ||= {}, commonOpts.base && (config.server.base = commonOpts.base), commonOpts.root && (config.root = root), commonOpts.mode && (config.mode = commonOpts.mode), commonOpts.logLevel && (config.logLevel = commonOpts.logLevel), !commonOpts.open || (null == (_config_server = config.server) ? void 0 : _config_server.open) || (config.server.open = commonOpts.open), commonOpts.host && (config.server.host = commonOpts.host), commonOpts.port && (config.server.port = commonOpts.port), void 0 === config.dev.cliShortcuts && (config.dev.cliShortcuts = !0), filePath && (config.dev.watchFiles = [
-        ...config.dev.watchFiles ? castArray(config.dev.watchFiles) : [],
+        ...config.dev.watchFiles ? helpers_castArray(config.dev.watchFiles) : [],
         {
             paths: filePath,
             type: 'reload-server'
         }
     ]), config;
 };
-async function init({ cliOptions, isRestart, isBuildWatch = !1 }) {
-    cliOptions && (commonOpts = cliOptions);
+async function init_init({ cliOptions, isRestart, isBuildWatch = !1 }) {
+    var _commonOpts_environment, envDir;
+    cliOptions && (commonOpts = cliOptions), commonOpts.environment = null == (_commonOpts_environment = commonOpts.environment) ? void 0 : _commonOpts_environment.flatMap((env)=>env.split(','));
     try {
-        var envDir;
         let cwd = process.cwd(), root = commonOpts.root ? ensureAbsolutePath(cwd, commonOpts.root) : cwd, rsbuild = await createRsbuild({
             cwd: root,
             rsbuildConfig: ()=>init_loadConfig(root),
@@ -7625,7 +8720,7 @@ async function init({ cliOptions, isRestart, isBuildWatch = !1 }) {
             let files = [], config = rsbuild.getNormalizedConfig();
             if (config.dev.watchFiles) for (let watchConfig of config.dev.watchFiles){
                 if ('reload-server' !== watchConfig.type) continue;
-                let paths = castArray(watchConfig.paths);
+                let paths = helpers_castArray(watchConfig.paths);
                 watchConfig.options ? watchFilesForRestart({
                     files: paths,
                     rsbuild,
@@ -7659,7 +8754,7 @@ let cleaners = [], onBeforeRestartServer = (cleaner)=>{
         clear,
         id: 'server'
     });
-    let rsbuild = await init({
+    let rsbuild = await init_init({
         isRestart: !0
     });
     return !!rsbuild && (await rsbuild.startDevServer(), !0);
@@ -7669,7 +8764,7 @@ let cleaners = [], onBeforeRestartServer = (cleaner)=>{
         clear,
         id: 'build'
     });
-    let rsbuild = await init({
+    let rsbuild = await init_init({
         isRestart: !0,
         isBuildWatch: !0
     });
@@ -7714,11 +8809,11 @@ async function runCLI() {
         ].includes(level) && (logger.level = level);
     }
     let { npm_execpath } = process.env;
-    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.11\n`);
+    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.13\n`);
     try {
         !function() {
             let cli = ((name = "")=>new CAC(name))('rsbuild');
-            cli.help(), cli.version("1.4.11"), cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
+            cli.help(), cli.version("1.4.13"), cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
                 default: 'jiti'
             }).option('-r, --root <root>', 'specify the project root directory, can be an absolute path or a path relative to cwd').option('-m, --mode <mode>', 'specify the build mode, can be `development`, `production` or `none`').option('--log-level <level>', 'specify the log level, can be `info`, `warn`, `error` or `silent`').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file').option('--environment <name>', 'specify the name of environment to build', {
                 type: [
@@ -7729,7 +8824,7 @@ async function runCLI() {
             let devCommand = cli.command('', 'starting the dev server').alias('dev'), buildCommand = cli.command('build', 'build the app for production'), previewCommand = cli.command('preview', 'preview the production build locally'), inspectCommand = cli.command('inspect', 'inspect the Rspack and Rsbuild configs');
             applyServerOptions(devCommand), applyServerOptions(previewCommand), devCommand.action(async (options)=>{
                 try {
-                    let rsbuild = await init({
+                    let rsbuild = await init_init({
                         cliOptions: options
                     });
                     await (null == rsbuild ? void 0 : rsbuild.startDevServer());
@@ -7738,7 +8833,7 @@ async function runCLI() {
                 }
             }), buildCommand.option('-w, --watch', 'turn on watch mode, watch for changes and rebuild').action(async (options)=>{
                 try {
-                    let rsbuild = await init({
+                    let rsbuild = await init_init({
                         cliOptions: options,
                         isBuildWatch: options.watch
                     }), buildInstance = await (null == rsbuild ? void 0 : rsbuild.build({
@@ -7750,7 +8845,7 @@ async function runCLI() {
                 }
             }), previewCommand.action(async (options)=>{
                 try {
-                    let rsbuild = await init({
+                    let rsbuild = await init_init({
                         cliOptions: options
                     });
                     await (null == rsbuild ? void 0 : rsbuild.preview());
@@ -7759,7 +8854,7 @@ async function runCLI() {
                 }
             }), inspectCommand.option('--output <output>', 'specify inspect content output path').option('--verbose', 'show full function definitions in output').action(async (options)=>{
                 try {
-                    let rsbuild = await init({
+                    let rsbuild = await init_init({
                         cliOptions: options
                     });
                     await (null == rsbuild ? void 0 : rsbuild.inspectConfig({
@@ -7776,5 +8871,5 @@ async function runCLI() {
         logger.error('Failed to start Rsbuild CLI.'), logger.error(err);
     }
 }
-let src_version = "1.4.11";
+let src_version = "1.4.13";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger, mergeRsbuildConfig, rspack_rspack as rspack, runCLI, src_version as version };