@rspack-debug/cli 2.0.0-canary.20260120 → 2.0.0-rc.2

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

@@ -1,145 +1,100 @@
-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";
-__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");
-        const path = __webpack_require__("path");
-        const nodeModulesRegex = /^(?:.*[\\/])?node_modules(?:[\\/].*)?$/;
-        const Module = module.constructor.length > 1 ? module.constructor : BuiltinModule;
-        const HOOK_RETURNED_NOTHING_ERROR_MESSAGE = "[Pirates] A hook returned a non-string, or nothing at all! This is a violation of intergalactic law!\n--------------------\nIf you have no idea what this means or what Pirates is, let me explain: Pirates is a module that makes it easy to implement require hooks. One of the require hooks you're using uses it. One of these require hooks didn't return anything from it's handler, so we don't know what to do. You might want to debug this.";
-        function shouldCompile(filename, exts, matcher, ignoreNodeModules) {
-            if ('string' != typeof filename) return false;
-            if (-1 === exts.indexOf(path.extname(filename))) return false;
-            const resolvedFilename = path.resolve(filename);
-            if (ignoreNodeModules && nodeModulesRegex.test(resolvedFilename)) return false;
-            if (matcher && 'function' == typeof matcher) return !!matcher(resolvedFilename);
-            return true;
+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;
         }
-        function addHook(hook, opts = {}) {
-            let reverted = false;
-            const loaders = [];
-            const oldLoaders = [];
-            let exts;
-            const originalJSLoader = Module._extensions['.js'];
-            const matcher = opts.matcher || null;
-            const ignoreNodeModules = false !== opts.ignoreNodeModules;
-            exts = opts.extensions || opts.exts || opts.extension || opts.ext || [
-                '.js'
-            ];
-            if (!Array.isArray(exts)) exts = [
-                exts
-            ];
-            exts.forEach((ext)=>{
-                if ('string' != typeof ext) throw new TypeError(`Invalid Extension: ${ext}`);
-                const oldLoader = Module._extensions[ext] || originalJSLoader;
-                oldLoaders[ext] = Module._extensions[ext];
-                loaders[ext] = Module._extensions[ext] = function(mod, filename) {
-                    let compile;
-                    if (!reverted) {
-                        if (shouldCompile(filename, exts, matcher, ignoreNodeModules)) {
-                            compile = mod._compile;
-                            mod._compile = function(code) {
-                                mod._compile = compile;
-                                const newCode = hook(code, filename);
-                                if ('string' != typeof newCode) throw new Error(HOOK_RETURNED_NOTHING_ERROR_MESSAGE);
-                                return mod._compile(newCode, filename);
-                            };
-                        }
-                    }
-                    oldLoader(mod, filename);
-                };
-            });
-            return function() {
-                if (reverted) return;
-                reverted = true;
-                exts.forEach((ext)=>{
-                    if (Module._extensions[ext] === loaders[ext]) if (oldLoaders[ext]) Module._extensions[ext] = oldLoaders[ext];
-                    else delete Module._extensions[ext];
-                });
-            };
+        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
+        });
+    };
+})();
+(()=>{
+    var installedChunks = {
+        162: 0,
+        410: 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;
         }
-        exports.addHook = addHook;
-    },
-    module (module) {
-        module.exports = __rspack_external_module;
-    },
-    path (module) {
-        module.exports = __rspack_external_path;
+    };
+    __webpack_require__.C = installChunk;
+})();
+__webpack_require__.add({
+    stream (module) {
+        module.exports = __rspack_createRequire_require("stream");
     }
 });
 function toArr(any) {
@@ -148,13 +103,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 +145,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 +178,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 +203,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 +212,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 +289,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 +389,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 +419,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 +450,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 +528,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 +541,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 +580,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 +593,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 +609,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 +633,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,16 +642,15 @@ 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
         ],
         default: []
-    }).option('--config-loader <loader>', 'Specify the loader to load the config file, can be `native` or `register`.', {
-        default: 'register'
+    }).option('--config-loader <loader>', 'Specify the loader to load the config file, can be `auto`, `jiti` or `native`.', {
+        default: 'auto'
     }).option('--env <env>', 'env passed to config function', {
         type: [
             String
@@ -708,7 +725,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 +770,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 +811,25 @@ 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 ?? '/'
             },
+            hot: false,
             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 +845,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 +875,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 +895,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,108 +936,86 @@ class ServeCommand {
                 logger.error(error);
                 process.exit(2);
             }
-        });
+        }));
     }
 }
