@rsbuild/core 1.4.11 → 1.4.13

package/dist/index.cjs

@@ -164,6 +164,304 @@ var __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, exports1) {
+        "use strict";
+        Object.defineProperty(exports1, "__esModule", {
+            value: !0
+        }), exports1.arrayToString = void 0, exports1.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, exports1, __webpack_require__) {
+        "use strict";
+        Object.defineProperty(exports1, "__esModule", {
+            value: !0
+        }), exports1.FunctionParser = exports1.dedentFunction = exports1.functionToString = exports1.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;
+        }
+        exports1.USED_METHOD_KEY = new WeakSet(), exports1.functionToString = (fn, space, next, key)=>{
+            let name = "string" == typeof key ? key : void 0;
+            return void 0 !== name && exports1.USED_METHOD_KEY.add(fn), new FunctionParser(fn, space, next, name).stringify();
+        }, exports1.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|\/\/.*|\/\*[^]*?\*\/)*/);
+            }
+        }
+        exports1.FunctionParser = FunctionParser;
+    },
+    "../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/index.js": function(__unused_webpack_module, exports1, __webpack_require__) {
+        "use strict";
+        exports1.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");
+        exports1.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, exports1, __webpack_require__) {
+        "use strict";
+        Object.defineProperty(exports1, "__esModule", {
+            value: !0
+        }), exports1.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");
+        exports1.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, exports1) {
+        "use strict";
+        Object.defineProperty(exports1, "__esModule", {
+            value: !0
+        }), exports1.stringifyPath = exports1.quoteKey = exports1.isValidVariableName = exports1.IS_VALID_IDENTIFIER = exports1.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)}`;
+        }
+        exports1.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) && exports1.IS_VALID_IDENTIFIER.test(name);
+        }
+        exports1.IS_VALID_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/, exports1.isValidVariableName = isValidVariableName, exports1.quoteKey = function(key, next) {
+            return isValidVariableName(key) ? key : next(key);
+        }, exports1.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, exports1, __webpack_require__) {
+        "use strict";
+        Object.defineProperty(exports1, "__esModule", {
+            value: !0
+        }), exports1.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
+        };
+        exports1.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) {
@@ -723,12 +1021,6 @@ var __webpack_modules__ = {
             return module;
         });
     },
-    "../../compiled/connect-history-api-fallback/index.js": function(module) {
-        "use strict";
-        module.exports = import("../compiled/connect-history-api-fallback/index.js").then(function(module) {
-            return module;
-        });
-    },
     "../../compiled/connect/index.js": function(module) {
         "use strict";
         module.exports = import("../compiled/connect/index.js").then(function(module) {
@@ -753,6 +1045,12 @@ var __webpack_modules__ = {
             return module;
         });
     },
+    "../../compiled/mrmime/index.js": function(module) {
+        "use strict";
+        module.exports = import("../compiled/mrmime/index.js").then(function(module) {
+            return module;
+        });
+    },
     "../../compiled/on-finished/index.js": function(module) {
         "use strict";
         module.exports = import("../compiled/on-finished/index.js").then(function(module) {
@@ -902,7 +1200,7 @@ __webpack_require__.n = (module)=>{
 var __webpack_exports__ = {};
 for(var __webpack_i__ in (()=>{
     "use strict";
-    let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin, isDockerCached, cachedResult;
+    let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin, isDockerCached, cachedResult, hmrClientPath, overlayClientPath;
     __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
         PLUGIN_CSS_NAME: ()=>PLUGIN_CSS_NAME,
         createRsbuild: ()=>createRsbuild,
@@ -940,7 +1238,741 @@ for(var __webpack_i__ in (()=>{
     let external_node_url_namespaceObject = require("node:url");
     var cjs = __webpack_require__("../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js"), cjs_default = __webpack_require__.n(cjs);
     let picocolors_index_js_namespaceObject = require("../compiled/picocolors/index.js");
-    var picocolors_index_js_default = __webpack_require__.n(picocolors_index_js_namespaceObject);
+    var picocolors_index_js_default = __webpack_require__.n(picocolors_index_js_namespaceObject), 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 = function(superClass) {
+        return 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;
+            }
+        };
+    }(createMap(createChainable(class extends Function {
+        classCall() {
+            throw Error('not implemented');
+        }
+        constructor(){
+            return super(), new Proxy(this, {
+                apply: (target, thisArg, args)=>target.classCall(...args)
+            });
+        }
+    }))), ChainedSet = function(superClass) {
+        return class extends superClass {
+            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();
+            }
+        };
+    }(createChainable(Object)), 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 = (0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__), constants_dirname = (0, external_node_path_namespaceObject.dirname)(constants_filename), ROOT_DIST_DIR = 'dist', LOADER_PATH = (0, external_node_path_namespaceObject.join)(constants_dirname), STATIC_PATH = (0, external_node_path_namespaceObject.join)(constants_dirname, '../static'), COMPILED_PATH = (0, external_node_path_namespaceObject.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',
@@ -1164,7 +2196,16 @@ for(var __webpack_i__ in (()=>{
     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;
     };
@@ -1209,7 +2250,7 @@ for(var __webpack_i__ in (()=>{
     }
     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
@@ -1299,10 +2340,10 @@ for(var __webpack_i__ in (()=>{
     isDebug() && (index_js_namespaceObject.logger.level = 'verbose'), index_js_namespaceObject.logger.override({
         debug: (message, ...args)=>{
             if ('verbose' !== index_js_namespaceObject.logger.level) return;
-            let time = picocolors_index_js_default().gray(`${function() {
+            let time = picocolors_index_js_default().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_index_js_default().magenta('rsbuild')} ${time} ${message}`, ...args);
         }
     });
@@ -1627,9 +2668,11 @@ ${section.body}` : section.body).join("\n\n"));
         };
         return {
             tapEnvironment,
-            tap: (handler)=>tapEnvironment({
+            tap: (handler)=>{
+                tapEnvironment({
                     handler
-                }),
+                });
+            },
             callChain: async ({ environment, args: params })=>{
                 for (let callback of [
                     ...preGroup,
@@ -1743,13 +2786,13 @@ ${section.body}` : section.body).join("\n\n"));
         };
         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: [
                         {
@@ -1790,7 +2833,7 @@ ${section.body}` : section.body).join("\n\n"));
         };
         onBeforeCompile({
             compiler,
-            beforeEnvironmentCompiler: async (buildIndex)=>await context.hooks.onBeforeEnvironmentCompile.callBatch({
+            beforeEnvironmentCompiler: async (buildIndex)=>context.hooks.onBeforeEnvironmentCompile.callBatch({
                     environment: environmentList[buildIndex].name,
                     args: [
                         {
@@ -1901,8 +2944,8 @@ ${section.body}` : section.body).join("\n\n"));
             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, {
@@ -1996,7 +3039,8 @@ ${section.body}` : section.body).join("\n\n"));
                     wasm: 'static/wasm',
                     image: 'static/image',
                     media: 'static/media',
-                    assets: 'static/assets'
+                    assets: 'static/assets',
+                    favicon: './'
                 },
                 assetPrefix: DEFAULT_ASSET_PREFIX,
                 filename: {},
@@ -2144,7 +3188,7 @@ ${section.body}` : section.body).join("\n\n"));
             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 {
@@ -2279,7 +3323,7 @@ ${section.body}` : section.body).join("\n\n"));
     async function createContext(options, userConfig) {
         let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, external_node_path_namespaceObject.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,
@@ -2317,8 +3361,6 @@ ${section.body}` : section.body).join("\n\n"));
             specifiedEnvironments
         };
     }
-    let rspack_chain_index_js_namespaceObject = require("../compiled/rspack-chain/index.js");
-    var rspack_chain_index_js_default = __webpack_require__.n(rspack_chain_index_js_namespaceObject);
     let normalizePluginObject = (plugin)=>{
         let { setup: _, ...rest } = plugin;
         return {
@@ -2362,7 +3404,7 @@ ${section.body}` : section.body).join("\n\n"));
         index_js_namespaceObject.logger.success(`config inspection completed, generated files: \n\n${fileInfos}\n`);
     }
     function stringifyConfig(config, verbose) {
-        return (0, rspack_chain_index_js_default().toString)(config, {
+        return src_class.toString(config, {
             verbose
         });
     }
@@ -2462,14 +3504,14 @@ ${section.body}` : section.body).join("\n\n"));
     async function modifyBundlerChain(context, utils) {
         var _utils_environment_config_tools;
         index_js_namespaceObject.logger.debug('modify bundler chain');
-        let bundlerChain = new (rspack_chain_index_js_default())(), [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 index_js_namespaceObject.logger.debug('modify bundler chain done'), modifiedBundlerChain;
     }
     let configChain_CHAIN_ID = {
@@ -2588,19 +3630,19 @@ ${section.body}` : section.body).join("\n\n"));
             ...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) {
@@ -2612,7 +3654,7 @@ ${section.body}` : section.body).join("\n\n"));
         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,
@@ -2643,6 +3685,14 @@ ${section.body}` : section.body).join("\n\n"));
         }
         return config.devServer && index_js_namespaceObject.logger.warn(`${picocolors_index_js_default().dim('[rsbuild:config]')} Find invalid Rspack config: "${picocolors_index_js_default().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;
         index_js_namespaceObject.logger.debug('modify Rsbuild config');
@@ -2676,7 +3726,7 @@ ${section.body}` : section.body).join("\n\n"));
                 ...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;
