create-rsbuild 0.0.0-next-20240528072128 → 0.0.0-next-20240723074951

package/dist/index.js

@@ -38,12 +38,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/@modern-js+module-tools@2.50.0_eslint@9.3.0_typescript@5.4.5/node_modules/@modern-js/module-tools/shims/esm.js
+// ../../node_modules/.pnpm/@modern-js+module-tools@2.56.0_typescript@5.5.2/node_modules/@modern-js/module-tools/shims/esm.js
 import { fileURLToPath } from "url";
 import path from "path";
 var getFilename, getDirname, __dirname;
 var init_esm = __esm({
-  "../../node_modules/.pnpm/@modern-js+module-tools@2.50.0_eslint@9.3.0_typescript@5.4.5/node_modules/@modern-js/module-tools/shims/esm.js"() {
+  "../../node_modules/.pnpm/@modern-js+module-tools@2.56.0_typescript@5.5.2/node_modules/@modern-js/module-tools/shims/esm.js"() {
     "use strict";
     getFilename = () => fileURLToPath(import.meta.url);
     getDirname = () => path.dirname(getFilename());
@@ -113,57 +113,392 @@ var require_src = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/picocolors@1.0.0/node_modules/picocolors/picocolors.js
+// ../../node_modules/.pnpm/picocolors@1.0.1/node_modules/picocolors/picocolors.js
 var require_picocolors = __commonJS({
-  "../../node_modules/.pnpm/picocolors@1.0.0/node_modules/picocolors/picocolors.js"(exports, module) {
+  "../../node_modules/.pnpm/picocolors@1.0.1/node_modules/picocolors/picocolors.js"(exports, module) {
     "use strict";
     init_esm();
-    var tty2 = __require("tty");
-    var isColorSupported = !("NO_COLOR" in process.env || process.argv.includes("--no-color")) && ("FORCE_COLOR" in process.env || process.argv.includes("--color") || process.platform === "win32" || tty2.isatty(1) && process.env.TERM !== "dumb" || "CI" in process.env);
+    var argv = process.argv || [];
+    var env2 = process.env;
+    var isColorSupported = !("NO_COLOR" in env2 || argv.includes("--no-color")) && ("FORCE_COLOR" in env2 || argv.includes("--color") || process.platform === "win32" || __require != null && __require("tty").isatty(1) && env2.TERM !== "dumb" || "CI" in env2);
     var formatter2 = (open, close, replace = open) => (input) => {
       let string = "" + input;
       let index = string.indexOf(close, open.length);
       return ~index ? open + replaceClose2(string, close, replace, index) + close : open + string + close;
     };
     var replaceClose2 = (string, close, replace, index) => {
-      let start = string.substring(0, index) + replace;
-      let end = string.substring(index + close.length);
-      let nextIndex = end.indexOf(close);
-      return ~nextIndex ? start + replaceClose2(end, close, replace, nextIndex) : start + end;
+      let result = "";
+      let 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);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let init = enabled ? formatter2 : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: init("\x1B[0m", "\x1B[0m"),
+        bold: init("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: init("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: init("\x1B[3m", "\x1B[23m"),
+        underline: init("\x1B[4m", "\x1B[24m"),
+        inverse: init("\x1B[7m", "\x1B[27m"),
+        hidden: init("\x1B[8m", "\x1B[28m"),
+        strikethrough: init("\x1B[9m", "\x1B[29m"),
+        black: init("\x1B[30m", "\x1B[39m"),
+        red: init("\x1B[31m", "\x1B[39m"),
+        green: init("\x1B[32m", "\x1B[39m"),
+        yellow: init("\x1B[33m", "\x1B[39m"),
+        blue: init("\x1B[34m", "\x1B[39m"),
+        magenta: init("\x1B[35m", "\x1B[39m"),
+        cyan: init("\x1B[36m", "\x1B[39m"),
+        white: init("\x1B[37m", "\x1B[39m"),
+        gray: init("\x1B[90m", "\x1B[39m"),
+        bgBlack: init("\x1B[40m", "\x1B[49m"),
+        bgRed: init("\x1B[41m", "\x1B[49m"),
+        bgGreen: init("\x1B[42m", "\x1B[49m"),
+        bgYellow: init("\x1B[43m", "\x1B[49m"),
+        bgBlue: init("\x1B[44m", "\x1B[49m"),
+        bgMagenta: init("\x1B[45m", "\x1B[49m"),
+        bgCyan: init("\x1B[46m", "\x1B[49m"),
+        bgWhite: init("\x1B[47m", "\x1B[49m")
+      };
     };
-    var createColors = (enabled = isColorSupported) => ({
-      isColorSupported: enabled,
-      reset: enabled ? (s) => `\x1B[0m${s}\x1B[0m` : String,
-      bold: enabled ? formatter2("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m") : String,
-      dim: enabled ? formatter2("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m") : String,
-      italic: enabled ? formatter2("\x1B[3m", "\x1B[23m") : String,
-      underline: enabled ? formatter2("\x1B[4m", "\x1B[24m") : String,
-      inverse: enabled ? formatter2("\x1B[7m", "\x1B[27m") : String,
-      hidden: enabled ? formatter2("\x1B[8m", "\x1B[28m") : String,
-      strikethrough: enabled ? formatter2("\x1B[9m", "\x1B[29m") : String,
-      black: enabled ? formatter2("\x1B[30m", "\x1B[39m") : String,
-      red: enabled ? formatter2("\x1B[31m", "\x1B[39m") : String,
-      green: enabled ? formatter2("\x1B[32m", "\x1B[39m") : String,
-      yellow: enabled ? formatter2("\x1B[33m", "\x1B[39m") : String,
-      blue: enabled ? formatter2("\x1B[34m", "\x1B[39m") : String,
-      magenta: enabled ? formatter2("\x1B[35m", "\x1B[39m") : String,
-      cyan: enabled ? formatter2("\x1B[36m", "\x1B[39m") : String,
-      white: enabled ? formatter2("\x1B[37m", "\x1B[39m") : String,
-      gray: enabled ? formatter2("\x1B[90m", "\x1B[39m") : String,
-      bgBlack: enabled ? formatter2("\x1B[40m", "\x1B[49m") : String,
-      bgRed: enabled ? formatter2("\x1B[41m", "\x1B[49m") : String,
-      bgGreen: enabled ? formatter2("\x1B[42m", "\x1B[49m") : String,
-      bgYellow: enabled ? formatter2("\x1B[43m", "\x1B[49m") : String,
-      bgBlue: enabled ? formatter2("\x1B[44m", "\x1B[49m") : String,
-      bgMagenta: enabled ? formatter2("\x1B[45m", "\x1B[49m") : String,
-      bgCyan: enabled ? formatter2("\x1B[46m", "\x1B[49m") : String,
-      bgWhite: enabled ? formatter2("\x1B[47m", "\x1B[49m") : String
-    });
     module.exports = createColors();
     module.exports.createColors = createColors;
   }
 });
 
+// ../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js
+var require_cjs = __commonJS({
+  "../../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js"(exports, module) {
+    "use strict";
+    init_esm();
+    var isMergeableObject = function isMergeableObject2(value) {
+      return isNonNullObject(value) && !isSpecial(value);
+    };
+    function isNonNullObject(value) {
+      return !!value && typeof value === "object";
+    }
+    function isSpecial(value) {
+      var stringValue = Object.prototype.toString.call(value);
+      return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+    }
+    var canUseSymbol = typeof Symbol === "function" && Symbol.for;
+    var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for("react.element") : 60103;
+    function isReactElement(value) {
+      return value.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function emptyTarget(val) {
+      return Array.isArray(val) ? [] : {};
+    }
+    function cloneUnlessOtherwiseSpecified(value, options) {
+      return options.clone !== false && options.isMergeableObject(value) ? deepmerge2(emptyTarget(value), value, options) : value;
+    }
+    function defaultArrayMerge(target, source, options) {
+      return target.concat(source).map(function(element) {
+        return cloneUnlessOtherwiseSpecified(element, options);
+      });
+    }
+    function getMergeFunction(key, options) {
+      if (!options.customMerge) {
+        return deepmerge2;
+      }
+      var customMerge = options.customMerge(key);
+      return typeof customMerge === "function" ? customMerge : deepmerge2;
+    }
+    function getEnumerableOwnPropertySymbols(target) {
+      return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+        return Object.propertyIsEnumerable.call(target, symbol);
+      }) : [];
+    }
+    function getKeys(target) {
+      return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+    }
+    function propertyIsOnObject(object, property) {
+      try {
+        return property in object;
+      } catch (_3) {
+        return false;
+      }
+    }
+    function propertyIsUnsafe(target, key) {
+      return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+    }
+    function mergeObject(target, source, options) {
+      var destination = {};
+      if (options.isMergeableObject(target)) {
+        getKeys(target).forEach(function(key) {
+          destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+        });
+      }
+      getKeys(source).forEach(function(key) {
+        if (propertyIsUnsafe(target, key)) {
+          return;
+        }
+        if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+          destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+        } else {
+          destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+        }
+      });
+      return destination;
+    }
+    function deepmerge2(target, source, options) {
+      options = options || {};
+      options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+      options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+      options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+      var sourceIsArray = Array.isArray(source);
+      var targetIsArray = Array.isArray(target);
+      var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+      if (!sourceAndTargetTypesMatch) {
+        return cloneUnlessOtherwiseSpecified(source, options);
+      } else if (sourceIsArray) {
+        return options.arrayMerge(target, source, options);
+      } else {
+        return mergeObject(target, source, options);
+      }
+    }
+    deepmerge2.all = function deepmergeAll(array, options) {
+      if (!Array.isArray(array)) {
+        throw new Error("first argument should be an array");
+      }
+      return array.reduce(function(prev, next) {
+        return deepmerge2(prev, next, options);
+      }, {});
+    };
+    var deepmerge_1 = deepmerge2;
+    module.exports = deepmerge_1;
+  }
+});
+
+// ../../node_modules/.pnpm/minimist@1.2.8/node_modules/minimist/index.js
+var require_minimist = __commonJS({
+  "../../node_modules/.pnpm/minimist@1.2.8/node_modules/minimist/index.js"(exports, module) {
+    "use strict";
+    init_esm();
+    function hasKey(obj, keys) {
+      var o2 = obj;
+      keys.slice(0, -1).forEach(function(key2) {
+        o2 = o2[key2] || {};
+      });
+      var key = keys[keys.length - 1];
+      return key in o2;
+    }
+    function isNumber(x3) {
+      if (typeof x3 === "number") {
+        return true;
+      }
+      if (/^0x[0-9a-f]+$/i.test(x3)) {
+        return true;
+      }
+      return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x3);
+    }
+    function isConstructorOrProto(obj, key) {
+      return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+    }
+    module.exports = function(args, opts) {
+      if (!opts) {
+        opts = {};
+      }
+      var flags = {
+        bools: {},
+        strings: {},
+        unknownFn: null
+      };
+      if (typeof opts.unknown === "function") {
+        flags.unknownFn = opts.unknown;
+      }
+      if (typeof opts.boolean === "boolean" && opts.boolean) {
+        flags.allBools = true;
+      } else {
+        [].concat(opts.boolean).filter(Boolean).forEach(function(key2) {
+          flags.bools[key2] = true;
+        });
+      }
+      var aliases = {};
+      function aliasIsBoolean(key2) {
+        return aliases[key2].some(function(x3) {
+          return flags.bools[x3];
+        });
+      }
+      Object.keys(opts.alias || {}).forEach(function(key2) {
+        aliases[key2] = [].concat(opts.alias[key2]);
+        aliases[key2].forEach(function(x3) {
+          aliases[x3] = [key2].concat(aliases[key2].filter(function(y3) {
+            return x3 !== y3;
+          }));
+        });
+      });
+      [].concat(opts.string).filter(Boolean).forEach(function(key2) {
+        flags.strings[key2] = true;
+        if (aliases[key2]) {
+          [].concat(aliases[key2]).forEach(function(k2) {
+            flags.strings[k2] = true;
+          });
+        }
+      });
+      var defaults = opts.default || {};
+      var argv = { _: [] };
+      function argDefined(key2, arg2) {
+        return flags.allBools && /^--[^=]+$/.test(arg2) || flags.strings[key2] || flags.bools[key2] || aliases[key2];
+      }
+      function setKey(obj, keys, value2) {
+        var o2 = obj;
+        for (var i2 = 0; i2 < keys.length - 1; i2++) {
+          var key2 = keys[i2];
+          if (isConstructorOrProto(o2, key2)) {
+            return;
+          }
+          if (o2[key2] === void 0) {
+            o2[key2] = {};
+          }
+          if (o2[key2] === Object.prototype || o2[key2] === Number.prototype || o2[key2] === String.prototype) {
+            o2[key2] = {};
+          }
+          if (o2[key2] === Array.prototype) {
+            o2[key2] = [];
+          }
+          o2 = o2[key2];
+        }
+        var lastKey = keys[keys.length - 1];
+        if (isConstructorOrProto(o2, lastKey)) {
+          return;
+        }
+        if (o2 === Object.prototype || o2 === Number.prototype || o2 === String.prototype) {
+          o2 = {};
+        }
+        if (o2 === Array.prototype) {
+          o2 = [];
+        }
+        if (o2[lastKey] === void 0 || flags.bools[lastKey] || typeof o2[lastKey] === "boolean") {
+          o2[lastKey] = value2;
+        } else if (Array.isArray(o2[lastKey])) {
+          o2[lastKey].push(value2);
+        } else {
+          o2[lastKey] = [o2[lastKey], value2];
+        }
+      }
+      function setArg(key2, val, arg2) {
+        if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
+          if (flags.unknownFn(arg2) === false) {
+            return;
+          }
+        }
+        var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
+        setKey(argv, key2.split("."), value2);
+        (aliases[key2] || []).forEach(function(x3) {
+          setKey(argv, x3.split("."), value2);
+        });
+      }
+      Object.keys(flags.bools).forEach(function(key2) {
+        setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
+      });
+      var notFlags = [];
+      if (args.indexOf("--") !== -1) {
+        notFlags = args.slice(args.indexOf("--") + 1);
+        args = args.slice(0, args.indexOf("--"));
+      }
+      for (var i = 0; i < args.length; i++) {
+        var arg = args[i];
+        var key;
+        var next;
+        if (/^--.+=/.test(arg)) {
+          var m2 = arg.match(/^--([^=]+)=([\s\S]*)$/);
+          key = m2[1];
+          var value = m2[2];
+          if (flags.bools[key]) {
+            value = value !== "false";
+          }
+          setArg(key, value, arg);
+        } else if (/^--no-.+/.test(arg)) {
+          key = arg.match(/^--no-(.+)/)[1];
+          setArg(key, false, arg);
+        } else if (/^--.+/.test(arg)) {
+          key = arg.match(/^--(.+)/)[1];
+          next = args[i + 1];
+          if (next !== void 0 && !/^(-|--)[^-]/.test(next) && !flags.bools[key] && !flags.allBools && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+            setArg(key, next, arg);
+            i += 1;
+          } else if (/^(true|false)$/.test(next)) {
+            setArg(key, next === "true", arg);
+            i += 1;
+          } else {
+            setArg(key, flags.strings[key] ? "" : true, arg);
+          }
+        } else if (/^-[^-]+/.test(arg)) {
+          var letters = arg.slice(1, -1).split("");
+          var broken = false;
+          for (var j2 = 0; j2 < letters.length; j2++) {
+            next = arg.slice(j2 + 2);
+            if (next === "-") {
+              setArg(letters[j2], next, arg);
+              continue;
+            }
+            if (/[A-Za-z]/.test(letters[j2]) && next[0] === "=") {
+              setArg(letters[j2], next.slice(1), arg);
+              broken = true;
+              break;
+            }
+            if (/[A-Za-z]/.test(letters[j2]) && /-?\d+(\.\d*)?(e-?\d+)?$/.test(next)) {
+              setArg(letters[j2], next, arg);
+              broken = true;
+              break;
+            }
+            if (letters[j2 + 1] && letters[j2 + 1].match(/\W/)) {
+              setArg(letters[j2], arg.slice(j2 + 2), arg);
+              broken = true;
+              break;
+            } else {
+              setArg(letters[j2], flags.strings[letters[j2]] ? "" : true, arg);
+            }
+          }
+          key = arg.slice(-1)[0];
+          if (!broken && key !== "-") {
+            if (args[i + 1] && !/^(-|--)[^-]/.test(args[i + 1]) && !flags.bools[key] && (aliases[key] ? !aliasIsBoolean(key) : true)) {
+              setArg(key, args[i + 1], arg);
+              i += 1;
+            } else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
+              setArg(key, args[i + 1] === "true", arg);
+              i += 1;
+            } else {
+              setArg(key, flags.strings[key] ? "" : true, arg);
+            }
+          }
+        } else {
+          if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
+            argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
+          }
+          if (opts.stopEarly) {
+            argv._.push.apply(argv._, args.slice(i + 1));
+            break;
+          }
+        }
+      }
+      Object.keys(defaults).forEach(function(k2) {
+        if (!hasKey(argv, k2.split("."))) {
+          setKey(argv, k2.split("."), defaults[k2]);
+          (aliases[k2] || []).forEach(function(x3) {
+            setKey(argv, x3.split("."), defaults[k2]);
+          });
+        }
+      });
+      if (opts["--"]) {
+        argv["--"] = notFlags.slice();
+      } else {
+        notFlags.forEach(function(k2) {
+          argv._.push(k2);
+        });
+      }
+      return argv;
+    };
+  }
+});
+
 // src/index.ts
 init_esm();
 import fs from "fs";
