@rsbuild/core 1.4.10 → 1.4.12

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) {
@@ -914,7 +1212,7 @@ for(var __webpack_i__ in (()=>{
         PLUGIN_SWC_NAME: ()=>PLUGIN_SWC_NAME,
         defaultAllowedOrigins: ()=>defaultAllowedOrigins,
         ensureAssetPrefix: ()=>ensureAssetPrefix,
-        rspack: ()=>core_namespaceObject.rspack,
+        rspack: ()=>rspack_rspack,
         runCLI: ()=>runCLI,
         defineConfig: ()=>defineConfig
     });
@@ -935,12 +1233,746 @@ for(var __webpack_i__ in (()=>{
         setCssExtractPlugin: ()=>setCssExtractPlugin,
         setHTMLPlugin: ()=>setHTMLPlugin
     });
-    let core_namespaceObject = require("@rspack/core"), index_js_namespaceObject = require("../compiled/rslog/index.js"), external_node_path_namespaceObject = require("node:path");
+    let external_node_module_namespaceObject = require("node:module"), rspack_rspack = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__)('@rspack/core'), index_js_namespaceObject = require("../compiled/rslog/index.js"), external_node_path_namespaceObject = require("node:path");
     var external_node_path_default = __webpack_require__.n(external_node_path_namespaceObject);
     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',
@@ -952,7 +1984,7 @@ for(var __webpack_i__ in (()=>{
         node: [
             'node >= 16'
         ]
-    }, HTML_REGEX = /\.html$/, JS_REGEX = /\.(?:js|mjs|cjs|jsx)$/, SCRIPT_REGEX = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/, CSS_REGEX = /\.css$/, RAW_QUERY_REGEX = /^\?raw$/, INLINE_QUERY_REGEX = /^\?inline$/, NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/, PLUGIN_SWC_NAME = 'rsbuild:swc', PLUGIN_CSS_NAME = 'rsbuild:css', FONT_EXTENSIONS = [
+    }, JS_REGEX = /\.(?:js|mjs|cjs|jsx)$/, SCRIPT_REGEX = /\.(?:js|jsx|mjs|cjs|ts|tsx|mts|cts)$/, CSS_REGEX = /\.css$/, RAW_QUERY_REGEX = /^\?raw$/, INLINE_QUERY_REGEX = /^\?inline$/, NODE_MODULES_REGEX = /[\\/]node_modules[\\/]/, PLUGIN_SWC_NAME = 'rsbuild:swc', PLUGIN_CSS_NAME = 'rsbuild:css', FONT_EXTENSIONS = [
         'woff',
         'woff2',
         'eot',
@@ -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
@@ -1257,6 +2298,8 @@ for(var __webpack_i__ in (()=>{
                 return filename.media ?? `[name]${hash}[ext]`;
             case 'assets':
                 return filename.assets ?? `[name]${hash}[ext]`;
+            case 'wasm':
+                return filename.wasm ?? '[hash].module.wasm';
             default:
                 throw Error(`${picocolors_index_js_default().dim('[rsbuild:config]')} unknown key ${picocolors_index_js_default().yellow(type)} in ${picocolors_index_js_default().yellow('output.filename')}`);
         }
@@ -1297,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);
         }
     });
@@ -1625,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,
@@ -1741,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: [
                         {
@@ -1788,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: [
                         {
@@ -1873,7 +2918,7 @@ ${section.body}` : section.body).join("\n\n"));
             if (void 0 !== result) return result;
         }while (loc !== (loc = external_node_path_namespaceObject.dirname(loc)));
     }
-    let configCache = {}, external_node_module_namespaceObject = require("node:module"), OVERRIDE_PATHS = [
+    let configCache = {}, OVERRIDE_PATHS = [
         'performance.removeConsole',
         'output.inlineScripts',
         'output.inlineStyles',
@@ -1899,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, {
@@ -2142,7 +3187,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 {
@@ -2277,7 +3322,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.10",
+            version: "1.4.12",
             rootPath,
             distPath: '',
             cachePath,
@@ -2315,8 +3360,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 {
@@ -2360,7 +3403,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
         });
     }
@@ -2460,14 +3503,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 = {
@@ -2556,7 +3599,7 @@ ${section.body}` : section.body).join("\n\n"));
         plugin && (pluginHelper_htmlPlugin = plugin);
     }, getHTMLPlugin = ()=>(pluginHelper_htmlPlugin || (pluginHelper_htmlPlugin = pluginHelper_require('../compiled/html-rspack-plugin/index.js')), pluginHelper_htmlPlugin), setCssExtractPlugin = (plugin)=>{
         cssExtractPlugin = plugin;
-    }, getCssExtractPlugin = ()=>cssExtractPlugin || core_namespaceObject.rspack.CssExtractRspackPlugin;
+    }, getCssExtractPlugin = ()=>cssExtractPlugin || rspack_rspack.CssExtractRspackPlugin;
     async function modifyRspackConfig(context, rspackConfig, chainUtils) {
         var _utils_environment_config_tools;
         index_js_namespaceObject.logger.debug('modify Rspack config');
@@ -2586,19 +3629,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) {
@@ -2607,11 +3650,10 @@ ${section.body}` : section.body).join("\n\n"));
         };
     }
     function getChainUtils(target, environment) {
-        let nodeEnv = process.env.NODE_ENV;
         return {
-            rspack: core_namespaceObject.rspack,
+            rspack: rspack_rspack,
             environment,
-            env: nodeEnv,
+            env: process.env.NODE_ENV || '',
             target,
             isDev: 'development' === environment.config.mode,
             isProd: 'production' === environment.config.mode,
@@ -2622,7 +3664,7 @@ ${section.body}` : section.body).join("\n\n"));
         };
     }
     async function generateRspackConfig({ target, context, environment }) {
-        let chainUtils = getChainUtils(target, context.environments[environment]), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, SourceMapDevToolPlugin, HotModuleReplacementPlugin } = core_namespaceObject.rspack, rspackConfig = (await modifyBundlerChain(context, {
+        let chainUtils = getChainUtils(target, context.environments[environment]), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, SourceMapDevToolPlugin, HotModuleReplacementPlugin } = rspack_rspack, rspackConfig = (await modifyBundlerChain(context, {
             ...chainUtils,
             bundler: {
                 BannerPlugin,
@@ -2675,7 +3717,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;
@@ -2839,9 +3881,9 @@ ${section.body}` : section.body).join("\n\n"));
         if (await context.hooks.onBeforeCreateCompiler.callBatch({
             bundlerConfigs: rspackConfigs,
             environments: context.environments
-        }), !await isSatisfyRspackVersion(core_namespaceObject.rspack.rspackVersion)) throw Error(`${picocolors_index_js_default().dim('[rsbuild]')} The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${picocolors_index_js_default().green(rspackMinVersion)}`);
-        let isMultiCompiler = rspackConfigs.length > 1, compiler = isMultiCompiler ? (0, core_namespaceObject.rspack)(rspackConfigs) : (0, core_namespaceObject.rspack)(rspackConfigs[0]), isVersionLogged = !1, isCompiling = !1, logRspackVersion = ()=>{
-            isVersionLogged || (index_js_namespaceObject.logger.debug(`use Rspack v${core_namespaceObject.rspack.rspackVersion}`), isVersionLogged = !0);
+        }), !await isSatisfyRspackVersion(rspack_rspack.rspackVersion)) throw Error(`${picocolors_index_js_default().dim('[rsbuild]')} The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${picocolors_index_js_default().green(rspackMinVersion)}`);
+        let isMultiCompiler = rspackConfigs.length > 1, compiler = isMultiCompiler ? rspack_rspack(rspackConfigs) : rspack_rspack(rspackConfigs[0]), isVersionLogged = !1, isCompiling = !1, logRspackVersion = ()=>{
+            isVersionLogged || (index_js_namespaceObject.logger.debug(`use Rspack v${rspack_rspack.rspackVersion}`), isVersionLogged = !0);
         };
         return compiler.hooks.watchRun.tap('rsbuild:compiling', (compiler)=>{
             logRspackVersion(), isCompiling || function(compiler, context) {
@@ -2888,7 +3930,7 @@ ${section.body}` : section.body).join("\n\n"));
             context,
             compiler,
             bundlerConfigs: rspackConfigs,
-            MultiStatsCtor: core_namespaceObject.rspack.MultiStats
+            MultiStatsCtor: rspack_rspack.MultiStats
         }), await context.hooks.onAfterCreateCompiler.callBatch({
             compiler,
             environments: context.environments
@@ -2909,16 +3951,19 @@ ${section.body}` : section.body).join("\n\n"));
             bundlerConfigs,
             compiler,
             isWatch: !!watch,
-            MultiStatsCtor: core_namespaceObject.rspack.MultiStats
-        }), watch) return compiler.watch({}, (err)=>{
-            err && index_js_namespaceObject.logger.error(err);
-        }), {
-            close: ()=>new Promise((resolve)=>{
-                    compiler.close(()=>{
-                        resolve();
-                    });
-                })
-        };
+            MultiStatsCtor: rspack_rspack.MultiStats
+        }), watch) {
+            let watchOptions = bundlerConfigs ? bundlerConfigs.map((options)=>options.watchOptions || {}) : [];
+            return compiler.watch(watchOptions.length > 1 ? watchOptions : watchOptions[0] || {}, (err)=>{
+                err && index_js_namespaceObject.logger.error(err);
+            }), {
+                close: ()=>new Promise((resolve)=>{
+                        compiler.close(()=>{
+                            resolve();
+                        });
+                    })
+            };
+        }
         let { stats } = await new Promise((resolve, reject)=>{
             compiler.run((err, stats)=>{
                 compiler.close((closeErr)=>{
@@ -2935,7 +3980,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.`);
@@ -2976,11 +4021,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
             }
@@ -3052,7 +4097,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
@@ -3104,12 +4149,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);
@@ -3139,7 +4184,7 @@ ${section.body}` : section.body).join("\n\n"));
     let EXCLUDE_ASSET_REGEX = /\.(?:map|LICENSE\.txt|d\.ts)$/, excludeAsset = (asset)=>EXCLUDE_ASSET_REGEX.test(asset.name), getAssetColor = (size)=>size > 300000 ? picocolors_index_js_default().red : size > 100000 ? picocolors_index_js_default().yellow : picocolors_index_js_default().green, calcFileSize = (len)=>{
         let val = len / 1000;
         return `${val.toFixed(val < 1 ? 2 : 1)} kB`;
-    }, coloringAssetName = (assetName)=>JS_REGEX.test(assetName) ? picocolors_index_js_default().cyan(assetName) : CSS_REGEX.test(assetName) ? picocolors_index_js_default().yellow(assetName) : HTML_REGEX.test(assetName) ? picocolors_index_js_default().green(assetName) : picocolors_index_js_default().magenta(assetName), COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|md)$/i;
+    }, coloringAssetName = (assetName)=>JS_REGEX.test(assetName) ? picocolors_index_js_default().cyan(assetName) : assetName.endsWith('.css') ? picocolors_index_js_default().yellow(assetName) : assetName.endsWith('.html') ? picocolors_index_js_default().green(assetName) : picocolors_index_js_default().magenta(assetName), COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest|md)$/i;
     async function printFileSizes(options, stats, rootPath, environmentName) {
         let logs = [], showTotal = !1 !== options.total, showDetail = !1 !== options.detail, exclude = options.exclude ?? excludeAsset;
         if (!showTotal && !showDetail) return logs;
@@ -3156,16 +4201,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
@@ -3842,10 +4878,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);
@@ -3946,7 +4982,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 = [
@@ -4011,7 +5049,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);
@@ -4121,8 +5159,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);
@@ -4209,7 +5247,7 @@ ${section.body}` : section.body).join("\n\n"));
             traceOutput = 'perfetto' === traceLayer ? defaultRustTracePerfettoOutput : 'stdout';
         }
         let filter = "OVERVIEW" === (value = filterValue) ? 'info' : "ALL" === value ? 'trace' : value;
