@rspack-debug/cli 1.3.14

package/dist/index.js

@@ -0,0 +1,795 @@
+"use strict";
+var __webpack_modules__ = {
+    "@rspack/core": function(module) {
+        module.exports = require("@rspack/core");
+    },
+    "node:fs": function(module) {
+        module.exports = require("node:fs");
+    },
+    "node:path": function(module) {
+        module.exports = require("node:path");
+    },
+    "@discoveryjs/json-ext": function(module) {
+        module.exports = import("@discoveryjs/json-ext").then(function(module) {
+            return module;
+        });
+    },
+    "@rspack/dev-server": function(module) {
+        module.exports = import("@rspack/dev-server").then(function(module) {
+            return module;
+        });
+    },
+    "exit-hook": function(module) {
+        module.exports = import("exit-hook").then(function(module) {
+            return module;
+        });
+    },
+    interpret: function(module) {
+        module.exports = import("interpret").then(function(module) {
+            return module;
+        });
+    },
+    rechoir: function(module) {
+        module.exports = import("rechoir").then(function(module) {
+            return module;
+        });
+    },
+    "webpack-bundle-analyzer": function(module) {
+        module.exports = import("webpack-bundle-analyzer").then(function(module) {
+            return module;
+        });
+    }
+};
+var __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] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (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_require__.f = {};
+    __webpack_require__.e = (chunkId)=>Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key)=>{
+            __webpack_require__.f[key](chunkId, promises);
+            return promises;
+        }, []));
+})();
+(()=>{
+    __webpack_require__.u = (chunkId)=>"" + chunkId + ".js";
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+(()=>{
+    var installedChunks = {
+        980: 1
+    };
+    var installChunk = (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 i = 0; i < chunkIds.length; i++)installedChunks[chunkIds[i]] = 1;
+    };
+    __webpack_require__.f.require = (chunkId, promises)=>{
+        if (!installedChunks[chunkId]) installChunk(require("./" + __webpack_require__.u(chunkId)));
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        definePlugin: ()=>definePlugin,
+        RspackCLI: ()=>RspackCLI,
+        defineConfig: ()=>defineConfig
+    });
+    var external_node_path_ = __webpack_require__("node:path");
+    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_);
+    const external_node_util_namespaceObject = require("node:util");
+    var external_node_util_default = /*#__PURE__*/ __webpack_require__.n(external_node_util_namespaceObject);
+    var core_ = __webpack_require__("@rspack/core");
+    const external_colorette_namespaceObject = require("colorette");
+    const external_yargs_namespaceObject = require("yargs");
+    var external_yargs_default = /*#__PURE__*/ __webpack_require__.n(external_yargs_namespaceObject);
+    const helpers_namespaceObject = require("yargs/helpers");
+    var external_node_fs_ = __webpack_require__("node:fs");
+    var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_);
+    const commonOptions = (yargs)=>yargs.options({
+            config: {
+                g: true,
+                type: "string",
+                describe: "config file",
+                alias: "c"
+            },
+            configName: {
+                type: "array",
+                string: true,
+                describe: "Name of the configuration to use."
+            },
+            configLoader: {
+                type: "string",
+                default: "register",
+                describe: "Specify the loader to load the config file, can be `native` or `register`."
+            },
+            nodeEnv: {
+                string: true,
+                describe: "sets `process.env.NODE_ENV` to be specified value"
+            }
+        });
+    const commonOptionsForBuildAndServe = (yargs)=>yargs.options({
+            entry: {
+                type: "array",
+                string: true,
+                describe: "entry file"
+            },
+            outputPath: {
+                type: "string",
+                describe: "output path dir",
+                alias: "o"
+            },
+            mode: {
+                type: "string",
+                describe: "mode",
+                alias: "m"
+            },
+            watch: {
+                type: "boolean",
+                default: false,
+                describe: "watch",
+                alias: "w"
+            },
+            env: {
+                type: "array",
+                string: true,
+                describe: "env passed to config function"
+            },
+            devtool: {
+                type: "boolean",
+                default: false,
+                describe: "devtool",
+                alias: "d"
+            }
+        }).alias({
+            v: "version",
+            h: "help"
+        });
+    function normalizeEnv(argv) {
+        function parseValue(previous, value) {
+            const [allKeys, val] = value.split(/=(.+)/, 2);
+            const splitKeys = allKeys.split(/\.(?!$)/);
+            let prevRef = previous;
+            splitKeys.forEach((key, index)=>{
+                let someKey = key;
+                if (someKey.endsWith("=")) {
+                    someKey = someKey.slice(0, -1);
+                    prevRef[someKey] = void 0;
+                    return;
+                }
+                if (!prevRef[someKey] || "string" == typeof prevRef[someKey]) prevRef[someKey] = {};
+                if (index === splitKeys.length - 1) if ("string" == typeof val) prevRef[someKey] = val;
+                else prevRef[someKey] = true;
+                prevRef = prevRef[someKey];
+            });
+            return previous;
+        }
+        const envObj = (argv.env ?? []).reduce(parseValue, {});
+        argv.env = envObj;
+    }
+    function setBuiltinEnvArg(env, envNameSuffix, value) {
+        const envNames = [
+            `RSPACK_${envNameSuffix}`
+        ];
+        for (const envName of envNames)if (!(envName in env)) env[envName] = value;
+    }
+    function ensureEnvObject(options) {
+        if (Array.isArray(options.env)) normalizeEnv(options);
+        options.env = options.env || {};
+        return options.env;
+    }
+    function setDefaultNodeEnv(options, defaultEnv) {
+        if (void 0 !== process.env.NODE_ENV) return;
+        process.env.NODE_ENV = "string" == typeof options.nodeEnv ? options.nodeEnv : defaultEnv;
+    }
+    class BuildCommand {
+        async apply(cli) {
+            cli.program.command([
+                "build",
+                "$0",
+                "bundle",
+                "b"
+            ], "run the rspack build", (yargs)=>{
+                commonOptionsForBuildAndServe(commonOptions(yargs)).options({
+                    analyze: {
+                        type: "boolean",
+                        default: false,
+                        describe: "analyze"
+                    },
+                    json: {
+                        describe: "emit stats json"
+                    },
+                    profile: {
+                        type: "boolean",
+                        default: false,
+                        describe: "capture timing information for each module"
+                    }
+                });
+            }, async (options)=>{
+                setDefaultNodeEnv(options, "production");
+                const env = ensureEnvObject(options);
+                if (options.watch) setBuiltinEnvArg(env, "WATCH", true);
+                else {
+                    setBuiltinEnvArg(env, "BUNDLE", true);
+                    setBuiltinEnvArg(env, "BUILD", true);
+                }
+                const logger = cli.getLogger();
+                let createJsonStringifyStream;
+                if (options.json) {
+                    const jsonExt = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@discoveryjs/json-ext"));
+                    createJsonStringifyStream = jsonExt.default.stringifyStream;
+                }
+                const errorHandler = (error, stats)=>{
+                    if (error) {
+                        logger.error(error);
+                        process.exit(2);
+                    }
+                    if (null == stats ? void 0 : stats.hasErrors()) process.exitCode = 1;
+                    if (!compiler || !stats) return;
+                    const statsOptions = cli.isMultipleCompiler(compiler) ? {
+                        children: compiler.compilers.map((compiler)=>compiler.options ? compiler.options.stats : void 0)
+                    } : compiler.options ? compiler.options.stats : void 0;
+                    if (options.json && createJsonStringifyStream) {
+                        const handleWriteError = (error)=>{
+                            logger.error(error);
+                            process.exit(2);
+                        };
+                        if (true === options.json) createJsonStringifyStream(stats.toJson(statsOptions)).on("error", handleWriteError).pipe(process.stdout).on("error", handleWriteError).on("close", ()=>process.stdout.write("\n"));
+                        else if ("string" == typeof options.json) createJsonStringifyStream(stats.toJson(statsOptions)).on("error", handleWriteError).pipe(external_node_fs_.createWriteStream(options.json)).on("error", handleWriteError).on("close", ()=>{
+                            process.stderr.write(`[rspack-cli] ${cli.colors.green(`stats are successfully stored as json to ${options.json}`)}\n`);
+                        });
+                    } else {
+                        const printedStats = stats.toString(statsOptions);
+                        if (printedStats) logger.raw(printedStats);
+                    }
+                };
+                const rspackOptions = {
+                    ...options,
+                    argv: {
+                        ...options
+                    }
+                };
+                const compiler = await cli.createCompiler(rspackOptions, "build", errorHandler);
+                if (!compiler || cli.isWatch(compiler)) return;
+                compiler.run((error, stats)=>{
+                    compiler.close((closeErr)=>{
+                        if (closeErr) logger.error(closeErr);
+                        errorHandler(error, stats);
+                    });
+                });
+            });
+        }
+    }
+    const previewOptions = (yargs)=>{
+        yargs.positional("dir", {
+            type: "string",
+            describe: "directory want to preview"
+        });
+        return commonOptions(yargs).options({
+            publicPath: {
+                type: "string",
+                describe: "static resource server path"
+            },
+            port: {
+                type: "number",
+                describe: "preview server port"
+            },
+            host: {
+                type: "string",
+                describe: "preview server host"
+            },
+            open: {
+                type: "boolean",
+                describe: "open browser"
+            },
+            server: {
+                type: "string",
+                describe: "Configuration items for the server."
+            }
+        });
+    };
+    const defaultRoot = "dist";
+    class PreviewCommand {
+        async apply(cli) {
+            cli.program.command([
+                "preview [dir]",
+                "preview",
+                "p"
+            ], "run the rspack server for build output", previewOptions, async (options)=>{
+                setDefaultNodeEnv(options, "production");
+                const rspackOptions = {
+                    ...options,
+                    argv: {
+                        ...options
+                    }
+                };
+                const { RspackDevServer } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@rspack/dev-server"));
+                let config = await cli.loadConfig(rspackOptions);
+                config = await getPreviewConfig(config, options);
+                if (!Array.isArray(config)) config = [
+                    config
+                ];
+                config = config.find((item)=>item.devServer) || config[0];
+                const devServerOptions = config.devServer;
+                try {
+                    const compiler = (0, core_.rspack)({
+                        entry: {}
+                    });
+                    if (!compiler) return;
+                    const server = new RspackDevServer(devServerOptions, compiler);
+                    await server.start();
+                } catch (error) {
+                    const logger = cli.getLogger();
+                    logger.error(error);
+                    process.exit(2);
+                }
+            });
+        }
+    }
+    async function getPreviewConfig(item, options) {
+        const internalPreviewConfig = async (item)=>{
+            var _item_output, _item_devServer, _item_devServer1, _item_devServer2, _item_devServer3, _item_devServer4;
+            item.devServer = {
+                static: {
+                    directory: options.dir ? external_node_path_default().join(item.context ?? process.cwd(), options.dir) : (null == (_item_output = item.output) ? void 0 : _item_output.path) ?? external_node_path_default().join(item.context ?? process.cwd(), defaultRoot),
+                    publicPath: options.publicPath ?? "/"
+                },
+                port: options.port ?? 8080,
+                proxy: null == (_item_devServer = item.devServer) ? void 0 : _item_devServer.proxy,
+                host: options.host ?? (null == (_item_devServer1 = item.devServer) ? void 0 : _item_devServer1.host),
+                open: options.open ?? (null == (_item_devServer2 = item.devServer) ? void 0 : _item_devServer2.open),
+                server: options.server ?? (null == (_item_devServer3 = item.devServer) ? void 0 : _item_devServer3.server),
+                historyApiFallback: null == (_item_devServer4 = item.devServer) ? void 0 : _item_devServer4.historyApiFallback
+            };
+            return item;
+        };
+        if (Array.isArray(item)) return Promise.all(item.map(internalPreviewConfig));
+        return internalPreviewConfig(item);
+    }
+    class ServeCommand {
+        async apply(cli) {
+            cli.program.command([
+                "serve",
+                "server",
+                "s",
+                "dev"
+            ], "run the rspack dev server.", (yargs)=>commonOptionsForBuildAndServe(commonOptions(yargs)).options({
+                    hot: {
+                        coerce: (arg)=>{
+                            if ("boolean" == typeof arg || "only" === arg) return arg;
+                            if ("false" === arg) return false;
+                            return true;
+                        },
+                        describe: "enables hot module replacement"
+                    },
+                    port: {
+                        type: "number",
+                        coerce: (arg)=>Number.isInteger(arg) ? arg : void 0,
+                        describe: "allows to specify a port to use"
+                    },
+                    host: {
+                        type: "string",
+                        describe: "allows to specify a hostname to use"
+                    }
+                }), async (options)=>{
+                setDefaultNodeEnv(options, "development");
+                setBuiltinEnvArg(ensureEnvObject(options), "SERVE", true);
+                const rspackOptions = {
+                    ...options,
+                    argv: {
+                        ...options
+                    }
+                };
+                const { RspackDevServer } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "@rspack/dev-server"));
+                const compiler = await cli.createCompiler(rspackOptions, "serve");
+                if (!compiler) return;
+                const compilers = cli.isMultipleCompiler(compiler) ? compiler.compilers : [
+                    compiler
+                ];
+                const possibleCompilers = compilers.filter((compiler)=>compiler.options.devServer);
+                const usedPorts = [];
+                const servers = [];
+                const compilerForDevServer = possibleCompilers.length > 0 ? possibleCompilers[0] : compilers[0];
+                for (const compiler of compilers){
+                    const devServer = compiler.options.devServer ??= {};
+                    devServer.hot = options.hot ?? devServer.hot ?? true;
+                    if (false !== devServer.client) {
+                        if (true === devServer.client || null == devServer.client) devServer.client = {};
+                        devServer.client = {
+                            overlay: {
+                                errors: true,
+                                warnings: false
+                            },
+                            ...devServer.client
+                        };
+                    }
+                }
+                const result = compilerForDevServer.options.devServer ??= {};
+                if (compilerForDevServer.options.experiments.lazyCompilation) {
+                    const options = compilerForDevServer.options.experiments.lazyCompilation;
+                    const setupMiddlewares = result.setupMiddlewares;
+                    const lazyCompileMiddleware = core_.rspack.experiments.lazyCompilationMiddleware(compilerForDevServer, options);
+                    result.setupMiddlewares = (middlewares, server)=>{
+                        let finalMiddlewares = middlewares;
+                        if (setupMiddlewares) finalMiddlewares = setupMiddlewares(finalMiddlewares, server);
+                        return [
+                            lazyCompileMiddleware,
+                            ...finalMiddlewares
+                        ];
+                    };
+                }
+                result.hot = options.hot ?? result.hot ?? true;
+                result.host = options.host || result.host;
+                result.port = options.port || result.port;
+                if (false !== result.client) {
+                    if (true === result.client || null == result.client) result.client = {};
+                    result.client = {
+                        overlay: {
+                            errors: true,
+                            warnings: false
+                        },
+                        ...result.client
+                    };
+                }
+                const devServerOptions = result;
+                if (devServerOptions.port) {
+                    const portNumber = Number(devServerOptions.port);
+                    if (!Number.isNaN(portNumber)) {
+                        if (usedPorts.find((port)=>portNumber === port)) throw new Error("Unique ports must be specified for each devServer option in your rspack configuration. Alternatively, run only 1 devServer config using the --config-name flag to specify your desired config.");
+                        usedPorts.push(portNumber);
+                    }
+                }
+                try {
+                    const server = new RspackDevServer(devServerOptions, compiler);
+                    await server.start();
+                    servers.push(server);
+                } catch (error) {
+                    const logger = cli.getLogger();
+                    logger.error(error);
+                    process.exit(2);
+                }
+            });
+        }
+    }
+    const external_node_url_namespaceObject = require("node:url");
+    const readPackageUp_readPackageUp = (cwd = process.cwd())=>{
+        let currentDir = external_node_path_default().resolve(cwd);
+        let packageJsonPath = external_node_path_default().join(currentDir, "package.json");
+        while(!external_node_fs_default().existsSync(packageJsonPath)){
+            const parentDir = external_node_path_default().dirname(currentDir);
+            if (parentDir === currentDir) return null;
+            currentDir = parentDir;
+            packageJsonPath = external_node_path_default().join(currentDir, "package.json");
+        }
+        try {
+            return JSON.parse(external_node_fs_default().readFileSync(packageJsonPath, "utf8"));
+        } catch (error) {
+            return null;
+        }
+    };
+    const readPackageUp = readPackageUp_readPackageUp;
+    const isEsmFile = (filePath, cwd = process.cwd())=>{
+        const ext = external_node_path_default().extname(filePath);
+        if (/\.(mjs|mts)$/.test(ext)) return true;
+        if (/\.(cjs|cts)/.test(ext)) return false;
+        const packageJson = readPackageUp(external_node_path_default().dirname(filePath));
+        return (null == packageJson ? void 0 : packageJson.type) === "module";
+    };
+    const utils_isEsmFile = isEsmFile;
+    const crossImport = async (path, cwd = process.cwd())=>{
+        if (utils_isEsmFile(path, cwd)) {
+            const url = (0, external_node_url_namespaceObject.pathToFileURL)(path).href;
+            const { default: config } = await import(url);
+            return config;
+        }
+        let result = require(path);
+        if (result && "object" == typeof result && "default" in result) result = result.default || {};
+        return result;
+    };
+    const DEFAULT_EXTENSIONS = [
+        ".js",
+        ".ts",
+        ".mjs",
+        ".mts",
+        ".cjs",
+        ".cts"
+    ];
+    const findConfig = (basePath)=>DEFAULT_EXTENSIONS.map((ext)=>basePath + ext).find(external_node_fs_default().existsSync);
+    const utils_findConfig = findConfig;
+    const isTsFile = (configPath)=>{
+        const ext = external_node_path_default().extname(configPath);
+        return /\.(c|m)?ts$/.test(ext);
+    };
+    const utils_isTsFile = isTsFile;
+    const loadConfig_DEFAULT_CONFIG_NAME = "rspack.config";
+    const registerLoader = async (configPath)=>{
+        const ext = external_node_path_default().extname(configPath);
+        if (utils_isEsmFile(configPath) && utils_isTsFile(configPath)) return;
+        const { default: interpret } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "interpret"));
+        const extensions = Object.fromEntries(Object.entries(interpret.extensions).filter(([key])=>key === ext));
+        if (0 === Object.keys(extensions).length) throw new Error(`config file "${configPath}" is not supported.`);
+        try {
+            const { default: rechoir } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "rechoir"));
+            rechoir.prepare(extensions, configPath);
+        } catch (error) {
+            const failures = null == error ? void 0 : error.failures;
+            if (failures) {
+                const messages = failures.map((failure)=>failure.error.message);
+                throw new Error(`${messages.join("\n")}`);
+            }
+            throw error;
+        }
+    };
+    async function loadExtendedConfig(config, configPath, cwd, options) {
+        if (!("extends" in config) || !config.extends) return config;
+        const extendsList = Array.isArray(config.extends) ? config.extends : [
+            config.extends
+        ];
+        const { extends: _, ...configWithoutExtends } = config;
+        const baseDir = external_node_path_default().dirname(configPath);
+        let resultConfig = configWithoutExtends;
+        for (const extendPath of extendsList){
+            let resolvedPath;
+            if (extendPath.startsWith(".") || extendPath.startsWith("/") || extendPath.includes(":\\")) {
+                resolvedPath = external_node_path_default().resolve(baseDir, extendPath);
+                if (!external_node_path_default().extname(resolvedPath)) {
+                    const foundConfig = utils_findConfig(resolvedPath);
+                    if (foundConfig) resolvedPath = foundConfig;
+                    else throw new Error(`Extended configuration file "${resolvedPath}" not found.`);
+                }
+            } else try {
+                resolvedPath = require.resolve(extendPath, {
+                    paths: [
+                        baseDir,
+                        cwd
+                    ]
+                });
+            } catch (error) {
+                throw new Error(`Cannot find module '${extendPath}' to extend from.`);
+            }
+            if (!external_node_fs_default().existsSync(resolvedPath)) throw new Error(`Extended configuration file "${resolvedPath}" not found.`);
+            if (utils_isTsFile(resolvedPath) && "register" === options.configLoader) await registerLoader(resolvedPath);
+            let extendedConfig = await crossImport(resolvedPath, cwd);
+            if ("function" == typeof extendedConfig) {
+                var _options_argv;
+                extendedConfig = extendedConfig(null == (_options_argv = options.argv) ? void 0 : _options_argv.env, options.argv);
+                if ("function" == typeof extendedConfig.then) extendedConfig = await extendedConfig;
+            }
+            extendedConfig = await loadExtendedConfig(extendedConfig, resolvedPath, cwd, options);
+            resultConfig = core_.util.cleverMerge(extendedConfig, resultConfig);
+        }
+        return resultConfig;
+    }
+    async function loadRspackConfig(options, cwd = process.cwd()) {
+        let configPath;
+        let loadedConfig;
+        if (options.config) {
+            configPath = external_node_path_default().resolve(cwd, options.config);
+            if (!external_node_fs_default().existsSync(configPath)) throw new Error(`config file "${configPath}" not found.`);
+            if (utils_isTsFile(configPath) && "register" === options.configLoader) await registerLoader(configPath);
+            loadedConfig = await crossImport(configPath, cwd);
+        } else {
+            const defaultConfig = utils_findConfig(external_node_path_default().resolve(cwd, loadConfig_DEFAULT_CONFIG_NAME));
+            if (!defaultConfig) return {};
+            configPath = defaultConfig;
+            if (utils_isTsFile(defaultConfig) && "register" === options.configLoader) await registerLoader(defaultConfig);
+            loadedConfig = await crossImport(defaultConfig, cwd);
+        }
+        if ("function" != typeof loadedConfig && configPath) loadedConfig = await loadExtendedConfig(loadedConfig, configPath, cwd, options);
+        return loadedConfig;
+    }
+    function _define_property(obj, key, value) {
+        if (key in obj) Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+        else obj[key] = value;
+        return obj;
+    }
+    class RspackCLI {
+        async createCompiler(options, rspackCommand, callback) {
+            process.env.RSPACK_CONFIG_VALIDATE ??= "loose";
+            let config = await this.loadConfig(options);
+            config = await this.buildConfig(config, options, rspackCommand);
+            const isWatch = Array.isArray(config) ? config.some((i)=>i.watch) : config.watch;
+            let compiler;
+            try {
+                compiler = (0, core_.rspack)(config, isWatch ? callback : void 0);
+            } catch (e) {
+                if (e instanceof core_.ValidationError) {
+                    this.getLogger().error(e.message);
+                    process.exit(2);
+                } else if (e instanceof Error) {
+                    if ("function" == typeof callback) callback(e);
+                    else this.getLogger().error(e);
+                    return null;
+                }
+                throw e;
+            }
+            return compiler;
+        }
+        createColors(useColor) {
+            const shouldUseColor = useColor || external_colorette_namespaceObject.isColorSupported;
+            return {
+                ...(0, external_colorette_namespaceObject.createColors)({
+                    useColor: shouldUseColor
+                }),
+                isColorSupported: shouldUseColor
+            };
+        }
+        getLogger() {
+            return {
+                error: (val)=>console.error(`[rspack-cli] ${this.colors.red(external_node_util_default().format(val))}`),
+                warn: (val)=>console.warn(`[rspack-cli] ${this.colors.yellow(val)}`),
+                info: (val)=>console.info(`[rspack-cli] ${this.colors.cyan(val)}`),
+                success: (val)=>console.log(`[rspack-cli] ${this.colors.green(val)}`),
+                log: (val)=>console.log(`[rspack-cli] ${val}`),
+                raw: (val)=>console.log(val)
+            };
+        }
+        async run(argv) {
+            this.program.showHelpOnFail(false);
+            this.program.usage("[options]");
+            this.program.scriptName("rspack");
+            this.program.strictCommands(true).strict(true);
+            this.program.middleware(normalizeEnv);
+            this.registerCommands();
+            await this.program.parseAsync((0, helpers_namespaceObject.hideBin)(argv));
+        }
+        async registerCommands() {
+            const builtinCommands = [
+                new BuildCommand(),
+                new ServeCommand(),
+                new PreviewCommand()
+            ];
+            for (const command of builtinCommands)command.apply(this);
+        }
+        async buildConfig(item, options, command) {
+            const isBuild = "build" === command;
+            const isServe = "serve" === command;
+            const internalBuildConfig = async (item)=>{
+                if (options.entry) item.entry = {
+                    main: options.entry.map((x)=>external_node_path_default().resolve(process.cwd(), x))[0]
+                };
+                item.output = item.output || {};
+                if (options.outputPath) item.output.path = external_node_path_default().resolve(process.cwd(), options.outputPath);
+                if (options.analyze) {
+                    const { BundleAnalyzerPlugin } = await Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "webpack-bundle-analyzer"));
+                    (item.plugins ??= []).push({
+                        name: "rspack-bundle-analyzer",
+                        apply (compiler) {
+                            new BundleAnalyzerPlugin({
+                                generateStatsFile: true
+                            }).apply(compiler);
+                        }
+                    });
+                }
+                if (options.profile) item.profile = true;
+                if (process.env.RSPACK_PROFILE) {
+                    const { applyProfile } = await __webpack_require__.e("556").then(__webpack_require__.bind(__webpack_require__, "./src/utils/profile.ts"));
+                    await applyProfile(process.env.RSPACK_PROFILE, process.env.RSPACK_TRACE_LAYER, process.env.RSPACK_TRACE_OUTPUT);
+                }
+                if (options.watch) item.watch = options.watch;
+                if (!item.mode) item.mode = isBuild ? "production" : "development";
+                if (options.mode) item.mode = options.mode;
+                if (void 0 === item.devtool) item.devtool = isBuild ? "source-map" : "cheap-module-source-map";
+                if (isServe) {
+                    const installed = (item.plugins ||= []).find((item)=>item instanceof core_.ProgressPlugin);
+                    if (!installed) (item.plugins ??= []).push(new core_.ProgressPlugin());
+                }
+                if (void 0 === item.stats) item.stats = {
+                    preset: "errors-warnings",
+                    timings: true
+                };
+                else if ("boolean" == typeof item.stats) item.stats = item.stats ? {
+                    preset: "normal"
+                } : {
+                    preset: "none"
+                };
+                else if ("string" == typeof item.stats) item.stats = {
+                    preset: item.stats
+                };
+                if (this.colors.isColorSupported && void 0 === item.stats.colors) item.stats.colors = true;
+                return item;
+            };
+            if (Array.isArray(item)) return Promise.all(item.map(internalBuildConfig));
+            return internalBuildConfig(item);
+        }
+        async loadConfig(options) {
+            let loadedConfig = await loadRspackConfig(options);
+            if ("function" == typeof loadedConfig) {
+                var _options_argv;
+                let functionResult = loadedConfig(null == (_options_argv = options.argv) ? void 0 : _options_argv.env, options.argv);
+                if ("function" == typeof functionResult.then) functionResult = await functionResult;
+                loadedConfig = functionResult;
+                if ("extends" in loadedConfig && loadedConfig.extends) {
+                    const tempConfigPath = external_node_path_default().resolve(process.cwd(), "rspack.config.js");
+                    loadedConfig = await loadExtendedConfig(loadedConfig, tempConfigPath, process.cwd(), options);
+                }
+            }
+            if (options.configName) {
+                const notFoundConfigNames = [];
+                loadedConfig = options.configName.map((configName)=>{
+                    let found;
+                    found = Array.isArray(loadedConfig) ? loadedConfig.find((options)=>options.name === configName) : loadedConfig.name === configName ? loadedConfig : void 0;
+                    if (!found) notFoundConfigNames.push(configName);
+                    return found;
+                });
+                if (notFoundConfigNames.length > 0) {
+                    this.getLogger().error(notFoundConfigNames.map((configName)=>`Configuration with the name "${configName}" was not found.`).join(" "));
+                    process.exit(2);
+                }
+            }
+            return loadedConfig;
+        }
+        isMultipleCompiler(compiler) {
+            return Boolean(compiler.compilers);
+        }
+        isWatch(compiler) {
+            return Boolean(this.isMultipleCompiler(compiler) ? compiler.compilers.some((compiler)=>compiler.options.watch) : compiler.options.watch);
+        }
+        constructor(){
+            _define_property(this, "colors", void 0);
+            _define_property(this, "program", void 0);
+            this.colors = this.createColors();
+            this.program = external_yargs_default()();
+        }
+    }
+    function defineConfig(config) {
+        return config;
+    }
+    function definePlugin(plugin) {
+        return plugin;
+    }
+})();
+exports.RspackCLI = __webpack_exports__.RspackCLI;
+exports.defineConfig = __webpack_exports__.defineConfig;
+exports.definePlugin = __webpack_exports__.definePlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "RspackCLI",
+    "defineConfig",
+    "definePlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});