@@ -2709,13 +3759,7 @@ ${section.body}` : section.body).join("\n\n"));
                         applyEnvironmentDefaultConfig({
                             ...mergeRsbuildConfig({
                                 ...rsbuildSharedConfig,
-                                dev: pick(dev, [
-                                    'writeToDisk',
-                                    'hmr',
-                                    'assetPrefix',
-                                    'progressBar',
-                                    'lazyCompilation'
-                                ])
+                                dev: pick(dev, allowedEnvironmentDevKeys)
                             }, config)
                         })
                     ]));
@@ -2727,24 +3771,18 @@ ${section.body}` : section.body).join("\n\n"));
             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);
@@ -2939,7 +3977,7 @@ ${section.body}` : section.body).join("\n\n"));
     }, types_namespaceObject = require("node:util/types");
     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_index_js_default().dim('[rsbuild:loadEnv]')} ${picocolors_index_js_default().yellow('local')} cannot be used as a value for env mode, because ${picocolors_index_js_default().yellow('.env.local')} represents a temporary local file. Please use another value.`);
@@ -2980,11 +4018,11 @@ ${section.body}` : section.body).join("\n\n"));
             rawPublicVars
         };
     }
-    let external_node_util_namespaceObject = require("node:util"), mrmime_index_js_namespaceObject = require("../compiled/mrmime/index.js"), chainStaticAssetRule = ({ emit, rule, maxSize, filename, assetType })=>{
+    let external_node_util_namespaceObject = require("node:util"), 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
             }
@@ -3056,7 +4094,7 @@ ${section.body}` : section.body).join("\n\n"));
     }, 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
