rolldown 0.13.2 → 0.14.0

package/dist/esm/cli.mjs

@@ -1,10 +1,8 @@
 import __node_module__ from 'node:module';
 const require = __node_module__.createRequire(import.meta.url)
-import { LogLevelOptionSchema, LogLevelSchema, LogLevelWithErrorSchema, RollupLogSchema, RollupLogWithStringSchema, __export, arraify } from "../shared/plugin-context-data-iKSAvmTX.mjs";
-import { rolldown } from "../shared/rolldown-Hf7txSlh.mjs";
-import { description, version } from "../shared/package-unZcnfG9.mjs";
-import { createConsola } from "../shared/consola.36c0034f-m5cABVv4.mjs";
-import { default as nodePath } from "node:path";
+import { LogLevelOptionSchema, LogLevelSchema, LogLevelWithErrorSchema, RollupLogSchema, RollupLogWithStringSchema, __export, arraify, description, rolldown, version, watch } from "../shared/src_index-ywYMd4vB.mjs";
+import { createConsola } from "../shared/consola.36c0034f-Xyw7SC_7.mjs";
+import { default as nodePath, default as path } from "node:path";
 import { ZodFirstPartyTypeKind, ZodFirstPartyTypeKind as ZodFirstPartyTypeKind$1, ZodFirstPartyTypeKind as ZodFirstPartyTypeKind$2, z, z as z$1, z as z$2, z as z$3 } from "zod";
 import { default as process$1, env } from "node:process";
 import { performance } from "node:perf_hooks";
@@ -114,6 +112,205 @@ __export(colors_ns, {
 });
 const { bold: bold, cyan: cyan, dim: dim, gray: gray, green: green, red: red, underline: underline, yellow: yellow } = createColors({useColor: env.FORCE_COLOR !== "0" && !env.NO_COLOR});
 
