nitro 3.0.1-alpha.1 → 3.0.260311-beta

package/dist/_libs/c12+readdirp+chokidar.d.mts

@@ -0,0 +1,230 @@
+import { Stats } from "node:fs";
+import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
+import { DownloadTemplateOptions } from "giget";
+
+//#region node_modules/.pnpm/c12@4.0.0-beta.3_chokidar@5.0.0_dotenv@17.3.1_giget@3.1.2_jiti@2.6.1_magicast@0.5.2/node_modules/c12/dist/_chunks/libs/ohash.d.mts
+//#region node_modules/.pnpm/ohash@2.0.11/node_modules/ohash/dist/utils/index.d.mts
+/**
+ * Calculates the difference between two objects and returns a list of differences.
+ *
+ * @param {any} obj1 - The first object to compare.
+ * @param {any} obj2 - The second object to compare.
+ * @param {HashOptions} [opts={}] - Configuration options for hashing the objects. See {@link HashOptions}.
+ * @returns {DiffEntry[]} An array with the differences between the two objects.
+ */
+declare function diff(obj1: any, obj2: any): DiffEntry[];
+declare class DiffEntry {
+  key: string;
+  type: "changed" | "added" | "removed";
+  newValue: DiffHashedObject;
+  oldValue?: DiffHashedObject | undefined;
+  constructor(key: string, type: "changed" | "added" | "removed", newValue: DiffHashedObject, oldValue?: DiffHashedObject | undefined);
+  toString(): string;
+  toJSON(): string;
+}
+declare class DiffHashedObject {
+  key: string;
+  value: any;
+  hash?: string | undefined;
+  props?: Record<string, DiffHashedObject> | undefined;
+  constructor(key: string, value: any, hash?: string | undefined, props?: Record<string, DiffHashedObject> | undefined);
+  toString(): string;
+  toJSON(): string;
+} //#endregion
+//#endregion
+//#region node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.d.ts
+type AWF = {
+  stabilityThreshold: number;
+  pollInterval: number;
+};
+type BasicOpts = {
+  persistent: boolean;
+  ignoreInitial: boolean;
+  followSymlinks: boolean;
+  cwd?: string;
+  usePolling: boolean;
+  interval: number;
+  binaryInterval: number;
+  alwaysStat?: boolean;
+  depth?: number;
+  ignorePermissionErrors: boolean;
+  atomic: boolean | number;
+};
+type ChokidarOptions = Partial<BasicOpts & {
+  ignored: Matcher | Matcher[];
+  awaitWriteFinish: boolean | Partial<AWF>;
+}>;
+type MatchFunction = (val: string, stats?: Stats) => boolean;
+interface MatcherObject {
+  path: string;
+  recursive?: boolean;
+}
+type Matcher = string | RegExp | MatchFunction | MatcherObject;
+//#endregion
+//#region node_modules/.pnpm/c12@4.0.0-beta.3_chokidar@5.0.0_dotenv@17.3.1_giget@3.1.2_jiti@2.6.1_magicast@0.5.2/node_modules/c12/dist/index.d.mts
+//#region src/dotenv.d.ts
+interface DotenvOptions {
+  /**
+   * The project root directory (either absolute or relative to the current working directory).
+   *
+   * Defaults to `options.cwd` in `loadConfig` context, or `process.cwd()` when used as standalone.
+   */
+  cwd?: string;
+  /**
+   * What file or files to look in for environment variables (either absolute or relative
+   * to the current working directory). For example, `.env`.
+   * With the array type, the order enforce the env loading priority (last one overrides).
+   */
+  fileName?: string | string[];
+  /**
+   * Whether to interpolate variables within .env.
+   *
+   * @example
+   * ```env
+   * BASE_DIR="/test"
+   * # resolves to "/test/further"
+   * ANOTHER_DIR="${BASE_DIR}/further"
+   * ```
+   */
+  interpolate?: boolean;
+  /**
+   * An object describing environment variables (key, value pairs).
+   */
+  env?: NodeJS.ProcessEnv;
+  /**
+   * Resolve `_FILE` suffixed environment variables by reading the file at the
+   * specified path and assigning its trimmed content to the base key.
+   *
+   * This is useful for container secrets (e.g. Docker, Kubernetes) where
+   * sensitive values are mounted as files.
+   *
+   * @default false
+   *
+   * @example
+   * ```env
+   * DATABASE_PASSWORD_FILE="/run/secrets/db_password"
+   * # resolves to DATABASE_PASSWORD=<contents of /run/secrets/db_password>
+   * ```
+   */
+  expandFileReferences?: boolean;
+}
+declare global {
+  var __c12_dotenv_vars__: Map<Record<string, any>, Set<string>>;
+} //#endregion
+//#region src/types.d.ts
+interface ConfigLayerMeta {
+  name?: string;
+  [key: string]: any;
+}
+type UserInputConfig = Record<string, any>;
+interface C12InputConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+  $test?: T;
+  $development?: T;
+  $production?: T;
+  $env?: Record<string, T>;
+  $meta?: MT;
+}
+interface SourceOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+  /** Custom meta for layer */
+  meta?: MT;
+  /** Layer config overrides */
+  overrides?: T;
+  [key: string]: any;
+  /**
+   * Options for cloning remote sources
+   *
+   * @see https://giget.unjs.io
+   */
+  giget?: DownloadTemplateOptions;
+  /**
+   * Install dependencies after cloning
+   *
+   * @see https://nypm.unjs.io
+   */
+  install?: boolean;
+  /**
+   * Token for cloning private sources
+   *
+   * @see https://giget.unjs.io#providing-token-for-private-repositories
+   */
+  auth?: string;
+}
+interface ConfigLayer<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+  config: T | null;
+  source?: string;
+  sourceOptions?: SourceOptions<T, MT>;
+  meta?: MT;
+  cwd?: string;
+  configFile?: string;
+}
+interface ResolvedConfig<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> extends ConfigLayer<T, MT> {
+  config: T;
+  layers?: ConfigLayer<T, MT>[];
+  cwd?: string;
+  _configFile?: string;
+}
+type ConfigSource = "overrides" | "main" | "rc" | "packageJson" | "defaultConfig";
+interface ConfigFunctionContext {
+  [key: string]: any;
+}
+interface ResolvableConfigContext<T extends UserInputConfig = UserInputConfig> {
+  configs: Record<ConfigSource, T | null | undefined>;
+  rawConfigs: Record<ConfigSource, ResolvableConfig<T> | null | undefined>;
+}
+type MaybePromise<T> = T | Promise<T>;
+type ResolvableConfig<T extends UserInputConfig = UserInputConfig> = MaybePromise<T | null | undefined> | ((ctx: ResolvableConfigContext<T>) => MaybePromise<T | null | undefined>);
+interface LoadConfigOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> {
+  name?: string;
+  cwd?: string;
+  configFile?: string;
+  rcFile?: false | string;
+  globalRc?: boolean;
+  dotenv?: boolean | DotenvOptions;
+  envName?: string | false;
+  packageJson?: boolean | string | string[];
+  defaults?: T;
+  defaultConfig?: ResolvableConfig<T>;
+  overrides?: ResolvableConfig<T>;
+  omit$Keys?: boolean;
+  /** Context passed to config functions */
+  context?: ConfigFunctionContext;
+  resolve?: (id: string, options: LoadConfigOptions<T, MT>) => null | undefined | ResolvedConfig<T, MT> | Promise<ResolvedConfig<T, MT> | undefined | null>;
+  /** Custom import function used to load configuration files */
+  import?: (id: string) => Promise<unknown>;
+  /** Custom resolver for picking which export to use from the loaded module. Default: `(mod) => mod.default || mod` */
+  resolveModule?: (mod: any) => any;
+  giget?: false | DownloadTemplateOptions;
+  merger?: (...sources: Array<T | null | undefined>) => T;
+  extend?: false | {
+    extendKey?: string | string[];
+  };
+  configFileRequired?: boolean;
+}
+//#endregion
+//#region src/watch.d.ts
+type DiffEntries = ReturnType<typeof diff>;
+type ConfigWatcher<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> = ResolvedConfig<T, MT> & {
+  watchingFiles: string[];
+  unwatch: () => Promise<void>;
+};
+interface WatchConfigOptions<T extends UserInputConfig = UserInputConfig, MT extends ConfigLayerMeta = ConfigLayerMeta> extends LoadConfigOptions<T, MT> {
+  chokidarOptions?: ChokidarOptions;
+  debounce?: false | number;
+  onWatch?: (event: {
+    type: "created" | "updated" | "removed";
+    path: string;
+  }) => void | Promise<void>;
+  acceptHMR?: (context: {
+    getDiff: () => DiffEntries;
+    newConfig: ResolvedConfig<T, MT>;
+    oldConfig: ResolvedConfig<T, MT>;
+  }) => void | boolean | Promise<void | boolean>;
+  onUpdate?: (context: {
+    getDiff: () => ReturnType<typeof diff>;
+    newConfig: ResolvedConfig<T, MT>;
+    oldConfig: ResolvedConfig<T, MT>;
+  }) => void | Promise<void>;
+}
+//#endregion
+export { WatchConfigOptions as a, ResolvedConfig as i, ConfigWatcher as n, ChokidarOptions as o, DotenvOptions as r, C12InputConfig as t };

