rolldown 0.12.2 → 0.13.0-snapshot-514fd69-20240905003110

package/dist/esm/cli.mjs

@@ -1,535 +1,36 @@
 import __node_module__ from 'node:module';
 const require = __node_module__.createRequire(import.meta.url)
-import { __commonJSMin, __export, __toESM, arraify } from "../shared/utils_index-_DFpKlu1.mjs";
-import { rolldown } from "../shared/rolldown-kYz4BvAA.mjs";
-import { colors, consola, createConsola } from "../shared/consola.36c0034f-jtHhMkSX.mjs";
-import { pathToFileURL } from "node:url";
+import { LogLevelOptionSchema, LogLevelSchema, LogLevelWithErrorSchema, RollupLogSchema, RollupLogWithStringSchema, __export, arraify } from "../shared/plugin-context-data-AMG1kfMv.mjs";
+import { rolldown } from "../shared/rolldown-NGdGAW73.mjs";
+import { description, version } from "../shared/package-3VR4tEG7.mjs";
+import { createConsola } from "../shared/consola.36c0034f-m5cABVv4.mjs";
 import { default as nodePath } 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 "node:util";
-import * as tty from "node:tty";
 import { performance } from "node:perf_hooks";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+import * as tty from "node:tty";
 
-//#region ../../node_modules/.pnpm/mri@1.2.0/node_modules/mri/lib/index.js
-var require_lib_index = __commonJSMin((exports, module) => {
-	function toArr$1(any) {
-		return any == null ? [] : Array.isArray(any) ? any : [any];
-	}
-	function toVal$1(out, key, val, opts) {
-		var x, old = out[key], nxt = (!!~opts.string.indexOf(key) ? (val == null || 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 == null ? nxt : (Array.isArray(old) ? old.concat(nxt) : [old, nxt]);
-	}
-	module.exports = function(args, opts) {
-		args = args || [];
-		opts = opts || {};
-		var k, arr, arg, name, val, out = {_: []};
-		var i = 0, j = 0, idx = 0, 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$1(opts.string);
-		opts.boolean = toArr$1(opts.boolean);
-		if (alibi) {
-			for (k in opts.alias) {
-				arr = opts.alias[k] = toArr$1(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]);
-		}
-		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]);
-					}
-				}
-			}
-		}
-		const keys = strict ? Object.keys(opts.alias) : [];
-		for (i = 0; i < len; i++) {
-			arg = args[i];
-			if (arg === '--') {
-				out._ = out._.concat(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.substring(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.substring(++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$1(out, name, (idx + 1 < arr.length) || val, opts);
-				}
-			}
-		}
-		if (defaults) {
-			for (k in opts.default) {
-				if (out[k] === void 0) {
-					out[k] = opts.default[k];
-				}
-			}
-		}
-		if (alibi) {
-			for (k in out) {
-				arr = opts.alias[k] || [];
-				while (arr.length > 0) {
-					out[arr.shift()] = out[k];
-				}
-			}
-		}
-		return out;
-	};
-});
-
-//#endregion
-//#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;
-}
-class CLIError extends Error {
-	constructor(message, code) {
-		super(message);
-		this.code = code;
-		this.name = 'CLIError';
-	}
-}
-const NUMBER_CHAR_RE = /\d/;
-const STR_SPLITTERS = ['-', '_', '/', '.'];
-function isUppercase(char = '') {
-	if (NUMBER_CHAR_RE.test(char)) {
-		return void 0;
-	}
-	return char !== char.toLowerCase();
-}
-function splitByCase(str, separators) {
-	const splitters = separators ?? STR_SPLITTERS;
-	const parts = [];
-	if (!str || typeof str !== 'string') {
-		return parts;
-	}
-	let buff = '';
-	let previousUpper;
-	let previousSplitter;
-	for (const char of str) {
-		const isSplitter = splitters.includes(char);
-		if (isSplitter === true) {
-			parts.push(buff);
-			buff = '';
-			previousUpper = void 0;
-			continue;
-		}
-		const isUpper = isUppercase(char);
-		if (previousSplitter === false) {
-			if (previousUpper === false && isUpper === true) {
-				parts.push(buff);
-				buff = char;
-				previousUpper = isUpper;
-				continue;
-			}
-			if (previousUpper === true && isUpper === false && buff.length > 1) {
-				const lastChar = buff.at(-1);
-				parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
-				buff = lastChar + char;
-				previousUpper = isUpper;
-				continue;
-			}
-		}
-		buff += char;
-		previousUpper = isUpper;
-		previousSplitter = isSplitter;
-	}
-	parts.push(buff);
-	return parts;
-}
-function upperFirst(str) {
-	return str ? str[0].toUpperCase() + str.slice(1) : '';
-}
-function lowerFirst(str) {
-	return str ? str[0].toLowerCase() + str.slice(1) : '';
-}
-function pascalCase(str, opts) {
-	return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => upperFirst(opts?.normalize ? p.toLowerCase() : p)).join('') : '';
-}
-function camelCase(str, opts) {
-	return lowerFirst(pascalCase(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];
-}
-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 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]);
-		}
-	}
-	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]);
-				}
-			}
-		}
-	}
-	const keys = strict ? Object.keys(opts.alias) : [];
-	for (i = 0; i < len; i++) {
-		arg = args[i];
-		if (arg === '--') {
-			out._ = out._.concat(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 (defaults) {
-		for (k in opts.default) {
-			if (out[k] === void 0) {
-				out[k] = opts.default[k];
-			}
-		}
-	}
-	if (alibi) {
-		for (k in out) {
-			arr = opts.alias[k] || [];
-			while (arr.length > 0) {
-				out[arr.shift()] = out[k];
-			}
-		}
-	}
-	return out;
-}
-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);
-		} 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 parsed = parseRawArgs(rawArgs, parseOptions);
-	const [ ...positionalArguments] = parsed._;
-	const parsedArgsProxy = new Proxy(parsed, {get(target, prop) {
-		return target[prop] ?? target[camelCase(prop)] ?? target[kebabCase(prop)];
-	}});
-	for (const [, arg] of args.entries()) {
-		if (arg.type === 'positional') {
-			const nextPositionalArgument = positionalArguments.shift();
-			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.required && parsedArgsProxy[arg.name] === void 0) {
-			throw new CLIError(`Missing required argument: --${arg.name}`, 'EARG');
-		}
-	}
-	return parsedArgsProxy;
-}
-function resolveArgs(argsDef) {
-	const args = [];
-	for (const [name, argDef] of Object.entries(argsDef || {})) {
-		args.push({
-			...argDef,
-			name,
-			alias: toArray(argDef.alias)
-		});
-	}
-	return args;
-}
-function defineCommand(def) {
-	return def;
-}
-async function runCommand(cmd, opts) {
-	const cmdArgs = await resolveValue(cmd.args || {});
-	const parsedArgs = parseArgs$1(opts.rawArgs, cmdArgs);
-	const context = {
-		rawArgs: opts.rawArgs,
-		args: parsedArgs,
-		data: opts.data,
-		cmd
-	};
-	if (typeof cmd.setup === 'function') {
-		await cmd.setup(context);
-	}
-	let result;
-	try {
-		const subCommands = await resolveValue(cmd.subCommands);
-		if (subCommands && Object.keys(subCommands).length > 0) {
-			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');
-				}
-				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');
-			}
-		}
-		if (typeof cmd.run === 'function') {
-			result = await cmd.run(context);
-		}
-	} finally {
-		if (typeof cmd.cleanup === 'function') {
-			await cmd.cleanup(context);
-		}
-	}
-	return {result};
-}
-async function resolveSubCommand(cmd, rawArgs, parent) {
-	const subCommands = await resolveValue(cmd.subCommands);
-	if (subCommands && Object.keys(subCommands).length > 0) {
-		const subCommandArgIndex = rawArgs.findIndex((arg) => !arg.startsWith('-'));
-		const subCommandName = rawArgs[subCommandArgIndex];
-		const subCommand = await resolveValue(subCommands[subCommandName]);
-		if (subCommand) {
-			return resolveSubCommand(subCommand, rawArgs.slice(subCommandArgIndex + 1), cmd);
-		}
-	}
-	return [cmd, parent];
-}
-async function showUsage(cmd, parent) {
-	try {
-		consola.log(await renderUsage(cmd, parent) + '\n');
-	} catch (error) {
-		consola.error(error);
-	}
-}
-async function renderUsage(cmd, parent) {
-	const cmdMeta = await resolveValue(cmd.meta || {});
-	const cmdArgs = resolveArgs(await resolveValue(cmd.args || {}));
-	const parentMeta = await resolveValue(parent?.meta || {});
-	const commandName = `${parentMeta.name ? `${parentMeta.name} ` : ''}` + (cmdMeta.name || process.argv[1]);
-	const argLines = [];
-	const posLines = [];
-	const commandsLines = [];
-	const usageLine = [];
-	for (const arg of cmdArgs) {
-		if (arg.type === 'positional') {
-			const name = arg.name.toUpperCase();
-			const isRequired = arg.required !== false && arg.default === void 0;
-			const defaultHint = arg.default ? `="${arg.default}"` : '';
-			posLines.push(['`' + 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 || '']);
-			if (isRequired) {
-				usageLine.push(argStr);
-			}
-		}
-	}
-	if (cmd.subCommands) {
-		const commandNames = [];
-		const subCommands = await resolveValue(cmd.subCommands);
-		for (const [name, sub] of Object.entries(subCommands)) {
-			const subCmd = await resolveValue(sub);
-			const meta = await resolveValue(subCmd?.meta);
-			commandsLines.push([`\`${name}\``, meta?.description || '']);
-			commandNames.push(name);
-		}
-		usageLine.push(commandNames.join('|'));
-	}
-	const usageLines = [];
-	const version$1 = cmdMeta.version || parentMeta.version;
-	usageLines.push(colors.gray(`${cmdMeta.description} (${commandName + (version$1 ? ` v${version$1}` : '')})`), '');
-	const hasOptions = argLines.length > 0 || posLines.length > 0;
-	usageLines.push(`${colors.underline(colors.bold('USAGE'))} \`${commandName}${hasOptions ? ' [OPTIONS]' : ''} ${usageLine.join(' ')}\``, '');
-	if (posLines.length > 0) {
-		usageLines.push(colors.underline(colors.bold('ARGUMENTS')), '');
-		usageLines.push(formatLineColumns(posLines, '  '));
-		usageLines.push('');
-	}
-	if (argLines.length > 0) {
-		usageLines.push(colors.underline(colors.bold('OPTIONS')), '');
-		usageLines.push(formatLineColumns(argLines, '  '));
-		usageLines.push('');
-	}
-	if (commandsLines.length > 0) {
-		usageLines.push(colors.underline(colors.bold('COMMANDS')), '');
-		usageLines.push(formatLineColumns(commandsLines, '  '));
-		usageLines.push('', `Use \`${commandName} <command> --help\` for more information about a command.`);
-	}
-	return usageLines.filter((l) => typeof l === 'string').join('\n');
-}
-async function runMain(cmd, opts = {}) {
-	const rawArgs = opts.rawArgs || process.argv.slice(2);
-	const showUsage$1 = opts.showUsage || showUsage;
-	try {
-		if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
-			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
-			process.exit(0);
-		} 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.log(meta.version);
-		} else {
-			await runCommand(cmd, {rawArgs});
-		}
-	} catch (error) {
-		const isCLIError = error instanceof CLIError;
-		if (!isCLIError) {
-			consola.error(error, '\n');
-		}
-		if (isCLIError) {
-			await showUsage$1(...await resolveSubCommand(cmd, rawArgs));
-		}
-		consola.error(error.message);
-		process.exit(1);
+//#region src/cli/utils.ts
+const logger = process.env.ROLLDOWN_TEST ? createTestingLogger() : createConsola({formatOptions: {date: false}});
+function createTestingLogger() {
+	const types = ["silent", "fatal", "error", "warn", "log", "info", "success", "fail", "ready", "start", "box", "debug", "trace", "verbose",];
+	const ret = Object.create(null);
+	for (const type of types) {
+		ret[type] = console.log;
 	}
+	return ret;
 }
-
-//#endregion
-//#region src/cli/utils.ts
-const logger = createConsola({formatOptions: {date: false}});
 async function ensureConfig(configPath) {
 	if (!isSupportedFormat(configPath)) {
-		throw new Error(`Unsupported config format. Expected: \`${SUPPORTED_CONFIG_FORMATS.join(',')}\` but got \`${nodePath.extname(configPath)}\``);
+		throw new Error(`Unsupported config format. Expected: \`${SUPPORTED_CONFIG_FORMATS.join(",")}\` but got \`${nodePath.extname(configPath)}\``);
 	}
-	const fileUrl = pathToFileURL(configPath).toString();
+	const fileUrl = (pathToFileURL(configPath)).toString();
 	const configExports = await import(fileUrl);
 	return configExports.default;
 }
-const SUPPORTED_CONFIG_FORMATS = ['.js', '.mjs', '.cjs'];
+const SUPPORTED_CONFIG_FORMATS = [".js", ".mjs", ".cjs"];
 function isSupportedFormat(configPath) {
 	const ext = nodePath.extname(configPath);
 	return SUPPORTED_CONFIG_FORMATS.includes(ext);
@@ -537,22 +38,22 @@ function isSupportedFormat(configPath) {
 
 //#endregion
 //#region ../../node_modules/.pnpm/colorette@2.0.20/node_modules/colorette/index.js
-const { env: env$1 = {}, argv = [], platform = '' } = typeof process === 'undefined' ? {} : process;
-const isDisabled = 'NO_COLOR'in env$1 || argv.includes('--no-color');
-const isForced = 'FORCE_COLOR'in env$1 || argv.includes('--color');
-const isWindows = platform === 'win32';
-const isDumbTerminal = env$1.TERM === 'dumb';
+const { env: env$1 = {}, argv: argv = [], platform: platform = "" } = typeof process === "undefined" ? {} : process;
+const isDisabled = "NO_COLOR"in env$1 || argv.includes("--no-color");
+const isForced = "FORCE_COLOR"in env$1 || argv.includes("--color");
+const isWindows = platform === "win32";
+const isDumbTerminal = env$1.TERM === "dumb";
 const isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env$1.TERM && !isDumbTerminal;
-const isCI = 'CI'in env$1 && ('GITHUB_ACTIONS'in env$1 || 'GITLAB_CI'in env$1 || 'CIRCLECI'in env$1);
-const isColorSupported = !isDisabled && (isForced || (isWindows && !isDumbTerminal) || isCompatibleTerminal || isCI);
+const isCI = "CI"in env$1 && ("GITHUB_ACTIONS"in env$1 || "GITLAB_CI"in env$1 || "CIRCLECI"in env$1);
+const isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
 const replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
 const clearBleed = (index, string, open, close, replace) => index < 0 ? open + string + close : open + replaceClose(index, string, close, replace) + close;
-const filterEmpty = (open, close, replace = open, at = open.length + 1) => (string) => string || !(string === '' || string === undefined) ? clearBleed(('' + string).indexOf(close, at), string, open, close, replace) : '';
+const filterEmpty = (open, close, replace = open, at = open.length + 1) => (string) => string || !(string === "" || string === undefined) ? clearBleed(("" + string).indexOf(close, at), string, open, close, replace) : "";
 const init = (open, close, replace) => filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
-const colors$1 = {
+const colors = {
 	reset: init(0, 0),
-	bold: init(1, 22, '\x1B[22m\x1B[1m'),
-	dim: init(2, 22, '\x1B[22m\x1B[2m'),
+	bold: init(1, 22, "\x1B[22m\x1B[1m"),
+	dim: init(2, 22, "\x1B[22m\x1B[2m"),
 	italic: init(3, 23),
 	underline: init(4, 24),
 	inverse: init(7, 27),
@@ -592,11 +93,11 @@ const colors$1 = {
 	bgCyanBright: init(106, 49),
 	bgWhiteBright: init(107, 49)
 };
-const createColors = ({ useColor = isColorSupported } = {}) => useColor ? colors$1 : Object.keys(colors$1).reduce((colors$2, key) => ({
-	...colors$2,
+const createColors = ({ useColor: useColor = isColorSupported } = {}) => useColor ? colors : (Object.keys(colors)).reduce((colors$1, key) => ({
+	...colors$1,
 	[key]: String
 }), {});
-const { reset, bold: bold$1, dim: dim$1, italic, underline: underline$1, inverse, hidden, strikethrough, black, red: red$1, green: green$1, yellow: yellow$1, blue, magenta, cyan: cyan$1, white, gray: gray$1, bgBlack, bgRed, bgGreen, bgYellow, bgBlue, bgMagenta, bgCyan, bgWhite, blackBright, redBright, greenBright, yellowBright, blueBright, magentaBright, cyanBright, whiteBright, bgBlackBright, bgRedBright, bgGreenBright, bgYellowBright, bgBlueBright, bgMagentaBright, bgCyanBright, bgWhiteBright } = createColors();
+const { reset: reset, bold: bold$1, dim: dim$1, italic: italic, underline: underline$1, inverse: inverse, hidden: hidden, strikethrough: strikethrough, black: black, red: red$1, green: green$1, yellow: yellow$1, blue: blue, magenta: magenta, cyan: cyan$1, white: white, gray: gray$1, bgBlack: bgBlack, bgRed: bgRed, bgGreen: bgGreen, bgYellow: bgYellow, bgBlue: bgBlue, bgMagenta: bgMagenta, bgCyan: bgCyan, bgWhite: bgWhite, blackBright: blackBright, redBright: redBright, greenBright: greenBright, yellowBright: yellowBright, blueBright: blueBright, magentaBright: magentaBright, cyanBright: cyanBright, whiteBright: whiteBright, bgBlackBright: bgBlackBright, bgRedBright: bgRedBright, bgGreenBright: bgGreenBright, bgYellowBright: bgYellowBright, bgBlueBright: bgBlueBright, bgMagentaBright: bgMagentaBright, bgCyanBright: bgCyanBright, bgWhiteBright: bgWhiteBright } = createColors();
 
 //#endregion
 //#region src/cli/colors.ts
@@ -611,11 +112,11 @@ __export(colors_ns, {
 	underline: () => underline,
 	yellow: () => yellow
 });
-const { bold, cyan, dim, gray, green, red, underline, yellow } = createColors({useColor: env.FORCE_COLOR !== '0' && !env.NO_COLOR});
+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 src/cli/commands/bundle.ts
-async function bundle(configPath) {
+async function bundleWithConfig(configPath, cliOptions) {
 	const config = await ensureConfig(configPath);
 	if (!config) {
 		logger.error(`No configuration found at ${config}`);
@@ -623,28 +124,53 @@ async function bundle(configPath) {
 	}
 	const configList = arraify(config);
 	for (const config$1 of configList) {
-		await bundleInner(config$1);
+		await bundleInner(config$1, cliOptions);
 	}
 }
-async function bundleInner(options) {
+async function bundleWithCliOptions(cliOptions) {
+	if (cliOptions.output.dir) {
+		await bundleInner({}, cliOptions);
+	} else {
+		const build = await rolldown(cliOptions.input);
+		const { output: output } = await build.generate(cliOptions.output);
+		if (output.length > 1) {
+			logger.error("Multiple chunks are not supported to display in stdout");
+			process.exit(1);
+		} else if (output.length === 0) {
+			logger.error("No output generated");
+			process.exit(1);
+		} else {
+			logger.log(output[0].code);
+		}
+	}
+}
+async function bundleInner(options$1, cliOptions) {
 	const startTime = performance.now();
-	const build = await rolldown(options);
-	const bundleOutput = await build.write(options?.output);
+	const build = await rolldown({
+		...options$1,
+		...cliOptions.input
+	});
+	const bundleOutput = await build.write({
+		...options$1?.output,
+		...cliOptions.output
+	});
 	const endTime = performance.now();
 	printBundleOutputPretty(bundleOutput);
 	logger.log(``);
-	logger.success(`Finished in ${bold((endTime - startTime).toFixed(2))} ms`);
+	const duration = endTime - startTime;
+	const spent = duration < 1000 ? `${duration.toFixed(2)} ms` : `${(duration / 1000).toFixed(2)} s`;
+	logger.success(`Finished in ${bold(spent)}`);
 }
 function printBundleOutputPretty(output) {
 	const outputEntries = collectOutputEntries(output.output);
 	const outputLayoutSizes = collectOutputLayoutAdjustmentSizes(outputEntries);
-	printOutputEntries(outputEntries, outputLayoutSizes, '<DIR>');
+	printOutputEntries(outputEntries, outputLayoutSizes, "<DIR>");
 }
 function collectOutputEntries(output) {
 	return output.map((chunk) => ({
 		type: chunk.type,
 		fileName: chunk.fileName,
-		size: chunk.type === 'chunk' ? chunk.code.length : chunk.source.length
+		size: chunk.type === "chunk" ? chunk.code.length : chunk.source.length
 	}));
 }
 function collectOutputLayoutAdjustmentSizes(entries) {
@@ -658,14 +184,14 @@ function collectOutputLayoutAdjustmentSizes(entries) {
 			biggestSize = entry.size;
 		}
 	}
-	const sizePad = displaySize(biggestSize).length;
+	const sizePad = (displaySize(biggestSize)).length;
 	return {
 		longest,
 		biggestSize,
 		sizePad
 	};
 }
-const numberFormatter = new Intl.NumberFormat('en', {
+const numberFormatter = new Intl.NumberFormat("en", {
 	maximumFractionDigits: 2,
 	minimumFractionDigits: 2
 });
@@ -673,11 +199,11 @@ function displaySize(bytes) {
 	return `${numberFormatter.format(bytes / 1000)} kB`;
 }
 const CHUNK_GROUPS = [{
-	type: 'asset',
-	color: 'green'
+	type: "asset",
+	color: "green"
 }, {
-	type: 'chunk',
-	color: 'cyan'
+	type: "chunk",
+	color: "cyan"
 },];
 function printOutputEntries(entries, sizeAdjustment, distPath) {
 	for (const group of CHUNK_GROUPS) {
@@ -685,65 +211,1505 @@ function printOutputEntries(entries, sizeAdjustment, distPath) {
 		if (!filtered.length) {
 			continue;
 		}
-		for (const entry of filtered.sort((a, z) => a.size - z.size)) {
+		for (const entry of filtered.sort((a, z$4) => a.size - z$4.size)) {
 			let log = dim(withTrailingSlash(distPath));
 			log += colors_ns[group.color](entry.fileName.padEnd(sizeAdjustment.longest + 2));
 			log += dim(entry.type);
-			log += dim(` │ size: ${displaySize(entry.size).padStart(sizeAdjustment.sizePad)}`);
+			log += dim(` │ size: ${(displaySize(entry.size)).padStart(sizeAdjustment.sizePad)}`);
 			logger.log(log);
 		}
 	}
 }
 function withTrailingSlash(path) {
-	if (path[path.length - 1] !== '/') {
+	if (path[path.length - 1] !== "/") {
 		return `${path}/`;
 	}
 	return path;
 }
 
 //#endregion
-//#region package.json
-const version = '0.12.2';
-const description = 'Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.';
+//#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
+const ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
+const defaultOptions = {
+	name: undefined,
+	$refStrategy: "root",
+	basePath: ["#"],
+	effectStrategy: "input",
+	pipeStrategy: "all",
+	dateStrategy: "format:date-time",
+	mapStrategy: "entries",
+	removeAdditionalStrategy: "passthrough",
+	definitionPath: "definitions",
+	target: "jsonSchema7",
+	strictUnions: false,
+	definitions: {},
+	errorMessages: false,
+	markdownDescription: false,
+	patternStrategy: "escape",
+	applyRegexFlags: false,
+	emailStrategy: "format:email",
+	base64Strategy: "contentEncoding:base64",
+	nameStrategy: "ref"
+};
+const getDefaultOptions = (options$1) => typeof options$1 === "string" ? {
+	...defaultOptions,
+	name: options$1
+} : {
+	...defaultOptions,
+	...options$1
+};
 
 //#endregion
-//#region src/cli/constants.ts
-const DEFAULT_CONFIG_FILENAME = 'rolldown.config.js';
+//#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
+const getRefs = (options$1) => {
+	const _options = getDefaultOptions(options$1);
+	const currentPath = _options.name !== undefined ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+	return {
+		..._options,
+		currentPath: currentPath,
+		propertyPath: undefined,
+		seen: new Map((Object.entries(_options.definitions)).map(([name, def]) => [def._def, {
+			def: def._def,
+			path: [..._options.basePath, _options.definitionPath, name],
+			jsonSchema: undefined
+		},]))
+	};
+};
 
 //#endregion
-//#region src/cli/index.ts
-var import_lib_index = __toESM(require_lib_index());
-const main = defineCommand({
-	meta: {
-		name: 'rolldown',
-		version,
-		description
+//#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
+function addErrorMessage(res, key, errorMessage, refs) {
+	if (!refs?.errorMessages) return;
+	if (errorMessage) {
+		res.errorMessage = {
+			...res.errorMessage,
+			[key]: errorMessage
+		};
+	}
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+	res[key] = value;
+	addErrorMessage(res, key, 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
+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
+function parseArrayDef(def, refs) {
+	const res = {type: "array"};
+	if (def.type?._def?.typeName !== ZodFirstPartyTypeKind$2.ZodAny) {
+		res.items = parseDef(def.type._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "items"]
+		});
+	}
+	if (def.minLength) {
+		setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+	}
+	if (def.maxLength) {
+		setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+	}
+	if (def.exactLength) {
+		setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+		setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+	}
+	return res;
+}
+
+//#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
+function parseBigintDef(def, refs) {
+	const res = {
+		type: "integer",
+		format: "int64"
+	};
+	if (!def.checks) return res;
+	for (const check of def.checks) {
+		switch (check.kind) {
+			case "min":
+				if (refs.target === "jsonSchema7") {
+					if (check.inclusive) {
+						setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+					} else {
+						setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+					}
+				} else {
+					if (!check.inclusive) {
+						res.exclusiveMinimum = true;
+					}
+					setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+				}
+				break;
+			case "max":
+				if (refs.target === "jsonSchema7") {
+					if (check.inclusive) {
+						setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+					} else {
+						setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+					}
+				} else {
+					if (!check.inclusive) {
+						res.exclusiveMaximum = true;
+					}
+					setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+				}
+				break;
+			case "multipleOf":
+				setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+				break;
+		}
+	}
+	return res;
+}
+
+//#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
+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
+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
+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
+function parseDateDef(def, refs, overrideDateStrategy) {
+	const strategy = overrideDateStrategy ?? refs.dateStrategy;
+	if (Array.isArray(strategy)) {
+		return {anyOf: strategy.map((item, i) => parseDateDef(def, refs, item))};
+	}
+	switch (strategy) {
+		case "string":
+		case "format:date-time": return {
+			type: "string",
+			format: "date-time"
+		};
+		case "format:date": return {
+			type: "string",
+			format: "date"
+		};
+		case "integer": return integerDateParser(def, refs);
+	}
+}
+const integerDateParser = (def, refs) => {
+	const res = {
+		type: "integer",
+		format: "unix-time"
+	};
+	if (refs.target === "openApi3") {
+		return res;
+	}
+	for (const check of def.checks) {
+		switch (check.kind) {
+			case "min":
+				setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+				break;
+			case "max":
+				setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+				break;
+		}
+	}
+	return res;
+};
+
+//#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
+function parseDefaultDef(_def, refs) {
+	return {
+		...parseDef(_def.innerType._def, refs),
+		default: _def.defaultValue()
+	};
+}
+
+//#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
+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
+function parseEnumDef(def) {
+	return {
+		type: "string",
+		enum: def.values
+	};
+}
+
+//#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
+const isJsonSchema7AllOfType = (type) => {
+	if ("type"in type && type.type === "string") return false;
+	return "allOf"in type;
+};
+function parseIntersectionDef(def, refs) {
+	const allOf = [parseDef(def.left._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "allOf", "0"]
+	}), parseDef(def.right._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "allOf", "1"]
+	}),].filter((x) => !!x);
+	let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? {unevaluatedProperties: false} : undefined;
+	const mergedAllOf = [];
+	allOf.forEach((schema$1) => {
+		if (isJsonSchema7AllOfType(schema$1)) {
+			mergedAllOf.push(...schema$1.allOf);
+			if (schema$1.unevaluatedProperties === undefined) {
+				unevaluatedProperties = undefined;
+			}
+		} else {
+			let nestedSchema = schema$1;
+			if ("additionalProperties"in schema$1 && schema$1.additionalProperties === false) {
+				const { additionalProperties: additionalProperties,...rest } = schema$1;
+				nestedSchema = rest;
+			} else {
+				unevaluatedProperties = undefined;
+			}
+			mergedAllOf.push(nestedSchema);
+		}
+	});
+	return mergedAllOf.length ? {
+		allOf: mergedAllOf,
+		...unevaluatedProperties
+	} : undefined;
+}
+
+//#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
+function parseLiteralDef(def, refs) {
+	const parsedType = typeof def.value;
+	if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
+		return {type: Array.isArray(def.value) ? "array" : "object"};
+	}
+	if (refs.target === "openApi3") {
+		return {
+			type: parsedType === "bigint" ? "integer" : parsedType,
+			enum: [def.value]
+		};
+	}
+	return {
+		type: parsedType === "bigint" ? "integer" : parsedType,
+		const: def.value
+	};
+}
+
+//#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
+let emojiRegex;
+const zodPatterns = {
+	cuid: /^[cC][^\s-]{8,}$/,
+	cuid2: /^[0-9a-z]+$/,
+	ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
+	email: /^(?!\.)(?!.*\.\.)([a-zA-Z0-9_'+\-\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\-]*\.)+[a-zA-Z]{2,}$/,
+	emoji: () => {
+		if (emojiRegex === undefined) {
+			emojiRegex = RegExp("^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$", "u");
+		}
+		return emojiRegex;
 	},
-	args: {
-		config: {
-			type: 'string',
-			alias: 'c',
-			description: 'Use this config file (if argument is used but value is unspecified, defaults to `rolldown.config.js`)'
-		},
-		help: {
-			type: 'boolean',
-			alias: 'h',
-			description: 'Show this help message'
+	uuid: /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/,
+	ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/,
+	ipv6: /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/,
+	base64: /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/,
+	nanoid: /^[a-zA-Z0-9_-]{21}$/
+};
+function parseStringDef(def, refs) {
+	const res = {type: "string"};
+	function processPattern(value) {
+		return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(value) : value;
+	}
+	if (def.checks) {
+		for (const check of def.checks) {
+			switch (check.kind) {
+				case "min":
+					setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+					break;
+				case "max":
+					setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+					break;
+				case "email":
+					switch (refs.emailStrategy) {
+						case "format:email":
+							addFormat(res, "email", check.message, refs);
+							break;
+						case "format:idn-email":
+							addFormat(res, "idn-email", check.message, refs);
+							break;
+						case "pattern:zod":
+							addPattern(res, zodPatterns.email, check.message, refs);
+							break;
+					}
+					break;
+				case "url":
+					addFormat(res, "uri", check.message, refs);
+					break;
+				case "uuid":
+					addFormat(res, "uuid", check.message, refs);
+					break;
+				case "regex":
+					addPattern(res, check.regex, check.message, refs);
+					break;
+				case "cuid":
+					addPattern(res, zodPatterns.cuid, check.message, refs);
+					break;
+				case "cuid2":
+					addPattern(res, zodPatterns.cuid2, check.message, refs);
+					break;
+				case "startsWith":
+					addPattern(res, RegExp(`^${processPattern(check.value)}`), check.message, refs);
+					break;
+				case "endsWith":
+					addPattern(res, RegExp(`${processPattern(check.value)}$`), check.message, refs);
+					break;
+				case "datetime":
+					addFormat(res, "date-time", check.message, refs);
+					break;
+				case "date":
+					addFormat(res, "date", check.message, refs);
+					break;
+				case "time":
+					addFormat(res, "time", check.message, refs);
+					break;
+				case "duration":
+					addFormat(res, "duration", check.message, refs);
+					break;
+				case "length":
+					setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
+					setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
+					break;
+				case "includes": {
+					addPattern(res, RegExp(processPattern(check.value)), check.message, refs);
+					break;
+				}
+				case "ip": {
+					if (check.version !== "v6") {
+						addFormat(res, "ipv4", check.message, refs);
+					}
+					if (check.version !== "v4") {
+						addFormat(res, "ipv6", check.message, refs);
+					}
+					break;
+				}
+				case "emoji":
+					addPattern(res, zodPatterns.emoji, check.message, refs);
+					break;
+				case "ulid": {
+					addPattern(res, zodPatterns.ulid, check.message, refs);
+					break;
+				}
+				case "base64": {
+					switch (refs.base64Strategy) {
+						case "format:binary": {
+							addFormat(res, "binary", check.message, refs);
+							break;
+						}
+						case "contentEncoding:base64": {
+							setResponseValueAndErrors(res, "contentEncoding", "base64", check.message, refs);
+							break;
+						}
+						case "pattern:zod": {
+							addPattern(res, zodPatterns.base64, check.message, refs);
+							break;
+						}
+					}
+					break;
+				}
+				case "nanoid": {
+					addPattern(res, zodPatterns.nanoid, check.message, refs);
+				}
+				case "toLowerCase":
+				case "toUpperCase":
+				case "trim": break;
+				default: ((_) => {})(check);
+			}
+		}
+	}
+	return res;
+}
+const escapeNonAlphaNumeric = (value) => ((Array.from(value)).map((c) => /[a-zA-Z0-9]/.test(c) ? c : `\\${c}`)).join("");
+const addFormat = (schema$1, value, message, refs) => {
+	if (schema$1.format || schema$1.anyOf?.some((x) => x.format)) {
+		if (!schema$1.anyOf) {
+			schema$1.anyOf = [];
+		}
+		if (schema$1.format) {
+			schema$1.anyOf.push({
+				format: schema$1.format,
+				...schema$1.errorMessage && refs.errorMessages && {errorMessage: {format: schema$1.errorMessage.format}}
+			});
+			delete schema$1.format;
+			if (schema$1.errorMessage) {
+				delete schema$1.errorMessage.format;
+				if ((Object.keys(schema$1.errorMessage)).length === 0) {
+					delete schema$1.errorMessage;
+				}
+			}
+		}
+		schema$1.anyOf.push({
+			format: value,
+			...message && refs.errorMessages && {errorMessage: {format: message}}
+		});
+	} else {
+		setResponseValueAndErrors(schema$1, "format", value, message, refs);
+	}
+};
+const addPattern = (schema$1, regex, message, refs) => {
+	if (schema$1.pattern || schema$1.allOf?.some((x) => x.pattern)) {
+		if (!schema$1.allOf) {
+			schema$1.allOf = [];
+		}
+		if (schema$1.pattern) {
+			schema$1.allOf.push({
+				pattern: schema$1.pattern,
+				...schema$1.errorMessage && refs.errorMessages && {errorMessage: {pattern: schema$1.errorMessage.pattern}}
+			});
+			delete schema$1.pattern;
+			if (schema$1.errorMessage) {
+				delete schema$1.errorMessage.pattern;
+				if ((Object.keys(schema$1.errorMessage)).length === 0) {
+					delete schema$1.errorMessage;
+				}
+			}
+		}
+		schema$1.allOf.push({
+			pattern: processRegExp(regex, refs),
+			...message && refs.errorMessages && {errorMessage: {pattern: message}}
+		});
+	} else {
+		setResponseValueAndErrors(schema$1, "pattern", processRegExp(regex, refs), message, refs);
+	}
+};
+const processRegExp = (regexOrFunction, refs) => {
+	const regex = typeof regexOrFunction === "function" ? regexOrFunction() : regexOrFunction;
+	if (!refs.applyRegexFlags || !regex.flags) return regex.source;
+	const flags = {
+		i: regex.flags.includes("i"),
+		m: regex.flags.includes("m"),
+		s: regex.flags.includes("s")
+	};
+	const source = flags.i ? regex.source.toLowerCase() : regex.source;
+	let pattern = "";
+	let isEscaped = false;
+	let inCharGroup = false;
+	let inCharRange = false;
+	for (let i = 0; i < source.length; i++) {
+		if (isEscaped) {
+			pattern += source[i];
+			isEscaped = false;
+			continue;
+		}
+		if (flags.i) {
+			if (inCharGroup) {
+				if (source[i].match(/[a-z]/)) {
+					if (inCharRange) {
+						pattern += source[i];
+						pattern += `${source[i - 2]}-${source[i]}`.toUpperCase();
+						inCharRange = false;
+					} else if (source[i + 1] === "-" && source[i + 2]?.match(/[a-z]/)) {
+						pattern += source[i];
+						inCharRange = true;
+					} else {
+						pattern += `${source[i]}${source[i].toUpperCase()}`;
+					}
+					continue;
+				}
+			} else if (source[i].match(/[a-z]/)) {
+				pattern += `[${source[i]}${source[i].toUpperCase()}]`;
+				continue;
+			}
+		}
+		if (flags.m) {
+			if (source[i] === "^") {
+				pattern += `(^|(?<=[\r\n]))`;
+				continue;
+			} else if (source[i] === "$") {
+				pattern += `($|(?=[\r\n]))`;
+				continue;
+			}
+		}
+		if (flags.s && source[i] === ".") {
+			pattern += inCharGroup ? `${source[i]}\r\n` : `[${source[i]}\r\n]`;
+			continue;
+		}
+		pattern += source[i];
+		if (source[i] === "\\") {
+			isEscaped = true;
+		} else if (inCharGroup && source[i] === "]") {
+			inCharGroup = false;
+		} else if (!inCharGroup && source[i] === "[") {
+			inCharGroup = true;
+		}
+	}
+	try {
+		const regexTest = new RegExp(pattern);
+	} catch {
+		console.warn(`Could not convert regex pattern at ${refs.currentPath.join("/")} to a flag-independent form! Falling back to the flag-ignorant source`);
+		return regex.source;
+	}
+	return pattern;
+};
+
+//#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
+function parseRecordDef(def, refs) {
+	if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodEnum) {
+		return {
+			type: "object",
+			required: def.keyType._def.values,
+			properties: def.keyType._def.values.reduce((acc, key) => ({
+				...acc,
+				[key]: parseDef(def.valueType._def, {
+					...refs,
+					currentPath: [...refs.currentPath, "properties", key]
+				}) ?? {}
+			}), {}),
+			additionalProperties: false
+		};
+	}
+	const schema$1 = {
+		type: "object",
+		additionalProperties: parseDef(def.valueType._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "additionalProperties"]
+		}) ?? {}
+	};
+	if (refs.target === "openApi3") {
+		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
+		}, {});
+		return {
+			...schema$1,
+			propertyNames: keyType
+		};
+	} else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind$1.ZodEnum) {
+		return {
+			...schema$1,
+			propertyNames: {enum: def.keyType._def.values}
+		};
+	}
+	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
+function parseMapDef(def, refs) {
+	if (refs.mapStrategy === "record") {
+		return parseRecordDef(def, refs);
+	}
+	const keys = parseDef(def.keyType._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "items", "items", "0"]
+	}) || {};
+	const values = parseDef(def.valueType._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "items", "items", "1"]
+	}) || {};
+	return {
+		type: "array",
+		maxItems: 125,
+		items: {
+			type: "array",
+			items: [keys, values],
+			minItems: 2,
+			maxItems: 2
+		}
+	};
+}
+
+//#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
+function parseNativeEnumDef(def) {
+	const object = def.values;
+	const actualKeys = (Object.keys(def.values)).filter((key) => {
+		return typeof object[object[key]] !== "number";
+	});
+	const actualValues = actualKeys.map((key) => object[key]);
+	const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
+	return {
+		type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
+		enum: actualValues
+	};
+}
+
+//#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
+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
+function parseNullDef(refs) {
+	return refs.target === "openApi3" ? {
+		enum: ["null"],
+		nullable: true
+	} : {type: "null"};
+}
+
+//#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
+const primitiveMappings = {
+	ZodString: "string",
+	ZodNumber: "number",
+	ZodBigInt: "integer",
+	ZodBoolean: "boolean",
+	ZodNull: "null"
+};
+function parseUnionDef(def, refs) {
+	if (refs.target === "openApi3") return asAnyOf(def, refs);
+	const options$1 = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
+	if (options$1.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
+		const types = options$1.reduce((types$1, x) => {
+			const type = primitiveMappings[x._def.typeName];
+			return type && !types$1.includes(type) ? [...types$1, type] : types$1;
+		}, []);
+		return {type: types.length > 1 ? types : types[0]};
+	} else if (options$1.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
+		const types = options$1.reduce((acc, x) => {
+			const type = typeof x._def.value;
+			switch (type) {
+				case "string":
+				case "number":
+				case "boolean": return [...acc, type];
+				case "bigint": return [...acc, "integer"];
+				case "object": if (x._def.value === null) return [...acc, "null"];
+				case "symbol":
+				case "undefined":
+				case "function":
+				default: return acc;
+			}
+		}, []);
+		if (types.length === options$1.length) {
+			const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+			return {
+				type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
+				enum: options$1.reduce((acc, x) => {
+					return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
+				}, [])
+			};
+		}
+	} else if (options$1.every((x) => x._def.typeName === "ZodEnum")) {
+		return {
+			type: "string",
+			enum: options$1.reduce((acc, x) => [...acc, ...x._def.values.filter((x$1) => !acc.includes(x$1)),], [])
+		};
+	}
+	return asAnyOf(def, refs);
+}
+const asAnyOf = (def, refs) => {
+	const anyOf = ((def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "anyOf", `${i}`]
+	}))).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && (Object.keys(x)).length > 0));
+	return anyOf.length ? {anyOf} : undefined;
+};
+
+//#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
+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") {
+			return {
+				type: primitiveMappings[def.innerType._def.typeName],
+				nullable: true
+			};
+		}
+		return {type: [primitiveMappings[def.innerType._def.typeName], "null",]};
+	}
+	if (refs.target === "openApi3") {
+		const base$1 = parseDef(def.innerType._def, {
+			...refs,
+			currentPath: [...refs.currentPath]
+		});
+		if (base$1 && "$ref"in base$1) return {
+			allOf: [base$1],
+			nullable: true
+		};
+		return base$1 && {
+			...base$1,
+			nullable: true
+		};
+	}
+	const base = parseDef(def.innerType._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "anyOf", "0"]
+	});
+	return base && {anyOf: [base, {type: "null"}]};
+}
+
+//#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
+function parseNumberDef(def, refs) {
+	const res = {type: "number"};
+	if (!def.checks) return res;
+	for (const check of def.checks) {
+		switch (check.kind) {
+			case "int":
+				res.type = "integer";
+				addErrorMessage(res, "type", check.message, refs);
+				break;
+			case "min":
+				if (refs.target === "jsonSchema7") {
+					if (check.inclusive) {
+						setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+					} else {
+						setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
+					}
+				} else {
+					if (!check.inclusive) {
+						res.exclusiveMinimum = true;
+					}
+					setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
+				}
+				break;
+			case "max":
+				if (refs.target === "jsonSchema7") {
+					if (check.inclusive) {
+						setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+					} else {
+						setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
+					}
+				} else {
+					if (!check.inclusive) {
+						res.exclusiveMaximum = true;
+					}
+					setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
+				}
+				break;
+			case "multipleOf":
+				setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+				break;
+		}
+	}
+	return res;
+}
+
+//#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
+function decideAdditionalProperties(def, refs) {
+	if (refs.removeAdditionalStrategy === "strict") {
+		return def.catchall._def.typeName === "ZodNever" ? def.unknownKeys !== "strict" : parseDef(def.catchall._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "additionalProperties"]
+		}) ?? true;
+	} else {
+		return def.catchall._def.typeName === "ZodNever" ? def.unknownKeys === "passthrough" : parseDef(def.catchall._def, {
+			...refs,
+			currentPath: [...refs.currentPath, "additionalProperties"]
+		}) ?? true;
+	}
+}
+function parseObjectDef(def, refs) {
+	const result = {
+		type: "object",
+		...(Object.entries(def.shape())).reduce((acc, [propName, propDef]) => {
+			if (propDef === undefined || propDef._def === undefined) return acc;
+			const parsedDef = parseDef(propDef._def, {
+				...refs,
+				currentPath: [...refs.currentPath, "properties", propName],
+				propertyPath: [...refs.currentPath, "properties", propName]
+			});
+			if (parsedDef === undefined) return acc;
+			return {
+				properties: {
+					...acc.properties,
+					[propName]: parsedDef
+				},
+				required: propDef.isOptional() ? acc.required : [...acc.required, propName]
+			};
+		}, {
+			properties: {},
+			required: []
+		}),
+		additionalProperties: decideAdditionalProperties(def, refs)
+	};
+	if (!result.required.length) delete result.required;
+	return result;
+}
+
+//#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
+const parseOptionalDef = (def, refs) => {
+	if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
+		return parseDef(def.innerType._def, refs);
+	}
+	const innerSchema = parseDef(def.innerType._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "anyOf", "1"]
+	});
+	return innerSchema ? {anyOf: [{not: {}}, innerSchema,]} : {};
+};
+
+//#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
+const parsePipelineDef = (def, refs) => {
+	if (refs.pipeStrategy === "input") {
+		return parseDef(def.in._def, refs);
+	} else if (refs.pipeStrategy === "output") {
+		return parseDef(def.out._def, refs);
+	}
+	const a = parseDef(def.in._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "allOf", "0"]
+	});
+	const b = parseDef(def.out._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
+	});
+	return {allOf: [a, b].filter((x) => x !== undefined)};
+};
+
+//#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
+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
+function parseSetDef(def, refs) {
+	const items = parseDef(def.valueType._def, {
+		...refs,
+		currentPath: [...refs.currentPath, "items"]
+	});
+	const schema$1 = {
+		type: "array",
+		uniqueItems: true,
+		items
+	};
+	if (def.minSize) {
+		setResponseValueAndErrors(schema$1, "minItems", def.minSize.value, def.minSize.message, refs);
+	}
+	if (def.maxSize) {
+		setResponseValueAndErrors(schema$1, "maxItems", def.maxSize.value, def.maxSize.message, refs);
+	}
+	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/tuple.js
+function parseTupleDef(def, refs) {
+	if (def.rest) {
+		return {
+			type: "array",
+			minItems: def.items.length,
+			items: (def.items.map((x, i) => parseDef(x._def, {
+				...refs,
+				currentPath: [...refs.currentPath, "items", `${i}`]
+			}))).reduce((acc, x) => x === undefined ? acc : [...acc, x], []),
+			additionalItems: parseDef(def.rest._def, {
+				...refs,
+				currentPath: [...refs.currentPath, "additionalItems"]
+			})
+		};
+	} else {
+		return {
+			type: "array",
+			minItems: def.items.length,
+			maxItems: def.items.length,
+			items: (def.items.map((x, i) => parseDef(x._def, {
+				...refs,
+				currentPath: [...refs.currentPath, "items", `${i}`]
+			}))).reduce((acc, x) => x === undefined ? acc : [...acc, x], [])
+		};
+	}
+}
+
+//#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
+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
+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
+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
+function parseDef(def, refs, forceResolution = false) {
+	const seenItem = refs.seen.get(def);
+	if (refs.override) {
+		const overrideResult = refs.override?.(def, refs, seenItem, forceResolution);
+		if (overrideResult !== ignoreOverride) {
+			return overrideResult;
+		}
+	}
+	if (seenItem && !forceResolution) {
+		const seenSchema = get$ref(seenItem, refs);
+		if (seenSchema !== undefined) {
+			return seenSchema;
 		}
+	}
+	const newItem = {
+		def,
+		path: refs.currentPath,
+		jsonSchema: undefined
+	};
+	refs.seen.set(def, newItem);
+	const jsonSchema = selectParser(def, def.typeName, refs);
+	if (jsonSchema) {
+		addMeta(def, refs, jsonSchema);
+	}
+	newItem.jsonSchema = jsonSchema;
+	return jsonSchema;
+}
+const get$ref = (item, refs) => {
+	switch (refs.$refStrategy) {
+		case "root": return {$ref: item.path.join("/")};
+		case "relative": return {$ref: getRelativePath(refs.currentPath, item.path)};
+		case "none":
+		case "seen": {
+			if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
+				console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
+				return {};
+			}
+			return refs.$refStrategy === "seen" ? {} : undefined;
+		}
+	}
+};
+const getRelativePath = (pathA, pathB) => {
+	let i = 0;
+	for (; i < pathA.length && i < pathB.length; i++) {
+		if (pathA[i] !== pathB[i]) break;
+	}
+	return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+const selectParser = (def, typeName, refs) => {
+	switch (typeName) {
+		case ZodFirstPartyTypeKind.ZodString: return parseStringDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodNumber: return parseNumberDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodObject: return parseObjectDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBigInt: return parseBigintDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBoolean: return parseBooleanDef();
+		case ZodFirstPartyTypeKind.ZodDate: return parseDateDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodUndefined: return parseUndefinedDef();
+		case ZodFirstPartyTypeKind.ZodNull: return parseNullDef(refs);
+		case ZodFirstPartyTypeKind.ZodArray: return parseArrayDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodUnion:
+		case ZodFirstPartyTypeKind.ZodDiscriminatedUnion: return parseUnionDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodIntersection: return parseIntersectionDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodTuple: return parseTupleDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodRecord: return parseRecordDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodLiteral: return parseLiteralDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodEnum: return parseEnumDef(def);
+		case ZodFirstPartyTypeKind.ZodNativeEnum: return parseNativeEnumDef(def);
+		case ZodFirstPartyTypeKind.ZodNullable: return parseNullableDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodOptional: return parseOptionalDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodMap: return parseMapDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodSet: return parseSetDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodLazy: return parseDef((def.getter())._def, refs);
+		case ZodFirstPartyTypeKind.ZodPromise: return parsePromiseDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodNaN:
+		case ZodFirstPartyTypeKind.ZodNever: return parseNeverDef();
+		case ZodFirstPartyTypeKind.ZodEffects: return parseEffectsDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodAny: return parseAnyDef();
+		case ZodFirstPartyTypeKind.ZodUnknown: return parseUnknownDef();
+		case ZodFirstPartyTypeKind.ZodDefault: return parseDefaultDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodBranded: return parseBrandedDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodReadonly: return parseReadonlyDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodCatch: return parseCatchDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodPipeline: return parsePipelineDef(def, refs);
+		case ZodFirstPartyTypeKind.ZodFunction:
+		case ZodFirstPartyTypeKind.ZodVoid:
+		case ZodFirstPartyTypeKind.ZodSymbol: return undefined;
+		default: return ((_) => undefined)(typeName);
+	}
+};
+const addMeta = (def, refs, jsonSchema) => {
+	if (def.description) {
+		jsonSchema.description = def.description;
+		if (refs.markdownDescription) {
+			jsonSchema.markdownDescription = def.description;
+		}
+	}
+	return 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
+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]) => ({
+		...acc,
+		[name$1]: parseDef(schema$2._def, {
+			...refs,
+			currentPath: [...refs.basePath, refs.definitionPath, name$1]
+		}, true) ?? {}
+	}), {}) : undefined;
+	const name = typeof options$1 === "string" ? options$1 : options$1?.nameStrategy === "title" ? undefined : options$1?.name;
+	const main$1 = parseDef(schema$1._def, name === undefined ? refs : {
+		...refs,
+		currentPath: [...refs.basePath, refs.definitionPath, name]
+	}, false) ?? {};
+	const title = typeof options$1 === "object" && options$1.name !== undefined && options$1.nameStrategy === "title" ? options$1.name : undefined;
+	if (title !== undefined) {
+		main$1.title = title;
+	}
+	const combined = name === undefined ? definitions ? {
+		...main$1,
+		[refs.definitionPath]: definitions
+	} : main$1 : {
+		$ref: [...refs.$refStrategy === "relative" ? [] : refs.basePath, refs.definitionPath, name,].join("/"),
+		[refs.definitionPath]: {
+			...definitions,
+			[name]: main$1
+		}
+	};
+	if (refs.target === "jsonSchema7") {
+		combined.$schema = "http://json-schema.org/draft-07/schema#";
+	} else if (refs.target === "jsonSchema2019-09") {
+		combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
+	}
+	return combined;
+};
+
+//#endregion
+//#region src/utils/zod-ext.ts
+const stringOrRegExp = () => (z$3.string()).or(z$3.instanceof(RegExp));
+const optionalStringArray = () => ((z$3.string()).array()).optional();
+const returnTrue = () => true;
+const phantom = () => z$3.custom(returnTrue);
+const voidNullableWith = (t) => {
+	return (voidNullable()).or(t);
+};
+const voidNullable = () => {
+	return ((z$3.void()).or(z$3.null())).or(z$3.undefined());
+};
+
+//#endregion
+//#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 inputOptionsSchema = z$2.strictObject({
+	input: inputOptionSchema.optional(),
+	plugins: ((phantom()).array()).optional(),
+	external: externalSchema.optional(),
+	resolve: (z$2.strictObject({
+		alias: (z$2.record(z$2.string())).optional(),
+		aliasFields: (z$2.array(z$2.array(z$2.string()))).optional(),
+		conditionNames: optionalStringArray(),
+		exportsFields: (z$2.array(z$2.array(z$2.string()))).optional(),
+		extensions: optionalStringArray(),
+		mainFields: optionalStringArray(),
+		mainFiles: optionalStringArray(),
+		modules: optionalStringArray(),
+		symlinks: (z$2.boolean()).optional(),
+		tsconfigFilename: (z$2.string()).optional()
+	})).optional(),
+	cwd: ((z$2.string()).describe("current working directory.")).optional(),
+	platform: ((((z$2.literal("node")).or(z$2.literal("browser"))).or(z$2.literal("neutral"))).describe(`platform for which the code should be generated (node, ${underline("browser")}, neutral).`)).optional(),
+	shimMissingExports: (z$2.boolean()).optional(),
+	treeshake: (phantom()).optional(),
+	logLevel: (LogLevelOptionSchema.describe(`log level (${dim("silent")}, ${underline(gray("info"))}, debug, ${yellow("warn")})`)).optional(),
+	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(),
+	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()
+});
+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(),
+	inject: ((z$2.record(z$2.string())).describe("inject import statements on demand")).optional(),
+	treeshake: (((z$2.boolean()).describe("enable treeshaking")).default(true)).optional()
+})).omit({
+	input: true,
+	plugins: true,
+	onwarn: true,
+	onLog: true,
+	resolve: true,
+	experimental: 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 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(),
+	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(),
+	sourcemapIgnoreList: ((z$1.boolean()).or(phantom())).optional(),
+	sourcemapPathTransform: (phantom()).optional(),
+	banner: ((z$1.string()).or(addonFunctionSchema)).optional(),
+	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(),
+	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(),
+	inlineDynamicImports: (((z$1.boolean()).describe("inline dynamic imports")).default(false)).optional()
+});
+const getAddonDescription = (placement, wrapper) => {
+	return `code to insert the ${bold(placement)} of the bundled file (${bold(wrapper)} the wrapper function).`;
+};
+const outputCliOptionsSchema = (outputOptionsSchema.extend({
+	banner: ((z$1.string()).describe(getAddonDescription("top", "outside"))).optional(),
+	footer: ((z$1.string()).describe(getAddonDescription("bottom", "outside"))).optional(),
+	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});
+
+//#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(),
+	help: ((z.boolean()).describe("Show help")).optional(),
+	version: ((z.boolean()).describe("Show version number")).optional()
+})).merge(inputCliOptionsSchema)).merge(outputCliOptionsSchema);
+const schema = zodToJsonSchema(cliOptionsSchema);
+
+//#endregion
+//#region src/cli/arguments/alias.ts
+const alias = {
+	config: {
+		abbreviation: "c",
+		description: "Use config file",
+		hint: "filename",
+		default: "rolldown.config.js"
 	},
-	async run(_ctx) {
-		const parsedArgs = (0, import_lib_index.default)(process$1.argv.slice(2));
-		let argConfig = parsedArgs.c || parsedArgs.config;
-		if (argConfig) {
-			if (argConfig == true) {
-				argConfig = DEFAULT_CONFIG_FILENAME;
+	help: {abbreviation: "h"},
+	version: {abbreviation: "v"},
+	dir: {abbreviation: "d"},
+	external: {abbreviation: "e"},
+	format: {abbreviation: "f"},
+	name: {abbreviation: "n"},
+	globals: {abbreviation: "g"},
+	sourcemap: {
+		abbreviation: "s",
+		default: false
+	},
+	minify: {abbreviation: "m"},
+	platform: {abbreviation: "p"},
+	assetFileNames: {hint: "name"},
+	chunkFileNames: {hint: "name"},
+	entryFileNames: {hint: "name"},
+	externalLiveBindings: {default: true},
+	treeshake: {default: 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";
+else if (types.includes("array")) return "array";
+else if (types.includes("string")) return "string";
+else if (types.includes("number")) return "number";
+else if (types.includes("boolean")) return "boolean";
+	}
+	return "object";
+}
+function flattenSchema(schema$1, base = {}, parent = "") {
+	for (const [k, value] of Object.entries(schema$1)) {
+		const key = parent ? `${parent}.${k}` : k;
+		if (getSchemaType(value) === "object") {
+			if ("properties"in value) {
+				flattenSchema(value.properties, base, key);
+			} else {
+				base[key] = value;
 			}
-			await bundle(argConfig);
-			process$1.exit(0);
+		} else {
+			base[key] = value;
+		}
+	}
+	return base;
+}
+function setNestedProperty(obj, path, value) {
+	const keys = path.split(".");
+	let current = obj;
+	for (let i = 0; i < keys.length - 1; i++) {
+		if (!current[keys[i]]) {
+			current[keys[i]] = {};
 		}
-		showUsage(main);
+		current = current[keys[i]];
 	}
+	const finalKey = keys[keys.length - 1];
+	Object.defineProperty(current, finalKey, {
+		value: value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+}
+function camelCaseToKebabCase(str) {
+	return str.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+function kebabCaseToCamelCase(str) {
+	return str.replace(/-./g, (match) => match[1].toUpperCase());
+}
+
+//#endregion
+//#region src/cli/arguments/normalize.ts
+function normalizeCliOptions(cliOptions, positionals) {
+	const parsed = cliOptionsSchema.safeParse(cliOptions);
+	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.`);
+		});
+		process.exit(1);
+	}
+	const result = {
+		input: {},
+		output: {},
+		help: options$1.help ?? false,
+		version: options$1.version ?? false
+	};
+	if (typeof options$1.config === "string") {
+		result.config = options$1.config ? options$1.config : "rolldown.config.js";
+	}
+	const reservedKeys = ["help", "version", "config"];
+	const keysOfInput = (inputCliOptionsSchema.keyof())._def.values;
+	const keysOfOutput = (outputCliOptionsSchema.keyof())._def.values;
+	for (let [key, value] of Object.entries(options$1)) {
+		const keys = key.split(".");
+		const [primary] = keys;
+		if (keysOfInput.includes(primary)) {
+			setNestedProperty(result.input, key, value);
+		} else if (keysOfOutput.includes(primary)) {
+			setNestedProperty(result.output, key, value);
+		} else if (!reservedKeys.includes(key)) {
+			logger.error(`Unknown option: ${key}`);
+			process.exit(1);
+		}
+	}
+	if (!result.config && positionals.length > 0) {
+		result.input.input = positionals;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/cli/arguments/index.ts
+const flattenedSchema = flattenSchema(schema.properties);
+const options = Object.fromEntries((Object.entries(flattenedSchema)).map(([key, schema$1]) => {
+	const config = (Object.getOwnPropertyDescriptor(alias, key))?.value;
+	const type = getSchemaType(schema$1);
+	const result = {
+		type: type === "boolean" ? "boolean" : "string",
+		description: schema$1?.description ?? config?.description ?? "",
+		hint: config?.hint
+	};
+	if (config && config?.abbreviation) {
+		result.short = config?.abbreviation;
+	}
+	key = camelCaseToKebabCase(key);
+	return [typeof config?.default === "boolean" && config?.default ? `no-${key}` : key, result,];
+}));
+function parseCliArguments() {
+	const { values: values, tokens: tokens, positionals: positionals } = parseArgs({
+		options,
+		tokens: true,
+		allowPositionals: true,
+		strict: false
+	});
+	(tokens.filter((token) => token.kind === "option")).forEach((option) => {
+		let negative = false;
+		if (option.name.startsWith("no-")) {
+			const name = kebabCaseToCamelCase(option.name.substring(3));
+			if (name in flattenedSchema) {
+				delete values[option.name];
+				option.name = name;
+				negative = true;
+			}
+		}
+		delete values[option.name];
+		option.name = kebabCaseToCamelCase(option.name);
+		let originalType = flattenedSchema[option.name];
+		if (!originalType) {
+			logger.warn(`Invalid option: ${option.rawName}. We will ignore this option.`);
+			return;
+		}
+		let type = getSchemaType(originalType);
+		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: {},
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			if (key && value) {
+				Object.defineProperty(values[option.name], key, {
+					value,
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+		} else if (type === "array" && typeof option.value === "string") {
+			if (!values[option.name]) {
+				Object.defineProperty(values, option.name, {
+					value: [],
+					enumerable: true,
+					configurable: true,
+					writable: true
+				});
+			}
+			;
+			values[option.name].push(option.value);
+		} else if (type === "boolean") {
+			Object.defineProperty(values, option.name, {
+				value: !negative,
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+		} else {
+			Object.defineProperty(values, option.name, {
+				value: option.value ?? "",
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+		}
+	});
+	return normalizeCliOptions(values, positionals);
+}
+
+//#endregion
+//#region src/cli/commands/help.ts
+const introduction = `${gray(`${description} (rolldown v${version})`)}
+
+${bold(underline("USAGE"))} ${cyan("rolldown -c <config>")} or ${cyan("rolldown <input> <options>")}`;
+const examples = [{
+	title: "Bundle with a config file `rolldown.config.mjs`",
+	command: "rolldown -c rolldown.config.mjs"
+}, {
+	title: "Bundle the `src/main.ts` to `dist` with `cjs` format",
+	command: "rolldown src/main.ts -d dist -f cjs"
+}, {
+	title: "Bundle the `src/main.ts` and handle the `.png` assets to Data URL",
+	command: "rolldown src/main.ts -d dist --moduleTypes .png=dataurl"
+}, {
+	title: "Bundle the `src/main.tsx` and minify the output with sourcemap",
+	command: "rolldown src/main.tsx -d dist -m -s"
+}, {
+	title: "Create self-executing IIFE using external jQuery as `$` and `_`",
+	command: "rolldown src/main.ts -d dist -n bundle -f iife -e jQuery,window._ -g jQuery=$"
+},];
+const notes = ["Due to the API limitation, you need to pass `-s` for `.map` sourcemap file as the last argument.", "If you are using the configuration, please pass the `-c` as the last argument if you ignore the default configuration file.", "CLI options will override the configuration file.", "For more information, please visit https://rolldown.rs/.",];
+function showHelp() {
+	logger.log(introduction);
+	logger.log("");
+	logger.log(`${bold(underline("OPTIONS"))}`);
+	logger.log("");
+	logger.log((((Object.entries(options)).sort(([a], [b]) => {
+		if (options[a].short && !options[b].short) {
+			return -1;
+		}
+		if (!options[a].short && options[b].short) {
+			return 1;
+		}
+		if (options[a].short && options[b].short) {
+			return options[a].short.localeCompare(options[b].short);
+		}
+		return a.localeCompare(b);
+	})).map(([option, { type: type, short: short, hint: hint, description: description$1 }]) => {
+		let optionStr = "  ";
+		const config = (Object.getOwnPropertyDescriptor(alias, option) ?? {}).value ?? {};
+		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}, `;
+		}
+		if (type === "string") {
+			optionStr += `<${hint ?? option}>`;
+		}
+		if (description$1 && description$1.length > 0) {
+			description$1 = description$1[0].toUpperCase() + description$1.slice(1);
+		}
+		return cyan(optionStr.padEnd(30)) + description$1 + (description$1 && description$1?.endsWith(".") ? "" : ".");
+	})).join("\n"));
+	logger.log("");
+	logger.log(`${bold(underline("EXAMPLES"))}`);
+	logger.log("");
+	examples.forEach(({ title: title, command: command }, ord) => {
+		logger.log(`  ${ord + 1}. ${title}:`);
+		logger.log(`    ${cyan(command)}`);
+		logger.log("");
+	});
+	logger.log(`${bold(underline("NOTES"))}`);
+	logger.log("");
+	notes.forEach((note) => {
+		logger.log(`  * ${gray(note)}`);
+	});
+}
+
+//#endregion
+//#region src/cli/index.ts
+async function main() {
+	const cliOptions = parseCliArguments();
+	if (cliOptions.config) {
+		await bundleWithConfig(cliOptions.config, cliOptions);
+		return;
+	}
+	if ("input"in cliOptions.input) {
+		await bundleWithCliOptions(cliOptions);
+		return;
+	}
+	if (cliOptions.version) {
+		logger.log(`rolldown v${version}`);
+		return;
+	}
+	showHelp();
+}
+(main()).catch((err) => {
+	logger.error(err);
+	process$1.exit(1);
 });
-runMain(main);
 
-//#endregion
+//#endregion