@rzl-zone/build-tools 0.0.5

package/dist/commander-kit/index.js

@@ -0,0 +1,550 @@
+/*!
+* ========================================================================
+*  @rzl-zone/build-tools
+* ------------------------------------------------------------------------
+*  Version: `0.0.5`
+*  Author: `Rizalvin Dwiky <rizalvindwiky1998@gmail.com>`
+*  Repository: `https://github.com/rzl-zone/rzl-zone/tree/main/packages/build-tools`
+* ========================================================================
+*/
+
+import { _ as isUndefined, c as isNil, i as isBoolean, l as isNonEmptyString, t as deepFreeze, u as isNull } from "../helper-BdjaR8Yv.js";
+import { r as ICONS } from "../server-CWrDd29Y.js";
+import { n as PACKAGE_META, t as CommandIdentity } from "../identity-BJ0QX7AJ.js";
+import { a as joinInline, i as formatOptionValue, l as picocolors, n as EOL, s as joinLinesLoose, t as ConfigurationError } from "../client-XhkdKJ4d.js";
+import "@rzl-zone/node-only";
+import { parse } from "node:path";
+import { Argument, Command, CommanderError, Help, InvalidArgumentError, InvalidOptionArgumentError, Option } from "commander";
+function isCommanderError(err) {
+	return err instanceof CommanderError;
+}
+function formatCommanderError(err) {
+	if (err instanceof CommanderError) return err.message;
+	return String(err);
+}
+function getCommanderErrorCode(err) {
+	if (err instanceof CommanderError) return err.code;
+	return null;
+}
+var CliCommand = class extends Command {
+	constructor(name) {
+		name = isNonEmptyString(name) ? name : void 0;
+		super(name);
+	}
+	usage(str) {
+		if (str === false) {
+			super.usage("");
+			return this;
+		}
+		if (!isNonEmptyString(str)) return super.usage();
+		return super.usage(str);
+	}
+	version(str, flags, description) {
+		if (str === false) {
+			super.version("");
+			return this;
+		}
+		if (!isNonEmptyString(str)) return super.version();
+		return super.version(str, flags, description);
+	}
+};
+function handleCommanderExit(err) {
+	if (isCommanderError(err)) {
+		const code = err.code;
+		if (code === "commander.helpDisplayed" || code === "commander.version") process.exit(0);
+		process.exit(err.exitCode ?? 1);
+	}
+	console.error(err);
+	process.exit(1);
+}
+function isExactInstanceOf(value, ctor) {
+	//! Constraint: Immediately reject primitives
+	if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+	return Object.getPrototypeOf(value) === ctor.prototype;
+}
+var CliHelp = class extends Help {
+	constructor() {
+		super();
+	}
+};
+var CliOption = class extends Option {
+	constructor(arg, description) {
+		super(arg, description);
+	}
+};
+const hasSymbolConstructor = typeof Symbol === "function" && typeof Symbol("x") === "symbol" && typeof Symbol.for === "function" && typeof Symbol.keyFor === "function";
+const REGISTRY_KEY = "__rzl_global_symbol_registry__";
+function getGlobal() {
+	if (typeof globalThis !== "undefined") return globalThis;
+	if (typeof self !== "undefined") return self;
+	if (typeof window !== "undefined") return window;
+	if (typeof global !== "undefined") return global;
+	return {};
+}
+function createUID() {
+	return Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+function createLocalSymbol(desc) {
+	if (hasSymbolConstructor) return Symbol(desc);
+	return "@@rzl/local/" + (desc ?? "") + "/" + createUID();
+}
+function createGlobalSymbol(key) {
+	if (hasSymbolConstructor) return Symbol.for(key);
+	const registry = getRegistry();
+	if (registry.byKey[key]) return registry.byKey[key];
+	const value = "@@rzl/global/" + key + "/" + createUID();
+	registry.byKey[key] = value;
+	registry.byValue.set(value, key);
+	return value;
+}
+function getRegistry() {
+	const g = getGlobal();
+	if (!g[REGISTRY_KEY]) g[REGISTRY_KEY] = {
+		byKey: Object.create(null),
+		byValue: /* @__PURE__ */ new Map()
+	};
+	return g[REGISTRY_KEY];
+}
+const SymbolSafe = Object.assign(function SymbolSafe(description) {
+	return createLocalSymbol(description);
+}, {
+	for(key) {
+		return createGlobalSymbol(key);
+	},
+	keyFor(sym) {
+		if (hasSymbolConstructor && typeof sym === "symbol") return Symbol.keyFor(sym);
+		return getRegistry().byValue.get(sym);
+	}
+});
+const COMMANDER_INTERNAL_SYMBOL = SymbolSafe("rzl-built-tools:commander.internal");
+function createDefaultInternalState() {
+	return {
+		ui: void 0,
+		help: void 0,
+		packageName: void 0,
+		manualUsage: void 0,
+		disableUsage: false,
+		versionMeta: void 0,
+		versionInjected: false,
+		versionDisable: false,
+		versionOriginal: void 0,
+		versionSetByUser: false
+	};
+}
+const resetAllCommandInternal = (cmd) => {
+	const fresh = createDefaultInternalState();
+	if ("_internalState" in cmd && "_setInternalState" in cmd) {
+		cmd._setInternalState(fresh);
+		return fresh;
+	}
+	cmd[COMMANDER_INTERNAL_SYMBOL] = fresh;
+	return fresh;
+};
+function getInternalState(cmd) {
+	if ("_internalState" in cmd && "_setInternalState" in cmd) {
+		let state = cmd._internalState;
+		if (!state) {
+			state = resetAllCommandInternal(cmd);
+			cmd._setInternalState(state);
+		}
+		return state;
+	}
+	if (!cmd[COMMANDER_INTERNAL_SYMBOL]) cmd[COMMANDER_INTERNAL_SYMBOL] = resetAllCommandInternal(cmd);
+	return cmd[COMMANDER_INTERNAL_SYMBOL];
+}
+function setInternalUiState(cmd, input) {
+	const internal = getInternalState(cmd);
+	const sanitized = createUIState(input);
+	if (!internal.ui) {
+		internal.ui = sanitized;
+		return;
+	}
+	Object.assign(internal.ui, sanitized);
+}
+function createUIState(input) {
+	const result = {};
+	if (isNonEmptyString(input.title)) result.title = input.title;
+	if (isNonEmptyString(input.usage)) result.usage = input.usage;
+	if (isNonEmptyString(input.packageName)) result.packageName = input.packageName;
+	if (isNonEmptyString(input.version)) result.version = input.version;
+	return result;
+}
+function styleUsage(raw, { fromHelpCommandUsage, errorConfig: { field = "raw", expected = "a non-empty string", context = "styleUsage" } = {} } = {}) {
+	if (!isNonEmptyString(raw)) throw ConfigurationError.type(field, expected, raw, context);
+	return raw.split(/\s+/).map((token, index) => {
+		if (!!fromHelpCommandUsage && index === 0) return picocolors.cyanBright(token);
+		if (token === "[options]") return picocolors.blueBright(token);
+		if (token === "[command]") return picocolors.magentaBright(token);
+		if (token.startsWith("<") && token.endsWith(">")) return picocolors.gray(token);
+		if (token.startsWith("[") && token.endsWith("]")) return picocolors.gray(token);
+		return token;
+	}).join(" ");
+}
+function reorderUsage(raw, { errorConfig: { field = "raw", expected = "a non-empty string", context = "reorderUsage" } = {} } = {}) {
+	if (!isNonEmptyString(raw)) throw ConfigurationError.type(field, expected, raw, context);
+	const tokens = raw.match(/\S+/g) ?? [];
+	const optionTokens = tokens.filter((t) => t === "[options]");
+	return [...tokens.filter((t) => t !== "[options]"), ...optionTokens].join(" ");
+}
+var StyledHelp = class extends CliHelp {
+	constructor() {
+		super();
+	}
+	commandUsage(cmd) {
+		const { manualUsage, ui, disableUsage } = getInternalState(cmd);
+		if (disableUsage) return "";
+		if (isNonEmptyString(manualUsage)) return manualUsage;
+		if (isNonEmptyString(ui?.usage)) return ui.usage;
+		return styleUsage(reorderUsage(super.commandUsage(cmd), { errorConfig: {
+			field: "`super.commandUsage(cmd)`",
+			context: "StyledHelp.commandUsage"
+		} }), {
+			fromHelpCommandUsage: true,
+			errorConfig: {
+				field: "`reorderUsage(super.commandUsage(cmd))`",
+				context: "StyledHelp.commandUsage (by `reorderUsage(super.commandUsage(cmd))`)"
+			}
+		});
+	}
+	formatHelp(cmd, helper) {
+		const usage = this.commandUsage(cmd);
+		const usageBlock = joinLinesLoose(picocolors.reset("Usage:"), `  ${usage}`);
+		const rest = super.formatHelp(cmd, helper);
+		if (!usage) return rest.replace(/^Usage:[\s\S]*?\n(?=\S)/, "");
+		return rest.replace(/^Usage:[\s\S]*?\n(?=\S)/, usageBlock + EOL + EOL);
+	}
+	optionDescription(option) {
+		let desc = option.description || "";
+		const hasDefault = option.defaultValue !== void 0;
+		if (isNonEmptyString(desc)) {
+			desc = desc.trim();
+			if (hasDefault) {
+				if (desc.endsWith(".")) desc = desc.slice(0, -1) + "";
+				else if (!desc.endsWith(",")) desc += "";
+				desc += ` ${picocolors.italic(`(default: ${formatOptionValue(option.defaultValue)})`)}.`;
+			} else if (!desc.trim().endsWith(".")) desc += ".";
+		}
+		return desc;
+	}
+};
+function resolveFactoryOriginErrorSuffix(programCommand) {
+	return isExactInstanceOf(programCommand, CommandBaseProgram) ? " by 'createBaseProgram' factory function" : "";
+}
+function resolveInstanceOriginErrorSuffix(programCommand) {
+	return isExactInstanceOf(programCommand, Command) ? "Command" : isExactInstanceOf(programCommand, CliCommand) ? "CliCommand" : "";
+}
+function interceptUsage(cmd) {
+	const originalUsage = cmd.usage.bind(cmd);
+	function usage(str) {
+		if (!isNil(str)) {
+			if (str === false) {
+				getInternalState(cmd).manualUsage = void 0;
+				getInternalState(cmd).disableUsage = true;
+				return cmd;
+			}
+			if (!isNonEmptyString(str)) {
+				const errorMessageByFactory = resolveFactoryOriginErrorSuffix(cmd);
+				const errorMessageInstance = resolveInstanceOriginErrorSuffix(cmd);
+				throw ConfigurationError.type("usage", "a non-empty string or `false` only", str, `'${errorMessageInstance}.usage'${errorMessageByFactory}`);
+			}
+			getInternalState(cmd).manualUsage = str;
+			return originalUsage(str);
+		}
+		return originalUsage();
+	}
+	cmd.usage = usage;
+}
+const COMMANDER_UI_DEFAULTS = deepFreeze({
+	FLAGS: {
+		VERSION: "-v, --version",
+		HELP: "-h, --help"
+	},
+	DESCRIPTIONS: {
+		HELP: "To display help for this command.",
+		VERSION: "The version package of this command."
+	}
+});
+const { DESCRIPTIONS: DESCRIPTIONS$2, FLAGS: FLAGS$3 } = COMMANDER_UI_DEFAULTS;
+function interceptHelp(cmd) {
+	function resetInternalHelpState(cmd) {
+		getInternalState(cmd).help = void 0;
+	}
+	const original = cmd.helpOption.bind(cmd);
+	cmd.helpOption = function(flags, description) {
+		const errorMessageByFactory = resolveFactoryOriginErrorSuffix(cmd);
+		const errorMessageInstance = resolveInstanceOriginErrorSuffix(cmd);
+		if (!isNil(flags) && !isNonEmptyString(flags) && !isBoolean(flags)) {
+			resetInternalHelpState(cmd);
+			throw ConfigurationError.type("flags", "a non-empty string or a boolean", flags, `'${errorMessageInstance}.helpOption'${errorMessageByFactory}`);
+		}
+		if (!isNil(description) && !isNonEmptyString(description)) {
+			resetInternalHelpState(cmd);
+			throw ConfigurationError.type("description", "a non-empty string if provided", description, `'${errorMessageInstance}.helpOption'${errorMessageByFactory}`);
+		}
+		const _decs = isNonEmptyString(description) ? description : DESCRIPTIONS$2.HELP;
+		if (flags === false) {
+			getInternalState(cmd).help = { disabled: true };
+			return original(flags);
+		}
+		if (flags === true) {
+			getInternalState(cmd).help = {
+				flags: FLAGS$3.HELP,
+				description: _decs,
+				disabled: false
+			};
+			return original(flags, _decs);
+		}
+		if (isNonEmptyString(flags)) {
+			getInternalState(cmd).help = {
+				flags,
+				description: _decs,
+				disabled: false
+			};
+			return original(flags, _decs);
+		}
+		return original(flags, _decs);
+	};
+}
+const { FLAGS: FLAGS$2 } = COMMANDER_UI_DEFAULTS;
+function interceptVersion(cmd, versionDescription) {
+	const originalVersion = cmd.version.bind(cmd);
+	getInternalState(cmd).versionOriginal = originalVersion;
+	function version(value, flags, description) {
+		if (arguments.length === 0) return originalVersion();
+		if (value === false) {
+			getInternalState(cmd).versionDisable = true;
+			getInternalState(cmd).versionOriginal = void 0;
+			return cmd;
+		}
+		const errorMessageByFactory = resolveFactoryOriginErrorSuffix(cmd);
+		const errorMessageInstance = resolveInstanceOriginErrorSuffix(cmd);
+		if (!isNonEmptyString(value)) throw ConfigurationError.type("str", "a non-empty string", value, `'${errorMessageInstance}.version'${errorMessageByFactory}`);
+		if (!isNil(flags) && !isNonEmptyString(flags)) throw ConfigurationError.type("flags", "a non-empty string if provided", flags, `'${errorMessageInstance}.version'${errorMessageByFactory}`);
+		if (!isNil(description) && !isNonEmptyString(description)) throw ConfigurationError.type("description", "a non-empty string if provided", description, `'${errorMessageInstance}.version'${errorMessageByFactory}`);
+		const _flag = isNonEmptyString(flags) ? flags : FLAGS$2.VERSION;
+		const _decs = isNonEmptyString(description) ? description : versionDescription;
+		getInternalState(cmd).versionMeta = {
+			value,
+			flags: _flag,
+			description: _decs
+		};
+		getInternalState(cmd).versionSetByUser = true;
+		return originalVersion(value, _flag, _decs);
+	}
+	cmd.version = version;
+}
+var CliArgument = class extends Argument {
+	constructor(arg, description) {
+		super(arg, description);
+	}
+};
+const { DESCRIPTIONS: DESCRIPTIONS$1, FLAGS: FLAGS$1 } = COMMANDER_UI_DEFAULTS;
+const composeVersionDescription = (packageName) => {
+	const isPkgNameEmptyString = !isNonEmptyString(packageName);
+	if (!isUndefined(packageName) && isPkgNameEmptyString) throw ConfigurationError.type("packageName", "a non-empty string", packageName, "composeVersionDescription");
+	return (!isPkgNameEmptyString ? `The version package of ${packageName}.` : DESCRIPTIONS$1.VERSION).trim().replace(/\.*$/, "") + ".";
+};
+function normalizeVersionPrefix(version) {
+	if (!isNil(version) && !isNonEmptyString(version)) throw ConfigurationError.type("version", "a non-empty string, null or undefined", version, "composeVersionDescription");
+	if (isNull(version)) return null;
+	return version?.replace(/^v(?=\d)/, "");
+}
+function ensureVersionInjected(cmd, options) {
+	const { pkgNameFormatted, normalizedVersion } = options;
+	const _internal = getInternalState(cmd);
+	if (!_internal.versionSetByUser && !_internal.versionInjected) {
+		const _isNonEmptyString = isNonEmptyString(pkgNameFormatted);
+		const _pkgName = _isNonEmptyString ? pkgNameFormatted : void 0;
+		const _subTitle = _isNonEmptyString ? `${pkgNameFormatted} ${picocolors.reset("version")}:` : `${picocolors.blueBright("Version")}:`;
+		_internal.versionOriginal?.(joinLinesLoose(_subTitle, joinInline(`${picocolors.magentaBright(ICONS.arrowRight)}`, `${picocolors.gray(`v${normalizedVersion}`)}`)), FLAGS$1.VERSION, composeVersionDescription(_pkgName));
+		_internal.versionInjected = true;
+	}
+}
+function resolveBaseProgramPresentationMeta(params) {
+	const { cliName, packageName, packageVersion, commandIdentity, ui } = params;
+	const resolvedCliName = isNonEmptyString(cliName) ? cliName : isNonEmptyString(commandIdentity?.commandName) ? commandIdentity.commandName : isNonEmptyString(process.argv[1]) ? parse(process.argv[1]).name : void 0;
+	const identityTitle = commandIdentity?.cli?.();
+	const commandTitle = isNonEmptyString(identityTitle) ? identityTitle : isNonEmptyString(ui?.title) ? ui.title : void 0;
+	const resolvedPackageName = isNonEmptyString(packageName) ? packageName : isNonEmptyString(commandIdentity?.packageName) ? commandIdentity.packageName : PACKAGE_META.name;
+	const resolvedPackageVersion = isNonEmptyString(packageVersion) ? packageVersion : isNonEmptyString(commandIdentity?.version) ? commandIdentity.version : PACKAGE_META.version;
+	const normalizedVersion = normalizeVersionPrefix(resolvedPackageVersion);
+	const isDiffCommandName = !!resolvedCliName && resolvedCliName !== PACKAGE_META.name;
+	const pkgNameFormatted = `${picocolors.blueBright(resolvedPackageName)}${isDiffCommandName ? ` ${picocolors.cyanBright(`(${resolvedCliName})`)}` : ""}`;
+	const defaultTitleFormatted = joinInline(picocolors.blueBright(PACKAGE_META.name + "@" + normalizedVersion), isDiffCommandName ? `${picocolors.magentaBright(ICONS.arrowRight)} ${picocolors.yellowBright(resolvedCliName)}` : false);
+	return Object.freeze({
+		resolvedCliName,
+		commandTitle,
+		resolvedPackageName,
+		resolvedPackageVersion,
+		normalizedVersion,
+		isDiffCommandName,
+		pkgNameFormatted,
+		defaultTitleFormatted
+	});
+}
+function installParseVersionInterceptor(program, options) {
+	const { versionInjection } = options;
+	const originalParse = program.parse.bind(program);
+	const originalParseAsync = program.parseAsync.bind(program);
+	program.parse = function(...args) {
+		ensureVersionInjected(program, versionInjection);
+		return originalParse(...args);
+	};
+	program.parseAsync = async function(...args) {
+		ensureVersionInjected(program, versionInjection);
+		return originalParseAsync(...args);
+	};
+}
+var CommandBaseProgram = class CommandBaseProgram extends CliCommand {
+	_internalStateData;
+	constructor(name) {
+		super(name);
+		this._internalStateData = createDefaultInternalState();
+	}
+	get _internalState() {
+		return this._internalStateData;
+	}
+	_setInternalState(state) {
+		this._internalStateData = state;
+	}
+	createCommand(name) {
+		const sub = new CommandBaseProgram(name);
+		sub._setInternalState({ ...this._internalState });
+		return sub;
+	}
+};
+function createBaseProgram(options = {}) {
+	if (options.commandIdentity && !isExactInstanceOf(options.commandIdentity, CommandIdentity)) throw ConfigurationError.type("options.commandIdentity", "instanceof CommandIdentity", options.commandIdentity, "createBaseProgram");
+	const { commandTitle, defaultTitleFormatted, normalizedVersion, pkgNameFormatted, resolvedCliName, resolvedPackageName } = resolveBaseProgramPresentationMeta(options);
+	const cmd = new CommandBaseProgram(resolvedCliName);
+	cmd._setInternalState({
+		...createDefaultInternalState(),
+		ui: createUIState(options.ui || {}),
+		packageName: resolvedPackageName
+	});
+	interceptUsage(cmd);
+	interceptHelp(cmd);
+	interceptVersion(cmd, composeVersionDescription(pkgNameFormatted));
+	cmd.createHelp = () => new StyledHelp();
+	cmd.addHelpText("before", joinLinesLoose("", commandTitle ?? defaultTitleFormatted, ""));
+	cmd.exitOverride(handleCommanderExit);
+	const cmdApplyUi = applyCommanderUi(cmd, {
+		title: commandTitle,
+		usage: options.ui?.usage,
+		__commandName: resolvedCliName
+	});
+	installParseVersionInterceptor(cmdApplyUi, { versionInjection: {
+		normalizedVersion,
+		pkgNameFormatted
+	} });
+	return cmdApplyUi;
+}
+const { DESCRIPTIONS, FLAGS } = COMMANDER_UI_DEFAULTS;
+function resolveCliPresentationMeta(params) {
+	const { program, commandName, title, version, packageName } = params;
+	const _internal = getInternalState(program);
+	const isCommandBaseProgram = isExactInstanceOf(program, CommandBaseProgram);
+	const resolvedCliName = isNonEmptyString(commandName) ? commandName : isNonEmptyString(process.argv[1]) ? parse(process.argv[1]).name : void 0;
+	const isDiffCommandName = !!resolvedCliName && resolvedCliName !== PACKAGE_META.name;
+	const commandTitle = isNonEmptyString(commandName) ? commandName : isNonEmptyString(title) ? title : void 0;
+	let normalizedVersion = normalizeVersionPrefix(!isCommandBaseProgram && isNonEmptyString(version) ? version : isNonEmptyString(_internal.versionMeta?.value) ? _internal.versionMeta.value : void 0);
+	normalizedVersion = isNonEmptyString(normalizedVersion) ? normalizedVersion : normalizeVersionPrefix(PACKAGE_META.version);
+	const defaultTitleFormatted = joinInline(picocolors.blueBright((isNonEmptyString(_internal.packageName) ? _internal.packageName : PACKAGE_META.name) + "@" + normalizedVersion), isDiffCommandName ? `${picocolors.magentaBright(ICONS.arrowRight)} ${picocolors.yellowBright(resolvedCliName)}` : false);
+	const dynamicUsage = isNonEmptyString(_internal.manualUsage) ? _internal.manualUsage : isNonEmptyString(_internal.ui?.usage) ? _internal.ui.usage : (isDiffCommandName ? `${picocolors.cyanBright(resolvedCliName)} ` : "") + (isNonEmptyString(program.usage()) ? styleUsage(reorderUsage(program.usage(), { errorConfig: {
+		field: "`program.usage()`",
+		context: "resolveCliPresentationMeta (by `program.usage()` at const variable 'dynamicUsage')"
+	} }), { errorConfig: {
+		field: "`reorderUsage(program.usage())`",
+		context: "resolveCliPresentationMeta (by `reorderUsage(program.usage())` at const variable 'dynamicUsage')"
+	} }) : "");
+	const resolvedPackageName = isNonEmptyString(packageName) ? packageName : PACKAGE_META.name;
+	const resolvedPackageNameFormatted = `${picocolors.blueBright(resolvedPackageName)}${isDiffCommandName ? ` ${picocolors.cyanBright(`(${resolvedCliName})`)}` : ""}`;
+	const helpMeta = _internal.help;
+	const isHelpDisabled = helpMeta?.disabled === true;
+	const helpFlags = helpMeta?.flags ?? FLAGS.HELP;
+	const helpDesc = helpMeta?.description ?? DESCRIPTIONS.HELP;
+	return Object.freeze({
+		resolvedCliName,
+		resolvedPackageName,
+		resolvedPackageNameFormatted,
+		isDiffCommandName,
+		commandTitle,
+		normalizedVersion,
+		defaultTitleFormatted,
+		dynamicUsage,
+		help: {
+			meta: helpMeta,
+			disabled: isHelpDisabled,
+			flags: helpFlags,
+			description: helpDesc
+		}
+	});
+}
+function applyCommanderUi(program, options) {
+	const { title, usage, version, packageName, __commandName } = options;
+	if (!isExactInstanceOf(program, Command) && !isExactInstanceOf(program, CliCommand) && !isExactInstanceOf(program, CommandBaseProgram)) throw ConfigurationError.type("program", "instanceof Command, CliCommand or create by factory function 'createBaseProgram'", program, "applyCommanderUi");
+	setInternalUiState(program, {
+		title,
+		usage
+	});
+	if (!isExactInstanceOf(program, CommandBaseProgram)) {
+		const { commandTitle, defaultTitleFormatted, normalizedVersion, resolvedPackageNameFormatted } = resolveCliPresentationMeta({
+			program,
+			commandName: __commandName,
+			version,
+			packageName,
+			title
+		});
+		interceptUsage(program);
+		interceptHelp(program);
+		interceptVersion(program, composeVersionDescription(resolvedPackageNameFormatted));
+		program.createHelp = () => new StyledHelp();
+		program.addHelpText("before", joinLinesLoose("", commandTitle ?? defaultTitleFormatted, ""));
+		program.exitOverride(handleCommanderExit);
+		installParseVersionInterceptor(program, { versionInjection: {
+			normalizedVersion,
+			pkgNameFormatted: resolvedPackageNameFormatted
+		} });
+	}
+	program.error = function(message) {
+		let errMsg = message.replace(/^error:\s*/i, "");
+		errMsg = errMsg.trim().replace(/\.*$/, "") + ".";
+		const { disableUsage } = getInternalState(program);
+		const { defaultTitleFormatted, dynamicUsage, help } = resolveCliPresentationMeta({
+			program,
+			title,
+			commandName: __commandName
+		});
+		const printOut = [
+			isNonEmptyString(title) ? title : defaultTitleFormatted,
+			"",
+			`${picocolors.bold(`${picocolors.red(`${ICONS.error} Error`)}`)} ${picocolors.redBright(errMsg)}`
+		];
+		if (!disableUsage && isNonEmptyString(dynamicUsage)) printOut.push("", picocolors.bold("Usage:"), `  ${picocolors.reset(picocolors.gray(dynamicUsage))}`);
+		if (!help.disabled) printOut.push("", `${picocolors.dim("Run")} ${picocolors.cyanBright(help.flags)} ${picocolors.dim(help.description)}`);
+		console.error(joinLinesLoose(...printOut));
+		process.exit(1);
+	};
+	return program;
+}
+const cliProgram = new CliCommand();
+var CliCommanderError = class extends CommanderError {
+	constructor(exitCode, code, message) {
+		super(exitCode, code, message);
+	}
+};
+var CliInvalidArgumentError = class extends InvalidArgumentError {
+	constructor(message) {
+		super(message);
+	}
+};
+var CliInvalidOptionArgumentError = class extends InvalidOptionArgumentError {
+	constructor(message) {
+		super(message);
+	}
+};
+const cliCreateArgument = (name, description) => new CliArgument(name, description);
+const cliCreateCommand = (name) => new CliCommand(name);
+const cliCreateOption = (arg, description) => new CliOption(arg, description);
+export { CliArgument, CliCommand, CliCommanderError, CliHelp, CliInvalidArgumentError, CliInvalidOptionArgumentError, CliOption, CommandIdentity, applyCommanderUi, cliCreateArgument, cliCreateCommand, cliCreateOption, cliProgram, createBaseProgram, formatCommanderError, getCommanderErrorCode, handleCommanderExit, isCommanderError };
+//# sourceMappingURL=index.js.map