@@ -484,6 +819,41 @@ var x = class {
     }
   }
 };
+var pD = Object.defineProperty;
+var fD = (t, u, F) => u in t ? pD(t, u, { enumerable: true, configurable: true, writable: true, value: F }) : t[u] = F;
+var K = (t, u, F) => (fD(t, typeof u != "symbol" ? u + "" : u, F), F);
+var gD = class extends x {
+  constructor(u) {
+    super(u, false), K(this, "options"), K(this, "cursor", 0), this.options = u.options, this.value = [...u.initialValues ?? []], this.cursor = Math.max(this.options.findIndex(({ value: F }) => F === u.cursorAt), 0), this.on("key", (F) => {
+      F === "a" && this.toggleAll();
+    }), this.on("cursor", (F) => {
+      switch (F) {
+        case "left":
+        case "up":
+          this.cursor = this.cursor === 0 ? this.options.length - 1 : this.cursor - 1;
+          break;
+        case "down":
+        case "right":
+          this.cursor = this.cursor === this.options.length - 1 ? 0 : this.cursor + 1;
+          break;
+        case "space":
+          this.toggleValue();
+          break;
+      }
+    });
+  }
+  get _value() {
+    return this.options[this.cursor].value;
+  }
+  toggleAll() {
+    const u = this.value.length === this.options.length;
+    this.value = u ? [] : this.options.map((F) => F.value);
+  }
+  toggleValue() {
+    const u = this.value.includes(this._value);
+    this.value = u ? this.value.filter((F) => F !== this._value) : [...this.value, this._value];
+  }
+};
 var bD = Object.defineProperty;
 var wD = (t, u, F) => u in t ? bD(t, u, { enumerable: true, configurable: true, writable: true, value: F }) : t[u] = F;
 var Z = (t, u, F) => (wD(t, typeof u != "symbol" ? u + "" : u, F), F);