@@ -3108,12 +4146,12 @@ ${section.body}` : section.body).join("\n\n"));
             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)=>((plugin)=>'function' == typeof plugin && !0 === plugin.postcss)(plugin) ? 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)=>((plugin)=>'function' == typeof plugin && plugin.postcss)(plugin) ? plugin() : plugin), options.config = !1, options), { postcssOptions } = finalOptions;
         if ('function' == typeof postcssOptions) {
             let postcssOptionsWrapper = (loaderContext)=>{
                 let options = postcssOptions(loaderContext);
@@ -3160,16 +4198,7 @@ ${section.body}` : section.body).join("\n\n"));
         }, 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
@@ -3279,22 +4308,26 @@ ${section.body}` : section.body).join("\n\n"));
             }));
     class RsbuildHtmlPlugin {
         apply(compiler) {
-            let emitFavicon = async (compilation, favicon)=>{
+            let emitFavicon = async ({ compilation, favicon, faviconDistPath })=>{
                 let buffer, name = external_node_path_default().basename(favicon);
                 if (compilation.assets[name]) return name;
                 if (!compilation.inputFileSystem) return addCompilationError(compilation, `${picocolors_index_js_default().dim('[rsbuild:html]')} Failed to read the favicon file as ${picocolors_index_js_default().yellow('compilation.inputFileSystem')} is not available.`), null;
-                let filename = external_node_path_default().isAbsolute(favicon) ? favicon : external_node_path_default().join(compilation.compiler.context, favicon);
+                let inputFilename = external_node_path_default().isAbsolute(favicon) ? favicon : external_node_path_default().join(compilation.compiler.context, favicon);
                 try {
-                    if (!(buffer = await (0, external_node_util_namespaceObject.promisify)(compilation.inputFileSystem.readFile)(filename))) throw Error('Buffer is undefined');
+                    if (!(buffer = await (0, external_node_util_namespaceObject.promisify)(compilation.inputFileSystem.readFile)(inputFilename))) throw Error('Buffer is undefined');
                 } catch (error) {
-                    return index_js_namespaceObject.logger.debug(`read favicon error: ${error}`), addCompilationError(compilation, `${picocolors_index_js_default().dim('[rsbuild:html]')} Failed to read the favicon file at ${picocolors_index_js_default().yellow(filename)}.`), null;
+                    return index_js_namespaceObject.logger.debug(`read favicon error: ${error}`), addCompilationError(compilation, `${picocolors_index_js_default().dim('[rsbuild:html]')} Failed to read the favicon file at ${picocolors_index_js_default().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 = external_node_path_default().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);
                 }
