@rsbuild/core 1.4.15 → 1.5.0-beta.1

package/dist/index.js

@@ -1,11 +1,17 @@
 /*! For license information please see index.js.LICENSE.txt */
 let swcHelpersPath, pluginHelper_htmlPlugin, cssExtractPlugin, isDockerCached, cachedResult, hmrClientPath, overlayClientPath;
-import { createRequire } from "node:module";
+import { fileURLToPath as __webpack_fileURLToPath__ } from "node:url";
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+import * as __WEBPACK_EXTERNAL_MODULE_fs__ from "fs";
+import * as __WEBPACK_EXTERNAL_MODULE_node_module_ab9f2194__ from "node:module";
+import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
+import * as __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__ from "node:url";
+import * as __WEBPACK_EXTERNAL_MODULE_os__ from "os";
+import * as __WEBPACK_EXTERNAL_MODULE_path__ from "path";
+import * as __WEBPACK_EXTERNAL_MODULE_url__ from "url";
 import { logger } from "../compiled/rslog/index.js";
-import node_path, { dirname, isAbsolute as external_node_path_isAbsolute, join, posix, relative, sep } from "node:path";
-import { URL as external_node_url_URL, fileURLToPath, pathToFileURL } from "node:url";
 import picocolors from "../compiled/picocolors/index.js";
-import node_fs, { constants as external_node_fs_constants, existsSync } from "node:fs";
+import node_fs, { existsSync } from "node:fs";
 import { EventEmitter } from "events";
 import node_os, { constants as external_node_os_constants } from "node:os";
 import node_process from "node:process";
@@ -14,7 +20,7 @@ import { promisify as external_node_util_promisify } from "node:util";
 import node_zlib from "node:zlib";
 import { Buffer as external_node_buffer_Buffer } from "node:buffer";
 import node_child_process, { execFile } from "node:child_process";
-import promises from "node:fs/promises";
+import promises, { constants as promises_constants } from "node:fs/promises";
 var superClass, superClass1, 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");
@@ -541,6 +547,399 @@ var superClass, superClass1, EsmMode, __webpack_modules__ = {
             return type.slice(8, -1).toLowerCase().replace(/\s/g, '');
         };
     },
+    "../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        let path = __webpack_require__("path"), fs = __webpack_require__("fs"), os = __webpack_require__("os"), url = __webpack_require__("url"), fsReadFileAsync = fs.promises.readFile;
+        function parentDir(p) {
+            return path.dirname(p) || path.sep;
+        }
+        let jsonLoader = (_, content)=>JSON.parse(content), requireFunc = __WEBPACK_EXTERNAL_createRequire(import.meta.url), defaultLoadersSync = Object.freeze({
+            '.js': requireFunc,
+            '.json': requireFunc,
+            '.cjs': requireFunc,
+            noExt: jsonLoader
+        });
+        module.exports.defaultLoadersSync = defaultLoadersSync;
+        let dynamicImport = async (id)=>{
+            try {
+                let fileUrl = url.pathToFileURL(id).href;
+                return (await import(fileUrl)).default;
+            } catch (e) {
+                try {
+                    return requireFunc(id);
+                } catch (requireE) {
+                    if ('ERR_REQUIRE_ESM' === requireE.code || requireE instanceof SyntaxError && requireE.toString().includes('Cannot use import statement outside a module')) throw e;
+                    throw requireE;
+                }
+            }
+        }, defaultLoaders = Object.freeze({
+            '.js': dynamicImport,
+            '.mjs': dynamicImport,
+            '.cjs': dynamicImport,
+            '.json': jsonLoader,
+            noExt: jsonLoader
+        });
+        function getOptions(name, options, sync) {
+            let conf = {
+                stopDir: os.homedir(),
+                searchPlaces: [
+                    'package.json',
+                    `.${name}rc.json`,
+                    `.${name}rc.js`,
+                    `.${name}rc.cjs`,
+                    ...sync ? [] : [
+                        `.${name}rc.mjs`
+                    ],
+                    `.config/${name}rc`,
+                    `.config/${name}rc.json`,
+                    `.config/${name}rc.js`,
+                    `.config/${name}rc.cjs`,
+                    ...sync ? [] : [
+                        `.config/${name}rc.mjs`
+                    ],
+                    `${name}.config.js`,
+                    `${name}.config.cjs`,
+                    ...sync ? [] : [
+                        `${name}.config.mjs`
+                    ]
+                ],
+                ignoreEmptySearchPlaces: !0,
+                cache: !0,
+                transform: (x)=>x,
+                packageProp: [
+                    name
+                ],
+                ...options,
+                loaders: {
+                    ...sync ? defaultLoadersSync : defaultLoaders,
+                    ...options.loaders
+                }
+            };
+            return conf.searchPlaces.forEach((place)=>{
+                let key = path.extname(place) || 'noExt', loader = conf.loaders[key];
+                if (!loader) throw Error(`Missing loader for extension "${place}"`);
+                if ('function' != typeof loader) throw Error(`Loader for extension "${place}" is not a function: Received ${typeof loader}.`);
+            }), conf;
+        }
+        function getPackageProp(props, obj) {
+            return 'string' == typeof props && props in obj ? obj[props] : (Array.isArray(props) ? props : props.split('.')).reduce((acc, prop)=>void 0 === acc ? acc : acc[prop], obj) || null;
+        }
+        function validateFilePath(filepath) {
+            if (!filepath) throw Error('load must pass a non-empty string');
+        }
+        function validateLoader(loader, ext) {
+            if (!loader) throw Error(`No loader specified for extension "${ext}"`);
+            if ('function' != typeof loader) throw Error('loader is not a function');
+        }
+        module.exports.defaultLoaders = defaultLoaders;
+        let makeEmplace = (enableCache)=>(c, filepath, res)=>(enableCache && c.set(filepath, res), res);
+        module.exports.lilconfig = function(name, options) {
+            let { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache } = getOptions(name, options ?? {}, !1), searchCache = new Map(), loadCache = new Map(), emplace = makeEmplace(cache);
+            return {
+                async search (searchFrom = process.cwd()) {
+                    let result = {
+                        config: null,
+                        filepath: ''
+                    }, visited = new Set(), dir = searchFrom;
+                    dirLoop: for(;;){
+                        if (cache) {
+                            let r = searchCache.get(dir);
+                            if (void 0 !== r) {
+                                for (let p of visited)searchCache.set(p, r);
+                                return r;
+                            }
+                            visited.add(dir);
+                        }
+                        for (let searchPlace of searchPlaces){
+                            let filepath = path.join(dir, searchPlace);
+                            try {
+                                await fs.promises.access(filepath);
+                            } catch  {
+                                continue;
+                            }
+                            let content = String(await fsReadFileAsync(filepath)), loaderKey = path.extname(searchPlace) || 'noExt', loader = loaders[loaderKey];
+                            if ('package.json' === searchPlace) {
+                                let maybeConfig = getPackageProp(packageProp, await loader(filepath, content));
+                                if (null != maybeConfig) {
+                                    result.config = maybeConfig, result.filepath = filepath;
+                                    break dirLoop;
+                                }
+                                continue;
+                            }
+                            let isEmpty = '' === content.trim();
+                            if (!isEmpty || !ignoreEmptySearchPlaces) {
+                                isEmpty ? (result.isEmpty = !0, result.config = void 0) : (validateLoader(loader, loaderKey), result.config = await loader(filepath, content)), result.filepath = filepath;
+                                break dirLoop;
+                            }
+                        }
+                        if (dir === stopDir || dir === parentDir(dir)) break;
+                        dir = parentDir(dir);
+                    }
+                    let transformed = '' === result.filepath && null === result.config ? transform(null) : transform(result);
+                    if (cache) for (let p of visited)searchCache.set(p, transformed);
+                    return transformed;
+                },
+                async load (filepath) {
+                    validateFilePath(filepath);
+                    let absPath = path.resolve(process.cwd(), filepath);
+                    if (cache && loadCache.has(absPath)) return loadCache.get(absPath);
+                    let { base, ext } = path.parse(absPath), loaderKey = ext || 'noExt', loader = loaders[loaderKey];
+                    validateLoader(loader, loaderKey);
+                    let content = String(await fsReadFileAsync(absPath));
+                    if ('package.json' === base) {
+                        let pkg = await loader(absPath, content);
+                        return emplace(loadCache, absPath, transform({
+                            config: getPackageProp(packageProp, pkg),
+                            filepath: absPath
+                        }));
+                    }
+                    let result = {
+                        config: null,
+                        filepath: absPath
+                    }, isEmpty = '' === content.trim();
+                    return isEmpty && ignoreEmptySearchPlaces ? emplace(loadCache, absPath, transform({
+                        config: void 0,
+                        filepath: absPath,
+                        isEmpty: !0
+                    })) : (result.config = isEmpty ? void 0 : await loader(absPath, content), emplace(loadCache, absPath, transform(isEmpty ? {
+                        ...result,
+                        isEmpty,
+                        config: void 0
+                    } : result)));
+                },
+                clearLoadCache () {
+                    cache && loadCache.clear();
+                },
+                clearSearchCache () {
+                    cache && searchCache.clear();
+                },
+                clearCaches () {
+                    cache && (loadCache.clear(), searchCache.clear());
+                }
+            };
+        }, module.exports.lilconfigSync = function(name, options) {
+            let { ignoreEmptySearchPlaces, loaders, packageProp, searchPlaces, stopDir, transform, cache } = getOptions(name, options ?? {}, !0), searchCache = new Map(), loadCache = new Map(), emplace = makeEmplace(cache);
+            return {
+                search (searchFrom = process.cwd()) {
+                    let result = {
+                        config: null,
+                        filepath: ''
+                    }, visited = new Set(), dir = searchFrom;
+                    dirLoop: for(;;){
+                        if (cache) {
+                            let r = searchCache.get(dir);
+                            if (void 0 !== r) {
+                                for (let p of visited)searchCache.set(p, r);
+                                return r;
+                            }
+                            visited.add(dir);
+                        }
+                        for (let searchPlace of searchPlaces){
+                            let filepath = path.join(dir, searchPlace);
+                            try {
+                                fs.accessSync(filepath);
+                            } catch  {
+                                continue;
+                            }
+                            let loaderKey = path.extname(searchPlace) || 'noExt', loader = loaders[loaderKey], content = String(fs.readFileSync(filepath));
+                            if ('package.json' === searchPlace) {
+                                let maybeConfig = getPackageProp(packageProp, loader(filepath, content));
+                                if (null != maybeConfig) {
+                                    result.config = maybeConfig, result.filepath = filepath;
+                                    break dirLoop;
+                                }
+                                continue;
+                            }
+                            let isEmpty = '' === content.trim();
+                            if (!isEmpty || !ignoreEmptySearchPlaces) {
+                                isEmpty ? (result.isEmpty = !0, result.config = void 0) : (validateLoader(loader, loaderKey), result.config = loader(filepath, content)), result.filepath = filepath;
+                                break dirLoop;
+                            }
+                        }
+                        if (dir === stopDir || dir === parentDir(dir)) break;
+                        dir = parentDir(dir);
+                    }
+                    let transformed = '' === result.filepath && null === result.config ? transform(null) : transform(result);
+                    if (cache) for (let p of visited)searchCache.set(p, transformed);
+                    return transformed;
+                },
+                load (filepath) {
+                    validateFilePath(filepath);
+                    let absPath = path.resolve(process.cwd(), filepath);
+                    if (cache && loadCache.has(absPath)) return loadCache.get(absPath);
+                    let { base, ext } = path.parse(absPath), loaderKey = ext || 'noExt', loader = loaders[loaderKey];
+                    validateLoader(loader, loaderKey);
+                    let content = String(fs.readFileSync(absPath));
+                    if ('package.json' === base) return transform({
+                        config: getPackageProp(packageProp, loader(absPath, content)),
+                        filepath: absPath
+                    });
+                    let result = {
+                        config: null,
+                        filepath: absPath
+                    }, isEmpty = '' === content.trim();
+                    return isEmpty && ignoreEmptySearchPlaces ? emplace(loadCache, absPath, transform({
+                        filepath: absPath,
+                        config: void 0,
+                        isEmpty: !0
+                    })) : (result.config = isEmpty ? void 0 : loader(absPath, content), emplace(loadCache, absPath, transform(isEmpty ? {
+                        ...result,
+                        isEmpty,
+                        config: void 0
+                    } : result)));
+                },
+                clearLoadCache () {
+                    cache && loadCache.clear();
+                },
+                clearSearchCache () {
+                    cache && searchCache.clear();
+                },
+                clearCaches () {
+                    cache && (loadCache.clear(), searchCache.clear());
+                }
+            };
+        };
+    },
+    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        let yaml, { resolve } = __webpack_require__("node:path"), config = __webpack_require__("../../node_modules/.pnpm/lilconfig@3.1.3/node_modules/lilconfig/src/index.js"), loadOptions = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/options.js"), loadPlugins = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/plugins.js"), req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/req.js");
+        async function processResult(ctx, result) {
+            let obj, file = result.filepath || '', projectConfig = ((obj = result.config) && obj.__esModule ? obj : {
+                default: obj
+            }).default || {};
+            (projectConfig = 'function' == typeof projectConfig ? projectConfig(ctx) : Object.assign({}, projectConfig, ctx)).plugins || (projectConfig.plugins = []);
+            let res = {
+                file,
+                options: await loadOptions(projectConfig, file),
+                plugins: await loadPlugins(projectConfig, file)
+            };
+            return delete projectConfig.plugins, res;
+        }
+        async function loader(filepath) {
+            return req(filepath);
+        }
+        async function yamlLoader(_, content) {
+            if (!yaml) try {
+                yaml = await import("yaml");
+            } catch (e) {
+                throw Error(`'yaml' is required for the YAML configuration files. Make sure it is installed\nError: ${e.message}`);
+            }
+            return yaml.parse(content);
+        }
+        module.exports = function(ctx, path, options) {
+            var ctx1;
+            return ctx1 = ctx, (ctx1 = Object.assign({
+                cwd: process.cwd(),
+                env: process.env.NODE_ENV
+            }, ctx1)).env || (process.env.NODE_ENV = 'development'), ctx = ctx1, path = path ? resolve(path) : process.cwd(), config.lilconfig('postcss', ((options = {})=>{
+                let moduleName = 'postcss';
+                return {
+                    ...options,
+                    loaders: {
+                        ...options.loaders,
+                        '.cjs': loader,
+                        '.cts': loader,
+                        '.js': loader,
+                        '.mjs': loader,
+                        '.mts': loader,
+                        '.ts': loader,
+                        '.yaml': yamlLoader,
+                        '.yml': yamlLoader
+                    },
+                    searchPlaces: [
+                        ...options.searchPlaces || [],
+                        'package.json',
+                        `.${moduleName}rc`,
+                        `.${moduleName}rc.json`,
+                        `.${moduleName}rc.yaml`,
+                        `.${moduleName}rc.yml`,
+                        `.${moduleName}rc.ts`,
+                        `.${moduleName}rc.cts`,
+                        `.${moduleName}rc.mts`,
+                        `.${moduleName}rc.js`,
+                        `.${moduleName}rc.cjs`,
+                        `.${moduleName}rc.mjs`,
+                        `${moduleName}.config.ts`,
+                        `${moduleName}.config.cts`,
+                        `${moduleName}.config.mts`,
+                        `${moduleName}.config.js`,
+                        `${moduleName}.config.cjs`,
+                        `${moduleName}.config.mjs`
+                    ]
+                };
+            })(options)).search(path).then((result)=>{
+                if (!result) throw Error(`No PostCSS Config found in: ${path}`);
+                return processResult(ctx, result);
+            });
+        };
+    },
+    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/options.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        let req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/req.js");
+        module.exports = async function(config, file) {
+            if (config.parser && 'string' == typeof config.parser) try {
+                config.parser = await req(config.parser, file);
+            } catch (err) {
+                throw Error(`Loading PostCSS Parser failed: ${err.message}\n\n(@${file})`);
+            }
+            if (config.syntax && 'string' == typeof config.syntax) try {
+                config.syntax = await req(config.syntax, file);
+            } catch (err) {
+                throw Error(`Loading PostCSS Syntax failed: ${err.message}\n\n(@${file})`);
+            }
+            if (config.stringifier && 'string' == typeof config.stringifier) try {
+                config.stringifier = await req(config.stringifier, file);
+            } catch (err) {
+                throw Error(`Loading PostCSS Stringifier failed: ${err.message}\n\n(@${file})`);
+            }
+            return config;
+        };
+    },
+    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/plugins.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        let req = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/req.js");
+        async function load(plugin, options, file) {
+            try {
+                if (null == options || 0 === Object.keys(options).length) return await req(plugin, file);
+                return (await req(plugin, file))(options);
+            } catch (err) {
+                throw Error(`Loading PostCSS Plugin failed: ${err.message}\n\n(@${file})`);
+            }
+        }
+        module.exports = async function(config, file) {
+            let list = [];
+            return Array.isArray(config.plugins) ? list = config.plugins.filter(Boolean) : (list = Object.entries(config.plugins).filter(([, options])=>!1 !== options).map(([plugin, options])=>load(plugin, options, file)), list = await Promise.all(list)), list.length && list.length > 0 && list.forEach((plugin, i)=>{
+                if (plugin.default && (plugin = plugin.default), !0 === plugin.postcss ? plugin = plugin() : plugin.postcss && (plugin = plugin.postcss), !('object' == typeof plugin && Array.isArray(plugin.plugins) || 'object' == typeof plugin && plugin.postcssPlugin || 'function' == typeof plugin)) throw TypeError(`Invalid PostCSS Plugin found at: plugins[${i}]\n\n(@${file})`);
+            }), list;
+        };
+    },
+    "../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/req.js": function(module, __unused_webpack_exports, __webpack_require__) {
+        let tsx, jiti;
+        var __filename = __webpack_fileURLToPath__(import.meta.url);
+        let { createRequire } = __webpack_require__("node:module"), { pathToFileURL } = __webpack_require__("node:url"), TS_EXT_RE = /\.[mc]?ts$/, importError = [];
+        module.exports = async function(name, rootFile = __filename) {
+            let url = createRequire(rootFile).resolve(name);
+            try {
+                return (await import(`${pathToFileURL(url)}?t=${Date.now()}`)).default;
+            } catch (err) {
+                if (!TS_EXT_RE.test(url)) throw err;
+            }
+            if (void 0 === tsx) try {
+                tsx = await import("tsx/cjs/api");
+            } catch (error) {
+                importError.push(error);
+            }
+            if (tsx) {
+                let loaded = tsx.require(name, rootFile);
+                return loaded && '__esModule' in loaded ? loaded.default : loaded;
+            }
+            if (void 0 === jiti) try {
+                jiti = (await import("jiti")).default;
+            } catch (error) {
+                importError.push(error);
+            }
+            if (jiti) return jiti(rootFile, {
+                interopDefault: !0
+            })(name);
+            throw Error(`'tsx' or 'jiti' is required for the TypeScript configuration files. Make sure it is installed\nError: ${importError.map((error)=>error.message).join('\n')}`);
+        };
+    },
     "../../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) {
@@ -1010,6 +1409,27 @@ var superClass, superClass1, EsmMode, __webpack_modules__ = {
             var matcher = new WildcardMatcher(text, separator || /[\/\.]/);
             return void 0 !== test ? matcher.match(test) : matcher;
         };
+    },
+    fs: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_fs__;
+    },
+    "node:module": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_module_ab9f2194__;
+    },
+    "node:path": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__;
+    },
+    "node:url": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_node_url_e96de089__;
+    },
+    os: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_os__;
+    },
+    path: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_path__;
+    },
+    url: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_url__;
     }
 }, __webpack_module_cache__ = {};
 function __webpack_require__(moduleId) {
@@ -1054,8 +1474,9 @@ __webpack_require__.r(provider_helpers_namespaceObject), __webpack_require__.d(p
     setCssExtractPlugin: ()=>setCssExtractPlugin,
     setHTMLPlugin: ()=>setHTMLPlugin
 });
-let rspack_rspack = createRequire(import.meta.url)('@rspack/core');
-var cjs = __webpack_require__("../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js"), cjs_default = __webpack_require__.n(cjs), dist = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/index.js");
+var external_node_module_ = __webpack_require__("node:module");
+let rspack_rspack = (0, external_node_module_.createRequire)(import.meta.url)('@rspack/core');
+var external_node_path_ = __webpack_require__("node:path"), external_node_url_ = __webpack_require__("node:url"), cjs = __webpack_require__("../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js"), cjs_default = __webpack_require__.n(cjs), dist = __webpack_require__("../../node_modules/.pnpm/javascript-stringify@2.1.0/node_modules/javascript-stringify/dist/index.js");
 function createMap(superClass) {
     return class extends superClass {
         extend(methods) {
@@ -1782,11 +2203,12 @@ class src_class extends ChainedMap {
             'recordsOutputPath',
             'name',
             'infrastructureLogging',
-            'snapshot'
+            'snapshot',
+            'lazyCompilation'
         ]);
     }
 }
