@rsbuild/core 1.2.16 → 1.2.18

package/dist/index.js

@@ -1,3 +1,4 @@
+/*! For license information please see index.js.LICENSE.txt */
 let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin;
 import * as __WEBPACK_EXTERNAL_MODULE_crypto__ from "crypto";
 import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
@@ -27,6 +28,31 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_querystring_aeb3c0b4__ from "node:que
 import * as __WEBPACK_EXTERNAL_MODULE_node_vm_bd3d9cea__ from "node:vm";
 import * as __WEBPACK_EXTERNAL_MODULE_events__ from "events";
 var EsmMode, __webpack_modules__ = {
+    "../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        let clone = __webpack_require__("../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js"), typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js"), isPlainObject = __webpack_require__("../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js");
+        module.exports = function cloneDeep(val, instanceClone) {
+            switch(typeOf(val)){
+                case 'object':
+                    return function(val, instanceClone) {
+                        if ('function' == typeof instanceClone) return instanceClone(val);
+                        if (instanceClone || isPlainObject(val)) {
+                            let res = new val.constructor();
+                            for(let key in val)res[key] = cloneDeep(val[key], instanceClone);
+                            return res;
+                        }
+                        return val;
+                    }(val, instanceClone);
+                case 'array':
+                    return function(val, instanceClone) {
+                        let res = new val.constructor(val.length);
+                        for(let i = 0; i < val.length; i++)res[i] = cloneDeep(val[i], instanceClone);
+                        return res;
+                    }(val, instanceClone);
+                default:
+                    return clone(val);
+            }
+        };
+    },
     "../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js": function(module) {
         var isMergeableObject = function(value) {
             var value1, value2, stringValue;
@@ -257,6 +283,617 @@ var EsmMode, __webpack_modules__ = {
         };
         module.exports.configDotenv = DotenvModule.configDotenv, module.exports._configVault = DotenvModule._configVault, module.exports._parseVault = DotenvModule._parseVault, module.exports.config = DotenvModule.config, module.exports.decrypt = DotenvModule.decrypt, module.exports.parse = DotenvModule.parse, module.exports.populate = DotenvModule.populate, module.exports = DotenvModule;
     },
+    "../../node_modules/.pnpm/flat@5.0.2/node_modules/flat/index.js": function(module) {
+        function isBuffer(obj) {
+            return obj && obj.constructor && 'function' == typeof obj.constructor.isBuffer && obj.constructor.isBuffer(obj);
+        }
+        function keyIdentity(key) {
+            return key;
+        }
+        function flatten(target, opts) {
+            let delimiter = (opts = opts || {}).delimiter || '.', maxDepth = opts.maxDepth, transformKey = opts.transformKey || keyIdentity, output = {};
+            return !function step(object, prev, currentDepth) {
+                currentDepth = currentDepth || 1, Object.keys(object).forEach(function(key) {
+                    let value = object[key], isarray = opts.safe && Array.isArray(value), type = Object.prototype.toString.call(value), isbuffer = isBuffer(value), newKey = prev ? prev + delimiter + transformKey(key) : transformKey(key);
+                    if (!isarray && !isbuffer && ('[object Object]' === type || '[object Array]' === type) && Object.keys(value).length && (!opts.maxDepth || currentDepth < maxDepth)) return step(value, newKey, currentDepth + 1);
+                    output[newKey] = value;
+                });
+            }(target), output;
+        }
+        module.exports = flatten, flatten.flatten = flatten, flatten.unflatten = function unflatten(target, opts) {
+            let delimiter = (opts = opts || {}).delimiter || '.', overwrite = opts.overwrite || !1, transformKey = opts.transformKey || keyIdentity, result = {};
+            if (isBuffer(target) || '[object Object]' !== Object.prototype.toString.call(target)) return target;
+            function getkey(key) {
+                let parsedKey = Number(key);
+                return isNaN(parsedKey) || -1 !== key.indexOf('.') || opts.object ? key : parsedKey;
+            }
+            return Object.keys(target = Object.keys(target).reduce(function(result, key) {
+                var target1;
+                let type = Object.prototype.toString.call(target[key]);
+                return '[object Object]' !== type && '[object Array]' !== type || function(val) {
+                    let type = Object.prototype.toString.call(val);
+                    return !val || ('[object Array]' === type ? !val.length : '[object Object]' === type ? !Object.keys(val).length : void 0);
+                }(target[key]) ? (result[key] = target[key], result) : Object.keys(target1 = flatten(target[key], opts)).reduce(function(result, key1) {
+                    return result[key + delimiter + key1] = target1[key1], result;
+                }, result);
+            }, {})).forEach(function(key) {
+                let split = key.split(delimiter).map(transformKey), key1 = getkey(split.shift()), key2 = getkey(split[0]), recipient = result;
+                for(; void 0 !== key2;){
+                    if ('__proto__' === key1) return;
+                    let type = Object.prototype.toString.call(recipient[key1]), isobject = '[object Object]' === type || '[object Array]' === type;
+                    if (!overwrite && !isobject && void 0 !== recipient[key1]) return;
+                    (!overwrite || isobject) && (overwrite || null != recipient[key1]) || (recipient[key1] = 'number' != typeof key2 || opts.object ? {} : []), recipient = recipient[key1], split.length > 0 && (key1 = getkey(split.shift()), key2 = getkey(split[0]));
+                }
+                recipient[key1] = unflatten(target[key], opts);
+            }), result;
+        };
+    },
+    "../../node_modules/.pnpm/is-plain-object@2.0.4/node_modules/is-plain-object/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        var isObject = __webpack_require__("../../node_modules/.pnpm/isobject@3.0.1/node_modules/isobject/index.js");
+        function isObjectObject(o) {
+            return !0 === isObject(o) && '[object Object]' === Object.prototype.toString.call(o);
+        }
+        module.exports = function(o) {
+            var ctor, prot;
+            return !1 !== isObjectObject(o) && 'function' == typeof (ctor = o.constructor) && !1 !== isObjectObject(prot = ctor.prototype) && !1 !== prot.hasOwnProperty('isPrototypeOf');
+        };
+    },
+    "../../node_modules/.pnpm/isobject@3.0.1/node_modules/isobject/index.js": function(module) {
+        module.exports = function(val) {
+            return null != val && 'object' == typeof val && !1 === Array.isArray(val);
+        };
+    },
+    "../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js": function(module) {
+        var toString = Object.prototype.toString;
+        function ctorName(val) {
+            return 'function' == typeof val.constructor ? val.constructor.name : null;
+        }
+        module.exports = function(val) {
+            if (void 0 === val) return 'undefined';
+            if (null === val) return 'null';
+            var val1, val2, val3, val4, val5, val6, val7, type = typeof val;
+            if ('boolean' === type) return 'boolean';
+            if ('string' === type) return 'string';
+            if ('number' === type) return 'number';
+            if ('symbol' === type) return 'symbol';
+            if ('function' === type) {
+                return 'GeneratorFunction' === ctorName(val) ? 'generatorfunction' : 'function';
+            }
+            if (val2 = val, Array.isArray ? Array.isArray(val2) : val2 instanceof Array) return 'array';
+            if ((val3 = val).constructor && 'function' == typeof val3.constructor.isBuffer && val3.constructor.isBuffer(val3)) return 'buffer';
+            if (function(val) {
+                try {
+                    if ('number' == typeof val.length && 'function' == typeof val.callee) return !0;
+                } catch (err) {
+                    if (-1 !== err.message.indexOf('callee')) return !0;
+                }
+                return !1;
+            }(val)) return 'arguments';
+            if ((val4 = val) instanceof Date || 'function' == typeof val4.toDateString && 'function' == typeof val4.getDate && 'function' == typeof val4.setDate) return 'date';
+            if ((val5 = val) instanceof Error || 'string' == typeof val5.message && val5.constructor && 'number' == typeof val5.constructor.stackTraceLimit) return 'error';
+            if ((val6 = val) instanceof RegExp || 'string' == typeof val6.flags && 'boolean' == typeof val6.ignoreCase && 'boolean' == typeof val6.multiline && 'boolean' == typeof val6.global) return 'regexp';
+            switch(ctorName(val)){
+                case 'Symbol':
+                    return 'symbol';
+                case 'Promise':
+                    return 'promise';
+                case 'WeakMap':
+                    return 'weakmap';
+                case 'WeakSet':
+                    return 'weakset';
+                case 'Map':
+                    return 'map';
+                case 'Set':
+                    return 'set';
+                case 'Int8Array':
+                    return 'int8array';
+                case 'Uint8Array':
+                    return 'uint8array';
+                case 'Uint8ClampedArray':
+                    return 'uint8clampedarray';
+                case 'Int16Array':
+                    return 'int16array';
+                case 'Uint16Array':
+                    return 'uint16array';
+                case 'Int32Array':
+                    return 'int32array';
+                case 'Uint32Array':
+                    return 'uint32array';
+                case 'Float32Array':
+                    return 'float32array';
+                case 'Float64Array':
+                    return 'float64array';
+            }
+            if ('function' == typeof (val7 = val).throw && 'function' == typeof val7.return && 'function' == typeof val7.next) return 'generator';
+            switch(type = toString.call(val)){
+                case '[object Object]':
+                    return 'object';
+                case '[object Map Iterator]':
+                    return 'mapiterator';
+                case '[object Set Iterator]':
+                    return 'setiterator';
+                case '[object String Iterator]':
+                    return 'stringiterator';
+                case '[object Array Iterator]':
+                    return 'arrayiterator';
+            }
+            return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
+        };
+    },
+    "../../node_modules/.pnpm/shallow-clone@3.0.1/node_modules/shallow-clone/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        let valueOf = Symbol.prototype.valueOf, typeOf = __webpack_require__("../../node_modules/.pnpm/kind-of@6.0.3/node_modules/kind-of/index.js");
+        module.exports = function(val, deep) {
+            var val1, val2, deep1;
+            switch(typeOf(val)){
+                case 'array':
+                    return val.slice();
+                case 'object':
+                    return Object.assign({}, val);
+                case 'date':
+                    return new val.constructor(Number(val));
+                case 'map':
+                    return new Map(val);
+                case 'set':
+                    return new Set(val);
+                case 'buffer':
+                    return function(val) {
+                        let len = val.length, buf = Buffer.allocUnsafe ? Buffer.allocUnsafe(len) : Buffer.from(len);
+                        return val.copy(buf), buf;
+                    }(val);
+                case 'symbol':
+                    return val1 = val, valueOf ? Object(valueOf.call(val1)) : {};
+                case 'arraybuffer':
+                    return function(val) {
+                        let res = new val.constructor(val.byteLength);
+                        return new Uint8Array(res).set(new Uint8Array(val)), res;
+                    }(val);
+                case 'float32array':
+                case 'float64array':
+                case 'int16array':
+                case 'int32array':
+                case 'int8array':
+                case 'uint16array':
+                case 'uint32array':
+                case 'uint8clampedarray':
+                case 'uint8array':
+                    return new (val2 = val).constructor(val2.buffer, val2.byteOffset, val2.length);
+                case 'regexp':
+                    return function(val) {
+                        let flags = void 0 !== val.flags ? val.flags : /\w+$/.exec(val) || void 0, re = new val.constructor(val.source, flags);
+                        return re.lastIndex = val.lastIndex, re;
+                    }(val);
+                case 'error':
+                    return Object.create(val);
+                default:
+                    return val;
+            }
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/index.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        }, __spreadArray = this && this.__spreadArray || function(to, from, pack) {
+            if (pack || 2 == arguments.length) for(var ar, i = 0, l = from.length; i < l; i++)!ar && i in from || (ar || (ar = Array.prototype.slice.call(from, 0, i)), ar[i] = from[i]);
+            return to.concat(ar || Array.prototype.slice.call(from));
+        }, __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.unique = exports.mergeWithRules = exports.mergeWithCustomize = exports.default = exports.merge = exports.CustomizeRule = exports.customizeObject = exports.customizeArray = void 0;
+        var wildcard_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/wildcard@2.0.1/node_modules/wildcard/index.js")), merge_with_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/merge-with.js")), join_arrays_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/join-arrays.js")), unique_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/unique.js"));
+        exports.unique = unique_1.default;
+        var types_1 = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/types.js");
+        Object.defineProperty(exports, "CustomizeRule", {
+            enumerable: !0,
+            get: function() {
+                return types_1.CustomizeRule;
+            }
+        });
+        var utils_1 = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/utils.js");
+        function merge(firstConfiguration) {
+            for(var configurations = [], _i = 1; _i < arguments.length; _i++)configurations[_i - 1] = arguments[_i];
+            return mergeWithCustomize({}).apply(void 0, __spreadArray([
+                firstConfiguration
+            ], __read(configurations), !1));
+        }
+        function mergeWithCustomize(options) {
+            return function(firstConfiguration) {
+                for(var configurations = [], _i = 1; _i < arguments.length; _i++)configurations[_i - 1] = arguments[_i];
+                if ((0, utils_1.isUndefined)(firstConfiguration) || configurations.some(utils_1.isUndefined)) throw TypeError("Merging undefined is not supported");
+                if (firstConfiguration.then) throw TypeError("Promises are not supported");
+                if (!firstConfiguration) return {};
+                if (0 === configurations.length) {
+                    if (Array.isArray(firstConfiguration)) {
+                        if (0 === firstConfiguration.length) return {};
+                        if (firstConfiguration.some(utils_1.isUndefined)) throw TypeError("Merging undefined is not supported");
+                        if (firstConfiguration[0].then) throw TypeError("Promises are not supported");
+                        return (0, merge_with_1.default)(firstConfiguration, (0, join_arrays_1.default)(options));
+                    }
+                    return firstConfiguration;
+                }
+                return (0, merge_with_1.default)([
+                    firstConfiguration
+                ].concat(configurations), (0, join_arrays_1.default)(options));
+            };
+        }
+        exports.merge = merge, exports.default = merge, exports.mergeWithCustomize = mergeWithCustomize, exports.customizeArray = function(rules) {
+            return function(a, b, key) {
+                var matchedRule = Object.keys(rules).find(function(rule) {
+                    return (0, wildcard_1.default)(rule, key);
+                }) || "";
+                if (matchedRule) switch(rules[matchedRule]){
+                    case types_1.CustomizeRule.Prepend:
+                        return __spreadArray(__spreadArray([], __read(b), !1), __read(a), !1);
+                    case types_1.CustomizeRule.Replace:
+                        return b;
+                    case types_1.CustomizeRule.Append:
+                    default:
+                        return __spreadArray(__spreadArray([], __read(a), !1), __read(b), !1);
+                }
+            };
+        }, exports.mergeWithRules = function(rules) {
+            return mergeWithCustomize({
+                customizeArray: function(a, b, key) {
+                    var currentRule = rules;
+                    return (key.split(".").forEach(function(k) {
+                        currentRule && (currentRule = currentRule[k]);
+                    }), (0, utils_1.isPlainObject)(currentRule)) ? function mergeWithRule(_a) {
+                        var currentRule = _a.currentRule, a = _a.a, b = _a.b;
+                        if (!isArray(a)) return a;
+                        var bAllMatches = [];
+                        return a.map(function(ao) {
+                            if (!(0, utils_1.isPlainObject)(currentRule)) return ao;
+                            var ret = {}, rulesToMatch = [], operations = {};
+                            Object.entries(currentRule).forEach(function(_a) {
+                                var _b = __read(_a, 2), k = _b[0], v = _b[1];
+                                v === types_1.CustomizeRule.Match ? rulesToMatch.push(k) : operations[k] = v;
+                            });
+                            var bMatches = b.filter(function(o) {
+                                var matches = rulesToMatch.every(function(rule) {
+                                    return (0, utils_1.isSameCondition)(ao[rule], o[rule]);
+                                });
+                                return matches && bAllMatches.push(o), matches;
+                            });
+                            return (0, utils_1.isPlainObject)(ao) ? (Object.entries(ao).forEach(function(_a) {
+                                var _b = __read(_a, 2), k = _b[0], v = _b[1];
+                                switch(currentRule[k]){
+                                    case types_1.CustomizeRule.Match:
+                                        ret[k] = v, Object.entries(currentRule).forEach(function(_a) {
+                                            var _b = __read(_a, 2), k = _b[0];
+                                            if (_b[1] === types_1.CustomizeRule.Replace && bMatches.length > 0) {
+                                                var val = last(bMatches)[k];
+                                                void 0 !== val && (ret[k] = val);
+                                            }
+                                        });
+                                        break;
+                                    case types_1.CustomizeRule.Append:
+                                        if (!bMatches.length) {
+                                            ret[k] = v;
+                                            break;
+                                        }
+                                        var appendValue = last(bMatches)[k];
+                                        if (!isArray(v) || !isArray(appendValue)) throw TypeError("Trying to append non-arrays");
+                                        ret[k] = v.concat(appendValue);
+                                        break;
+                                    case types_1.CustomizeRule.Merge:
+                                        if (!bMatches.length) {
+                                            ret[k] = v;
+                                            break;
+                                        }
+                                        var lastValue = last(bMatches)[k];
+                                        if (!(0, utils_1.isPlainObject)(v) || !(0, utils_1.isPlainObject)(lastValue)) throw TypeError("Trying to merge non-objects");
+                                        ret[k] = merge(v, lastValue);
+                                        break;
+                                    case types_1.CustomizeRule.Prepend:
+                                        if (!bMatches.length) {
+                                            ret[k] = v;
+                                            break;
+                                        }
+                                        var prependValue = last(bMatches)[k];
+                                        if (!isArray(v) || !isArray(prependValue)) throw TypeError("Trying to prepend non-arrays");
+                                        ret[k] = prependValue.concat(v);
+                                        break;
+                                    case types_1.CustomizeRule.Replace:
+                                        ret[k] = bMatches.length > 0 ? last(bMatches)[k] : v;
+                                        break;
+                                    default:
+                                        var currentRule_1 = operations[k], b_1 = bMatches.map(function(o) {
+                                            return o[k];
+                                        }).reduce(function(acc, val) {
+                                            return isArray(acc) && isArray(val) ? __spreadArray(__spreadArray([], __read(acc), !1), __read(val), !1) : acc;
+                                        }, []);
+                                        ret[k] = mergeWithRule({
+                                            currentRule: currentRule_1,
+                                            a: v,
+                                            b: b_1
+                                        });
+                                }
+                            }), ret) : ao;
+                        }).concat(b.filter(function(o) {
+                            return !bAllMatches.includes(o);
+                        }));
+                    }({
+                        currentRule: currentRule,
+                        a: a,
+                        b: b
+                    }) : "string" == typeof currentRule ? function(_a) {
+                        var currentRule = _a.currentRule, a = _a.a, b = _a.b;
+                        switch(currentRule){
+                            case types_1.CustomizeRule.Append:
+                                return a.concat(b);
+                            case types_1.CustomizeRule.Prepend:
+                                return b.concat(a);
+                            case types_1.CustomizeRule.Replace:
+                                return b;
+                        }
+                        return a;
+                    }({
+                        currentRule: currentRule,
+                        a: a,
+                        b: b
+                    }) : void 0;
+                }
+            });
+        };
+        var isArray = Array.isArray;
+        function last(arr) {
+            return arr[arr.length - 1];
+        }
+        exports.customizeObject = function(rules) {
+            return function(a, b, key) {
+                switch(rules[key]){
+                    case types_1.CustomizeRule.Prepend:
+                        return (0, merge_with_1.default)([
+                            b,
+                            a
+                        ], (0, join_arrays_1.default)());
+                    case types_1.CustomizeRule.Replace:
+                        return b;
+                    case types_1.CustomizeRule.Append:
+                        return (0, merge_with_1.default)([
+                            a,
+                            b
+                        ], (0, join_arrays_1.default)());
+                }
+            };
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/join-arrays.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        }, __spreadArray = this && this.__spreadArray || function(to, from, pack) {
+            if (pack || 2 == arguments.length) for(var ar, i = 0, l = from.length; i < l; i++)!ar && i in from || (ar || (ar = Array.prototype.slice.call(from, 0, i)), ar[i] = from[i]);
+            return to.concat(ar || Array.prototype.slice.call(from));
+        }, __importDefault = this && this.__importDefault || function(mod) {
+            return mod && mod.__esModule ? mod : {
+                default: mod
+            };
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        });
+        var clone_deep_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js")), merge_with_1 = __importDefault(__webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/merge-with.js")), utils_1 = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/utils.js"), isArray = Array.isArray;
+        exports.default = function joinArrays(_a) {
+            var _b = void 0 === _a ? {} : _a, customizeArray = _b.customizeArray, customizeObject = _b.customizeObject, key = _b.key;
+            return function _joinArrays(a, b, k) {
+                var newKey = key ? "".concat(key, ".").concat(k) : k;
+                if ((0, utils_1.isFunction)(a) && (0, utils_1.isFunction)(b)) return function() {
+                    for(var args = [], _i = 0; _i < arguments.length; _i++)args[_i] = arguments[_i];
+                    return _joinArrays(a.apply(void 0, __spreadArray([], __read(args), !1)), b.apply(void 0, __spreadArray([], __read(args), !1)), k);
+                };
+                if (isArray(a) && isArray(b)) {
+                    var customResult = customizeArray && customizeArray(a, b, newKey);
+                    return customResult || __spreadArray(__spreadArray([], __read(a), !1), __read(b), !1);
+                }
+                if ((0, utils_1.isRegex)(b)) return b;
+                if ((0, utils_1.isPlainObject)(a) && (0, utils_1.isPlainObject)(b)) {
+                    var customResult = customizeObject && customizeObject(a, b, newKey);
+                    return customResult || (0, merge_with_1.default)([
+                        a,
+                        b
+                    ], joinArrays({
+                        customizeArray: customizeArray,
+                        customizeObject: customizeObject,
+                        key: newKey
+                    }));
+                }
+                return (0, utils_1.isPlainObject)(b) ? (0, clone_deep_1.default)(b) : isArray(b) ? __spreadArray([], __read(b), !1) : b;
+            };
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/merge-with.js": function(__unused_webpack_module, exports) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.default = function(objects, customizer) {
+            var _a = __read(objects), first = _a[0], rest = _a.slice(1), ret = first;
+            return rest.forEach(function(a) {
+                var a1, b, customizer1, ret1;
+                a1 = ret, b = a, customizer1 = customizer, ret1 = {}, Object.keys(a1).concat(Object.keys(b)).forEach(function(k) {
+                    var v = customizer1(a1[k], b[k], k);
+                    ret1[k] = void 0 === v ? a1[k] : v;
+                }), ret = ret1;
+            }), ret;
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/types.js": function(__unused_webpack_module, exports) {
+        var CustomizeRule, CustomizeRule1;
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.CustomizeRule = void 0, (CustomizeRule1 = CustomizeRule || (exports.CustomizeRule = CustomizeRule = {})).Match = "match", CustomizeRule1.Merge = "merge", CustomizeRule1.Append = "append", CustomizeRule1.Prepend = "prepend", CustomizeRule1.Replace = "replace";
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/unique.js": function(__unused_webpack_module, exports) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        }, __spreadArray = this && this.__spreadArray || function(to, from, pack) {
+            if (pack || 2 == arguments.length) for(var ar, i = 0, l = from.length; i < l; i++)!ar && i in from || (ar || (ar = Array.prototype.slice.call(from, 0, i)), ar[i] = from[i]);
+            return to.concat(ar || Array.prototype.slice.call(from));
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.default = function(key, uniques, getter) {
+            var uniquesSet = new Set(uniques);
+            return function(a, b, k) {
+                return k === key && Array.from(__spreadArray(__spreadArray([], __read(a), !1), __read(b), !1).map(function(it) {
+                    return {
+                        key: getter(it),
+                        value: it
+                    };
+                }).map(function(_a) {
+                    var key = _a.key, value = _a.value;
+                    return {
+                        key: uniquesSet.has(key) ? key : value,
+                        value: value
+                    };
+                }).reduce(function(m, _a) {
+                    var key = _a.key, value = _a.value;
+                    return m.delete(key), m.set(key, value);
+                }, new Map()).values());
+            };
+        };
+    },
+    "../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/utils.js": function(__unused_webpack_module, exports, __webpack_require__) {
+        var __read = this && this.__read || function(o, n) {
+            var m = "function" == typeof Symbol && o[Symbol.iterator];
+            if (!m) return o;
+            var r, e, i = m.call(o), ar = [];
+            try {
+                for(; (void 0 === n || n-- > 0) && !(r = i.next()).done;)ar.push(r.value);
+            } catch (error) {
+                e = {
+                    error: error
+                };
+            } finally{
+                try {
+                    r && !r.done && (m = i.return) && m.call(i);
+                } finally{
+                    if (e) throw e.error;
+                }
+            }
+            return ar;
+        };
+        Object.defineProperty(exports, "__esModule", {
+            value: !0
+        }), exports.isSameCondition = exports.isUndefined = exports.isPlainObject = exports.isFunction = exports.isRegex = void 0;
+        var flat_1 = __webpack_require__("../../node_modules/.pnpm/flat@5.0.2/node_modules/flat/index.js");
+        function isRegex(o) {
+            return o instanceof RegExp;
+        }
+        function isFunction(functionToCheck) {
+            return functionToCheck && "[object Function]" === ({}).toString.call(functionToCheck);
+        }
+        exports.isRegex = isRegex, exports.isFunction = isFunction, exports.isPlainObject = function(a) {
+            return !(null === a || Array.isArray(a)) && "object" == typeof a;
+        }, exports.isUndefined = function(a) {
+            return void 0 === a;
+        }, exports.isSameCondition = function(a, b) {
+            if (!a || !b) return a === b;
+            if ("string" == typeof a || "string" == typeof b || isRegex(a) || isRegex(b) || isFunction(a) || isFunction(b)) return a.toString() === b.toString();
+            var _a, _b, entriesA = Object.entries((0, flat_1.flatten)(a)), entriesB = Object.entries((0, flat_1.flatten)(b));
+            if (entriesA.length !== entriesB.length) return !1;
+            for(var i = 0; i < entriesA.length; i++)entriesA[i][0] = entriesA[i][0].replace(/\b\d+\b/g, "[]"), entriesB[i][0] = entriesB[i][0].replace(/\b\d+\b/g, "[]");
+            function cmp(_a, _b) {
+                var _c = __read(_a, 2), k1 = _c[0], v1 = _c[1], _d = __read(_b, 2), k2 = _d[0], v2 = _d[1];
+                return k1 < k2 ? -1 : k1 > k2 ? 1 : v1 < v2 ? -1 : +(v1 > v2);
+            }
+            if (entriesA.sort(cmp), entriesB.sort(cmp), entriesA.length !== entriesB.length) return !1;
+            for(var i = 0; i < entriesA.length; i++)if (entriesA[i][0] !== entriesB[i][0] || (null === (_a = entriesA[i][1]) || void 0 === _a ? void 0 : _a.toString()) !== (null === (_b = entriesB[i][1]) || void 0 === _b ? void 0 : _b.toString())) return !1;
+            return !0;
+        };
+    },
+    "../../node_modules/.pnpm/wildcard@2.0.1/node_modules/wildcard/index.js": function(module) {
+        var REGEXP_PARTS = /(\*|\?)/g;
+        function WildcardMatcher(text, separator) {
+            this.text = text = text || '', this.hasWild = text.indexOf('*') >= 0, this.separator = separator, this.parts = text.split(separator).map(this.classifyPart.bind(this));
+        }
+        WildcardMatcher.prototype.match = function(input) {
+            var ii, testParts, matches = !0, parts = this.parts, partsCount = parts.length;
+            if ('string' == typeof input || input instanceof String) {
+                if (this.hasWild || this.text == input) {
+                    for(ii = 0, testParts = (input || '').split(this.separator); matches && ii < partsCount; ii++)'*' !== parts[ii] && (matches = ii < testParts.length && (parts[ii] instanceof RegExp ? parts[ii].test(testParts[ii]) : parts[ii] === testParts[ii]));
+                    matches = matches && testParts;
+                } else matches = !1;
+            } else if ('function' == typeof input.splice) for(matches = [], ii = input.length; ii--;)this.match(input[ii]) && (matches[matches.length] = input[ii]);
+            else if ('object' == typeof input) for(var key in matches = {}, input)this.match(key) && (matches[key] = input[key]);
+            return matches;
+        }, WildcardMatcher.prototype.classifyPart = function(part) {
+            if ('*' === part) ;
+            else if (part.indexOf('*') >= 0 || part.indexOf('?') >= 0) return new RegExp(part.replace(REGEXP_PARTS, '\.$1'));
+            return part;
+        }, module.exports = function(text, test, separator) {
+            var matcher = new WildcardMatcher(text, separator || /[\/\.]/);
+            return void 0 !== test ? matcher.match(test) : matcher;
+        };
+    },
     crypto: function(module) {
         module.exports = __WEBPACK_EXTERNAL_MODULE_crypto__;
     },