@@ -3318,7 +4351,7 @@ ${section.body}` : section.body).join("\n\n"));
                 hooks.alterAssetTagGroups.tapPromise(this.name, async (data)=>{
                     let html, 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 (!((html = templateContent) && /<title/i.test(html) && /<\/title/i.test(html))) {
                         var _data_plugin_options;
                         ((headTags, title = '')=>{
@@ -3331,7 +4364,13 @@ ${section.body}` : section.body).join("\n\n"));
                             });
                         })(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)
@@ -3846,10 +4885,10 @@ ${section.body}` : section.body).join("\n\n"));
             }
             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_index_js_default().dim('-')} ${picocolors_index_js_default().dim(r.entryName.padEnd(maxNameLength + 4))}${picocolors_index_js_default().cyan(normalizeUrl(`${url}${r.pathname}`))}\n`;
+                for (let r of (index > 0 && (message += '\n'), message += `  \u{279C}  ${label}\n`, routes))message += `  ${picocolors_index_js_default().dim('-')} ${picocolors_index_js_default().dim(r.entryName.padEnd(maxNameLength + 4))}${picocolors_index_js_default().cyan(normalizeUrl(`${url}${r.pathname}`))}\n`;
             }), message;
         }(urls, routes);
-        return !1 === trailingLineBreak && message.endsWith('\n') && (message = message.slice(0, -1)), index_js_namespaceObject.logger.log(message), message;
+        return !trailingLineBreak && message.endsWith('\n') && (message = message.slice(0, -1)), index_js_namespaceObject.logger.log(message), message;
     }
     let getPort = async ({ host, port, strictPort, tryLimits = 20 })=>{
         'string' == typeof port && (port = Number.parseInt(port, 10)), strictPort && (tryLimits = 1);
@@ -3950,7 +4989,9 @@ ${section.body}` : section.body).join("\n\n"));
             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 = [
@@ -4015,7 +5056,7 @@ ${section.body}` : section.body).join("\n\n"));
             } : Array.isArray(open) ? {
                 targets: open
             } : {
-                targets: open.target ? castArray(open.target) : [],
+                targets: open.target ? helpers_castArray(open.target) : [],
                 before: open.before
             };
         })(config);
@@ -4125,8 +5166,8 @@ ${section.body}` : section.body).join("\n\n"));
                             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);
@@ -4409,16 +5450,23 @@ ${section.body}` : section.body).join("\n\n"));
             port: serverConfig.port
         };
     }
