@rspack/cli 2.0.0-canary.20260120 → 2.0.0-rc.1

package/dist/{131.js → 697.js}

@@ -1,80 +1,105 @@
-import * as __rspack_external_module from "module";
-import * as __rspack_external_path from "path";
-import { __webpack_require__ } from "./rslib-runtime.js";
 import node_path from "node:path";
 import node_util from "node:util";
 import { rspack } from "@rspack/core";
-import { EventEmitter } from "events";
 import node_fs from "node:fs";
 import { createRequire } from "node:module";
 import { pathToFileURL } from "node:url";
+import { createRequire as __rspack_createRequire } from "node:module";
+const __rspack_createRequire_require = __rspack_createRequire(import.meta.url);
+var __webpack_modules__ = {};
+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__;
+(()=>{
+    var getProto = Object.getPrototypeOf ? (obj)=>Object.getPrototypeOf(obj) : (obj)=>obj.__proto__;
+    var leafPrototypes;
+    __webpack_require__.t = function(value, mode) {
+        if (1 & mode) value = this(value);
+        if (8 & mode) return value;
+        if ('object' == typeof value && value) {
+            if (4 & mode && value.__esModule) return value;
+            if (16 & mode && 'function' == typeof value.then) return value;
+        }
+        var ns = Object.create(null);
+        __webpack_require__.r(ns);
+        var def = {};
+        leafPrototypes = leafPrototypes || [
+            null,
+            getProto({}),
+            getProto([]),
+            getProto(getProto)
+        ];
+        for(var current = 2 & mode && value; ('object' == typeof current || 'function' == typeof current) && !~leafPrototypes.indexOf(current); current = getProto(current))Object.getOwnPropertyNames(current).forEach((key)=>{
+            def[key] = ()=>value[key];
+        });
+        def['default'] = ()=>value;
+        __webpack_require__.d(ns, def);
+        return ns;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+var __webpack_require__temp = __webpack_require__;
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports, '__esModule', {
+            value: true
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.nmd = (module)=>{
+        module.paths = [];
+        if (!module.children) module.children = [];
+        return module;
+    };
+})();
+(()=>{
+    var installedChunks = {
+        410: 0,
+        697: 0
+    };
+    var installChunk = (data)=>{
+        var __rspack_esm_ids = data.__rspack_esm_ids;
+        var __webpack_modules__ = data.__webpack_modules__;
+        var __rspack_esm_runtime = data.__rspack_esm_runtime;
+        var moduleId, chunkId, i = 0;
+        for(moduleId in __webpack_modules__)if (__webpack_require__.o(__webpack_modules__, moduleId)) __webpack_require__.m[moduleId] = __webpack_modules__[moduleId];
+        if (__rspack_esm_runtime) __rspack_esm_runtime(__webpack_require__);
+        for(; i < __rspack_esm_ids.length; i++){
+            chunkId = __rspack_esm_ids[i];
+            if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) installedChunks[chunkId][0]();
+            installedChunks[__rspack_esm_ids[i]] = 0;
+        }
+    };
+    __webpack_require__.C = installChunk;
+})();
 __webpack_require__.add({
-    "../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js" (module) {
-        let p = process || {}, argv = p.argv || [], env = p.env || {};
-        let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || "win32" === p.platform || (p.stdout || {}).isTTY && "dumb" !== env.TERM || !!env.CI);
-        let formatter = (open, close, replace = open)=>(input)=>{
-                let string = "" + input, index = string.indexOf(close, open.length);
-                return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
-            };
-        let replaceClose = (string, close, replace, index)=>{
-            let result = "", cursor = 0;
-            do {
-                result += string.substring(cursor, index) + replace;
-                cursor = index + close.length;
-                index = string.indexOf(close, cursor);
-            }while (~index);
-            return result + string.substring(cursor);
-        };
-        let createColors = (enabled = isColorSupported)=>{
-            let f = enabled ? formatter : ()=>String;
-            return {
-                isColorSupported: enabled,
-                reset: f("\x1b[0m", "\x1b[0m"),
-                bold: f("\x1b[1m", "\x1b[22m", "\x1b[22m\x1b[1m"),
-                dim: f("\x1b[2m", "\x1b[22m", "\x1b[22m\x1b[2m"),
-                italic: f("\x1b[3m", "\x1b[23m"),
-                underline: f("\x1b[4m", "\x1b[24m"),
-                inverse: f("\x1b[7m", "\x1b[27m"),
-                hidden: f("\x1b[8m", "\x1b[28m"),
-                strikethrough: f("\x1b[9m", "\x1b[29m"),
-                black: f("\x1b[30m", "\x1b[39m"),
-                red: f("\x1b[31m", "\x1b[39m"),
-                green: f("\x1b[32m", "\x1b[39m"),
-                yellow: f("\x1b[33m", "\x1b[39m"),
-                blue: f("\x1b[34m", "\x1b[39m"),
-                magenta: f("\x1b[35m", "\x1b[39m"),
-                cyan: f("\x1b[36m", "\x1b[39m"),
-                white: f("\x1b[37m", "\x1b[39m"),
-                gray: f("\x1b[90m", "\x1b[39m"),
-                bgBlack: f("\x1b[40m", "\x1b[49m"),
-                bgRed: f("\x1b[41m", "\x1b[49m"),
-                bgGreen: f("\x1b[42m", "\x1b[49m"),
-                bgYellow: f("\x1b[43m", "\x1b[49m"),
-                bgBlue: f("\x1b[44m", "\x1b[49m"),
-                bgMagenta: f("\x1b[45m", "\x1b[49m"),
-                bgCyan: f("\x1b[46m", "\x1b[49m"),
-                bgWhite: f("\x1b[47m", "\x1b[49m"),
-                blackBright: f("\x1b[90m", "\x1b[39m"),
-                redBright: f("\x1b[91m", "\x1b[39m"),
-                greenBright: f("\x1b[92m", "\x1b[39m"),
-                yellowBright: f("\x1b[93m", "\x1b[39m"),
-                blueBright: f("\x1b[94m", "\x1b[39m"),
-                magentaBright: f("\x1b[95m", "\x1b[39m"),
-                cyanBright: f("\x1b[96m", "\x1b[39m"),
-                whiteBright: f("\x1b[97m", "\x1b[39m"),
-                bgBlackBright: f("\x1b[100m", "\x1b[49m"),
-                bgRedBright: f("\x1b[101m", "\x1b[49m"),
-                bgGreenBright: f("\x1b[102m", "\x1b[49m"),
-                bgYellowBright: f("\x1b[103m", "\x1b[49m"),
-                bgBlueBright: f("\x1b[104m", "\x1b[49m"),
-                bgMagentaBright: f("\x1b[105m", "\x1b[49m"),
-                bgCyanBright: f("\x1b[106m", "\x1b[49m"),
-                bgWhiteBright: f("\x1b[107m", "\x1b[49m")
-            };
-        };
-        module.exports = createColors();
-        module.exports.createColors = createColors;
-    },
     "../../node_modules/.pnpm/pirates@4.0.7/node_modules/pirates/lib/index.js" (module, exports, __webpack_require__) {
         module = __webpack_require__.nmd(module);
         const BuiltinModule = __webpack_require__("module");
@@ -136,10 +161,16 @@ __webpack_require__.add({
         exports.addHook = addHook;
     },
     module (module) {
-        module.exports = __rspack_external_module;
+        module.exports = __rspack_createRequire_require("module");
     },
     path (module) {
-        module.exports = __rspack_external_path;
+        module.exports = __rspack_createRequire_require("path");
+    },
+    stream (module) {
+        module.exports = __rspack_createRequire_require("stream");
+    },
+    util (module) {
+        module.exports = __rspack_createRequire_require("util");
     }
 });
 function toArr(any) {
@@ -148,13 +179,13 @@ function toArr(any) {
     ];
 }
 function toVal(out, key, val, opts) {
-    var x, old = out[key], nxt = ~opts.string.indexOf(key) ? null == val || true === val ? '' : String(val) : 'boolean' == typeof val ? val : ~opts.boolean.indexOf(key) ? 'false' === val ? false : 'true' === val || (out._.push((x = +val, 0 * x === 0) ? x : val), !!val) : (x = +val, 0 * x === 0) ? x : val;
+    var x, old = out[key], nxt = ~opts.string.indexOf(key) ? null == val || true === val ? "" : String(val) : "boolean" == typeof val ? val : ~opts.boolean.indexOf(key) ? "false" === val ? false : "true" === val || (out._.push((x = +val, 0 * x === 0) ? x : val), !!val) : (x = +val, 0 * x === 0) ? x : val;
     out[key] = null == old ? nxt : Array.isArray(old) ? old.concat(nxt) : [
         old,
         nxt
     ];
 }
-function mri2(args, opts) {
+function lib_default(args, opts) {
     args = args || [];
     opts = opts || {};
     var k, arr, arg, name, val, out = {
@@ -190,26 +221,26 @@ function mri2(args, opts) {
     const keys = strict ? Object.keys(opts.alias) : [];
     for(i = 0; i < len; i++){
         arg = args[i];
-        if ('--' === arg) {
+        if ("--" === arg) {
             out._ = out._.concat(args.slice(++i));
             break;
         }
         for(j = 0; j < arg.length && 45 === arg.charCodeAt(j); j++);
         if (0 === j) out._.push(arg);
-        else if ('no-' === arg.substring(j, j + 3)) {
+        else if ("no-" === arg.substring(j, j + 3)) {
             name = arg.substring(j + 3);
             if (strict && !~keys.indexOf(name)) return opts.unknown(arg);
             out[name] = false;
         } else {
             for(idx = j + 1; idx < arg.length && 61 !== arg.charCodeAt(idx); idx++);
             name = arg.substring(j, idx);
-            val = arg.substring(++idx) || i + 1 === len || 45 === ('' + args[i + 1]).charCodeAt(0) || args[++i];
+            val = arg.substring(++idx) || i + 1 === len || 45 === ("" + args[i + 1]).charCodeAt(0) || args[++i];
             arr = 2 === j ? [
                 name
             ] : name;
             for(idx = 0; idx < arr.length; idx++){
                 name = arr[idx];
-                if (strict && !~keys.indexOf(name)) return opts.unknown('-'.repeat(j) + name);
+                if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
                 toVal(out, name, idx + 1 < arr.length || val, opts);
             }
         }
@@ -223,8 +254,10 @@ function mri2(args, opts) {
     }
     return out;
 }
-const removeBrackets = (v)=>v.replace(/[<[].+/, "").trim();
-const findAllBrackets = (v)=>{
+function removeBrackets(v) {
+    return v.replace(/[<[].+/, "").trim();
+}
+function findAllBrackets(v) {
     const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
     const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
     const res = [];
@@ -246,8 +279,8 @@ const findAllBrackets = (v)=>{
     let squareMatch;
     while(squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v))res.push(parse(squareMatch));
     return res;
-};
-const getMriOptions = (options)=>{
+}
+function getMriOptions(options) {
     const result = {
         alias: {},
         boolean: []
@@ -255,53 +288,74 @@ const getMriOptions = (options)=>{
     for (const [index, option] of options.entries()){
         if (option.names.length > 1) result.alias[option.names[0]] = option.names.slice(1);
         if (option.isBoolean) if (option.negated) {
-            const hasStringTypeOption = options.some((o, i)=>i !== index && o.names.some((name)=>option.names.includes(name)) && "boolean" == typeof o.required);
-            if (!hasStringTypeOption) result.boolean.push(option.names[0]);
+            if (!options.some((o, i)=>i !== index && o.names.some((name)=>option.names.includes(name)) && "boolean" == typeof o.required)) result.boolean.push(option.names[0]);
         } else result.boolean.push(option.names[0]);
     }
     return result;
-};
-const findLongest = (arr)=>arr.sort((a, b)=>a.length > b.length ? -1 : 1)[0];
-const padRight = (str, length)=>str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
-const camelcase = (input)=>input.replace(/([a-z])-([a-z])/g, (_, p1, p2)=>p1 + p2.toUpperCase());
-const setDotProp = (obj, keys, val)=>{
-    let i = 0;
-    let length = keys.length;
-    let t = obj;
-    let x;
-    for(; i < length; ++i){
-        x = t[keys[i]];
-        t = t[keys[i]] = i === length - 1 ? val : null != x ? x : !~keys[i + 1].indexOf(".") && +keys[i + 1] > -1 ? [] : {};
+}
+function findLongest(arr) {
+    return arr.sort((a, b)=>a.length > b.length ? -1 : 1)[0];
+}
+function padRight(str, length) {
+    return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+}
+function camelcase(input) {
+    return input.replaceAll(/([a-z])-([a-z])/g, (_, p1, p2)=>p1 + p2.toUpperCase());
+}
+function setDotProp(obj, keys, val) {
+    let current = obj;
+    for(let i = 0; i < keys.length; i++){
+        const key = keys[i];
+        if (i === keys.length - 1) {
+            current[key] = val;
+            return;
+        }
+        if (null == current[key]) {
+            const nextKeyIsArrayIndex = +keys[i + 1] > -1;
+            current[key] = nextKeyIsArrayIndex ? [] : {};
+        }
+        current = current[key];
     }
-};
-const setByType = (obj, transforms)=>{
+}
+function setByType(obj, transforms) {
     for (const key of Object.keys(transforms)){
         const transform = transforms[key];
         if (transform.shouldTransform) {
-            obj[key] = Array.prototype.concat.call([], obj[key]);
+            obj[key] = [
+                obj[key]
+            ].flat();
             if ("function" == typeof transform.transformFunction) obj[key] = obj[key].map(transform.transformFunction);
         }
     }
-};
-const getFileName = (input)=>{
-    const m = /([^\\\/]+)$/.exec(input);
+}
+function getFileName(input) {
+    const m = /([^\\/]+)$/.exec(input);
     return m ? m[1] : "";
-};
-const camelcaseOptionName = (name)=>name.split(".").map((v, i)=>0 === i ? camelcase(v) : v).join(".");
-class CACError extends Error {
+}
+function camelcaseOptionName(name) {
+    return name.split(".").map((v, i)=>0 === i ? camelcase(v) : v).join(".");
+}
+var CACError = class extends Error {
     constructor(message){
         super(message);
-        this.name = this.constructor.name;
-        if ("function" == typeof Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-        else this.stack = new Error(message).stack;
+        this.name = "CACError";
+        if ("function" != typeof Error.captureStackTrace) this.stack = new Error(message).stack;
     }
-}
-class Option {
+};
+var Option = class {
+    rawName;
+    description;
+    name;
+    names;
+    isBoolean;
+    required;
+    config;
+    negated;
     constructor(rawName, description, config){
         this.rawName = rawName;
         this.description = description;
         this.config = Object.assign({}, config);
-        rawName = rawName.replace(/\.\*/g, "");
+        rawName = rawName.replaceAll(".*", "");
         this.negated = false;
         this.names = removeBrackets(rawName).split(",").map((v)=>{
             let name = v.trim().replace(/^-{1,2}/, "");
@@ -311,16 +365,36 @@ class Option {
             }
             return camelcaseOptionName(name);
         }).sort((a, b)=>a.length > b.length ? 1 : -1);
-        this.name = this.names[this.names.length - 1];
+        this.name = this.names.at(-1);
         if (this.negated && null == this.config.default) this.config.default = true;
         if (rawName.includes("<")) this.required = true;
         else if (rawName.includes("[")) this.required = false;
         else this.isBoolean = true;
     }
-}
-const processArgs = process.argv;
-const platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
-class Command {
+};
+let runtimeProcessArgs;
+let runtimeInfo;
+if ("u" > typeof process) {
+    let runtimeName;
+    runtimeName = "u" > typeof Deno && "string" == typeof Deno.version?.deno ? "deno" : "u" > typeof Bun && "string" == typeof Bun.version ? "bun" : "node";
+    runtimeInfo = `${process.platform}-${process.arch} ${runtimeName}-${process.version}`;
+    runtimeProcessArgs = process.argv;
+} else runtimeInfo = "u" < typeof navigator ? "unknown" : `${navigator.platform} ${navigator.userAgent}`;
+var Command = class {
+    rawName;
+    description;
+    config;
+    cli;
+    options;
+    aliasNames;
+    name;
+    args;
+    commandAction;
+    usageText;
+    versionNumber;
+    examples;
+    helpCallback;
+    globalCommand;
     constructor(rawName, description, config = {}, cli){
         this.rawName = rawName;
         this.description = description;
@@ -391,14 +465,12 @@ class Command {
             title: "Usage",
             body: `  $ ${name} ${this.usageText || this.rawName}`
         });
-        const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
-        if (showCommands) {
+        if ((this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0) {
             const longestCommandName = findLongest(commands.map((command)=>command.rawName));
             sections.push({
                 title: "Commands",
                 body: commands.map((command)=>`  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`).join("\n")
-            });
-            sections.push({
+            }, {
                 title: "For more info, run any command with the `--help` flag",
                 body: commands.map((command)=>`  $ ${name}${"" === command.name ? "" : ` ${command.name}`} --help`).join("\n")
             });
@@ -423,13 +495,12 @@ class Command {
             }).join("\n")
         });
         if (helpCallback) sections = helpCallback(sections) || sections;
-        console.log(sections.map((section)=>section.title ? `${section.title}:
-${section.body}` : section.body).join("\n\n"));
+        console.info(sections.map((section)=>section.title ? `${section.title}:\n${section.body}` : section.body).join("\n\n"));
     }
     outputVersion() {
         const { name } = this.cli;
         const { versionNumber } = this.cli.globalCommand;
-        if (versionNumber) console.log(`${name}/${versionNumber} ${platformInfo}`);
+        if (versionNumber) console.info(`${name}/${versionNumber} ${runtimeInfo}`);
     }
     checkRequiredArgs() {
         const minimalArgsCount = this.args.filter((arg)=>arg.required).length;
@@ -455,14 +526,27 @@ ${section.body}` : section.body).join("\n\n"));
             }
         }
     }
-}
-class GlobalCommand extends Command {
+    checkUnusedArgs() {
+        const maximumArgsCount = this.args.some((arg)=>arg.variadic) ? 1 / 0 : this.args.length;
+        if (maximumArgsCount < this.cli.args.length) throw new CACError(`Unused args: ${this.cli.args.slice(maximumArgsCount).map((arg)=>`\`${arg}\``).join(", ")}`);
+    }
+};
+var GlobalCommand = class extends Command {
     constructor(cli){
         super("@@global@@", "", {}, cli);
     }
-}
-var __assign = Object.assign;
-class CAC extends EventEmitter {
+};
+var CAC = class extends EventTarget {
+    name;
+    commands;
+    globalCommand;
+    matchedCommand;
+    matchedCommandName;
+    rawArgs;
+    args;
+    options;
+    showHelpOnExit;
+    showVersionOnExit;
     constructor(name = ""){
         super();
         this.name = name;
@@ -520,7 +604,11 @@ class CAC extends EventEmitter {
         this.matchedCommand = void 0;
         this.matchedCommandName = void 0;
     }
-    parse(argv = processArgs, { run = true } = {}) {
+    parse(argv, { run = true } = {}) {
+        if (!argv) {
+            if (!runtimeProcessArgs) throw new Error("No argv provided and runtime process argv is not available.");
+            argv = runtimeProcessArgs;
+        }
         this.rawArgs = argv;
         if (!this.name) this.name = argv[1] ? getFileName(argv[1]) : "cli";
         let shouldParse = true;
@@ -529,19 +617,24 @@ class CAC extends EventEmitter {
             const commandName = parsed.args[0];
             if (command.isMatched(commandName)) {
                 shouldParse = false;
-                const parsedInfo = __assign(__assign({}, parsed), {
+                const parsedInfo = {
+                    ...parsed,
                     args: parsed.args.slice(1)
-                });
+                };
                 this.setParsedInfo(parsedInfo, command, commandName);
-                this.emit(`command:${commandName}`, command);
+                this.dispatchEvent(new CustomEvent(`command:${commandName}`, {
+                    detail: command
+                }));
             }
         }
         if (shouldParse) {
-            for (const command of this.commands)if ("" === command.name) {
+            for (const command of this.commands)if (command.isDefaultCommand) {
                 shouldParse = false;
                 const parsed = this.mri(argv.slice(2), command);
                 this.setParsedInfo(parsed, command);
-                this.emit("command:!", command);
+                this.dispatchEvent(new CustomEvent("command:!", {
+                    detail: command
+                }));
             }
         }
         if (shouldParse) {
@@ -563,7 +656,9 @@ class CAC extends EventEmitter {
             options: this.options
         };
         if (run) this.runMatchedCommand();
-        if (!this.matchedCommand && this.args[0]) this.emit("command:*");
+        if (!this.matchedCommand && this.args[0]) this.dispatchEvent(new CustomEvent("command:*", {
+            detail: this.args[0]
+        }));
         return parsedArgv;
     }
     mri(argv, command) {
@@ -574,12 +669,13 @@ class CAC extends EventEmitter {
         const mriOptions = getMriOptions(cliOptions);
         let argsAfterDoubleDashes = [];
         const doubleDashesIndex = argv.indexOf("--");
-        if (doubleDashesIndex > -1) {
+        if (-1 !== doubleDashesIndex) {
             argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
             argv = argv.slice(0, doubleDashesIndex);
         }
-        let parsed = mri2(argv, mriOptions);
-        parsed = Object.keys(parsed).reduce((res, name)=>__assign(__assign({}, res), {
+        let parsed = lib_default(argv, mriOptions);
+        parsed = Object.keys(parsed).reduce((res, name)=>({
+                ...res,
                 [camelcaseOptionName(name)]: parsed[name]
             }), {
             _: []
@@ -589,20 +685,17 @@ class CAC extends EventEmitter {
             "--": argsAfterDoubleDashes
         };
         const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
-        let transforms = Object.create(null);
+        const transforms = Object.create(null);
         for (const cliOption of cliOptions){
             if (!ignoreDefault && void 0 !== cliOption.config.default) for (const name of cliOption.names)options[name] = cliOption.config.default;
-            if (Array.isArray(cliOption.config.type)) {
-                if (void 0 === transforms[cliOption.name]) {
-                    transforms[cliOption.name] = Object.create(null);
-                    transforms[cliOption.name]["shouldTransform"] = true;
-                    transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
-                }
+            if (Array.isArray(cliOption.config.type) && void 0 === transforms[cliOption.name]) {
+                transforms[cliOption.name] = Object.create(null);
+                transforms[cliOption.name].shouldTransform = true;
+                transforms[cliOption.name].transformFunction = cliOption.config.type[0];
             }
         }
         for (const key of Object.keys(parsed))if ("_" !== key) {
-            const keys = key.split(".");
-            setDotProp(options, keys, parsed[key]);
+            setDotProp(options, key.split("."), parsed[key]);
             setByType(options, transforms);
         }
         return {
@@ -616,6 +709,7 @@ class CAC extends EventEmitter {
         command.checkUnknownOptions();
         command.checkOptionValue();
         command.checkRequiredArgs();
+        command.checkUnusedArgs();
         const actionArgs = [];
         command.args.forEach((arg, index)=>{
             if (arg.variadic) actionArgs.push(args.slice(index));
@@ -624,9 +718,8 @@ class CAC extends EventEmitter {
         actionArgs.push(options);
         return command.commandAction.apply(this, actionArgs);
     }
-}
+};
 const cac = (name = "")=>new CAC(name);
-const dist = cac;
 const commonOptions = (command)=>command.option('-c, --config <path>', 'config file').option('--config-name <name>', 'Name(s) of the configuration to use.', {
         type: [
             String
@@ -708,7 +801,7 @@ async function runBuild(cli, options) {
     const logger = cli.getLogger();
     let createJsonStringifyStream;
     if (options.json) {
-        const jsonExt = await import("@discoveryjs/json-ext");
+        const jsonExt = await import("./json-ext.js").then(__webpack_require__.t.bind(__webpack_require__, "../../node_modules/.pnpm/@discoveryjs+json-ext@0.5.7/node_modules/@discoveryjs/json-ext/src/index.js", 23));
         createJsonStringifyStream = jsonExt.default.stringifyStream;
     }
     const errorHandler = (error, stats)=>{
@@ -753,16 +846,16 @@ class BuildCommand {
     async apply(cli) {
         const command = cli.program.command('', 'run the Rspack build').alias('build').alias('bundle').alias('b');
         commonOptionsForBuildAndServe(commonOptions(command)).option('--json [path]', 'emit stats json');
-        command.action(async (options)=>{
+        command.action(cli.wrapAction(async (options)=>{
             await runBuild(cli, options);
-        });
+        }));
     }
 }
 class PreviewCommand {
     async apply(cli) {
         const command = cli.program.command('preview [dir]', 'run the Rspack server for build output').alias('p');
         commonOptions(command).option('--public-path <path>', 'static resource server path').option('--port <port>', 'preview server port').option('--host <host>', 'preview server host').option('--open', 'open browser').option('--server <config>', 'Configuration items for the server.');
-        command.action(async (dir, options)=>{
+        command.action(cli.wrapAction(async (dir, options)=>{
             setDefaultNodeEnv(options, 'production');
             normalizeCommonOptions(options, 'preview');
             let RspackDevServer;
@@ -794,23 +887,24 @@ class PreviewCommand {
                 logger.error(error);
                 process.exit(2);
             }
-        });
+        }));
     }
 }
 async function getPreviewConfig(item, options, dir) {
     const DEFAULT_ROOT = 'dist';
     const internalPreviewConfig = async (item)=>{
+        const devServer = false === item.devServer ? void 0 : item.devServer;
         item.devServer = {
             static: {
                 directory: dir ? node_path.join(item.context ?? process.cwd(), dir) : item.output?.path ?? node_path.join(item.context ?? process.cwd(), DEFAULT_ROOT),
                 publicPath: options.publicPath ?? '/'
             },
             port: options.port ?? 8080,
-            proxy: item.devServer?.proxy,
-            host: options.host ?? item.devServer?.host,
-            open: options.open ?? item.devServer?.open,
-            server: options.server ?? item.devServer?.server,
-            historyApiFallback: item.devServer?.historyApiFallback
+            proxy: devServer?.proxy,
+            host: options.host ?? devServer?.host,
+            open: options.open ?? devServer?.open,
+            server: options.server ?? devServer?.server,
+            historyApiFallback: devServer?.historyApiFallback
         };
         return item;
     };
@@ -826,7 +920,7 @@ class ServeCommand {
     async apply(cli) {
         const command = cli.program.command('serve', 'run the rspack dev server.').alias('server').alias('s').alias('dev');
         commonOptionsForBuildAndServe(commonOptions(command)).option('--hot [mode]', 'enables hot module replacement').option('--port <port>', 'allows to specify a port to use').option('--host <host>', 'allows to specify a hostname to use');
-        command.action(async (cliOptions)=>{
+        command.action(cli.wrapAction(async (cliOptions)=>{
             setDefaultNodeEnv(cliOptions, 'development');
             normalizeCommonOptions(cliOptions, 'serve');
             cliOptions.hot = normalizeHotOption(cliOptions.hot);
@@ -856,7 +950,9 @@ class ServeCommand {
             const compilerForDevServer = possibleCompilers.length > 0 ? possibleCompilers[0] : compilers[0];
             for (const [index, compiler] of compilers.entries()){
                 const userConfig = userConfigs[index];
-                const devServer = compiler.options.devServer ??= {};
+                const existingDevServer = compiler.options.devServer;
+                if (false === existingDevServer) continue;
+                const devServer = existingDevServer ?? (compiler.options.devServer = {});
                 const isWebAppOnly = compiler.platform.web && !compiler.platform.node && !compiler.platform.nwjs && !compiler.platform.electron && !compiler.platform.webworker;
                 if (isWebAppOnly && void 0 === userConfig.lazyCompilation) compiler.options.lazyCompilation = {
                     imports: true,
@@ -874,7 +970,8 @@ class ServeCommand {
                     };
                 }
             }
-            const devServerOptions = compilerForDevServer.options.devServer ??= {};
+            const compilerForDevServerOptions = compilerForDevServer.options.devServer;
+            const devServerOptions = false === compilerForDevServerOptions ? {} : compilerForDevServerOptions ?? (compilerForDevServer.options.devServer = {});
             const { setupMiddlewares } = devServerOptions;
             const lazyCompileMiddleware = rspack.lazyCompilationMiddleware(compiler);
             devServerOptions.setupMiddlewares = (middlewares, server)=>{
@@ -914,7 +1011,7 @@ class ServeCommand {
                 logger.error(error);
                 process.exit(2);
             }
-        });
+        }));
     }
 }
 const readPackageUp = (cwd = process.cwd())=>{
@@ -1104,16 +1201,45 @@ async function loadRspackConfig(options, cwd = process.cwd()) {
         configPath
     };
 }
-const picocolors = __webpack_require__("../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js");
+function isEnvColorSupported() {
+    if ("u" < typeof process) return false;
+    const p = process;
+    const argv = p.argv ?? [];
+    const env = p.env ?? {};
+    return !('NO_COLOR' in env || argv.includes('--no-color')) && ('FORCE_COLOR' in env || argv.includes('--color') || 'win32' === p.platform || p.stdout?.isTTY && 'dumb' !== env.TERM || 'CI' in env);
+}
+function createAnsiFormatter(open, close, replace = open) {
+    const closeLength = close.length;
+    return (input)=>{
+        const string = String(input);
+        let index = string.indexOf(close, open.length);
+        if (-1 === index) return open + string + close;
+        let result = '';
+        let cursor = 0;
+        do {
+            result += string.substring(cursor, index) + replace;
+            cursor = index + closeLength;
+            index = string.indexOf(close, cursor);
+        }while (-1 !== index);
+        return open + result + string.substring(cursor) + close;
+    };
+}
 class RspackCLI {
     colors;
     program;
+    _actionPromise;
     constructor(){
-        const program = dist('rspack');
+        const program = cac('rspack');
         this.colors = this.createColors();
         this.program = program;
         program.help();
-        program.version("2.0.0-canary.20260120");
+        program.version("2.0.0-rc.1");
+    }
+    wrapAction(fn) {
+        return (...args)=>{
+            this._actionPromise = fn(...args);
+            return this._actionPromise;
+        };
     }
     async buildCompilerConfig(options, rspackCommand) {
         let { config, pathMap } = await this.loadConfig(options);
@@ -1140,10 +1266,24 @@ class RspackCLI {
         return compiler;
     }
     createColors(useColor) {
-        const shouldUseColor = useColor || picocolors.isColorSupported;
+        const envSupported = isEnvColorSupported();
+        const enabled = useColor ?? envSupported;
+        if (!enabled) {
+            const passthrough = (text)=>String(text);
+            return {
+                isColorSupported: false,
+                red: passthrough,
+                yellow: passthrough,
+                cyan: passthrough,
+                green: passthrough
+            };
+        }
         return {
-            ...(0, picocolors.createColors)(shouldUseColor),
-            isColorSupported: shouldUseColor
+            isColorSupported: true,
+            red: createAnsiFormatter('\x1b[31m', '\x1b[39m'),
+            green: createAnsiFormatter('\x1b[32m', '\x1b[39m'),
+            yellow: createAnsiFormatter('\x1b[33m', '\x1b[39m'),
+            cyan: createAnsiFormatter('\x1b[36m', '\x1b[39m')
         };
     }
     getLogger() {
@@ -1159,6 +1299,7 @@ class RspackCLI {
     async run(argv) {
         await this.registerCommands();
         this.program.parse(argv);
+        if (this._actionPromise) await this._actionPromise;
     }
     async registerCommands() {
         const builtinCommands = [
@@ -1178,15 +1319,13 @@ class RspackCLI {
             item.output = item.output || {};
             if (options.outputPath) item.output.path = node_path.resolve(process.cwd(), options.outputPath);
             if (process.env.RSPACK_PROFILE) {
-                const { applyProfile } = await import("./274.js").then((mod)=>({
-                        applyProfile: mod.applyProfile
-                    }));
+                const { applyProfile } = await import("./profile.js");
                 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 (void 0 === item.devtool) item.devtool = isBuild ? false : 'cheap-module-source-map';
             if (void 0 !== options.devtool) item.devtool = options.devtool;
             if (isServe) {
                 const installed = (item.plugins ||= []).find((item)=>item instanceof rspack.ProgressPlugin);
@@ -1212,7 +1351,6 @@ class RspackCLI {
             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));
@@ -1265,4 +1403,4 @@ function defineConfig(config) {
 function definePlugin(plugin) {
     return plugin;
 }
-export { RspackCLI, defineConfig, definePlugin, node_fs, node_path, rspack };
+export { __webpack_require__temp as __webpack_require__, RspackCLI, defineConfig, definePlugin };