-let constants_filename = fileURLToPath(import.meta.url), constants_dirname = dirname(constants_filename), ROOT_DIST_DIR = 'dist', LOADER_PATH = join(constants_dirname), STATIC_PATH = join(constants_dirname, '../static'), COMPILED_PATH = join(constants_dirname, '../compiled'), RSBUILD_OUTPUTS_PATH = '.rsbuild', DEFAULT_DEV_HOST = '0.0.0.0', DEFAULT_ASSET_PREFIX = '/', DEFAULT_WEB_BROWSERSLIST = [
+let constants_filename = (0, external_node_url_.fileURLToPath)(import.meta.url), constants_dirname = (0, external_node_path_.dirname)(constants_filename), ROOT_DIST_DIR = 'dist', LOADER_PATH = (0, external_node_path_.join)(constants_dirname), STATIC_PATH = (0, external_node_path_.join)(constants_dirname, '../static'), COMPILED_PATH = (0, external_node_path_.join)(constants_dirname, '../compiled'), RSBUILD_OUTPUTS_PATH = '.rsbuild', DEFAULT_DEV_HOST = '0.0.0.0', DEFAULT_ASSET_PREFIX = '/', DEFAULT_WEB_BROWSERSLIST = [
     'chrome >= 87',
     'edge >= 88',
     'firefox >= 78',
@@ -1832,18 +2254,17 @@ let constants_filename = fileURLToPath(import.meta.url), constants_dirname = dir
     'aac',
     'm4a',
     'opus'
-], getCompiledPath = (packageName)=>join(COMPILED_PATH, packageName, 'index.js'), ensureAbsolutePath = (base, filePath)=>external_node_path_isAbsolute(filePath) ? filePath : join(base, filePath), getPathnameFromUrl = (publicPath)=>{
+], getCompiledPath = (packageName)=>(0, external_node_path_.join)(COMPILED_PATH, packageName, 'index.js'), ensureAbsolutePath = (base, filePath)=>(0, external_node_path_.isAbsolute)(filePath) ? filePath : (0, external_node_path_.join)(base, filePath), getPathnameFromUrl = (publicPath)=>{
     try {
         return publicPath ? new URL(publicPath).pathname : publicPath;
     } catch  {
         return publicPath;
     }
-}, dedupeNestedPaths = (paths)=>paths.sort((p1, p2)=>p2.length > p1.length ? -1 : 1).reduce((prev, curr)=>prev.find((p)=>curr.startsWith(p) || curr === p) ? prev : prev.concat(curr), []), toPosixPath = (filepath)=>'/' === sep ? filepath : filepath.replace(/\\/g, '/'), isFileSync = (filePath)=>{
+}, dedupeNestedPaths = (paths)=>paths.sort((p1, p2)=>p2.length > p1.length ? -1 : 1).reduce((prev, curr)=>prev.find((p)=>curr.startsWith(p) || curr === p) ? prev : prev.concat(curr), []), toPosixPath = (filepath)=>'/' === external_node_path_.sep ? filepath : filepath.replace(/\\/g, '/'), isFileSync = (filePath)=>{
     try {
-        var _fs_statSync;
-        return null == (_fs_statSync = node_fs.statSync(filePath, {
+        return node_fs.statSync(filePath, {
             throwIfNoEntry: !1
-        })) ? void 0 : _fs_statSync.isFile();
+        })?.isFile();
     } catch (_) {
         return !1;
     }
@@ -1861,7 +2282,7 @@ async function fileExistsByCompilation({ inputFileSystem }, filePath) {
     return new Promise((resolve)=>{
         if (!inputFileSystem) return void resolve(!1);
         inputFileSystem.stat(filePath, (err, stats)=>{
-            err ? resolve(!1) : resolve(!!(null == stats ? void 0 : stats.isFile()));
+            err ? resolve(!1) : resolve(!!stats?.isFile());
         });
     });
 }
@@ -1871,7 +2292,7 @@ async function emptyDir(dir, keep = [], checkExists = !0) {
             withFileTypes: !0
         });
         await Promise.all(entries.map(async (entry)=>{
-            let fullPath = node_path.join(dir, entry.name);
+            let fullPath = external_node_path_.default.join(dir, entry.name);
             !keep.some((reg)=>reg.test(toPosixPath(fullPath))) && (entry.isDirectory() ? (await emptyDir(fullPath, keep, !1), keep.length || await node_fs.promises.rmdir(fullPath)) : await node_fs.promises.unlink(fullPath));
         }));
     } catch (err) {
@@ -1997,16 +2418,12 @@ function formatMessage(stats, verbose) {
     }(message))).split('\n').filter((line, index, arr)=>0 === index || '' !== line.trim() || line.trim() !== arr[index - 1].trim()).join('\n')).trim();
 }
 function formatStatsMessages(stats, verbose) {
-    var _stats_errors, _stats_warnings;
     return {
-        errors: (null == (_stats_errors = stats.errors) ? void 0 : _stats_errors.map((error)=>formatMessage(error, verbose))) || [],
-        warnings: (null == (_stats_warnings = stats.warnings) ? void 0 : _stats_warnings.map((warning)=>formatMessage(warning, verbose))) || []
+        errors: stats.errors?.map((error)=>formatMessage(error, verbose)) || [],
+        warnings: stats.warnings?.map((warning)=>formatMessage(warning, verbose)) || []
     };
 }