-    let getCompilationMiddleware = async (compiler, options)=>{
-        let { default: rsbuildDevMiddleware } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/rsbuild-dev-middleware/index.js")), { clientPaths, callbacks, devConfig, serverConfig } = options, resolvedClientConfig = await getResolvedClientConfig(devConfig.client, serverConfig);
+    let compilationMiddleware_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__), getCompilationMiddleware = async (compiler, options)=>{
+        let { default: rsbuildDevMiddleware } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../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),
@@ -4428,10 +5476,10 @@ ${section.body}` : section.body).join("\n\n"));
                 }).apply(compiler);
             }({
                 compiler,
-                clientPaths,
                 devConfig,
                 resolvedClientConfig,
-                token
+                token,
+                config: environment.config
             }), (({ compiler, token, callbacks: { onDone, onInvalid } })=>{
                 if (((compiler)=>{
                     let { target } = compiler.options;
@@ -4529,9 +5577,6 @@ ${section.body}` : section.body).join("\n\n"));
                 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();
@@ -4546,8 +5591,6 @@ ${section.body}` : section.body).join("\n\n"));
                 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
@@ -4587,13 +5630,13 @@ ${section.body}` : section.body).join("\n\n"));
             let initialChunks = this.initialChunks[token], shouldReload = !!statsJson.entrypoints && !!initialChunks && (a = initialChunks, b = newInitialChunks, !(a.size === b.size && [
                 ...a
             ].every((value)=>b.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) {
@@ -4601,7 +5644,7 @@ ${section.body}` : section.body).join("\n\n"));
                     errors: getAllStatsErrors(statsJson),
                     warnings: []
                 });
-                return this.sockWrite({
+                this.sockWrite({
                     type: 'errors',
                     data: {
                         text: formattedErrors,
@@ -4761,20 +5804,22 @@ ${section.body}` : section.body).join("\n\n"));
                         }(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);
         }
@@ -4803,7 +5848,6 @@ ${section.body}` : section.body).join("\n\n"));
             writable: !0
         }) : obj[key] = value, obj;
     }
-    let compilationManager_require = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
     class CompilationManager {
         async init() {
             await this.setupCompilationMiddleware(), await this.socketServer.prepare();
@@ -4825,25 +5869,17 @@ ${section.body}` : section.body).join("\n\n"));
             });
         }
         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
@@ -4873,10 +5909,10 @@ ${section.body}` : section.body).join("\n\n"));
     }
     let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i, gzipMiddleware = ({ filter, level = external_node_zlib_default().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;
@@ -4887,22 +5923,77 @@ ${section.body}` : section.body).join("\n\n"));
                     })(res)) for (let listener of (res.setHeader('Content-Encoding', 'gzip'), res.removeHeader('Content-Length'), (gzip = external_node_zlib_default().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) {
+                index_js_namespaceObject.logger.debug('Not rewriting', req.method, req.url, 'because the method is not GET or HEAD.'), next();
+                return;
+            }
+            if (!headers || 'string' != typeof headers.accept) {
+                index_js_namespaceObject.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')) {
+                index_js_namespaceObject.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))) {
+                index_js_namespaceObject.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_namespaceObject.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) && index_js_namespaceObject.logger.debug('We recommend using an absolute path for the rewrite target.', 'Received a non-absolute rewrite target', rewriteTarget, 'for URL', req.url), index_js_namespaceObject.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) {
+                index_js_namespaceObject.logger.debug('Not rewriting', req.method, req.url, 'because the path includes a dot (.) character.'), next();
+                return;
+            }
+            let index = options.index || '/index.html';
+            index_js_namespaceObject.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 Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/on-finished/index.js"));
@@ -4932,7 +6023,10 @@ ${section.body}` : section.body).join("\n\n"));
     }, 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, {
@@ -5017,10 +6111,10 @@ ${section.body}` : section.body).join("\n\n"));
             '/__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"/>
@@ -5063,35 +6157,35 @@ ${section.body}` : section.body).join("\n\n"));
     <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) {
-                        index_js_namespaceObject.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) {
+                    index_js_namespaceObject.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 = external_node_path_default().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 (!external_node_path_default().extname(pathname)) {
                     let newUrl = `${pathname}.html`, filePath = external_node_path_default().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();
             })({
@@ -5105,23 +6199,22 @@ ${section.body}` : section.body).join("\n\n"));
             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 = external_node_path_default().join(distPath, 'index.html');
                 if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) {
                     let newUrl = '/index.html';
-                    return 'verbose' === index_js_namespaceObject.logger.level && index_js_namespaceObject.logger.debug(`${req.method} ${picocolors_index_js_default().gray(`${req.url} ${picocolors_index_js_default().yellow('fallback')} to ${newUrl}`)}`), req.url = newUrl, compilationManager.middleware(req, res, (...args)=>next(...args));
+                    'verbose' === index_js_namespaceObject.logger.level && index_js_namespaceObject.logger.debug(`${req.method} ${picocolors_index_js_default().gray(`${req.url} ${picocolors_index_js_default().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 Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../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);
             }
@@ -5134,7 +6227,7 @@ ${section.body}` : section.body).join("\n\n"));
                 '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);
@@ -5163,12 +6256,12 @@ ${section.body}` : section.body).join("\n\n"));
                 'default',
                 ...Object.keys(something)
             ])
