@rsbuild/core 1.2.15 → 1.2.17

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', {
@@ -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
@@ -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.15",
+        version: "1.2.17",
         rootPath,
         distPath: '',
         cachePath,
@@ -2280,9 +2911,26 @@ let isPostcssPluginCreator = (plugin)=>'function' == typeof plugin && !0 === plu
                         localIdentName,
                         emitCss
                     });
-                    rule.use(CHAIN_ID.USE.CSS).options(cssLoaderOptions), rule.merge({
+                    rule.use(CHAIN_ID.USE.CSS).options(cssLoaderOptions);
+                    let isStringExport = 'string' === cssLoaderOptions.exportType;
+                    if (isStringExport && rule.uses.has(CHAIN_ID.USE.MINI_CSS_EXTRACT) && rule.uses.delete(CHAIN_ID.USE.MINI_CSS_EXTRACT), rule.merge({
                         sideEffects: !0
-                    }), rule.resolve.preferRelative(!0);
+                    }), rule.resolve.preferRelative(!0), emitCss && !config.output.injectStyles && !isStringExport) {
+                        let extractPluginOptions = config.tools.cssExtract.pluginOptions, cssPath = config.output.distPath.css, cssFilename = getFilename(config, 'css', isProd), isCssFilenameFn = 'function' == typeof cssFilename, cssAsyncPath = config.output.distPath.cssAsync ?? (cssPath ? `${cssPath}/async` : 'async');
+                        chain.plugin(CHAIN_ID.PLUGIN.MINI_CSS_EXTRACT).use(getCssExtractPlugin(), [
+                            {
+                                filename: isCssFilenameFn ? (...args)=>{
+                                    let name = cssFilename(...args);
+                                    return __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.posix.join(cssPath, name);
+                                } : __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.posix.join(cssPath, cssFilename),
+                                chunkFilename: isCssFilenameFn ? (...args)=>{
+                                    let name = cssFilename(...args);
+                                    return __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.posix.join(cssAsyncPath, name);
+                                } : __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.posix.join(cssAsyncPath, cssFilename),
+                                ...extractPluginOptions
+                            }
+                        ]);
+                    }
                 }
             });
         }
