@rsbuild/webpack 1.6.0 → 1.6.2

package/dist/index.js

@@ -1,344 +1 @@
-import * as __WEBPACK_EXTERNAL_MODULE__rsbuild_core_1b356efc__ from "@rsbuild/core";
-import MultiStats from "webpack/lib/MultiStats.js";
-import { reduceConfigsWithContext } from "reduce-configs";
-import node_fs from "node:fs";
-var installedChunks, installChunk, __webpack_modules__ = {
-    "@rsbuild/core": function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE__rsbuild_core_1b356efc__;
-    }
-}, __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        id: moduleId,
-        loaded: !1,
-        exports: {}
-    };
-    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.loaded = !0, module.exports;
-}
-__webpack_require__.m = __webpack_modules__, __webpack_require__.n = (module)=>{
-    var getter = module && module.__esModule ? ()=>module.default : ()=>module;
-    return __webpack_require__.d(getter, {
-        a: getter
-    }), getter;
-}, __webpack_require__.d = (exports, definition)=>{
-    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key) && Object.defineProperty(exports, key, {
-        enumerable: !0,
-        get: definition[key]
-    });
-}, __webpack_require__.f = {}, __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>(__webpack_require__.f[key](chunkId, promises), promises), [])), __webpack_require__.u = (chunkId)=>"0~" + chunkId + ".js", __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.nmd = (module)=>(module.paths = [], module.children || (module.children = []), module), installedChunks = {
-    410: 0
-}, installChunk = (data)=>{
-    var moduleId, chunkId, __webpack_ids__ = data.__webpack_ids__, __webpack_modules__ = data.__webpack_modules__, __webpack_runtime__ = data.__webpack_runtime__, i = 0;
-    for(moduleId in __webpack_modules__)__webpack_require__.o(__webpack_modules__, moduleId) && (__webpack_require__.m[moduleId] = __webpack_modules__[moduleId]);
-    for(__webpack_runtime__ && __webpack_runtime__(__webpack_require__); i < __webpack_ids__.length; i++)chunkId = __webpack_ids__[i], __webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId] && installedChunks[chunkId][0](), installedChunks[__webpack_ids__[i]] = 0;
-}, __webpack_require__.f.j = function(chunkId, promises) {
-    var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : void 0;
-    if (0 !== installedChunkData) if (installedChunkData) promises.push(installedChunkData[1]);
-    else {
-        var promise = import("./" + __webpack_require__.u(chunkId)).then(installChunk, (e)=>{
-            throw 0 !== installedChunks[chunkId] && (installedChunks[chunkId] = void 0), e;
-        }), promise = Promise.race([
-            promise,
-            new Promise((resolve)=>{
-                installedChunkData = installedChunks[chunkId] = [
-                    resolve
-                ];
-            })
-        ]);
-        promises.push(installedChunkData[1] = promise);
-    }
-};
-var core_ = __webpack_require__("@rsbuild/core");
-let castArray = (arr)=>void 0 === arr ? [] : Array.isArray(arr) ? arr : [
-        arr
-    ];
-async function modifyWebpackChain(context, utils, chain) {
-    core_.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 core_.logger.debug('modify webpack chain done'), modifiedChain;
-}
-async function modifyWebpackConfig(context, webpackConfig, utils) {
-    core_.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
-    })), core_.logger.debug('modify webpack config done'), modifiedConfig;
-}
-async function getChainUtils(target, environment, helpers) {
-    let { default: webpack } = await import("webpack");
-    return {
-        ...helpers.getChainUtils(target, environment),
-        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], 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' === core_.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) {
-    core_.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 ? core_.logger.error(message) : 'warning' === level && core_.logger.warn(message);
-    }), 'dev' === context.action && helpers.registerDevHook({
-        compiler,
-        context,
-        bundlerConfigs: webpackConfigs,
-        MultiStatsCtor: MultiStats
-    }), await context.hooks.onAfterCreateCompiler.callBatch({
-        compiler,
-        environments: context.environments
-    }), core_.logger.debug('compiler created'), {
-        compiler,
-        webpackConfigs
-    };
-}
-let build = async (initOptions, { watch, compiler: customCompiler } = {})=>{
-    let compiler, bundlerConfigs, { helpers, context } = initOptions;
-    if (customCompiler) compiler = customCompiler;
-    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 && core_.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 && core_.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
-        }
-    ]);
-}
-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 { config, tsconfigPath } = environment, aliasStrategy = config.source.aliasStrategy ?? config.resolve.aliasStrategy;
-                    tsconfigPath && 'prefer-tsconfig' === aliasStrategy && await applyTsConfigPathsPlugin({
-                        chain,
-                        CHAIN_ID,
-                        configFile: tsconfigPath,
-                        mainFields: ((chain, target)=>{
-                            let mainFields = chain.resolve.mainFields.values();
-                            return mainFields.length ? mainFields : castArray(target).includes('web') || target.includes('web-worker') ? [
-                                'browser',
-                                'module',
-                                'main'
-                            ] : [
-                                'module',
-                                'main'
-                            ];
-                        })(chain, target),
-                        extensions: chain.resolve.extensions.values()
-                    });
-                    let { progressBar } = config.dev;
-                    if (progressBar) {
-                        let { ProgressPlugin } = await Promise.all([
-                            __webpack_require__.e("0"),
-                            __webpack_require__.e("502")
-                        ]).then(__webpack_require__.bind(__webpack_require__, "./src/progress/ProgressPlugin.ts"));
-                        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 { webpackProvider };
+export { webpackProvider } from "./161.js";

package/dist/rslib-runtime.js

@@ -0,0 +1,25 @@
+var __webpack_modules__ = {}, __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        id: moduleId,
+        loaded: !1,
+        exports: {}
+    };
+    return __webpack_modules__[moduleId](module, module.exports, __webpack_require__), module.loaded = !0, module.exports;
+}
+__webpack_require__.m = __webpack_modules__, __webpack_require__.add = function registerModules(modules) {
+    Object.assign(__webpack_require__.m, modules);
+}, __webpack_require__.n = (module)=>{
+    var getter = module && module.__esModule ? ()=>module.default : ()=>module;
+    return __webpack_require__.d(getter, {
+        a: getter
+    }), getter;
+}, __webpack_require__.d = (exports, definition)=>{
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key) && Object.defineProperty(exports, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.nmd = (module)=>(module.paths = [], module.children || (module.children = []), module);
+export { __webpack_require__ };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rsbuild/webpack",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "homepage": "https://rsbuild.rs",
   "repository": {
     "type": "git",
@@ -24,21 +24,21 @@
   ],
   "dependencies": {
     "copy-webpack-plugin": "11.0.0",
-    "html-webpack-plugin": "^5.6.4",
+    "html-webpack-plugin": "^5.6.5",
     "mini-css-extract-plugin": "2.9.4",
     "picocolors": "^1.1.1",
     "reduce-configs": "^1.1.1",
     "tsconfig-paths-webpack-plugin": "4.2.0",
-    "webpack": "^5.102.1"
+    "webpack": "^5.103.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.16.1",
-    "@types/node": "^22.18.12",
+    "@rslib/core": "0.18.0",
+    "@types/node": "^24.10.1",
     "ansi-escapes": "4.3.2",
     "cli-truncate": "2.1.0",
     "patch-console": "1.0.0",
     "typescript": "^5.9.3",
-    "@rsbuild/core": "1.6.0",
+    "@rsbuild/core": "1.6.8",
     "@scripts/test-helper": "1.0.1"
   },
   "peerDependencies": {

package/dist/0~502.js

@@ -1,204 +0,0 @@
-import picocolors from "picocolors";
-import webpack from "webpack";
-import { Console } from "node:console";
-import * as __WEBPACK_EXTERNAL_MODULE_stream__ from "stream";
-export const __webpack_id__ = "502";
-export const __webpack_ids__ = [
-    "502"
-];
-export const __webpack_modules__ = {
-    "./src/progress/ProgressPlugin.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
-        __webpack_require__.d(__webpack_exports__, {
-            ProgressPlugin: ()=>ProgressPlugin
-        });
-        var core_ = __webpack_require__("@rsbuild/core"), cli_truncate = __webpack_require__("../../../node_modules/.pnpm/cli-truncate@2.1.0/node_modules/cli-truncate/index.js"), cli_truncate_default = __webpack_require__.n(cli_truncate);
-        let clamp = (x, min, max)=>Math.min(max, Math.max(min, x)), 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
-        };
-        var build = __webpack_require__("../../../node_modules/.pnpm/patch-console@1.0.0/node_modules/patch-console/build/index.js"), build_default = __webpack_require__.n(build), ansi_escapes = __webpack_require__("../../../node_modules/.pnpm/ansi-escapes@4.3.2/node_modules/ansi-escapes/index.js"), ansi_escapes_default = __webpack_require__.n(ansi_escapes);
-        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();
-            }
-        }();
-        class ProgressPlugin extends webpack.ProgressPlugin {
-            name = 'ProgressPlugin';
-            id;
-            hasCompileErrors = !1;
-            compileTime = null;
-            prettyTime;
-            constructor(options){
-                let prevPercentage, prevPercentage1, { id = 'Rsbuild' } = options, nonTTYLogger = (prevPercentage = 0, {
-                    log: ({ id, done, current, hasErrors, compileTime })=>{
-                        let suffix = picocolors.gray(`(${id})`);
-                        if (done) {
-                            if (100 === prevPercentage) return;
-                            prevPercentage = 100, hasErrors ? core_.logger.error(`built failed in ${compileTime} ${suffix}`) : core_.logger.ready(`built in ${compileTime} ${suffix}`);
-                        } else current - prevPercentage > 10 && (prevPercentage = current, core_.logger.info(`build progress: ${current.toFixed(0)}% ${suffix}`));
-                    }
-                }), friendlyPercentage = (prevPercentage1 = 0, (percentage)=>{
-                    if (0 === percentage || 1 === percentage) return prevPercentage1 = 0, percentage;
-                    if (percentage <= prevPercentage1) {
-                        let step = 0;
-                        return prevPercentage1 < 0.3 ? step = 0.001 : prevPercentage1 < 0.6 ? step = 0.002 : prevPercentage1 < 0.8 ? step = 0.004 : prevPercentage1 < 0.99 && (step = 0.002), prevPercentage1 += step;
-                    }
-                    return prevPercentage1 = 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})`) : '';
-                            core_.logger.ready(`built in ${this.compileTime} ${suffix}`);
-                        }
-                    }
-                });
-            }
-        }
-    },
-    stream: function(module) {
-        module.exports = __WEBPACK_EXTERNAL_MODULE_stream__;
-    }
-};