-const readPackageUp = (cwd = process.cwd())=>{
-    let currentDir = node_path.resolve(cwd);
-    let packageJsonPath = node_path.join(currentDir, 'package.json');
-    while(!node_fs.existsSync(packageJsonPath)){
-        const parentDir = node_path.dirname(currentDir);
-        if (parentDir === currentDir) return null;
-        currentDir = parentDir;
-        packageJsonPath = node_path.join(currentDir, 'package.json');
-    }
-    try {
-        return JSON.parse(node_fs.readFileSync(packageJsonPath, 'utf8'));
-    } catch  {
-        return null;
-    }
-};
-const utils_readPackageUp = readPackageUp;
-const isEsmFile = (filePath)=>{
-    if (/\.(mjs|mts)$/.test(filePath)) return true;
-    if (/\.(cjs|cts)$/.test(filePath)) return false;
-    const packageJson = utils_readPackageUp(node_path.dirname(filePath));
-    return packageJson?.type === 'module';
-};
-const crossImport_require = createRequire(import.meta.url);
-const crossImport = async (path)=>{
-    if (isEsmFile(path)) {
-        const url = pathToFileURL(path).href;
-        const { default: config } = await import(url);
-        return config;
-    }
-    let result = crossImport_require(path);
-    if (result && 'object' == typeof result && 'default' in result) result = result.default || {};
-    return result;
-};
 const DEFAULT_EXTENSIONS = [
-    '.js',
     '.ts',
-    '.mjs',
+    '.js',
     '.mts',
-    '.cjs',
-    '.cts'
+    '.mjs',
+    '.cts',
+    '.cjs'
 ];
 const findConfig = (basePath)=>DEFAULT_EXTENSIONS.map((ext)=>basePath + ext).find(node_fs.existsSync);
 const utils_findConfig = findConfig;