@@ -545,7 +915,7 @@ var H = o("◆", "*");
 var I2 = o("■", "x");
 var x2 = o("▲", "x");
 var S2 = o("◇", "o");
-var K = o("┌", "T");
+var K2 = o("┌", "T");
 var a2 = o("│", "|");
 var d2 = o("└", "—");
 var b2 = o("●", ">");
@@ -624,6 +994,50 @@ ${import_picocolors2.default.cyan(d2)}
     }
   } }).prompt();
 };
+var ae = (r2) => {
+  const n = (i, t) => {
+    const s = i.label ?? String(i.value);
+    return t === "active" ? `${import_picocolors2.default.cyan(C)} ${s} ${i.hint ? import_picocolors2.default.dim(`(${i.hint})`) : ""}` : t === "selected" ? `${import_picocolors2.default.green(w2)} ${import_picocolors2.default.dim(s)}` : t === "cancelled" ? `${import_picocolors2.default.strikethrough(import_picocolors2.default.dim(s))}` : t === "active-selected" ? `${import_picocolors2.default.green(w2)} ${s} ${i.hint ? import_picocolors2.default.dim(`(${i.hint})`) : ""}` : t === "submitted" ? `${import_picocolors2.default.dim(s)}` : `${import_picocolors2.default.dim(M2)} ${import_picocolors2.default.dim(s)}`;
+  };
+  return new gD({ options: r2.options, initialValues: r2.initialValues, required: r2.required ?? true, cursorAt: r2.cursorAt, validate(i) {
+    if (this.required && i.length === 0)
+      return `Please select at least one option.
+${import_picocolors2.default.reset(import_picocolors2.default.dim(`Press ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" space ")))} to select, ${import_picocolors2.default.gray(import_picocolors2.default.bgWhite(import_picocolors2.default.inverse(" enter ")))} to submit`))}`;
+  }, render() {
+    let i = `${import_picocolors2.default.gray(a2)}
+${y2(this.state)}  ${r2.message}
+`;
+    switch (this.state) {
+      case "submit":
+        return `${i}${import_picocolors2.default.gray(a2)}  ${this.options.filter(({ value: t }) => this.value.includes(t)).map((t) => n(t, "submitted")).join(import_picocolors2.default.dim(", ")) || import_picocolors2.default.dim("none")}`;
+      case "cancel": {
+        const t = this.options.filter(({ value: s }) => this.value.includes(s)).map((s) => n(s, "cancelled")).join(import_picocolors2.default.dim(", "));
+        return `${i}${import_picocolors2.default.gray(a2)}  ${t.trim() ? `${t}
+${import_picocolors2.default.gray(a2)}` : ""}`;
+      }
+      case "error": {
+        const t = this.error.split(`
+`).map((s, c2) => c2 === 0 ? `${import_picocolors2.default.yellow(d2)}  ${import_picocolors2.default.yellow(s)}` : `   ${s}`).join(`
+`);
+        return i + import_picocolors2.default.yellow(a2) + "  " + this.options.map((s, c2) => {
+          const l2 = this.value.includes(s.value), u = c2 === this.cursor;
+          return u && l2 ? n(s, "active-selected") : l2 ? n(s, "selected") : n(s, u ? "active" : "inactive");
+        }).join(`
+${import_picocolors2.default.yellow(a2)}  `) + `
+` + t + `
+`;
+      }
+      default:
+        return `${i}${import_picocolors2.default.cyan(a2)}  ${this.options.map((t, s) => {
+          const c2 = this.value.includes(t.value), l2 = s === this.cursor;
+          return l2 && c2 ? n(t, "active-selected") : c2 ? n(t, "selected") : n(t, l2 ? "active" : "inactive");
+        }).join(`
+${import_picocolors2.default.cyan(a2)}  `)}
+${import_picocolors2.default.cyan(d2)}
+`;
+    }
+  } }).prompt();
+};
 var R2 = (r2) => r2.replace(me(), "");
 var le = (r2 = "", n = "") => {
   const i = `
@@ -653,6 +1067,10 @@ function me() {
   return new RegExp(r2, "g");
 }
 
+// src/index.ts
+var import_deepmerge = __toESM(require_cjs());
+var import_minimist = __toESM(require_minimist());
+
 // ../../node_modules/.pnpm/rslog@1.2.2/node_modules/rslog/dist/index.mjs
 init_esm();
 import process2 from "process";
@@ -944,9 +1362,14 @@ function checkCancel(value) {
   if (hD(value)) {
     cancelAndExit();
   }
+  return value;
 }
-function formatTargetDir(targetDir) {
-  return targetDir.trim().replace(/\/+$/g, "");
+function formatProjectName(input) {
+  const formatted = input.trim().replace(/\/+$/g, "");
+  return {
+    packageName: formatted.startsWith("@") ? formatted : path2.basename(formatted),
+    targetDir: formatted
+  };
 }
 function pkgFromUserAgent(userAgent) {
   if (!userAgent)
@@ -962,66 +1385,159 @@ function isEmptyDir(path3) {
   const files = fs.readdirSync(path3);
   return files.length === 0 || files.length === 1 && files[0] === ".git";
 }
+function logHelpMessage() {
+  logger.log(`
+   Usage: create-rsbuild [options]
+
+   Options:
+   
+     -h, --help       display help for command
+     -d, --dir        create project in specified directory
+     -t, --template   specify the template to use
+     --tools          select additional tools (biome, eslint, prettier)
+     --override       override files in target directory
+   
+   Templates:
+   
+     react            react-ts
+     vue3             vue3-ts
+     vue2             vue2-ts
+     lit              lit-ts
+     preact           preact-ts
+     svelte           svelte-ts
+     solid            solid-ts
+     vanilla          vanilla-ts
+`);
+}
+var frameworkAlias = {
+  vue: "vue3",
+  "solid-js": "solid"
+};
+async function getTemplate({ template }) {
+  if (typeof template === "string") {
+    const pair = template.split("-");
+    const language2 = pair[1] ?? "js";
+    const framework2 = pair[0];
+    return {
+      framework: frameworkAlias[framework2] ?? framework2,
+      language: language2
+    };
+  }
+  const framework = checkCancel(
+    await ie({
+      message: "Select framework",
+      options: [
+        { value: "react", label: "React" },
+        { value: "vue3", label: "Vue 3" },
+        { value: "vue2", label: "Vue 2" },
+        { value: "lit", label: "Lit" },
+        { value: "preact", label: "Preact" },
+        { value: "svelte", label: "Svelte" },
+        { value: "solid", label: "Solid" },
+        { value: "vanilla", label: "Vanilla" }
+      ]
+    })
+  );
+  const language = checkCancel(
+    await ie({
+      message: "Select language",
+      options: [
+        { value: "ts", label: "TypeScript" },
+        { value: "js", label: "JavaScript" }
+      ]
+    })
+  );
+  return {
+    framework,
+    language
+  };
+}
+async function getTools({ tools, dir, template }) {
+  if (tools) {
+    return Array.isArray(tools) ? tools : [tools];
+  }
+  if (dir && template) {
+    return [];
+  }
+  return checkCancel(
+    await ae({
+      message: "Select additional tools (press enter to continue)",
+      options: [
+        { value: "biome", label: "Add Biome for code linting and formatting" },
+        { value: "eslint", label: "Add ESLint for code linting" },
+        { value: "prettier", label: "Add Prettier for code formatting" }
+      ],
+      required: false
+    })
+  );
+}
 async function main() {
+  const argv = (0, import_minimist.default)(process.argv.slice(2), {
+    alias: { h: "help", d: "dir", t: "template" }
+  });
   console.log("");
   logger.greet("◆  Create Rsbuild Project");
+  if (argv.help) {
+    logHelpMessage();
+    return;
+  }
   const cwd = process.cwd();
   const pkgInfo = pkgFromUserAgent(process.env.npm_config_user_agent);
   const pkgManager = pkgInfo ? pkgInfo.name : "npm";
   const packageRoot = path2.resolve(__dirname, "..");
   const packageJsonPath = path2.join(packageRoot, "package.json");
   const { version } = __require(packageJsonPath);
-  let targetDir = await te({
-    message: "Input target folder",
-    placeholder: "my-project",
-    validate(value) {
-      if (value.length === 0) {
-        return "Target folder is required";
+  const projectName = argv.dir ?? checkCancel(
+    await te({
+      message: "Project name or path",
+      placeholder: "rsbuild-project",
+      defaultValue: "rsbuild-project",
+      validate(value) {
+        if (value.length === 0) {
+          return "Project name is required";
+        }
       }
-    }
-  });
-  checkCancel(targetDir);
-  targetDir = formatTargetDir(targetDir);
-  const distFolder = path2.join(cwd, targetDir);
-  if (fs.existsSync(distFolder) && !isEmptyDir(distFolder)) {
-    const option = await ie({
-      message: `"${targetDir}" is not empty, please choose:`,
-      options: [
-        { value: "yes", label: "Continue and override files" },
-        { value: "no", label: "Cancel operation" }
-      ]
-    });
-    checkCancel(option);
+    })
+  );
+  const { targetDir, packageName } = formatProjectName(projectName);
+  const distFolder = path2.isAbsolute(targetDir) ? targetDir : path2.join(cwd, targetDir);
+  if (!argv.override && fs.existsSync(distFolder) && !isEmptyDir(distFolder)) {
+    const option = checkCancel(
+      await ie({
+        message: `"${targetDir}" is not empty, please choose:`,
+        options: [
+          { value: "yes", label: "Continue and override files" },
+          { value: "no", label: "Cancel operation" }
+        ]
+      })
+    );
     if (option === "no") {
       cancelAndExit();
     }
   }
-  const framework = await ie({
-    message: "Select framework",
-    options: [
-      { value: "react", label: "React" },
-      { value: "vue3", label: "Vue 3" },
-      { value: "vue2", label: "Vue 2" },
-      { value: "lit", label: "Lit" },
-      { value: "preact", label: "Preact" },
-      { value: "svelte", label: "Svelte" },
-      { value: "solid", label: "Solid" },
-      { value: "vanilla", label: "Vanilla" }
-    ]
-  });
-  checkCancel(framework);
-  const language = await ie({
-    message: "Select language",
-    options: [
-      { value: "ts", label: "TypeScript" },
-      { value: "js", label: "JavaScript" }
-    ]
-  });
-  checkCancel(language);
+  const { framework, language } = await getTemplate(argv);
+  const tools = await getTools(argv);
   const srcFolder = path2.join(packageRoot, `template-${framework}-${language}`);
   const commonFolder = path2.join(packageRoot, "template-common");
+  if (!fs.existsSync(srcFolder)) {
+    throw new Error(
+      `Invalid input: template "${framework}-${language}" not found. `
+    );
+  }
   copyFolder(commonFolder, distFolder, version);
-  copyFolder(srcFolder, distFolder, version, path2.basename(targetDir));
+  copyFolder(srcFolder, distFolder, version, packageName);
+  for (const tool of tools) {
+    const toolFolder = path2.join(packageRoot, `template-${tool}`);
+    if (tool === "eslint") {
+      let subFolder = path2.join(toolFolder, `${framework}-${language}`);
+      if (!fs.existsSync(subFolder)) {
+        subFolder = path2.join(toolFolder, `common-${language}`);
+      }
+      copyFolder(subFolder, distFolder, version);
+    } else {
+      copyFolder(toolFolder, distFolder, version);
+    }
+  }
   const nextSteps = [
     `cd ${targetDir}`,
     `${pkgManager} i`,
@@ -1030,6 +1546,33 @@ async function main() {
   le(nextSteps.join("\n"), "Next steps");
   $e("Done.");
 }
+function sortObjectKeys(obj) {
+  const sortedKeys = Object.keys(obj).sort();
+  const sortedObj = {};
+  for (const key of sortedKeys) {
+    sortedObj[key] = obj[key];
+  }
+  return sortedObj;
+}
+function mergePackageJson(targetPackage, extraPackage) {
+  if (!fs.existsSync(targetPackage)) {
+    return;
+  }
+  const targetJson = JSON.parse(fs.readFileSync(targetPackage, "utf-8"));
+  const extraJson = JSON.parse(fs.readFileSync(extraPackage, "utf-8"));
+  const mergedJson = (0, import_deepmerge.default)(targetJson, extraJson);
+  mergedJson.name = targetJson.name || extraJson.name;
+  for (const key of ["scripts", "dependencies", "devDependencies"]) {
+    if (!(key in mergedJson)) {
+      continue;
+    }
+    mergedJson[key] = sortObjectKeys(
+      mergedJson[key]
+    );
+  }
+  fs.writeFileSync(targetPackage, `${JSON.stringify(mergedJson, null, 2)}
+`);
+}
 function copyFolder(src, dist, version, name) {
   const renameFiles = {
     gitignore: ".gitignore"
@@ -1045,20 +1588,32 @@ function copyFolder(src, dist, version, name) {
     const stat = fs.statSync(srcFile);
     if (stat.isDirectory()) {
       copyFolder(srcFile, distFile, version);
-    } else {
-      fs.copyFileSync(srcFile, distFile);
-      if (file === "package.json") {
+    } else if (file === "package.json") {
+      const targetPackage = path2.resolve(dist, "package.json");
+      if (fs.existsSync(targetPackage)) {
+        mergePackageJson(targetPackage, srcFile);
+      } else {
+        fs.copyFileSync(srcFile, distFile);
         updatePackageJson(distFile, version, name);
       }
+    } else {
+      fs.copyFileSync(srcFile, distFile);
     }
   }
 }
+var isStableVersion = (version) => {
+  return ["alpha", "beta", "rc", "canary", "nightly"].every(
+    (tag) => !version.includes(tag)
+  );
+};
 var updatePackageJson = (pkgJsonPath, version, name) => {
   let content = fs.readFileSync(pkgJsonPath, "utf-8");
-  content = content.replace(/workspace:\*/g, `^${version}`);
+  const targetVersion = isStableVersion(version) ? `^${version}` : version;
+  content = content.replace(/workspace:\*/g, targetVersion);
   const pkg = JSON.parse(content);
-  if (name)
+  if (name && name !== ".") {
     pkg.name = name;
+  }
   fs.writeFileSync(pkgJsonPath, JSON.stringify(pkg, null, 2));
 };
 main();