-        ], m = new SyntheticModule(exports1, ()=>{
-            for (let name of exports1)m.setExport(name, 'default' === name ? something : something[name]);
+        ], syntheticModule = new SyntheticModule(exports1, ()=>{
+            for (let name of exports1)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, {
@@ -5328,16 +6421,13 @@ ${section.body}` : section.body).join("\n\n"));
                     initializeImportMeta: (meta, _)=>{
                         meta.url = (0, external_node_url_namespaceObject.pathToFileURL)(file.path).href;
                     },
-                    importModuleDynamically: async (specifier, module)=>{
-                        let result = await _require(external_node_path_default().dirname(file.path), specifier, {
+                    importModuleDynamically: async (specifier, module)=>asModule(await _require(external_node_path_default().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(external_node_path_default().dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : (0, external_node_url_namespaceObject.fileURLToPath)(referencingModule.url)), specifier, {
+                    if (await esm.link(async (specifier, referencingModule)=>asModule(await _require(external_node_path_default().dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : (0, external_node_url_namespaceObject.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;
                 })();
@@ -5470,7 +6560,7 @@ ${section.body}` : section.body).join("\n\n"));
         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);
         }
@@ -5773,13 +6863,9 @@ ${section.body}` : section.body).join("\n\n"));
                     ...'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 Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../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 Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/sirv/index.js")), assetMiddleware = sirv(path, {
@@ -5927,7 +7013,7 @@ ${section.body}` : section.body).join("\n\n"));
                                     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_index_js_default().dim('[rsbuild:config]')} Could not find any entry module, please make sure that ${picocolors_index_js_default().yellow('src/index.(ts|js|tsx|jsx|mts|cts|mjs|cjs)')} exists, or customize entry through the ${picocolors_index_js_default().yellow('source.entry')} configuration.`);
@@ -6005,7 +7091,7 @@ ${section.body}` : section.body).join("\n\n"));
                             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));
                                 }
@@ -6092,7 +7178,7 @@ ${section.body}` : section.body).join("\n\n"));
                                     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);
                                 }
                             }({
@@ -6287,11 +7373,12 @@ ${section.body}` : section.body).join("\n\n"));
                             let extraData = {
                                 entryName,
                                 context: context1,
-                                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,
@@ -6368,7 +7455,7 @@ ${section.body}` : section.body).join("\n\n"));
                     }, 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 Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../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}`;
@@ -6378,7 +7465,7 @@ ${section.body}` : section.body).join("\n\n"));
                                         src,
                                         sizes,
                                         isURL: !0,
-                                        mimeType: (0, mrmime_index_js_namespaceObject.lookup)(src)
+                                        mimeType: lookup(src)
                                     };
                                     return iconFormatMap.set(src, formatted), formatted;
                                 }
@@ -6389,10 +7476,10 @@ ${section.body}` : section.body).join("\n\n"));
                                     isURL: !1,
                                     absolutePath,
                                     relativePath,