+//#endregion
+//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+const signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+	signals.push("SIGALRM", "SIGABRT", "SIGVTALRM", "SIGXCPU", "SIGXFSZ", "SIGUSR2", "SIGTRAP", "SIGSYS", "SIGQUIT", "SIGIOT");
+}
+if (process.platform === "linux") {
+	signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+const processOk = (process$3) => !!process$3 && typeof process$3 === "object" && typeof process$3.removeListener === "function" && typeof process$3.emit === "function" && typeof process$3.reallyExit === "function" && typeof process$3.listeners === "function" && typeof process$3.kill === "function" && typeof process$3.pid === "number" && typeof process$3.on === "function";
+const kExitEmitter = Symbol.for("signal-exit emitter");
+const global = globalThis;
+const ObjectDefineProperty = Object.defineProperty.bind(Object);
+class Emitter {
+	emitted = {
+		afterExit: false,
+		exit: false
+	};
+	listeners = {
+		afterExit: [],
+		exit: []
+	};
+	count = 0;
+	id = Math.random();
+	constructor() {
+		if (global[kExitEmitter]) {
+			return global[kExitEmitter];
+		}
+		ObjectDefineProperty(global, kExitEmitter, {
+			value: this,
+			writable: false,
+			enumerable: false,
+			configurable: false
+		});
+	}
+	on(ev, fn) {
+		this.listeners[ev].push(fn);
+	}
+	removeListener(ev, fn) {
+		const list = this.listeners[ev];
+		const i = list.indexOf(fn);
+		if (i === -1) {
+			return;
+		}
+		if (i === 0 && list.length === 1) {
+			list.length = 0;
+		} else {
+			list.splice(i, 1);
+		}
+	}
+	emit(ev, code, signal) {
+		if (this.emitted[ev]) {
+			return false;
+		}
+		this.emitted[ev] = true;
+		let ret = false;
+		for (const fn of this.listeners[ev]) {
+			ret = fn(code, signal) === true || ret;
+		}
+		if (ev === "exit") {
+			ret = this.emit("afterExit", code, signal) || ret;
+		}
+		return ret;
+	}
+}
+class SignalExitBase {}
+const signalExitWrap = (handler) => {
+	return {
+		onExit(cb, opts) {
+			return handler.onExit(cb, opts);
+		},
+		load() {
+			return handler.load();
+		},
+		unload() {
+			return handler.unload();
+		}
+	};
+};
+class SignalExitFallback extends SignalExitBase {
+	onExit() {
+		return () => {};
+	}
+	load() {}
+	unload() {}
+}
+class SignalExit extends SignalExitBase {
+	#hupSig = process$2.platform === "win32" ? "SIGINT" : "SIGHUP";
+	#emitter = new Emitter();
+	#process;
+	#originalProcessEmit;
+	#originalProcessReallyExit;
+	#sigListeners = {};
+	#loaded = false;
+	constructor(process$3) {
+		super();
+		this.#process = process$3;
+		this.#sigListeners = {};
+		for (const sig of signals) {
+			this.#sigListeners[sig] = () => {
+				const listeners = this.#process.listeners(sig);
+				let { count: count } = this.#emitter;
+				const p = process$3;
+				if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+					count += p.__signal_exit_emitter__.count;
+				}
+				if (listeners.length === count) {
+					this.unload();
+					const ret = this.#emitter.emit("exit", null, sig);
+					const s = sig === "SIGHUP" ? this.#hupSig : sig;
+					if (!ret) process$3.kill(process$3.pid, s);
+				}
+			};
+		}
+		this.#originalProcessReallyExit = process$3.reallyExit;
+		this.#originalProcessEmit = process$3.emit;
+	}
+	onExit(cb, opts) {
+		if (!processOk(this.#process)) {
+			return () => {};
+		}
+		if (this.#loaded === false) {
+			this.load();
+		}
+		const ev = opts?.alwaysLast ? "afterExit" : "exit";
+		this.#emitter.on(ev, cb);
+		return () => {
+			this.#emitter.removeListener(ev, cb);
+			if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+				this.unload();
+			}
+		};
+	}
+	load() {
+		if (this.#loaded) {
+			return;
+		}
+		this.#loaded = true;
+		this.#emitter.count += 1;
+		for (const sig of signals) {
+			try {
+				const fn = this.#sigListeners[sig];
+				if (fn) this.#process.on(sig, fn);
+			} catch (_) {}
+		}
+		this.#process.emit = (ev, ...a) => {
+			return this.#processEmit(ev, ...a);
+		};
+		this.#process.reallyExit = (code) => {
+			return this.#processReallyExit(code);
+		};
+	}
+	unload() {
+		if (!this.#loaded) {
+			return;
+		}
+		this.#loaded = false;
+		signals.forEach((sig) => {
+			const listener = this.#sigListeners[sig];
+			if (!listener) {
+				throw new Error("Listener not defined for signal: " + sig);
+			}
+			try {
+				this.#process.removeListener(sig, listener);
+			} catch (_) {}
+		});
+		this.#process.emit = this.#originalProcessEmit;
+		this.#process.reallyExit = this.#originalProcessReallyExit;
+		this.#emitter.count -= 1;
+	}
+	#processReallyExit(code) {
+		if (!processOk(this.#process)) {
+			return 0;
+		}
+		this.#process.exitCode = code || 0;
+		this.#emitter.emit("exit", this.#process.exitCode, null);
+		return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+	}
+	#processEmit(ev, ...args) {
+		const og = this.#originalProcessEmit;
+		if (ev === "exit" && processOk(this.#process)) {
+			if (typeof args[0] === "number") {
+				this.#process.exitCode = args[0];
+			}
+			const ret = og.call(this.#process, ev, ...args);
+			this.#emitter.emit("exit", this.#process.exitCode, null);
+			return ret;
+		} else {
+			return og.call(this.#process, ev, ...args);
+		}
+	}
+}
+const process$2 = globalThis.process;
+const { onExit: onExit, load: load, unload: unload } = signalExitWrap(processOk(process$2) ? new SignalExit(process$2) : new SignalExitFallback());
+
 //#endregion
 //#region src/cli/commands/bundle.ts
 async function bundleWithConfig(configPath, cliOptions) {
@@ -124,13 +321,13 @@ async function bundleWithConfig(configPath, cliOptions) {
 	}
 	const configList = arraify(config);
 	for (const config$1 of configList) {
-		await bundleInner(config$1, cliOptions);
+		cliOptions.watch ? await watchInner(config$1, cliOptions) : bundleInner(config$1, cliOptions);
 	}
 }
 async function bundleWithCliOptions(cliOptions) {
 	if (cliOptions.output.dir) {
-		await bundleInner({}, cliOptions);
-	} else {
+		cliOptions.watch ? await watchInner({}, cliOptions) : await bundleInner({}, cliOptions);
+	} else if (!cliOptions.watch) {
 		const build = await rolldown(cliOptions.input);
 		const { output: output } = await build.generate(cliOptions.output);
 		if (output.length > 1) {
@@ -142,8 +339,42 @@ async function bundleWithCliOptions(cliOptions) {
 		} else {
 			logger.log(output[0].code);
 		}
+	} else {
+		logger.error("You must specify `output.dir` to use watch mode");
+		process.exit(1);
 	}
 }
+async function watchInner(options$1, cliOptions) {
+	const watcher = await watch({
+		...options$1,
+		...cliOptions.input
+	});
+	onExit((code) => {
+		(Promise.resolve(watcher.close())).finally(() => {
+			process.exit(typeof code === "number" ? code : 0);
+		});
+		return true;
+	});
+	const changedFile = [];
+	watcher.on("change", (id, event) => {
+		if (event.event === "update") {
+			changedFile.push(id);
+		}
+	});
+	watcher.on("event", (event) => {
+		switch (event.code) {
+			case "BUNDLE_START":
+				logger.log(`Found ${bold((changedFile.map(relativeId)).join(", "))} changed, rebuilding...`);
+				changedFile.length = 0;
+				break;
+			case "BUNDLE_END":
+				logger.success(`Rebuilt ${bold(relativeId(event.output[0]))} in ${bold(ms(event.duration))}.`);
+				break;
+			default: break;
+		}
+	});
+	logger.log(`Waiting for changes...`);
+}
 async function bundleInner(options$1, cliOptions) {
 	const startTime = performance.now();
 	const build = await rolldown({
@@ -158,8 +389,7 @@ async function bundleInner(options$1, cliOptions) {
 	printBundleOutputPretty(bundleOutput);
 	logger.log(``);
 	const duration = endTime - startTime;
-	const spent = duration < 1000 ? `${duration.toFixed(2)} ms` : `${(duration / 1000).toFixed(2)} s`;
-	logger.success(`Finished in ${bold(spent)}`);
+	logger.success(`Finished in ${bold(ms(duration))}`);
 }
 function printBundleOutputPretty(output) {
 	const outputEntries = collectOutputEntries(output.output);
@@ -220,15 +450,22 @@ function printOutputEntries(entries, sizeAdjustment, distPath) {
 		}
 	}
 }
-function withTrailingSlash(path) {
-	if (path[path.length - 1] !== "/") {
-		return `${path}/`;
+function withTrailingSlash(path$1) {
+	if (path$1[path$1.length - 1] !== "/") {
+		return `${path$1}/`;
 	}
-	return path;
+	return path$1;
+}
+function ms(duration) {
+	return duration < 1000 ? `${duration.toFixed(2)} ms` : `${(duration / 1000).toFixed(2)} s`;
+}
+function relativeId(id) {
+	if (!path.isAbsolute(id)) return id;
+	return path.relative(path.resolve(), id);
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/Options.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/Options.js
 const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
 const defaultOptions = {
 	name: undefined,
@@ -260,7 +497,7 @@ const getDefaultOptions = (options$1) => typeof options$1 === "string" ? {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/Refs.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/Refs.js
 const getRefs = (options$1) => {
 	const _options = getDefaultOptions(options$1);
 	const currentPath = _options.name !== undefined ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
@@ -277,7 +514,7 @@ const getRefs = (options$1) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
 function addErrorMessage(res, key, errorMessage, refs) {
 	if (!refs?.errorMessages) return;
 	if (errorMessage) {
@@ -293,16 +530,16 @@ function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
 function parseAnyDef() {
 	return {};
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
 function parseArrayDef(def, refs) {
 	const res = {type: "array"};
-	if (def.type?._def?.typeName !== ZodFirstPartyTypeKind$2.ZodAny) {
+	if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind$2.ZodAny) {
 		res.items = parseDef(def.type._def, {
 			...refs,
 			currentPath: [...refs.currentPath, "items"]
@@ -322,7 +559,7 @@ function parseArrayDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
 function parseBigintDef(def, refs) {
 	const res = {
 		type: "integer",
@@ -368,25 +605,25 @@ function parseBigintDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
 function parseBooleanDef() {
 	return {type: "boolean"};
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
 function parseBrandedDef(_def, refs) {
 	return parseDef(_def.type._def, refs);
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
 const parseCatchDef = (def, refs) => {
 	return parseDef(def.innerType._def, refs);
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
 function parseDateDef(def, refs, overrideDateStrategy) {
 	const strategy = overrideDateStrategy ?? refs.dateStrategy;
 	if (Array.isArray(strategy)) {
@@ -427,7 +664,7 @@ const integerDateParser = (def, refs) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
 function parseDefaultDef(_def, refs) {
 	return {
 		...parseDef(_def.innerType._def, refs),
@@ -436,13 +673,13 @@ function parseDefaultDef(_def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
 function parseEffectsDef(_def, refs) {
 	return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : {};
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
 function parseEnumDef(def) {
 	return {
 		type: "string",
@@ -451,7 +688,7 @@ function parseEnumDef(def) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
 const isJsonSchema7AllOfType = (type) => {
 	if ("type"in type && type.type === "string") return false;
 	return "allOf"in type;
@@ -490,7 +727,7 @@ function parseIntersectionDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
 function parseLiteralDef(def, refs) {
 	const parsedType = typeof def.value;
 	if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
@@ -509,7 +746,7 @@ function parseLiteralDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
 let emojiRegex;
 const zodPatterns = {
 	cuid: /^[cC][^\s-]{8,}$/,
@@ -765,7 +1002,7 @@ const processRegExp = (regexOrFunction, refs) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
 function parseRecordDef(def, refs) {
 	if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodEnum) {
 		return {
@@ -792,10 +1029,7 @@ function parseRecordDef(def, refs) {
 		return schema$1;
 	}
 	if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodString && def.keyType._def.checks?.length) {
-		const keyType = (Object.entries(parseStringDef(def.keyType._def, refs))).reduce((acc, [key, value]) => key === "type" ? acc : {
-			...acc,
-			[key]: value
-		}, {});
+		const { type: type,...keyType } = parseStringDef(def.keyType._def, refs);
 		return {
 			...schema$1,
 			propertyNames: keyType
@@ -805,12 +1039,18 @@ function parseRecordDef(def, refs) {
 			...schema$1,
 			propertyNames: {enum: def.keyType._def.values}
 		};
+	} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodBranded && def.keyType._def.type._def.typeName === ZodFirstPartyTypeKind$1.ZodString && def.keyType._def.type._def.checks?.length) {
+		const { type: type,...keyType } = parseBrandedDef(def.keyType._def, refs);
+		return {
+			...schema$1,
+			propertyNames: keyType
+		};
 	}
 	return schema$1;
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
 function parseMapDef(def, refs) {
 	if (refs.mapStrategy === "record") {
 		return parseRecordDef(def, refs);
@@ -836,7 +1076,7 @@ function parseMapDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
 function parseNativeEnumDef(def) {
 	const object = def.values;
 	const actualKeys = (Object.keys(def.values)).filter((key) => {
@@ -851,13 +1091,13 @@ function parseNativeEnumDef(def) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
 function parseNeverDef() {
 	return {not: {}};
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
 function parseNullDef(refs) {
 	return refs.target === "openApi3" ? {
 		enum: ["null"],
@@ -866,7 +1106,7 @@ function parseNullDef(refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
 const primitiveMappings = {
 	ZodString: "string",
 	ZodNumber: "number",
@@ -924,7 +1164,7 @@ const asAnyOf = (def, refs) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
 function parseNullableDef(def, refs) {
 	if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
 		if (refs.target === "openApi3") {
@@ -957,7 +1197,7 @@ function parseNullableDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
 function parseNumberDef(def, refs) {
 	const res = {type: "number"};
 	if (!def.checks) return res;
@@ -1004,7 +1244,7 @@ function parseNumberDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
 function decideAdditionalProperties(def, refs) {
 	if (refs.removeAdditionalStrategy === "strict") {
 		return def.catchall._def.typeName === "ZodNever" ? def.unknownKeys !== "strict" : parseDef(def.catchall._def, {
@@ -1047,7 +1287,7 @@ function parseObjectDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
 const parseOptionalDef = (def, refs) => {
 	if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
 		return parseDef(def.innerType._def, refs);
@@ -1060,7 +1300,7 @@ const parseOptionalDef = (def, refs) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
 const parsePipelineDef = (def, refs) => {
 	if (refs.pipeStrategy === "input") {
 		return parseDef(def.in._def, refs);
@@ -1079,13 +1319,13 @@ const parsePipelineDef = (def, refs) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
 function parsePromiseDef(def, refs) {
 	return parseDef(def.type._def, refs);
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
 function parseSetDef(def, refs) {
 	const items = parseDef(def.valueType._def, {
 		...refs,
@@ -1106,7 +1346,7 @@ function parseSetDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
 function parseTupleDef(def, refs) {
 	if (def.rest) {
 		return {
@@ -1135,25 +1375,25 @@ function parseTupleDef(def, refs) {
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
 function parseUndefinedDef() {
 	return {not: {}};
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
 function parseUnknownDef() {
 	return {};
 }
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
 const parseReadonlyDef = (def, refs) => {
 	return parseDef(def.innerType._def, refs);
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parseDef.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/parseDef.js
 function parseDef(def, refs, forceResolution = false) {
 	const seenItem = refs.seen.get(def);
 	if (refs.override) {
@@ -1254,7 +1494,7 @@ const addMeta = (def, refs, jsonSchema) => {
 };
 
 //#endregion
-//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.2_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
+//#region ../../node_modules/.pnpm/zod-to-json-schema@3.23.5_zod@3.23.8/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
 const zodToJsonSchema = (schema$1, options$1) => {
 	const refs = getRefs(options$1);
 	const definitions = typeof options$1 === "object" && options$1.definitions ? (Object.entries(options$1.definitions)).reduce((acc, [name$1, schema$2]) => ({
@@ -1308,7 +1548,27 @@ const voidNullable = () => {
 //#region src/options/input-options.ts
 const inputOptionSchema = ((z$2.string()).or((z$2.string()).array())).or(z$2.record(z$2.string()));
 const externalSchema = ((stringOrRegExp()).or((stringOrRegExp()).array())).or(((z$2.function()).args(z$2.string(), (z$2.string()).optional(), z$2.boolean())).returns(voidNullableWith(z$2.boolean())));
-const moduleTypesSchema = z$2.record((((((((((z$2.literal("js")).or(z$2.literal("jsx"))).or(z$2.literal("ts"))).or(z$2.literal("tsx"))).or(z$2.literal("json"))).or(z$2.literal("text"))).or(z$2.literal("base64"))).or(z$2.literal("dataurl"))).or(z$2.literal("binary"))).or(z$2.literal("empty")));
+const moduleTypesSchema = z$2.record(((((((((((z$2.literal("js")).or(z$2.literal("jsx"))).or(z$2.literal("ts"))).or(z$2.literal("tsx"))).or(z$2.literal("json"))).or(z$2.literal("text"))).or(z$2.literal("base64"))).or(z$2.literal("dataurl"))).or(z$2.literal("binary"))).or(z$2.literal("empty"))).or(z$2.literal("css")));
+const jsxOptionsSchema = z$2.strictObject({
+	mode: (((z$2.literal("classic")).or(z$2.literal("automatic"))).describe("Jsx transformation mode")).optional(),
+	factory: ((z$2.string()).describe("Jsx element transformation")).optional(),
+	fragment: ((z$2.string()).describe("Jsx fragment transformation")).optional(),
+	importSource: ((z$2.string()).describe("Import the factory of element and fragment if mode is classic")).optional(),
+	jsxImportSource: ((z$2.string()).describe("Import the factory of element and fragment if mode is automatic")).optional(),
+	refresh: ((z$2.boolean()).describe("React refresh transformation")).optional(),
+	development: ((z$2.boolean()).describe("Development specific information")).optional()
+});
+const stringOrRegExpSchema = (stringOrRegExp()).or((stringOrRegExp()).array());
+const watchOptionsSchema = z$2.strictObject({
+	skipWrite: ((z$2.boolean()).describe("Skip the bundle.write() step")).optional(),
+	notify: ((z$2.strictObject({
+		pollInterval: (z$2.number()).optional(),
+		compareContents: (z$2.boolean()).optional()
+	})).describe("Notify options")).optional(),
+	include: stringOrRegExpSchema.optional(),
+	exclude: stringOrRegExpSchema.optional(),
+	chokidar: (z$2.any()).optional()
+});
 const inputOptionsSchema = z$2.strictObject({
 	input: inputOptionSchema.optional(),
 	plugins: ((phantom()).array()).optional(),
@@ -1317,6 +1577,7 @@ const inputOptionsSchema = z$2.strictObject({
 		alias: (z$2.record(z$2.string())).optional(),
 		aliasFields: (z$2.array(z$2.array(z$2.string()))).optional(),
 		conditionNames: optionalStringArray(),
+		extensionAlias: (z$2.record(z$2.string(), z$2.array(z$2.string()))).optional(),
 		exportsFields: (z$2.array(z$2.array(z$2.string()))).optional(),
 		extensions: optionalStringArray(),
 		mainFields: optionalStringArray(),
@@ -1333,9 +1594,16 @@ const inputOptionsSchema = z$2.strictObject({
 	onLog: ((z$2.function()).args(LogLevelSchema, RollupLogSchema, (z$2.function()).args(LogLevelWithErrorSchema, RollupLogWithStringSchema))).optional(),
 	onwarn: ((z$2.function()).args(RollupLogSchema, (z$2.function()).args(RollupLogWithStringSchema.or((z$2.function()).returns(RollupLogWithStringSchema))))).optional(),
 	moduleTypes: (moduleTypesSchema.describe("module types for customized extensions.")).optional(),
-	experimental: (z$2.strictObject({enableComposingJsPlugins: (z$2.boolean()).optional()})).optional(),
+	experimental: (z$2.strictObject({
+		enableComposingJsPlugins: (z$2.boolean()).optional(),
+		strictExecutionOrder: (z$2.boolean()).optional(),
+		disableLiveBindings: (z$2.boolean()).optional()
+	})).optional(),
 	define: ((z$2.record(z$2.string())).describe("define global variables")).optional(),
-	inject: (z$2.record((z$2.string()).or(z$2.tuple([z$2.string(), z$2.string()])))).optional()
+	inject: (z$2.record((z$2.string()).or(z$2.tuple([z$2.string(), z$2.string()])))).optional(),
+	profilerNames: (z$2.boolean()).optional(),
+	jsx: jsxOptionsSchema.optional(),
+	watch: (watchOptionsSchema.or(z$2.literal(false))).optional()
 });
 const inputCliOptionsSchema = (inputOptionsSchema.extend({
 	external: ((z$2.array(z$2.string())).describe("Comma-separated list of module ids to exclude from the bundle `<module-id>,...`")).optional(),
@@ -1347,16 +1615,19 @@ const inputCliOptionsSchema = (inputOptionsSchema.extend({
 	onwarn: true,
 	onLog: true,
 	resolve: true,
-	experimental: true
+	experimental: true,
+	profilerNames: true,
+	watch: true
 });
 
 //#endregion
 //#region src/options/output-options.ts
-const ModuleFormatSchema = (((((((z$1.literal("es")).or(z$1.literal("cjs"))).or(z$1.literal("esm"))).or(z$1.literal("module"))).or(z$1.literal("commonjs"))).or(z$1.literal("iife"))).describe(`output format of the generated bundle (supports ${underline("esm")}, cjs, and iife).`)).optional();
+const ModuleFormatSchema = ((((((((z$1.literal("es")).or(z$1.literal("cjs"))).or(z$1.literal("esm"))).or(z$1.literal("module"))).or(z$1.literal("commonjs"))).or(z$1.literal("iife"))).or(z$1.literal("umd"))).describe(`output format of the generated bundle (supports ${underline("esm")}, cjs, and iife).`)).optional();
 const addonFunctionSchema = ((z$1.function()).args(phantom())).returns((z$1.string()).or(z$1.promise(z$1.string())));
 const chunkFileNamesFunctionSchema = ((z$1.function()).args(phantom())).returns(z$1.string());
 const outputOptionsSchema = z$1.strictObject({
-	dir: ((z$1.string()).describe("Output directory, defaults to `dist`.")).optional(),
+	dir: ((z$1.string()).describe("Output directory, defaults to `dist` if `file` is not set.")).optional(),
+	file: ((z$1.string()).describe("Single output file")).optional(),
 	exports: (((((z$1.literal("auto")).or(z$1.literal("named"))).or(z$1.literal("default"))).or(z$1.literal("none"))).describe(`specify a export mode (${underline("auto")}, named, default, none)`)).optional(),
 	format: ModuleFormatSchema,
 	sourcemap: ((((z$1.boolean()).or(z$1.literal("inline"))).or(z$1.literal("hidden"))).describe(`generate sourcemap (\`-s inline\` for inline, or ${bold("pass the `-s` on the last argument if you want to generate `.map` file")}).`)).optional(),
@@ -1366,22 +1637,22 @@ const outputOptionsSchema = z$1.strictObject({
 	footer: ((z$1.string()).or(addonFunctionSchema)).optional(),
 	intro: ((z$1.string()).or(addonFunctionSchema)).optional(),
 	outro: ((z$1.string()).or(addonFunctionSchema)).optional(),
-	extend: ((z$1.boolean()).describe("extend global variable defined by name in IIFE or UMD formats")).optional(),
+	extend: ((z$1.boolean()).describe("extend global variable defined by name in IIFE / UMD formats")).optional(),
 	esModule: ((z$1.literal("if-default-prop")).or(z$1.boolean())).optional(),
 	entryFileNames: ((z$1.string()).or(chunkFileNamesFunctionSchema)).optional(),
 	chunkFileNames: ((z$1.string()).or(chunkFileNamesFunctionSchema)).optional(),
 	assetFileNames: (z$1.string()).optional(),
 	minify: ((z$1.boolean()).describe("minify the bundled file.")).optional(),
 	name: ((z$1.string()).describe("name for UMD / IIFE format outputs")).optional(),
-	globals: ((z$1.record(z$1.string())).describe("Comma-separated list of `module-id:global` pairs (`<module-id>:<global>,...`)")).optional(),
-	externalLiveBindings: (((z$1.boolean()).describe("use external live bindings")).default(true)).optional(),
+	globals: ((z$1.record(z$1.string())).describe("global variable of UMD / IIFE dependencies (syntax: `key=value`)")).optional(),
+	externalLiveBindings: (((z$1.boolean()).describe("external live bindings")).default(true)).optional(),
 	inlineDynamicImports: (((z$1.boolean()).describe("inline dynamic imports")).default(false)).optional(),
 	advancedChunks: (z$1.strictObject({
 		minSize: (z$1.number()).optional(),
 		minShareCount: (z$1.number()).optional(),
 		groups: (z$1.array(z$1.strictObject({
 			name: z$1.string(),
-			test: (z$1.string()).optional(),
+			test: ((z$1.string()).or(z$1.instanceof(RegExp))).optional(),
 			priority: (z$1.number()).optional(),
 			minSize: (z$1.number()).optional(),
 			minShareCount: (z$1.number()).optional()
@@ -1397,16 +1668,22 @@ const outputCliOptionsSchema = (outputOptionsSchema.extend({
 	intro: ((z$1.string()).describe(getAddonDescription("top", "inside"))).optional(),
 	outro: ((z$1.string()).describe(getAddonDescription("bottom", "inside"))).optional(),
 	esModule: ((z$1.boolean()).describe("always generate `__esModule` marks in non-ESM formats, defaults to `if-default-prop` (use `--no-esModule` to always disable).")).optional(),
-	sourcemapIgnoreList: (z$1.boolean()).optional(),
-	sourcemapPathTransform: (z$1.undefined()).optional()
-})).omit({sourcemapPathTransform: true});
+	advancedChunks: (z$1.strictObject({
+		minSize: ((z$1.number()).describe("minimum size of the chunk")).optional(),
+		minShareCount: ((z$1.number()).describe("minimum share count of the chunk")).optional()
+	})).optional()
+})).omit({
+	sourcemapPathTransform: true,
+	sourcemapIgnoreList: true
+});
 
 //#endregion
 //#region src/cli/arguments/schema.ts
 const cliOptionsSchema = ((z.strictObject({
-	config: (((z.string()).or(z.boolean())).describe("Path to the config file (default: `rollup.config.js`)")).optional(),
+	config: (((z.string()).or(z.boolean())).describe("Path to the config file (default: `rolldown.config.js`)")).optional(),
 	help: ((z.boolean()).describe("Show help")).optional(),
-	version: ((z.boolean()).describe("Show version number")).optional()
+	version: ((z.boolean()).describe("Show version number")).optional(),
+	watch: ((z.boolean()).describe("Watch files in bundle and rebuild on changes")).optional()
 })).merge(inputCliOptionsSchema)).merge(outputCliOptionsSchema);
 const schema = zodToJsonSchema(cliOptionsSchema);
 
@@ -1415,12 +1692,12 @@ const schema = zodToJsonSchema(cliOptionsSchema);
 const alias = {
 	config: {
 		abbreviation: "c",
-		description: "Use config file",
 		hint: "filename",
 		default: "rolldown.config.js"
 	},
 	help: {abbreviation: "h"},
 	version: {abbreviation: "v"},
+	watch: {abbreviation: "w"},
 	dir: {abbreviation: "d"},
 	external: {abbreviation: "e"},
 	format: {abbreviation: "f"},
@@ -1428,24 +1705,27 @@ const alias = {
 	globals: {abbreviation: "g"},
 	sourcemap: {
 		abbreviation: "s",
-		default: false
+		default: true
 	},
 	minify: {abbreviation: "m"},
 	platform: {abbreviation: "p"},
 	assetFileNames: {hint: "name"},
 	chunkFileNames: {hint: "name"},
 	entryFileNames: {hint: "name"},
-	externalLiveBindings: {default: true},
-	treeshake: {default: true},
+	externalLiveBindings: {
+		default: true,
+		reverse: true
+	},
+	treeshake: {
+		default: true,
+		reverse: true
+	},
 	moduleTypes: {hint: "types"}
 };
 
 //#endregion
 //#region src/cli/arguments/utils.ts
 function getSchemaType(schema$1) {
-	if ("type"in schema$1) {
-		return schema$1.type;
-	}
 	if ("anyOf"in schema$1) {
 		const types = schema$1.anyOf.map((s) => getSchemaType(s));
 		if (types.includes("object")) return "object";
@@ -1454,6 +1734,9 @@ else if (types.includes("string")) return "string";
 else if (types.includes("number")) return "number";
 else if (types.includes("boolean")) return "boolean";
 	}
+	if ("type"in schema$1) {
+		return schema$1.type;
+	}
 	return "object";
 }
 function flattenSchema(schema$1, base = {}, parent = "") {
@@ -1471,8 +1754,8 @@ function flattenSchema(schema$1, base = {}, parent = "") {
 	}
 	return base;
 }
-function setNestedProperty(obj, path, value) {
-	const keys = path.split(".");
+function setNestedProperty(obj, path$1, value) {
+	const keys = path$1.split(".");
 	let current = obj;
 	for (let i = 0; i < keys.length - 1; i++) {
 		if (!current[keys[i]]) {
@@ -1502,7 +1785,7 @@ function normalizeCliOptions(cliOptions, positionals) {
 	const options$1 = parsed.data ?? {};
 	if (!parsed.success) {
 		parsed.error.errors.forEach((error) => {
-			logger.error(`Invalid value for option: ${error.path.join(", ")}. ${error.message}. You can use \`rolldown -h\` to see the help.`);
+			logger.error(`Invalid value for option ${error.path.join(", ")}. You can use \`rolldown -h\` to see the help.`);
 		});
 		process.exit(1);
 	}
@@ -1510,12 +1793,13 @@ function normalizeCliOptions(cliOptions, positionals) {
 		input: {},
 		output: {},
 		help: options$1.help ?? false,
-		version: options$1.version ?? false
+		version: options$1.version ?? false,
+		watch: options$1.watch ?? false
 	};
 	if (typeof options$1.config === "string") {
 		result.config = options$1.config ? options$1.config : "rolldown.config.js";
 	}
-	const reservedKeys = ["help", "version", "config"];
+	const reservedKeys = ["help", "version", "config", "watch"];
 	const keysOfInput = (inputCliOptionsSchema.keyof())._def.values;
 	const keysOfOutput = (outputCliOptionsSchema.keyof())._def.values;
 	for (let [key, value] of Object.entries(options$1)) {
@@ -1550,8 +1834,15 @@ const options = Object.fromEntries((Object.entries(flattenedSchema)).map(([key,
 	if (config && config?.abbreviation) {
 		result.short = config?.abbreviation;
 	}
+	if (config && config.reverse) {
+		if (result.description.startsWith("enable")) {
+			result.description = result.description.replace("enable", "disable");
+		} else {
+			result.description = `disable ${result.description}`;
+		}
+	}
 	key = camelCaseToKebabCase(key);
-	return [typeof config?.default === "boolean" && config?.default ? `no-${key}` : key, result,];
+	return [config?.reverse ? `no-${key}` : key, result];
 }));
 function parseCliArguments() {
 	const { values: values, tokens: tokens, positionals: positionals } = parseArgs({
@@ -1574,12 +1865,21 @@ function parseCliArguments() {
 		option.name = kebabCaseToCamelCase(option.name);
 		let originalType = flattenedSchema[option.name];
 		if (!originalType) {
-			logger.warn(`Invalid option: ${option.rawName}. We will ignore this option.`);
-			return;
+			logger.error(`Invalid option: ${option.rawName}. We will ignore this option.`);
+			process.exit(1);
 		}
 		let type = getSchemaType(originalType);
-		if (type === "object" && typeof option.value === "string") {
-			const [key, value] = ((option.value?.split(",")).map((x) => x.split("=")))[0];
+		if (type === "string" && typeof option.value !== "string") {
+			let opt = option;
+			let defaultValue = (Object.getOwnPropertyDescriptor(alias, opt.name))?.value;
+			Object.defineProperty(values, opt.name, {
+				value: defaultValue.default ?? "",
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+		} else if (type === "object" && typeof option.value === "string") {
+			const [key, value] = ((option.value.split(",")).map((x) => x.split("=")))[0];
 			if (!values[option.name]) {
 				Object.defineProperty(values, option.name, {
 					value: {},
@@ -1665,15 +1965,8 @@ function showHelp() {
 		}
 		return a.localeCompare(b);
 	})).map(([option, { type: type, short: short, hint: hint, description: description$1 }]) => {
-		let optionStr = "  ";
-		const config = (Object.getOwnPropertyDescriptor(alias, option) ?? {}).value ?? {};
+		let optionStr = `  --${option} `;
 		option = camelCaseToKebabCase(option);
-		if (typeof config.default === "boolean" && type === "boolean" && config.default) {
-			optionStr += `--no-${option}`;
-			description$1 = `Do not ${description$1}`;
-		} else {
-			optionStr += `--${option} `;
-		}
 		if (short) {
 			optionStr += `-${short}, `;
 		}