-let getAllStatsErrors = (statsData)=>{
-    var _statsData_errors, _statsData_children;
-    return statsData.errorsCount && (null == (_statsData_errors = statsData.errors) ? void 0 : _statsData_errors.length) === 0 ? null == (_statsData_children = statsData.children) ? void 0 : _statsData_children.reduce((errors, curr)=>errors.concat(curr.errors || []), []) : statsData.errors;
-}, getAssetsFromStats = (stats)=>stats.toJson({
+let getAllStatsErrors = (statsData)=>statsData.errorsCount && statsData.errors?.length === 0 ? statsData.children?.reduce((errors, curr)=>errors.concat(curr.errors || []), []) : statsData.errors, getAssetsFromStats = (stats)=>stats.toJson({
         all: !1,
         assets: !0,
         cachedAssets: !0,
@@ -2015,10 +2432,7 @@ let getAllStatsErrors = (statsData)=>{
         groupAssetsByChunk: !1,
         groupAssetsByExtension: !1,
         groupAssetsByEmitStatus: !1
-    }).assets || [], getAllStatsWarnings = (statsData)=>{
-    var _statsData_warnings, _statsData_children;
-    return statsData.warningsCount && (null == (_statsData_warnings = statsData.warnings) ? void 0 : _statsData_warnings.length) === 0 ? null == (_statsData_children = statsData.children) ? void 0 : _statsData_children.reduce((warnings, curr)=>warnings.concat(curr.warnings || []), []) : statsData.warnings;
-};
+    }).assets || [], getAllStatsWarnings = (statsData)=>statsData.warningsCount && statsData.warnings?.length === 0 ? statsData.children?.reduce((warnings, curr)=>warnings.concat(curr.warnings || []), []) : statsData.warnings;
 function getStatsOptions(compiler) {
     if (helpers_isMultiCompiler(compiler)) return {
         children: compiler.compilers.map((compiler)=>compiler.options ? compiler.options.stats : void 0)
@@ -2072,33 +2486,36 @@ let rspackMinVersion = '1.2.4', setNodeEnv = (env)=>{
     return 'string' == typeof publicPath ? 'auto' === publicPath ? '' : publicPath.endsWith('/') ? publicPath : `${publicPath}/` : DEFAULT_ASSET_PREFIX;
 }, urlJoin = (base, path)=>{
     let [urlProtocol, baseUrl] = base.split('://');
-    return `${urlProtocol}://${posix.join(baseUrl, path)}`;
+    return `${urlProtocol}://${external_node_path_.posix.join(baseUrl, path)}`;
 }, canParse = (url)=>{
     try {
-        return new external_node_url_URL(url), !0;
+        return new external_node_url_.URL(url), !0;
     } catch  {
         return !1;
     }
-}, ensureAssetPrefix = (url, assetPrefix = DEFAULT_ASSET_PREFIX)=>url.startsWith('//') || canParse(url) || 'auto' === assetPrefix || 'function' == typeof assetPrefix ? url : assetPrefix.startsWith('http') ? urlJoin(assetPrefix, url) : assetPrefix.startsWith('//') ? urlJoin(`https:${assetPrefix}`, url).replace('https:', '') : posix.join(assetPrefix, url);
+}, ensureAssetPrefix = (url, assetPrefix = DEFAULT_ASSET_PREFIX)=>url.startsWith('//') || canParse(url) || 'auto' === assetPrefix || 'function' == typeof assetPrefix ? url : assetPrefix.startsWith('http') ? urlJoin(assetPrefix, url) : assetPrefix.startsWith('//') ? urlJoin(`https:${assetPrefix}`, url).replace('https:', '') : external_node_path_.posix.join(assetPrefix, url);
 function getFilename(config, type, isProd, isServer) {
-    let { filename, filenameHash } = config.output, hash = 'string' == typeof filenameHash ? filenameHash ? `.[${filenameHash}]` : '' : filenameHash ? '.[contenthash:8]' : '';
+    let { filename, filenameHash } = config.output, getHash = (dot = !0)=>'string' == typeof filenameHash ? filenameHash ? `${dot ? '.' : ''}[${filenameHash}]` : '' : filenameHash ? `${dot ? '.' : ''}[contenthash:8]` : '';
     switch(type){
         case 'js':
-            return filename.js ?? `[name]${isProd && !isServer ? hash : ''}.js`;
+            return filename.js ?? `[name]${isProd && !isServer ? getHash() : ''}.js`;
         case 'css':
-            return filename.css ?? `[name]${isProd ? hash : ''}.css`;
+            return filename.css ?? `[name]${isProd ? getHash() : ''}.css`;
         case 'svg':
-            return filename.svg ?? `[name]${hash}.svg`;
+            return filename.svg ?? `[name]${getHash()}.svg`;
         case 'font':
-            return filename.font ?? `[name]${hash}[ext]`;
+            return filename.font ?? `[name]${getHash()}[ext]`;
         case 'image':
-            return filename.image ?? `[name]${hash}[ext]`;
+            return filename.image ?? `[name]${getHash()}[ext]`;
         case 'media':
-            return filename.media ?? `[name]${hash}[ext]`;
+            return filename.media ?? `[name]${getHash()}[ext]`;
         case 'assets':
-            return filename.assets ?? `[name]${hash}[ext]`;
+            return filename.assets ?? `[name]${getHash()}[ext]`;
         case 'wasm':
-            return filename.wasm ?? '[hash].module.wasm';
+            return filename.wasm ?? `${getHash(!1)}.module.wasm`;
+        case 'html':
+            if (filename.html) return filename.html;
+            return 'flat' === config.html.outputStructure ? '[name].html' : '[name]/index.html';
         default:
             throw Error(`${picocolors.dim('[rsbuild:config]')} unknown key ${picocolors.yellow(type)} in ${picocolors.yellow('output.filename')}`);
     }
@@ -2536,13 +2953,13 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
         for(let index = 0; index < compilers.length; index++){
             let compiler = compilers[index], compilerDone = !1;
             (isWatch ? compiler.hooks.watchRun : compiler.hooks.run).tapPromise(name, async ()=>{
-                !compilerDone && (compilerDone = !0, doneCompilers++), waitBeforeCompileDone || (waitBeforeCompileDone = null == beforeCompile ? void 0 : beforeCompile()), await waitBeforeCompileDone, await beforeEnvironmentCompiler(index);
+                !compilerDone && (compilerDone = !0, doneCompilers++), waitBeforeCompileDone || (waitBeforeCompileDone = beforeCompile?.()), await waitBeforeCompileDone, await beforeEnvironmentCompiler(index);
             }), compiler.hooks.invalid.tap(name, ()=>{
                 compilerDone && (compilerDone = !1, doneCompilers--), doneCompilers <= 0 && (waitBeforeCompileDone = void 0);
             });
         }
     } else (isWatch ? compiler.hooks.watchRun : compiler.hooks.run).tapPromise(name, async ()=>{
-        await (null == beforeCompile ? void 0 : beforeCompile()), await beforeEnvironmentCompiler(0);
+        await beforeCompile?.(), await beforeEnvironmentCompiler(0);
     });
 }, onCompileDone = ({ compiler, onDone, onEnvironmentDone, MultiStatsCtor })=>{
     if (helpers_isMultiCompiler(compiler)) {
@@ -2594,7 +3011,7 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
                 environment: environmentList[buildIndex].name,
                 args: [
                     {
-                        bundlerConfig: null == bundlerConfigs ? void 0 : bundlerConfigs[buildIndex],
+                        bundlerConfig: bundlerConfigs?.[buildIndex],
                         environment: environmentList[buildIndex],
                         isWatch,
                         isFirstCompile
@@ -2635,13 +3052,19 @@ let onBeforeCompile = ({ compiler, beforeCompile, beforeEnvironmentCompiler, isW
                 environment: environmentList[buildIndex].name,
                 args: [
                     {
-                        bundlerConfig: null == bundlerConfigs ? void 0 : bundlerConfigs[buildIndex],
+                        bundlerConfig: bundlerConfigs?.[buildIndex],
                         environment: environmentList[buildIndex],
                         isWatch: !0,
                         isFirstCompile
                     }
                 ]
             }),
+        beforeCompile: async ()=>context.hooks.onBeforeDevCompile.callBatch({
+                bundlerConfigs,
+                environments: context.environments,
+                isFirstCompile,
+                isWatch: !0
+            }),
         isWatch: !0
     }), onCompileDone({
         compiler,
@@ -2700,7 +3123,7 @@ function parseConfig(string) {
     }), result;
 }
 function parsePackageOrReadConfig(file) {
-    if ('package.json' === node_path.basename(file)) return parsePackage(file);
+    if ('package.json' === external_node_path_.default.basename(file)) return parsePackage(file);
     if (!isFile(file)) throw new BrowserslistError(`Can't read ${file} config`);
     return parseConfig(node_fs.readFileSync(file, 'utf-8'));
 }
@@ -2708,11 +3131,11 @@ function pickEnv(config, opts) {
     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) ? node_path.dirname(file) : file, loc = node_path.resolve(dir);
+    let dir = isFile(file) ? external_node_path_.default.dirname(file) : file, loc = external_node_path_.default.resolve(dir);
     do {
         let result = callback(loc);
         if (void 0 !== result) return result;
-    }while (loc !== (loc = node_path.dirname(loc)));
+    }while (loc !== (loc = external_node_path_.default.dirname(loc)));
 }
 let configCache = {}, OVERRIDE_PATHS = [
     'performance.removeConsole',
@@ -2758,7 +3181,7 @@ let configCache = {}, OVERRIDE_PATHS = [
         merged[key] = merge(x[key], y[key], childPath);
     }
     return merged;
-}, mergeRsbuildConfig = (...configs)=>2 === configs.length ? merge(configs[0], configs[1]) : configs.length < 2 ? configs[0] : configs.reduce((result, config)=>merge(result, config), {}), defaultConfig_require = createRequire(import.meta.url), defaultAllowedOrigins = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/, createDefaultConfig = ()=>({
+}, mergeRsbuildConfig = (...configs)=>2 === configs.length ? merge(configs[0], configs[1]) : configs.length < 2 ? configs[0] : configs.reduce((result, config)=>merge(result, config), {}), defaultConfig_require = (0, external_node_module_.createRequire)(import.meta.url), defaultAllowedOrigins = /^https?:\/\/(?:(?:[^:]+\.)?localhost|127\.0\.0\.1|\[::1\])(?::\d+)?$/, createDefaultConfig = ()=>({
         dev: {
             hmr: !0,
             liveReload: !0,
@@ -2802,7 +3225,7 @@ let configCache = {}, OVERRIDE_PATHS = [
             outputStructure: 'flat',
             scriptLoading: 'defer'
         },
-        resolve: (swcHelpersPath || (swcHelpersPath = dirname(defaultConfig_require.resolve('@swc/helpers/package.json'))), {
+        resolve: (swcHelpersPath || (swcHelpersPath = (0, external_node_path_.dirname)(defaultConfig_require.resolve('@swc/helpers/package.json'))), {
             alias: {
                 '@swc/helpers': swcHelpersPath
             },
@@ -2852,6 +3275,7 @@ let configCache = {}, OVERRIDE_PATHS = [
             legalComments: 'linked',
             injectStyles: !1,
             minify: !0,
+            module: !1,
             manifest: !1,
             sourceMap: {
                 js: void 0,
@@ -2893,10 +3317,12 @@ let configCache = {}, OVERRIDE_PATHS = [
         },
         environments: {}
     }), withDefaultConfig = async (rootPath, config)=>{
-    var _merged_server, _config_dev, _config_output;
     let merged = mergeRsbuildConfig(createDefaultConfig(), config);
-    if (merged.root ||= rootPath, merged.source ||= {}, (null == (_merged_server = merged.server) ? void 0 : _merged_server.base) && ((null == (_config_dev = config.dev) ? void 0 : _config_dev.assetPrefix) === void 0 && (merged.dev ||= {}, merged.dev.assetPrefix = merged.server.base), (null == (_config_output = config.output) ? void 0 : _config_output.assetPrefix) === void 0 && (merged.output ||= {}, merged.output.assetPrefix = merged.server.base)), !merged.source.tsconfigPath) {
-        let tsconfigPath = join(rootPath, 'tsconfig.json');
+    if (merged.root ||= rootPath, merged.source ||= {}, merged.server?.base && (config.dev?.assetPrefix === void 0 && (merged.dev ||= {}, merged.dev.assetPrefix = merged.server.base), config.output?.assetPrefix === void 0 && (merged.output ||= {}, merged.output.assetPrefix = merged.server.base)), merged.dev?.lazyCompilation === void 0 && (merged.dev ||= {}, merged.dev.lazyCompilation = {
+        imports: !0,
+        entries: !1
+    }), !merged.source.tsconfigPath) {
+        let tsconfigPath = (0, external_node_path_.join)(rootPath, 'tsconfig.json');
         await isFileExists(tsconfigPath) && (merged.source.tsconfigPath = tsconfigPath);
     }
     return merged;
@@ -2976,9 +3402,8 @@ async function initPlugins({ context, pluginManager }) {
     for (let { environment, instance } of plugins)if (instance.remove) if (environment) for (let item of (removedEnvPlugins[environment] ??= new Set(), instance.remove))removedEnvPlugins[environment].add(item);
     else for (let item of instance.remove)removedPlugins.add(item);
     for (let { instance, environment } of plugins){
-        var _removedEnvPlugins_environment;
         let { name, setup } = instance;
-        if (!(removedPlugins.has(name) || environment && (null == (_removedEnvPlugins_environment = removedEnvPlugins[environment]) ? void 0 : _removedEnvPlugins_environment.has(name)))) {
+        if (!(removedPlugins.has(name) || environment && removedEnvPlugins[environment]?.has(name))) {
             if (instance.apply && context.action) if (isFunction(instance.apply)) {
                 if (!instance.apply(context.originalConfig, {
                     action: context.action
@@ -3037,14 +3462,13 @@ let mapProcessAssetsStage = (compiler, stage)=>{
 }, browsersListCache = new Map(), getEnvironmentHTMLPaths = (entry, config)=>'web' !== config.output.target || !1 === config.tools.htmlPlugin ? {} : Object.keys(entry).reduce((prev, key)=>{
         let entryValue = entry[key];
         return ('string' == typeof entryValue || Array.isArray(entryValue) || !1 !== entryValue.html) && (prev[key] = function(entryName, config) {
-            let filename;
-            filename = config.output.filename.html ? config.output.filename.html.replace('[name]', entryName) : 'flat' === config.html.outputStructure ? `${entryName}.html` : `${entryName}/index.html`;
-            let prefix = config.output.distPath.html;
-            return prefix.startsWith('/') && logger.warn(`${picocolors.dim('[rsbuild:config]')} Absolute path is not recommended at ${picocolors.yellow(`output.distPath.html: "${prefix}"`)}, use relative path instead.`), removeLeadingSlash(posix.join(prefix, filename));
+            let filename = getFilename(config, 'html').replace('[name]', entryName), prefix = config.output.distPath.html;
+            return prefix.startsWith('/') && logger.warn(`${picocolors.dim('[rsbuild:config]')} Absolute path is not recommended at ${picocolors.yellow(`output.distPath.html: "${prefix}"`)}, use relative path instead.`), removeLeadingSlash(external_node_path_.posix.join(prefix, filename));
         }(key, config)), prev;
     }, {});
 async function updateEnvironmentContext(context, configs) {
     for (let [index, [name, config]] of (context.environments ||= {}, Object.entries(configs).entries())){
+        var cwd;
         let browserslist = function(path, config) {
             let { target, overrideBrowserslist } = config.output;
             if (Array.isArray(overrideBrowserslist)) return overrideBrowserslist;
@@ -3056,10 +3480,10 @@ async function updateEnvironmentContext(context, configs) {
                         if (opts.config) return pickEnv(parsePackageOrReadConfig(opts.config), opts);
                         if (opts.path) {
                             let config = function(from) {
-                                let resolved, fromDir = isFile(from = node_path.resolve(from)) ? node_path.dirname(from) : from;
+                                let resolved, fromDir = isFile(from = external_node_path_.default.resolve(from)) ? external_node_path_.default.dirname(from) : from;
                                 if (fromDir in configCache) return configCache[fromDir];
                                 let configFile = eachParent(from, (dir)=>{
-                                    let pkgBrowserslist, config = node_path.join(dir, 'browserslist'), pkg = node_path.join(dir, 'package.json'), rc = node_path.join(dir, '.browserslistrc');
+                                    let pkgBrowserslist, config = external_node_path_.default.join(dir, 'browserslist'), pkg = external_node_path_.default.join(dir, 'package.json'), rc = external_node_path_.default.join(dir, '.browserslistrc');
                                     if (isFile(pkg)) try {
                                         pkgBrowserslist = parsePackage(pkg);
                                     } catch (e) {
@@ -3072,7 +3496,7 @@ async function updateEnvironmentContext(context, configs) {
                                     return isFile(config) ? config : isFile(rc) ? rc : pkgBrowserslist ? pkg : void 0;
                                 });
                                 configFile && (resolved = parsePackageOrReadConfig(configFile));
-                                let configDir = configFile && node_path.dirname(configFile);
+                                let configDir = configFile && external_node_path_.default.dirname(configFile);
                                 return eachParent(from, (dir)=>{
                                     if (resolved && (configCache[dir] = resolved), dir === configDir) return null;
                                 }), resolved;
@@ -3092,10 +3516,7 @@ async function updateEnvironmentContext(context, configs) {
         }(context.rootPath, config), { entry = {}, tsconfigPath } = config.source, htmlPaths = getEnvironmentHTMLPaths(entry, config), webSocketToken = 'dev' === context.action ? await helpers_hash(context.rootPath + name) : '', environmentContext = {
             index,
             name,
-            distPath: function(cwd, config) {
-                var _config_output_distPath, _config_output;
-                return ensureAbsolutePath(cwd, (null == (_config_output = config.output) || null == (_config_output_distPath = _config_output.distPath) ? void 0 : _config_output_distPath.root) ?? ROOT_DIST_DIR);
-            }(context.rootPath, config),
+            distPath: (cwd = context.rootPath, ensureAbsolutePath(cwd, config.output?.distPath?.root ?? ROOT_DIST_DIR)),
             entry,
             browserslist,
             htmlPaths,
@@ -3110,9 +3531,9 @@ async function updateEnvironmentContext(context, configs) {
     }
 }
 async function createContext(options, userConfig) {
-    let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = join(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0, bundlerType = userConfig.provider ? 'webpack' : 'rspack';
+    let { cwd } = options, rootPath = userConfig.root ? ensureAbsolutePath(cwd, userConfig.root) : cwd, rsbuildConfig = await withDefaultConfig(rootPath, userConfig), cachePath = (0, external_node_path_.join)(rootPath, 'node_modules', '.cache'), specifiedEnvironments = options.environment && options.environment.length > 0 ? options.environment : void 0, bundlerType = userConfig.provider ? 'webpack' : 'rspack';
     return {
-        version: "1.4.15",
+        version: "1.5.0-beta.1",
         rootPath,
         distPath: '',
         cachePath,
@@ -3124,6 +3545,7 @@ async function createContext(options, userConfig) {
             onCloseBuild: createAsyncHook(),
             onAfterBuild: createAsyncHook(),
             onBeforeBuild: createAsyncHook(),
+            onBeforeDevCompile: createAsyncHook(),
             onDevCompileDone: createAsyncHook(),
             onCloseDevServer: createAsyncHook(),
             onAfterStartDevServer: createAsyncHook(),
@@ -3159,17 +3581,21 @@ let normalizePluginObject = (plugin)=>{
 };
 async function outputInspectConfigFiles({ rawBundlerConfigs, rawEnvironmentConfigs, inspectOptions, rawExtraConfigs, configType }) {
     let { outputPath } = inspectOptions, files = [
-        ...rawEnvironmentConfigs.map(({ name, content })=>1 === rawEnvironmentConfigs.length ? {
-                path: join(outputPath, 'rsbuild.config.mjs'),
+        ...rawEnvironmentConfigs.map(({ name, content })=>{
+            if (1 === rawEnvironmentConfigs.length) return {
+                path: (0, external_node_path_.join)(outputPath, 'rsbuild.config.mjs'),
                 label: 'Rsbuild config',
                 content
-            } : {
-                path: join(outputPath, `rsbuild.config.${name}.mjs`),
+            };
+            let outputFile = `rsbuild.config.${name}.mjs`;
+            return {
+                path: (0, external_node_path_.join)(outputPath, outputFile),
                 label: `Rsbuild config (${name})`,
                 content
-            }),
+            };
+        }),
         ...rawBundlerConfigs.map(({ name, content })=>{
-            let outputFilePath = join(outputPath, `${configType}.config.${name}.mjs`);
+            let outputFile = `${configType}.config.${name}.mjs`, outputFilePath = (0, external_node_path_.join)(outputPath, outputFile);
             return node_fs.existsSync(outputFilePath) && (outputFilePath = outputFilePath.replace(/\.mjs$/, `.${Date.now()}.mjs`)), {
                 path: outputFilePath,
                 label: `${upperFirst(configType)} Config (${name})`,
@@ -3177,7 +3603,7 @@ async function outputInspectConfigFiles({ rawBundlerConfigs, rawEnvironmentConfi
             };
         }),
         ...(rawExtraConfigs || []).map(({ name, content })=>({
-                path: join(outputPath, `${name}.config.mjs`),
+                path: (0, external_node_path_.join)(outputPath, `${name}.config.mjs`),
                 label: `${upperFirst(name)} Config`,
                 content
             }))
@@ -3226,7 +3652,7 @@ async function inspectConfig({ context, pluginManager, bundlerConfigs, inspectOp
         normalizedConfig: context.normalizedConfig,
         inspectOptions,
         pluginManager
-    }), outputPath = (context1 = context, (inspectOptions1 = inspectOptions).outputPath ? external_node_path_isAbsolute(inspectOptions1.outputPath) ? inspectOptions1.outputPath : join(context1.distPath, inspectOptions1.outputPath) : join(context1.distPath, RSBUILD_OUTPUTS_PATH)), rawExtraConfigs = inspectOptions.extraConfigs ? Object.entries(inspectOptions.extraConfigs).map(([name, content])=>({
+    }), outputPath = (context1 = context, (inspectOptions1 = inspectOptions).outputPath ? (0, external_node_path_.isAbsolute)(inspectOptions1.outputPath) ? inspectOptions1.outputPath : (0, external_node_path_.join)(context1.distPath, inspectOptions1.outputPath) : (0, external_node_path_.join)(context1.distPath, RSBUILD_OUTPUTS_PATH)), rawExtraConfigs = inspectOptions.extraConfigs ? Object.entries(inspectOptions.extraConfigs).map(([name, content])=>({
             name,
             content: 'string' == typeof content ? content : stringifyConfig(content, inspectOptions.verbose)
         })) : void 0;
@@ -3287,7 +3713,6 @@ function reduceConfigsMergeContext({ initial, config, ctx, mergeFn = Object.assi
 }
 var webpack_merge_dist = __webpack_require__("../../node_modules/.pnpm/webpack-merge@6.0.1/node_modules/webpack-merge/dist/index.js");
 async function modifyBundlerChain(context, utils) {
-    var _utils_environment_config_tools;
     logger.debug('modify bundler chain');
     let bundlerChain = new src_class(), [modifiedBundlerChain] = await context.hooks.modifyBundlerChain.callChain({
         environment: utils.environment.name,
@@ -3296,7 +3721,7 @@ async function modifyBundlerChain(context, utils) {
             utils
         ]
     });
-    if (null == (_utils_environment_config_tools = utils.environment.config.tools) ? void 0 : _utils_environment_config_tools.bundlerChain) for (let item of helpers_castArray(utils.environment.config.tools.bundlerChain))await item(modifiedBundlerChain, utils);
+    if (utils.environment.config.tools?.bundlerChain) for (let item of helpers_castArray(utils.environment.config.tools.bundlerChain))await item(modifiedBundlerChain, utils);
     return logger.debug('modify bundler chain done'), modifiedBundlerChain;
 }
 let configChain_CHAIN_ID = {
@@ -3381,13 +3806,12 @@ let configChain_CHAIN_ID = {
     RESOLVE_PLUGIN: {
         TS_CONFIG_PATHS: 'ts-config-paths'
     }
-}, pluginHelper_require = createRequire(import.meta.url), setHTMLPlugin = (plugin)=>{
+}, pluginHelper_require = (0, external_node_module_.createRequire)(import.meta.url), setHTMLPlugin = (plugin)=>{
     plugin && (pluginHelper_htmlPlugin = plugin);
 }, getHTMLPlugin = ()=>(pluginHelper_htmlPlugin || (pluginHelper_htmlPlugin = pluginHelper_require('../compiled/html-rspack-plugin/index.js')), pluginHelper_htmlPlugin), setCssExtractPlugin = (plugin)=>{
     cssExtractPlugin = plugin;
 };
 async function modifyRspackConfig(context, rspackConfig, chainUtils) {
-    var _utils_environment_config_tools;
     logger.debug('modify Rspack config');
     let currentConfig = rspackConfig, utils = getConfigUtils(()=>currentConfig, chainUtils);
     if ([currentConfig] = await context.hooks.modifyRspackConfig.callChain({
@@ -3399,7 +3823,7 @@ async function modifyRspackConfig(context, rspackConfig, chainUtils) {
         afterEach: ([config])=>{
             currentConfig = config;
         }
-    }), null == (_utils_environment_config_tools = utils.environment.config.tools) ? void 0 : _utils_environment_config_tools.rspack) {
+    }), utils.environment.config.tools?.rspack) {
         let toolsRspackConfig = utils.environment.config.tools.rspack;
         currentConfig = await reduceConfigsAsyncWithContext({
             initial: currentConfig,
@@ -3481,12 +3905,11 @@ let allowedEnvironmentDevKeys = [
     'lazyCompilation'
 ];
 async function modifyRsbuildConfig(context) {
-    var _context_config_plugins, _modified_plugins;
     logger.debug('modify Rsbuild config');
-    let pluginsCount = (null == (_context_config_plugins = context.config.plugins) ? void 0 : _context_config_plugins.length) ?? 0, [modified] = await context.hooks.modifyRsbuildConfig.callChain(context.config, {
+    let pluginsCount = context.config.plugins?.length ?? 0, [modified] = await context.hooks.modifyRsbuildConfig.callChain(context.config, {
         mergeRsbuildConfig: mergeRsbuildConfig
     });
-    context.config = modified, ((null == (_modified_plugins = modified.plugins) ? void 0 : _modified_plugins.length) ?? 0) !== pluginsCount && logger.warn(`${picocolors.dim('[rsbuild]')} Cannot change plugins via ${picocolors.yellow('modifyRsbuildConfig')} as plugins are already initialized when it executes.`), logger.debug('modify Rsbuild config done');
+    context.config = modified, (modified.plugins?.length ?? 0) !== pluginsCount && logger.warn(`${picocolors.dim('[rsbuild]')} Cannot change plugins via ${picocolors.yellow('modifyRsbuildConfig')} as plugins are already initialized when it executes.`), logger.debug('modify Rsbuild config done');
 }
 async function modifyEnvironmentConfig(context, config, name) {
     logger.debug(`modify Rsbuild environment(${name}) config`);
@@ -3536,7 +3959,7 @@ async function initRsbuildConfig({ context, pluginManager }) {
                     'cts',
                     'mjs',
                     'cjs'
-                ].map((ext)=>join(root, `src/index.${ext}`)));
+                ].map((ext)=>(0, external_node_path_.join)(root, `src/index.${ext}`)));
                 return entryFile ? {
                     index: entryFile
                 } : {};
@@ -3594,13 +4017,13 @@ async function initRsbuildConfig({ context, pluginManager }) {
             ...new Set(paths)
         ];
         if (1 === uniquePaths.length) return uniquePaths[0];
-        let [first, ...rest] = uniquePaths.map((p)=>p.split(sep)), common = [];
+        let [first, ...rest] = uniquePaths.map((p)=>p.split(external_node_path_.sep)), common = [];
         for(let i = 0; i < first.length; i++){
             let segment = first[i];
             if (rest.every((p)=>p[i] === segment)) common.push(segment);
             else break;
         }
-        return common.join(sep);
+        return common.join(external_node_path_.sep);
     }(distPaths), ((config)=>{
         if (config.server.base && !config.server.base.startsWith('/')) throw Error(`${picocolors.dim('[rsbuild:config]')} The ${picocolors.yellow('"server.base"')} option should start with a slash, for example: "/base"`);
         if (!config.environments) return;
@@ -3647,7 +4070,7 @@ async function initConfigs({ context, pluginManager, rsbuildOptions }) {
     };
 }
 function isLikelyFile(filePath) {
-    return (filePath.split(sep).pop() || '').includes('.');
+    return (filePath.split(external_node_path_.sep).pop() || '').includes('.');
 }
 function formatFileList(paths, rootPath) {
     let files = paths.filter(isLikelyFile);
@@ -3655,10 +4078,10 @@ function formatFileList(paths, rootPath) {
         paths[0]
     ]);
     let fileInfo = files.slice(0, 1).map((file)=>(function(originalFilePath, root) {
-            let prefix = root.endsWith(sep) ? root : root + sep, filePath = originalFilePath;
+            let prefix = root.endsWith(external_node_path_.sep) ? root : root + external_node_path_.sep, filePath = originalFilePath;
             filePath.startsWith(prefix) && (filePath = filePath.slice(prefix.length));
-            let parts = filePath.split(sep).filter(Boolean);
-            return parts.length > 3 ? parts.slice(-3).join(sep) : parts.join(sep);
+            let parts = filePath.split(external_node_path_.sep).filter(Boolean);
+            return parts.length > 3 ? parts.slice(-3).join(external_node_path_.sep) : parts.join(external_node_path_.sep);
         })(file, rootPath)).join(', ');
     return files.length > 1 ? `${fileInfo} and ${files.length - 1} more` : fileInfo;
 }
@@ -3684,13 +4107,13 @@ async function createCompiler_createCompiler(options) {
     return compiler.hooks.watchRun.tap('rsbuild:compiling', (compiler)=>{
         logRspackVersion(), isCompiling || function(compiler, context) {
             let changedFiles = compiler.modifiedFiles ? Array.from(compiler.modifiedFiles) : null;
-            if (null == changedFiles ? void 0 : changedFiles.length) {
+            if (changedFiles?.length) {
                 let fileInfo = formatFileList(changedFiles, context.rootPath);
                 logger.start(`building ${picocolors.dim(fileInfo)}`);
                 return;
             }
             let removedFiles = compiler.removedFiles ? Array.from(compiler.removedFiles) : null;
-            if (null == removedFiles ? void 0 : removedFiles.length) {
+            if (removedFiles?.length) {
                 let fileInfo = formatFileList(removedFiles, context.rootPath);
                 logger.start(`building ${picocolors.dim(`removed ${fileInfo}`)}`);
                 return;
@@ -3713,12 +4136,9 @@ async function createCompiler_createCompiler(options) {
                     logger.ready(`built in ${time}${suffix}`);
                 }
             }, hasErrors = stats.hasErrors();
-            if (!hasErrors) {
-                var _statsJson_children;
-                isMultiCompiler && (null == (_statsJson_children = statsJson.children) ? void 0 : _statsJson_children.length) ? statsJson.children.forEach((c, index)=>{
-                    printTime(c, index);
-                }) : printTime(statsJson, 0);
-            }
+            hasErrors || (isMultiCompiler && statsJson.children?.length ? statsJson.children.forEach((c, index)=>{
+                printTime(c, index);
+            }) : printTime(statsJson, 0));
             let { message, level } = formatStats(statsJson, hasErrors);
             'error' === level && logger.error(message), 'warning' === level && logger.warn(message), isCompiling = !1;
         })(stats);
@@ -3763,7 +4183,7 @@ let RSPACK_BUILD_ERROR = 'Rspack build failed.', build_build = async (initOption
     let { stats } = await new Promise((resolve, reject)=>{
         compiler.run((err, stats)=>{
             compiler.close((closeErr)=>{
-                closeErr && logger.error('Failed to close compiler: ', closeErr), err ? reject(err) : (null == stats ? void 0 : stats.hasErrors()) ? reject(Error(RSPACK_BUILD_ERROR)) : resolve({
+                closeErr && logger.error('Failed to close compiler: ', closeErr), err ? reject(err) : stats?.hasErrors() ? reject(Error(RSPACK_BUILD_ERROR)) : resolve({
                     stats
                 });
             });
@@ -3785,7 +4205,7 @@ function loadEnv({ cwd = process.cwd(), mode = process.env.NODE_ENV || '', prefi
         '.env.local',
         `.env.${mode}`,
         `.env.${mode}.local`
-    ].map((filename)=>join(cwd, filename)).filter(isFileSync), parsed = {};
+    ].map((filename)=>(0, external_node_path_.join)(cwd, filename)).filter(isFileSync), parsed = {};
     for (let envPath of filePaths)Object.assign(parsed, function(src) {
         let match, obj = {}, lines = src.toString();
         for(lines = lines.replace(/\r\n?/gm, '\n'); null != (match = DOTENV_LINE.exec(lines));){
@@ -3826,12 +4246,9 @@ let chainStaticAssetRule = ({ emit, rule, maxSize, filename, assetType })=>{
             maxSize
         }
     }).set('generator', generatorOptions);
-}, isUseAnalyzer = (config)=>{
-    var _config_performance;
-    return process.env.BUNDLE_ANALYZE || (null == (_config_performance = config.performance) ? void 0 : _config_performance.bundleAnalyze);
-};
+}, isUseAnalyzer = (config)=>process.env.BUNDLE_ANALYZE || config.performance?.bundleAnalyze;
 async function validateWebpackCache(cacheDirectory, buildDependencies) {
-    let configFile = join(cacheDirectory, 'buildDependencies.json');
+    let configFile = (0, external_node_path_.join)(cacheDirectory, 'buildDependencies.json');
     if (await isFileExists(configFile)) {
         let rawConfigFile = await node_fs.promises.readFile(configFile, 'utf-8'), prevBuildDependencies = null;
         try {
@@ -3850,15 +4267,14 @@ async function validateWebpackCache(cacheDirectory, buildDependencies) {
     }), await node_fs.promises.writeFile(configFile, JSON.stringify(buildDependencies));
 }
 async function getBuildDependencies(context, config, environmentContext, userBuildDependencies) {
-    var _config__privateMeta;
-    let rootPackageJson = join(context.rootPath, 'package.json'), browserslistConfig = join(context.rootPath, '.browserslistrc'), buildDependencies = {};
+    let rootPackageJson = (0, external_node_path_.join)(context.rootPath, 'package.json'), browserslistConfig = (0, external_node_path_.join)(context.rootPath, '.browserslistrc'), buildDependencies = {};
     await isFileExists(rootPackageJson) && (buildDependencies.packageJson = [
         rootPackageJson
     ]);
     let { tsconfigPath } = environmentContext;
     tsconfigPath && (buildDependencies.tsconfig = [
         tsconfigPath
-    ]), (null == (_config__privateMeta = config._privateMeta) ? void 0 : _config__privateMeta.configFilePath) && (buildDependencies.rsbuildConfig = [
+    ]), config._privateMeta?.configFilePath && (buildDependencies.rsbuildConfig = [
         config._privateMeta.configFilePath
     ]), await isFileExists(browserslistConfig) && (buildDependencies.browserslistrc = [
         browserslistConfig
@@ -3868,7 +4284,7 @@ async function getBuildDependencies(context, config, environmentContext, userBui
         'js',
         'cjs',
         'mjs'
-    ].map((ext)=>join(context.rootPath, `tailwind.config.${ext}`)));
+    ].map((ext)=>(0, external_node_path_.join)(context.rootPath, `tailwind.config.${ext}`)));
     return tailwindConfig && (buildDependencies.tailwindcss = [
         tailwindConfig
     ]), {
@@ -3876,7 +4292,7 @@ async function getBuildDependencies(context, config, environmentContext, userBui
         ...userBuildDependencies
     };
 }
-let addTrailingSep = (dir)=>dir.endsWith(sep) ? dir : dir + sep, isStrictSubdir = (parent, child)=>{
+let addTrailingSep = (dir)=>dir.endsWith(external_node_path_.sep) ? dir : dir + external_node_path_.sep, isStrictSubdir = (parent, child)=>{
     let parentDir = addTrailingSep(parent), childDir = addTrailingSep(child);
     return parentDir !== childDir && childDir.startsWith(parentDir);
 }, normalizeCleanDistPath = (userOptions)=>{
@@ -3890,7 +4306,9 @@ let addTrailingSep = (dir)=>dir.endsWith(sep) ? dir : dir + sep, isStrictSubdir
         ...defaultOptions,
         ...userOptions
     };
-}, parseMinifyOptions = (config)=>{
+};
+var postcss_load_config_src = __webpack_require__("../../node_modules/.pnpm/postcss-load-config@6.0.1_jiti@2.5.1_postcss@8.5.6_yaml@2.8.0/node_modules/postcss-load-config/src/index.js"), src_default = __webpack_require__.n(postcss_load_config_src);
+let parseMinifyOptions = (config)=>{
     let isProd = 'production' === config.mode, { minify } = config.output;
     if ('boolean' == typeof minify) {
         let shouldMinify = minify && isProd;
@@ -3926,9 +4344,8 @@ let addTrailingSep = (dir)=>dir.endsWith(sep) ? dir : dir + sep, isStrictSubdir
 async function loadUserPostcssrc(root, postcssrcCache) {
     let cached = postcssrcCache.get(root);
     if (cached) return clonePostCSSConfig(await cached);
-    let { default: postcssrc } = await import("../compiled/postcss-load-config/index.js"), promise = postcssrc({}, root).catch((err)=>{
-        var _err_message;
-        if (null == (_err_message = err.message) ? void 0 : _err_message.includes('No PostCSS Config found')) return {};
+    let promise = src_default()({}, root).catch((err)=>{
+        if (err.message?.includes('No PostCSS Config found')) return {};
         throw err;
     });
     return postcssrcCache.set(root, promise), promise.then((config)=>(postcssrcCache.set(root, config), clonePostCSSConfig(config)));
@@ -3983,11 +4400,11 @@ async function printFileSizes(options, stats, rootPath, environmentName) {
     let logs = [], showTotal = !1 !== options.total, showDetail = !1 !== options.detail, exclude = options.exclude ?? excludeAsset;
     if (!showTotal && !showDetail) return logs;
     let formatAsset = async (asset, distPath, distFolder)=>{
-        let fileName = asset.name.split('?')[0], contents = await node_fs.promises.readFile(node_path.join(distPath, fileName)), size = Buffer.byteLength(contents), gzippedSize = options.compressed && COMPRESSIBLE_REGEX.test(fileName) ? await gzipSize(contents) : null, gzipSizeLabel = gzippedSize ? getAssetColor(gzippedSize)(calcFileSize(gzippedSize)) : null;
+        let fileName = asset.name.split('?')[0], contents = await node_fs.promises.readFile(external_node_path_.default.join(distPath, fileName)), size = Buffer.byteLength(contents), gzippedSize = options.compressed && COMPRESSIBLE_REGEX.test(fileName) ? await gzipSize(contents) : null, gzipSizeLabel = gzippedSize ? getAssetColor(gzippedSize)(calcFileSize(gzippedSize)) : null;
         return {
             size,
-            folder: node_path.join(distFolder, node_path.dirname(fileName)),
-            name: node_path.basename(fileName),
+            folder: external_node_path_.default.join(distFolder, external_node_path_.default.dirname(fileName)),
+            name: external_node_path_.default.basename(fileName),
             gzippedSize,
             sizeLabel: calcFileSize(size),
             gzipSizeLabel
@@ -4001,7 +4418,7 @@ async function printFileSizes(options, stats, rootPath, environmentName) {
                 size: asset.size
             };
             return !exclude(assetInfo) && (!options.include || options.include(assetInfo));
-        }), distFolder = node_path.relative(rootPath, distPath);
+        }), distFolder = external_node_path_.default.relative(rootPath, distPath);
         return Promise.all(filteredAssets.map((asset)=>formatAsset(asset, distPath, distFolder)));
     }, assets = await getAssets();
     if (0 === assets.length) return logs;
@@ -4010,7 +4427,7 @@ async function printFileSizes(options, stats, rootPath, environmentName) {
     for (let asset of (showTotal = showTotal && !(showDetail && 1 === assets.length), assets))totalSize += asset.size, options.compressed && (totalGzipSize += asset.gzippedSize ?? asset.size);
     let fileHeader = showDetail ? `File (${environmentName})` : '', totalSizeLabel = showTotal ? showDetail ? 'Total:' : `Total size (${environmentName}):` : '', totalSizeStr = showTotal ? calcFileSize(totalSize) : '';
     if (showDetail) {
-        let maxFileLength = Math.max(...assets.map((a)=>(a.folder + node_path.sep + a.name).length), showTotal ? totalSizeLabel.length : 0, fileHeader.length), maxSizeLength = Math.max(...assets.map((a)=>a.sizeLabel.length), totalSizeStr.length), showGzipHeader = !!(options.compressed && assets.some((item)=>null !== item.gzippedSize));
+        let maxFileLength = Math.max(...assets.map((a)=>(a.folder + external_node_path_.default.sep + a.name).length), showTotal ? totalSizeLabel.length : 0, fileHeader.length), maxSizeLength = Math.max(...assets.map((a)=>a.sizeLabel.length), totalSizeStr.length), showGzipHeader = !!(options.compressed && assets.some((item)=>null !== item.gzippedSize));
         for (let asset of (logs.push(function(maxFileLength, maxSizeLength, fileHeader, showGzipHeader) {
             let lengths = [
                 maxFileLength,
@@ -4026,9 +4443,9 @@ async function printFileSizes(options, stats, rootPath, environmentName) {
             }, '');
             return picocolors.blue(headerRow);
         }(maxFileLength, maxSizeLength, fileHeader, showGzipHeader)), assets)){
-            let { sizeLabel } = asset, { name, folder, gzipSizeLabel } = asset, fileNameLength = (folder + node_path.sep + name).length, sizeLength = sizeLabel.length;
+            let { sizeLabel } = asset, { name, folder, gzipSizeLabel } = asset, fileNameLength = (folder + external_node_path_.default.sep + name).length, sizeLength = sizeLabel.length;
             sizeLength < maxSizeLength && (sizeLabel += ' '.repeat(maxSizeLength - sizeLength));
-            let fileNameLabel = picocolors.dim(asset.folder + node_path.sep) + coloringAssetName(asset.name);
+            let fileNameLabel = picocolors.dim(asset.folder + external_node_path_.default.sep) + coloringAssetName(asset.name);
             fileNameLength < maxFileLength && (fileNameLabel += ' '.repeat(maxFileLength - fileNameLength));
             let log = `${fileNameLabel}   ${sizeLabel}`;
             gzipSizeLabel && (log += `   ${gzipSizeLabel}`), logs.push(log);
@@ -4048,14 +4465,6 @@ async function printFileSizes(options, stats, rootPath, environmentName) {
     }
     return logs.push(''), logs;
 }
-function RsbuildHtmlPlugin_define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
-}
 let entryNameSymbol = Symbol('entryName'), VOID_TAGS = [
     'area',
     'base',
@@ -4104,18 +4513,23 @@ let entryNameSymbol = Symbol('entryName'), VOID_TAGS = [
             ...override
         }));
 class RsbuildHtmlPlugin {
+    name;
+    getExtraData;
+    constructor(getExtraData){
+        this.name = 'RsbuildHtmlPlugin', this.getExtraData = getExtraData;
+    }
     apply(compiler) {
         let emitFavicon = async ({ compilation, favicon, faviconDistPath })=>{
-            let buffer, name = node_path.basename(favicon);
+            let buffer, name = external_node_path_.default.basename(favicon);
             if (compilation.assets[name]) return name;
             if (!compilation.inputFileSystem) return addCompilationError(compilation, `${picocolors.dim('[rsbuild:html]')} Failed to read the favicon file as ${picocolors.yellow('compilation.inputFileSystem')} is not available.`), null;
-            let inputFilename = node_path.isAbsolute(favicon) ? favicon : node_path.join(compilation.compiler.context, favicon);
+            let inputFilename = external_node_path_.default.isAbsolute(favicon) ? favicon : external_node_path_.default.join(compilation.compiler.context, favicon);
             try {
                 if (!(buffer = await external_node_util_promisify(compilation.inputFileSystem.readFile)(inputFilename))) throw Error('Buffer is undefined');
             } catch (error) {
                 return logger.debug(`read favicon error: ${error}`), addCompilationError(compilation, `${picocolors.dim('[rsbuild:html]')} Failed to read the favicon file at ${picocolors.yellow(inputFilename)}.`), null;
             }
-            let source = new compiler.webpack.sources.RawSource(buffer, !1), outputFilename = node_path.posix.join(faviconDistPath, name);
+            let source = new compiler.webpack.sources.RawSource(buffer, !1), outputFilename = external_node_path_.default.posix.join(faviconDistPath, name);
             return compilation.emitAsset(outputFilename, source), outputFilename;
         }, addFavicon = async ({ headTags, favicon, faviconDistPath, compilation, publicPath })=>{
             let href = favicon;
@@ -4149,19 +4563,15 @@ class RsbuildHtmlPlugin {
                 let extraData = getExtraDataByPlugin(data.plugin);
                 if (!extraData) return data;
                 let { headTags, bodyTags } = data, { favicon, faviconDistPath, context, tagConfig, entryName, environment, templateContent } = extraData;
-                if (!(templateContent && /<title/i.test(templateContent) && /<\/title/i.test(templateContent))) {
-                    var _data_plugin_options;
-                    ((headTags, title = '')=>{
-                        '' !== title && void 0 !== title && headTags.unshift({
-                            tagName: 'title',
-                            innerHTML: title,
-                            attributes: {},
-                            voidTag: !1,
-                            meta: {}
-                        });
-                    })(headTags, null == (_data_plugin_options = data.plugin.options) ? void 0 : _data_plugin_options.title);
-                }
-                favicon && await addFavicon({
+                templateContent && /<title/i.test(templateContent) && /<\/title/i.test(templateContent) || ((headTags, title = '')=>{
+                    '' !== title && void 0 !== title && headTags.unshift({
+                        tagName: 'title',
+                        innerHTML: title,
+                        attributes: {},
+                        voidTag: !1,
+                        meta: {}
+                    });
+                })(headTags, data.plugin.options?.title), favicon && await addFavicon({
                     headTags,
                     favicon,
                     faviconDistPath,
@@ -4188,8 +4598,7 @@ class RsbuildHtmlPlugin {
                     headTags: modified.headTags.map(fromBasicTag),
                     bodyTags: modified.bodyTags.map(fromBasicTag)
                 }), tagConfig && ((data, tagConfig, compilationHash, entryName)=>{
-                    var _tagConfig_tags;
-                    if (!(null == (_tagConfig_tags = tagConfig.tags) ? void 0 : _tagConfig_tags.length)) return;
+                    if (!tagConfig.tags?.length) return;
                     let fromInjectTags = (tags)=>{
                         let ret = [];
                         for (let tag of tags){
@@ -4251,9 +4660,6 @@ class RsbuildHtmlPlugin {
             });
         });
     }
-    constructor(getExtraData){
-        RsbuildHtmlPlugin_define_property(this, "name", void 0), RsbuildHtmlPlugin_define_property(this, "getExtraData", void 0), this.name = 'RsbuildHtmlPlugin', this.getExtraData = getExtraData;
-    }
 }
 let existTemplatePath = new Set();
 async function getTemplate(entryName, config, rootPath) {
@@ -4271,7 +4677,7 @@ async function getTemplate(entryName, config, rootPath) {
             templateContent: (mountId = config.html.mountId, `<!doctype html><html><head></head><body><div id="${mountId}"></div></body></html>`)
         };
     }
-    let absolutePath = external_node_path_isAbsolute(templatePath) ? templatePath : node_path.join(rootPath, templatePath);
+    let absolutePath = (0, external_node_path_.isAbsolute)(templatePath) ? templatePath : external_node_path_.default.join(rootPath, templatePath);
     if (!existTemplatePath.has(absolutePath)) {
         if (!await isFileExists(absolutePath)) throw Error(`${picocolors.dim('[rsbuild:html]')} Failed to resolve HTML template, check if the file exists: ${picocolors.yellow(absolutePath)}`);
         existTemplatePath.add(absolutePath);
@@ -4285,7 +4691,7 @@ async function getTemplate(entryName, config, rootPath) {
 function updateSourceMappingURL({ source, compilation, publicPath, type, config }) {
     let { devtool } = compilation.options;
     if (devtool && !devtool.includes('inline') && source.includes('# sourceMappingURL')) {
-        let prefix = addTrailingSlash(node_path.join(publicPath, config.output.distPath[type] || ''));
+        let prefix = addTrailingSlash(external_node_path_.default.join(publicPath, config.output.distPath[type] || ''));
         return source.replace(/# sourceMappingURL=/, `# sourceMappingURL=${prefix}`);
     }
     return source;
@@ -4338,7 +4744,7 @@ let isWsl = ()=>{
         if (mountPoint) return mountPoint;
         let configFilePath = '/etc/wsl.conf', isConfigFileExists = !1;
         try {
-            await promises.access(configFilePath, external_node_fs_constants.F_OK), isConfigFileExists = !0;
+            await promises.access(configFilePath, promises_constants.F_OK), isConfigFileExists = !0;
         } catch  {}
         if (!isConfigFileExists) return defaultMountPoint;
         let configContent = await promises.readFile(configFilePath, {
@@ -4468,7 +4874,7 @@ async function default_browser_defaultBrowser() {
     if ('win32' === node_process.platform) return defaultBrowser();
     throw Error('Only macOS, Linux, and Windows are supported');
 }
-let open_execFile = external_node_util_promisify(node_child_process.execFile), open_dirname = node_path.dirname(fileURLToPath(import.meta.url)), localXdgOpenPath = node_path.join(open_dirname, 'xdg-open'), { platform, arch } = node_process;
+let open_execFile = external_node_util_promisify(node_child_process.execFile), open_dirname = external_node_path_.default.dirname((0, external_node_url_.fileURLToPath)(import.meta.url)), localXdgOpenPath = external_node_path_.default.join(open_dirname, 'xdg-open'), { platform, arch } = node_process;
 async function getWindowsDefaultBrowserFromWsl() {
     let powershellPath = await powerShellPath(), rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`, encodedCommand = external_node_buffer_Buffer.from(rawCommand, 'utf16le').toString('base64'), { stdout } = await open_execFile(powershellPath, [
         '-NoProfile',
@@ -4555,7 +4961,7 @@ let pTryEach = async (array, mapper)=>{
         else {
             let exeLocalXdgOpen = !1;
             try {
-                await promises.access(localXdgOpenPath, external_node_fs_constants.X_OK), exeLocalXdgOpen = !0;
+                await promises.access(localXdgOpenPath, promises_constants.X_OK), exeLocalXdgOpen = !0;
             } catch  {}
             command = node_process.versions.electron ?? ('android' === platform || !open_dirname || '/' === open_dirname || !exeLocalXdgOpen) ? 'xdg-open' : localXdgOpenPath;
         }
@@ -4640,12 +5046,12 @@ let normalizeUrl = (url)=>url.replace(/([^:]\/)\/+/g, '$1'), joinUrlSegments = (
     let trailingSlashBase = addTrailingSlash(base);
     return path.startsWith(trailingSlashBase) ? path.slice(trailingSlashBase.length - 1) : path;
 }, getRoutes = (context)=>Object.values(context.environments).reduce((prev, environmentContext)=>{
-        let { distPath, config } = environmentContext, distPrefix = relative(context.distPath, distPath).split(sep).join('/'), routes = formatRoutes(environmentContext.htmlPaths, context.normalizedConfig.server.base, posix.join(distPrefix, config.output.distPath.html), config.html.outputStructure);
+        let { distPath, config } = environmentContext, distPrefix = (0, external_node_path_.relative)(context.distPath, distPath).split(external_node_path_.sep).join('/'), routes = formatRoutes(environmentContext.htmlPaths, context.normalizedConfig.server.base, external_node_path_.posix.join(distPrefix, config.output.distPath.html), config.html.outputStructure);
         return prev.concat(...routes);
     }, []), formatRoutes = (entry, base, distPathPrefix, outputStructure)=>{
     let prefix = joinUrlSegments(base, ((input)=>{
         let prefix = input;
-        if ((null == prefix ? void 0 : prefix.startsWith('./')) && (prefix = prefix.replace('./', '')), !prefix) return '/';
+        if (prefix?.startsWith('./') && (prefix = prefix.replace('./', '')), !prefix) return '/';
         let hasLeadingSlash = prefix.startsWith('/'), hasTailSlash = prefix.endsWith('/');
         return `${hasLeadingSlash ? '' : '/'}${prefix}${hasTailSlash ? '' : '/'}`;
     })(distPathPrefix));
@@ -4822,7 +5228,7 @@ async function openBrowser(url) {
         let options = browser ? {
             app: {
                 name: apps[browser] ?? browser,
-                arguments: null == browserArgs ? void 0 : browserArgs.split(' ')
+                arguments: browserArgs?.split(' ')
             }
         } : {};
         return (await ((target, options)=>{
@@ -4881,6 +5287,10 @@ function recursiveChunkEntryNames(chunk) {
     ];
 }
 class PatchSplitChunksPlugin {
+    name;
+    constructor(name){
+        this.name = name;
+    }
     apply(compiler) {
         let { splitChunks } = compiler.options.optimization;
         if (!splitChunks) return;
@@ -4906,33 +5316,27 @@ class PatchSplitChunksPlugin {
         let { cacheGroups } = splitChunks;
         if (cacheGroups) for (let cacheGroupKey of Object.keys(cacheGroups))cacheGroups[cacheGroupKey] && applyPatch(cacheGroups[cacheGroupKey]);
     }
-    constructor(name){
-        var key, value;
-        value = void 0, (key = "name") in this ? Object.defineProperty(this, key, {
-            value: value,
-            enumerable: !0,
-            configurable: !0,
-            writable: !0
-        }) : this[key] = value, this.name = name;
-    }
 }
-let resolve_require = createRequire(import.meta.url);
+let resolve_require = (0, external_node_module_.createRequire)(import.meta.url);
 function isAsyncChunk(chunk) {
     return 'canBeInitial' in chunk ? !chunk.canBeInitial() : 'isInitial' in chunk && !chunk.isInitial();
 }
-function HtmlResourceHintsPlugin_define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
-}
 let HtmlResourceHintsPlugin_defaultOptions = {
     type: 'async-chunks',
     dedupe: !0
 };
 class HtmlResourceHintsPlugin {
+    options;
+    name = 'HtmlResourceHintsPlugin';
+    resourceHints = [];
+    type;
+    HTMLCount;
+    constructor(options, type, HTMLCount){
+        this.options = {
+            ...HtmlResourceHintsPlugin_defaultOptions,
+            ...options
+        }, this.type = type, this.HTMLCount = HTMLCount;
+    }
     apply(compiler) {
         compiler.hooks.compilation.tap(this.name, (compilation)=>{
             let pluginHooks = getHTMLPlugin().getCompilationHooks(compilation), pluginName = `HTML${upperFirst(this.type)}Plugin`;
@@ -4945,13 +5349,9 @@ class HtmlResourceHintsPlugin {
                         if ('initial' === includeType) return chunks.filter((chunk)=>!isAsyncChunk(chunk));
                         if ('all-chunks' === includeType) return chunks;
                         if ('all-assets' === includeType) {
-                            var _compilation_assetsInfo;
                             let licenseAssets = [
-                                ...(null == (_compilation_assetsInfo = compilation.assetsInfo) ? void 0 : _compilation_assetsInfo.values()) || []
-                            ].map((info)=>{
-                                var _info_related;
-                                return null != (_info_related = info.related) && !!_info_related.license && info.related.license;
-                            }).filter(Boolean);
+                                ...compilation.assetsInfo?.values() || []
+                            ].map((info)=>!!info.related?.license && info.related.license).filter(Boolean);
                             return [
                                 {
                                     files: Object.keys(compilation.assets).filter((t)=>!licenseAssets.includes(t))
@@ -4977,7 +5377,7 @@ class HtmlResourceHintsPlugin {
                                 let { options } = htmlPluginData.plugin;
                                 return recursiveChunkEntryNames(chunk).some((chunkName)=>{
                                     var includeChunks, excludeChunks;
-                                    return includeChunks = null == options ? void 0 : options.chunks, excludeChunks = null == options ? void 0 : options.excludeChunks, !(Array.isArray(includeChunks) && -1 === includeChunks.indexOf(chunkName) || Array.isArray(excludeChunks) && -1 !== excludeChunks.indexOf(chunkName));
+                                    return includeChunks = options?.chunks, excludeChunks = options?.excludeChunks, !(Array.isArray(includeChunks) && -1 === includeChunks.indexOf(chunkName) || Array.isArray(excludeChunks) && -1 !== excludeChunks.indexOf(chunkName));
                                 });
                             })({
                                 chunk: chunk,
@@ -4995,7 +5395,7 @@ class HtmlResourceHintsPlugin {
                             rel: type
                         };
                         'preload' === type && (attributes.as = function({ href, file }) {
-                            let url = new external_node_url_URL(file || href, 'https://example.com'), extension = node_path.extname(url.pathname).slice(1);
+                            let url = new external_node_url_.URL(file || href, 'https://example.com'), extension = external_node_path_.default.extname(url.pathname).slice(1);
                             return [
                                 'css'
                             ].includes(extension) ? 'style' : IMAGE_EXTENSIONS.includes(extension) ? 'image' : VIDEO_EXTENSIONS.includes(extension) ? 'video' : AUDIO_EXTENSIONS.includes(extension) ? 'audio' : FONT_EXTENSIONS.includes(extension) ? 'font' : [
@@ -5021,12 +5421,6 @@ class HtmlResourceHintsPlugin {
             });
         });
     }
-    constructor(options, type, HTMLCount){
-        HtmlResourceHintsPlugin_define_property(this, "options", void 0), HtmlResourceHintsPlugin_define_property(this, "name", 'HtmlResourceHintsPlugin'), HtmlResourceHintsPlugin_define_property(this, "resourceHints", []), HtmlResourceHintsPlugin_define_property(this, "type", void 0), HtmlResourceHintsPlugin_define_property(this, "HTMLCount", void 0), this.options = {
-            ...HtmlResourceHintsPlugin_defaultOptions,
-            ...options
-        }, this.type = type, this.HTMLCount = HTMLCount;
-    }
 }
 let resourceHints_generateLinks = (options, rel)=>options.map((option)=>({
             tag: 'link',
@@ -5034,9 +5428,9 @@ let resourceHints_generateLinks = (options, rel)=>options.map((option)=>({
                 rel,
                 ...option
             }
-        })), rsdoctor_require = createRequire(import.meta.url);
+        })), rsdoctor_require = (0, external_node_module_.createRequire)(import.meta.url);
 async function ensureFileDir(outputFilePath) {
-    let dir = node_path.dirname(outputFilePath);
+    let dir = external_node_path_.default.dirname(outputFilePath);
     await node_fs.promises.mkdir(dir, {
         recursive: !0
     });
@@ -5044,7 +5438,7 @@ async function ensureFileDir(outputFilePath) {
 async function applyProfile(root, filterValue, traceLayer = 'perfetto', traceOutput) {
     if ('perfetto' !== traceLayer && 'logger' !== traceLayer) throw Error(`unsupported trace layer: ${traceLayer}`);
     if (!traceOutput) {
-        let timestamp = Date.now(), defaultOutputDir = node_path.join(root, `.rspack-profile-${timestamp}-${process.pid}`), defaultRustTracePerfettoOutput = node_path.join(defaultOutputDir, 'rspack.pftrace');
+        let timestamp = Date.now(), defaultOutputDir = external_node_path_.default.join(root, `.rspack-profile-${timestamp}-${process.pid}`), defaultRustTracePerfettoOutput = external_node_path_.default.join(defaultOutputDir, 'rspack.pftrace');
         traceOutput = 'perfetto' === traceLayer ? defaultRustTracePerfettoOutput : 'stdout';
     }
     return await ensureFileDir(traceOutput), await rspack_rspack.experiments.globalTrace.register("OVERVIEW" === filterValue ? 'info' : "ALL" === filterValue ? 'trace' : filterValue, traceLayer, traceOutput), traceOutput;
@@ -5087,7 +5481,7 @@ let MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\
                     priority: -9,
                     test: NODE_MODULES_REGEX,
                     name: (module)=>module ? function(modulePath) {
-                            let handleModuleContext = null == modulePath ? void 0 : modulePath.match(MODULE_PATH_REGEX);
+                            let handleModuleContext = modulePath?.match(MODULE_PATH_REGEX);
                             if (!handleModuleContext) return;
                             let [, scope, name] = handleModuleContext;
                             return [
@@ -5149,7 +5543,7 @@ let MODULE_PATH_REGEX = /.*[\\/]node_modules[\\/](?!\.pnpm[\\/])(?:(@[^\\/]+)[\\
             }
         };
     }
-}, swc_require = createRequire(import.meta.url), builtinSwcLoaderName = 'builtin:swc-loader', isCliShortcutsEnabled = (config)=>config.dev.cliShortcuts && isTTY('stdin');
+}, swc_require = (0, external_node_module_.createRequire)(import.meta.url), builtinSwcLoaderName = 'builtin:swc-loader', isCliShortcutsEnabled = (config)=>config.dev.cliShortcuts && isTTY('stdin');
 async function setupCliShortcuts({ help = !0, openPage, closeServer, printUrls, restartServer, customShortcuts }) {
     let shortcuts = [
         {
@@ -5222,7 +5616,7 @@ async function resolveHostname(host = 'localhost') {
         '0000:0000:0000:0000:0000:0000:0000:0000'
     ]).has(host) ? 'localhost' : host;
 }
-let compilationMiddleware_require = createRequire(import.meta.url), getCompilationMiddleware = async ({ config, compiler, callbacks, environments, resolvedPort })=>{
+let compilationMiddleware_require = (0, external_node_module_.createRequire)(import.meta.url), getCompilationMiddleware = async ({ config, compiler, callbacks, environments, resolvedPort })=>{
     let { default: rsbuildDevMiddleware } = await import("../compiled/rsbuild-dev-middleware/index.js"), resolvedHost = await resolveHostname(config.server.host);
     return applyToCompiler(compiler, (compiler, index)=>{
         let environment = Object.values(environments).find((env)=>env.index === index);
@@ -5234,9 +5628,8 @@ let compilationMiddleware_require = createRequire(import.meta.url), getCompilati
                 return !!target && (Array.isArray(target) ? target.includes('web') : 'web' === target);
             })(compiler)) return;
             let clientPaths = function(devConfig) {
-                var _devConfig_client;
                 let clientPaths = [];
-                return (devConfig.hmr || devConfig.liveReload) && (hmrClientPath || (hmrClientPath = compilationMiddleware_require.resolve('@rsbuild/core/client/hmr')), clientPaths.push(hmrClientPath), (null == (_devConfig_client = devConfig.client) ? void 0 : _devConfig_client.overlay) && (overlayClientPath || (overlayClientPath = compilationMiddleware_require.resolve('@rsbuild/core/client/overlay')), clientPaths.push(overlayClientPath))), clientPaths;
+                return (devConfig.hmr || devConfig.liveReload) && (hmrClientPath || (hmrClientPath = compilationMiddleware_require.resolve('@rsbuild/core/client/hmr')), clientPaths.push(hmrClientPath), devConfig.client?.overlay && (overlayClientPath || (overlayClientPath = compilationMiddleware_require.resolve('@rsbuild/core/client/overlay')), clientPaths.push(overlayClientPath))), clientPaths;
             }(config.dev);
             if (!clientPaths.length) return;
             let clientConfig = {
@@ -5317,30 +5710,42 @@ let closeCode = [
     29,
     39,
     49
-];
-function socketServer_define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
-}
-let parseQueryString = (req)=>{
+], parseQueryString = (req)=>{
     let queryStr = req.url ? req.url.split('?')[1] : '';
     return queryStr ? Object.fromEntries(new URLSearchParams(queryStr)) : {};
 };
 class SocketServer {
+    wsServer;
+    sockets = new Map();
+    options;
+    stats;
+    initialChunks;
+    heartbeatTimer = null;
+    environments;
+    constructor(options, environments){
+        this.options = options, this.stats = {}, this.initialChunks = {}, this.environments = environments;
+    }
+    upgrade = (req, socket, head)=>{
+        if (!this.wsServer.shouldHandle(req)) return;
+        let query = parseQueryString(req);
+        if (!Object.values(this.environments).map((env)=>env.webSocketToken).includes(query.token)) return void socket.destroy();
+        this.wsServer.handleUpgrade(req, socket, head, (connection)=>{
+            this.wsServer.emit('connection', connection, req);
+        });
+    };
+    checkSockets = ()=>{
+        for (let socket of this.wsServer.clients)socket.isAlive ? (socket.isAlive = !1, socket.ping(()=>{})) : socket.terminate();
+        null !== this.heartbeatTimer && (this.heartbeatTimer = setTimeout(this.checkSockets, 30000).unref());
+    };
     clearHeartbeatTimer() {
         this.heartbeatTimer && (clearTimeout(this.heartbeatTimer), this.heartbeatTimer = null);
     }
     async prepare() {
-        var _this_options_client;
         this.clearHeartbeatTimer();
         let { default: ws } = await import("../compiled/ws/index.js");
         this.wsServer = new ws.Server({
             noServer: !0,
-            path: null == (_this_options_client = this.options.client) ? void 0 : _this_options_client.path
+            path: this.options.client?.path
         }), this.wsServer.on('error', (err)=>{
             logger.error(err);
         }), this.heartbeatTimer = setTimeout(this.checkSockets, 30000).unref(), this.wsServer.on('connection', (socket, req)=>{
@@ -5443,9 +5848,9 @@ class SocketServer {
                             let pathRegex = /(?:\.\.?[/\\]|[a-zA-Z]:\\|\/)[^:]*:\d+:\d+/g, urlRegex = /(https?:\/\/(?:[\w-]+\.)+[a-z0-9](?:[\w-.~:/?#[\]@!$&'*+,;=])*)/gi;
                             return text.split('\n').map((line)=>{
                                 let replacedLine = line.replace(pathRegex, (file)=>{
-                                    let hasClosingSpan = file.includes('</span>') && !file.includes('<span'), filePath = hasClosingSpan ? file.replace('</span>', '') : file, isAbsolute = node_path.isAbsolute(filePath), absolutePath = root1 && !isAbsolute ? node_path.join(root1, filePath) : filePath, relativePath = root1 && isAbsolute ? function(base, filepath) {
-                                        let relativePath = relative(base, filepath);
-                                        return '' === relativePath ? `.${sep}` : relativePath.startsWith('.') ? relativePath : `.${sep}${relativePath}`;
+                                    let hasClosingSpan = file.includes('</span>') && !file.includes('<span'), filePath = hasClosingSpan ? file.replace('</span>', '') : file, isAbsolute = external_node_path_.default.isAbsolute(filePath), absolutePath = root1 && !isAbsolute ? external_node_path_.default.join(root1, filePath) : filePath, relativePath = root1 && isAbsolute ? function(base, filepath) {
+                                        let relativePath = (0, external_node_path_.relative)(base, filepath);
+                                        return '' === relativePath ? `.${external_node_path_.sep}` : relativePath.startsWith('.') ? relativePath : `.${external_node_path_.sep}${relativePath}`;
                                     }(root1, filePath) : filePath;
                                     return `<a class="file-link" data-file="${absolutePath}">${relativePath}</a>${hasClosingSpan ? '</span>' : ''}`;
                                 });
@@ -5608,29 +6013,19 @@ class SocketServer {
     send(connection, message) {
         1 === connection.readyState && connection.send(message);
     }
-    constructor(options, environments){
-        socketServer_define_property(this, "wsServer", void 0), socketServer_define_property(this, "sockets", new Map()), socketServer_define_property(this, "options", void 0), socketServer_define_property(this, "stats", void 0), socketServer_define_property(this, "initialChunks", void 0), socketServer_define_property(this, "heartbeatTimer", null), socketServer_define_property(this, "environments", void 0), socketServer_define_property(this, "upgrade", (req, socket, head)=>{
-            if (!this.wsServer.shouldHandle(req)) return;
-            let query = parseQueryString(req);
-            if (!Object.values(this.environments).map((env)=>env.webSocketToken).includes(query.token)) return void socket.destroy();
-            this.wsServer.handleUpgrade(req, socket, head, (connection)=>{
-                this.wsServer.emit('connection', connection, req);
-            });
-        }), socketServer_define_property(this, "checkSockets", ()=>{
-            for (let socket of this.wsServer.clients)socket.isAlive ? (socket.isAlive = !1, socket.ping(()=>{})) : socket.terminate();
-            null !== this.heartbeatTimer && (this.heartbeatTimer = setTimeout(this.checkSockets, 30000).unref());
-        }), this.options = options, this.stats = {}, this.initialChunks = {}, this.environments = environments;
-    }
-}
-function compilationManager_define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
 }
 class CompilationManager {
+    middleware;
+    outputFileSystem;
+    config;
+    compiler;
+    environments;
+    publicPaths;
+    socketServer;
+    resolvedPort;
+    constructor({ config, compiler, publicPaths, resolvedPort, environments }){
+        this.config = config, this.compiler = compiler, this.environments = environments, this.publicPaths = publicPaths, this.resolvedPort = resolvedPort, this.outputFileSystem = node_fs, this.socketServer = new SocketServer(config.dev, environments);
+    }
     async init() {
         await this.setupCompilationMiddleware(), await this.socketServer.prepare();
         let { compiler } = this;
@@ -5650,6 +6045,7 @@ class CompilationManager {
             });
         });
     }
+    readFileSync = (fileName)=>'readFileSync' in this.outputFileSystem ? this.outputFileSystem.readFileSync(fileName, 'utf-8') : node_fs.readFileSync(fileName, 'utf-8');
     async setupCompilationMiddleware() {
         let { config, publicPaths, environments } = this, middleware = await getCompilationMiddleware({
             config,
@@ -5674,9 +6070,6 @@ class CompilationManager {
         };
         wrapper.close = middleware.close, wrapper.watch = middleware.watch, this.middleware = wrapper;
     }
-    constructor({ config, compiler, publicPaths, resolvedPort, environments }){
-        compilationManager_define_property(this, "middleware", void 0), compilationManager_define_property(this, "outputFileSystem", void 0), compilationManager_define_property(this, "config", void 0), compilationManager_define_property(this, "compiler", void 0), compilationManager_define_property(this, "environments", void 0), compilationManager_define_property(this, "publicPaths", void 0), compilationManager_define_property(this, "socketServer", void 0), compilationManager_define_property(this, "resolvedPort", void 0), compilationManager_define_property(this, "readFileSync", (fileName)=>'readFileSync' in this.outputFileSystem ? this.outputFileSystem.readFileSync(fileName, 'utf-8') : node_fs.readFileSync(fileName, 'utf-8')), this.config = config, this.compiler = compiler, this.environments = environments, this.publicPaths = publicPaths, this.resolvedPort = resolvedPort, this.outputFileSystem = node_fs, this.socketServer = new SocketServer(config.dev, environments);
-    }
 }
 let ENCODING_REGEX = /\bgzip\b/, CONTENT_TYPE_REGEX = /text|javascript|\/json|xml/i, gzipMiddleware = ({ filter, level = node_zlib.constants.Z_BEST_SPEED } = {})=>(req, res, next)=>{
         let gzip, writeHeadStatus;
@@ -5737,15 +6130,14 @@ function historyApiFallbackMiddleware(options = {}) {
         let parsedUrl = function(req) {
             let proto = req.headers['x-forwarded-proto'] || 'http', host = req.headers['x-forwarded-host'] || req.headers.host || 'localhost';
             try {
-                return new external_node_url_URL(req.url || '/', `${proto}://${host}`);
+                return new external_node_url_.URL(req.url || '/', `${proto}://${host}`);
             } catch  {
                 return null;
             }
         }(req);
         if (null === parsedUrl) return void next();
         for (let rewrite of rewrites){
-            var _parsedUrl_pathname;
-            let match = null == (_parsedUrl_pathname = parsedUrl.pathname) ? void 0 : _parsedUrl_pathname.match(rewrite.from);
+            let match = parsedUrl.pathname?.match(rewrite.from);
             if (!match) continue;
             let rule = rewrite.to;
             '/' !== (rewriteTarget = 'string' == typeof rule ? rule : rule({
@@ -5772,7 +6164,7 @@ let faviconFallbackMiddleware = (req, res, next)=>{
         let _startAt = process.hrtime();
         onFinished(res, ()=>{
             let method = req.method, url = req.originalUrl || req.url, status = Number(res.statusCode), statusColor = status >= 500 ? picocolors.red : status >= 400 ? picocolors.yellow : status >= 300 ? picocolors.cyan : status >= 200 ? picocolors.green : (res)=>res, endAt = process.hrtime(), totalTime = (endAt[0] - _startAt[0]) * 1e3 + (endAt[1] - _startAt[1]) * 1e-6;
-            logger.debug(`${statusColor(status)} ${method} ${picocolors.gray(url)} ${picocolors.gray(`${totalTime.toFixed(3)} ms`)}`);
+            logger.debug(`${statusColor(status)} ${method} ${url} ${picocolors.dim(`${totalTime.toFixed(3)} ms`)}`);
         }), next();
     };
 }, notFoundMiddleware = (_req, res, _next)=>{
@@ -5785,14 +6177,13 @@ let faviconFallbackMiddleware = (req, res, next)=>{
     next();
 }, middlewares_isFileExists = async (filePath, outputFileSystem)=>new Promise((resolve)=>{
         outputFileSystem.stat(filePath, (_error, stats)=>{
-            resolve(null == stats ? void 0 : stats.isFile());
+            resolve(stats?.isFile());
         });
     }), maybeHTMLRequest = (req)=>{
     if (!req.url || !req.headers || 'GET' !== req.method && 'HEAD' !== req.method) return !1;
     let { accept } = req.headers;
     return 'string' == typeof accept && (accept.includes('text/html') || accept.includes('*/*'));
 }, postfixRE = /[?#].*$/, getUrlPathname = (url)=>url.replace(postfixRE, ''), getBaseMiddleware = ({ base })=>(req, res, next)=>{
-        var _req_headers_accept;
         let url = req.url, pathname = getUrlPathname(url);
         if (pathname.startsWith(base)) {
             req.url = stripBase(url, base), next();
@@ -5805,7 +6196,7 @@ let faviconFallbackMiddleware = (req, res, next)=>{
             }), res.end();
             return;
         }
-        if (null == (_req_headers_accept = req.headers.accept) ? void 0 : _req_headers_accept.includes('text/html')) {
+        if (req.headers.accept?.includes('text/html')) {
             res.writeHead(404, {
                 'Content-Type': 'text/html'
             }), res.end(`The server is configured with a base URL of ${base} - did you mean to visit <a href="${redirectPath}">${redirectPath}</a> instead?`);
@@ -5865,12 +6256,8 @@ let faviconFallbackMiddleware = (req, res, next)=>{
     }
     let { compress } = server;
     if (compress && middlewares.push(gzipMiddleware('object' == typeof compress ? compress : void 0)), 'dev' === context.action && 'rspack' === context.bundlerType && compilationManager) {
-        var _compiler_options_experiments;
         let { compiler } = compilationManager;
-        (helpers_isMultiCompiler(compiler) ? compiler.compilers.some((childCompiler)=>{
-            var _childCompiler_options_experiments;
-            return null == (_childCompiler_options_experiments = childCompiler.options.experiments) ? void 0 : _childCompiler_options_experiments.lazyCompilation;
-        }) : null == (_compiler_options_experiments = compiler.options.experiments) ? void 0 : _compiler_options_experiments.lazyCompilation) && middlewares.push(rspack_rspack.experiments.lazyCompilationMiddleware(compiler));
+        (helpers_isMultiCompiler(compiler) ? compiler.compilers.some((childCompiler)=>childCompiler.options.experiments?.lazyCompilation || childCompiler.options.lazyCompilation) : compiler.options.experiments?.lazyCompilation || compiler.options.lazyCompilation) && middlewares.push(rspack_rspack.experiments.lazyCompilationMiddleware(compiler));
     }
     server.base && '/' !== server.base && middlewares.push(getBaseMiddleware({
         base: server.base
@@ -5930,8 +6317,8 @@ let faviconFallbackMiddleware = (req, res, next)=>{
                 for(let key in environments){
                     res.write(`<h2>Environment: ${key}</h2>`);
                     let list = [], environment = environments[key], stats = await environment.getStats(), assets = getAssetsFromStats(stats);
-                    for (let asset of (res.write('<ul>'), assets))list.push(`<li><a target="_blank" href="${null == asset ? void 0 : asset.name}">${null == asset ? void 0 : asset.name}</a></li>`);
-                    res.write(null == list ? void 0 : list.join('')), res.write('</ul>');
+                    for (let asset of (res.write('<ul>'), assets))list.push(`<li><a target="_blank" href="${asset?.name}">${asset?.name}</a></li>`);
+                    res.write(list?.join('')), res.write('</ul>');
                 }
                 res.end('</body></html>');
             } catch (err) {
@@ -5940,8 +6327,7 @@ let faviconFallbackMiddleware = (req, res, next)=>{
         })({
         environments: devServerAPI.environments
     })), compilationManager && (middlewares.push(compilationManager.middleware), upgradeEvents.push(compilationManager.socketServer.upgrade), middlewares.push((req, res, next)=>{
-        var _req_url;
-        (null == (_req_url = req.url) ? void 0 : _req_url.endsWith('.hot-update.json')) && 'OPTIONS' !== req.method ? (res.statusCode = 404, res.end()) : next();
+        req.url?.endsWith('.hot-update.json') && 'OPTIONS' !== req.method ? (res.statusCode = 404, res.end()) : next();
     })), compilationManager && middlewares.push((({ distPath, compilationManager })=>async (req, res, next)=>{
             if (!maybeHTMLRequest(req)) return void next();
             let pathname = getUrlPathname(req.url), rewrite = (newUrl)=>{
@@ -5950,18 +6336,18 @@ let faviconFallbackMiddleware = (req, res, next)=>{
                 });
             };
             if (pathname.endsWith('/')) {
-                let newUrl = `${pathname}index.html`, filePath = node_path.join(distPath, newUrl);
+                let newUrl = `${pathname}index.html`, filePath = external_node_path_.default.join(distPath, newUrl);
                 if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) return void rewrite(newUrl);
-            } else if (!node_path.extname(pathname)) {
-                let newUrl = `${pathname}.html`, filePath = node_path.join(distPath, newUrl);
+            } else if (!external_node_path_.default.extname(pathname)) {
+                let newUrl = `${pathname}.html`, filePath = external_node_path_.default.join(distPath, newUrl);
                 if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) return void rewrite(newUrl);
             }
             next();
         })({
         compilationManager,
         distPath: context.distPath
-    })), normalizePublicDirs(null == server ? void 0 : server.publicDir))){
-        let { default: sirv } = await import("../compiled/sirv/index.js"), { name } = publicDir, assetMiddleware = sirv(external_node_path_isAbsolute(name) ? name : join(pwd, name), {
+    })), normalizePublicDirs(server?.publicDir))){
+        let { default: sirv } = await import("../compiled/sirv/index.js"), { name } = publicDir, assetMiddleware = sirv((0, external_node_path_.isAbsolute)(name) ? name : (0, external_node_path_.join)(pwd, name), {
             etag: !0,
             dev: !0
         });
@@ -5970,10 +6356,10 @@ let faviconFallbackMiddleware = (req, res, next)=>{
     for (let callback of postCallbacks)callback();
     return compilationManager && middlewares.push((({ htmlFallback, distPath, compilationManager })=>async (req, res, next)=>{
             if (!maybeHTMLRequest(req) || '/favicon.ico' === req.url || 'index' !== htmlFallback) return void next();
-            let filePath = node_path.join(distPath, 'index.html');
+            let filePath = external_node_path_.default.join(distPath, 'index.html');
             if (await middlewares_isFileExists(filePath, compilationManager.outputFileSystem)) {
                 let newUrl = '/index.html';
-                'verbose' === logger.level && logger.debug(`${req.method} ${picocolors.gray(`${req.url} ${picocolors.yellow('fallback')} to ${newUrl}`)}`), req.url = newUrl, compilationManager.middleware(req, res, (...args)=>{
+                'verbose' === logger.level && logger.debug(`    ${req.method} ${req.url} ${picocolors.yellow('fallback to')} ${newUrl}`), req.url = newUrl, compilationManager.middleware(req, res, (...args)=>{
                     next(...args);
                 });
                 return;
@@ -5983,7 +6369,7 @@ let faviconFallbackMiddleware = (req, res, next)=>{
         compilationManager,
         distPath: context.distPath,
         htmlFallback: server.htmlFallback
-    })), server.historyApiFallback && (middlewares.push(historyApiFallbackMiddleware(!0 === server.historyApiFallback ? {} : server.historyApiFallback)), (null == compilationManager ? void 0 : compilationManager.middleware) && middlewares.push(compilationManager.middleware)), middlewares.push(faviconFallbackMiddleware), {
+    })), server.historyApiFallback && (middlewares.push(historyApiFallbackMiddleware(!0 === server.historyApiFallback ? {} : server.historyApiFallback)), compilationManager?.middleware && middlewares.push(compilationManager.middleware)), middlewares.push(faviconFallbackMiddleware), {
         onUpgrade: (...args)=>{
             for (let cb of upgradeEvents)cb(...args);
         }
@@ -6012,7 +6398,7 @@ let faviconFallbackMiddleware = (req, res, next)=>{
     });
     return middlewares.push(...after), {
         close: async ()=>{
-            await (null == compilationManager ? void 0 : compilationManager.close());
+            await compilationManager?.close();
         },
         onUpgrade,
         middlewares
@@ -6032,15 +6418,14 @@ let faviconFallbackMiddleware = (req, res, next)=>{
     });
     return unlinked || (await syntheticModule.link(()=>{}), await syntheticModule.evaluate()), syntheticModule;
 };
-function basic_define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
-}
 class BasicRunner {
+    _options;
+    globalContext = null;
+    baseModuleScope = null;
+    requirers = new Map();
+    constructor(_options){
+        this._options = _options;
+    }
     run(file) {
         this.globalContext || (this.globalContext = this.createGlobalContext()), this.baseModuleScope = this.createBaseModuleScope(), this.createRunner();
         let res = this.getRequire()(this._options.dist, file.startsWith('./') ? file : `./${file}`);
@@ -6052,11 +6437,11 @@ class BasicRunner {
     }
     getFile(modulePath, currentDirectory) {
         if (Array.isArray(modulePath)) return {
-            path: node_path.join(currentDirectory, '.array-require.js'),
+            path: external_node_path_.default.join(currentDirectory, '.array-require.js'),
             content: `module.exports = (${modulePath.map((arg)=>`require(${JSON.stringify(`./${arg}`)})`).join(', ')});`,
             subPath: ''
         };
-        let joinedPath = /^\.\.?\//.test(modulePath) ? node_path.join(currentDirectory, modulePath) : modulePath;
+        let joinedPath = /^\.\.?\//.test(modulePath) ? external_node_path_.default.join(currentDirectory, modulePath) : modulePath;
         return this._options.isBundleOutput(joinedPath) ? {
             path: joinedPath,
             content: this._options.readFileSync(joinedPath),
@@ -6080,11 +6465,8 @@ class BasicRunner {
             throw Error(`${picocolors.dim('[rsbuild:runner]')} Not implemented`);
         });
     }
-    constructor(_options){
-        basic_define_property(this, "_options", void 0), basic_define_property(this, "globalContext", void 0), basic_define_property(this, "baseModuleScope", void 0), basic_define_property(this, "requirers", void 0), this._options = _options, this.globalContext = null, this.baseModuleScope = null, this.requirers = new Map();
-    }
 }
-let cjs_require = createRequire(import.meta.url), cjs_define = (...args)=>{
+let cjs_require = (0, external_node_module_.createRequire)(import.meta.url), cjs_define = (...args)=>{
     args.pop()();
 };
 class CommonJsRunner extends BasicRunner {
@@ -6113,10 +6495,10 @@ class CommonJsRunner extends BasicRunner {
     createModuleScope(requireFn, m, file) {
         return {
             ...this.baseModuleScope,
-            require: requireFn.bind(null, node_path.dirname(file.path)),
+            require: requireFn.bind(null, external_node_path_.default.dirname(file.path)),
             module: m,
             exports: m.exports,
-            __dirname: node_path.dirname(file.path),
+            __dirname: external_node_path_.default.dirname(file.path),
             __filename: file.path,
             define: cjs_define
         };
@@ -6157,12 +6539,11 @@ class CommonJsRunner extends BasicRunner {
     }
 }
 var type_EsmMode = ((EsmMode = {})[EsmMode.Unknown = 0] = "Unknown", EsmMode[EsmMode.Evaluated = 1] = "Evaluated", EsmMode[EsmMode.Unlinked = 2] = "Unlinked", EsmMode);
-let esm_require = createRequire(import.meta.url);
+let esm_require = (0, external_node_module_.createRequire)(import.meta.url);
 class EsmRunner extends CommonJsRunner {
     createRunner() {
-        var _this__options_compilerOptions_experiments;
         super.createRunner(), this.requirers.set('cjs', this.getRequire()), this.requirers.set('esm', this.createEsmRequirer());
-        let outputModule = null == (_this__options_compilerOptions_experiments = this._options.compilerOptions.experiments) ? void 0 : _this__options_compilerOptions_experiments.outputModule;
+        let outputModule = this._options.compilerOptions.experiments?.outputModule;
         this.requirers.set('entry', (currentDirectory, modulePath, context)=>{
             let file = this.getFile(modulePath, currentDirectory);
             return file ? outputModule && !file.path.endsWith('.cjs') ? this.requirers.get('esm')(currentDirectory, modulePath, {
@@ -6183,15 +6564,15 @@ class EsmRunner extends CommonJsRunner {
             let esm = esmCache.get(file.path);
             return (esm || (esm = new vm.SourceTextModule(file.content, {
                 identifier: `${esmIdentifier}-${file.path}`,
-                url: `${pathToFileURL(file.path).href}?${esmIdentifier}`,
+                url: `${(0, external_node_url_.pathToFileURL)(file.path).href}?${esmIdentifier}`,
                 initializeImportMeta: (meta, _)=>{
-                    meta.url = pathToFileURL(file.path).href;
+                    meta.url = (0, external_node_url_.pathToFileURL)(file.path).href;
                 },
-                importModuleDynamically: async (specifier, module)=>asModule(await _require(node_path.dirname(file.path), specifier, {
+                importModuleDynamically: async (specifier, module)=>asModule(await _require(external_node_path_.default.dirname(file.path), specifier, {
                         esmMode: type_EsmMode.Evaluated
                     }), module.context)
             }), esmCache.set(file.path, esm)), context.esmMode === type_EsmMode.Unlinked) ? esm : (async ()=>{
-                if (await esm.link(async (specifier, referencingModule)=>asModule(await _require(node_path.dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : fileURLToPath(referencingModule.url)), specifier, {
+                if (await esm.link(async (specifier, referencingModule)=>asModule(await _require(external_node_path_.default.dirname(referencingModule.identifier ? referencingModule.identifier.slice(esmIdentifier.length + 1) : (0, external_node_url_.fileURLToPath)(referencingModule.url)), specifier, {
                         esmMode: type_EsmMode.Unlinked
                     }), referencingModule.context, !0)), await esm.evaluate(), context.esmMode === type_EsmMode.Evaluated) return esm;
                 let ns = esm.namespace;
@@ -6201,6 +6582,10 @@ class EsmRunner extends CommonJsRunner {
     }
 }
 class BasicRunnerFactory {
+    name;
+    constructor(name){
+        this.name = name;
+    }
     create(options) {
         return this.createRunner(options);
     }
@@ -6212,15 +6597,6 @@ class BasicRunnerFactory {
         if ('web' === compilerOptions.target || 'webworker' === compilerOptions.target) throw Error(`${picocolors.dim('[rsbuild:runner]')} Not support run ${picocolors.yellow(compilerOptions.target)} resource in Rsbuild server`);
         return new EsmRunner(runnerOptions);
     }
-    constructor(name){
-        var key, value;
-        value = void 0, (key = "name") in this ? Object.defineProperty(this, key, {
-            value: value,
-            enumerable: !0,
-            configurable: !0,
-            writable: !0
-        }) : this[key] = value, this.name = name;
-    }
 }
 let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>{
     let runner = new BasicRunnerFactory(bundlePath).create(runnerFactoryOptions);
@@ -6232,17 +6608,14 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>{
         entrypoints: !0,
         outputPath: !0
     });
-    if (!(null == entrypoints ? void 0 : entrypoints[entryName])) throw Error(`${picocolors.dim('[rsbuild:loadBundle]')} Can't find entry: ${picocolors.yellow(entryName)}`);
+    if (!entrypoints?.[entryName]) throw Error(`${picocolors.dim('[rsbuild:loadBundle]')} Can't find entry: ${picocolors.yellow(entryName)}`);
     let { chunks: entryChunks = [] } = entrypoints[entryName], files = entryChunks.reduce((prev, entryChunkName)=>{
-        let chunk = null == chunks ? void 0 : chunks.find((chunk)=>{
-            var _chunk_names;
-            return chunk.entry && (null == (_chunk_names = chunk.names) ? void 0 : _chunk_names.includes(String(entryChunkName)));
-        });
-        return (null == chunk ? void 0 : chunk.files) ? prev.concat(chunk.files.filter((file)=>!file.endsWith('.css'))) : prev;
+        let chunk = chunks?.find((chunk)=>chunk.entry && chunk.names?.includes(String(entryChunkName)));
+        return chunk?.files ? prev.concat(chunk.files.filter((file)=>!file.endsWith('.css'))) : prev;
     }, []);
     if (0 === files.length) throw Error(`${picocolors.dim('[rsbuild:loadBundle]')} Failed to get bundle by entryName: ${picocolors.yellow(entryName)}`);
     if (files.length > 1) throw Error(`${picocolors.dim('[rsbuild:loadBundle]')} Only support load single entry chunk, but got ${picocolors.yellow(files.length)}: ${files.join(',')}`);
-    let allChunkFiles = (null == chunks ? void 0 : chunks.flatMap((c)=>c.files).map((file)=>join(outputPath, file))) || [];
+    let allChunkFiles = chunks?.flatMap((c)=>c.files).map((file)=>(0, external_node_path_.join)(outputPath, file)) || [];
     return await runner_run({
         bundlePath: files[0],
         dist: outputPath,
@@ -6254,7 +6627,7 @@ let runner_run = async ({ bundlePath, ...runnerFactoryOptions })=>{
     let cache = new WeakMap();
     return async (stats, entryName, utils)=>{
         let cachedEntries = cache.get(stats);
-        if (null == cachedEntries ? void 0 : cachedEntries[entryName]) return cachedEntries[entryName];
+        if (cachedEntries?.[entryName]) return cachedEntries[entryName];
         let res = await getter(stats, entryName, utils);
         return cache.set(stats, {
             ...cachedEntries || {},
@@ -6313,8 +6686,8 @@ async function setupWatchFiles(options) {
     return {
         async close () {
             await Promise.all([
-                null == closeDevFilesWatcher ? void 0 : closeDevFilesWatcher(),
-                null == serverFilesWatcher ? void 0 : serverFilesWatcher.close()
+                closeDevFilesWatcher?.(),
+                serverFilesWatcher?.close()
             ]);
         }
     };
@@ -6383,7 +6756,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
     let startCompile = async ()=>{
         let compiler = customCompiler || await createCompiler();
         if (!compiler) throw Error(`${picocolors.dim('[rsbuild:server]')} Failed to get compiler instance.`);
-        null == compiler || compiler.hooks.watchRun.tap('rsbuild:watchRun', ()=>{
+        compiler?.hooks.watchRun.tap('rsbuild:watchRun', ()=>{
             lastStats && (waitLastCompileDoneResolve && (waitLastCompileDoneResolve(), waitLastCompileDoneResolve = null), waitLastCompileDone = new Promise((resolve)=>{
                 waitLastCompileDoneResolve = resolve;
             }));
@@ -6416,9 +6789,9 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
             config,
             clearCache: !0
         }), cleanupGracefulShutdown = middlewareMode ? null : setupGracefulShutdown(), closeServer = async ()=>{
-        removeCleanup(closeServer), null == cleanupGracefulShutdown || cleanupGracefulShutdown(), await context.hooks.onCloseDevServer.callBatch(), await Promise.all([
-            null == devMiddlewares ? void 0 : devMiddlewares.close(),
-            null == fileWatcher ? void 0 : fileWatcher.close()
+        removeCleanup(closeServer), cleanupGracefulShutdown?.(), await context.hooks.onCloseDevServer.callBatch(), await Promise.all([
+            devMiddlewares?.close(),
+            fileWatcher?.close()
         ]);
     };
     middlewareMode || registerCleanup(closeServer);
@@ -6440,7 +6813,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
     }, cacheableLoadBundle = createCacheableFunction(loadBundle), cacheableTransformedHtml = createCacheableFunction((_stats, entryName, utils)=>((entryName, utils)=>{
             let { htmlPaths, distPath } = utils.environment, htmlPath = htmlPaths[entryName];
             if (!htmlPath) throw Error(`${picocolors.dim('[rsbuild:getTransformedHtml]')} Failed to get HTML file by entryName: ${picocolors.yellow(entryName)}`);
-            let fileName = join(distPath, htmlPath);
+            let fileName = (0, external_node_path_.join)(distPath, htmlPath);
             return utils.readFileSync(fileName);
         })(entryName, utils)), environmentAPI = Object.fromEntries(Object.entries(context.environments).map(([name, environment])=>[
             name,
@@ -6473,7 +6846,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
         middlewares,
         environments: environmentAPI,
         httpServer,
-        sockWrite: (type, data)=>null == compilationManager ? void 0 : compilationManager.socketServer.sockWrite({
+        sockWrite: (type, data)=>compilationManager?.socketServer.sockWrite({
                 type,
                 data
             }),
@@ -6527,7 +6900,7 @@ async function devServer_createDevServer(options, createCompiler, config, { comp
         context,
         postCallbacks
     })).middlewares))Array.isArray(item) ? middlewares.use(...item) : middlewares.use(item);
-    return null == compilationManager || compilationManager.watch(), logger.debug('create dev server done'), devServerAPI;
+    return compilationManager?.watch(), logger.debug('create dev server done'), devServerAPI;
 }
 let rspackProvider = ({ context, pluginManager, rsbuildOptions })=>{
     let createCompiler = async ()=>(await createCompiler_createCompiler({
@@ -6566,11 +6939,11 @@ let rspackProvider = ({ context, pluginManager, rsbuildOptions })=>{
                 rsbuildOptions
             }, options),
         async initConfigs (options) {
-            if (context.action && (null == options ? void 0 : options.action) && context.action !== options.action) throw Error(`\
+            if (context.action && options?.action && context.action !== options.action) throw Error(`\
 [rsbuild] initConfigs() can only be called with the same action type.
   - Expected: ${context.action}
-  - Actual: ${null == options ? void 0 : options.action}`);
-            (null == options ? void 0 : options.action) && (context.action = options.action);
+  - Actual: ${options?.action}`);
+            options?.action && (context.action = options.action);
             let { rspackConfigs } = await initConfigs({
                 context,
                 pluginManager,
@@ -6594,15 +6967,13 @@ let rspackProvider = ({ context, pluginManager, rsbuildOptions })=>{
         }
     };
 };
-function prodServer_define_property(obj, key, value) {
-    return key in obj ? Object.defineProperty(obj, key, {
-        value: value,
-        enumerable: !0,
-        configurable: !0,
-        writable: !0
-    }) : obj[key] = value, obj;
-}
 class RsbuildProdServer {
+    app;
+    options;
+    middlewares;
+    constructor(options, middlewares){
+        this.options = options, this.middlewares = middlewares;
+    }
     async onInit(app) {
         this.app = app, await this.applyDefaultMiddlewares();
     }
@@ -6642,15 +7013,12 @@ class RsbuildProdServer {
         });
         this.middlewares.use((req, res, next)=>{
             let url = req.url, assetPrefix = url && assetPrefixes.find((prefix)=>url.startsWith(prefix));
-            assetPrefix && (null == url ? void 0 : url.startsWith(assetPrefix)) ? (req.url = url.slice(assetPrefix.length), assetMiddleware(req, res, (...args)=>{
+            assetPrefix && url?.startsWith(assetPrefix) ? (req.url = url.slice(assetPrefix.length), assetMiddleware(req, res, (...args)=>{
                 req.url = url, next(...args);
             })) : assetMiddleware(req, res, next);
         });
     }
     async close() {}
-    constructor(options, middlewares){
-        prodServer_define_property(this, "app", void 0), prodServer_define_property(this, "options", void 0), prodServer_define_property(this, "middlewares", void 0), this.options = options, this.middlewares = middlewares;
-    }
 }
 async function startProdServer(context, config, { getPortSilently } = {}) {
     let { port, host, https, portTip } = await getServerConfig({
@@ -6730,7 +7098,6 @@ async function createRsbuild(options = {}) {
         ...'boolean' == typeof options.loadEnv ? {} : options.loadEnv
     }) : null, config = isFunction(options.rsbuildConfig) ? await options.rsbuildConfig() : options.rsbuildConfig || {};
     config.logLevel && (logger.level = config.logLevel), function(config, envs) {
-        var _config_performance;
         if (null !== envs && (config.source ||= {}, config.source.define = {
             ...envs.publicVars,
             ...config.source.define
@@ -6740,7 +7107,7 @@ async function createRsbuild(options = {}) {
                 paths: envs.filePaths,
                 type: 'reload-server'
             }
-        ], null == (_config_performance = config.performance) ? void 0 : _config_performance.buildCache))) {
+        ], config.performance?.buildCache))) {
             let { buildCache } = config.performance;
             !0 === buildCache ? config.performance.buildCache = {
                 buildDependencies: envs.filePaths
@@ -6819,7 +7186,7 @@ async function createRsbuild(options = {}) {
         }(context);
         function getNormalizedConfig(options) {
             if (context.normalizedConfig) {
-                if (null == options ? void 0 : options.environment) {
+                if (options?.environment) {
                     let config = context.normalizedConfig.environments[options.environment];
                     if (!config) throw Error(`${picocolors.dim('[rsbuild]')} Cannot find normalized config by environment: ${options.environment}.`);
                     return config;
@@ -6850,6 +7217,7 @@ async function createRsbuild(options = {}) {
         hooks.modifyBundlerChain.tap((chain, { target, environment })=>{
             let pluginName = 'RsbuildCorePlugin';
             chain.plugin(pluginName).use(class {
+                name = pluginName;
                 apply(compiler) {
                     for (let { handler, environment: pluginEnvironment } of (compiler.__rsbuildTransformer = transformer, resolveFns))(!pluginEnvironment || isEnvironmentMatch(pluginEnvironment, environment.name)) && compiler.hooks.compilation.tap(pluginName, (compilation, { normalModuleFactory })=>{
                         normalModuleFactory.hooks.resolve.tapPromise(pluginName, async (resolveData)=>handler({
@@ -6876,15 +7244,6 @@ async function createRsbuild(options = {}) {
                             }));
                     });
                 }
-                constructor(){
-                    var key;
-                    (key = "name") in this ? Object.defineProperty(this, key, {
-                        value: pluginName,
-                        enumerable: !0,
-                        configurable: !0,
-                        writable: !0
-                    }) : this[key] = pluginName;
-                }
             });
         });
         let onExitListened = !1, onExit = (cb)=>{
@@ -6916,7 +7275,7 @@ async function createRsbuild(options = {}) {
                             if (descriptor.targets && !descriptor.targets.includes(target) || descriptor.environments && !descriptor.environments.includes(environment.name)) return;
                             let rule = chain.module.rule(id);
                             descriptor.test && rule.test(descriptor.test), descriptor.resourceQuery && rule.resourceQuery(descriptor.resourceQuery), descriptor.layer && rule.layer(descriptor.layer), descriptor.issuerLayer && rule.issuerLayer(descriptor.issuerLayer), descriptor.issuer && rule.issuer(descriptor.issuer), descriptor.with && rule.with(descriptor.with), descriptor.mimetype && rule.mimetype(descriptor.mimetype), descriptor.order && 'default' !== descriptor.order ? rule.enforce(descriptor.order) : descriptor.enforce && rule.enforce(descriptor.enforce);
-                            let loaderPath = join(LOADER_PATH, descriptor.raw ? 'transformRawLoader.mjs' : 'transformLoader.mjs');
+                            let loaderName = descriptor.raw ? 'transformRawLoader.mjs' : 'transformLoader.mjs', loaderPath = (0, external_node_path_.join)(LOADER_PATH, loaderName);
                             rule.use(id).loader(loaderPath).options({
                                 id,
                                 getEnvironment: ()=>environment
@@ -6946,6 +7305,7 @@ async function createRsbuild(options = {}) {
                 onCloseBuild: hooks.onCloseBuild.tap,
                 onBeforeBuild: hooks.onBeforeBuild.tap,
                 onCloseDevServer: hooks.onCloseDevServer.tap,
+                onBeforeDevCompile: hooks.onBeforeDevCompile.tap,
                 onDevCompileDone: hooks.onDevCompileDone.tap,
                 onAfterCreateCompiler: hooks.onAfterCreateCompiler.tap,
                 onAfterStartDevServer: hooks.onAfterStartDevServer.tap,
@@ -7082,7 +7442,7 @@ async function createRsbuild(options = {}) {
                     if (!1 === buildCache) return;
                     cacheEnabled = !0;
                     let { context } = api, cacheConfig = 'boolean' == typeof buildCache ? {} : buildCache, cacheDirectory = function({ cacheDirectory }, context) {
-                        return cacheDirectory ? external_node_path_isAbsolute(cacheDirectory) ? cacheDirectory : join(context.rootPath, cacheDirectory) : join(context.cachePath, context.bundlerType);
+                        return cacheDirectory ? (0, external_node_path_.isAbsolute)(cacheDirectory) ? cacheDirectory : (0, external_node_path_.join)(context.rootPath, cacheDirectory) : (0, external_node_path_.join)(context.cachePath, context.bundlerType);
                     }(cacheConfig, context), buildDependencies = await getBuildDependencies(context, config, environment, cacheConfig.buildDependencies ? {
                         userBuildDependencies: cacheConfig.buildDependencies
                     } : {});
@@ -7140,17 +7500,16 @@ async function createRsbuild(options = {}) {
                 api.modifyBundlerChain((chain, { CHAIN_ID, isDev, isProd, isServer, environment, rspack })=>{
                     var jsAsync;
                     let { distPath, config } = environment, publicPath = function({ isDev, config, context }) {
-                        var _context_devServer, _context_devServer1, _context_devServer2;
                         let { dev, output, server } = config, publicPath = DEFAULT_ASSET_PREFIX;
                         if (isDev) {
                             if ('string' == typeof dev.assetPrefix) publicPath = dev.assetPrefix;
                             else if (dev.assetPrefix) {
-                                let protocol = (null == (_context_devServer1 = context.devServer) ? void 0 : _context_devServer1.https) ? 'https' : 'http', hostname = (null == (_context_devServer2 = context.devServer) ? void 0 : _context_devServer2.hostname) || DEFAULT_DEV_HOST;
+                                let protocol = context.devServer?.https ? 'https' : 'http', hostname = context.devServer?.hostname || DEFAULT_DEV_HOST;
                                 publicPath = hostname === DEFAULT_DEV_HOST ? `${protocol}://localhost:<port>/` : `${protocol}://${hostname}:<port>/`, server.base && '/' !== server.base && (publicPath = urlJoin(publicPath, server.base));
                             }
                         } else 'string' == typeof output.assetPrefix && (publicPath = output.assetPrefix);
                         let defaultPort = server.port ?? 3000;
-                        return formatPublicPath(replacePortPlaceholder(publicPath, isDev ? (null == (_context_devServer = context.devServer) ? void 0 : _context_devServer.port) ?? defaultPort : defaultPort));
+                        return formatPublicPath(replacePortPlaceholder(publicPath, isDev ? context.devServer?.port ?? defaultPort : defaultPort));
                     }({
                         config,
                         isDev,
@@ -7158,11 +7517,11 @@ async function createRsbuild(options = {}) {
                     }), jsPath = config.output.distPath.js, jsAsyncPath = void 0 !== (jsAsync = config.output.distPath.jsAsync) ? jsAsync : isServer ? jsPath : jsPath ? `${jsPath}/async` : 'async', jsFilename = getFilename(config, 'js', isProd, isServer), isJsFilenameFn = 'function' == typeof jsFilename;
                     if (chain.output.path(distPath).filename(isJsFilenameFn ? (...args)=>{
                         let name = jsFilename(...args);
-                        return posix.join(jsPath, name);
-                    } : posix.join(jsPath, jsFilename)).chunkFilename(isJsFilenameFn ? (...args)=>{
+                        return external_node_path_.posix.join(jsPath, name);
+                    } : external_node_path_.posix.join(jsPath, jsFilename)).chunkFilename(isJsFilenameFn ? (...args)=>{
                         let name = jsFilename(...args);
-                        return posix.join(jsAsyncPath, name);
-                    } : posix.join(jsAsyncPath, jsFilename)).publicPath(publicPath).pathinfo(!1).hashFunction('xxhash64'), isServer && chain.output.library({
+                        return external_node_path_.posix.join(jsAsyncPath, name);
+                    } : external_node_path_.posix.join(jsAsyncPath, jsFilename)).publicPath(publicPath).pathinfo(!1).hashFunction('xxhash64'), isServer && chain.output.library({
                         type: 'commonjs2',
                         ...chain.output.get('library') || {}
                     }), config.output.copy && 'rspack' === api.context.bundlerType) {
@@ -7207,7 +7566,7 @@ async function createRsbuild(options = {}) {
                                     continue;
                                 }
                                 try {
-                                    pkgPath = dirname(resolve_require.resolve(`${pkgName}/package.json`, {
+                                    pkgPath = (0, external_node_path_.dirname)(resolve_require.resolve(`${pkgName}/package.json`, {
                                         paths: [
                                             rootPath
                                         ]
@@ -7222,8 +7581,8 @@ async function createRsbuild(options = {}) {
                                     let trailing = [
                                         'node_modules',
                                         ...pkgName.split('/')
-                                    ].join(sep);
-                                    for(; !pkgPath.endsWith(trailing) && pkgPath.includes('node_modules');)pkgPath = dirname(pkgPath);
+                                    ].join(external_node_path_.sep);
+                                    for(; !pkgPath.endsWith(trailing) && pkgPath.includes('node_modules');)pkgPath = (0, external_node_path_.dirname)(pkgPath);
                                 } catch  {
                                     logger.debug(`${picocolors.dim('[rsbuild:resolve]')} The package ${picocolors.yellow(pkgName)} is not resolved in the project, dedupe option for ${picocolors.yellow(pkgName)} will be ignored.`);
                                     continue;
@@ -7290,7 +7649,7 @@ async function createRsbuild(options = {}) {
                                 } : void 0;
                             })(environment, params.isDev)),
                         (()=>{
-                            let { rootPath, distPath } = api.context, config = api.getNormalizedConfig(), targetPath = join(distPath, RSBUILD_OUTPUTS_PATH), { enable } = normalizeCleanDistPath(config.output.cleanDistPath);
+                            let { rootPath, distPath } = api.context, config = api.getNormalizedConfig(), targetPath = (0, external_node_path_.join)(distPath, RSBUILD_OUTPUTS_PATH), { enable } = normalizeCleanDistPath(config.output.cleanDistPath);
                             if (!0 === enable || 'auto' === enable && isStrictSubdir(rootPath, targetPath)) return {
                                 path: targetPath
                             };
@@ -7317,8 +7676,8 @@ async function createRsbuild(options = {}) {
                         let distDir = config.output.distPath[assetType], filename = getFilename(config, assetType, isProd);
                         return 'function' == typeof filename ? (...args)=>{
                             let name = filename(...args);
-                            return node_path.posix.join(distDir, name);
-                        } : node_path.posix.join(distDir, filename);
+                            return external_node_path_.default.posix.join(distDir, name);
+                        } : external_node_path_.default.posix.join(distDir, filename);
                     }, createAssetRule = (assetType, exts, emit)=>{
                         let regExp = function(exts) {
                             let matcher = exts.map((ext)=>ext.trim()).map((ext)=>ext.startsWith('.') ? ext.slice(1) : ext).join('|');
@@ -7485,10 +7844,7 @@ async function createRsbuild(options = {}) {
                         ];
                         if (crossorigin) {
                             let formattedCrossorigin = !0 === crossorigin ? 'anonymous' : crossorigin;
-                            for (let tag of allTags){
-                                var _tag_attrs, _tag_attrs1;
-                                ("script" === tag.tag && (null == (_tag_attrs = tag.attrs) ? void 0 : _tag_attrs.src) || 'link' === tag.tag && (null == (_tag_attrs1 = tag.attrs) ? void 0 : _tag_attrs1.rel) === 'stylesheet') && (tag.attrs.crossorigin ??= formattedCrossorigin);
-                            }
+                            for (let tag of allTags)("script" === tag.tag && tag.attrs?.src || 'link' === tag.tag && tag.attrs?.rel === 'stylesheet') && (tag.attrs.crossorigin ??= formattedCrossorigin);
                         }
                         return {
                             headTags,
@@ -7521,7 +7877,7 @@ async function createRsbuild(options = {}) {
                                 };
                                 return iconFormatMap.set(src, formatted), formatted;
                             }
-                            let absolutePath = node_path.isAbsolute(src) ? src : node_path.join(api.context.rootPath, src), relativePath = node_path.posix.join(distDir, node_path.basename(absolutePath)), formatted = {
+                            let absolutePath = external_node_path_.default.isAbsolute(src) ? src : external_node_path_.default.join(api.context.rootPath, src), relativePath = external_node_path_.default.posix.join(distDir, external_node_path_.default.basename(absolutePath)), formatted = {
                                 ...icon,
                                 sizes,
                                 src: ensureAssetPrefix(relativePath, publicPath),
@@ -7602,7 +7958,7 @@ async function createRsbuild(options = {}) {
             name: 'rsbuild:wasm',
             setup (api) {
                 api.modifyBundlerChain((chain, { CHAIN_ID, environment, isProd })=>{
-                    let { config } = environment, distPath = config.output.distPath.wasm, filename = posix.join(distPath, getFilename(config, 'wasm', isProd));
+                    let { config } = environment, distPath = config.output.distPath.wasm, filename = external_node_path_.posix.join(distPath, 'webpack' === api.context.bundlerType ? '[hash].module.wasm' : getFilename(config, 'wasm', isProd));
                     chain.experiments({
                         ...chain.get('experiments'),
                         asyncWebAssembly: !0
@@ -7639,7 +7995,7 @@ async function createRsbuild(options = {}) {
                     let name = ((resourcePath)=>{
                         let basename = '';
                         if (resourcePath) {
-                            let parsed = node_path.parse(resourcePath);
+                            let parsed = external_node_path_.default.parse(resourcePath);
                             parsed.dir && (basename = parsed.name);
                         }
                         return basename ? `${basename}.node` : null;
@@ -7713,14 +8069,13 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             });
                             rule.use(CHAIN_ID.USE.STYLE).loader(getCompiledPath('style-loader')).options(styleLoaderOptions);
                         } else rule.use(CHAIN_ID.USE.MINI_CSS_EXTRACT).loader((cssExtractPlugin || rspack_rspack.CssExtractRspackPlugin).loader).options(config.tools.cssExtract.loaderOptions);
-                        else rule.use(CHAIN_ID.USE.IGNORE_CSS).loader(node_path.join(LOADER_PATH, 'ignoreCssLoader.mjs'));
+                        else rule.use(CHAIN_ID.USE.IGNORE_CSS).loader(external_node_path_.default.join(LOADER_PATH, 'ignoreCssLoader.mjs'));
                         let importLoaders = 0, updateRules = (callback)=>{
                             callback(rule, 'normal'), callback(inlineRule, 'inline');
                         }, cssLoaderPath = getCompiledPath('css-loader');
                         if (updateRules((rule)=>{
                             rule.use(CHAIN_ID.USE.CSS).loader(cssLoaderPath);
                         }), emitCss) {
-                            var _postcssLoaderOptions_postcssOptions_plugins, _postcssLoaderOptions_postcssOptions;
                             if ('rspack' === api.context.bundlerType && !1 !== config.tools.lightningcssLoader) {
                                 importLoaders++;
                                 let { minifyCss } = parseMinifyOptions(config);
@@ -7734,7 +8089,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                 root: api.context.rootPath,
                                 postcssrcCache
                             });
-                            if ('function' == typeof postcssLoaderOptions.postcssOptions || (null == (_postcssLoaderOptions_postcssOptions = postcssLoaderOptions.postcssOptions) || null == (_postcssLoaderOptions_postcssOptions_plugins = _postcssLoaderOptions_postcssOptions.plugins) ? void 0 : _postcssLoaderOptions_postcssOptions_plugins.length)) {
+                            if ('function' == typeof postcssLoaderOptions.postcssOptions || postcssLoaderOptions.postcssOptions?.plugins?.length) {
                                 importLoaders++;
                                 let postcssLoaderPath = getCompiledPath('postcss-loader');
                                 updateRules((rule)=>{
@@ -7793,12 +8148,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                 {
                                     filename: isCssFilenameFn ? (...args)=>{
                                         let name = cssFilename(...args);
-                                        return posix.join(cssPath, name);
-                                    } : posix.join(cssPath, cssFilename),
+                                        return external_node_path_.posix.join(cssPath, name);
+                                    } : external_node_path_.posix.join(cssPath, cssFilename),
                                     chunkFilename: isCssFilenameFn ? (...args)=>{
                                         let name = cssFilename(...args);
-                                        return posix.join(cssAsyncPath, name);
-                                    } : posix.join(cssAsyncPath, cssFilename),
+                                        return external_node_path_.posix.join(cssAsyncPath, name);
+                                    } : external_node_path_.posix.join(cssAsyncPath, cssFilename),
                                     ...extractPluginOptions
                                 }
                             ]);
@@ -7827,7 +8182,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                     pure_funcs: pureFuncs
                                 };
                             }
-                            switch(config.output.legalComments){
+                            if (config.output.legalComments) switch(config.output.legalComments){
                                 case 'inline':
                                     options.minimizerOptions.format.comments = 'some', options.extractComments = !1;
                                     break;
@@ -7883,7 +8238,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 api.modifyBundlerChain({
                     order: 'pre',
                     handler: (chain, { CHAIN_ID, isDev, target, environment })=>{
-                        let { config, browserslist } = environment, cacheRoot = node_path.join(api.context.cachePath, '.swc'), rule = chain.module.rule(CHAIN_ID.RULE.JS).test(SCRIPT_REGEX).type("javascript/auto").dependency({
+                        let { config, browserslist } = environment, cacheRoot = external_node_path_.default.join(api.context.cachePath, '.swc'), rule = chain.module.rule(CHAIN_ID.RULE.JS).test(SCRIPT_REGEX).type("javascript/auto").dependency({
                             not: 'url'
                         }).resourceQuery({
                             not: RAW_QUERY_REGEX
@@ -7946,7 +8301,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                 for (let item of helpers_castArray(options))isFunction(item) ? imports = item(imports) ?? imports : imports.push(item);
                                 return imports;
                             })(pluginImport);
-                            (null == finalPluginImport ? void 0 : finalPluginImport.length) && (swcConfig.rspackExperiments ??= {}, swcConfig.rspackExperiments.import ??= [], swcConfig.rspackExperiments.import.push(...finalPluginImport));
+                            finalPluginImport?.length && (swcConfig.rspackExperiments ??= {}, swcConfig.rspackExperiments.import ??= [], swcConfig.rspackExperiments.import.push(...finalPluginImport));
                         }(swcConfig, config.source.transformImport), function(swcConfig, config) {
                             swcConfig.jsc ||= {}, swcConfig.jsc.transform ||= {};
                             let { version } = config.source.decorators;
@@ -7973,7 +8328,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                         } catch  {
                                             return '3';
                                         }
-                                    })(coreJsPath), coreJsDir = node_path.dirname(coreJsPath);
+                                    })(coreJsPath), coreJsDir = external_node_path_.default.dirname(coreJsPath);
                                     return swcConfig.env.coreJs = version, 'usage' === polyfillMode && (swcConfig.env.shippedProposals = !0), coreJsDir;
                                 }(swcConfig, polyfillMode);
                                 for (let item of [
@@ -7992,6 +8347,24 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 });
             }
         },
+        {
+            name: 'rsbuild:esm',
+            setup (api) {
+                api.modifyBundlerChain((chain, { environment, isServer })=>{
+                    let { config } = environment;
+                    if (config.output.module) {
+                        if (!isServer) throw Error('[rsbuild:config] `output.module` is only supported for Node.js targets.');
+                        chain.output.module(!0).chunkFormat('module').chunkLoading('import').workerChunkLoading('import').library({
+                            ...chain.output.get('library'),
+                            type: 'module'
+                        }), chain.experiments({
+                            ...chain.get('experiments'),
+                            outputModule: !0
+                        });
+                    }
+                });
+            }
+        },
         {
             name: 'rsbuild:externals',
             setup (api) {
@@ -8007,7 +8380,6 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             name: 'rsbuild:split-chunks',
             setup (api) {
                 api.modifyBundlerChain(async (chain, { environment, isServer, isWebWorker })=>{
-                    var _config_moduleFederation_options, _config_moduleFederation;
                     if (isServer || isWebWorker) {
                         chain.optimization.splitChunks(!1), isWebWorker && chain.module.parser.merge({
                             javascript: {
@@ -8017,7 +8389,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         return;
                     }
                     let { config } = environment, defaultConfig = {
-                        chunks: (null == (_config_moduleFederation = config.moduleFederation) || null == (_config_moduleFederation_options = _config_moduleFederation.options) ? void 0 : _config_moduleFederation_options.exposes) ? 'async' : 'all',
+                        chunks: config.moduleFederation?.options?.exposes ? 'async' : 'all',
                         cacheGroups: {}
                     };
                     'webpack' === api.context.bundlerType && (defaultConfig.enforceSizeThreshold = 50000);
@@ -8070,47 +8442,46 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         headTags,
                         bodyTags
                     };
-                    let publicPath = getPublicPathFromCompiler(compiler), updateTag = (tag)=>{
-                        var config;
-                        return config = environment.config, "script" === tag.tag ? ((publicPath, tag, compilation, scriptTests, config)=>{
-                            var _tag_attrs;
-                            let { assets } = compilation;
-                            if (!((null == (_tag_attrs = tag.attrs) ? void 0 : _tag_attrs.src) && 'string' == typeof tag.attrs.src)) return tag;
-                            let { src, ...otherAttrs } = tag.attrs, scriptName = publicPath ? src.replace(publicPath, '') : src, asset = assets[scriptName];
-                            if (null == asset || !matchTests(scriptName, asset, scriptTests)) return tag;
-                            let ret = {
-                                tag: "script",
-                                children: updateSourceMappingURL({
-                                    source: asset.source().toString(),
-                                    compilation,
-                                    publicPath,
-                                    type: 'js',
-                                    config
-                                }),
-                                attrs: {
-                                    ...otherAttrs
-                                }
-                            };
-                            return inlinedAssets.add(scriptName), ret;
-                        })(publicPath, tag, compilation, scriptTests, config) : 'link' === tag.tag && tag.attrs && 'stylesheet' === tag.attrs.rel ? ((publicPath, tag, compilation, styleTests, config)=>{
-                            var _tag_attrs;
-                            let { assets } = compilation;
-                            if (!((null == (_tag_attrs = tag.attrs) ? void 0 : _tag_attrs.href) && 'string' == typeof tag.attrs.href)) return tag;
-                            let linkName = publicPath ? tag.attrs.href.replace(publicPath, '') : tag.attrs.href, asset = assets[linkName];
-                            if (null == asset || !matchTests(linkName, asset, styleTests)) return tag;
-                            let ret = {
-                                tag: 'style',
-                                children: updateSourceMappingURL({
-                                    source: asset.source().toString(),
-                                    compilation,
-                                    publicPath,
-                                    type: 'css',
-                                    config
-                                })
-                            };
-                            return inlinedAssets.add(linkName), ret;
-                        })(publicPath, tag, compilation, styleTests, config) : tag;
-                    };
+                    let publicPath = getPublicPathFromCompiler(compiler), updateTag = (tag)=>((publicPath, tag, compilation, scriptTests, styleTests, config)=>{
+                            if ("script" === tag.tag) return ((publicPath, tag, compilation, scriptTests, config)=>{
+                                let { assets } = compilation;
+                                if (!(tag.attrs?.src && 'string' == typeof tag.attrs.src)) return tag;
+                                let { src, ...otherAttrs } = tag.attrs, scriptName = publicPath ? src.replace(publicPath, '') : src, asset = assets[scriptName];
+                                if (null == asset || !matchTests(scriptName, asset, scriptTests)) return tag;
+                                let ret = {
+                                    tag: "script",
+                                    children: updateSourceMappingURL({
+                                        source: asset.source().toString(),
+                                        compilation,
+                                        publicPath,
+                                        type: 'js',
+                                        config
+                                    }),
+                                    attrs: {
+                                        ...otherAttrs
+                                    }
+                                };
+                                return inlinedAssets.add(scriptName), ret;
+                            })(publicPath, tag, compilation, scriptTests, config);
+                            if ('link' === tag.tag && tag.attrs && 'stylesheet' === tag.attrs.rel) {
+                                let { assets } = compilation;
+                                if (!(tag.attrs?.href && 'string' == typeof tag.attrs.href)) return tag;
+                                let linkName = publicPath ? tag.attrs.href.replace(publicPath, '') : tag.attrs.href, asset = assets[linkName];
+                                if (null == asset || !matchTests(linkName, asset, styleTests)) return tag;
+                                let ret = {
+                                    tag: 'style',
+                                    children: updateSourceMappingURL({
+                                        source: asset.source().toString(),
+                                        compilation: compilation,
+                                        publicPath: publicPath,
+                                        type: 'css',
+                                        config: config
+                                    })
+                                };
+                                return inlinedAssets.add(linkName), ret;
+                            }
+                            return tag;
+                        })(publicPath, tag, compilation, scriptTests, styleTests, environment.config);
                     return {
                         headTags: headTags.map(updateTag),
                         bodyTags: bodyTags.map(updateTag)
@@ -8124,14 +8495,8 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 api.onBeforeCreateCompiler(async ({ bundlerConfigs })=>{
                     let packagePath, module;
                     if ('true' !== process.env.RSDOCTOR) return;
-                    let isRspack = 'rspack' === api.context.bundlerType, pluginName = isRspack ? 'RsdoctorRspackPlugin' : 'RsdoctorWebpackPlugin', isRsdoctorPlugin = (plugin)=>{
-                        var _plugin_constructor;
-                        return (null == plugin ? void 0 : plugin.isRsdoctorPlugin) === !0 || (null == plugin || null == (_plugin_constructor = plugin.constructor) ? void 0 : _plugin_constructor.name) === pluginName;
-                    };
-                    for (let config of bundlerConfigs){
-                        var _config_plugins;
-                        if (null == (_config_plugins = config.plugins) ? void 0 : _config_plugins.some((plugin)=>isRsdoctorPlugin(plugin))) return;
-                    }
+                    let isRspack = 'rspack' === api.context.bundlerType, pluginName = isRspack ? 'RsdoctorRspackPlugin' : 'RsdoctorWebpackPlugin', isRsdoctorPlugin = (plugin)=>plugin?.isRsdoctorPlugin === !0 || plugin?.constructor?.name === pluginName;
+                    for (let config of bundlerConfigs)if (config.plugins?.some((plugin)=>isRsdoctorPlugin(plugin))) return;
                     let packageName = isRspack ? '@rsdoctor/rspack-plugin' : '@rsdoctor/webpack-plugin';
                     try {
                         packagePath = rsdoctor_require.resolve(packageName, {
@@ -8144,7 +8509,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         return;
                     }
                     try {
-                        let moduleURL = 'win32' === process.platform ? pathToFileURL(packagePath).href : packagePath;
+                        let moduleURL = 'win32' === process.platform ? (0, external_node_url_.pathToFileURL)(packagePath).href : packagePath;
                         module = await import(moduleURL);
                     } catch  {
                         logger.error(`\`process.env.RSDOCTOR\` enabled, but failed to load ${picocolors.bold(picocolors.yellow(packageName))} module.`);
@@ -8219,10 +8584,8 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                 api.modifyRsbuildConfig({
                     order: 'post',
                     handler: (rsbuildConfig)=>{
-                        var _rsbuildConfig_performance, _config_performance;
                         let applyBundleAnalyzeConfig = (config)=>{
-                            var _config_performance;
-                            (null == (_config_performance = config.performance) ? void 0 : _config_performance.bundleAnalyze) ? config.performance.bundleAnalyze = {
+                            config.performance?.bundleAnalyze ? config.performance.bundleAnalyze = {
                                 generateStatsFile: !0,
                                 ...config.performance.bundleAnalyze || {}
                             } : (config.performance ??= {}, config.performance.bundleAnalyze = {
@@ -8230,8 +8593,8 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                 generateStatsFile: !0
                             });
                         };
-                        if (null == (_rsbuildConfig_performance = rsbuildConfig.performance) ? void 0 : _rsbuildConfig_performance.profile) applyBundleAnalyzeConfig(rsbuildConfig);
-                        else if (rsbuildConfig.environments) for (let config of Object.values(rsbuildConfig.environments))(null == (_config_performance = config.performance) ? void 0 : _config_performance.profile) && applyBundleAnalyzeConfig(config);
+                        if (rsbuildConfig.performance?.profile) applyBundleAnalyzeConfig(rsbuildConfig);
+                        else if (rsbuildConfig.environments) for (let config of Object.values(rsbuildConfig.environments))config.performance?.profile && applyBundleAnalyzeConfig(config);
                     }
                 }), api.modifyBundlerChain((chain, { environment })=>{
                     let { config } = environment, { profile } = config.performance;
@@ -8267,21 +8630,18 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             setup (api) {
                 let onStartServer = ({ port, routes })=>{
                     let config = api.getNormalizedConfig();
-                    if (config.server.open) {
-                        var _api_context_devServer;
-                        server_open_open({
-                            https: null == (_api_context_devServer = api.context.devServer) ? void 0 : _api_context_devServer.https,
-                            port,
-                            routes,
-                            config
-                        });
-                    }
+                    config.server.open && server_open_open({
+                        https: api.context.devServer?.https,
+                        port,
+                        routes,
+                        config
+                    });
                 };
                 api.onAfterStartDevServer(onStartServer), api.onAfterStartProdServer(onStartServer), api.onBeforeBuild(async ({ isFirstCompile, environments })=>{
                     if (isFirstCompile) for (let publicDir of normalizePublicDirs(api.getNormalizedConfig().server.publicDir)){
                         let { name, copyOnBuild } = publicDir;
                         if (!1 === copyOnBuild || !name) continue;
-                        let normalizedPath = external_node_path_isAbsolute(name) ? name : join(api.context.rootPath, name);
+                        let normalizedPath = (0, external_node_path_.isAbsolute)(name) ? name : (0, external_node_path_.join)(api.context.rootPath, name);
                         if (!node_fs.existsSync(normalizedPath)) continue;
                         let distPaths = dedupeNestedPaths(Object.values(environments).filter(({ config })=>!0 === copyOnBuild || 'auto' === copyOnBuild && 'node' !== config.output.target).map(({ distPath })=>distPath));
                         try {
@@ -8333,7 +8693,6 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                     return file.path;
                                 }), entries = {};
                                 for (let [name, chunkFiles] of chunkEntries){
-                                    var _files_find;
                                     let assets = new Set(), initialJS = [], asyncJS = [], initialCSS = [], asyncCSS = [];
                                     for (let file of chunkFiles){
                                         file.isInitial ? file.path.endsWith('.css') ? initialCSS.push(file.path) : initialJS.push(file.path) : file.path.endsWith('.css') ? asyncCSS.push(file.path) : asyncJS.push(file.path);
@@ -8342,7 +8701,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                                     }
                                     let entryManifest = {};
                                     assets.size && (entryManifest.assets = Array.from(assets));
-                                    let htmlPath = null == (_files_find = files.find((f)=>f.name === htmlPaths[name])) ? void 0 : _files_find.path;
+                                    let htmlPath = files.find((f)=>f.name === htmlPaths[name])?.path;
                                     htmlPath && (entryManifest.html = [
                                         htmlPath
                                     ]), initialJS.length && (entryManifest.initial = {
@@ -8385,14 +8744,12 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             setup (api) {
                 'webpack' !== api.context.bundlerType && (api.modifyRsbuildConfig((config)=>{
                     let { moduleFederation } = config;
-                    if ((null == moduleFederation ? void 0 : moduleFederation.options) && moduleFederation.options.exposes) {
-                        var _userConfig_server, _config_server, _config_dev_client, _userConfig_dev, _config_server1;
+                    if (moduleFederation?.options && moduleFederation.options.exposes) {
                         let userConfig = api.getRsbuildConfig('original');
-                        config.dev ||= {}, config.server ||= {}, (null == (_userConfig_server = userConfig.server) ? void 0 : _userConfig_server.cors) === void 0 && (config.server.cors = !0), (null == (_config_server = config.server) ? void 0 : _config_server.port) && !(null == (_config_dev_client = config.dev.client) ? void 0 : _config_dev_client.port) && (config.dev.client ||= {}, config.dev.client.port = config.server.port), (null == (_userConfig_dev = userConfig.dev) ? void 0 : _userConfig_dev.assetPrefix) === void 0 && config.dev.assetPrefix === (null == (_config_server1 = config.server) ? void 0 : _config_server1.base) && (config.dev.assetPrefix = !0);
+                        config.dev ||= {}, config.server ||= {}, userConfig.server?.cors === void 0 && (config.server.cors = !0), config.server?.port && !config.dev.client?.port && (config.dev.client ||= {}, config.dev.client.port = config.server.port), userConfig.dev?.assetPrefix === void 0 && config.dev.assetPrefix === config.server?.base && (config.dev.assetPrefix = !0);
                     }
                 }), api.modifyEnvironmentConfig((config)=>{
-                    var _config_moduleFederation, _config_performance_chunkSplit, _config_performance;
-                    (null == (_config_moduleFederation = config.moduleFederation) ? void 0 : _config_moduleFederation.options) && ((null == (_config_performance = config.performance) || null == (_config_performance_chunkSplit = _config_performance.chunkSplit) ? void 0 : _config_performance_chunkSplit.strategy) === 'split-by-experience' && (config.performance.chunkSplit = {
+                    config.moduleFederation?.options && (config.performance?.chunkSplit?.strategy === 'split-by-experience' && (config.performance.chunkSplit = {
                         ...config.performance.chunkSplit,
                         strategy: 'custom'
                     }), config.source.include = [
@@ -8400,9 +8757,8 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                         /@module-federation[\\/]/
                     ]);
                 }), api.modifyBundlerChain((chain, { CHAIN_ID, target, environment })=>{
-                    var _config_moduleFederation;
                     let { config } = environment;
-                    if (!(null == (_config_moduleFederation = config.moduleFederation) ? void 0 : _config_moduleFederation.options) || 'web' !== target) return;
+                    if (!config.moduleFederation?.options || 'web' !== target) return;
                     let { options } = config.moduleFederation;
                     chain.plugin(CHAIN_ID.PLUGIN.MODULE_FEDERATION).use(rspack_rspack.container.ModuleFederationPlugin, [
                         options
@@ -8434,28 +8790,18 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             apply: 'serve',
             setup (api) {
                 api.modifyBundlerChain((chain, { environment, target })=>{
-                    var _config_dev;
-                    if ('web' !== target) return;
-                    let { config } = environment, options = null == (_config_dev = config.dev) ? void 0 : _config_dev.lazyCompilation;
+                    if ('web' !== target || 'webpack' === api.context.bundlerType) return;
+                    let { config } = environment, options = config.dev?.lazyCompilation;
                     if (options) {
-                        if (!0 === options && Object.keys(chain.entryPoints.entries() || {}).length <= 1) return void chain.experiments({
-                            ...chain.get('experiments'),
-                            lazyCompilation: {
-                                entries: !1,
-                                imports: !0
-                            }
-                        });
-                        if ('object' == typeof options && 'string' == typeof options.serverUrl && api.context.devServer) return void chain.experiments({
-                            ...chain.get('experiments'),
-                            lazyCompilation: {
-                                ...options,
-                                serverUrl: replacePortPlaceholder(options.serverUrl, api.context.devServer.port)
-                            }
+                        if (!0 === options && Object.keys(chain.entryPoints.entries() || {}).length <= 1) return void chain.lazyCompilation({
+                            entries: !1,
+                            imports: !0
                         });
-                        chain.experiments({
-                            ...chain.get('experiments'),
-                            lazyCompilation: options
+                        if ('object' == typeof options && 'string' == typeof options.serverUrl && api.context.devServer) return void chain.lazyCompilation({
+                            ...options,
+                            serverUrl: replacePortPlaceholder(options.serverUrl, api.context.devServer.port)
                         });
+                        chain.lazyCompilation(options);
                     }
                 });
             }
@@ -8478,7 +8824,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             hashFuncNames: [
                                 algorithm
                             ],
-                            htmlPlugin: node_path.join(COMPILED_PATH, 'html-rspack-plugin/index.js')
+                            htmlPlugin: external_node_path_.default.join(COMPILED_PATH, 'html-rspack-plugin/index.js')
                         }
                     ]);
                 });
@@ -8496,7 +8842,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                     let environmentList = Object.values(environments);
                     applyToCompiler(compiler, (compiler, index)=>{
                         let nonce = nonces[index], environment = environmentList.find((item)=>item.index === index);
-                        if (!Object.keys((null == environment ? void 0 : environment.htmlPaths) ?? {}).length || !nonce) return;
+                        if (!Object.keys(environment?.htmlPaths ?? {}).length || !nonce) return;
                         let injectCode = createVirtualModule(`__webpack_nonce__ = "${nonce}";`);
                         new compiler.webpack.EntryPlugin(compiler.context, injectCode, {
                             name: void 0
@@ -8509,10 +8855,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
                             ...headTags,
                             ...bodyTags
                         ];
-                        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.rel) === 'preload' && (null == (_tag_attrs1 = tag.attrs) ? void 0 : _tag_attrs1.as) === "script") && (tag.attrs ??= {}, tag.attrs.nonce = nonce);
-                        }
+                        if (nonce) for (let tag of allTags)("script" === tag.tag || 'style' === tag.tag || 'link' === tag.tag && tag.attrs?.rel === 'preload' && tag.attrs?.as === "script") && (tag.attrs ??= {}, tag.attrs.nonce = nonce);
                         return {
                             headTags,
                             bodyTags
@@ -8574,6 +8917,7 @@ throw new Error('Failed to load Node.js addon: "${name}"\\n' + error);
             'onAfterStartDevServer',
             'onAfterStartProdServer',
             'onCloseDevServer',
+            'onBeforeDevCompile',
             'onDevCompileDone',
             'onExit',
             'getRsbuildConfig',
@@ -8609,7 +8953,7 @@ function defineConfig(config) {
 async function loadConfig_loadConfig({ cwd = process.cwd(), path, envMode, meta, loader = 'jiti' } = {}) {
     let configExport, configFilePath = ((root, customConfig)=>{
         if (customConfig) {
-            let customConfigPath = external_node_path_isAbsolute(customConfig) ? customConfig : join(root, customConfig);
+            let customConfigPath = (0, external_node_path_.isAbsolute)(customConfig) ? customConfig : (0, external_node_path_.join)(root, customConfig);
             if (node_fs.existsSync(customConfigPath)) return customConfigPath;
             logger.warn(`Cannot find config file: ${picocolors.dim(customConfigPath)}\n`);
         }
@@ -8621,7 +8965,7 @@ async function loadConfig_loadConfig({ cwd = process.cwd(), path, envMode, meta,
             'rsbuild.config.mts',
             'rsbuild.config.cts'
         ]){
-            let configFile = join(root, file);
+            let configFile = (0, external_node_path_.join)(root, file);
             if (node_fs.existsSync(configFile)) return configFile;
         }
         return null;
@@ -8634,7 +8978,7 @@ async function loadConfig_loadConfig({ cwd = process.cwd(), path, envMode, meta,
             configFilePath
         }, config);
     if ('native' === loader || /\.(?:js|mjs|cjs)$/.test(configFilePath)) try {
-        let configFileURL = pathToFileURL(configFilePath).href, exportModule = await import(`${configFileURL}?t=${Date.now()}`);
+        let configFileURL = (0, external_node_url_.pathToFileURL)(configFilePath).href, exportModule = await import(`${configFileURL}?t=${Date.now()}`);
         configExport = exportModule.default ? exportModule.default : exportModule;
     } catch (err) {
         if ('native' === loader) throw logger.error(`Failed to load file with native loader: ${picocolors.dim(configFilePath)}`), err;
@@ -8677,14 +9021,13 @@ async function loadConfig_loadConfig({ cwd = process.cwd(), path, envMode, meta,
     };
 }
 let commonOpts = {}, init_loadConfig = async (root)=>{
-    var _config_server;
     let { content: config, filePath } = await loadConfig_loadConfig({
         cwd: root,
         path: commonOpts.config,
         envMode: commonOpts.envMode,
         loader: commonOpts.configLoader
     });
-    return config.dev ||= {}, config.source ||= {}, config.server ||= {}, commonOpts.base && (config.server.base = commonOpts.base), commonOpts.root && (config.root = root), commonOpts.mode && (config.mode = commonOpts.mode), commonOpts.logLevel && (config.logLevel = commonOpts.logLevel), !commonOpts.open || (null == (_config_server = config.server) ? void 0 : _config_server.open) || (config.server.open = commonOpts.open), commonOpts.host && (config.server.host = commonOpts.host), commonOpts.port && (config.server.port = commonOpts.port), void 0 === config.dev.cliShortcuts && (config.dev.cliShortcuts = !0), filePath && (config.dev.watchFiles = [
+    return config.dev ||= {}, config.source ||= {}, config.server ||= {}, commonOpts.base && (config.server.base = commonOpts.base), commonOpts.root && (config.root = root), commonOpts.mode && (config.mode = commonOpts.mode), commonOpts.logLevel && (config.logLevel = commonOpts.logLevel), commonOpts.open && !config.server?.open && (config.server.open = commonOpts.open), commonOpts.host && (config.server.host = commonOpts.host), commonOpts.port && (config.server.port = commonOpts.port), void 0 === config.dev.cliShortcuts && (config.dev.cliShortcuts = !0), filePath && (config.dev.watchFiles = [
         ...config.dev.watchFiles ? helpers_castArray(config.dev.watchFiles) : [],
         {
             paths: filePath,
@@ -8693,15 +9036,15 @@ let commonOpts = {}, init_loadConfig = async (root)=>{
     ]), config;
 };
 async function init_init({ cliOptions, isRestart, isBuildWatch = !1 }) {
-    var _commonOpts_environment, envDir;
-    cliOptions && (commonOpts = cliOptions), commonOpts.environment = null == (_commonOpts_environment = commonOpts.environment) ? void 0 : _commonOpts_environment.flatMap((env)=>env.split(','));
+    cliOptions && (commonOpts = cliOptions), commonOpts.environment = commonOpts.environment?.flatMap((env)=>env.split(','));
     try {
+        var envDir;
         let cwd = process.cwd(), root = commonOpts.root ? ensureAbsolutePath(cwd, commonOpts.root) : cwd, rsbuild = await createRsbuild({
             cwd: root,
             rsbuildConfig: ()=>init_loadConfig(root),
             environment: commonOpts.environment,
             loadEnv: !1 !== commonOpts.env && {
-                cwd: (envDir = commonOpts.envDir) ? node_path.isAbsolute(envDir) ? envDir : node_path.join(root, envDir) : root,
+                cwd: (envDir = commonOpts.envDir) ? external_node_path_.default.isAbsolute(envDir) ? envDir : external_node_path_.default.join(root, envDir) : root,
                 mode: commonOpts.envMode
             }
         });
@@ -8733,7 +9076,7 @@ let cleaners = [], onBeforeRestartServer = (cleaner)=>{
     cleaners.push(cleaner);
 }, beforeRestart = async ({ filePath, clear = !0, id })=>{
     if (clear && isTTY() && !process.env.DEBUG && process.stdout.write('\x1B[H\x1B[2J'), filePath) {
-        let filename = node_path.basename(filePath);
+        let filename = external_node_path_.default.basename(filePath);
         logger.info(`restarting ${id} as ${picocolors.yellow(filename)} changed\n`);
     } else logger.info(`restarting ${id}...\n`);
     for (let cleaner of cleaners)await cleaner();
@@ -8778,17 +9121,16 @@ async function watchFilesForRestart({ files, rsbuild, isBuildWatch, watchOptions
     watcher.on('add', onChange), watcher.on('change', onChange), watcher.on('unlink', onChange);
 }
 let applyServerOptions = (command)=>{
-    command.option('-o, --open [url]', 'open the page in browser on startup').option('--port <port>', 'specify a port number for server to listen').option('--host <host>', 'specify the host that the server listens to');
-};
+    command.option('-o, --open [url]', 'Open the page in browser on startup').option('--port <port>', 'Set the port number for the server').option('--host <host>', 'Set the host that the server listens to');
+}, { argv: cli_argv } = process;
 function runCLI() {
-    if (!process.env.NODE_ENV) {
-        let command = process.argv[2];
+    if (process.title = 'rsbuild-node', !process.env.NODE_ENV) {
+        let command = cli_argv[2];
         process.env.NODE_ENV = [
             'build',
             'preview'
         ].includes(command) ? 'production' : 'development';
     }
-    process.title = 'rsbuild-node';
     let logLevelIndex = process.argv.findIndex((item)=>'--log-level' === item || '--logLevel' === item);
     if (-1 !== logLevelIndex) {
         let level = process.argv[logLevelIndex + 1];
@@ -8798,37 +9140,40 @@ function runCLI() {
             'silent'
         ].includes(level) && (logger.level = level);
     }
-    let { npm_execpath } = process.env;
-    (!npm_execpath || npm_execpath.includes('npx-cli.js') || npm_execpath.includes('.bun')) && logger.log(), logger.greet(`  Rsbuild v1.4.15\n`);
+    !function() {
+        if (cli_argv.some((item)=>'--help' === item || '-h' === item)) return;
+        let { npm_execpath, npm_lifecycle_event, NODE_RUN_SCRIPT_NAME } = process.env, isBun = npm_execpath?.includes('.bun');
+        logger.greet(`${'npx' === npm_lifecycle_event || isBun || NODE_RUN_SCRIPT_NAME ? '\n' : ''}  Rsbuild v1.5.0-beta.1\n`);
+    }();
     try {
         !function() {
             let cli = ((name = "")=>new CAC(name))('rsbuild');
-            cli.help(), cli.version("1.4.15"), cli.option('--base <base>', 'specify the base path of the server').option('-c, --config <config>', 'specify the configuration file, can be a relative or absolute path').option('--config-loader <loader>', 'specify the loader to load the config file, can be `jiti` or `native`', {
+            cli.help(), cli.version("1.5.0-beta.1"), cli.option('--base <base>', 'Set the base path of the server').option('-c, --config <config>', 'Set the configuration file (relative or absolute path)').option('--config-loader <loader>', 'Set the config file loader (jiti | native)', {
                 default: 'jiti'
-            }).option('-r, --root <root>', 'specify the project root directory, can be an absolute path or a path relative to cwd').option('-m, --mode <mode>', 'specify the build mode, can be `development`, `production` or `none`').option('--log-level <level>', 'specify the log level, can be `info`, `warn`, `error` or `silent`').option('--env-mode <mode>', 'specify the env mode to load the `.env.[mode]` file').option('--environment <name>', 'specify the name of environment to build', {
+            }).option('--env-dir <dir>', 'Set the directory for loading `.env` files').option('--env-mode <mode>', 'Set the env mode to load the `.env.[mode]` file').option('--environment <name>', 'Set the environment name(s) to build', {
                 type: [
                     String
                 ],
                 default: []
-            }).option('--env-dir <dir>', 'specify the directory to load `.env` files').option('--no-env', 'Disable loading `.env` files');
-            let devCommand = cli.command('', 'starting the dev server').alias('dev'), buildCommand = cli.command('build', 'build the app for production'), previewCommand = cli.command('preview', 'preview the production build locally'), inspectCommand = cli.command('inspect', 'inspect the Rspack and Rsbuild configs');
+            }).option('--log-level <level>', 'Set the log level (info | warn | error | silent)').option('-m, --mode <mode>', 'Set the build mode (development | production | none)').option('-r, --root <root>', 'Set the project root directory (absolute path or relative to cwd)').option('--no-env', 'Disable loading of `.env` files');
+            let devCommand = cli.command('dev', 'Start the dev server').alias(''), buildCommand = cli.command('build', 'Build the app for production'), previewCommand = cli.command('preview', 'Preview the production build locally'), inspectCommand = cli.command('inspect', 'Inspect the Rspack and Rsbuild configs');
             applyServerOptions(devCommand), applyServerOptions(previewCommand), devCommand.action(async (options)=>{
                 try {
                     let rsbuild = await init_init({
                         cliOptions: options
                     });
-                    await (null == rsbuild ? void 0 : rsbuild.startDevServer());
+                    await rsbuild?.startDevServer();
                 } catch (err) {
                     logger.error('Failed to start dev server.'), logger.error(err), process.exit(1);
                 }
-            }), buildCommand.option('-w, --watch', 'turn on watch mode, watch for changes and rebuild').action(async (options)=>{
+            }), buildCommand.option('-w, --watch', 'Enable watch mode to automatically rebuild on file changes').action(async (options)=>{
                 try {
                     let rsbuild = await init_init({
                         cliOptions: options,
                         isBuildWatch: options.watch
-                    }), buildInstance = await (null == rsbuild ? void 0 : rsbuild.build({
+                    }), buildInstance = await rsbuild?.build({
                         watch: options.watch
-                    }));
+                    });
                     buildInstance && (options.watch ? onBeforeRestartServer(buildInstance.close) : await buildInstance.close());
                 } catch (err) {
                     err instanceof Error && err.message === RSPACK_BUILD_ERROR || logger.error('Failed to build.'), logger.error(err), process.exit(1);
@@ -8838,20 +9183,20 @@ function runCLI() {
                     let rsbuild = await init_init({
                         cliOptions: options
                     });
-                    await (null == rsbuild ? void 0 : rsbuild.preview());
+                    await rsbuild?.preview();
                 } catch (err) {
                     logger.error('Failed to start preview server.'), logger.error(err), process.exit(1);
                 }
-            }), inspectCommand.option('--output <output>', 'specify inspect content output path').option('--verbose', 'show full function definitions in output').action(async (options)=>{
+            }), inspectCommand.option('--output <output>', 'Set the output path for inspection results').option('--verbose', 'Show complete function definitions in output').action(async (options)=>{
                 try {
                     let rsbuild = await init_init({
                         cliOptions: options
                     });
-                    await (null == rsbuild ? void 0 : rsbuild.inspectConfig({
+                    await rsbuild?.inspectConfig({
                         verbose: options.verbose,
                         outputPath: options.output,
                         writeToDisk: !0
-                    }));
+                    });
                 } catch (err) {
                     logger.error('Failed to inspect config.'), logger.error(err), process.exit(1);
                 }
@@ -8861,5 +9206,5 @@ function runCLI() {
         logger.error('Failed to start Rsbuild CLI.'), logger.error(err);
     }
 }
-let src_version = "1.4.15";
+let src_version = "1.5.0-beta.1";
 export { PLUGIN_CSS_NAME, PLUGIN_SWC_NAME, createRsbuild, defaultAllowedOrigins, defineConfig, ensureAssetPrefix, loadConfig_loadConfig as loadConfig, loadEnv, logger, mergeRsbuildConfig, rspack_rspack as rspack, runCLI, src_version as version };