-        return await ensureFileDir(traceOutput), await core_namespaceObject.rspack.experiments.globalTrace.register(filter, traceLayer, traceOutput), traceOutput;
+        return await ensureFileDir(traceOutput), await rspack_rspack.experiments.globalTrace.register(filter, traceLayer, traceOutput), traceOutput;
     }
     let MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\/])?([^\\/]+)/, SPLIT_STRATEGY_DISPATCHER = {
         'split-by-experience': function(ctx) {
@@ -4583,10 +5621,10 @@ ${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({
@@ -4597,7 +5635,7 @@ ${section.body}` : section.body).join("\n\n"));
                     errors: getAllStatsErrors(statsJson),
                     warnings: []
                 });
-                return this.sockWrite({
+                this.sockWrite({
                     type: 'errors',
                     data: {
                         text: formattedErrors,
@@ -4757,20 +5795,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);
         }
@@ -4824,11 +5864,11 @@ ${section.body}` : section.body).join("\n\n"));
             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;
+                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, {
                 callbacks: {
                     onInvalid: (token, fileName)=>{
-                        if ('string' == typeof fileName && HTML_REGEX.test(fileName)) return void this.socketServer.sockWrite({
+                        if ('string' == typeof fileName && fileName.endsWith('.html')) return void this.socketServer.sockWrite({
                             type: 'static-changed'
                         }, token);
                         this.socketServer.sockWrite({
@@ -4869,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;
@@ -4883,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"));
@@ -4928,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, {
@@ -5003,7 +6101,7 @@ ${section.body}` : section.body).join("\n\n"));
                     var _childCompiler_options_experiments;
                     return null == (_childCompiler_options_experiments = childCompiler.options.experiments) ? void 0 : _childCompiler_options_experiments.lazyCompilation;
                 }) : null == (_compiler_options_experiments = compiler.options.experiments) ? void 0 : _compiler_options_experiments.lazyCompilation;
-            })() && middlewares.push(core_namespaceObject.rspack.experiments.lazyCompilationMiddleware(compiler));
+            })() && middlewares.push(rspack_rspack.experiments.lazyCompilationMiddleware(compiler));
         }
         server.base && '/' !== server.base && middlewares.push(getBaseMiddleware({
             base: server.base
@@ -5013,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"/>
@@ -5059,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();
             })({
@@ -5101,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);
             }
@@ -5130,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);
@@ -5324,14 +6421,11 @@ ${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;
                     let ns = esm.namespace;
@@ -5466,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);
         }
@@ -5769,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, {
@@ -5896,10 +6986,12 @@ ${section.body}` : section.body).join("\n\n"));
                             aggregateTimeout: 0
                         }), chain.performance.hints(!1), chain.module.parser.merge({
                             javascript: {
-                                exportsPresence: 'error'
+                                exportsPresence: 'error',
+                                typeReexportsPresence: 'tolerant'
                             }
                         }), isDev && config.dev.hmr && 'web' === target && chain.plugin(CHAIN_ID.PLUGIN.HMR).use(bundler.HotModuleReplacementPlugin), isDev && chain.output.devtoolModuleFilenameTemplate((info)=>toPosixPath(info.absoluteResourcePath)), 'rspack' === api.context.bundlerType && chain.experiments({
                             ...chain.get('experiments'),
+                            typeReexportsPresence: !0,
                             rspackFuture: {
                                 bundlerInfo: {
                                     force: !1
@@ -5921,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.`);
@@ -5992,14 +7084,14 @@ ${section.body}` : section.body).join("\n\n"));
             {
                 name: 'rsbuild:output',
                 setup (api) {
-                    api.modifyBundlerChain(async (chain, { CHAIN_ID, isDev, isProd, isServer, environment })=>{
+                    api.modifyBundlerChain(async (chain, { CHAIN_ID, isDev, isProd, isServer, environment, rspack })=>{
                         var jsPath, isServer1, jsAsync;
                         let { distPath, config } = environment, publicPath = function({ isDev, config, context }) {
                             var _context_devServer, _context_devServer1, _context_devServer2;
                             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));
                                 }
@@ -6024,7 +7116,7 @@ ${section.body}` : section.body).join("\n\n"));
                             let { copy } = config.output, options = Array.isArray(copy) ? {
                                 patterns: copy
                             } : copy;
-                            chain.plugin(CHAIN_ID.PLUGIN.COPY).use(core_namespaceObject.rspack.CopyRspackPlugin, [
+                            chain.plugin(CHAIN_ID.PLUGIN.COPY).use(rspack.CopyRspackPlugin, [
                                 options
                             ]);
                         }
@@ -6086,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);
                                 }
                             }({
@@ -6285,7 +7377,7 @@ ${section.body}` : section.body).join("\n\n"));
                             };
                             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,
@@ -6362,7 +7454,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}`;
@@ -6372,7 +7464,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;
                                 }
@@ -6383,10 +7475,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"')}.`);
@@ -6456,15 +7548,13 @@ ${section.body}` : section.body).join("\n\n"));
             {
                 name: 'rsbuild:wasm',
                 setup (api) {
-                    api.modifyBundlerChain(async (chain, { CHAIN_ID, environment })=>{
-                        let { config } = environment, distPath = config.output.distPath.wasm;
+                    api.modifyBundlerChain(async (chain, { CHAIN_ID, environment, isProd })=>{
+                        let { config } = environment, distPath = config.output.distPath.wasm, filename = external_node_path_namespaceObject.posix.join(distPath, getFilename(config, 'wasm', isProd));
                         chain.experiments({
                             ...chain.get('experiments'),
                             asyncWebAssembly: !0
-                        });
-                        let wasmFilename = external_node_path_namespaceObject.posix.join(distPath, '[hash].module.wasm');
-                        chain.output.webassemblyModuleFilename(wasmFilename), chain.module.rule(CHAIN_ID.RULE.WASM).test(/\.wasm$/).dependency('url').type('asset/resource').set('generator', {
-                            filename: wasmFilename
+                        }), chain.output.webassemblyModuleFilename(filename), chain.module.rule(CHAIN_ID.RULE.WASM).test(/\.wasm$/).dependency('url').type('asset/resource').set('generator', {
+                            filename
                         });
                     });
                 }
@@ -6668,9 +7758,9 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 name: 'rsbuild:minimize',
                 setup (api) {
                     let isRspack = 'rspack' === api.context.bundlerType;
-                    api.modifyBundlerChain(async (chain, { environment, CHAIN_ID })=>{
+                    api.modifyBundlerChain(async (chain, { environment, CHAIN_ID, rspack })=>{
                         let { config } = environment, { minifyJs, minifyCss, jsOptions, cssOptions } = parseMinifyOptions(config);
-                        if (chain.optimization.minimize(minifyJs || minifyCss), minifyJs && isRspack && chain.optimization.minimizer(CHAIN_ID.MINIMIZER.JS).use(core_namespaceObject.rspack.SwcJsMinimizerRspackPlugin, [
+                        if (chain.optimization.minimize(minifyJs || minifyCss), minifyJs && isRspack && chain.optimization.minimizer(CHAIN_ID.MINIMIZER.JS).use(rspack.SwcJsMinimizerRspackPlugin, [
                             ((config, jsOptions)=>{
                                 let options = {};
                                 options.minimizerOptions ||= {}, options.minimizerOptions.format ||= {};
@@ -6711,7 +7801,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                     ])
                                 }
                             }, mergedOptions = cssOptions ? cjs_default()(defaultOptions, cssOptions) : defaultOptions;
-                            chain.optimization.minimizer(CHAIN_ID.MINIMIZER.CSS).use(core_namespaceObject.rspack.LightningCssMinimizerRspackPlugin, [
+                            chain.optimization.minimizer(CHAIN_ID.MINIMIZER.CSS).use(rspack.LightningCssMinimizerRspackPlugin, [
                                 mergedOptions
                             ]).end();
                         }
@@ -6721,11 +7811,11 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             {
                 name: 'rsbuild:progress',
                 setup (api) {
-                    'webpack' !== api.context.bundlerType && api.modifyBundlerChain(async (chain, { CHAIN_ID, environment })=>{
+                    'webpack' !== api.context.bundlerType && api.modifyBundlerChain(async (chain, { CHAIN_ID, environment, rspack })=>{
                         let { config } = environment, options = config.dev.progressBar;
                         if (!options) return;
                         let prefix = !0 !== options && void 0 !== options.id ? options.id : environment.name;
-                        chain.plugin(CHAIN_ID.PLUGIN.PROGRESS).use(core_namespaceObject.rspack.ProgressPlugin, [
+                        chain.plugin(CHAIN_ID.PLUGIN.PROGRESS).use(rspack.ProgressPlugin, [
                             {
                                 prefix,
                                 ...!0 === options ? {} : options
@@ -6784,6 +7874,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                     isModule: 'unknown',
                                     env: {
                                         targets: browserslist
+                                    },
+                                    rspackExperiments: {
+                                        collectTypeScriptInfo: {
+                                            typeExports: !0,
+                                            exportedEnum: !1
+                                        }
                                     }
                                 };
                             }({
@@ -6795,7 +7891,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));
@@ -6812,7 +7908,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 {
@@ -7033,7 +8129,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,
@@ -7044,7 +8140,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,
@@ -7246,7 +8342,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         let { config } = environment;
                         if (!(null == (_config_moduleFederation = config.moduleFederation) ? void 0 : _config_moduleFederation.options) || 'web' !== target) return;
                         let { options } = config.moduleFederation;
-                        chain.plugin(CHAIN_ID.PLUGIN.MODULE_FEDERATION).use(core_namespaceObject.rspack.container.ModuleFederationPlugin, [
+                        chain.plugin(CHAIN_ID.PLUGIN.MODULE_FEDERATION).use(rspack_rspack.container.ModuleFederationPlugin, [
                             options
                         ]), options.name && (options.exposes && chain.plugin('mf-patch-split-chunks').use(PatchSplitChunksPlugin, [
                             options.name
@@ -7267,7 +8363,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     api.onBeforeBuild(({ isFirstCompile })=>{
                         isFirstCompile && onStart();
                     }), api.onBeforeStartDevServer(onStart), api.onExit(()=>{
-                        traceOutput && (core_namespaceObject.rspack.experiments.globalTrace.cleanup(), index_js_namespaceObject.logger.info(`profile file saved to ${picocolors_index_js_default().cyan(traceOutput)}`));
+                        traceOutput && (rspack_rspack.experiments.globalTrace.cleanup(), index_js_namespaceObject.logger.info(`profile file saved to ${picocolors_index_js_default().cyan(traceOutput)}`));
                     });
                 }
             },
@@ -7305,7 +8401,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             {
                 name: 'rsbuild:sri',
                 setup (api) {
-                    api.modifyBundlerChain((chain, { environment, CHAIN_ID })=>{
+                    api.modifyBundlerChain((chain, { environment, CHAIN_ID, rspack })=>{
                         if ('webpack' === api.context.bundlerType) return;
                         let { config, htmlPaths } = environment;
                         if (0 === Object.keys(htmlPaths).length) return;
@@ -7314,7 +8410,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         let crossorigin = chain.output.get('crossOriginLoading');
                         (!1 === crossorigin || void 0 === crossorigin) && chain.output.crossOriginLoading('anonymous');
                         let { algorithm = 'sha384' } = sri;
-                        chain.plugin(CHAIN_ID.PLUGIN.SUBRESOURCE_INTEGRITY).use(core_namespaceObject.rspack.experiments.SubresourceIntegrityPlugin, [
+                        chain.plugin(CHAIN_ID.PLUGIN.SUBRESOURCE_INTEGRITY).use(rspack.experiments.SubresourceIntegrityPlugin, [
                             {
                                 enabled: !0,
                                 hashFuncNames: [
@@ -7376,7 +8472,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'
@@ -7598,42 +8694,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
-                        })
+                        });
+                    }
                 };
             };
         }({
@@ -7675,7 +8789,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',
@@ -7779,7 +8893,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,
@@ -7806,17 +8920,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),
@@ -7831,7 +8945,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,
@@ -7865,7 +8979,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);
@@ -7875,7 +8989,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
         });
@@ -7920,11 +9034,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.10\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.12\n`);
         try {
             !function() {
                 let cli = ((name = "")=>new CAC(name))('rsbuild');
-                cli.help(), cli.version("1.4.10"), 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.12"), 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: [
@@ -7935,7 +9049,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());
@@ -7944,7 +9058,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({
@@ -7956,7 +9070,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());
@@ -7965,7 +9079,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({
@@ -7982,7 +9096,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.10";
+    let src_version = "1.4.12";
 })(), 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",