@@ -2370,21 +3018,24 @@ async function printFileSizes(options, stats, rootPath, environmentName) {
     if (0 === assets.length) return logs;
     logs.push(''), assets.sort((a, b)=>a.size - b.size);
     let longestLabelLength = Math.max(...assets.map((a)=>a.sizeLabel.length)), longestFileLength = Math.max(...assets.map((a)=>(a.folder + __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.sep + a.name).length));
-    !1 !== options.detail && logs.push(function(longestFileLength, longestLabelLength, options, environmentName) {
-        let longestLengths = [
-            longestFileLength,
-            longestLabelLength
-        ], rowTypes = [
-            `File (${environmentName})`,
-            'Size'
-        ];
-        options.compressed && rowTypes.push('Gzip');
-        let headerRow = rowTypes.reduce((prev, cur, index)=>{
-            let length = longestLengths[index], curLabel = cur;
-            return length && (curLabel = cur.length < length ? cur + ' '.repeat(length - cur.length) : cur), `${prev + curLabel}    `;
-        }, '  ');
-        return __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.blue(headerRow);
-    }(longestFileLength, longestLabelLength, options, environmentName));
+    if (!1 !== options.detail) {
+        let showGzipHeader = !!(options.compressed && assets.some((item)=>null !== item.gzippedSize));
+        logs.push(function(longestFileLength, longestLabelLength, environmentName, showGzipHeader) {
+            let longestLengths = [
+                longestFileLength,
+                longestLabelLength
+            ], rowTypes = [
+                `File (${environmentName})`,
+                'Size'
+            ];
+            showGzipHeader && rowTypes.push('Gzip');
+            let headerRow = rowTypes.reduce((prev, cur, index)=>{
+                let length = longestLengths[index], curLabel = cur;
+                return length && (curLabel = cur.length < length ? cur + ' '.repeat(length - cur.length) : cur), `${prev + curLabel}    `;
+            }, '  ');
+            return __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.blue(headerRow);
+        }(longestFileLength, longestLabelLength, environmentName, showGzipHeader));
+    }
     let totalSize = 0, totalGzipSize = 0;
     for (let asset of assets){
         let { sizeLabel } = asset, { name, folder, gzipSizeLabel } = asset, fileNameLength = (folder + __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.default.sep + name).length, sizeLength = sizeLabel.length;
@@ -3111,7 +3762,10 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         ...headTags,
                         ...bodyTags
                     ];
-                    if (nonce) for (let tag of allTags)("script" === tag.tag || 'style' === tag.tag) && (tag.attrs ??= {}, tag.attrs.nonce = nonce);
+                    if (nonce) for (let tag of allTags){
+                        var _tag_attrs, _tag_attrs1;
+                        ("script" === tag.tag || 'style' === tag.tag || 'link' === tag.tag && (null === (_tag_attrs = tag.attrs) || void 0 === _tag_attrs ? void 0 : _tag_attrs.rel) === 'preload' && (null === (_tag_attrs1 = tag.attrs) || void 0 === _tag_attrs1 ? void 0 : _tag_attrs1.as) === "script") && (tag.attrs ??= {}, tag.attrs.nonce = nonce);
+                    }
                     return {
                         headTags,
                         bodyTags
@@ -3341,7 +3995,7 @@ async function open_open({ https, port, routes, config, clearCache }) {
 let getJsAsyncPath = (jsPath, isServer, jsAsync)=>void 0 !== jsAsync ? jsAsync : isServer ? jsPath : jsPath ? `${jsPath}/async` : 'async', pluginOutput = ()=>({
         name: 'rsbuild:output',
         setup (api) {
-            api.modifyBundlerChain(async (chain, { CHAIN_ID, target, isProd, isServer, environment })=>{
+            api.modifyBundlerChain(async (chain, { CHAIN_ID, isProd, isServer, environment })=>{
                 let { distPath, config } = environment, publicPath = function({ isProd, config, context }) {
                     var _context_devServer, _context_devServer1, _context_devServer2;
                     let { dev, output, server } = config, publicPath = DEFAULT_ASSET_PREFIX, port = (null === (_context_devServer = context.devServer) || void 0 === _context_devServer ? void 0 : _context_devServer.port) || server.port || 3000;
@@ -3374,23 +4028,6 @@ let getJsAsyncPath = (jsPath, isServer, jsAsync)=>void 0 !== jsAsync ? jsAsync :
                         options
                     ]);
                 }
-                let emitCss = config.output.emitCss ?? 'web' === target;
-                if (!config.output.injectStyles && emitCss) {
-                    let extractPluginOptions = config.tools.cssExtract.pluginOptions, cssPath = config.output.distPath.css, cssFilename = getFilename(config, 'css', isProd), isCssFilenameFn = 'function' == typeof cssFilename, cssAsyncPath = config.output.distPath.cssAsync ?? (cssPath ? `${cssPath}/async` : 'async');
-                    chain.plugin(CHAIN_ID.PLUGIN.MINI_CSS_EXTRACT).use(getCssExtractPlugin(), [
-                        {
-                            filename: isCssFilenameFn ? (...args)=>{
-                                let name = cssFilename(...args);
-                                return __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.posix.join(cssPath, name);
-                            } : __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.posix.join(cssPath, cssFilename),
-                            chunkFilename: isCssFilenameFn ? (...args)=>{
-                                let name = cssFilename(...args);
-                                return __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.posix.join(cssAsyncPath, name);
-                            } : __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.posix.join(cssAsyncPath, cssFilename),
-                            ...extractPluginOptions
-                        }
-                    ]);
-                }
             });
         }
     }), pluginPerformance = ()=>({
@@ -3882,7 +4519,7 @@ let resourceHints_generateLinks = (options, rel)=>options.map((option)=>({
                 };
                 'webpack' === api.context.bundlerType && (defaultConfig.enforceSizeThreshold = 50000);
                 let { chunkSplit } = config.performance, forceSplittingGroups = {};
-                chunkSplit.forceSplitting && (forceSplittingGroups = function(forceSplitting) {
+                chunkSplit.forceSplitting && (forceSplittingGroups = function(forceSplitting, strategy) {
                     let cacheGroups = {};
                     for (let [key, regexp] of Array.isArray(forceSplitting) ? forceSplitting.map((regexp, index)=>[
                             `force-split-${index}`,
@@ -3891,11 +4528,11 @@ let resourceHints_generateLinks = (options, rel)=>options.map((option)=>({
                         test: regexp,
                         name: key,
                         chunks: 'all',
-                        priority: 0,
+                        priority: +('single-vendor' === strategy),
                         enforce: !0
                     };
                     return cacheGroups;
-                }(chunkSplit.forceSplitting));
+                }(chunkSplit.forceSplitting, chunkSplit.strategy));
                 let override = 'custom' === chunkSplit.strategy ? chunkSplit.splitChunks ?? chunkSplit.override : chunkSplit.override, splitChunksOptions = await SPLIT_STRATEGY_DISPATCHER[chunkSplit.strategy || 'split-by-experience']({
                     defaultConfig,
                     override: override || {},
@@ -4153,6 +4790,7 @@ async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerCo
         }
     };
 }
+var dist = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/index.js");
 async function modifyRspackConfig(context, rspackConfig, utils) {
     var _utils_environment_config_tools;
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rspack config');
@@ -4171,11 +4809,10 @@ async function modifyRspackConfig(context, rspackConfig, utils) {
     })), __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('modify Rspack config done'), modifiedConfig;
 }
 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);
@@ -4610,47 +5247,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({
@@ -4658,10 +5298,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>
@@ -4783,13 +5426,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({
@@ -5619,11 +6262,21 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
     })).middlewares))Array.isArray(item) ? middlewares.use(...item) : middlewares.use(item);
     return __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('create dev server done'), devServerAPI;
 }
-function cutPath(filePath, root) {
-    let prefix = root.endsWith(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep) ? root : root + __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep;
-    if (filePath.startsWith(prefix)) return filePath.slice(prefix.length);
-    let parts = filePath.split(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep).filter(Boolean);
-    return parts.length > 3 ? parts.slice(-3).join(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep) : parts.join(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep);
+function isLikelyFile(filePath) {
+    return (filePath.split(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep).pop() || '').includes('.');
+}
+function formatFileList(paths, rootPath) {
+    let files = paths.filter(isLikelyFile);
+    0 === files.length && (files = [
+        paths[0]
+    ]);
+    let fileInfo = files.slice(0, 1).map((file)=>(function(originalFilePath, root) {
+            let prefix = root.endsWith(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep) ? root : root + __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep, filePath = originalFilePath;
+            filePath.startsWith(prefix) && (filePath = filePath.slice(prefix.length));
+            let parts = filePath.split(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep).filter(Boolean);
+            return parts.length > 3 ? parts.slice(-3).join(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep) : parts.join(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__.sep);
+        })(file, rootPath)).join(', ');
+    return files.length > 1 ? `${fileInfo} and ${files.length - 1} more` : fileInfo;
 }
 async function createCompiler_createCompiler(options) {
     __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.debug('create compiler');
@@ -5636,17 +6289,21 @@ async function createCompiler_createCompiler(options) {
         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)=>{
-        if (logRspackVersion(), !isCompiling) {
-            let changedFiles = compiler.modifiedFiles ? Array.from(compiler.modifiedFiles) : [], removedFiles = compiler.removedFiles ? Array.from(compiler.removedFiles) : [];
-            if (changedFiles.length) {
-                let fileInfo = __WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.dim(changedFiles.map((file)=>cutPath(file, context.rootPath)).join(', '));
-                __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.start(`building ${fileInfo}`);
-            } else if (removedFiles.length) {
-                let fileInfo = removedFiles.map((file)=>cutPath(file, context.rootPath)).join(', ');
+        logRspackVersion(), isCompiling || function(compiler, context) {
+            let changedFiles = compiler.modifiedFiles ? Array.from(compiler.modifiedFiles) : null;
+            if (null == changedFiles ? void 0 : changedFiles.length) {
+                let fileInfo = formatFileList(changedFiles, context.rootPath);
+                __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.start(`building ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.dim(fileInfo)}`);
+                return;
+            }
+            let removedFiles = compiler.removedFiles ? Array.from(compiler.removedFiles) : null;
+            if (null == removedFiles ? void 0 : removedFiles.length) {
+                let fileInfo = formatFileList(removedFiles, context.rootPath);
                 __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.start(`building ${__WEBPACK_EXTERNAL_MODULE__compiled_picocolors_index_js_ea7a20e9__.default.dim(`removed ${fileInfo}`)}`);
-            } else __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.start('build started...');
-        }
-        isCompiling = !0;
+                return;
+            }
+            __WEBPACK_EXTERNAL_MODULE__compiled_rslog_index_js_c302f6e3__.logger.start('build started...');
+        }(compiler, context), isCompiling = !0;
     }), 'build' === context.command && compiler.hooks.run.tap('rsbuild:run', logRspackVersion);
     let done = (stats)=>{
         let statsOptions = getStatsOptions(compiler), statsJson = stats.toJson({
@@ -6624,7 +7281,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', {
@@ -6648,12 +7305,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.15\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.17\n`);
     }();
     try {
         !function() {
-            let cli = dist('rsbuild');
-            cli.help(), cli.version("1.2.15"), applyCommonOptions(cli);
+            let cli = cac_dist('rsbuild');
+            cli.help(), cli.version("1.2.17"), 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 {
@@ -6704,6 +7361,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.15";
+let src_version = "1.2.17";
 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 };