-const TS_EXTENSION = [
-    '.ts',
-    '.cts',
-    '.mts'
+const loadConfig_require = createRequire(import.meta.url);
+const loadConfig_DEFAULT_CONFIG_NAME = 'rspack.config';
+const JS_CONFIG_EXTENSION_REGEXP = /\.(?:js|mjs|cjs)$/;
+const CONFIG_LOADER_VALUES = [
+    'auto',
+    'jiti',
+    'native'
 ];
-const isTsFile = (configPath)=>{
-    const ext = node_path.extname(configPath);
-    return TS_EXTENSION.includes(ext);
+const PREBUNDLED_JITI_PATH = new URL('../compiled/jiti/index.js', import.meta.url).href;
+const supportsNativeTypeScript = ()=>{
+    const features = process.features;
+    return Boolean(features.typescript || process.versions.bun || process.versions.deno);
 };
-const utils_isTsFile = isTsFile;
-const lib = __webpack_require__("../../node_modules/.pnpm/pirates@4.0.7/node_modules/pirates/lib/index.js");
-const loadConfig_require = createRequire(import.meta.url);
-const injectInlineSourceMap = ({ code, map })=>{
-    if (map) {
-        const base64Map = Buffer.from(map, 'utf8').toString('base64');
-        const sourceMapContent = `//# sourceMappingURL=data:application/json;charset=utf-8;base64,${base64Map}`;
-        return `${code}\n${sourceMapContent}`;
-    }
-    return code;
+const normalizeConfigLoader = (configLoader)=>{
+    const normalizedLoader = configLoader ?? 'auto';
+    if (CONFIG_LOADER_VALUES.includes(normalizedLoader)) return normalizedLoader;
+    throw new Error(`config loader "${normalizedLoader}" is not supported. Expected one of: ${CONFIG_LOADER_VALUES.join(', ')}.`);
 };
-function compile(sourcecode, filename) {
-    const { code, map } = rspack.experiments.swc.transformSync(sourcecode, {
-        jsc: {
-            parser: {
-                syntax: "typescript",
-                tsx: false,
-                decorators: true,
-                dynamicImport: true
-            }
-        },
-        filename: filename,
-        module: {
-            type: 'commonjs'
-        },
-        sourceMaps: true,
-        isModule: true
-    });
-    return injectInlineSourceMap({
-        code,
-        map
+const resolveDefaultExport = (result)=>result && 'object' == typeof result && 'default' in result ? result.default : result;
+const loadConfigWithNativeLoader = async (configPath)=>{
+    const configFileURL = pathToFileURL(configPath).href;
+    const loadedModule = await import(`${configFileURL}?t=${Date.now()}`);
+    return resolveDefaultExport(loadedModule);
+};
+let jitiInstancePromise;
+const getJiti = async ()=>{
+    if (!jitiInstancePromise) jitiInstancePromise = import(PREBUNDLED_JITI_PATH).then((module)=>{
+        const createJiti = 'createJiti' in module ? module.createJiti : module.default;
+        return createJiti(import.meta.filename, {
+            moduleCache: false,
+            interopDefault: true,
+            nativeModules: [
+                "typescript"
+            ]
+        });
     });
-}
-const loadConfig_DEFAULT_CONFIG_NAME = 'rspack.config';
-const registerLoader = (configPath)=>{
-    if (isEsmFile(configPath) && utils_isTsFile(configPath)) return;
-    if (!utils_isTsFile(configPath)) throw new Error(`config file "${configPath}" is not supported.`);
-    (0, lib.addHook)((code, filename)=>{
-        try {
-            return compile(code, filename);
-        } catch (err) {
-            throw new Error(`Failed to transform file "${filename}" when loading TypeScript config file:\n ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }, {
-        exts: TS_EXTENSION
+    return jitiInstancePromise;
+};
+const loadConfigWithJiti = async (configPath)=>{
+    const jiti = await getJiti();
+    return jiti.import(configPath, {
+        default: true
     });
 };
+const loadConfigByPath = async (configPath, options)=>{
+    const configLoader = normalizeConfigLoader(options.configLoader);
+    const useNative = Boolean('native' === configLoader || 'auto' === configLoader && supportsNativeTypeScript());
+    if (useNative || JS_CONFIG_EXTENSION_REGEXP.test(configPath)) try {
+        return await loadConfigWithNativeLoader(configPath);
+    } catch (error) {
+        if ('native' === configLoader) throw error;
+    }
+    return loadConfigWithJiti(configPath);
+};
+const isConfigObject = (value)=>Boolean(value) && 'object' == typeof value && !Array.isArray(value);
+const isRspackConfig = (value)=>Array.isArray(value) || isConfigObject(value);
+const resolveRspackConfigExport = async (configExport, options)=>{
+    let loadedConfig = configExport;
+    if ('function' == typeof loadedConfig) {
+        let functionResult = loadedConfig(options.env, options);
+        if ('function' == typeof functionResult.then) functionResult = await functionResult;
+        if (void 0 === functionResult) throw new Error('[rspack-cli:loadConfig] The config function must return a config object.');
+        loadedConfig = functionResult;
+    }
+    if (!isRspackConfig(loadedConfig)) throw new Error(`[rspack-cli:loadConfig] The config must be an object, an array, or a function that returns one, get ${String(loadedConfig)}`);
+    return loadedConfig;
+};
 const checkIsMultiRspackOptions = (config)=>Array.isArray(config);
 async function loadExtendedConfig(config, configPath, cwd, options) {
     if (checkIsMultiRspackOptions(config)) {
@@ -1068,13 +1068,9 @@ async function loadExtendedConfig(config, configPath, cwd, options) {
             throw new Error(`Cannot find module '${extendPath}' to extend from.`);
         }
         if (!node_fs.existsSync(resolvedPath)) throw new Error(`Extended configuration file "${resolvedPath}" not found.`);
-        if (utils_isTsFile(resolvedPath) && 'register' === options.configLoader) registerLoader(resolvedPath);
-        let loadedConfig = await crossImport(resolvedPath);
-        if ('function' == typeof loadedConfig) {
-            loadedConfig = loadedConfig(options.env, options);
-            if ('function' == typeof loadedConfig.then) loadedConfig = await loadedConfig;
-        }
-        const { config: extendedConfig, pathMap: extendedPathMap } = await loadExtendedConfig(loadedConfig, resolvedPath, cwd, options);
+        const loadedConfig = await loadConfigByPath(resolvedPath, options);
+        const resolvedConfig = await resolveRspackConfigExport(loadedConfig, options);
+        const { config: extendedConfig, pathMap: extendedPathMap } = await loadExtendedConfig(resolvedConfig, resolvedPath, cwd, options);
         const configPaths = [
             ...pathMap.get(resultConfig) || [],
             ...extendedPathMap.get(extendedConfig) || []
@@ -1097,23 +1093,51 @@ async function loadRspackConfig(options, cwd = process.cwd()) {
         if (!defaultConfig) return null;
         configPath = defaultConfig;
     }
-    if (utils_isTsFile(configPath) && 'register' === options.configLoader) registerLoader(configPath);
-    const loadedConfig = await crossImport(configPath);
+    const loadedConfig = await loadConfigByPath(configPath, options);
     return {
         loadedConfig,
         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.2");
+    }
+    wrapAction(fn) {
+        return (...args)=>{
+            this._actionPromise = fn(...args);
+            return this._actionPromise;
+        };
     }
     async buildCompilerConfig(options, rspackCommand) {
         let { config, pathMap } = await this.loadConfig(options);
@@ -1140,10 +1164,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 +1197,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 +1217,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 +1249,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));
@@ -1224,13 +1260,9 @@ class RspackCLI {
             config: this.filterConfig(options, {}),
             pathMap: new WeakMap()
         };
-        let { loadedConfig, configPath } = config;
-        if ('function' == typeof loadedConfig) {
-            let functionResult = loadedConfig(options.env, options);
-            if ('function' == typeof functionResult.then) functionResult = await functionResult;
-            loadedConfig = functionResult;
-        }
-        const { config: extendedConfig, pathMap } = await loadExtendedConfig(loadedConfig, configPath, process.cwd(), options);
+        const { loadedConfig, configPath } = config;
+        const resolvedConfig = await resolveRspackConfigExport(loadedConfig, options);
+        const { config: extendedConfig, pathMap } = await loadExtendedConfig(resolvedConfig, configPath, process.cwd(), options);
         return {
             config: this.filterConfig(options, extendedConfig),
             pathMap
@@ -1265,4 +1297,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 };