@rsbuild/webpack 1.6.0 → 1.6.2

package/dist/{0~0.js → 0~999.js}

@@ -1,8 +1,10 @@
-export const __webpack_id__ = "0";
-export const __webpack_ids__ = [
-    "0"
-];
-export const __webpack_modules__ = {
+import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
+import { __webpack_require__ } from "./rslib-runtime.js";
+import picocolors from "picocolors";
+import webpack from "webpack";
+import { Console } from "node:console";
+import { logger } from "./161.js";
+__webpack_require__.add({
     "../../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js": function(module) {
         let ansiEscapes = module.exports;
         module.exports.default = ansiEscapes;
@@ -81,7 +83,7 @@ export const __webpack_modules__ = {
         };
         Object.defineProperty(module, 'exports', {
             enumerable: !0,
-            get: function() {
+            get: function assembleStyles() {
                 let codes = new Map(), styles = {
                     modifier: {
                         reset: [
@@ -412,6 +414,9 @@ export const __webpack_modules__ = {
                 value: labels
             });
         }
+        function comparativeDistance(x, y) {
+            return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
+        }
         convert.rgb.hsl = function(rgb) {
             let h, r = rgb[0] / 255, g = rgb[1] / 255, b = rgb[2] / 255, min = Math.min(r, g, b), max = Math.max(r, g, b), delta = max - min;
             max === min ? h = 0 : r === max ? h = (g - b) / delta : g === max ? h = 2 + (b - r) / delta : b === max && (h = 4 + (r - g) / delta), (h = Math.min(60 * h, 360)) < 0 && (h += 360);
@@ -450,7 +455,7 @@ export const __webpack_modules__ = {
             if (reversed) return reversed;
             let currentClosestDistance = 1 / 0;
             for (let keyword of Object.keys(cssKeywords)){
-                let value = cssKeywords[keyword], distance = (rgb[0] - value[0]) ** 2 + (rgb[1] - value[1]) ** 2 + (rgb[2] - value[2]) ** 2;
+                let distance = comparativeDistance(rgb, cssKeywords[keyword]);
                 distance < currentClosestDistance && (currentClosestDistance = distance, currentClosestKeyword = keyword);
             }
             return currentClosestKeyword;
@@ -814,6 +819,24 @@ export const __webpack_modules__ = {
     },
     "../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         let conversions = __webpack_require__("../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js"), route = __webpack_require__("../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/route.js"), convert = {};
+        function wrapRaw(fn) {
+            let wrappedFn = function(...args) {
+                let arg0 = args[0];
+                return null == arg0 ? arg0 : (arg0.length > 1 && (args = arg0), fn(args));
+            };
+            return 'conversion' in fn && (wrappedFn.conversion = fn.conversion), wrappedFn;
+        }
+        function wrapRounded(fn) {
+            let wrappedFn = function(...args) {
+                let arg0 = args[0];
+                if (null == arg0) return arg0;
+                arg0.length > 1 && (args = arg0);
+                let result = fn(args);
+                if ('object' == typeof result) for(let len = result.length, i = 0; i < len; i++)result[i] = Math.round(result[i]);
+                return result;
+            };
+            return 'conversion' in fn && (wrappedFn.conversion = fn.conversion), wrappedFn;
+        }
         Object.keys(conversions).forEach((fromModel)=>{
             convert[fromModel] = {}, Object.defineProperty(convert[fromModel], 'channels', {
                 value: conversions[fromModel].channels
@@ -822,58 +845,52 @@ export const __webpack_modules__ = {
             });
             let routes = route(fromModel);
             Object.keys(routes).forEach((toModel)=>{
-                let wrappedFn, wrappedFn1, fn = routes[toModel];
-                convert[fromModel][toModel] = (wrappedFn = function(...args) {
-                    let arg0 = args[0];
-                    if (null == arg0) return arg0;
-                    arg0.length > 1 && (args = arg0);
-                    let result = fn(args);
-                    if ('object' == typeof result) for(let len = result.length, i = 0; i < len; i++)result[i] = Math.round(result[i]);
-                    return result;
-                }, 'conversion' in fn && (wrappedFn.conversion = fn.conversion), wrappedFn), convert[fromModel][toModel].raw = (wrappedFn1 = function(...args) {
-                    let arg0 = args[0];
-                    return null == arg0 ? arg0 : (arg0.length > 1 && (args = arg0), fn(args));
-                }, 'conversion' in fn && (wrappedFn1.conversion = fn.conversion), wrappedFn1);
+                let fn = routes[toModel];
+                convert[fromModel][toModel] = wrapRounded(fn), convert[fromModel][toModel].raw = wrapRaw(fn);
             });
         }), module.exports = convert;
     },
     "../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/route.js": function(module, __unused_webpack_exports, __webpack_require__) {
         let conversions = __webpack_require__("../../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js");
-        module.exports = function(fromModel) {
-            let graph = function(fromModel) {
-                let graph = function() {
-                    let graph = {}, models = Object.keys(conversions);
-                    for(let len = models.length, i = 0; i < len; i++)graph[models[i]] = {
-                        distance: -1,
-                        parent: null
-                    };
-                    return graph;
-                }(), queue = [
-                    fromModel
-                ];
-                for(graph[fromModel].distance = 0; queue.length;){
-                    let current = queue.pop(), adjacents = Object.keys(conversions[current]);
-                    for(let len = adjacents.length, i = 0; i < len; i++){
-                        let adjacent = adjacents[i], node = graph[adjacent];
-                        -1 === node.distance && (node.distance = graph[current].distance + 1, node.parent = current, queue.unshift(adjacent));
-                    }
+        function buildGraph() {
+            let graph = {}, models = Object.keys(conversions);
+            for(let len = models.length, i = 0; i < len; i++)graph[models[i]] = {
+                distance: -1,
+                parent: null
+            };
+            return graph;
+        }
+        function deriveBFS(fromModel) {
+            let graph = buildGraph(), queue = [
+                fromModel
+            ];
+            for(graph[fromModel].distance = 0; queue.length;){
+                let current = queue.pop(), adjacents = Object.keys(conversions[current]);
+                for(let len = adjacents.length, i = 0; i < len; i++){
+                    let adjacent = adjacents[i], node = graph[adjacent];
+                    -1 === node.distance && (node.distance = graph[current].distance + 1, node.parent = current, queue.unshift(adjacent));
                 }
-                return graph;
-            }(fromModel), conversion = {}, models = Object.keys(graph);
+            }
+            return graph;
+        }
+        function link(from, to) {
+            return function(args) {
+                return to(from(args));
+            };
+        }
+        function wrapConversion(toModel, graph) {
+            let path = [
+                graph[toModel].parent,
+                toModel
+            ], fn = conversions[graph[toModel].parent][toModel], cur = graph[toModel].parent;
+            for(; graph[cur].parent;)path.unshift(graph[cur].parent), fn = link(conversions[graph[cur].parent][cur], fn), cur = graph[cur].parent;
+            return fn.conversion = path, fn;
+        }
+        module.exports = function(fromModel) {
+            let graph = deriveBFS(fromModel), conversion = {}, models = Object.keys(graph);
             for(let len = models.length, i = 0; i < len; i++){
                 let toModel = models[i];
-                null !== graph[toModel].parent && (conversion[toModel] = function(toModel, graph) {
-                    let path = [
-                        graph[toModel].parent,
-                        toModel
-                    ], fn = conversions[graph[toModel].parent][toModel], cur = graph[toModel].parent;
-                    for(; graph[cur].parent;)path.unshift(graph[cur].parent), fn = function(from, to) {
-                        return function(args) {
-                            return to(from(args));
-                        };
-                    }(conversions[graph[cur].parent][cur], fn), cur = graph[cur].parent;
-                    return fn.conversion = path, fn;
-                }(toModel, graph));
+                null !== graph[toModel].parent && (conversion[toModel] = wrapConversion(toModel, graph));
             }
             return conversion;
         };
@@ -1736,5 +1753,202 @@ export const __webpack_modules__ = {
     "../../../node_modules/.pnpm/strip-ansi@6.0.1/node_modules/strip-ansi/index.js": function(module, __unused_webpack_exports, __webpack_require__) {
         let ansiRegex = __webpack_require__("../../../node_modules/.pnpm/ansi-regex@5.0.1/node_modules/ansi-regex/index.js");
         module.exports = (string)=>'string' == typeof string ? string.replace(ansiRegex(), '') : string;
+    },
+    stream: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_stream__;
+    }
+});
+let clamp = (x, min, max)=>Math.min(max, Math.max(min, x)), cli_truncate = __webpack_require__("../../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js");
+var cli_truncate_default = __webpack_require__.n(cli_truncate);
+let defaultOption = {
+    total: 100,
+    current: 0,
+    color: 'green',
+    bgColor: 'gray',
+    char: '━',
+    width: 25,
+    buildIcon: '◯',
+    errorIcon: '✖',
+    errorInfo: 'compile failed',
+    message: '',
+    done: !1,
+    spaceWidth: 1,
+    messageWidth: 25,
+    messageColor: 'gray',
+    id: '',
+    maxIdLen: 16,
+    hasErrors: !1
+}, ansi_escapes = __webpack_require__("../../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js");
+var ansi_escapes_default = __webpack_require__.n(ansi_escapes);
+let build = __webpack_require__("../../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js");
+var build_default = __webpack_require__.n(build);
+let colorList = [
+    'green',
+    'cyan',
+    'yellow',
+    'blue',
+    'magenta'
+], bus = new class {
+    states = [];
+    log;
+    restore;
+    prevOutput;
+    destroyed = !1;
+    constructor(){
+        var stream;
+        let previousLineCount, previousOutput, render;
+        this.prevOutput = '', this.log = (stream = process.stdout, previousLineCount = 0, previousOutput = '', (render = (str)=>{
+            let output = `${str}\n`;
+            output !== previousOutput && (previousOutput = output, stream.write(ansi_escapes_default().eraseLines(previousLineCount) + output), previousLineCount = output.split('\n').length);
+        }).clear = ()=>{
+            stream.write(ansi_escapes_default().eraseLines(previousLineCount)), previousOutput = '', previousLineCount = 0;
+        }, render.done = ()=>{
+            previousOutput = '', previousLineCount = 0;
+        }, render), console.Console = Console, this.restore = build_default()((type, data)=>{
+            this.writeToStd(type, data);
+        });
+    }
+    update(state) {
+        let index = this.states.findIndex((i)=>i.id === state.id);
+        -1 === index ? this.states.push(state) : this.states[index] = state;
+    }
+    writeToStd(type = 'stdout', data) {
+        this.log.clear(), data && ('stdout' === type ? process.stdout.write(data) : 'stderr' === type && process.stderr.write(data)), this.log(this.prevOutput);
+    }
+    render() {
+        let maxIdLen = Math.max(...this.states.map((i)=>i.id?.length ?? 0)) + 2, { columns = 70 } = process.stdout;
+        this.prevOutput = this.states.map((i, k)=>{
+            let bar = ((option)=>{
+                var id;
+                let left, right, mergedOptions = {
+                    ...defaultOption,
+                    ...option
+                }, { total, done, buildIcon, errorIcon, errorInfo, width, current, color, bgColor, char, message, messageWidth, spaceWidth, messageColor, maxIdLen, hasErrors } = mergedOptions, space = ' '.repeat(spaceWidth), percent = clamp(Math.floor(current / total * 100), 0, 100), barColor = picocolors[color], backgroundColor = picocolors[bgColor], doneColor = hasErrors ? picocolors.red : barColor, idColor = done ? doneColor : barColor, id1 = mergedOptions.id ? idColor((left = Math.floor((maxIdLen - (id = mergedOptions.id).length) / 2), right = maxIdLen - left - id.length, ' '.repeat(left) + id + ' '.repeat(right))) : '', { columns: terminalWidth = 70 } = process.stdout;
+                if (done) {
+                    if (hasErrors) {
+                        let message = picocolors.bold(doneColor(errorInfo));
+                        return terminalWidth >= 40 ? [
+                            idColor(errorIcon),
+                            id1,
+                            doneColor(`${space}${message}`)
+                        ].join('') : [
+                            id1,
+                            doneColor(`${message}`)
+                        ].join('');
+                    }
+                    return '';
+                }
+                let msgStr = picocolors[messageColor](cli_truncate_default()(message, messageWidth, {
+                    position: 'start'
+                })), left1 = clamp(Math.floor(percent * width / 100), 0, width), right1 = clamp(width - left1, 0, width), barStr = `${barColor(char.repeat(left1))}${backgroundColor(char.repeat(right1))}`, percentStr = `${percent.toString().padStart(3)}%`;
+                return terminalWidth >= 70 ? [
+                    idColor(buildIcon),
+                    id1,
+                    space,
+                    barStr,
+                    space,
+                    percentStr,
+                    space,
+                    msgStr
+                ].join('') : terminalWidth >= 40 ? [
+                    idColor(buildIcon),
+                    id1,
+                    space,
+                    barStr,
+                    space,
+                    percentStr
+                ].join('') : [
+                    idColor(buildIcon),
+                    id1,
+                    space,
+                    percentStr
+                ].join('');
+            })({
+                maxIdLen,
+                color: i.color ?? colorList[k % colorList.length],
+                ...i
+            });
+            return bar ? cli_truncate_default()(bar, columns, {
+                position: 'end'
+            }) : null;
+        }).filter((item)=>null !== item).join('\n'), this.writeToStd();
+    }
+    destroy() {
+        this.destroyed || this.restore(), this.destroyed = !0;
+    }
+    clear() {
+        this.log.clear(), this.log.done();
+    }
+}();
+function createNonTTYLogger() {
+    let prevPercentage = 0;
+    return {
+        log: ({ id, done, current, hasErrors, compileTime })=>{
+            let suffix = picocolors.gray(`(${id})`);
+            if (done) {
+                if (100 === prevPercentage) return;
+                prevPercentage = 100, hasErrors ? logger.error(`build failed in ${compileTime} ${suffix}`) : logger.ready(`built in ${compileTime} ${suffix}`);
+            } else current - prevPercentage > 10 && (prevPercentage = current, logger.info(`build progress: ${current.toFixed(0)}% ${suffix}`));
+        }
+    };
+}
+class ProgressPlugin extends webpack.ProgressPlugin {
+    name = 'ProgressPlugin';
+    id;
+    hasCompileErrors = !1;
+    compileTime = null;
+    prettyTime;
+    constructor(options){
+        let prevPercentage, { id = 'Rsbuild' } = options, nonTTYLogger = createNonTTYLogger(), friendlyPercentage = (prevPercentage = 0, (percentage)=>{
+            if (0 === percentage || 1 === percentage) return prevPercentage = 0, percentage;
+            if (percentage <= prevPercentage) {
+                let step = 0;
+                return prevPercentage < 0.3 ? step = 0.001 : prevPercentage < 0.6 ? step = 0.002 : prevPercentage < 0.8 ? step = 0.004 : prevPercentage < 0.99 && (step = 0.002), prevPercentage += step;
+            }
+            return prevPercentage = percentage, percentage;
+        });
+        super({
+            activeModules: !1,
+            entries: !0,
+            modules: !0,
+            modulesCount: 5000,
+            profile: !1,
+            dependencies: !0,
+            dependenciesCount: 10000,
+            percentBy: null,
+            handler: (originalPercentage, message)=>{
+                let percentage = friendlyPercentage(originalPercentage), done = 1 === percentage;
+                process.stdout.isTTY ? (bus.update({
+                    id,
+                    current: 100 * percentage,
+                    message,
+                    done,
+                    hasErrors: this.hasCompileErrors
+                }), bus.render()) : nonTTYLogger.log({
+                    id,
+                    done,
+                    current: 100 * percentage,
+                    hasErrors: this.hasCompileErrors,
+                    compileTime: this.compileTime
+                });
+            }
+        }), this.id = id, this.prettyTime = options.prettyTime;
+    }
+    apply(compiler) {
+        super.apply(compiler);
+        let startTime = null;
+        compiler.hooks.compile.tap(this.name, ()=>{
+            this.compileTime = null, startTime = process.hrtime();
+        }), compiler.hooks.done.tap(this.name, (stat)=>{
+            if (startTime) {
+                this.hasCompileErrors = stat.hasErrors();
+                let hrtime = process.hrtime(startTime), seconds = hrtime[0] + hrtime[1] / 1e9;
+                if (this.compileTime = this.prettyTime(seconds), startTime = null, !this.hasCompileErrors) {
+                    let suffix = this.id ? picocolors.gray(` (${this.id})`) : '';
+                    logger.ready(`built in ${this.compileTime} ${suffix}`);
+                }
+            }
+        });
     }
-};
+}
+export { ProgressPlugin };

package/dist/161.js

@@ -0,0 +1,294 @@
+import { logger } from "@rsbuild/core";
+import MultiStats from "webpack/lib/MultiStats.js";
+import { reduceConfigsWithContext } from "reduce-configs";
+import node_fs from "node:fs";
+let castArray = (arr)=>void 0 === arr ? [] : Array.isArray(arr) ? arr : [
+        arr
+    ];
+async function modifyWebpackChain(context, utils, chain) {
+    logger.debug('modify webpack chain');
+    let [modifiedChain] = await context.hooks.modifyWebpackChain.callChain({
+        environment: utils.environment.name,
+        args: [
+            chain,
+            utils
+        ]
+    });
+    if (utils.environment.config.tools?.webpackChain) for (let item of castArray(utils.environment.config.tools.webpackChain))item(modifiedChain, utils);
+    return logger.debug('modify webpack chain done'), modifiedChain;
+}
+async function modifyWebpackConfig(context, webpackConfig, utils) {
+    logger.debug('modify webpack config');
+    let [modifiedConfig] = await context.hooks.modifyWebpackConfig.callChain({
+        environment: utils.environment.name,
+        args: [
+            webpackConfig,
+            utils
+        ]
+    });
+    return utils.environment.config.tools?.webpack && (modifiedConfig = reduceConfigsWithContext({
+        initial: modifiedConfig,
+        config: utils.environment.config.tools.webpack,
+        ctx: utils,
+        mergeFn: utils.mergeConfig
+    })), logger.debug('modify webpack config done'), modifiedConfig;
+}
+async function getChainUtils(target, environment, environments, helpers) {
+    let { default: webpack } = await import("webpack");
+    return {
+        ...helpers.getChainUtils(target, environment, environments),
+        name: ({
+            web: 'client',
+            node: 'server',
+            'web-worker': 'web-worker'
+        })[target] || '',
+        webpack,
+        HtmlWebpackPlugin: helpers.getHTMLPlugin()
+    };
+}
+async function generateWebpackConfig({ target, context, environment, helpers }) {
+    let chainUtils = await getChainUtils(target, context.environments[environment], context.environments, helpers), { default: webpack } = await import("webpack"), { BannerPlugin, DefinePlugin, IgnorePlugin, ProvidePlugin, SourceMapDevToolPlugin, HotModuleReplacementPlugin } = webpack, bundlerChain = await helpers.modifyBundlerChain(context, {
+        ...chainUtils,
+        bundler: {
+            BannerPlugin,
+            DefinePlugin,
+            IgnorePlugin,
+            ProvidePlugin,
+            SourceMapDevToolPlugin,
+            HotModuleReplacementPlugin
+        }
+    }), webpackConfig = (await modifyWebpackChain(context, chainUtils, bundlerChain)).toConfig(), configUtils = helpers.getConfigUtils(()=>webpackConfig, chainUtils);
+    return webpackConfig = await modifyWebpackConfig(context, webpackConfig, configUtils);
+}
+async function initConfigs({ context, pluginManager, rsbuildOptions, helpers }) {
+    let normalizedConfig = await helpers.initRsbuildConfig({
+        context,
+        pluginManager
+    }), webpackConfigs = await Promise.all(Object.entries(normalizedConfig.environments).map(([environment, config])=>generateWebpackConfig({
+            target: config.output.target,
+            context,
+            environment,
+            helpers
+        })));
+    if ('verbose' === logger.level) {
+        let inspect = async ()=>{
+            await helpers.inspectConfig({
+                context,
+                bundler: 'webpack',
+                pluginManager,
+                inspectOptions: {
+                    verbose: !0,
+                    writeToDisk: !0
+                },
+                rsbuildOptions,
+                bundlerConfigs: webpackConfigs
+            });
+        };
+        context.hooks.onBeforeBuild.tap(async ({ isFirstCompile })=>{
+            isFirstCompile && await inspect();
+        }), context.hooks.onAfterStartDevServer.tap(inspect);
+    }
+    return {
+        webpackConfigs
+    };
+}
+async function createCompiler_createCompiler(options) {
+    logger.debug('creating compiler');
+    let HOOK_NAME = 'rsbuild:compiler', { helpers, context } = options, { webpackConfigs } = await initConfigs(options);
+    await context.hooks.onBeforeCreateCompiler.callBatch({
+        bundlerConfigs: webpackConfigs,
+        environments: context.environments
+    });
+    let { default: webpack } = await import("webpack"), compiler = webpack(1 === webpackConfigs.length ? webpackConfigs[0] : webpackConfigs);
+    return compiler.hooks.run.tap(HOOK_NAME, ()=>{
+        context.buildState.status = 'building';
+    }), compiler.hooks.watchRun.tap(HOOK_NAME, ()=>{
+        context.buildState.status = 'building';
+    }), compiler.hooks.invalid.tap(HOOK_NAME, ()=>{
+        context.buildState.stats = null, context.buildState.status = 'idle', context.buildState.hasErrors = !1;
+    }), compiler.hooks.done.tap(HOOK_NAME, (statsInstance)=>{
+        let stats = helpers.getRsbuildStats(statsInstance, compiler, context.action), hasErrors = statsInstance.hasErrors();
+        context.buildState.stats = stats, context.buildState.status = 'done', context.buildState.hasErrors = hasErrors, context.socketServer?.onBuildDone();
+        let { message, level } = helpers.formatStats(stats, hasErrors);
+        'error' === level ? logger.error(message) : 'warning' === level && logger.warn(message);
+    }), 'dev' === context.action && helpers.registerDevHook({
+        compiler,
+        context,
+        bundlerConfigs: webpackConfigs,
+        MultiStatsCtor: MultiStats
+    }), await context.hooks.onAfterCreateCompiler.callBatch({
+        compiler,
+        environments: context.environments
+    }), logger.debug('compiler created'), {
+        compiler,
+        webpackConfigs
+    };
+}
+let build = async (initOptions, { watch, compiler: customCompiler } = {})=>{
+    let compiler, bundlerConfigs, { helpers, context } = initOptions;
+    if (customCompiler) compiler = customCompiler, bundlerConfigs = customCompiler.options;
+    else {
+        let result = await createCompiler_createCompiler(initOptions);
+        compiler = result.compiler, bundlerConfigs = result.webpackConfigs;
+    }
+    if (helpers.registerBuildHook({
+        context,
+        bundlerConfigs: bundlerConfigs,
+        compiler,
+        isWatch: !!watch,
+        MultiStatsCtor: MultiStats
+    }), watch) return compiler.watch({}, (err)=>{
+        err && logger.error(err);
+    }), {
+        close: ()=>new Promise((resolve)=>{
+                compiler.close(()=>{
+                    resolve();
+                });
+            })
+    };
+    let { stats } = await new Promise((resolve, reject)=>{
+        compiler.run((err, stats)=>{
+            err ? reject(err) : context.buildState.hasErrors ? reject(Error('webpack build failed.')) : compiler.close((closeErr)=>{
+                closeErr && logger.error(closeErr), resolve({
+                    stats
+                });
+            });
+        });
+    });
+    return {
+        stats,
+        close: async ()=>{}
+    };
+};
+async function applyTsConfigPathsPlugin({ chain, CHAIN_ID, mainFields, extensions, configFile }) {
+    let { TsconfigPathsPlugin } = await import("tsconfig-paths-webpack-plugin");
+    chain.resolve.plugin(CHAIN_ID.RESOLVE_PLUGIN.TS_CONFIG_PATHS).use(TsconfigPathsPlugin, [
+        {
+            configFile,
+            extensions,
+            mainFields: mainFields
+        }
+    ]);
+}
+function isWebTarget(target) {
+    return castArray(target).includes('web') || target.includes('web-worker');
+}
+let webpackProvider = async ({ context, pluginManager, rsbuildOptions, helpers })=>{
+    let { default: cssExtractPlugin } = await import("mini-css-extract-plugin");
+    if (helpers.setCssExtractPlugin(cssExtractPlugin), helpers.setHTMLPlugin) {
+        let { default: htmlPlugin } = await import("html-webpack-plugin");
+        helpers.setHTMLPlugin(htmlPlugin);
+    }
+    let createCompiler = async ()=>(await createCompiler_createCompiler({
+            context,
+            pluginManager,
+            rsbuildOptions,
+            helpers
+        })).compiler;
+    return pluginManager.addPlugins([
+        {
+            name: 'rsbuild-webpack:adaptor',
+            setup (api) {
+                api.modifyBundlerChain(async (chain, { CHAIN_ID, environment, target })=>{
+                    let mainFields, { config, tsconfigPath } = environment, aliasStrategy = config.source.aliasStrategy ?? config.resolve.aliasStrategy;
+                    tsconfigPath && 'prefer-tsconfig' === aliasStrategy && await applyTsConfigPathsPlugin({
+                        chain,
+                        CHAIN_ID,
+                        configFile: tsconfigPath,
+                        mainFields: (mainFields = chain.resolve.mainFields.values()).length ? mainFields : isWebTarget(target) ? [
+                            'browser',
+                            'module',
+                            'main'
+                        ] : [
+                            'module',
+                            'main'
+                        ],
+                        extensions: chain.resolve.extensions.values()
+                    });
+                    let { progressBar } = config.dev;
+                    if (progressBar) {
+                        let { ProgressPlugin } = await import("./0~999.js").then((mod)=>({
+                                ProgressPlugin: mod.ProgressPlugin
+                            }));
+                        chain.plugin(CHAIN_ID.PLUGIN.PROGRESS).use(ProgressPlugin, [
+                            {
+                                id: environment.name,
+                                prettyTime: helpers.prettyTime,
+                                ...!0 === progressBar ? {} : progressBar
+                            }
+                        ]);
+                    }
+                    let { copy } = config.output;
+                    if (copy) {
+                        let { default: CopyPlugin } = await import("copy-webpack-plugin"), options = Array.isArray(copy) ? {
+                            patterns: copy
+                        } : copy;
+                        chain.plugin(CHAIN_ID.PLUGIN.COPY).use(CopyPlugin, [
+                            options
+                        ]);
+                    }
+                }), api.modifyWebpackConfig(async (config)=>{
+                    let copyPlugin = config.plugins?.find((item)=>item?.constructor.name === 'CopyPlugin');
+                    copyPlugin && copyPlugin.patterns.every((pattern)=>'string' != typeof pattern && pattern.context && !node_fs.existsSync(pattern.context)) && (config.plugins = config.plugins?.filter((item)=>item?.constructor.name !== 'CopyPlugin'));
+                });
+            }
+        }
+    ]), {
+        bundler: 'webpack',
+        createCompiler,
+        async initConfigs () {
+            let { webpackConfigs } = await initConfigs({
+                context,
+                pluginManager,
+                rsbuildOptions,
+                helpers
+            });
+            return webpackConfigs;
+        },
+        async createDevServer (options) {
+            let config = await helpers.initRsbuildConfig({
+                context,
+                pluginManager
+            });
+            return helpers.createDevServer({
+                context,
+                pluginManager,
+                rsbuildOptions
+            }, createCompiler, config, options);
+        },
+        async startDevServer (options) {
+            let config = await helpers.initRsbuildConfig({
+                context,
+                pluginManager
+            });
+            return (await helpers.createDevServer({
+                context,
+                pluginManager,
+                rsbuildOptions
+            }, createCompiler, config, options)).listen();
+        },
+        build: async (options)=>build({
+                context,
+                pluginManager,
+                rsbuildOptions,
+                helpers
+            }, options),
+        async inspectConfig (inspectOptions) {
+            let bundlerConfigs = (await initConfigs({
+                context,
+                pluginManager,
+                rsbuildOptions,
+                helpers
+            })).webpackConfigs;
+            return await helpers.inspectConfig({
+                context,
+                pluginManager,
+                bundler: 'webpack',
+                bundlerConfigs,
+                rsbuildOptions,
+                inspectOptions
+            });
+        }
+    };
+};
+export { logger, webpackProvider };