rolldown 0.10.2 → 0.10.3

package/dist/cjs/cli.cjs

@@ -0,0 +1,772 @@
+const { __commonJSMin, __export, __toESM } = require("../shared/chunk-WMSF1LUG.cjs");
+const { arraify } = require("../shared/utils_index-0Q22WhZL.cjs");
+const { rolldown } = require("../shared/rolldown-pt4wPK1i.cjs");
+const { colors, consola, createConsola } = require("../shared/consola_36c0034f-RVbq7gBJ.cjs");
+const { pathToFileURL } = __toESM(require("node:url"));
+const { default: nodePath } = __toESM(require("node:path"));
+const { default: process$1, env } = __toESM(require("node:process"));
+require("node:util");
+require("node:tty");
+const { performance } = __toESM(require("node:perf_hooks"));
+const tty = __toESM(require("tty"));
+
+// ../../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;
+	};
+});
+
+// ../../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);
+	}}
+
+// 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)}\``);
+	}
+	const fileUrl = pathToFileURL(configPath).toString();
+	const configExports = await import(fileUrl);
+	return configExports.default;
+}
+const SUPPORTED_CONFIG_FORMATS = ['.js', '.mjs', '.cjs'];
+function isSupportedFormat(configPath) {
+	const ext = nodePath.extname(configPath);
+	return SUPPORTED_CONFIG_FORMATS.includes(ext);
+}
+
+// ../../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 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 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 init = (open, close, replace) => filterEmpty(`\x1b[${open}m`, `\x1b[${close}m`, replace);
+const colors$1 = {
+	reset:init(0, 0),
+	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),
+	hidden:init(8, 28),
+	strikethrough:init(9, 29),
+	black:init(30, 39),
+	red:init(31, 39),
+	green:init(32, 39),
+	yellow:init(33, 39),
+	blue:init(34, 39),
+	magenta:init(35, 39),
+	cyan:init(36, 39),
+	white:init(37, 39),
+	gray:init(90, 39),
+	bgBlack:init(40, 49),
+	bgRed:init(41, 49),
+	bgGreen:init(42, 49),
+	bgYellow:init(43, 49),
+	bgBlue:init(44, 49),
+	bgMagenta:init(45, 49),
+	bgCyan:init(46, 49),
+	bgWhite:init(47, 49),
+	blackBright:init(90, 39),
+	redBright:init(91, 39),
+	greenBright:init(92, 39),
+	yellowBright:init(93, 39),
+	blueBright:init(94, 39),
+	magentaBright:init(95, 39),
+	cyanBright:init(96, 39),
+	whiteBright:init(97, 39),
+	bgBlackBright:init(100, 49),
+	bgRedBright:init(101, 49),
+	bgGreenBright:init(102, 49),
+	bgYellowBright:init(103, 49),
+	bgBlueBright:init(104, 49),
+	bgMagentaBright:init(105, 49),
+	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,
+	[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();
+
+// src/cli/colors.ts
+var colors_ns = {};
+__export(colors_ns, {
+	bold:() => bold,
+	cyan:() => cyan,
+	dim:() => dim,
+	gray:() => gray,
+	green:() => green,
+	red:() => red,
+	underline:() => underline,
+	yellow:() => yellow
+});
+const {bold, cyan, dim, gray, green, red, underline, yellow} = createColors({
+	useColor:env.FORCE_COLOR !== '0' &&  !env.NO_COLOR
+});
+
+// src/cli/commands/bundle.ts
+async function bundle(configPath) {
+	const config = await ensureConfig(configPath);
+	if ( !config) {
+		logger.error(`No configuration found at ${config}`);
+		process.exit(1);
+	}
+	const configList = arraify(config);
+	for (const config2 of  configList) 	{
+		await bundleInner(config2);
+	}
+}
+async function bundleInner(options) {
+	const startTime = performance.now();
+	const build = await rolldown(options);
+	const bundleOutput = await build.write(options?.output);
+	const endTime = performance.now();
+	printBundleOutputPretty(bundleOutput);
+	logger.log(``);
+	logger.success(`Finished in ${colors_ns.bold((endTime - startTime).toFixed(2))} ms`);
+}
+function printBundleOutputPretty(output) {
+	const outputEntries = collectOutputEntries(output.output);
+	const outputLayoutSizes = collectOutputLayoutAdjustmentSizes(outputEntries);
+	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
+	}));
+}
+function collectOutputLayoutAdjustmentSizes(entries) {
+	let longest = 0;
+	let biggestSize = 0;
+	for (const entry of  entries) 	{
+		if (entry.fileName.length > longest) {
+			longest = entry.fileName.length;
+		}
+		if (entry.size > biggestSize) {
+			biggestSize = entry.size;
+		}
+	}
+	const sizePad = displaySize(biggestSize).length;
+	return {
+		longest,
+		biggestSize,
+		sizePad
+	};
+}
+const numberFormatter = new Intl.NumberFormat('en', {
+	maximumFractionDigits:2,
+	minimumFractionDigits:2
+});
+function displaySize(bytes) {
+	return `${numberFormatter.format(bytes / 1e3)} kB`;
+}
+const CHUNK_GROUPS = [{
+	type:'asset',
+	color:'green'
+}, {
+	type:'chunk',
+	color:'cyan'
+}];
+function printOutputEntries(entries, sizeAdjustment, distPath) {
+	for (const group of  CHUNK_GROUPS) 	{
+		const filtered = entries.filter(e => e.type === group.type);
+		if ( !filtered.length) {
+			continue;
+		}
+		for (const entry of  filtered.sort((a, z) => a.size - z.size)) 		{
+			let log = colors_ns.dim(withTrailingSlash(distPath));
+			log += colors_ns[group.color](entry.fileName.padEnd(sizeAdjustment.longest + 2));
+			log += colors_ns.dim(entry.type);
+			log += colors_ns.dim(` \u2502 size: ${displaySize(entry.size).padStart(sizeAdjustment.sizePad)}`);
+			logger.log(log);
+		}
+	}
+}
+function withTrailingSlash(path) {
+	if (path[path.length - 1] !== '/') {
+		return `${path}/`;
+	}
+	return path;
+}
+
+// package.json
+const version = '0.10.3';
+const description = 'Fast JavaScript/TypeScript bundler in Rust with Rollup-compatible API.';
+const keywords = ['webpack', 'parcel', 'esbuild', 'rollup', 'bundler', 'rolldown'];
+const files = ['bin', 'cli', 'dist', '!dist/*.node'];
+const napi = {
+	'binaryName':'rolldown-binding',
+	'packageName':'@rolldown/binding',
+	'targets':['x86_64-apple-darwin', 'x86_64-pc-windows-msvc', 'x86_64-unknown-linux-gnu', 'x86_64-unknown-linux-musl', 'i686-pc-windows-msvc', 'armv7-unknown-linux-gnueabihf', 'aarch64-unknown-linux-gnu', 'aarch64-apple-darwin', 'aarch64-unknown-linux-musl', 'aarch64-pc-windows-msvc', 'wasm32-wasip1-threads'],
+	'wasm':{
+		'initialMemory':16384,
+		'browser':{
+			'fs':true
+		}
+	},
+	'dtsHeader':'type MaybePromise<T> = T | Promise<T>\ntype Nullable<T> = T | null | undefined\ntype VoidNullable<T = void> = T | null | undefined | void\n'
+};
+
+// src/cli/constants.ts
+const DEFAULT_CONFIG_FILENAME = 'rolldown.config.js';
+
+// src/cli/index.ts
+var import_lib_index = __toESM(require_lib_index());
+const main = defineCommand({
+	meta:{
+		name:'rolldown',
+		version,
+		description
+	},
+	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'
+		}
+	},
+	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;
+			}
+			await bundle(argConfig);
+			process$1.exit(0);
+			return;
+		}
+		showUsage(main);
+	}
+});
+runMain(main);