rolldown 0.10.5 → 0.11.0

package/dist/esm/cli.mjs

@@ -1,24 +1,528 @@
 import __node_module__ from 'node:module';
 const require = __node_module__.createRequire(import.meta.url)
-import { __export, arraify } from "../shared/bindingify_plugin-gPrr_HPR.mjs";
-import { rolldown } from "../shared/rolldown-bgokD9pg.mjs";
+import { __commonJSMin, __export, __toESM, arraify } from "../shared/utils_index-DAvBTBzR.mjs";
+import { rolldown } from "../shared/rolldown-RjvHfXoR.mjs";
+import { colors, consola, createConsola } from "../shared/consola_36c0034f-5LhwiLE2.mjs";
 import { pathToFileURL } from "node:url";
 import { default as nodePath } from "node:path";
 import { default as process$1, env } from "node:process";
-import { default as parseArgs } from "mri";
-import { defineCommand, runMain, showUsage } from "citty";
+import "node:util";
+import * as tty from "node:tty";
 import { performance } from "node:perf_hooks";
-import { createConsola } from "consola";
-import { createColors } from "colorette";
 
-//#region src/cli/utils.ts
-const logger = createConsola({
-	formatOptions:{
-		date:false
+//#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);
+	}
+}
+
+//#endregion
+//#region src/cli/utils.ts
+const logger = createConsola({formatOptions: {date: false}});
 async function ensureConfig(configPath) {
-	if ( !isSupportedFormat(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();
@@ -31,33 +535,94 @@ function isSupportedFormat(configPath) {
 	return SUPPORTED_CONFIG_FORMATS.includes(ext);
 }
 
+//#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 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();
+
 //#endregion
 //#region 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
+	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});
 
 //#endregion
 //#region src/cli/commands/bundle.ts
 async function bundle(configPath) {
 	const config = await ensureConfig(configPath);
-	if ( !config) {
+	if (!config) {
 		logger.error(`No configuration found at ${config}`);
 		process.exit(1);
 	}
 	const configList = arraify(config);
-	for (const config$1 of  configList) 	{
+	for (const config$1 of configList) {
 		await bundleInner(config$1);
 	}
 }
@@ -68,7 +633,7 @@ async function bundleInner(options) {
 	const endTime = performance.now();
 	printBundleOutputPretty(bundleOutput);
 	logger.log(``);
-	logger.success(`Finished in ${colors_ns.bold((endTime - startTime).toFixed(2))} ms`);
+	logger.success(`Finished in ${bold((endTime - startTime).toFixed(2))} ms`);
 }
 function printBundleOutputPretty(output) {
 	const outputEntries = collectOutputEntries(output.output);
@@ -76,16 +641,16 @@ function printBundleOutputPretty(output) {
 	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
+	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) 	{
+	for (const entry of entries) {
 		if (entry.fileName.length > longest) {
 			longest = entry.fileName.length;
 		}
@@ -101,30 +666,30 @@ function collectOutputLayoutAdjustmentSizes(entries) {
 	};
 }
 const numberFormatter = new Intl.NumberFormat('en', {
-	maximumFractionDigits:2,
-	minimumFractionDigits:2
+	maximumFractionDigits: 2,
+	minimumFractionDigits: 2
 });
 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) 	{
-		const filtered = entries.filter(e => e.type === group.type);
-		if ( !filtered.length) {
+	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));
+		for (const entry of filtered.sort((a, z) => a.size - z.size)) {
+			let log = dim(withTrailingSlash(distPath));
 			log += colors_ns[group.color](entry.fileName.padEnd(sizeAdjustment.longest + 2));
-			log += colors_ns.dim(entry.type);
-			log += colors_ns.dim(` │ size: ${displaySize(entry.size).padStart(sizeAdjustment.sizePad)}`);
+			log += dim(entry.type);
+			log += dim(` │ size: ${displaySize(entry.size).padStart(sizeAdjustment.sizePad)}`);
 			logger.log(log);
 		}
 	}
@@ -138,21 +703,19 @@ function withTrailingSlash(path) {
 
 //#endregion
 //#region package.json
-const version = '0.10.5';
+const version = '0.11.0';
 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
-		}
+	'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'
+	'dtsHeader': 'type MaybePromise<T> = T | Promise<T>\ntype Nullable<T> = T | null | undefined\ntype VoidNullable<T = void> = T | null | undefined | void\n'
 };
 
 //#endregion
@@ -161,26 +724,27 @@ const DEFAULT_CONFIG_FILENAME = 'rolldown.config.js';
 
 //#endregion
 //#region src/cli/index.ts
+var import_lib_index = __toESM(require_lib_index());
 const main = defineCommand({
-	meta:{
-		name:'rolldown',
+	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`)'
+	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'
+		help: {
+			type: 'boolean',
+			alias: 'h',
+			description: 'Show this help message'
 		}
 	},
-	async run(_ctx){
-		const parsedArgs = parseArgs(process$1.argv.slice(2));
+	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) {