-                                    mimeType: (0, mrmime_index_js_namespaceObject.lookup)(absolutePath)
+                                    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_index_js_default().dim('[rsbuild:app-icon]')} ${picocolors_index_js_default().yellow('"appIcon.name"')} is required when ${picocolors_index_js_default().yellow('"target"')} is ${picocolors_index_js_default().yellow('"web-app-manifest"')}.`);
@@ -6805,7 +7892,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));
@@ -6822,7 +7909,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                     default:
                                         throw Error(`${picocolors_index_js_default().dim('[rsbuild:swc]')} Unknown decorators version: ${picocolors_index_js_default().yellow(version)}`);
                                 }
-                            }(swcConfig, config), castArray(target1 = target).includes('web') || target1.includes('web-worker')) {
+                            }(swcConfig, config), helpers_castArray(target1 = target).includes('web') || target1.includes('web-worker')) {
                                 let polyfillMode = config.output.polyfill;
                                 if ('off' === polyfillMode) swcConfig.env.mode = void 0;
                                 else {
@@ -7043,7 +8130,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,
@@ -7054,7 +8141,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,
@@ -7386,7 +8473,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 ...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'
@@ -7608,42 +8695,60 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     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
-                        })
+                        });
+                    }
                 };
             };
         }({
@@ -7685,7 +8790,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             build,
             preview,
             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',
@@ -7789,7 +8894,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             throw index_js_namespaceObject.logger.error(`Failed to load file with jiti: ${picocolors_index_js_default().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,
@@ -7816,17 +8921,17 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             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, cwd, envDir;
+        cliOptions && (commonOpts = cliOptions), commonOpts.environment = null == (_commonOpts_environment = commonOpts.environment) ? void 0 : _commonOpts_environment.flatMap((env)=>env.split(','));
         try {
-            var cwd, envDir;
             let cwd1 = process.cwd(), root = commonOpts.root ? ensureAbsolutePath(cwd1, commonOpts.root) : cwd1, rsbuild = await createRsbuild({
                 cwd: root,
                 rsbuildConfig: ()=>init_loadConfig(root),
@@ -7841,7 +8946,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 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,
@@ -7875,7 +8980,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             clear,
             id: 'server'
         });
-        let rsbuild = await init({
+        let rsbuild = await init_init({
             isRestart: !0
         });
         return !!rsbuild && (await rsbuild.startDevServer(), !0);
@@ -7885,7 +8990,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             clear,
             id: 'build'
         });
-        let rsbuild = await init({
+        let rsbuild = await init_init({
             isRestart: !0,
             isBuildWatch: !0
         });
@@ -7930,11 +9035,11 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             ].includes(level) && (index_js_namespaceObject.logger.level = level);
         }
         let { npm_execpath } = process.env;
-        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && index_js_namespaceObject.logger.log(), index_js_namespaceObject.logger.greet(`  Rsbuild v1.4.11\n`);
+        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && index_js_namespaceObject.logger.log(), index_js_namespaceObject.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: [
@@ -7945,7 +9050,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 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());
@@ -7954,7 +9059,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     }
                 }), 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({
@@ -7966,7 +9071,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     }
                 }), previewCommand.action(async (options)=>{
                     try {
-                        let rsbuild = await init({
+                        let rsbuild = await init_init({
                             cliOptions: options
                         });
                         await (null == rsbuild ? void 0 : rsbuild.preview());
@@ -7975,7 +9080,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     }
                 }), 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({
@@ -7992,7 +9097,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             index_js_namespaceObject.logger.error('Failed to start Rsbuild CLI.'), index_js_namespaceObject.logger.error(err);
         }
     }
-    let src_version = "1.4.11";
+    let src_version = "1.4.13";
 })(), exports.PLUGIN_CSS_NAME = __webpack_exports__.PLUGIN_CSS_NAME, exports.PLUGIN_SWC_NAME = __webpack_exports__.PLUGIN_SWC_NAME, exports.createRsbuild = __webpack_exports__.createRsbuild, exports.defaultAllowedOrigins = __webpack_exports__.defaultAllowedOrigins, exports.defineConfig = __webpack_exports__.defineConfig, exports.ensureAssetPrefix = __webpack_exports__.ensureAssetPrefix, exports.loadConfig = __webpack_exports__.loadConfig, exports.loadEnv = __webpack_exports__.loadEnv, exports.logger = __webpack_exports__.logger, exports.mergeRsbuildConfig = __webpack_exports__.mergeRsbuildConfig, exports.rspack = __webpack_exports__.rspack, exports.runCLI = __webpack_exports__.runCLI, exports.version = __webpack_exports__.version, __webpack_exports__)-1 === [
     "PLUGIN_CSS_NAME",
     "PLUGIN_SWC_NAME",