@@ -279,25 +916,19 @@ function __webpack_require__(moduleId) {
     var module = __webpack_module_cache__[moduleId] = {
         exports: {}
     };
-    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.exports;
+    return __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__), module.exports;
 }
-__webpack_require__.n = function(module) {
-    var getter = module && module.__esModule ? function() {
-        return module.default;
-    } : function() {
-        return module;
-    };
+__webpack_require__.n = (module)=>{
+    var getter = module && module.__esModule ? ()=>module.default : ()=>module;
     return __webpack_require__.d(getter, {
         a: getter
     }), getter;
-}, __webpack_require__.d = function(exports, definition) {
+}, __webpack_require__.d = (exports, definition)=>{
     for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key) && Object.defineProperty(exports, key, {
         enumerable: !0,
         get: definition[key]
     });
-}, __webpack_require__.o = function(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}, __webpack_require__.r = function(exports) {
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = function(exports) {
     'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {
         value: 'Module'
     }), Object.defineProperty(exports, '__esModule', {
@@ -572,7 +1203,7 @@ let getAllStatsErrors = (statsData)=>{
     return statsData.warningsCount && (null === (_statsData_warnings = statsData.warnings) || void 0 === _statsData_warnings ? void 0 : _statsData_warnings.length) === 0 ? null === (_statsData_children = statsData.children) || void 0 === _statsData_children ? void 0 : _statsData_children.reduce((warnings, curr)=>warnings.concat(curr.warnings || []), []) : statsData.warnings;
 };
 function getStatsOptions(compiler) {
-    if (isMultiCompiler(compiler)) return {
+    if (helpers_isMultiCompiler(compiler)) return {
         children: compiler.compilers.map((compiler)=>compiler.options ? compiler.options.stats : void 0)
     };
     let { stats } = compiler.options;
@@ -671,8 +1302,8 @@ function getFilename(config, type, isProd, isServer) {
     }
 }
 let applyToCompiler = (compiler, apply)=>{
-    isMultiCompiler(compiler) ? compiler.compilers.forEach(apply) : apply(compiler, 0);
-}, upperFirst = (str)=>str ? str.charAt(0).toUpperCase() + str.slice(1) : '', isURL = (str)=>str.startsWith('http') || str.startsWith('//:'), createVirtualModule = (content)=>`data:text/javascript,${content}`, isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
+    helpers_isMultiCompiler(compiler) ? compiler.compilers.forEach(apply) : apply(compiler, 0);
+}, upperFirst = (str)=>str ? str.charAt(0).toUpperCase() + str.slice(1) : '', isURL = (str)=>str.startsWith('http') || str.startsWith('//:'), createVirtualModule = (content)=>`data:text/javascript,${content}`, helpers_isMultiCompiler = (compiler)=>'compilers' in compiler && Array.isArray(compiler.compilers);
 function pick(obj, keys) {
     return keys.reduce((ret, key)=>(void 0 !== obj[key] && (ret[key] = obj[key]), ret), {});
 }
@@ -778,7 +1409,7 @@ function parsePackageOrReadConfig(file) {
 }
 function pickEnv(config, opts) {
     let name;
-    return 'object' != typeof config ? config : ('string' == typeof opts.env ? name = opts.env : process.env.BROWSERSLIST_ENV ? name = process.env.BROWSERSLIST_ENV : process.env.NODE_ENV ? name = process.env.NODE_ENV : name = 'production', config[name] || config.defaults);
+    return 'object' != typeof config ? config : config['string' == typeof opts.env ? opts.env : process.env.BROWSERSLIST_ENV ? process.env.BROWSERSLIST_ENV : process.env.NODE_ENV ? process.env.NODE_ENV : 'production'] || config.defaults;
 }
 function eachParent(file, callback) {
     let dir = isFile(file) ? __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.dirname(file) : file, loc = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.resolve(dir);
@@ -803,7 +1434,7 @@ let configCache = {}, OVERRIDE_PATHS = [
         return OVERRIDE_PATHS.includes(realKey);
     }
     return OVERRIDE_PATHS.includes(key);
-}, mergeConfig_merge = (x, y, path = '')=>{
+}, merge = (x, y, path = '')=>{
     if (isOverridePath(path)) return y ?? x;
     if (void 0 === x) return isPlainObject(y) ? cloneDeep(y) : y;
     if (void 0 === y) return isPlainObject(x) ? cloneDeep(x) : x;
@@ -824,10 +1455,10 @@ let configCache = {}, OVERRIDE_PATHS = [
         ...Object.keys(y)
     ])){
         let childPath = path ? `${path}.${key}` : key;
-        merged[key] = mergeConfig_merge(x[key], y[key], childPath);
+        merged[key] = merge(x[key], y[key], childPath);
     }
     return merged;
-}, mergeRsbuildConfig = (...configs)=>2 === configs.length ? mergeConfig_merge(configs[0], configs[1]) : configs.length < 2 ? configs[0] : configs.reduce((result, config)=>mergeConfig_merge(result, config), {}), commonOpts = {}, getEnvDir = (cwd, envDir)=>envDir ? __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.isAbsolute(envDir) ? envDir : __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.join(cwd, envDir) : cwd;
+}, mergeRsbuildConfig = (...configs)=>2 === configs.length ? merge(configs[0], configs[1]) : configs.length < 2 ? configs[0] : configs.reduce((result, config)=>merge(result, config), {}), commonOpts = {}, getEnvDir = (cwd, envDir)=>envDir ? __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.isAbsolute(envDir) ? envDir : __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.join(cwd, envDir) : cwd;
 async function init({ cliOptions, isRestart, isBuildWatch = !1 }) {
     cliOptions && (commonOpts = cliOptions);
     try {
@@ -1148,7 +1779,7 @@ async function watchFilesForRestart(files, root, isBuildWatch, watchOptions) {
         ignorePermissionErrors: !0,
         ...watchOptions
     }), callback = (func = async (filePath)=>{
-        watcher.close(), isBuildWatch ? await restartBuild({
+        await watcher.close(), isBuildWatch ? await restartBuild({
             filePath
         }) : await restartDevServer({
             filePath
@@ -1414,7 +2045,7 @@ function createAsyncHook() {
 }
 let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isWatch })=>{
     let name = 'rsbuild:beforeCompile';
-    if (isMultiCompiler(compiler)) {
+    if (helpers_isMultiCompiler(compiler)) {
         let waitBeforeCompileDone;
         let { compilers } = compiler, doneCompilers = 0;
         for(let index = 0; index < compilers.length; index++){
@@ -1429,7 +2060,7 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
         await (null == beforeCompile ? void 0 : beforeCompile()), await beforeEnvironmentCompiler(0);
     });
 }, onCompileDone = ({ compiler, onDone, onEnvironmentDone, MultiStatsCtor })=>{
-    if (isMultiCompiler(compiler)) {
+    if (helpers_isMultiCompiler(compiler)) {
         let { compilers } = compiler, compilerStats = [], doneCompilers = 0;
         for(let index = 0; index < compilers.length; index++){
             let compiler = compilers[index], compilerIndex = index, compilerDone = !1;
@@ -1653,7 +2284,7 @@ async function updateEnvironmentContext(context, configs) {
 async function createContext(options, userConfig, bundlerType) {
     let { cwd } = options, rootPath = userConfig.root ? getAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.join)(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
     return {
-        version: "1.2.16",
+        version: "1.2.18",
         rootPath,
         distPath: '',
         cachePath,
@@ -4159,29 +4790,32 @@ async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerCo
         }
     };
 }
-async function modifyRspackConfig(context, rspackConfig, utils) {
+var dist = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/index.js");
+async function modifyRspackConfig(context, rspackConfig, chainUtils) {
     var _utils_environment_config_tools;
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rspack config');
-    let [modifiedConfig] = await context.hooks.modifyRspackConfig.callChain({
+    let currentConfig = rspackConfig, proxiedConfig = new Proxy({}, {
+        get: (_, prop)=>currentConfig[prop],
+        set: (_, prop, value)=>(currentConfig[prop] = value, !0)
+    }), utils = await getConfigUtils(proxiedConfig, chainUtils);
+    return [currentConfig] = await context.hooks.modifyRspackConfig.callChain({
         environment: utils.environment.name,
         args: [
             rspackConfig,
             utils
         ]
-    });
-    return (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.rspack) && (modifiedConfig = await reduceConfigsAsyncWithContext({
-        initial: modifiedConfig,
+    }), (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.rspack) && (currentConfig = await reduceConfigsAsyncWithContext({
+        initial: currentConfig,
         config: utils.environment.config.tools.rspack,
         ctx: utils,
-        mergeFn: utils.mergeConfig
-    })), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rspack config done'), modifiedConfig;
+        mergeFn: (...args)=>currentConfig = utils.mergeConfig.call(utils, args)
+    })), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rspack config done'), currentConfig;
 }
 async function getConfigUtils(config, chainUtils) {
-    let { merge } = await import("../compiled/webpack-merge/index.js");
     return {
         ...chainUtils,
         rspack: __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack,
-        mergeConfig: merge,
+        mergeConfig: dist.merge,
         addRules (rules) {
             let ruleArr = castArray(rules);
             config.module || (config.module = {}), config.module.rules || (config.module.rules = []), config.module.rules.unshift(...ruleArr);
@@ -4236,7 +4870,7 @@ async function generateRspackConfig({ target, context, environment }) {
             }
         }
         config.devServer && __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.warn(`[rsbuild:config] Find invalid Rspack config: "${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.yellow('devServer')}". Note that Rspack's "devServer" config is not supported by Rsbuild. You can use Rsbuild's "dev" config to configure the Rsbuild dev server.`);
-    }(rspackConfig = await modifyRspackConfig(context, rspackConfig, await getConfigUtils(rspackConfig, chainUtils))), rspackConfig;
+    }(rspackConfig = await modifyRspackConfig(context, rspackConfig, chainUtils)), rspackConfig;
 }
 async function modifyRsbuildConfig(context) {
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rsbuild config');
@@ -4616,47 +5250,50 @@ class SocketServer {
         let curStats = this.stats[name];
         if (!curStats) return null;
         let statsOptions = getStatsOptions(curStats.compilation.compiler);
-        return curStats.toJson({
-            all: !1,
-            hash: !0,
-            assets: !0,
-            warnings: !0,
-            warningsCount: !0,
-            errors: !0,
-            errorsCount: !0,
-            errorDetails: !1,
-            entrypoints: !0,
-            children: !0,
-            moduleTrace: !0,
-            ...statsOptions
-        });
+        return {
+            statsJson: curStats.toJson({
+                all: !1,
+                hash: !0,
+                assets: !0,
+                warnings: !0,
+                warningsCount: !0,
+                errors: !0,
+                errorsCount: !0,
+                errorDetails: !1,
+                entrypoints: !0,
+                children: !0,
+                moduleTrace: !0,
+                ...statsOptions
+            }),
+            root: curStats.compilation.compiler.options.context
+        };
     }
     sendStats({ force = !1, compilationId }) {
-        let stats = this.getStats(compilationId);
-        if (!stats) return null;
-        let newInitialChunks = new Set();
-        if (stats.entrypoints) for (let entrypoint of Object.values(stats.entrypoints)){
+        let result = this.getStats(compilationId);
+        if (!result) return null;
+        let { statsJson, root } = result, newInitialChunks = new Set();
+        if (statsJson.entrypoints) for (let entrypoint of Object.values(statsJson.entrypoints)){
             let chunks = entrypoint.chunks;
             if (Array.isArray(chunks)) for (let chunkName of chunks)chunkName && newInitialChunks.add(String(chunkName));
         }
-        let initialChunks = this.initialChunks[compilationId], shouldReload = !!stats.entrypoints && !!initialChunks && !(initialChunks.size === newInitialChunks.size && [
+        let initialChunks = this.initialChunks[compilationId], shouldReload = !!statsJson.entrypoints && !!initialChunks && !(initialChunks.size === newInitialChunks.size && [
             ...initialChunks
         ].every((value)=>newInitialChunks.has(value)));
         if (this.initialChunks[compilationId] = newInitialChunks, shouldReload) return this.sockWrite({
             type: 'static-changed',
             compilationId
         });
-        if (!force && stats && !stats.errorsCount && stats.assets && stats.assets.every((asset)=>!asset.emitted)) return this.sockWrite({
+        if (!force && statsJson && !statsJson.errorsCount && statsJson.assets && statsJson.assets.every((asset)=>!asset.emitted)) return this.sockWrite({
             type: 'still-ok',
             compilationId
         });
         if (this.sockWrite({
             type: 'hash',
             compilationId,
-            data: stats.hash
-        }), stats.errorsCount) {
+            data: statsJson.hash
+        }), statsJson.errorsCount) {
             let { errors: formattedErrors } = formatStatsMessages({
-                errors: getAllStatsErrors(stats),
+                errors: getAllStatsErrors(statsJson),
                 warnings: []
             });
             return this.sockWrite({
@@ -4664,10 +5301,13 @@ class SocketServer {
                 compilationId,
                 data: {
                     text: formattedErrors,
-                    html: function(errors) {
-                        let htmlItems = errors.map((item)=>server_ansiHTML(item ? item.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;') : '').replace(/(?:[a-zA-Z]:\\|\/).*?:\d+:\d+/g, (file)=>{
-                                let hasClosingSpan = file.includes('</span>') && !file.includes('<span'), filePath = hasClosingSpan ? file.replace('</span>', '') : file;
-                                return `<a class="file-link" data-file="${filePath}">${filePath}</a>${hasClosingSpan ? '</span>' : ''}`;
+                    html: function(errors, root) {
+                        let htmlItems = errors.map((item)=>server_ansiHTML(item ? item.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;') : '').replace(/(?:\.\.?[\/\\]|[a-zA-Z]:\\|\/)[^:]*:\d+:\d+/g, (file)=>{
+                                let hasClosingSpan = file.includes('</span>') && !file.includes('<span'), filePath = hasClosingSpan ? file.replace('</span>', '') : file, isAbsolute = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.isAbsolute(filePath), absolutePath = root && !isAbsolute ? __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.join(root, filePath) : filePath, relativePath = root && isAbsolute ? function(base, filepath) {
+                                    let relativePath = (0, __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.relative)(base, filepath);
+                                    return '' === relativePath ? `.${__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep}` : relativePath.startsWith('.') ? relativePath : `.${__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep}${relativePath}`;
+                                }(root, filePath) : filePath;
+                                return `<a class="file-link" data-file="${absolutePath}">${relativePath}</a>${hasClosingSpan ? '</span>' : ''}`;
                             }));
                         return `
 <style>
@@ -4789,13 +5429,13 @@ class SocketServer {
   </div>
 </div>
 `;
-                    }(formattedErrors)
+                    }(formattedErrors, root)
                 }
             });
         }
-        if (stats.warningsCount) {
+        if (statsJson.warningsCount) {
             let { warnings: formattedWarnings } = formatStatsMessages({
-                warnings: getAllStatsWarnings(stats),
+                warnings: getAllStatsWarnings(statsJson),
                 errors: []
             });
             return this.sockWrite({
@@ -5044,7 +5684,12 @@ class CommonJsRunner extends BasicRunner {
             let currentModuleScope = this.createModuleScope(this.getRequire(), m, file), args = Object.keys(currentModuleScope), argValues = args.map((arg)=>currentModuleScope[arg]), code = `(function(${args.join(', ')}) {
         ${file.content}
       })`;
-            return this.preExecute(code, file), (this._options.runInNewContext ? __WEBPACK_EXTERNAL_MODULE_node_vm_bd3d9cea__.default.runInNewContext(code, this.globalContext, file.path) : __WEBPACK_EXTERNAL_MODULE_node_vm_bd3d9cea__.default.runInThisContext(code, file.path)).call(m.exports, ...argValues), this.postExecute(m, file), m.exports;
+            this.preExecute(code, file);
+            let dynamicImport = Function('specifier', 'return import(specifier)');
+            return __WEBPACK_EXTERNAL_MODULE_node_vm_bd3d9cea__.default.runInThisContext(code, {
+                filename: file.path,
+                importModuleDynamically: async (specifier)=>await dynamicImport(specifier)
+            }).call(m.exports, ...argValues), this.postExecute(m, file), m.exports;
         };
     }
 }
@@ -5487,7 +6132,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
     }) : Promise.resolve(), startCompile = async ()=>{
         let compiler = customCompiler || await createCompiler();
         if (!compiler) throw Error('[rsbuild:server] Failed to get compiler instance.');
-        let publicPaths = isMultiCompiler(compiler) ? compiler.compilers.map(getPublicPathFromCompiler) : [
+        let publicPaths = helpers_isMultiCompiler(compiler) ? compiler.compilers.map(getPublicPathFromCompiler) : [
             getPublicPathFromCompiler(compiler)
         ], compilerDevMiddleware = new CompilerDevMiddleware({
             dev: devConfig,
@@ -5499,7 +6144,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             compiler,
             environments: options.context.environments
         });
-        return await compilerDevMiddleware.init(), outputFileSystem = (isMultiCompiler(compiler) ? compiler.compilers[0].outputFileSystem : compiler.outputFileSystem) || __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.default, {
+        return await compilerDevMiddleware.init(), outputFileSystem = (helpers_isMultiCompiler(compiler) ? compiler.compilers[0].outputFileSystem : compiler.outputFileSystem) || __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.default, {
             middleware: compilerDevMiddleware.middleware,
             sockWrite: (...args)=>compilerDevMiddleware.sockWrite(...args),
             onUpgrade: (...args)=>compilerDevMiddleware.upgrade(...args),
@@ -5648,7 +6293,7 @@ async function createCompiler_createCompiler(options) {
         bundlerConfigs: rspackConfigs,
         environments: context.environments
     }), !await isSatisfyRspackVersion(__WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack.rspackVersion)) throw Error(`[rsbuild] The current Rspack version does not meet the requirements, the minimum supported version of Rspack is ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.green(rspackMinVersion)}`);
-    let compiler = 1 === rspackConfigs.length ? (0, __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack)(rspackConfigs[0]) : (0, __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack)(rspackConfigs), isVersionLogged = !1, isCompiling = !1, logRspackVersion = ()=>{
+    let isMultiCompiler = rspackConfigs.length > 1, compiler = isMultiCompiler ? (0, __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack)(rspackConfigs) : (0, __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack)(rspackConfigs[0]), isVersionLogged = !1, isCompiling = !1, logRspackVersion = ()=>{
         isVersionLogged || (__WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug(`use Rspack v${__WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack.rspackVersion}`), isVersionLogged = !0);
     };
     compiler.hooks.watchRun.tap('rsbuild:compiling', (compiler)=>{
@@ -5677,13 +6322,13 @@ async function createCompiler_createCompiler(options) {
             ...statsOptions
         }), printTime = (c, index)=>{
             if (c.time) {
-                let time = prettyTime(c.time / 1000), { name } = rspackConfigs[index], suffix = name ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.gray(` (${name})`) : '';
+                let time = prettyTime(c.time / 1000), { name } = rspackConfigs[index], suffix = name && isMultiCompiler ? __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.gray(` (${name})`) : '';
                 __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.ready(`built in ${time}${suffix}`);
             }
         }, hasErrors = stats.hasErrors();
         if (!hasErrors) {
             var _statsJson_children;
-            rspackConfigs.length > 1 && (null === (_statsJson_children = statsJson.children) || void 0 === _statsJson_children ? void 0 : _statsJson_children.length) ? statsJson.children.forEach((c, index)=>{
+            isMultiCompiler && (null === (_statsJson_children = statsJson.children) || void 0 === _statsJson_children ? void 0 : _statsJson_children.length) ? statsJson.children.forEach((c, index)=>{
                 printTime(c, index);
             }) : printTime(statsJson, 0);
         }
@@ -6644,7 +7289,7 @@ class CAC extends __WEBPACK_EXTERNAL_MODULE_events__.EventEmitter {
         }), actionArgs.push(options), command.commandAction.apply(this, actionArgs);
     }
 }
-let dist = (name = "")=>new CAC(name), applyCommonOptions = (cli)=>{
+let cac_dist = (name = "")=>new CAC(name), applyCommonOptions = (cli)=>{
     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('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file').option('--environment <name>', 'specify the name of environment to build', {
@@ -6668,12 +7313,12 @@ async function runCLI() {
             }
         }(), process.title = 'rsbuild-node';
         let { npm_execpath } = process.env;
-        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.greet(`  Rsbuild v1.2.16\n`);
+        (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.greet(`  Rsbuild v1.2.18\n`);
     }();
     try {
         !function() {
-            let cli = dist('rsbuild');
-            cli.help(), cli.version("1.2.16"), applyCommonOptions(cli);
+            let cli = cac_dist('rsbuild');
+            cli.help(), cli.version("1.2.18"), applyCommonOptions(cli);
             let devCommand = cli.command('dev', 'starting the dev server'), 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 {
@@ -6724,6 +7369,6 @@ async function runCLI() {
         __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.error('Failed to start Rsbuild CLI.'), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.error(err);
     }
 }
-let src_version = "1.2.16";
+let src_version = "1.2.18";
 var __webpack_exports__logger = __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger, __webpack_exports__rspack = __WEBPACK_EXTERNAL_MODULE__rspack_core_e0096ff7__.rspack;
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, createRsbuild, defineConfig, ensureAssetPrefix, config_loadConfig as loadConfig, loadEnv, mergeRsbuildConfig, runCLI, src_version as version, __webpack_exports__logger as logger, __webpack_exports__rspack as rspack };