package/dist/_libs/citty.mjs

@@ -1,26 +1,5 @@
-import consola$1 from "consola";
-import { colors } from "consola/utils";
-
-//#region node_modules/.pnpm/citty@0.1.6/node_modules/citty/dist/index.mjs
-function toArray(val) {
-	if (Array.isArray(val)) return val;
-	return val === void 0 ? [] : [val];
-}
-function formatLineColumns(lines, linePrefix = "") {
-	const maxLengh = [];
-	for (const line of lines) for (const [i, element] of line.entries()) maxLengh[i] = Math.max(maxLengh[i] || 0, element.length);
-	return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLengh[i])).join("  ")).join("\n");
-}
-function resolveValue(input) {
-	return typeof input === "function" ? input() : input;
-}
-var CLIError = class extends Error {
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = "CLIError";
-	}
-};
+import { parseArgs } from "node:util";
+//#region node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/_chunks/libs/scule.mjs
 const NUMBER_CHAR_RE = /\d/;
 const STR_SPLITTERS = [
 	"-",
@@ -85,101 +64,141 @@ function camelCase(str, opts) {
 function kebabCase(str, joiner) {
 	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner ?? "-") : "";
 }
-function toArr(any) {
-	return any == void 0 ? [] : Array.isArray(any) ? any : [any];
+//#endregion
+//#region node_modules/.pnpm/citty@0.2.1/node_modules/citty/dist/index.mjs
+function toArray(val) {
+	if (Array.isArray(val)) return val;
+	return val === void 0 ? [] : [val];
 }
-function toVal(out, key, val, opts) {
-	let x;
-	const old = out[key];
-	const nxt = ~opts.string.indexOf(key) ? val == void 0 || val === true ? "" : String(val) : typeof val === "boolean" ? val : ~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
-	out[key] = old == void 0 ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+function formatLineColumns(lines, linePrefix = "") {
+	const maxLength = [];
+	for (const line of lines) for (const [i, element] of line.entries()) maxLength[i] = Math.max(maxLength[i] || 0, element.length);
+	return lines.map((l) => l.map((c, i) => linePrefix + c[i === 0 ? "padStart" : "padEnd"](maxLength[i])).join("  ")).join("\n");
 }
-function parseRawArgs(args = [], opts = {}) {
-	let k;
-	let arr;
-	let arg;
-	let name;
-	let val;
-	const out = { _: [] };
-	let i = 0;
-	let j = 0;
-	let idx = 0;
-	const len = args.length;
-	const alibi = opts.alias !== void 0;
-	const strict = opts.unknown !== void 0;
-	const defaults = opts.default !== void 0;
-	opts.alias = opts.alias || {};
-	opts.string = toArr(opts.string);
-	opts.boolean = toArr(opts.boolean);
-	if (alibi) for (k in opts.alias) {
-		arr = opts.alias[k] = toArr(opts.alias[k]);
-		for (i = 0; i < arr.length; i++) (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
-	}
-	for (i = opts.boolean.length; i-- > 0;) {
-		arr = opts.alias[opts.boolean[i]] || [];
-		for (j = arr.length; j-- > 0;) opts.boolean.push(arr[j]);
-	}
-	for (i = opts.string.length; i-- > 0;) {
-		arr = opts.alias[opts.string[i]] || [];
-		for (j = arr.length; j-- > 0;) opts.string.push(arr[j]);
+function resolveValue(input) {
+	return typeof input === "function" ? input() : input;
+}
+var CLIError = class extends Error {
+	code;
+	constructor(message, code) {
+		super(message);
+		this.name = "CLIError";
+		this.code = code;
 	}
-	if (defaults) for (k in opts.default) {
-		name = typeof opts.default[k];
-		arr = opts.alias[k] = opts.alias[k] || [];
-		if (opts[name] !== void 0) {
-			opts[name].push(k);
-			for (i = 0; i < arr.length; i++) opts[name].push(arr[i]);
+};
+function parseRawArgs(args = [], opts = {}) {
+	const booleans = new Set(opts.boolean || []);
+	const strings = new Set(opts.string || []);
+	const aliasMap = opts.alias || {};
+	const defaults = opts.default || {};
+	const aliasToMain = /* @__PURE__ */ new Map();
+	const mainToAliases = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(aliasMap)) {
+		const targets = value;
+		for (const target of targets) {
+			aliasToMain.set(key, target);
+			if (!mainToAliases.has(target)) mainToAliases.set(target, []);
+			mainToAliases.get(target).push(key);
+			aliasToMain.set(target, key);
+			if (!mainToAliases.has(key)) mainToAliases.set(key, []);
+			mainToAliases.get(key).push(target);
 		}
 	}
-	const keys = strict ? Object.keys(opts.alias) : [];
-	for (i = 0; i < len; i++) {
-		arg = args[i];
+	const options = {};
+	function getType(name) {
+		if (booleans.has(name)) return "boolean";
+		const aliases = mainToAliases.get(name) || [];
+		for (const alias of aliases) if (booleans.has(alias)) return "boolean";
+		return "string";
+	}
+	const allOptions = new Set([
+		...booleans,
+		...strings,
+		...Object.keys(aliasMap),
+		...Object.values(aliasMap).flat(),
+		...Object.keys(defaults)
+	]);
+	for (const name of allOptions) if (!options[name]) options[name] = {
+		type: getType(name),
+		default: defaults[name]
+	};
+	for (const [alias, main] of aliasToMain.entries()) if (alias.length === 1 && options[main] && !options[main].short) options[main].short = alias;
+	const processedArgs = [];
+	const negatedFlags = {};
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
 		if (arg === "--") {
-			out._ = out._.concat(args.slice(++i));
+			processedArgs.push(...args.slice(i));
 			break;
 		}
-		for (j = 0; j < arg.length; j++) if (arg.charCodeAt(j) !== 45) break;
-		if (j === 0) out._.push(arg);
-		else if (arg.substring(j, j + 3) === "no-") {
-			name = arg.slice(Math.max(0, j + 3));
-			if (strict && !~keys.indexOf(name)) return opts.unknown(arg);
-			out[name] = false;
-		} else {
-			for (idx = j + 1; idx < arg.length; idx++) if (arg.charCodeAt(idx) === 61) break;
-			name = arg.substring(j, idx);
-			val = arg.slice(Math.max(0, ++idx)) || i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i];
-			arr = j === 2 ? [name] : name;
-			for (idx = 0; idx < arr.length; idx++) {
-				name = arr[idx];
-				if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
-				toVal(out, name, idx + 1 < arr.length || val, opts);
-			}
+		if (arg.startsWith("--no-")) {
+			const flagName = arg.slice(5);
+			negatedFlags[flagName] = true;
+			continue;
 		}
+		processedArgs.push(arg);
 	}
-	if (defaults) {
-		for (k in opts.default) if (out[k] === void 0) out[k] = opts.default[k];
+	let parsed;
+	try {
+		parsed = parseArgs({
+			args: processedArgs,
+			options: Object.keys(options).length > 0 ? options : void 0,
+			allowPositionals: true,
+			strict: false
+		});
+	} catch {
+		parsed = {
+			values: {},
+			positionals: processedArgs
+		};
 	}
-	if (alibi) for (k in out) {
-		arr = opts.alias[k] || [];
-		while (arr.length > 0) out[arr.shift()] = out[k];
+	const out = { _: [] };
+	out._ = parsed.positionals;
+	for (const [key, value] of Object.entries(parsed.values)) out[key] = value;
+	for (const [name] of Object.entries(negatedFlags)) {
+		out[name] = false;
+		const mainName = aliasToMain.get(name);
+		if (mainName) out[mainName] = false;
+		const aliases = mainToAliases.get(name);
+		if (aliases) for (const alias of aliases) out[alias] = false;
+	}
+	for (const [alias, main] of aliasToMain.entries()) {
+		if (out[alias] !== void 0 && out[main] === void 0) out[main] = out[alias];
+		if (out[main] !== void 0 && out[alias] === void 0) out[alias] = out[main];
 	}
 	return out;
 }
-function parseArgs(rawArgs, argsDef) {
+const noColor = /* @__PURE__ */ (() => {
+	const env = globalThis.process?.env ?? {};
+	return env.NO_COLOR === "1" || env.TERM === "dumb" || env.TEST || env.CI;
+})();
+const _c = (c, r = 39) => (t) => noColor ? t : `\u001B[${c}m${t}\u001B[${r}m`;
+const bold = /* @__PURE__ */ _c(1, 22);
+const cyan = /* @__PURE__ */ _c(36);
+const gray = /* @__PURE__ */ _c(90);
+const underline = /* @__PURE__ */ _c(4, 24);
+function parseArgs$1(rawArgs, argsDef) {
 	const parseOptions = {
 		boolean: [],
 		string: [],
-		mixed: [],
 		alias: {},
 		default: {}
 	};
 	const args = resolveArgs(argsDef);
 	for (const arg of args) {
 		if (arg.type === "positional") continue;
-		if (arg.type === "string") parseOptions.string.push(arg.name);
+		if (arg.type === "string" || arg.type === "enum") parseOptions.string.push(arg.name);
 		else if (arg.type === "boolean") parseOptions.boolean.push(arg.name);
 		if (arg.default !== void 0) parseOptions.default[arg.name] = arg.default;
 		if (arg.alias) parseOptions.alias[arg.name] = arg.alias;
+		const camelName = camelCase(arg.name);
+		const kebabName = kebabCase(arg.name);
+		if (camelName !== arg.name || kebabName !== arg.name) {
+			const existingAliases = toArray(parseOptions.alias[arg.name] || []);
+			if (camelName !== arg.name && !existingAliases.includes(camelName)) existingAliases.push(camelName);
+			if (kebabName !== arg.name && !existingAliases.includes(kebabName)) existingAliases.push(kebabName);
+			if (existingAliases.length > 0) parseOptions.alias[arg.name] = existingAliases;
+		}
 	}
 	const parsed = parseRawArgs(rawArgs, parseOptions);
 	const [ ...positionalArguments] = parsed._;
@@ -191,6 +210,10 @@ function parseArgs(rawArgs, argsDef) {
 		if (nextPositionalArgument !== void 0) parsedArgsProxy[arg.name] = nextPositionalArgument;
 		else if (arg.default === void 0 && arg.required !== false) throw new CLIError(`Missing required positional argument: ${arg.name.toUpperCase()}`, "EARG");
 		else parsedArgsProxy[arg.name] = arg.default;
+	} else if (arg.type === "enum") {
+		const argument = parsedArgsProxy[arg.name];
+		const options = arg.options || [];
+		if (argument !== void 0 && options.length > 0 && !options.includes(argument)) throw new CLIError(`Invalid value for argument: ${cyan(`--${arg.name}`)} (${cyan(argument)}). Expected one of: ${options.map((o) => cyan(o)).join(", ")}.`, "EARG");
 	} else if (arg.required && parsedArgsProxy[arg.name] === void 0) throw new CLIError(`Missing required argument: --${arg.name}`, "EARG");
 	return parsedArgsProxy;
 }
@@ -208,7 +231,7 @@ function defineCommand(def) {
 }
 async function runCommand(cmd, opts) {
 	const cmdArgs = await resolveValue(cmd.args || {});
-	const parsedArgs = parseArgs(opts.rawArgs, cmdArgs);
+	const parsedArgs = parseArgs$1(opts.rawArgs, cmdArgs);
 	const context = {
 		rawArgs: opts.rawArgs,
 		args: parsedArgs,
@@ -223,7 +246,7 @@ async function runCommand(cmd, opts) {
 			const subCommandArgIndex = opts.rawArgs.findIndex((arg) => !arg.startsWith("-"));
 			const subCommandName = opts.rawArgs[subCommandArgIndex];
 			if (subCommandName) {
-				if (!subCommands[subCommandName]) throw new CLIError(`Unknown command \`${subCommandName}\``, "E_UNKNOWN_COMMAND");
+				if (!subCommands[subCommandName]) throw new CLIError(`Unknown command ${cyan(subCommandName)}`, "E_UNKNOWN_COMMAND");
 				const subCommand = await resolveValue(subCommands[subCommandName]);
 				if (subCommand) await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
 			} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
@@ -246,11 +269,12 @@ async function resolveSubCommand(cmd, rawArgs, parent) {
 }
 async function showUsage(cmd, parent) {
 	try {
-		consola$1.log(await renderUsage(cmd, parent) + "\n");
+		console.log(await renderUsage(cmd, parent) + "\n");
 	} catch (error) {
-		consola$1.error(error);
+		console.error(error);
 	}
 }
+const negativePrefixRe = /^no[-A-Z]/;
 async function renderUsage(cmd, parent) {
 	const cmdMeta = await resolveValue(cmd.meta || {});
 	const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
@@ -265,15 +289,19 @@ async function renderUsage(cmd, parent) {
 		const isRequired = arg.required !== false && arg.default === void 0;
 		const defaultHint = arg.default ? `="${arg.default}"` : "";
 		posLines.push([
-			"`" + name + defaultHint + "`",
+			cyan(name + defaultHint),
 			arg.description || "",
 			arg.valueHint ? `<${arg.valueHint}>` : ""
 		]);
 		usageLine.push(isRequired ? `<${name}>` : `[${name}]`);
 	} else {
 		const isRequired = arg.required === true && arg.default === void 0;
-		const argStr = (arg.type === "boolean" && arg.default === true ? [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ") : [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ")) + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "");
-		argLines.push(["`" + argStr + (isRequired ? " (required)" : "") + "`", arg.description || ""]);
+		const argStr = [...(arg.alias || []).map((a) => `-${a}`), `--${arg.name}`].join(", ") + (arg.type === "string" && (arg.valueHint || arg.default) ? `=${arg.valueHint ? `<${arg.valueHint}>` : `"${arg.default || ""}"`}` : "") + (arg.type === "enum" && arg.options ? `=<${arg.options.join("|")}>` : "");
+		argLines.push([cyan(argStr + (isRequired ? " (required)" : "")), arg.description || ""]);
+		if (arg.type === "boolean" && (arg.default === true || arg.negativeDescription) && !negativePrefixRe.test(arg.name)) {
+			const negativeArgStr = [...(arg.alias || []).map((a) => `--no-${a}`), `--no-${arg.name}`].join(", ");
+			argLines.push([cyan(negativeArgStr + (isRequired ? " (required)" : "")), arg.negativeDescription || ""]);
+		}
 		if (isRequired) usageLine.push(argStr);
 	}
 	if (cmd.subCommands) {
@@ -281,30 +309,31 @@ async function renderUsage(cmd, parent) {
 		const subCommands = await resolveValue(cmd.subCommands);
 		for (const [name, sub] of Object.entries(subCommands)) {
 			const meta = await resolveValue((await resolveValue(sub))?.meta);
-			commandsLines.push([`\`${name}\``, meta?.description || ""]);
+			if (meta?.hidden) continue;
+			commandsLines.push([cyan(name), meta?.description || ""]);
 			commandNames.push(name);
 		}
 		usageLine.push(commandNames.join("|"));
 	}
 	const usageLines = [];
 	const version = cmdMeta.version || parentMeta.version;
-	usageLines.push(colors.gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
+	usageLines.push(gray(`${cmdMeta.description} (${commandName + (version ? ` v${version}` : "")})`), "");
 	const hasOptions = argLines.length > 0 || posLines.length > 0;
-	usageLines.push(`${colors.underline(colors.bold("USAGE"))} \`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}\``, "");
+	usageLines.push(`${underline(bold("USAGE"))} ${cyan(`${commandName}${hasOptions ? " [OPTIONS]" : ""} ${usageLine.join(" ")}`)}`, "");
 	if (posLines.length > 0) {
-		usageLines.push(colors.underline(colors.bold("ARGUMENTS")), "");
+		usageLines.push(underline(bold("ARGUMENTS")), "");
 		usageLines.push(formatLineColumns(posLines, "  "));
 		usageLines.push("");
 	}
 	if (argLines.length > 0) {
-		usageLines.push(colors.underline(colors.bold("OPTIONS")), "");
+		usageLines.push(underline(bold("OPTIONS")), "");
 		usageLines.push(formatLineColumns(argLines, "  "));
 		usageLines.push("");
 	}
 	if (commandsLines.length > 0) {
-		usageLines.push(colors.underline(colors.bold("COMMANDS")), "");
+		usageLines.push(underline(bold("COMMANDS")), "");
 		usageLines.push(formatLineColumns(commandsLines, "  "));
-		usageLines.push("", `Use \`${commandName} <command> --help\` for more information about a command.`);
+		usageLines.push("", `Use ${cyan(`${commandName} <command> --help`)} for more information about a command.`);
 	}
 	return usageLines.filter((l) => typeof l === "string").join("\n");
 }
@@ -318,16 +347,15 @@ async function runMain(cmd, opts = {}) {
 		} else if (rawArgs.length === 1 && rawArgs[0] === "--version") {
 			const meta = typeof cmd.meta === "function" ? await cmd.meta() : await cmd.meta;
 			if (!meta?.version) throw new CLIError("No version specified", "E_NO_VERSION");
-			consola$1.log(meta.version);
+			console.log(meta.version);
 		} else await runCommand(cmd, { rawArgs });
 	} catch (error) {
-		const isCLIError = error instanceof CLIError;
-		if (!isCLIError) consola$1.error(error, "\n");
-		if (isCLIError) await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
-		consola$1.error(error.message);
+		if (error instanceof CLIError) {
+			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
+			console.error(error.message);
+		} else console.error(error, "\n");
 		process.exit(1);
 	}
 }
-
 //#endregion
-export { runMain as n, defineCommand as t };
+export { runMain as n, defineCommand as t };