@rsbuild/webpack 1.1.0 → 1.1.2

package/dist/index.cjs

@@ -1,56 +1,36 @@
 "use strict";
 var __webpack_modules__ = {
     "../../../node_modules/.pnpm/webpack@5.96.1/node_modules/webpack/lib/MultiStats.js": function(module, __unused_webpack_exports, __webpack_require__) {
-        /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/ const identifierUtils = __webpack_require__("../../../node_modules/.pnpm/webpack@5.96.1/node_modules/webpack/lib/util/identifier.js");
-        /** @typedef {import("../declarations/WebpackOptions").StatsOptions} StatsOptions */ /** @typedef {import("./Compilation").CreateStatsOptionsContext} CreateStatsOptionsContext */ /** @typedef {import("./Compilation").NormalizedStatsOptions} NormalizedStatsOptions */ /** @typedef {import("./Stats")} Stats */ /** @typedef {import("./stats/DefaultStatsFactoryPlugin").KnownStatsCompilation} KnownStatsCompilation */ /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsCompilation} StatsCompilation */ /** @typedef {import("./stats/DefaultStatsFactoryPlugin").StatsError} StatsError */ /**
- * @param {string} str string
- * @param {string} prefix pref
- * @returns {string} indent
- */ const indent = (str, prefix)=>{
-            const rem = str.replace(/\n([^\n])/g, `\n${prefix}$1`);
+        let identifierUtils = __webpack_require__("../../../node_modules/.pnpm/webpack@5.96.1/node_modules/webpack/lib/util/identifier.js"), indent = (str, prefix)=>{
+            let rem = str.replace(/\n([^\n])/g, `\n${prefix}$1`);
             return prefix + rem;
         };
-        /** @typedef {{ version: boolean, hash: boolean, errorsCount: boolean, warningsCount: boolean, errors: boolean, warnings: boolean, children: NormalizedStatsOptions[] }} ChildOptions */ class MultiStats {
-            /**
-	 * @param {Stats[]} stats the child stats
-	 */ constructor(stats){
+        module.exports = class MultiStats {
+            constructor(stats){
                 this.stats = stats;
             }
             get hash() {
                 return this.stats.map((stat)=>stat.hash).join("");
             }
-            /**
-	 * @returns {boolean} true if a child compilation encountered an error
-	 */ hasErrors() {
+            hasErrors() {
                 return this.stats.some((stat)=>stat.hasErrors());
             }
-            /**
-	 * @returns {boolean} true if a child compilation had a warning
-	 */ hasWarnings() {
+            hasWarnings() {
                 return this.stats.some((stat)=>stat.hasWarnings());
             }
-            /**
-	 * @param {string | boolean | StatsOptions | undefined} options stats options
-	 * @param {CreateStatsOptionsContext} context context
-	 * @returns {ChildOptions} context context
-	 */ _createChildOptions(options, context) {
-                const getCreateStatsOptions = ()=>{
-                    if (!options) options = {};
-                    const { children: childrenOptions, ...baseOptions } = "string" == typeof options ? {
+            _createChildOptions(options, context) {
+                let getCreateStatsOptions = ()=>{
+                    !options && (options = {});
+                    let { children: childrenOptions, ...baseOptions } = "string" == typeof options ? {
                         preset: options
-                    } : /** @type {StatsOptions} */ options;
+                    } : options;
                     return {
                         childrenOptions,
                         baseOptions
                     };
-                };
-                const children = this.stats.map((stat, idx)=>{
+                }, children = this.stats.map((stat, idx)=>{
                     if ("boolean" == typeof options) return stat.compilation.createStatsOptions(options, context);
-                    const { childrenOptions, baseOptions } = getCreateStatsOptions();
-                    const childOptions = Array.isArray(childrenOptions) ? childrenOptions[idx] : childrenOptions;
+                    let { childrenOptions, baseOptions } = getCreateStatsOptions(), childOptions = Array.isArray(childrenOptions) ? childrenOptions[idx] : childrenOptions;
                     return stat.compilation.createStatsOptions({
                         ...baseOptions,
                         ..."string" == typeof childOptions ? {
@@ -68,379 +48,139 @@ var __webpack_modules__ = {
                     children
                 };
             }
-            /**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
-	 * @returns {StatsCompilation} json output
-	 */ toJson(options) {
-                const childOptions = this._createChildOptions(options, {
-                    forToString: false
-                });
-                /** @type {KnownStatsCompilation} */ const obj = {};
+            toJson(options) {
+                let childOptions = this._createChildOptions(options, {
+                    forToString: !1
+                }), obj = {};
                 obj.children = this.stats.map((stat, idx)=>{
-                    const obj = stat.toJson(childOptions.children[idx]);
-                    const compilationName = stat.compilation.name;
-                    const name = compilationName && identifierUtils.makePathsRelative(stat.compilation.compiler.context, compilationName, stat.compilation.compiler.root);
-                    obj.name = name;
-                    return obj;
-                });
-                if (childOptions.version) obj.version = obj.children[0].version;
-                if (childOptions.hash) obj.hash = obj.children.map((j)=>j.hash).join("");
-                /**
-		 * @param {StatsCompilation} j stats error
-		 * @param {StatsError} obj Stats error
-		 * @returns {TODO} result
-		 */ const mapError = (j, obj)=>({
+                    let obj = stat.toJson(childOptions.children[idx]), compilationName = stat.compilation.name, name = compilationName && identifierUtils.makePathsRelative(stat.compilation.compiler.context, compilationName, stat.compilation.compiler.root);
+                    return obj.name = name, obj;
+                }), childOptions.version && (obj.version = obj.children[0].version), childOptions.hash && (obj.hash = obj.children.map((j)=>j.hash).join(""));
+                let mapError = (j, obj)=>({
                         ...obj,
                         compilerPath: obj.compilerPath ? `${j.name}.${obj.compilerPath}` : j.name
                     });
-                if (childOptions.errors) {
-                    obj.errors = [];
-                    for (const j of obj.children){
-                        const errors = /** @type {NonNullable<KnownStatsCompilation["errors"]>} */ j.errors;
-                        for (const i of errors)obj.errors.push(mapError(j, i));
-                    }
-                }
-                if (childOptions.warnings) {
-                    obj.warnings = [];
-                    for (const j of obj.children){
-                        const warnings = /** @type {NonNullable<KnownStatsCompilation["warnings"]>} */ j.warnings;
-                        for (const i of warnings)obj.warnings.push(mapError(j, i));
-                    }
-                }
-                if (childOptions.errorsCount) {
-                    obj.errorsCount = 0;
-                    for (const j of obj.children)obj.errorsCount += /** @type {number} */ j.errorsCount;
-                }
-                if (childOptions.warningsCount) {
-                    obj.warningsCount = 0;
-                    for (const j of obj.children)obj.warningsCount += /** @type {number} */ j.warningsCount;
-                }
+                if (childOptions.errors) for (let j of (obj.errors = [], obj.children))for (let i of j.errors)obj.errors.push(mapError(j, i));
+                if (childOptions.warnings) for (let j of (obj.warnings = [], obj.children))for (let i of j.warnings)obj.warnings.push(mapError(j, i));
+                if (childOptions.errorsCount) for (let j of (obj.errorsCount = 0, obj.children))obj.errorsCount += j.errorsCount;
+                if (childOptions.warningsCount) for (let j of (obj.warningsCount = 0, obj.children))obj.warningsCount += j.warningsCount;
                 return obj;
             }
-            /**
-	 * @param {(string | boolean | StatsOptions)=} options stats options
-	 * @returns {string} string output
-	 */ toString(options) {
-                const childOptions = this._createChildOptions(options, {
-                    forToString: true
+            toString(options) {
+                let childOptions = this._createChildOptions(options, {
+                    forToString: !0
                 });
-                const results = this.stats.map((stat, idx)=>{
-                    const str = stat.toString(childOptions.children[idx]);
-                    const compilationName = stat.compilation.name;
-                    const name = compilationName && identifierUtils.makePathsRelative(stat.compilation.compiler.context, compilationName, stat.compilation.compiler.root).replace(/\|/g, " ");
-                    if (!str) return str;
-                    return name ? `${name}:\n${indent(str, "  ")}` : str;
-                });
-                return results.filter(Boolean).join("\n\n");
+                return this.stats.map((stat, idx)=>{
+                    let str = stat.toString(childOptions.children[idx]), compilationName = stat.compilation.name, name = compilationName && identifierUtils.makePathsRelative(stat.compilation.compiler.context, compilationName, stat.compilation.compiler.root).replace(/\|/g, " ");
+                    return str ? name ? `${name}:\n${indent(str, "  ")}` : str : str;
+                }).filter(Boolean).join("\n\n");
             }
-        }
-        module.exports = MultiStats;
+        };
     },
     "../../../node_modules/.pnpm/webpack@5.96.1/node_modules/webpack/lib/util/identifier.js": function(module, __unused_webpack_exports, __webpack_require__) {
-        /*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-*/ const path = __webpack_require__("path");
-        const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
-        const SEGMENTS_SPLIT_REGEXP = /([|!])/;
-        const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
-        /**
- * @typedef {object} MakeRelativePathsCache
- * @property {Map<string, Map<string, string>>=} relativePaths
- */ /**
- * @param {string} relativePath relative path
- * @returns {string} request
- */ const relativePathToRequest = (relativePath)=>{
-            if ("" === relativePath) return "./.";
-            if (".." === relativePath) return "../.";
-            if (relativePath.startsWith("../")) return relativePath;
-            return `./${relativePath}`;
-        };
-        /**
- * @param {string} context context for relative path
- * @param {string} maybeAbsolutePath path to make relative
- * @returns {string} relative path in request style
- */ const absoluteToRequest = (context, maybeAbsolutePath)=>{
+        let path = __webpack_require__("path"), WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/, SEGMENTS_SPLIT_REGEXP = /([|!])/, WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g, relativePathToRequest = (relativePath)=>"" === relativePath ? "./." : ".." === relativePath ? "../." : relativePath.startsWith("../") ? relativePath : `./${relativePath}`, absoluteToRequest = (context, maybeAbsolutePath)=>{
             if ("/" === maybeAbsolutePath[0]) {
-                if (maybeAbsolutePath.length > 1 && "/" === maybeAbsolutePath[maybeAbsolutePath.length - 1]) // this 'path' is actually a regexp generated by dynamic requires.
-                // Don't treat it as an absolute path.
-                return maybeAbsolutePath;
-                const querySplitPos = maybeAbsolutePath.indexOf("?");
-                let resource = -1 === querySplitPos ? maybeAbsolutePath : maybeAbsolutePath.slice(0, querySplitPos);
-                resource = relativePathToRequest(path.posix.relative(context, resource));
-                return -1 === querySplitPos ? resource : resource + maybeAbsolutePath.slice(querySplitPos);
+                if (maybeAbsolutePath.length > 1 && "/" === maybeAbsolutePath[maybeAbsolutePath.length - 1]) return maybeAbsolutePath;
+                let querySplitPos = maybeAbsolutePath.indexOf("?"), resource = -1 === querySplitPos ? maybeAbsolutePath : maybeAbsolutePath.slice(0, querySplitPos);
+                return resource = relativePathToRequest(path.posix.relative(context, resource)), -1 === querySplitPos ? resource : resource + maybeAbsolutePath.slice(querySplitPos);
             }
             if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
-                const querySplitPos = maybeAbsolutePath.indexOf("?");
-                let resource = -1 === querySplitPos ? maybeAbsolutePath : maybeAbsolutePath.slice(0, querySplitPos);
-                resource = path.win32.relative(context, resource);
-                if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) resource = relativePathToRequest(resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/"));
-                return -1 === querySplitPos ? resource : resource + maybeAbsolutePath.slice(querySplitPos);
+                let querySplitPos = maybeAbsolutePath.indexOf("?"), resource = -1 === querySplitPos ? maybeAbsolutePath : maybeAbsolutePath.slice(0, querySplitPos);
+                return resource = path.win32.relative(context, resource), !WINDOWS_ABS_PATH_REGEXP.test(resource) && (resource = relativePathToRequest(resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/"))), -1 === querySplitPos ? resource : resource + maybeAbsolutePath.slice(querySplitPos);
             }
-            // not an absolute path
             return maybeAbsolutePath;
-        };
-        /**
- * @param {string} context context for relative path
- * @param {string} relativePath path
- * @returns {string} absolute path
- */ const requestToAbsolute = (context, relativePath)=>{
-            if (relativePath.startsWith("./") || relativePath.startsWith("../")) return path.join(context, relativePath);
-            return relativePath;
-        };
-        /**
- * @template T
- * @typedef {function(string, object=): T} MakeCacheableResult
- */ /**
- * @template T
- * @typedef {function(string): T} BindCacheResultFn
- */ /**
- * @template T
- * @typedef {function(object): BindCacheResultFn<T>} BindCache
- */ /**
- * @template T
- * @param {(function(string): T)} realFn real function
- * @returns {MakeCacheableResult<T> & { bindCache: BindCache<T> }} cacheable function
- */ const makeCacheable = (realFn)=>{
-            /**
-	 * @template T
-	 * @typedef {Map<string, T>} CacheItem
-	 */ /** @type {WeakMap<object, CacheItem<T>>} */ const cache = new WeakMap();
-            /**
-	 * @param {object} associatedObjectForCache an object to which the cache will be attached
-	 * @returns {CacheItem<T>} cache item
-	 */ const getCache = (associatedObjectForCache)=>{
-                const entry = cache.get(associatedObjectForCache);
+        }, requestToAbsolute = (context, relativePath)=>relativePath.startsWith("./") || relativePath.startsWith("../") ? path.join(context, relativePath) : relativePath, makeCacheable = (realFn)=>{
+            let cache = new WeakMap(), getCache = (associatedObjectForCache)=>{
+                let entry = cache.get(associatedObjectForCache);
                 if (void 0 !== entry) return entry;
-                /** @type {Map<string, T>} */ const map = new Map();
-                cache.set(associatedObjectForCache, map);
-                return map;
-            };
-            /** @type {MakeCacheableResult<T> & { bindCache: BindCache<T> }} */ const fn = (str, associatedObjectForCache)=>{
+                let map = new Map();
+                return cache.set(associatedObjectForCache, map), map;
+            }, fn = (str, associatedObjectForCache)=>{
                 if (!associatedObjectForCache) return realFn(str);
-                const cache = getCache(associatedObjectForCache);
-                const entry = cache.get(str);
+                let cache = getCache(associatedObjectForCache), entry = cache.get(str);
                 if (void 0 !== entry) return entry;
-                const result = realFn(str);
-                cache.set(str, result);
-                return result;
+                let result = realFn(str);
+                return cache.set(str, result), result;
             };
-            /** @type {BindCache<T>} */ fn.bindCache = (associatedObjectForCache)=>{
-                const cache = getCache(associatedObjectForCache);
-                /**
-		 * @param {string} str string
-		 * @returns {T} value
-		 */ return (str)=>{
-                    const entry = cache.get(str);
+            return fn.bindCache = (associatedObjectForCache)=>{
+                let cache = getCache(associatedObjectForCache);
+                return (str)=>{
+                    let entry = cache.get(str);
                     if (void 0 !== entry) return entry;
-                    const result = realFn(str);
-                    cache.set(str, result);
-                    return result;
+                    let result = realFn(str);
+                    return cache.set(str, result), result;
                 };
-            };
-            return fn;
-        };
-        /** @typedef {function(string, string, object=): string} MakeCacheableWithContextResult */ /** @typedef {function(string, string): string} BindCacheForContextResultFn */ /** @typedef {function(string): string} BindContextCacheForContextResultFn */ /** @typedef {function(object=): BindCacheForContextResultFn} BindCacheForContext */ /** @typedef {function(string, object=): BindContextCacheForContextResultFn} BindContextCacheForContext */ /**
- * @param {function(string, string): string} fn function
- * @returns {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} cacheable function with context
- */ const makeCacheableWithContext = (fn)=>{
-            /** @type {WeakMap<object, Map<string, Map<string, string>>>} */ const cache = new WeakMap();
-            /** @type {MakeCacheableWithContextResult & { bindCache: BindCacheForContext, bindContextCache: BindContextCacheForContext }} */ const cachedFn = (context, identifier, associatedObjectForCache)=>{
+            }, fn;
+        }, makeCacheableWithContext = (fn)=>{
+            let cache = new WeakMap(), cachedFn = (context, identifier, associatedObjectForCache)=>{
+                let cachedResult;
                 if (!associatedObjectForCache) return fn(context, identifier);
                 let innerCache = cache.get(associatedObjectForCache);
-                if (void 0 === innerCache) {
-                    innerCache = new Map();
-                    cache.set(associatedObjectForCache, innerCache);
-                }
-                let cachedResult;
+                void 0 === innerCache && (innerCache = new Map(), cache.set(associatedObjectForCache, innerCache));
                 let innerSubCache = innerCache.get(context);
-                if (void 0 === innerSubCache) innerCache.set(context, innerSubCache = new Map());
-                else cachedResult = innerSubCache.get(identifier);
-                if (void 0 !== cachedResult) return cachedResult;
-                const result = fn(context, identifier);
-                innerSubCache.set(identifier, result);
-                return result;
+                if (void 0 === innerSubCache ? innerCache.set(context, innerSubCache = new Map()) : cachedResult = innerSubCache.get(identifier), void 0 !== cachedResult) return cachedResult;
+                let result = fn(context, identifier);
+                return innerSubCache.set(identifier, result), result;
             };
-            /** @type {BindCacheForContext} */ cachedFn.bindCache = (associatedObjectForCache)=>{
+            return cachedFn.bindCache = (associatedObjectForCache)=>{
                 let innerCache;
-                if (associatedObjectForCache) {
-                    innerCache = cache.get(associatedObjectForCache);
-                    if (void 0 === innerCache) {
-                        innerCache = new Map();
-                        cache.set(associatedObjectForCache, innerCache);
-                    }
-                } else innerCache = new Map();
-                /**
-		 * @param {string} context context used to create relative path
-		 * @param {string} identifier identifier used to create relative path
-		 * @returns {string} the returned relative path
-		 */ const boundFn = (context, identifier)=>{
+                return associatedObjectForCache ? void 0 === (innerCache = cache.get(associatedObjectForCache)) && (innerCache = new Map(), cache.set(associatedObjectForCache, innerCache)) : innerCache = new Map(), (context, identifier)=>{
                     let cachedResult;
                     let innerSubCache = innerCache.get(context);
-                    if (void 0 === innerSubCache) innerCache.set(context, innerSubCache = new Map());
-                    else cachedResult = innerSubCache.get(identifier);
-                    if (void 0 !== cachedResult) return cachedResult;
-                    const result = fn(context, identifier);
-                    innerSubCache.set(identifier, result);
-                    return result;
+                    if (void 0 === innerSubCache ? innerCache.set(context, innerSubCache = new Map()) : cachedResult = innerSubCache.get(identifier), void 0 !== cachedResult) return cachedResult;
+                    let result = fn(context, identifier);
+                    return innerSubCache.set(identifier, result), result;
                 };
-                return boundFn;
-            };
-            /** @type {BindContextCacheForContext} */ cachedFn.bindContextCache = (context, associatedObjectForCache)=>{
+            }, cachedFn.bindContextCache = (context, associatedObjectForCache)=>{
                 let innerSubCache;
                 if (associatedObjectForCache) {
                     let innerCache = cache.get(associatedObjectForCache);
-                    if (void 0 === innerCache) {
-                        innerCache = new Map();
-                        cache.set(associatedObjectForCache, innerCache);
-                    }
-                    innerSubCache = innerCache.get(context);
-                    if (void 0 === innerSubCache) innerCache.set(context, innerSubCache = new Map());
+                    void 0 === innerCache && (innerCache = new Map(), cache.set(associatedObjectForCache, innerCache)), void 0 === (innerSubCache = innerCache.get(context)) && innerCache.set(context, innerSubCache = new Map());
                 } else innerSubCache = new Map();
-                /**
-		 * @param {string} identifier identifier used to create relative path
-		 * @returns {string} the returned relative path
-		 */ const boundFn = (identifier)=>{
-                    const cachedResult = innerSubCache.get(identifier);
+                return (identifier)=>{
+                    let cachedResult = innerSubCache.get(identifier);
                     if (void 0 !== cachedResult) return cachedResult;
-                    const result = fn(context, identifier);
-                    innerSubCache.set(identifier, result);
-                    return result;
+                    let result = fn(context, identifier);
+                    return innerSubCache.set(identifier, result), result;
                 };
-                return boundFn;
-            };
-            return cachedFn;
+            }, cachedFn;
         };
-        /**
- * @param {string} context context for relative path
- * @param {string} identifier identifier for path
- * @returns {string} a converted relative path
- */ const _makePathsRelative = (context, identifier)=>identifier.split(SEGMENTS_SPLIT_REGEXP).map((str)=>absoluteToRequest(context, str)).join("");
-        module.exports.makePathsRelative = makeCacheableWithContext(_makePathsRelative);
-        /**
- * @param {string} context context for relative path
- * @param {string} identifier identifier for path
- * @returns {string} a converted relative path
- */ const _makePathsAbsolute = (context, identifier)=>identifier.split(SEGMENTS_SPLIT_REGEXP).map((str)=>requestToAbsolute(context, str)).join("");
-        module.exports.makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
-        /**
- * @param {string} context absolute context path
- * @param {string} request any request string may containing absolute paths, query string, etc.
- * @returns {string} a new request string avoiding absolute paths when possible
- */ const _contextify = (context, request)=>request.split("!").map((r)=>absoluteToRequest(context, r)).join("!");
-        const contextify = makeCacheableWithContext(_contextify);
+        module.exports.makePathsRelative = makeCacheableWithContext((context, identifier)=>identifier.split(SEGMENTS_SPLIT_REGEXP).map((str)=>absoluteToRequest(context, str)).join(""));
+        module.exports.makePathsAbsolute = makeCacheableWithContext((context, identifier)=>identifier.split(SEGMENTS_SPLIT_REGEXP).map((str)=>requestToAbsolute(context, str)).join(""));
+        let contextify = makeCacheableWithContext((context, request)=>request.split("!").map((r)=>absoluteToRequest(context, r)).join("!"));
         module.exports.contextify = contextify;
-        /**
- * @param {string} context absolute context path
- * @param {string} request any request string
- * @returns {string} a new request string using absolute paths when possible
- */ const _absolutify = (context, request)=>request.split("!").map((r)=>requestToAbsolute(context, r)).join("!");
-        const absolutify = makeCacheableWithContext(_absolutify);
+        let absolutify = makeCacheableWithContext((context, request)=>request.split("!").map((r)=>requestToAbsolute(context, r)).join("!"));
         module.exports.absolutify = absolutify;
-        const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
-        const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
-        /** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */ /** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */ /**
- * @param {string} str the path with query and fragment
- * @returns {ParsedResource} parsed parts
- */ const _parseResource = (str)=>{
-            const match = /** @type {unknown} */ PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+        let PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/, PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
+        module.exports.parseResource = makeCacheable((str)=>{
+            let match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
             return {
                 resource: str,
                 path: match[1].replace(/\0(.)/g, "$1"),
                 query: match[2] ? match[2].replace(/\0(.)/g, "$1") : "",
                 fragment: match[3] || ""
             };
-        };
-        module.exports.parseResource = makeCacheable(_parseResource);
-        /**
- * Parse resource, skips fragment part
- * @param {string} str the path with query and fragment
- * @returns {ParsedResourceWithoutFragment} parsed parts
- */ const _parseResourceWithoutFragment = (str)=>{
-            const match = /** @type {unknown} */ PATH_QUERY_REGEXP.exec(str);
+        });
+        module.exports.parseResourceWithoutFragment = makeCacheable((str)=>{
+            let match = PATH_QUERY_REGEXP.exec(str);
             return {
                 resource: str,
                 path: match[1].replace(/\0(.)/g, "$1"),
                 query: match[2] ? match[2].replace(/\0(.)/g, "$1") : ""
             };
-        };
-        module.exports.parseResourceWithoutFragment = makeCacheable(_parseResourceWithoutFragment);
-        /**
- * @param {string} filename the filename which should be undone
- * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
- * @param {boolean} enforceRelative true returns ./ for empty paths
- * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
- */ module.exports.getUndoPath = (filename, outputPath, enforceRelative)=>{
-            let depth = -1;
-            let append = "";
-            outputPath = outputPath.replace(/[\\/]$/, "");
-            for (const part of filename.split(/[/\\]+/))if (".." === part) {
+        }), module.exports.getUndoPath = (filename, outputPath, enforceRelative)=>{
+            let depth = -1, append = "";
+            for (let part of (outputPath = outputPath.replace(/[\\/]$/, ""), filename.split(/[/\\]+/)))if (".." === part) {
                 if (depth > -1) depth--;
                 else {
-                    const i = outputPath.lastIndexOf("/");
-                    const j = outputPath.lastIndexOf("\\");
-                    const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
+                    let i = outputPath.lastIndexOf("/"), j = outputPath.lastIndexOf("\\"), pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
                     if (pos < 0) return `${outputPath}/`;
-                    append = `${outputPath.slice(pos + 1)}/${append}`;
-                    outputPath = outputPath.slice(0, pos);
+                    append = `${outputPath.slice(pos + 1)}/${append}`, outputPath = outputPath.slice(0, pos);
                 }
-            } else if ("." !== part) depth++;
+            } else "." !== part && depth++;
             return depth > 0 ? `${"../".repeat(depth)}${append}` : enforceRelative ? `./${append}` : append;
         };
     },
-    "./src/shared.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            A9: function() {
-                return initRsbuildConfig;
-            },
-            AS: function() {
-                return prettyTime;
-            },
-            DO: function() {
-                return stringifyConfig;
-            },
-            EB: function() {
-                return modifyBundlerChain;
-            },
-            Oo: function() {
-                return registerBuildHook;
-            },
-            PD: function() {
-                return getRsbuildInspectConfig;
-            },
-            PZ: function() {
-                return createDevServer;
-            },
-            SM: function() {
-                return outputInspectConfigFiles;
-            },
-            XQ: function() {
-                return castArray;
-            },
-            g5: function() {
-                return getStatsOptions;
-            },
-            iL: function() {
-                return chainToConfig;
-            },
-            px: function() {
-                return getChainUtils;
-            },
-            v1: function() {
-                return formatStats;
-            },
-            xn: function() {
-                return registerDevHook;
-            }
-        });
-        /* ESM import */ var _rsbuild_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("@rsbuild/core");
-        const { getChainUtils, initRsbuildConfig, createDevServer, formatStats, getStatsOptions, stringifyConfig, outputInspectConfigFiles, getRsbuildInspectConfig, chainToConfig, modifyBundlerChain, registerDevHook, registerBuildHook, prettyTime } = _rsbuild_core__WEBPACK_IMPORTED_MODULE_0__.__internalHelper;
-        const castArray = (arr)=>{
-            if (void 0 === arr) return [];
-            return Array.isArray(arr) ? arr : [
-                arr
-            ];
-        };
-    },
     "@rsbuild/core": function(module) {
         module.exports = require("@rsbuild/core");
     },
@@ -468,103 +208,61 @@ var __webpack_modules__ = {
     webpack: function(module) {
         module.exports = import("webpack");
     }
-};
-/************************************************************************/ // The module cache
-var __webpack_module_cache__ = {};
-// The require function
+}, __webpack_module_cache__ = {};
 function __webpack_require__(moduleId) {
-    // Check if module is in cache
     var cachedModule = __webpack_module_cache__[moduleId];
     if (void 0 !== cachedModule) return cachedModule.exports;
-    // Create a new module (and put it into the cache)
     var module = __webpack_module_cache__[moduleId] = {
         id: moduleId,
-        loaded: false,
+        loaded: !1,
         exports: {}
     };
-    // Execute the module function
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    // Flag the module as loaded
-    module.loaded = true;
-    // Return the exports of the module
-    return module.exports;
+    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.loaded = !0, module.exports;
 }
-// expose the modules object (__webpack_modules__)
-__webpack_require__.m = __webpack_modules__;
-/************************************************************************/ // webpack/runtime/async_module
-(()=>{
-    var webpackQueues = "function" == typeof Symbol ? Symbol("webpack queues") : "__webpack_queues__";
-    var webpackExports = "function" == typeof Symbol ? Symbol("webpack exports") : "__webpack_exports__";
-    var webpackError = "function" == typeof Symbol ? Symbol("webpack error") : "__webpack_error__";
-    var resolveQueue = function(queue) {
-        if (queue && queue.d < 1) {
-            queue.d = 1;
-            queue.forEach(function(fn) {
-                fn.r--;
-            });
-            queue.forEach(function(fn) {
-                fn.r-- ? fn.r++ : fn();
-            });
-        }
-    };
-    var wrapDeps = function(deps) {
-        return deps.map(function(dep) {
-            if (null !== dep && "object" == typeof dep) {
-                if (dep[webpackQueues]) return dep;
-                if (dep.then) {
-                    var queue = [];
-                    queue.d = 0;
-                    dep.then(function(r) {
-                        obj[webpackExports] = r;
-                        resolveQueue(queue);
-                    }, function(e) {
-                        obj[webpackError] = e;
-                        resolveQueue(queue);
-                    });
-                    var obj = {};
-                    obj[webpackQueues] = function(fn) {
-                        fn(queue);
-                    };
-                    return obj;
-                }
-            }
-            var ret = {};
-            ret[webpackQueues] = function() {};
-            ret[webpackExports] = dep;
-            return ret;
-        });
+__webpack_require__.m = __webpack_modules__, (()=>{
+    var webpackQueues = "function" == typeof Symbol ? Symbol("webpack queues") : "__webpack_queues__", webpackExports = "function" == typeof Symbol ? Symbol("webpack exports") : "__webpack_exports__", webpackError = "function" == typeof Symbol ? Symbol("webpack error") : "__webpack_error__", resolveQueue = function(queue) {
+        queue && queue.d < 1 && (queue.d = 1, queue.forEach(function(fn) {
+            fn.r--;
+        }), queue.forEach(function(fn) {
+            fn.r-- ? fn.r++ : fn();
+        }));
     };
     __webpack_require__.a = function(module, body, hasAwait) {
-        var queue;
         hasAwait && ((queue = []).d = -1);
-        var depQueues = new Set();
-        var exports1 = module.exports;
-        var currentDeps;
-        var outerResolve;
-        var reject;
-        var promise = new Promise(function(resolve, rej) {
-            reject = rej;
-            outerResolve = resolve;
+        var queue, currentDeps, outerResolve, reject, depQueues = new Set(), exports1 = module.exports, promise = new Promise(function(resolve, rej) {
+            reject = rej, outerResolve = resolve;
         });
-        promise[webpackExports] = exports1;
-        promise[webpackQueues] = function(fn) {
-            queue && fn(queue), depQueues.forEach(fn), promise["catch"](function() {});
-        };
-        module.exports = promise;
-        body(function(deps) {
-            currentDeps = wrapDeps(deps);
-            var fn;
-            var getResult = function() {
+        promise[webpackExports] = exports1, promise[webpackQueues] = function(fn) {
+            queue && fn(queue), depQueues.forEach(fn), promise.catch(function() {});
+        }, module.exports = promise, body(function(deps) {
+            currentDeps = deps.map(function(dep) {
+                if (null !== dep && "object" == typeof dep) {
+                    if (dep[webpackQueues]) return dep;
+                    if (dep.then) {
+                        var queue = [];
+                        queue.d = 0, dep.then(function(r) {
+                            obj[webpackExports] = r, resolveQueue(queue);
+                        }, function(e) {
+                            obj[webpackError] = e, resolveQueue(queue);
+                        });
+                        var obj = {};
+                        return obj[webpackQueues] = function(fn) {
+                            fn(queue);
+                        }, obj;
+                    }
+                }
+                var ret = {};
+                return ret[webpackQueues] = function() {}, ret[webpackExports] = dep, ret;
+            });
+            var fn, getResult = function() {
                 return currentDeps.map(function(d) {
                     if (d[webpackError]) throw d[webpackError];
                     return d[webpackExports];
                 });
-            };
-            var promise = new Promise(function(resolve) {
-                fn = function() {
+            }, promise = new Promise(function(resolve) {
+                (fn = function() {
                     resolve(getResult);
-                };
-                fn.r = 0;
+                }).r = 0;
                 var fnQueue = function(q) {
                     q === queue || depQueues.has(q) || (depQueues.add(q), q && !q.d && (fn.r++, q.push(fn)));
                 };
@@ -575,141 +273,76 @@ __webpack_require__.m = __webpack_modules__;
             return fn.r ? promise : getResult();
         }, function(err) {
             err ? reject(promise[webpackError] = err) : outerResolve(exports1), resolveQueue(queue);
-        });
-        queue && queue.d < 0 && (queue.d = 0);
+        }), queue && queue.d < 0 && (queue.d = 0);
     };
-})();
-// webpack/runtime/compat_get_default_export
-(()=>{
-    // getDefaultExport function for compatibility with non-ESM modules
-    __webpack_require__.n = function(module) {
-        var getter = module && module.__esModule ? function() {
-            return module['default'];
-        } : function() {
-            return module;
-        };
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-// webpack/runtime/define_property_getters
-(()=>{
-    __webpack_require__.d = function(exports1, definition) {
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-// webpack/runtime/ensure_chunk
-(()=>{
-    __webpack_require__.f = {};
-    // This file contains only the entry chunk.
-    // The chunk loading function for additional chunks
-    __webpack_require__.e = function(chunkId) {
-        return Promise.all(Object.keys(__webpack_require__.f).reduce(function(promises, key) {
-            __webpack_require__.f[key](chunkId, promises);
-            return promises;
-        }, []));
-    };
-})();
-// webpack/runtime/get javascript chunk filename
-(()=>{
-    // This function allow to reference chunks
-    __webpack_require__.u = function(chunkId) {
-        // return url for filenames not based on template
-        // return url for filenames based on template
-        return "" + chunkId + ".cjs";
-    };
-})();
-// webpack/runtime/has_own_property
-(()=>{
-    __webpack_require__.o = function(obj, prop) {
-        return Object.prototype.hasOwnProperty.call(obj, prop);
-    };
-})();
-// webpack/runtime/make_namespace_object
-(()=>{
-    // define __esModule on exports
-    __webpack_require__.r = function(exports1) {
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-// webpack/runtime/node_module_decorator
-(()=>{
-    __webpack_require__.nmd = function(module) {
-        module.paths = [];
-        if (!module.children) module.children = [];
+})(), __webpack_require__.n = function(module) {
+    var getter = module && module.__esModule ? function() {
+        return module.default;
+    } : function() {
         return module;
     };
-})();
-// webpack/runtime/require_chunk_loading
-(()=>{
+    return __webpack_require__.d(getter, {
+        a: getter
+    }), getter;
+}, __webpack_require__.d = function(exports1, definition) {
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key) && Object.defineProperty(exports1, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.f = {}, __webpack_require__.e = function(chunkId) {
+    return Promise.all(Object.keys(__webpack_require__.f).reduce(function(promises, key) {
+        return __webpack_require__.f[key](chunkId, promises), promises;
+    }, []));
+}, __webpack_require__.u = function(chunkId) {
+    return "" + chunkId + ".cjs";
+}, __webpack_require__.o = function(obj, prop) {
+    return Object.prototype.hasOwnProperty.call(obj, prop);
+}, __webpack_require__.r = function(exports1) {
+    'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports1, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports1, '__esModule', {
+        value: !0
+    });
+}, __webpack_require__.nmd = function(module) {
+    return module.paths = [], !module.children && (module.children = []), module;
+}, (()=>{
     var installedChunks = {
         980: 1
-    };
-    // object to store loaded chunks
-    // "1" means "loaded", otherwise not loaded yet
-    var installChunk = function(chunk) {
+    }, installChunk = function(chunk) {
         var moreModules = chunk.modules, chunkIds = chunk.ids, runtime = chunk.runtime;
-        for(var moduleId in moreModules)if (__webpack_require__.o(moreModules, moduleId)) __webpack_require__.m[moduleId] = moreModules[moduleId];
-        if (runtime) runtime(__webpack_require__);
+        for(var moduleId in moreModules)__webpack_require__.o(moreModules, moduleId) && (__webpack_require__.m[moduleId] = moreModules[moduleId]);
+        runtime && runtime(__webpack_require__);
         for(var i = 0; i < chunkIds.length; i++)installedChunks[chunkIds[i]] = 1;
     };
-    // require() chunk loading for javascript
     __webpack_require__.f.require = function(chunkId, promises) {
-        // "1" is the signal for "already loaded"
-        if (!installedChunks[chunkId]) installChunk(require("./" + __webpack_require__.u(chunkId)));
+        !installedChunks[chunkId] && installChunk(require("./" + __webpack_require__.u(chunkId)));
     };
 })();
-/************************************************************************/ var __webpack_exports__ = {};
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-    webpackProvider: ()=>/* reexport */ webpackProvider
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__), __webpack_require__.d(__webpack_exports__, {
+    webpackProvider: ()=>webpackProvider
 });
-// EXTERNAL MODULE: external "@rsbuild/core"
-var core_ = __webpack_require__("@rsbuild/core");
-// EXTERNAL MODULE: ../../../node_modules/.pnpm/webpack@5.96.1/node_modules/webpack/lib/MultiStats.js
-var MultiStats = __webpack_require__("../../../node_modules/.pnpm/webpack@5.96.1/node_modules/webpack/lib/MultiStats.js");
-var MultiStats_default = /*#__PURE__*/ __webpack_require__.n(MultiStats);
-const external_node_path_namespaceObject = require("node:path");
-// EXTERNAL MODULE: ./src/shared.ts
-var shared = __webpack_require__("./src/shared.ts");
-const getInspectOutputPath = (context, inspectOptions)=>{
-    if (inspectOptions.outputPath) {
-        if ((0, external_node_path_namespaceObject.isAbsolute)(inspectOptions.outputPath)) return inspectOptions.outputPath;
-        return (0, external_node_path_namespaceObject.join)(context.distPath, inspectOptions.outputPath);
-    }
+var core_ = __webpack_require__("@rsbuild/core"), MultiStats = __webpack_require__("../../../node_modules/.pnpm/webpack@5.96.1/node_modules/webpack/lib/MultiStats.js"), MultiStats_default = __webpack_require__.n(MultiStats);
+let external_node_path_namespaceObject = require("node:path"), getInspectOutputPath = (context, inspectOptions)=>{
+    if (inspectOptions.outputPath) return (0, external_node_path_namespaceObject.isAbsolute)(inspectOptions.outputPath) ? inspectOptions.outputPath : (0, external_node_path_namespaceObject.join)(context.distPath, inspectOptions.outputPath);
     return (0, external_node_path_namespaceObject.join)(context.distPath, '.rsbuild');
 };
-async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerConfigs, inspectOptions = {} }) {
-    if (inspectOptions.mode) process.env.NODE_ENV = inspectOptions.mode;
-    else if (!process.env.NODE_ENV) process.env.NODE_ENV = 'development';
-    const webpackConfigs = bundlerConfigs || (await initConfigs({
+async function inspectConfig({ helpers, context, pluginManager, rsbuildOptions, bundlerConfigs, inspectOptions = {} }) {
+    inspectOptions.mode ? process.env.NODE_ENV = inspectOptions.mode : !process.env.NODE_ENV && (process.env.NODE_ENV = 'development');
+    let webpackConfigs = bundlerConfigs || (await initConfigs({
         context,
         pluginManager,
-        rsbuildOptions
-    })).webpackConfigs;
-    const rawBundlerConfigs = webpackConfigs.map((config, index)=>({
+        rsbuildOptions,
+        helpers
+    })).webpackConfigs, rawBundlerConfigs = webpackConfigs.map((config, index)=>({
             name: config.name || String(index),
-            content: (0, shared /* stringifyConfig */ .DO)(config, inspectOptions.verbose)
-        }));
-    const { rsbuildConfig, rawRsbuildConfig, environmentConfigs, rawEnvironmentConfigs } = (0, shared /* getRsbuildInspectConfig */ .PD)({
+            content: helpers.stringifyConfig(config, inspectOptions.verbose)
+        })), { rsbuildConfig, rawRsbuildConfig, environmentConfigs, rawEnvironmentConfigs } = helpers.getRsbuildInspectConfig({
         normalizedConfig: context.normalizedConfig,
         inspectOptions,
         pluginManager
-    });
-    const outputPath = getInspectOutputPath(context, inspectOptions);
-    if (inspectOptions.writeToDisk) await (0, shared /* outputInspectConfigFiles */ .SM)({
+    }), outputPath = getInspectOutputPath(context, inspectOptions);
+    return inspectOptions.writeToDisk && await helpers.outputInspectConfigFiles({
         rawBundlerConfigs,
         rawEnvironmentConfigs,
         inspectOptions: {
@@ -717,8 +350,7 @@ async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerCo
             outputPath
         },
         configType: 'webpack'
-    });
-    return {
+    }), {
         rsbuildConfig: rawRsbuildConfig,
         environmentConfigs: rawEnvironmentConfigs.map((r)=>r.content),
         bundlerConfigs: rawBundlerConfigs.map((r)=>r.content),
@@ -729,20 +361,21 @@ async function inspectConfig({ context, pluginManager, rsbuildOptions, bundlerCo
         }
     };
 }
-const external_reduce_configs_namespaceObject = require("reduce-configs");
+let external_reduce_configs_namespaceObject = require("reduce-configs"), castArray = (arr)=>void 0 === arr ? [] : Array.isArray(arr) ? arr : [
+        arr
+    ];
 async function modifyWebpackChain(context, utils, chain) {
     var _utils_environment_config_tools;
     core_.logger.debug('modify webpack chain');
-    const [modifiedChain] = await context.hooks.modifyWebpackChain.callInEnvironment({
+    let [modifiedChain] = await context.hooks.modifyWebpackChain.callInEnvironment({
         environment: utils.environment.name,
         args: [
             chain,
             utils
         ]
     });
-    if (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.webpackChain) for (const item of (0, shared /* castArray */ .XQ)(utils.environment.config.tools.webpackChain))item(modifiedChain, utils);
-    core_.logger.debug('modify webpack chain done');
-    return modifiedChain;
+    if (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.webpackChain) for (let item of castArray(utils.environment.config.tools.webpackChain))item(modifiedChain, utils);
+    return core_.logger.debug('modify webpack chain done'), modifiedChain;
 }
 async function modifyWebpackConfig(context, webpackConfig, utils) {
     var _utils_environment_config_tools;
@@ -754,34 +387,28 @@ async function modifyWebpackConfig(context, webpackConfig, utils) {
             utils
         ]
     });
-    if (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.webpack) modifiedConfig = (0, external_reduce_configs_namespaceObject.reduceConfigsWithContext)({
+    return (null === (_utils_environment_config_tools = utils.environment.config.tools) || void 0 === _utils_environment_config_tools ? void 0 : _utils_environment_config_tools.webpack) && (modifiedConfig = (0, external_reduce_configs_namespaceObject.reduceConfigsWithContext)({
         initial: modifiedConfig,
         config: utils.environment.config.tools.webpack,
         ctx: utils,
         mergeFn: utils.mergeConfig
-    });
-    core_.logger.debug('modify webpack config done');
-    return modifiedConfig;
+    })), core_.logger.debug('modify webpack config done'), modifiedConfig;
 }
-async function getChainUtils(target, environment) {
-    const { default: webpack } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "webpack"));
-    const nameMap = {
-        web: 'client',
-        node: 'server',
-        'web-worker': 'web-worker'
-    };
+async function getChainUtils(target, environment, helpers) {
+    let { default: webpack } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "webpack"));
     return {
-        ...(0, shared /* getChainUtils */ .px)(target, environment),
-        name: nameMap[target] || '',
+        ...helpers.getChainUtils(target, environment),
+        name: ({
+            web: 'client',
+            node: 'server',
+            'web-worker': 'web-worker'
+        })[target] || '',
         webpack,
-        HtmlWebpackPlugin: core_.__internalHelper.getHTMLPlugin()
+        HtmlWebpackPlugin: helpers.getHTMLPlugin()
     };
 }
-async function generateWebpackConfig({ target, context, environment }) {
-    const chainUtils = await getChainUtils(target, context.environments[environment]);
-    const { default: webpack } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "webpack"));
-    const { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, HotModuleReplacementPlugin } = webpack;
-    const bundlerChain = await (0, shared /* modifyBundlerChain */ .EB)(context, {
+async function generateWebpackConfig({ target, context, environment, helpers }) {
+    let chainUtils = await getChainUtils(target, context.environments[environment], helpers), { default: webpack } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "webpack")), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, HotModuleReplacementPlugin } = webpack, bundlerChain = await helpers.modifyBundlerChain(context, {
         ...chainUtils,
         bundler: {
             BannerPlugin,
@@ -790,43 +417,36 @@ async function generateWebpackConfig({ target, context, environment }) {
             ProvidePlugin,
             HotModuleReplacementPlugin
         }
-    });
-    const chain = await modifyWebpackChain(context, chainUtils, bundlerChain);
-    let webpackConfig = (0, shared /* chainToConfig */ .iL)(chain);
-    const configUtils = await core_.__internalHelper.getConfigUtils(webpackConfig, chainUtils);
-    webpackConfig = await modifyWebpackConfig(context, webpackConfig, configUtils);
-    return webpackConfig;
+    }), chain = await modifyWebpackChain(context, chainUtils, bundlerChain), webpackConfig = helpers.chainToConfig(chain), configUtils = await helpers.getConfigUtils(webpackConfig, chainUtils);
+    return webpackConfig = await modifyWebpackConfig(context, webpackConfig, configUtils);
 }
-async function initConfigs({ context, pluginManager, rsbuildOptions }) {
-    const normalizedConfig = await (0, shared /* initRsbuildConfig */ .A9)({
+async function initConfigs({ context, pluginManager, rsbuildOptions, helpers }) {
+    let normalizedConfig = await helpers.initRsbuildConfig({
         context,
         pluginManager
-    });
-    const webpackConfigs = await Promise.all(Object.entries(normalizedConfig.environments).map(([environment, config])=>generateWebpackConfig({
+    }), webpackConfigs = await Promise.all(Object.entries(normalizedConfig.environments).map(([environment, config])=>generateWebpackConfig({
             target: config.output.target,
             context,
-            environment
+            environment,
+            helpers
         })));
-    // write Rsbuild config and webpack config to disk in debug mode
     if ('verbose' === core_.logger.level) {
-        const inspect = ()=>{
-            const inspectOptions = {
-                verbose: true,
-                writeToDisk: true
-            };
+        let inspect = ()=>{
             inspectConfig({
                 context,
                 pluginManager,
-                inspectOptions,
+                inspectOptions: {
+                    verbose: !0,
+                    writeToDisk: !0
+                },
                 rsbuildOptions,
-                bundlerConfigs: webpackConfigs
+                bundlerConfigs: webpackConfigs,
+                helpers
             });
         };
-        // run inspect later to avoid cleaned by cleanOutput plugin
         context.hooks.onBeforeBuild.tap(({ isFirstCompile })=>{
-            if (isFirstCompile) inspect();
-        });
-        context.hooks.onAfterStartDevServer.tap(inspect);
+            isFirstCompile && inspect();
+        }), context.hooks.onAfterStartDevServer.tap(inspect);
     }
     return {
         webpackConfigs
@@ -835,86 +455,65 @@ async function initConfigs({ context, pluginManager, rsbuildOptions }) {
 async function createCompiler_createCompiler(options) {
     var _context_normalizedConfig;
     core_.logger.debug('create compiler');
-    const { context } = options;
-    const { webpackConfigs } = await initConfigs(options);
+    let { helpers, context } = options, { webpackConfigs } = await initConfigs(options);
     await context.hooks.onBeforeCreateCompiler.call({
         bundlerConfigs: webpackConfigs,
         environments: context.environments
     });
-    const { default: webpack } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "webpack"));
-    const compiler = 1 === webpackConfigs.length ? webpack(webpackConfigs[0]) : webpack(webpackConfigs);
-    const done = (stats)=>{
-        const statsOptions = (0, shared /* getStatsOptions */ .g5)(compiler);
-        const statsJson = stats.toJson({
-            children: true,
+    let { default: webpack } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "webpack")), compiler = webpack(1 === webpackConfigs.length ? webpackConfigs[0] : webpackConfigs), done = (stats)=>{
+        let statsOptions = helpers.getStatsOptions(compiler), statsJson = stats.toJson({
+            children: !0,
             ...'string' == typeof statsOptions ? {
                 preset: statsOptions
             } : {
                 preset: 'errors-warnings'
             },
             ...'object' == typeof statsOptions ? statsOptions : {}
-        });
-        const { message, level } = (0, shared /* formatStats */ .v1)(statsJson, stats.hasErrors());
-        if ('error' === level) core_.logger.error(message);
-        if ('warning' === level) core_.logger.warn(message);
+        }), { message, level } = helpers.formatStats(statsJson, stats.hasErrors());
+        'error' === level && core_.logger.error(message), 'warning' === level && core_.logger.warn(message);
     };
-    compiler.hooks.done.tap('rsbuild:done', (stats)=>{
+    return compiler.hooks.done.tap('rsbuild:done', (stats)=>{
         done(stats);
-    });
-    if ((null === (_context_normalizedConfig = context.normalizedConfig) || void 0 === _context_normalizedConfig ? void 0 : _context_normalizedConfig.mode) === 'development') (0, shared /* registerDevHook */ .xn)({
+    }), (null === (_context_normalizedConfig = context.normalizedConfig) || void 0 === _context_normalizedConfig ? void 0 : _context_normalizedConfig.mode) === 'development' && helpers.registerDevHook({
         compiler,
         context,
         bundlerConfigs: webpackConfigs,
         MultiStatsCtor: MultiStats_default()
-    });
-    await context.hooks.onAfterCreateCompiler.call({
+    }), await context.hooks.onAfterCreateCompiler.call({
         compiler,
         environments: context.environments
-    });
-    core_.logger.debug('create compiler done');
-    return {
+    }), core_.logger.debug('create compiler done'), {
         compiler,
         webpackConfigs
     };
 }
-const build = async (initOptions, { watch, compiler: customCompiler } = {})=>{
-    const { context } = initOptions;
-    let compiler;
-    let bundlerConfigs;
+let build = async (initOptions, { watch, compiler: customCompiler } = {})=>{
+    let compiler, bundlerConfigs;
+    let { helpers, context } = initOptions;
     if (customCompiler) compiler = customCompiler;
     else {
-        const result = await createCompiler_createCompiler(initOptions);
-        compiler = result.compiler;
-        bundlerConfigs = result.webpackConfigs;
+        let result = await createCompiler_createCompiler(initOptions);
+        compiler = result.compiler, bundlerConfigs = result.webpackConfigs;
     }
-    (0, shared /* registerBuildHook */ .Oo)({
+    if (helpers.registerBuildHook({
         context,
         bundlerConfigs: bundlerConfigs,
         compiler,
-        isWatch: Boolean(watch),
+        isWatch: !!watch,
         MultiStatsCtor: MultiStats_default()
-    });
-    if (watch) {
-        const watching = compiler.watch({}, (err)=>{
-            if (err) core_.logger.error(err);
-        });
-        return {
-            close: ()=>new Promise((resolve)=>{
-                    watching.close(()=>{
-                        resolve();
-                    });
-                })
-        };
-    }
-    const { stats } = await new Promise((resolve, reject)=>{
+    }), watch) return compiler.watch({}, (err)=>{
+        err && core_.logger.error(err);
+    }), {
+        close: ()=>new Promise((resolve)=>{
+                compiler.close(()=>{
+                    resolve();
+                });
+            })
+    };
+    let { stats } = await new Promise((resolve, reject)=>{
         compiler.run((err, stats)=>{
-            if (err) reject(err);
-            else if (null == stats ? void 0 : stats.hasErrors()) reject(new Error('Webpack build failed!'));
-            else // When using run or watch, call close and wait for it to finish before calling run or watch again.
-            // Concurrent compilations will corrupt the output files.
-            compiler.close((closeErr)=>{
-                closeErr && core_.logger.error(closeErr);
-                resolve({
+            err ? reject(err) : (null == stats ? void 0 : stats.hasErrors()) ? reject(Error('Webpack build failed!')) : compiler.close((closeErr)=>{
+                closeErr && core_.logger.error(closeErr), resolve({
                     stats
                 });
             });
@@ -922,165 +521,142 @@ const build = async (initOptions, { watch, compiler: customCompiler } = {})=>{
     });
     return {
         stats,
-        // This close method is a noop in non-watch mode
-        // In watch mode, it's defined above to stop watching
-        close: async ()=>{}
+        close: ()=>new Promise((resolve)=>{
+                compiler.close(()=>{
+                    resolve();
+                });
+            })
     };
-};
-const external_node_fs_namespaceObject = require("node:fs");
-var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+}, external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = __webpack_require__.n(external_node_fs_namespaceObject);
 async function applyTsConfigPathsPlugin({ chain, CHAIN_ID, mainFields, extensions, configFile }) {
-    const { TsconfigPathsPlugin } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "tsconfig-paths-webpack-plugin"));
+    let { TsconfigPathsPlugin } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "tsconfig-paths-webpack-plugin"));
     chain.resolve.plugin(CHAIN_ID.RESOLVE_PLUGIN.TS_CONFIG_PATHS).use(TsconfigPathsPlugin, [
         {
             configFile,
             extensions,
-            // https://github.com/dividab/tsconfig-paths-webpack-plugin/pull/106
             mainFields: mainFields
         }
     ]);
 }
 function isWebTarget(target) {
-    const targets = (0, shared /* castArray */ .XQ)(target);
-    return targets.includes('web') || target.includes('web-worker');
+    return castArray(target).includes('web') || target.includes('web-worker');
 }
-const getMainFields = (chain, target)=>{
-    const mainFields = chain.resolve.mainFields.values();
-    if (mainFields.length) return mainFields;
-    if (isWebTarget(target)) return [
+let getMainFields = (chain, target)=>{
+    let mainFields = chain.resolve.mainFields.values();
+    return mainFields.length ? mainFields : isWebTarget(target) ? [
         'browser',
         'module',
         'main'
-    ];
-    return [
+    ] : [
         'module',
         'main'
     ];
-};
-/**
- * Handling differences between Webpack and Rspack
- */ const pluginAdaptor = ()=>({
+}, pluginAdaptor = (helpers)=>({
         name: 'rsbuild-webpack:adaptor',
         setup (api) {
             api.modifyBundlerChain(async (chain, { CHAIN_ID, environment, target })=>{
-                const { config, tsconfigPath } = environment;
-                if (tsconfigPath && 'prefer-tsconfig' === config.source.aliasStrategy) await applyTsConfigPathsPlugin({
+                let { config, tsconfigPath } = environment;
+                tsconfigPath && 'prefer-tsconfig' === config.source.aliasStrategy && await applyTsConfigPathsPlugin({
                     chain,
                     CHAIN_ID,
                     configFile: tsconfigPath,
                     mainFields: getMainFields(chain, target),
                     extensions: chain.resolve.extensions.values()
                 });
-                // enable progress bar for webpack by default
-                const progress = config.dev.progressBar ?? true;
+                let progress = config.dev.progressBar ?? !0;
                 if (progress) {
-                    const { ProgressPlugin } = await Promise.all(/* import() */ [
+                    let { ProgressPlugin } = await Promise.all([
                         __webpack_require__.e("997"),
                         __webpack_require__.e("15")
                     ]).then(__webpack_require__.bind(__webpack_require__, "./src/progress/ProgressPlugin.ts"));
                     chain.plugin(CHAIN_ID.PLUGIN.PROGRESS).use(ProgressPlugin, [
                         {
                             id: environment.name,
-                            ...true === progress ? {} : progress
+                            prettyTime: helpers.prettyTime,
+                            ...!0 === progress ? {} : progress
                         }
                     ]);
                 }
-                const { copy } = config.output;
+                let { copy } = config.output;
                 if (copy) {
-                    const { default: CopyPlugin } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "copy-webpack-plugin"));
-                    const options = Array.isArray(copy) ? {
+                    let { default: CopyPlugin } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "copy-webpack-plugin")), options = Array.isArray(copy) ? {
                         patterns: copy
                     } : copy;
                     chain.plugin(CHAIN_ID.PLUGIN.COPY).use(CopyPlugin, [
-                        // @ts-expect-error to type mismatch
                         options
                     ]);
                 }
-            });
-            api.modifyWebpackConfig(async (config)=>{
-                var _config_plugins;
-                const copyPlugin = null === (_config_plugins = config.plugins) || void 0 === _config_plugins ? void 0 : _config_plugins.find((item)=>(null == item ? void 0 : item.constructor.name) === 'CopyPlugin');
-                if (copyPlugin) {
-                    // If the pattern.context directory not exists, we should remove CopyPlugin.
-                    // Otherwise the CopyPlugin will cause the webpack to re-compile.
-                    const isContextNotExists = copyPlugin.patterns.every((pattern)=>'string' != typeof pattern && pattern.context && !external_node_fs_default().existsSync(pattern.context));
-                    if (isContextNotExists) {
-                        var _config_plugins1;
-                        config.plugins = null === (_config_plugins1 = config.plugins) || void 0 === _config_plugins1 ? void 0 : _config_plugins1.filter((item)=>(null == item ? void 0 : item.constructor.name) !== 'CopyPlugin');
-                    }
-                }
+            }), api.modifyWebpackConfig(async (config)=>{
+                var _config_plugins, _config_plugins1;
+                let copyPlugin = null === (_config_plugins = config.plugins) || void 0 === _config_plugins ? void 0 : _config_plugins.find((item)=>(null == item ? void 0 : item.constructor.name) === 'CopyPlugin');
+                copyPlugin && copyPlugin.patterns.every((pattern)=>'string' != typeof pattern && pattern.context && !external_node_fs_default().existsSync(pattern.context)) && (config.plugins = null === (_config_plugins1 = config.plugins) || void 0 === _config_plugins1 ? void 0 : _config_plugins1.filter((item)=>(null == item ? void 0 : item.constructor.name) !== 'CopyPlugin'));
             });
         }
-    });
-const webpackProvider = async ({ context, pluginManager, rsbuildOptions, setCssExtractPlugin })=>{
-    const { default: cssExtractPlugin } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "mini-css-extract-plugin"));
-    setCssExtractPlugin(cssExtractPlugin);
-    const createCompiler = async ()=>{
-        const result = await createCompiler_createCompiler({
+    }), webpackProvider = async ({ context, pluginManager, rsbuildOptions, helpers })=>{
+    let { default: cssExtractPlugin } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "mini-css-extract-plugin"));
+    helpers.setCssExtractPlugin(cssExtractPlugin);
+    let createCompiler = async ()=>(await createCompiler_createCompiler({
             context,
             pluginManager,
-            rsbuildOptions
-        });
-        return result.compiler;
-    };
-    pluginManager.addPlugins([
-        pluginAdaptor()
-    ]);
-    return {
+            rsbuildOptions,
+            helpers
+        })).compiler;
+    return pluginManager.addPlugins([
+        pluginAdaptor(helpers)
+    ]), {
         bundler: 'webpack',
         createCompiler,
         async initConfigs () {
-            const { webpackConfigs } = await initConfigs({
+            let { webpackConfigs } = await initConfigs({
                 context,
                 pluginManager,
-                rsbuildOptions
+                rsbuildOptions,
+                helpers
             });
             return webpackConfigs;
         },
         async createDevServer (options) {
-            const config = await (0, shared /* initRsbuildConfig */ .A9)({
+            let config = await helpers.initRsbuildConfig({
                 context,
                 pluginManager
             });
-            return (0, shared /* createDevServer */ .PZ)({
+            return helpers.createDevServer({
                 context,
                 pluginManager,
                 rsbuildOptions
             }, createCompiler, config, options);
         },
         async startDevServer (options) {
-            const config = await (0, shared /* initRsbuildConfig */ .A9)({
+            let config = await helpers.initRsbuildConfig({
                 context,
                 pluginManager
             });
-            const server = await (0, shared /* createDevServer */ .PZ)({
+            return (await helpers.createDevServer({
                 context,
                 pluginManager,
                 rsbuildOptions
-            }, createCompiler, config, options);
-            return server.listen();
+            }, createCompiler, config, options)).listen();
         },
-        async build (options) {
-            return build({
+        build: async (options)=>build({
                 context,
                 pluginManager,
-                rsbuildOptions
-            }, options);
-        },
-        async inspectConfig (inspectOptions) {
-            return await inspectConfig({
+                rsbuildOptions,
+                helpers
+            }, options),
+        inspectConfig: async (inspectOptions)=>await inspectConfig({
                 context,
                 pluginManager,
                 rsbuildOptions,
-                inspectOptions
-            });
-        }
+                inspectOptions,
+                helpers
+            })
     };
 };
 var __webpack_export_target__ = exports;
 for(var i in __webpack_exports__)__webpack_export_target__[i] = __webpack_exports__[i];
-if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
-    value: true
+__webpack_exports__.__esModule && Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: !0
 });
 
 // Annotate the CommonJS export names for ESM import in node: