@rsbuild/core 1.2.16 → 1.2.17

package/dist/index.cjs

@@ -1,5 +1,32 @@
+/*! For license information please see index.cjs.LICENSE.txt */
 let __rslib_import_meta_url__ = 'undefined' == typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
 var __webpack_modules__ = {
+    "../../node_modules/.pnpm/clone-deep@4.0.1/node_modules/clone-deep/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        "use strict";
+        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) {
         "use strict";
         var isMergeableObject = function(value) {
@@ -232,6 +259,627 @@ var __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__) {
+        "use strict";
+        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) {
+        "use strict";
+        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__) {
+        "use strict";
+        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, exports1, __webpack_require__) {
+        "use strict";
+        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(exports1, "__esModule", {
+            value: !0
+        }), exports1.unique = exports1.mergeWithRules = exports1.mergeWithCustomize = exports1.default = exports1.merge = exports1.CustomizeRule = exports1.customizeObject = exports1.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"));
+        exports1.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(exports1, "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));
+            };
+        }
+        exports1.merge = merge, exports1.default = merge, exports1.mergeWithCustomize = mergeWithCustomize, exports1.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);
+                }
+            };
+        }, exports1.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];
+        }
+        exports1.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, exports1, __webpack_require__) {
+        "use strict";
+        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(exports1, "__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;
+        exports1.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, exports1) {
+        "use strict";
+        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(exports1, "__esModule", {
+            value: !0
+        }), exports1.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, exports1) {
+        "use strict";
+        var CustomizeRule, CustomizeRule1;
+        Object.defineProperty(exports1, "__esModule", {
+            value: !0
+        }), exports1.CustomizeRule = void 0, (CustomizeRule1 = CustomizeRule || (exports1.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, exports1) {
+        "use strict";
+        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(exports1, "__esModule", {
+            value: !0
+        }), exports1.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, exports1, __webpack_require__) {
+        "use strict";
+        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(exports1, "__esModule", {
+            value: !0
+        }), exports1.isSameCondition = exports1.isUndefined = exports1.isPlainObject = exports1.isFunction = exports1.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);
+        }
+        exports1.isRegex = isRegex, exports1.isFunction = isFunction, exports1.isPlainObject = function(a) {
+            return !(null === a || Array.isArray(a)) && "object" == typeof a;
+        }, exports1.isUndefined = function(a) {
+            return void 0 === a;
+        }, exports1.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) {
+        "use strict";
+        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) {
         "use strict";
         module.exports = require("crypto");
@@ -304,10 +952,6 @@ var __webpack_modules__ = {
         "use strict";
         module.exports = import("../compiled/webpack-bundle-analyzer/index.js");
     },
-    "../../compiled/webpack-merge/index.js": function(module) {
-        "use strict";
-        module.exports = import("../compiled/webpack-merge/index.js");
-    },
     "../../compiled/ws/index.js": function(module) {
         "use strict";
         module.exports = import("../compiled/ws/index.js");
@@ -339,25 +983,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(exports1, definition) {
+}, __webpack_require__.d = (exports1, definition)=>{
     for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key) && Object.defineProperty(exports1, key, {
         enumerable: !0,
         get: definition[key]
     });
-}, __webpack_require__.o = function(obj, prop) {
-    return Object.prototype.hasOwnProperty.call(obj, prop);
-}, __webpack_require__.r = function(exports1) {
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = function(exports1) {
     'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
         value: 'Module'
     }), Object.defineProperty(exports1, '__esModule', {
@@ -369,18 +1007,18 @@ var __webpack_exports__ = {};
     "use strict";
     let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin;
     __webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
-        ensureAssetPrefix: ()=>ensureAssetPrefix,
-        PLUGIN_CSS_NAME: ()=>PLUGIN_CSS_NAME,
-        mergeRsbuildConfig: ()=>mergeRsbuildConfig,
         logger: ()=>rslog_index_js_namespaceObject.logger,
-        loadEnv: ()=>loadEnv,
         createRsbuild: ()=>createRsbuild,
         rspack: ()=>core_namespaceObject.rspack,
+        defineConfig: ()=>defineConfig,
+        mergeRsbuildConfig: ()=>mergeRsbuildConfig,
         runCLI: ()=>runCLI,
         version: ()=>src_rslib_entry_version,
         PLUGIN_SWC_NAME: ()=>PLUGIN_SWC_NAME,
+        PLUGIN_CSS_NAME: ()=>PLUGIN_CSS_NAME,
         loadConfig: ()=>config_loadConfig,
-        defineConfig: ()=>defineConfig
+        ensureAssetPrefix: ()=>ensureAssetPrefix,
+        loadEnv: ()=>loadEnv
     });
     var provider_helpers_namespaceObject = {};
     __webpack_require__.r(provider_helpers_namespaceObject), __webpack_require__.d(provider_helpers_namespaceObject, {
@@ -867,7 +1505,7 @@ var __webpack_exports__ = {};
     }
     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) ? external_node_path_namespaceObject.dirname(file) : file, loc = external_node_path_namespaceObject.resolve(dir);
@@ -894,7 +1532,7 @@ var __webpack_exports__ = {};
             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;
@@ -915,10 +1553,10 @@ var __webpack_exports__ = {};
             ...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 ? external_node_path_default().isAbsolute(envDir) ? envDir : external_node_path_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 ? external_node_path_default().isAbsolute(envDir) ? envDir : external_node_path_default().join(cwd, envDir) : cwd;
     async function init({ cliOptions, isRestart, isBuildWatch = !1 }) {
         cliOptions && (commonOpts = cliOptions);
         try {
@@ -1239,7 +1877,7 @@ var __webpack_exports__ = {};
             ignorePermissionErrors: !0,
             ...watchOptions
         }), callback = (func = async (filePath)=>{
-            watcher.close(), isBuildWatch ? await restartBuild({
+            await watcher.close(), isBuildWatch ? await restartBuild({
                 filePath
             }) : await restartDevServer({
                 filePath
@@ -1744,7 +2382,7 @@ var __webpack_exports__ = {};
     async function createContext(options, userConfig, bundlerType) {
         let { cwd } = options, rootPath = userConfig.root ? getAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, external_node_path_namespaceObject.join)(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0;
         return {
-            version: "1.2.16",
+            version: "1.2.17",
             rootPath,
             distPath: '',
             cachePath,
@@ -4262,6 +4900,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             }
         };
     }
+    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;
         rslog_index_js_namespaceObject.logger.debug('modify Rspack config');
@@ -4280,11 +4919,10 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
         })), rslog_index_js_namespaceObject.logger.debug('modify Rspack config done'), modifiedConfig;
     }
     async function getConfigUtils(config, chainUtils) {
-        let { merge } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../compiled/webpack-merge/index.js"));
         return {
             ...chainUtils,
             rspack: core_namespaceObject.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);
@@ -4722,47 +5360,50 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             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({
@@ -4770,10 +5411,13 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     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 = external_node_path_default().isAbsolute(filePath), absolutePath = root && !isAbsolute ? external_node_path_default().join(root, filePath) : filePath, relativePath = root && isAbsolute ? function(base, filepath) {
+                                        let relativePath = (0, external_node_path_namespaceObject.relative)(base, filepath);
+                                        return '' === relativePath ? `.${external_node_path_namespaceObject.sep}` : relativePath.startsWith('.') ? relativePath : `.${external_node_path_namespaceObject.sep}${relativePath}`;
+                                    }(root, filePath) : filePath;
+                                    return `<a class="file-link" data-file="${absolutePath}">${relativePath}</a>${hasClosingSpan ? '</span>' : ''}`;
                                 }));
                             return `
 <style>
@@ -4895,13 +5539,13 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
   </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({
@@ -6756,7 +7400,7 @@ ${section.body}` : section.body).join("\n\n"));
             }), 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', {
@@ -6780,12 +7424,12 @@ ${section.body}` : section.body).join("\n\n"));
                 }
             }(), process.title = 'rsbuild-node';
             let { npm_execpath } = process.env;
-            (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), rslog_index_js_namespaceObject.logger.greet(`  Rsbuild v1.2.16\n`);
+            (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && console.log(), rslog_index_js_namespaceObject.logger.greet(`  Rsbuild v1.2.17\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.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 {
@@ -6836,7 +7480,7 @@ ${section.body}` : section.body).join("\n\n"));
             rslog_index_js_namespaceObject.logger.error('Failed to start Rsbuild CLI.'), rslog_index_js_namespaceObject.logger.error(err);
         }
     }
-    let src_rslib_entry_version = "1.2.16";
+    let src_rslib_entry_version = "1.2.17";
 })();
 var __webpack_export_target__ = exports;
 for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];