@clerc/plugin-completions 1.0.0-beta.24 → 1.0.0-beta.25

package/dist/index.js

@@ -1,152 +1,1582 @@
-import { DOUBLE_DASH, Types, definePlugin, normalizeFlagValue, resolveCommand } from "@clerc/core";
-import tabtab, { getShellFromEnv } from "@pnpm/tabtab";
+import t from "@bomb.sh/tab";
+import { Clerc, NoCommandSpecifiedError, NoSuchCommandError, Types, definePlugin, normalizeFlagValue, resolveCommand } from "@clerc/core";
+import tty from "node:tty";
 
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget, symbols) => {
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+		secondTarget && __defProp(secondTarget, Symbol.toStringTag, { value: "Module" });
+	}
+	__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default");
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
 //#region ../utils/src/index.ts
 const toArray = (a) => Array.isArray(a) ? a : [a];
+function joinWithAnd(values) {
+	if (values.length === 0) return "";
+	if (values.length === 1) return values[0];
+	const last = values.pop();
+	return `${values.join(", ")} and ${last}`;
+}
 const kebabCase = (s) => s.replace(/([A-Z])/g, (_, c) => `-${c.toLowerCase()}`);
 const formatFlagName = (n) => n.length <= 1 ? `-${n}` : `--${kebabCase(n)}`;
+const formatVersion = (v) => v.length === 0 ? "" : v.startsWith("v") ? v : `v${v}`;
+const isTruthy = Boolean;
+const objectIsEmpty = (obj) => Object.keys(obj).length === 0;
+
+//#endregion
+//#region ../plugin-help/src/utils.ts
+function formatTypeValue(type) {
+	if (typeof type === "function") return type.display ?? type.name;
+	const innerType = type[0];
+	return `Array<${innerType.displayName ?? innerType.name}>`;
+}
+function formatFlagDefault(value) {
+	if (typeof value === "function" && "display" in value && value.display) return value.display;
+	return String(value);
+}
+function formatCommandName(name) {
+	if (name === "") return "(root)";
+	return name;
+}
+
+//#endregion
+//#region ../plugin-help/src/formatters.ts
+const defaultFormatters = {
+	formatTypeValue,
+	formatFlagDefault
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/ansi-regex@6.1.0/node_modules/ansi-regex/index.js
+function ansiRegex({ onlyFirst = false } = {}) {
+	const pattern = [`[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?(?:\\u0007|\\u001B\\u005C|\\u009C))`, "(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))"].join("|");
+	return new RegExp(pattern, onlyFirst ? void 0 : "g");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/strip-ansi@7.1.0/node_modules/strip-ansi/index.js
+const regex = ansiRegex();
+function stripAnsi(string) {
+	if (typeof string !== "string") throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
+	return string.replace(regex, "");
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/get-east-asian-width@1.3.0/node_modules/get-east-asian-width/lookup.js
+function isAmbiguous(x) {
+	return x === 161 || x === 164 || x === 167 || x === 168 || x === 170 || x === 173 || x === 174 || x >= 176 && x <= 180 || x >= 182 && x <= 186 || x >= 188 && x <= 191 || x === 198 || x === 208 || x === 215 || x === 216 || x >= 222 && x <= 225 || x === 230 || x >= 232 && x <= 234 || x === 236 || x === 237 || x === 240 || x === 242 || x === 243 || x >= 247 && x <= 250 || x === 252 || x === 254 || x === 257 || x === 273 || x === 275 || x === 283 || x === 294 || x === 295 || x === 299 || x >= 305 && x <= 307 || x === 312 || x >= 319 && x <= 322 || x === 324 || x >= 328 && x <= 331 || x === 333 || x === 338 || x === 339 || x === 358 || x === 359 || x === 363 || x === 462 || x === 464 || x === 466 || x === 468 || x === 470 || x === 472 || x === 474 || x === 476 || x === 593 || x === 609 || x === 708 || x === 711 || x >= 713 && x <= 715 || x === 717 || x === 720 || x >= 728 && x <= 731 || x === 733 || x === 735 || x >= 768 && x <= 879 || x >= 913 && x <= 929 || x >= 931 && x <= 937 || x >= 945 && x <= 961 || x >= 963 && x <= 969 || x === 1025 || x >= 1040 && x <= 1103 || x === 1105 || x === 8208 || x >= 8211 && x <= 8214 || x === 8216 || x === 8217 || x === 8220 || x === 8221 || x >= 8224 && x <= 8226 || x >= 8228 && x <= 8231 || x === 8240 || x === 8242 || x === 8243 || x === 8245 || x === 8251 || x === 8254 || x === 8308 || x === 8319 || x >= 8321 && x <= 8324 || x === 8364 || x === 8451 || x === 8453 || x === 8457 || x === 8467 || x === 8470 || x === 8481 || x === 8482 || x === 8486 || x === 8491 || x === 8531 || x === 8532 || x >= 8539 && x <= 8542 || x >= 8544 && x <= 8555 || x >= 8560 && x <= 8569 || x === 8585 || x >= 8592 && x <= 8601 || x === 8632 || x === 8633 || x === 8658 || x === 8660 || x === 8679 || x === 8704 || x === 8706 || x === 8707 || x === 8711 || x === 8712 || x === 8715 || x === 8719 || x === 8721 || x === 8725 || x === 8730 || x >= 8733 && x <= 8736 || x === 8739 || x === 8741 || x >= 8743 && x <= 8748 || x === 8750 || x >= 8756 && x <= 8759 || x === 8764 || x === 8765 || x === 8776 || x === 8780 || x === 8786 || x === 8800 || x === 8801 || x >= 8804 && x <= 8807 || x === 8810 || x === 8811 || x === 8814 || x === 8815 || x === 8834 || x === 8835 || x === 8838 || x === 8839 || x === 8853 || x === 8857 || x === 8869 || x === 8895 || x === 8978 || x >= 9312 && x <= 9449 || x >= 9451 && x <= 9547 || x >= 9552 && x <= 9587 || x >= 9600 && x <= 9615 || x >= 9618 && x <= 9621 || x === 9632 || x === 9633 || x >= 9635 && x <= 9641 || x === 9650 || x === 9651 || x === 9654 || x === 9655 || x === 9660 || x === 9661 || x === 9664 || x === 9665 || x >= 9670 && x <= 9672 || x === 9675 || x >= 9678 && x <= 9681 || x >= 9698 && x <= 9701 || x === 9711 || x === 9733 || x === 9734 || x === 9737 || x === 9742 || x === 9743 || x === 9756 || x === 9758 || x === 9792 || x === 9794 || x === 9824 || x === 9825 || x >= 9827 && x <= 9829 || x >= 9831 && x <= 9834 || x === 9836 || x === 9837 || x === 9839 || x === 9886 || x === 9887 || x === 9919 || x >= 9926 && x <= 9933 || x >= 9935 && x <= 9939 || x >= 9941 && x <= 9953 || x === 9955 || x === 9960 || x === 9961 || x >= 9963 && x <= 9969 || x === 9972 || x >= 9974 && x <= 9977 || x === 9979 || x === 9980 || x === 9982 || x === 9983 || x === 10045 || x >= 10102 && x <= 10111 || x >= 11094 && x <= 11097 || x >= 12872 && x <= 12879 || x >= 57344 && x <= 63743 || x >= 65024 && x <= 65039 || x === 65533 || x >= 127232 && x <= 127242 || x >= 127248 && x <= 127277 || x >= 127280 && x <= 127337 || x >= 127344 && x <= 127373 || x === 127375 || x === 127376 || x >= 127387 && x <= 127404 || x >= 917760 && x <= 917999 || x >= 983040 && x <= 1048573 || x >= 1048576 && x <= 1114109;
+}
+function isFullWidth(x) {
+	return x === 12288 || x >= 65281 && x <= 65376 || x >= 65504 && x <= 65510;
+}
+function isWide(x) {
+	return x >= 4352 && x <= 4447 || x === 8986 || x === 8987 || x === 9001 || x === 9002 || x >= 9193 && x <= 9196 || x === 9200 || x === 9203 || x === 9725 || x === 9726 || x === 9748 || x === 9749 || x >= 9776 && x <= 9783 || x >= 9800 && x <= 9811 || x === 9855 || x >= 9866 && x <= 9871 || x === 9875 || x === 9889 || x === 9898 || x === 9899 || x === 9917 || x === 9918 || x === 9924 || x === 9925 || x === 9934 || x === 9940 || x === 9962 || x === 9970 || x === 9971 || x === 9973 || x === 9978 || x === 9981 || x === 9989 || x === 9994 || x === 9995 || x === 10024 || x === 10060 || x === 10062 || x >= 10067 && x <= 10069 || x === 10071 || x >= 10133 && x <= 10135 || x === 10160 || x === 10175 || x === 11035 || x === 11036 || x === 11088 || x === 11093 || x >= 11904 && x <= 11929 || x >= 11931 && x <= 12019 || x >= 12032 && x <= 12245 || x >= 12272 && x <= 12287 || x >= 12289 && x <= 12350 || x >= 12353 && x <= 12438 || x >= 12441 && x <= 12543 || x >= 12549 && x <= 12591 || x >= 12593 && x <= 12686 || x >= 12688 && x <= 12773 || x >= 12783 && x <= 12830 || x >= 12832 && x <= 12871 || x >= 12880 && x <= 42124 || x >= 42128 && x <= 42182 || x >= 43360 && x <= 43388 || x >= 44032 && x <= 55203 || x >= 63744 && x <= 64255 || x >= 65040 && x <= 65049 || x >= 65072 && x <= 65106 || x >= 65108 && x <= 65126 || x >= 65128 && x <= 65131 || x >= 94176 && x <= 94180 || x === 94192 || x === 94193 || x >= 94208 && x <= 100343 || x >= 100352 && x <= 101589 || x >= 101631 && x <= 101640 || x >= 110576 && x <= 110579 || x >= 110581 && x <= 110587 || x === 110589 || x === 110590 || x >= 110592 && x <= 110882 || x === 110898 || x >= 110928 && x <= 110930 || x === 110933 || x >= 110948 && x <= 110951 || x >= 110960 && x <= 111355 || x >= 119552 && x <= 119638 || x >= 119648 && x <= 119670 || x === 126980 || x === 127183 || x === 127374 || x >= 127377 && x <= 127386 || x >= 127488 && x <= 127490 || x >= 127504 && x <= 127547 || x >= 127552 && x <= 127560 || x === 127568 || x === 127569 || x >= 127584 && x <= 127589 || x >= 127744 && x <= 127776 || x >= 127789 && x <= 127797 || x >= 127799 && x <= 127868 || x >= 127870 && x <= 127891 || x >= 127904 && x <= 127946 || x >= 127951 && x <= 127955 || x >= 127968 && x <= 127984 || x === 127988 || x >= 127992 && x <= 128062 || x === 128064 || x >= 128066 && x <= 128252 || x >= 128255 && x <= 128317 || x >= 128331 && x <= 128334 || x >= 128336 && x <= 128359 || x === 128378 || x === 128405 || x === 128406 || x === 128420 || x >= 128507 && x <= 128591 || x >= 128640 && x <= 128709 || x === 128716 || x >= 128720 && x <= 128722 || x >= 128725 && x <= 128727 || x >= 128732 && x <= 128735 || x === 128747 || x === 128748 || x >= 128756 && x <= 128764 || x >= 128992 && x <= 129003 || x === 129008 || x >= 129292 && x <= 129338 || x >= 129340 && x <= 129349 || x >= 129351 && x <= 129535 || x >= 129648 && x <= 129660 || x >= 129664 && x <= 129673 || x >= 129679 && x <= 129734 || x >= 129742 && x <= 129756 || x >= 129759 && x <= 129769 || x >= 129776 && x <= 129784 || x >= 131072 && x <= 196605 || x >= 196608 && x <= 262141;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/get-east-asian-width@1.3.0/node_modules/get-east-asian-width/index.js
+function validate(codePoint) {
+	if (!Number.isSafeInteger(codePoint)) throw new TypeError(`Expected a code point, got \`${typeof codePoint}\`.`);
+}
+function eastAsianWidth(codePoint, { ambiguousAsWide = false } = {}) {
+	validate(codePoint);
+	if (isFullWidth(codePoint) || isWide(codePoint) || ambiguousAsWide && isAmbiguous(codePoint)) return 2;
+	return 1;
+}
 
 //#endregion
-//#region src/complete.ts
-function splitCommand(cmd) {
-	const args = [];
-	let current = "";
-	let quote = null;
-	let escape = false;
-	for (const char of cmd) {
-		if (escape) {
-			current += char;
-			escape = false;
+//#region ../../node_modules/.pnpm/string-width@8.1.0/node_modules/string-width/index.js
+/**
+Logic:
+- Segment graphemes to match how terminals render clusters.
+- Width rules:
+1. Skip non-printing clusters (Default_Ignorable, Control, pure Mark, lone Surrogates). Tabs are ignored by design.
+2. RGI emoji clusters (\p{RGI_Emoji}) are double-width.
+3. Otherwise use East Asian Width of the cluster’s first visible code point, and add widths for trailing Halfwidth/Fullwidth Forms within the same cluster (e.g., dakuten/handakuten/prolonged sound mark).
+*/
+const segmenter = new Intl.Segmenter();
+const zeroWidthClusterRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
+const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+function baseVisible(segment) {
+	return segment.replace(leadingNonPrintingRegex, "");
+}
+function isZeroWidthCluster(segment) {
+	return zeroWidthClusterRegex.test(segment);
+}
+function trailingHalfwidthWidth(segment, eastAsianWidthOptions) {
+	let extra = 0;
+	if (segment.length > 1) {
+		for (const char of segment.slice(1)) if (char >= "＀" && char <= "￯") extra += eastAsianWidth(char.codePointAt(0), eastAsianWidthOptions);
+	}
+	return extra;
+}
+function stringWidth(input, options = {}) {
+	if (typeof input !== "string" || input.length === 0) return 0;
+	const { ambiguousIsNarrow = true, countAnsiEscapeCodes = false } = options;
+	let string = input;
+	if (!countAnsiEscapeCodes) string = stripAnsi(string);
+	if (string.length === 0) return 0;
+	let width = 0;
+	const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+	for (const { segment } of segmenter.segment(string)) {
+		if (isZeroWidthCluster(segment)) continue;
+		if (rgiEmojiRegex.test(segment)) {
+			width += 2;
 			continue;
 		}
-		if (char === "\\") {
-			escape = true;
-			continue;
+		const codePoint = baseVisible(segment).codePointAt(0);
+		width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+		width += trailingHalfwidthWidth(segment, eastAsianWidthOptions);
+	}
+	return width;
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/text-table@0.2.0/node_modules/text-table/index.js
+var require_text_table = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = function(rows_, opts) {
+		if (!opts) opts = {};
+		var hsep = opts.hsep === void 0 ? "  " : opts.hsep;
+		var align = opts.align || [];
+		var stringLength = opts.stringLength || function(s) {
+			return String(s).length;
+		};
+		var dotsizes = reduce(rows_, function(acc, row) {
+			forEach(row, function(c, ix) {
+				var n = dotindex(c);
+				if (!acc[ix] || n > acc[ix]) acc[ix] = n;
+			});
+			return acc;
+		}, []);
+		var rows = map(rows_, function(row) {
+			return map(row, function(c_, ix) {
+				var c = String(c_);
+				if (align[ix] === ".") {
+					var index = dotindex(c);
+					var size = dotsizes[ix] + (/\./.test(c) ? 1 : 2) - (stringLength(c) - index);
+					return c + Array(size).join(" ");
+				} else return c;
+			});
+		});
+		var sizes = reduce(rows, function(acc, row) {
+			forEach(row, function(c, ix) {
+				var n = stringLength(c);
+				if (!acc[ix] || n > acc[ix]) acc[ix] = n;
+			});
+			return acc;
+		}, []);
+		return map(rows, function(row) {
+			return map(row, function(c, ix) {
+				var n = sizes[ix] - stringLength(c) || 0;
+				var s = Array(Math.max(n + 1, 1)).join(" ");
+				if (align[ix] === "r" || align[ix] === ".") return s + c;
+				if (align[ix] === "c") return Array(Math.ceil(n / 2 + 1)).join(" ") + c + Array(Math.floor(n / 2 + 1)).join(" ");
+				return c + s;
+			}).join(hsep).replace(/\s+$/, "");
+		}).join("\n");
+	};
+	function dotindex(c) {
+		var m = /\.[^.]*$/.exec(c);
+		return m ? m.index + 1 : c.length;
+	}
+	function reduce(xs, f, init) {
+		if (xs.reduce) return xs.reduce(f, init);
+		var i = 0;
+		var acc = arguments.length >= 3 ? init : xs[i++];
+		for (; i < xs.length; i++) f(acc, xs[i], i);
+		return acc;
+	}
+	function forEach(xs, f) {
+		if (xs.forEach) return xs.forEach(f);
+		for (var i = 0; i < xs.length; i++) f.call(xs, xs[i], i);
+	}
+	function map(xs, f) {
+		if (xs.map) return xs.map(f);
+		var res = [];
+		for (var i = 0; i < xs.length; i++) res.push(f.call(xs, xs[i], i));
+		return res;
+	}
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/yoctocolors@2.1.2/node_modules/yoctocolors/base.js
+const hasColors = tty?.WriteStream?.prototype?.hasColors?.() ?? false;
+const format = (open, close) => {
+	if (!hasColors) return (input) => input;
+	const openCode = `\u001B[${open}m`;
+	const closeCode = `\u001B[${close}m`;
+	return (input) => {
+		const string = input + "";
+		let index = string.indexOf(closeCode);
+		if (index === -1) return openCode + string + closeCode;
+		let result = openCode;
+		let lastIndex = 0;
+		const replaceCode = (close === 22 ? closeCode : "") + openCode;
+		while (index !== -1) {
+			result += string.slice(lastIndex, index) + replaceCode;
+			lastIndex = index + closeCode.length;
+			index = string.indexOf(closeCode, lastIndex);
+		}
+		result += string.slice(lastIndex) + closeCode;
+		return result;
+	};
+};
+const reset = format(0, 0);
+const bold = format(1, 22);
+const dim = format(2, 22);
+const italic = format(3, 23);
+const underline = format(4, 24);
+const overline = format(53, 55);
+const inverse = format(7, 27);
+const hidden = format(8, 28);
+const strikethrough = format(9, 29);
+const black = format(30, 39);
+const red = format(31, 39);
+const green = format(32, 39);
+const yellow = format(33, 39);
+const blue = format(34, 39);
+const magenta = format(35, 39);
+const cyan = format(36, 39);
+const white = format(37, 39);
+const gray = format(90, 39);
+const bgBlack = format(40, 49);
+const bgRed = format(41, 49);
+const bgGreen = format(42, 49);
+const bgYellow = format(43, 49);
+const bgBlue = format(44, 49);
+const bgMagenta = format(45, 49);
+const bgCyan = format(46, 49);
+const bgWhite = format(47, 49);
+const bgGray = format(100, 49);
+const redBright = format(91, 39);
+const greenBright = format(92, 39);
+const yellowBright = format(93, 39);
+const blueBright = format(94, 39);
+const magentaBright = format(95, 39);
+const cyanBright = format(96, 39);
+const whiteBright = format(97, 39);
+const bgRedBright = format(101, 49);
+const bgGreenBright = format(102, 49);
+const bgYellowBright = format(103, 49);
+const bgBlueBright = format(104, 49);
+const bgMagentaBright = format(105, 49);
+const bgCyanBright = format(106, 49);
+const bgWhiteBright = format(107, 49);
+
+//#endregion
+//#region ../plugin-help/src/renderer.ts
+var import_text_table = /* @__PURE__ */ __toESM(require_text_table(), 1);
+const DEFAULT_GROUP_KEY = "default";
+const table = (items) => (0, import_text_table.default)(items, { stringLength: stringWidth });
+const splitTable = (items) => table(items).split("\n");
+const DELIMITER = "-";
+const INDENT = " ".repeat(2);
+const withIndent = (str) => `${INDENT}${str}`;
+function groupDefinitionsToMap(definitions) {
+	const map$1 = /* @__PURE__ */ new Map();
+	if (definitions) for (const [key, name] of definitions) map$1.set(key, name);
+	return map$1;
+}
+function validateGroup(group, groupMap, itemType, itemName) {
+	if (group && group !== DEFAULT_GROUP_KEY && !groupMap.has(group)) throw new Error(`Unknown ${itemType} group "${group}" for "${itemName}". Available groups: ${[...groupMap.keys()].join(", ") || "(none)"}`);
+}
+var HelpRenderer = class {
+	_command;
+	get _commandGroups() {
+		return groupDefinitionsToMap(this._getGroups().commands);
+	}
+	get _flagGroups() {
+		return groupDefinitionsToMap(this._getGroups().flags);
+	}
+	get _globalFlagGroups() {
+		return groupDefinitionsToMap(this._getGroups().globalFlags);
+	}
+	constructor(_formatters, _cli, _globalFlags, _getGroups, _getExamples, _notes) {
+		this._formatters = _formatters;
+		this._cli = _cli;
+		this._globalFlags = _globalFlags;
+		this._getGroups = _getGroups;
+		this._getExamples = _getExamples;
+		this._notes = _notes;
+	}
+	setCommand(command) {
+		if (command) {
+			this._command = command;
+			this._getExamples = () => command?.help?.examples;
+			this._notes = command?.help?.notes;
+		}
+	}
+	renderSections(sections) {
+		return sections.filter(isTruthy).map((section) => {
+			const body = Array.isArray(section.body) ? section.body.filter((s) => s !== void 0).join("\n") : section.body;
+			if (!section.title) return body;
+			return `${underline(bold(section.title))}\n${body.split("\n").map(withIndent).join("\n")}`;
+		}).join("\n\n");
+	}
+	render() {
+		const sections = [
+			this.renderHeader(),
+			this.renderUsage(),
+			this.renderParameters(),
+			this.renderCommandFlags(),
+			this.renderGlobalFlags(),
+			this.renderCommands(),
+			this.renderExamples(),
+			this.renderNotes()
+		];
+		return this.renderSections(sections);
+	}
+	renderHeader() {
+		const { _name, _version, _description } = this._cli;
+		const command = this._command;
+		const description = command ? command.description : _description;
+		const formattedCommandName = command?.name ? ` ${bold(command.name)}` : "";
+		const headerLine = command ? `${dim(_name)}${formattedCommandName}` : `${bold(_name)} ${formatVersion(_version)}`;
+		const alias = command?.alias ? `Alias${toArray(command.alias).length > 1 ? "es" : ""}: ${toArray(command.alias).map((a) => bold(a)).join(", ")}` : void 0;
+		return { body: [`${headerLine}${description ? ` ${DELIMITER} ${description}` : ""}`, alias] };
+	}
+	renderUsage() {
+		const { _scriptName } = this._cli;
+		const command = this._command;
+		let usage = `$ ${_scriptName}`;
+		if (command) {
+			if (command.name) usage += ` ${command.name}`;
+			if (command.parameters) usage += ` ${command.parameters.map((p$1) => typeof p$1 === "string" ? p$1 : p$1.key).join(" ")}`;
+		} else if (this._cli._commands.size > 0 && !(this._cli._commands.has("") && this._cli._commands.size === 1)) usage += this._cli._commands.has("") ? " [command]" : " <command>";
+		if (command?.flags && !objectIsEmpty(command.flags) || !objectIsEmpty(this._globalFlags)) usage += " [flags]";
+		return {
+			title: "Usage",
+			body: [usage]
+		};
+	}
+	renderParameters() {
+		const command = this._command;
+		if (!command?.parameters || command.parameters.length === 0) return;
+		return {
+			title: "Parameters",
+			body: splitTable(command.parameters.map((parameter) => {
+				const key = typeof parameter === "string" ? parameter : parameter.key;
+				const type = typeof parameter === "string" ? void 0 : parameter.type;
+				const description = typeof parameter === "string" ? void 0 : parameter.description;
+				return [
+					bold(key),
+					type ? this._formatters.formatTypeValue(type) : "string",
+					description
+				].filter(isTruthy);
+			}))
+		};
+	}
+	getSubcommands(parentCommandName) {
+		const subcommands = /* @__PURE__ */ new Map();
+		if (parentCommandName === "") return subcommands;
+		const prefix = `${parentCommandName} `;
+		for (const [name, command] of this._cli._commands) if (name.startsWith(prefix)) {
+			const subcommandName = name.slice(prefix.length);
+			subcommands.set(subcommandName, command);
+		}
+		return subcommands;
+	}
+	buildGroupedCommandsBody(commandsToShow, prefix) {
+		const groupedCommands = /* @__PURE__ */ new Map();
+		const defaultCommands = [];
+		let rootCommand = [];
+		for (const command of commandsToShow.values()) {
+			if (command.__isAlias || command.help?.show === false) continue;
+			const group = command.help?.group;
+			validateGroup(group, this._commandGroups, "command", command.name);
+			const item = [`${bold(formatCommandName(command.name.slice(prefix.length)))}${command.alias ? ` (${toArray(command.alias).join(", ")})` : ""}`, command.description].filter(isTruthy);
+			if (command.name === "") rootCommand = item;
+			else if (group && group !== DEFAULT_GROUP_KEY) {
+				const groupItems = groupedCommands.get(group) ?? [];
+				groupItems.push(item);
+				groupedCommands.set(group, groupItems);
+			} else defaultCommands.push(item);
 		}
-		if (quote) if (char === quote) quote = null;
-		else current += char;
-		else if (char === "\"" || char === "'") quote = char;
-		else if (/\s/.test(char)) {
-			if (current) {
-				args.push(current);
-				current = "";
+		const body = [];
+		const defaultGroup = [];
+		if (rootCommand.length > 0) defaultGroup.push(rootCommand);
+		if (defaultCommands.length > 0) defaultGroup.push(...defaultCommands);
+		if (defaultGroup.length > 0) body.push(...splitTable(defaultGroup));
+		for (const [key, name] of this._commandGroups) {
+			const items = groupedCommands.get(key);
+			if (items && items.length > 0) {
+				if (body.length > 0) body.push("");
+				body.push(`${dim(name)}`);
+				body.push(...splitTable(items).map(withIndent));
 			}
-		} else current += char;
-	}
-	if (current) args.push(current);
-	return args;
-}
-async function getCompletion(cli, env) {
-	const inputArgv = splitCommand(env.partial.slice(0, env.partial.length - env.lastPartial.length)).slice(1);
-	if (inputArgv.includes(DOUBLE_DASH)) return [];
-	const [command, commandName] = resolveCommand(cli._commands, inputArgv);
-	if (env.lastPartial.startsWith("-")) {
-		const flags = command ? {
-			...cli._globalFlags,
-			...command.flags
-		} : cli._globalFlags;
-		const candidates$1 = [];
-		for (const [name, def] of Object.entries(flags)) {
-			const normalized = normalizeFlagValue(def);
-			candidates$1.push({
-				name: formatFlagName(name),
-				description: normalized.description
-			});
-			if (normalized.alias) {
-				const aliases = toArray(normalized.alias);
-				for (const alias of aliases) candidates$1.push({
-					name: formatFlagName(alias),
-					description: normalized.description
+		}
+		return body;
+	}
+	renderAvailableSubcommands(parentCommandName) {
+		const subcommands = this.getSubcommands(parentCommandName);
+		if (subcommands.size === 0) return "";
+		const prefix = `${parentCommandName} `;
+		const body = this.buildGroupedCommandsBody(subcommands, prefix);
+		if (body.length === 0) return "";
+		const sections = [{ body: `${this._cli._name} ${bold(parentCommandName)} not found` }, {
+			title: "Available Subcommands",
+			body
+		}];
+		return this.renderSections(sections);
+	}
+	renderCommands() {
+		const commands = this._cli._commands;
+		let commandsToShow;
+		let title = "Commands";
+		let prefix = "";
+		if (this._command) {
+			prefix = this._command.name ? `${this._command.name} ` : "";
+			title = "Subcommands";
+			commandsToShow = this.getSubcommands(this._command.name);
+			if (commandsToShow.size === 0) return;
+		} else commandsToShow = commands;
+		if (commandsToShow.size === 0) return;
+		const body = this.buildGroupedCommandsBody(commandsToShow, prefix);
+		return {
+			title,
+			body
+		};
+	}
+	renderFlagItem(name, flag) {
+		flag = normalizeFlagValue(flag);
+		const flagName = formatFlagName(name);
+		const shortFlag = flag.short ? formatFlagName(flag.short) : "";
+		const type = this._formatters.formatTypeValue(flag.type);
+		return [
+			bold([flagName, shortFlag].filter(Boolean).join(", ")),
+			dim(type),
+			flag.description,
+			flag.default !== void 0 && dim(`[default: ${bold(this._formatters.formatFlagDefault(flag.default))}]`)
+		].filter(isTruthy);
+	}
+	renderGroupedFlags(flags, groupMap, itemType) {
+		const groupedFlags = /* @__PURE__ */ new Map();
+		const defaultFlags = [];
+		for (const [name, flag] of Object.entries(flags)) {
+			const group = flag.help?.group;
+			validateGroup(group, groupMap, itemType, name);
+			const item = this.renderFlagItem(name, flag);
+			if (group && group !== DEFAULT_GROUP_KEY) {
+				const groupItems = groupedFlags.get(group) ?? [];
+				groupItems.push(item);
+				groupedFlags.set(group, groupItems);
+			} else defaultFlags.push(item);
+		}
+		const body = [];
+		if (defaultFlags.length > 0) body.push(...splitTable(defaultFlags));
+		for (const [key, name] of groupMap) {
+			const items = groupedFlags.get(key);
+			if (items && items.length > 0) {
+				if (body.length > 0) body.push("");
+				body.push(`${dim(name)}`);
+				body.push(...splitTable(items).map(withIndent));
+			}
+		}
+		return body;
+	}
+	renderCommandFlags() {
+		const command = this._command;
+		if (!command?.flags || objectIsEmpty(command.flags)) return;
+		return {
+			title: "Flags",
+			body: this.renderGroupedFlags(command.flags, this._flagGroups, "flag")
+		};
+	}
+	renderGlobalFlags() {
+		if (!this._globalFlags || objectIsEmpty(this._globalFlags)) return;
+		return {
+			title: "Global Flags",
+			body: this.renderGroupedFlags(this._globalFlags, this._globalFlagGroups, "global flag")
+		};
+	}
+	renderNotes() {
+		if (!this._notes?.length) return;
+		return {
+			title: "Notes",
+			body: this._notes
+		};
+	}
+	renderExamples() {
+		const examples = this._getExamples();
+		if (!examples?.length) return;
+		return {
+			title: "Examples",
+			body: splitTable(examples.map(([command, description]) => {
+				return [
+					command,
+					DELIMITER,
+					description
+				];
+			}))
+		};
+	}
+};
+
+//#endregion
+//#region ../plugin-help/src/store.ts
+function addStoreApi(cli, { groups }) {
+	cli.store.help = { addGroup: (options) => {
+		if (options.commands) groups.commands = [...groups.commands ?? [], ...options.commands];
+		if (options.flags) groups.flags = [...groups.flags ?? [], ...options.flags];
+		if (options.globalFlags) groups.globalFlags = [...groups.globalFlags ?? [], ...options.globalFlags];
+	} };
+}
+
+//#endregion
+//#region ../plugin-help/src/index.ts
+const helpPlugin = ({ command = true, flag = true, showHelpWhenNoCommandSpecified = true, notes, examples, banner, formatters, groups = {} } = {}) => definePlugin({ setup: (cli) => {
+	addStoreApi(cli, { groups });
+	const mergedFormatters = {
+		...defaultFormatters,
+		...formatters
+	};
+	const generalHelpNotes = [
+		"If no command is specified, show help for the CLI.",
+		"If a command is specified, show help for the command.",
+		flag && "-h is an alias for --help."
+	].filter(isTruthy);
+	const getGeneralHelpExamples = () => [
+		command && [`$ ${cli._scriptName} help`, "Show help"],
+		command && [`$ ${cli._scriptName} help <command>`, "Show help for a specific command"],
+		flag && [`$ ${cli._scriptName} <command> --help`, "Show help for a specific command"]
+	].filter(isTruthy);
+	const effectiveNotes = notes ?? generalHelpNotes;
+	const getEffectiveExamples = () => examples ?? getGeneralHelpExamples();
+	function printHelp(s) {
+		if (banner) console.log(banner);
+		console.log(s);
+	}
+	const renderer = new HelpRenderer(mergedFormatters, cli, cli._globalFlags, () => groups, getEffectiveExamples, effectiveNotes);
+	function tryPrintSubcommandsHelp(commandName) {
+		const subcommandsOutput = renderer.renderAvailableSubcommands(commandName);
+		if (subcommandsOutput) {
+			printHelp(subcommandsOutput);
+			return true;
+		}
+		return false;
+	}
+	if (command) cli.command("help", "Show help", {
+		parameters: ["[command...]"],
+		help: {
+			notes: generalHelpNotes,
+			examples: getGeneralHelpExamples()
+		}
+	}).on("help", (ctx) => {
+		const commandName = ctx.parameters.command;
+		let command$1;
+		if (commandName.length > 0) {
+			[command$1] = resolveCommand(cli._commands, commandName);
+			if (!command$1) {
+				const parentCommandName = commandName.join(" ");
+				if (tryPrintSubcommandsHelp(parentCommandName)) return;
+				throw new NoSuchCommandError(parentCommandName);
+			}
+		}
+		renderer.setCommand(command$1);
+		printHelp(renderer.render());
+	});
+	if (flag) cli.globalFlag("help", "Show help", {
+		short: "h",
+		type: Boolean,
+		default: false
+	});
+	cli.interceptor({
+		enforce: "post",
+		handler: async (ctx, next) => {
+			if (ctx.flags.help) {
+				const command$1 = ctx.command;
+				if (!command$1 && ctx.rawParsed.parameters.length > 0) {
+					if (tryPrintSubcommandsHelp(ctx.rawParsed.parameters.join(" "))) return;
+					await next();
+				}
+				renderer.setCommand(command$1);
+				printHelp(renderer.render());
+			} else if (showHelpWhenNoCommandSpecified && !ctx.command && ctx.rawParsed.parameters.length === 0) printHelp(renderer.render());
+			else await next();
+		}
+	});
+} });
+
+//#endregion
+//#region ../plugin-version/src/index.ts
+const versionPlugin = ({ command = true, flag = true } = {}) => definePlugin({ setup: (cli) => {
+	const formattedVersion = formatVersion(cli._version);
+	if (command) cli.command("version", "Prints current version", {}).on("version", () => {
+		console.log(formattedVersion);
+	});
+	if (flag) cli.globalFlag("version", "Prints current version", {
+		short: "V",
+		type: Boolean,
+		default: false
+	}).interceptor({
+		enforce: "pre",
+		handler: async (ctx, next) => {
+			if (ctx.flags.version) console.log(formattedVersion);
+			else await next();
+		}
+	});
+} });
+
+//#endregion
+//#region ../../node_modules/.pnpm/picocolors@1.1.1/node_modules/picocolors/picocolors.js
+var require_picocolors = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let p = process || {}, argv = p.argv || [], env = p.env || {};
+	let isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+	let formatter = (open, close, replace = open) => (input) => {
+		let string = "" + input, index = string.indexOf(close, open.length);
+		return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+	};
+	let replaceClose = (string, close, replace, index) => {
+		let result = "", cursor = 0;
+		do {
+			result += string.substring(cursor, index) + replace;
+			cursor = index + close.length;
+			index = string.indexOf(close, cursor);
+		} while (~index);
+		return result + string.substring(cursor);
+	};
+	let createColors = (enabled = isColorSupported) => {
+		let f = enabled ? formatter : () => String;
+		return {
+			isColorSupported: enabled,
+			reset: f("\x1B[0m", "\x1B[0m"),
+			bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+			dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+			italic: f("\x1B[3m", "\x1B[23m"),
+			underline: f("\x1B[4m", "\x1B[24m"),
+			inverse: f("\x1B[7m", "\x1B[27m"),
+			hidden: f("\x1B[8m", "\x1B[28m"),
+			strikethrough: f("\x1B[9m", "\x1B[29m"),
+			black: f("\x1B[30m", "\x1B[39m"),
+			red: f("\x1B[31m", "\x1B[39m"),
+			green: f("\x1B[32m", "\x1B[39m"),
+			yellow: f("\x1B[33m", "\x1B[39m"),
+			blue: f("\x1B[34m", "\x1B[39m"),
+			magenta: f("\x1B[35m", "\x1B[39m"),
+			cyan: f("\x1B[36m", "\x1B[39m"),
+			white: f("\x1B[37m", "\x1B[39m"),
+			gray: f("\x1B[90m", "\x1B[39m"),
+			bgBlack: f("\x1B[40m", "\x1B[49m"),
+			bgRed: f("\x1B[41m", "\x1B[49m"),
+			bgGreen: f("\x1B[42m", "\x1B[49m"),
+			bgYellow: f("\x1B[43m", "\x1B[49m"),
+			bgBlue: f("\x1B[44m", "\x1B[49m"),
+			bgMagenta: f("\x1B[45m", "\x1B[49m"),
+			bgCyan: f("\x1B[46m", "\x1B[49m"),
+			bgWhite: f("\x1B[47m", "\x1B[49m"),
+			blackBright: f("\x1B[90m", "\x1B[39m"),
+			redBright: f("\x1B[91m", "\x1B[39m"),
+			greenBright: f("\x1B[92m", "\x1B[39m"),
+			yellowBright: f("\x1B[93m", "\x1B[39m"),
+			blueBright: f("\x1B[94m", "\x1B[39m"),
+			magentaBright: f("\x1B[95m", "\x1B[39m"),
+			cyanBright: f("\x1B[96m", "\x1B[39m"),
+			whiteBright: f("\x1B[97m", "\x1B[39m"),
+			bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+			bgRedBright: f("\x1B[101m", "\x1B[49m"),
+			bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+			bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+			bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+			bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+			bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+			bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+		};
+	};
+	module.exports = createColors();
+	module.exports.createColors = createColors;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/kons@0.7.1/node_modules/kons/dist/utils-6230ae77.mjs
+var import_picocolors$1 = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+function parseStack(stack) {
+	return stack.split("\n").splice(1).map((l) => l.trim().replace("file://", ""));
+}
+function formatStack(stack) {
+	return `
+${parseStack(stack).map((line) => `  ${line.replace(/^at ([\s\S]+) \((.+)\)/, (_, m1, m2) => import_picocolors$1.default.gray(`at ${m1} (${import_picocolors$1.default.cyan(m2)})`))}`).join("\n")}`;
+}
+const NEWLINE_RE = /\r?\n/g;
+function formatMessage(messages) {
+	return messages.map((m) => {
+		if (typeof (m == null ? void 0 : m.stack) === "string") return [m.message, formatStack(m.stack)];
+		if (typeof m === "string") return m.split(NEWLINE_RE);
+		return m;
+	}).flat();
+}
+function createBadge(badgeType, bgColor) {
+	const upperType = badgeType.toUpperCase();
+	const bgColorFormatter = import_picocolors$1.default[bgColor];
+	return import_picocolors$1.default.bold(import_picocolors$1.default.inverse(bgColorFormatter(` ${upperType} `)));
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/kons@0.7.1/node_modules/kons/dist/index.mjs
+var import_picocolors = /* @__PURE__ */ __toESM(require_picocolors(), 1);
+function createFormatter(type, bgColor, { target = console.log, textColor, newline = true } = {}) {
+	const bgColorFormatter = import_picocolors.default[bgColor];
+	const textColorFormatter = textColor ? import_picocolors.default[textColor] : bgColorFormatter;
+	return (...messages) => {
+		const formattedMessages = formatMessage(messages);
+		const badge = createBadge(type, bgColor);
+		for (const message of formattedMessages) target(`${badge} ${textColorFormatter(message)}${newline ? "\n" : ""}`);
+	};
+}
+const log = createFormatter("log", "gray");
+const info = createFormatter("info", "blue", { target: console.info });
+const warn = createFormatter("warn", "yellow", { target: console.warn });
+const success = createFormatter("success", "green");
+const error = createFormatter("error", "red", { target: console.error });
+
+//#endregion
+//#region ../plugin-friendly-error/src/index.ts
+const friendlyErrorPlugin = ({ target = error } = {}) => definePlugin({ setup: (cli) => cli.errorHandler((err) => {
+	target(err.message);
+	process.exit(1);
+}) });
+
+//#endregion
+//#region ../../node_modules/.pnpm/fastest-levenshtein@1.0.16/node_modules/fastest-levenshtein/mod.js
+var require_fastest_levenshtein = /* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.distance = exports.closest = void 0;
+	var peq = new Uint32Array(65536);
+	var myers_32 = function(a, b) {
+		var n = a.length;
+		var m = b.length;
+		var lst = 1 << n - 1;
+		var pv = -1;
+		var mv = 0;
+		var sc = n;
+		var i = n;
+		while (i--) peq[a.charCodeAt(i)] |= 1 << i;
+		for (i = 0; i < m; i++) {
+			var eq = peq[b.charCodeAt(i)];
+			var xv = eq | mv;
+			eq |= (eq & pv) + pv ^ pv;
+			mv |= ~(eq | pv);
+			pv &= eq;
+			if (mv & lst) sc++;
+			if (pv & lst) sc--;
+			mv = mv << 1 | 1;
+			pv = pv << 1 | ~(xv | mv);
+			mv &= xv;
+		}
+		i = n;
+		while (i--) peq[a.charCodeAt(i)] = 0;
+		return sc;
+	};
+	var myers_x = function(b, a) {
+		var n = a.length;
+		var m = b.length;
+		var mhc = [];
+		var phc = [];
+		var hsize = Math.ceil(n / 32);
+		var vsize = Math.ceil(m / 32);
+		for (var i = 0; i < hsize; i++) {
+			phc[i] = -1;
+			mhc[i] = 0;
+		}
+		var j = 0;
+		for (; j < vsize - 1; j++) {
+			var mv_1 = 0;
+			var pv_1 = -1;
+			var start_1 = j * 32;
+			var vlen_1 = Math.min(32, m) + start_1;
+			for (var k = start_1; k < vlen_1; k++) peq[b.charCodeAt(k)] |= 1 << k;
+			for (var i = 0; i < n; i++) {
+				var eq = peq[a.charCodeAt(i)];
+				var pb = phc[i / 32 | 0] >>> i & 1;
+				var mb = mhc[i / 32 | 0] >>> i & 1;
+				var xv = eq | mv_1;
+				var xh = ((eq | mb) & pv_1) + pv_1 ^ pv_1 | eq | mb;
+				var ph = mv_1 | ~(xh | pv_1);
+				var mh = pv_1 & xh;
+				if (ph >>> 31 ^ pb) phc[i / 32 | 0] ^= 1 << i;
+				if (mh >>> 31 ^ mb) mhc[i / 32 | 0] ^= 1 << i;
+				ph = ph << 1 | pb;
+				mh = mh << 1 | mb;
+				pv_1 = mh | ~(xv | ph);
+				mv_1 = ph & xv;
+			}
+			for (var k = start_1; k < vlen_1; k++) peq[b.charCodeAt(k)] = 0;
+		}
+		var mv = 0;
+		var pv = -1;
+		var start = j * 32;
+		var vlen = Math.min(32, m - start) + start;
+		for (var k = start; k < vlen; k++) peq[b.charCodeAt(k)] |= 1 << k;
+		var score = m;
+		for (var i = 0; i < n; i++) {
+			var eq = peq[a.charCodeAt(i)];
+			var pb = phc[i / 32 | 0] >>> i & 1;
+			var mb = mhc[i / 32 | 0] >>> i & 1;
+			var xv = eq | mv;
+			var xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
+			var ph = mv | ~(xh | pv);
+			var mh = pv & xh;
+			score += ph >>> m - 1 & 1;
+			score -= mh >>> m - 1 & 1;
+			if (ph >>> 31 ^ pb) phc[i / 32 | 0] ^= 1 << i;
+			if (mh >>> 31 ^ mb) mhc[i / 32 | 0] ^= 1 << i;
+			ph = ph << 1 | pb;
+			mh = mh << 1 | mb;
+			pv = mh | ~(xv | ph);
+			mv = ph & xv;
+		}
+		for (var k = start; k < vlen; k++) peq[b.charCodeAt(k)] = 0;
+		return score;
+	};
+	var distance$1 = function(a, b) {
+		if (a.length < b.length) {
+			var tmp = b;
+			b = a;
+			a = tmp;
+		}
+		if (b.length === 0) return a.length;
+		if (a.length <= 32) return myers_32(a, b);
+		return myers_x(a, b);
+	};
+	exports.distance = distance$1;
+	var closest = function(str, arr) {
+		var min_distance = Infinity;
+		var min_index = 0;
+		for (var i = 0; i < arr.length; i++) {
+			var dist = distance$1(str, arr[i]);
+			if (dist < min_distance) {
+				min_distance = dist;
+				min_index = i;
+			}
+		}
+		return arr[min_index];
+	};
+	exports.closest = closest;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/lodash.deburr@4.1.0/node_modules/lodash.deburr/index.js
+var require_lodash = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	/**
+	* lodash (Custom Build) <https://lodash.com/>
+	* Build: `lodash modularize exports="npm" -o ./`
+	* Copyright jQuery Foundation and other contributors <https://jquery.org/>
+	* Released under MIT license <https://lodash.com/license>
+	* Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
+	* Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
+	*/
+	/** Used as references for various `Number` constants. */
+	var INFINITY = Infinity;
+	/** `Object#toString` result references. */
+	var symbolTag = "[object Symbol]";
+	/** Used to match Latin Unicode letters (excluding mathematical operators). */
+	var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
+	/**
+	* Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and
+	* [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).
+	*/
+	var reComboMark = RegExp("[\\u0300-\\u036f\\ufe20-\\ufe23\\u20d0-\\u20f0]", "g");
+	/** Used to map Latin Unicode letters to basic Latin letters. */
+	var deburredLetters = {
+		"À": "A",
+		"Á": "A",
+		"Â": "A",
+		"Ã": "A",
+		"Ä": "A",
+		"Å": "A",
+		"à": "a",
+		"á": "a",
+		"â": "a",
+		"ã": "a",
+		"ä": "a",
+		"å": "a",
+		"Ç": "C",
+		"ç": "c",
+		"Ð": "D",
+		"ð": "d",
+		"È": "E",
+		"É": "E",
+		"Ê": "E",
+		"Ë": "E",
+		"è": "e",
+		"é": "e",
+		"ê": "e",
+		"ë": "e",
+		"Ì": "I",
+		"Í": "I",
+		"Î": "I",
+		"Ï": "I",
+		"ì": "i",
+		"í": "i",
+		"î": "i",
+		"ï": "i",
+		"Ñ": "N",
+		"ñ": "n",
+		"Ò": "O",
+		"Ó": "O",
+		"Ô": "O",
+		"Õ": "O",
+		"Ö": "O",
+		"Ø": "O",
+		"ò": "o",
+		"ó": "o",
+		"ô": "o",
+		"õ": "o",
+		"ö": "o",
+		"ø": "o",
+		"Ù": "U",
+		"Ú": "U",
+		"Û": "U",
+		"Ü": "U",
+		"ù": "u",
+		"ú": "u",
+		"û": "u",
+		"ü": "u",
+		"Ý": "Y",
+		"ý": "y",
+		"ÿ": "y",
+		"Æ": "Ae",
+		"æ": "ae",
+		"Þ": "Th",
+		"þ": "th",
+		"ß": "ss",
+		"Ā": "A",
+		"Ă": "A",
+		"Ą": "A",
+		"ā": "a",
+		"ă": "a",
+		"ą": "a",
+		"Ć": "C",
+		"Ĉ": "C",
+		"Ċ": "C",
+		"Č": "C",
+		"ć": "c",
+		"ĉ": "c",
+		"ċ": "c",
+		"č": "c",
+		"Ď": "D",
+		"Đ": "D",
+		"ď": "d",
+		"đ": "d",
+		"Ē": "E",
+		"Ĕ": "E",
+		"Ė": "E",
+		"Ę": "E",
+		"Ě": "E",
+		"ē": "e",
+		"ĕ": "e",
+		"ė": "e",
+		"ę": "e",
+		"ě": "e",
+		"Ĝ": "G",
+		"Ğ": "G",
+		"Ġ": "G",
+		"Ģ": "G",
+		"ĝ": "g",
+		"ğ": "g",
+		"ġ": "g",
+		"ģ": "g",
+		"Ĥ": "H",
+		"Ħ": "H",
+		"ĥ": "h",
+		"ħ": "h",
+		"Ĩ": "I",
+		"Ī": "I",
+		"Ĭ": "I",
+		"Į": "I",
+		"İ": "I",
+		"ĩ": "i",
+		"ī": "i",
+		"ĭ": "i",
+		"į": "i",
+		"ı": "i",
+		"Ĵ": "J",
+		"ĵ": "j",
+		"Ķ": "K",
+		"ķ": "k",
+		"ĸ": "k",
+		"Ĺ": "L",
+		"Ļ": "L",
+		"Ľ": "L",
+		"Ŀ": "L",
+		"Ł": "L",
+		"ĺ": "l",
+		"ļ": "l",
+		"ľ": "l",
+		"ŀ": "l",
+		"ł": "l",
+		"Ń": "N",
+		"Ņ": "N",
+		"Ň": "N",
+		"Ŋ": "N",
+		"ń": "n",
+		"ņ": "n",
+		"ň": "n",
+		"ŋ": "n",
+		"Ō": "O",
+		"Ŏ": "O",
+		"Ő": "O",
+		"ō": "o",
+		"ŏ": "o",
+		"ő": "o",
+		"Ŕ": "R",
+		"Ŗ": "R",
+		"Ř": "R",
+		"ŕ": "r",
+		"ŗ": "r",
+		"ř": "r",
+		"Ś": "S",
+		"Ŝ": "S",
+		"Ş": "S",
+		"Š": "S",
+		"ś": "s",
+		"ŝ": "s",
+		"ş": "s",
+		"š": "s",
+		"Ţ": "T",
+		"Ť": "T",
+		"Ŧ": "T",
+		"ţ": "t",
+		"ť": "t",
+		"ŧ": "t",
+		"Ũ": "U",
+		"Ū": "U",
+		"Ŭ": "U",
+		"Ů": "U",
+		"Ű": "U",
+		"Ų": "U",
+		"ũ": "u",
+		"ū": "u",
+		"ŭ": "u",
+		"ů": "u",
+		"ű": "u",
+		"ų": "u",
+		"Ŵ": "W",
+		"ŵ": "w",
+		"Ŷ": "Y",
+		"ŷ": "y",
+		"Ÿ": "Y",
+		"Ź": "Z",
+		"Ż": "Z",
+		"Ž": "Z",
+		"ź": "z",
+		"ż": "z",
+		"ž": "z",
+		"IJ": "IJ",
+		"ij": "ij",
+		"Œ": "Oe",
+		"œ": "oe",
+		"ʼn": "'n",
+		"ſ": "ss"
+	};
+	/** Detect free variable `global` from Node.js. */
+	var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+	/** Detect free variable `self`. */
+	var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+	/** Used as a reference to the global object. */
+	var root = freeGlobal || freeSelf || Function("return this")();
+	/**
+	* The base implementation of `_.propertyOf` without support for deep paths.
+	*
+	* @private
+	* @param {Object} object The object to query.
+	* @returns {Function} Returns the new accessor function.
+	*/
+	function basePropertyOf(object) {
+		return function(key) {
+			return object == null ? void 0 : object[key];
+		};
+	}
+	/**
+	* Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A
+	* letters to basic Latin letters.
+	*
+	* @private
+	* @param {string} letter The matched letter to deburr.
+	* @returns {string} Returns the deburred letter.
+	*/
+	var deburrLetter = basePropertyOf(deburredLetters);
+	/**
+	* Used to resolve the
+	* [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+	* of values.
+	*/
+	var objectToString = Object.prototype.toString;
+	/** Built-in value references. */
+	var Symbol$1 = root.Symbol;
+	/** Used to convert symbols to primitives and strings. */
+	var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+	/**
+	* The base implementation of `_.toString` which doesn't convert nullish
+	* values to empty strings.
+	*
+	* @private
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	*/
+	function baseToString(value) {
+		if (typeof value == "string") return value;
+		if (isSymbol(value)) return symbolToString ? symbolToString.call(value) : "";
+		var result = value + "";
+		return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+	}
+	/**
+	* Checks if `value` is object-like. A value is object-like if it's not `null`
+	* and has a `typeof` result of "object".
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+	* @example
+	*
+	* _.isObjectLike({});
+	* // => true
+	*
+	* _.isObjectLike([1, 2, 3]);
+	* // => true
+	*
+	* _.isObjectLike(_.noop);
+	* // => false
+	*
+	* _.isObjectLike(null);
+	* // => false
+	*/
+	function isObjectLike(value) {
+		return !!value && typeof value == "object";
+	}
+	/**
+	* Checks if `value` is classified as a `Symbol` primitive or object.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to check.
+	* @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+	* @example
+	*
+	* _.isSymbol(Symbol.iterator);
+	* // => true
+	*
+	* _.isSymbol('abc');
+	* // => false
+	*/
+	function isSymbol(value) {
+		return typeof value == "symbol" || isObjectLike(value) && objectToString.call(value) == symbolTag;
+	}
+	/**
+	* Converts `value` to a string. An empty string is returned for `null`
+	* and `undefined` values. The sign of `-0` is preserved.
+	*
+	* @static
+	* @memberOf _
+	* @since 4.0.0
+	* @category Lang
+	* @param {*} value The value to process.
+	* @returns {string} Returns the string.
+	* @example
+	*
+	* _.toString(null);
+	* // => ''
+	*
+	* _.toString(-0);
+	* // => '-0'
+	*
+	* _.toString([1, 2, 3]);
+	* // => '1,2,3'
+	*/
+	function toString(value) {
+		return value == null ? "" : baseToString(value);
+	}
+	/**
+	* Deburrs `string` by converting
+	* [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)
+	* and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)
+	* letters to basic Latin letters and removing
+	* [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).
+	*
+	* @static
+	* @memberOf _
+	* @since 3.0.0
+	* @category String
+	* @param {string} [string=''] The string to deburr.
+	* @returns {string} Returns the deburred string.
+	* @example
+	*
+	* _.deburr('déjà vu');
+	* // => 'deja vu'
+	*/
+	function deburr$1(string) {
+		string = toString(string);
+		return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
+	}
+	module.exports = deburr$1;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/didyoumean2@7.0.4/node_modules/didyoumean2/dist/index.mjs
+var import_fastest_levenshtein = require_fastest_levenshtein();
+var import_lodash = /* @__PURE__ */ __toESM(require_lodash(), 1);
+let ReturnTypeEnums = /* @__PURE__ */ function(ReturnTypeEnums$1) {
+	ReturnTypeEnums$1["ALL_CLOSEST_MATCHES"] = "all-closest-matches";
+	ReturnTypeEnums$1["ALL_MATCHES"] = "all-matches";
+	ReturnTypeEnums$1["ALL_SORTED_MATCHES"] = "all-sorted-matches";
+	ReturnTypeEnums$1["FIRST_CLOSEST_MATCH"] = "first-closest-match";
+	ReturnTypeEnums$1["FIRST_MATCH"] = "first-match";
+	return ReturnTypeEnums$1;
+}({});
+let ThresholdTypeEnums = /* @__PURE__ */ function(ThresholdTypeEnums$1) {
+	ThresholdTypeEnums$1["EDIT_DISTANCE"] = "edit-distance";
+	ThresholdTypeEnums$1["SIMILARITY"] = "similarity";
+	return ThresholdTypeEnums$1;
+}({});
+const fillDefaultOptions = (options) => {
+	const optionsWithDefaultValues = {
+		caseSensitive: false,
+		deburr: true,
+		matchPath: [],
+		returnType: ReturnTypeEnums.FIRST_CLOSEST_MATCH,
+		thresholdType: ThresholdTypeEnums.SIMILARITY,
+		trimSpaces: true,
+		...options
+	};
+	if (!Object.values(ReturnTypeEnums).includes(optionsWithDefaultValues.returnType)) throw new TypeError("unknown returnType");
+	if (!Object.values(ThresholdTypeEnums).includes(optionsWithDefaultValues.thresholdType)) throw new TypeError("unknown thresholdType");
+	switch (optionsWithDefaultValues.thresholdType) {
+		case ThresholdTypeEnums.EDIT_DISTANCE: return {
+			threshold: 20,
+			...optionsWithDefaultValues
+		};
+		case ThresholdTypeEnums.SIMILARITY: return {
+			threshold: .4,
+			...optionsWithDefaultValues
+		};
+	}
+};
+/**
+* Using edit distance between `a` and `b` to calculate similarity
+*
+* @param {string} a - `input`
+* @param {string} b - String from `matchList`
+* @returns {number} similarity between `a` and `b`
+*/
+const getSimilarity = (a, b) => {
+	if (!a || !b) return 0;
+	if (a === b) return 1;
+	const editDistance = (0, import_fastest_levenshtein.distance)(a, b);
+	const longestLength = Math.max(a.length, b.length);
+	return (longestLength - editDistance) / longestLength;
+};
+/**
+* Normalize a string
+*
+* @param {string} str - any string
+* @param {object} options - options that allows you to modify the behavior
+* @returns {string} - normalized string
+*/
+const normalizeString = (str, options) => {
+	let s = str;
+	if (options.trimSpaces) s = s.trim().replaceAll(/\s+/gu, " ");
+	if (options.deburr) s = (0, import_lodash.default)(s);
+	if (!options.caseSensitive) s = s.toLowerCase();
+	return s;
+};
+const getMatchItemStr = (matchItem, matchPath) => {
+	const matchItemStr = matchPath.length > 0 ? matchPath.reduce((acc, prop) => {
+		return acc?.[prop];
+	}, matchItem) : matchItem;
+	if (typeof matchItemStr !== "string") return "";
+	return matchItemStr;
+};
+/**
+* Process matchItem according to options
+*
+* @param {object | string} matchItem - Item for matching with `input`
+* @param {object} options - options that allows you to modify the behavior
+* @returns {string} - processed matchItem
+*/
+const matchItemProcessor = (matchItem, options) => {
+	const { matchPath } = options;
+	return normalizeString(getMatchItemStr(matchItem, matchPath), options);
+};
+/**
+* Generate result
+*
+* @param {object[] | string[]} matchList - List for matching with `input`
+* @param {number[]} matchedIndexes - indexes of matchList that need to be returned as result
+* @param {ReturnTypeEnums} returnType - how the result will response to user
+* @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`
+*/
+const resultProcessor = (matchList, matchedIndexes, returnType) => {
+	switch (returnType) {
+		case ReturnTypeEnums.ALL_CLOSEST_MATCHES:
+		case ReturnTypeEnums.ALL_MATCHES:
+		case ReturnTypeEnums.ALL_SORTED_MATCHES: return matchedIndexes.map((matchedIndex) => matchList[matchedIndex]);
+		case ReturnTypeEnums.FIRST_CLOSEST_MATCH:
+		case ReturnTypeEnums.FIRST_MATCH: {
+			const matchedIndex = matchedIndexes[0];
+			if (matchedIndex === void 0) return null;
+			return matchList[matchedIndex];
+		}
+	}
+};
+/**
+* Main function for didyoumean2
+*
+* @param {string} input - string that you are not sure and want to match with `matchList`
+* @param {object[] | string[]} matchList - List for matching with `input`
+* @param {null | object | undefined} options - options that allows you to modify the behavior
+* @returns {Array | null | object | string} - matched result(s), return object if `match` is `{Object[]}`
+*/
+function didYouMean(input, matchList, options) {
+	const optionsWithDefaults = fillDefaultOptions(options);
+	const { returnType, threshold, thresholdType } = optionsWithDefaults;
+	const normalizedInput = normalizeString(input, optionsWithDefaults);
+	let checkIfMatched;
+	let scoreProcessor;
+	switch (thresholdType) {
+		case ThresholdTypeEnums.EDIT_DISTANCE:
+			checkIfMatched = (score) => score <= threshold;
+			scoreProcessor = (matchItem) => (0, import_fastest_levenshtein.distance)(normalizedInput, matchItemProcessor(matchItem, optionsWithDefaults));
+			break;
+		case ThresholdTypeEnums.SIMILARITY:
+			checkIfMatched = (score) => score >= threshold;
+			scoreProcessor = (matchItem) => getSimilarity(normalizedInput, matchItemProcessor(matchItem, optionsWithDefaults));
+			break;
+	}
+	const matchedIndexes = [];
+	switch (returnType) {
+		case ReturnTypeEnums.ALL_CLOSEST_MATCHES:
+		case ReturnTypeEnums.FIRST_CLOSEST_MATCH: {
+			const scores = [];
+			let marginValue;
+			switch (thresholdType) {
+				case ThresholdTypeEnums.EDIT_DISTANCE:
+					marginValue = Number.POSITIVE_INFINITY;
+					for (const matchItem of matchList) {
+						const score = scoreProcessor(matchItem);
+						if (marginValue > score) marginValue = score;
+						scores.push(score);
+					}
+					break;
+				case ThresholdTypeEnums.SIMILARITY:
+					marginValue = 0;
+					for (const matchItem of matchList) {
+						const score = scoreProcessor(matchItem);
+						if (marginValue < score) marginValue = score;
+						scores.push(score);
+					}
+					break;
+			}
+			for (const [i, score] of scores.entries()) if (checkIfMatched(score) && score === marginValue) matchedIndexes.push(i);
+			break;
+		}
+		case ReturnTypeEnums.ALL_MATCHES:
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) matchedIndexes.push(i);
+			}
+			break;
+		case ReturnTypeEnums.ALL_SORTED_MATCHES: {
+			const unsortedResults = [];
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) unsortedResults.push({
+					score,
+					index: i
 				});
 			}
+			switch (thresholdType) {
+				case ThresholdTypeEnums.EDIT_DISTANCE:
+					unsortedResults.sort((a, b) => a.score - b.score);
+					break;
+				case ThresholdTypeEnums.SIMILARITY:
+					unsortedResults.sort((a, b) => b.score - a.score);
+					break;
+			}
+			for (const unsortedResult of unsortedResults) matchedIndexes.push(unsortedResult.index);
+			break;
 		}
-		return candidates$1;
-	}
-	const candidates = [];
-	let prefix = "";
-	if (commandName) {
-		const matchedParts = commandName.split(" ");
-		const remainingArgs = inputArgv.slice(matchedParts.length);
-		prefix = `${[command.name, ...remainingArgs].join(" ")} `;
-	} else prefix = inputArgv.length > 0 ? `${inputArgv.join(" ")} ` : "";
-	for (const command$1 of cli._commands.values()) {
-		if (command$1.completions?.show === false) continue;
-		if (command$1.name.startsWith(prefix)) {
-			const nextWord = command$1.name.slice(prefix.length).split(" ")[0];
-			if (nextWord) candidates.push({
-				name: nextWord,
-				description: command$1.description
-			});
+		case ReturnTypeEnums.FIRST_MATCH:
+			for (const [i, matchItem] of matchList.entries()) {
+				const score = scoreProcessor(matchItem);
+				if (checkIfMatched(score)) {
+					matchedIndexes.push(i);
+					break;
+				}
+			}
+			break;
+	}
+	return resultProcessor(matchList, matchedIndexes, returnType);
+}
+
+//#endregion
+//#region ../plugin-not-found/src/index.ts
+const notFoundPlugin = () => definePlugin({ setup: (cli) => cli.interceptor({
+	enforce: "post",
+	handler: async (_ctx, next) => {
+		const commandKeys = [...cli._commands.keys()];
+		const hasCommands = commandKeys.length > 0;
+		try {
+			await next();
+		} catch (e) {
+			if (!(e instanceof NoSuchCommandError || e instanceof NoCommandSpecifiedError)) throw e;
+			if (e instanceof NoCommandSpecifiedError) {
+				let text$1 = "No command specified.";
+				if (hasCommands) text$1 += `\nPossible commands: ${commandKeys.join(", ")}.`;
+				throw new NoCommandSpecifiedError(text$1);
+			}
+			const { commandName } = e;
+			const closestCommandName = didYouMean(commandName, commandKeys);
+			let text = `Command "${strikethrough(commandName)}" not found.`;
+			if (hasCommands && closestCommandName) text += `\nDid you mean "${bold(closestCommandName)}"?`;
+			else if (!hasCommands) text += "\nNo commands registered.";
+			throw new NoSuchCommandError(commandName, text);
+		}
+	}
+}) });
+
+//#endregion
+//#region ../plugin-strict-flags/src/index.ts
+const strictFlagsPlugin = () => definePlugin({ setup: (cli) => {
+	cli.interceptor(async (ctx, next) => {
+		const keys = Object.keys(ctx.rawParsed.unknown);
+		if (!ctx.resolved || keys.length === 0) await next();
+		else throw keys.length > 1 ? /* @__PURE__ */ new Error(`Unexpected flags: ${joinWithAnd(keys)}`) : /* @__PURE__ */ new Error(`Unexpected flag: ${keys[0]}`);
+	});
+} });
+
+//#endregion
+//#region ../clerc/src/re-exports.ts
+var re_exports_exports = /* @__PURE__ */ __export({
+	completionsPlugin: () => completionsPlugin,
+	defaultFormatters: () => defaultFormatters,
+	friendlyErrorPlugin: () => friendlyErrorPlugin,
+	helpPlugin: () => helpPlugin,
+	notFoundPlugin: () => notFoundPlugin,
+	strictFlagsPlugin: () => strictFlagsPlugin,
+	versionPlugin: () => versionPlugin
+});
+import * as import___clerc_core from "@clerc/core";
+__reExport(re_exports_exports, import___clerc_core);
+
+//#endregion
+//#region ../clerc/src/index.ts
+var src_exports = /* @__PURE__ */ __export({
+	Cli: () => Cli,
+	completionsPlugin: () => completionsPlugin,
+	defaultFormatters: () => defaultFormatters,
+	friendlyErrorPlugin: () => friendlyErrorPlugin,
+	helpPlugin: () => helpPlugin,
+	notFoundPlugin: () => notFoundPlugin,
+	strictFlagsPlugin: () => strictFlagsPlugin,
+	versionPlugin: () => versionPlugin
+});
+__reExport(src_exports, re_exports_exports);
+const Cli = (options) => Clerc.create(options).use(versionPlugin()).use(helpPlugin());
+
+//#endregion
+//#region src/t.ts
+function resetTab() {
+	t.commands.clear();
+	t.options.clear();
+	t.arguments.clear();
+	t.completions = [];
+}
+function registerGlobalFlags(globalFlags, tc) {
+	for (const [flagName, def] of Object.entries(globalFlags)) {
+		const normalized = (0, src_exports.normalizeFlagValue)(def);
+		const desc = normalized.description ?? "";
+		tc.option(flagName, desc, normalized.short);
+	}
+}
+function buildTabModel(globalFlags, commands) {
+	resetTab();
+	registerGlobalFlags(globalFlags, t);
+	for (const cmd of commands.values()) {
+		if (cmd.completions?.show === false) continue;
+		const command = t.command(cmd.name, cmd.description ?? "");
+		registerGlobalFlags(globalFlags, command);
+		for (const [flagName, def] of Object.entries(cmd.flags ?? {})) {
+			const normalized = (0, src_exports.normalizeFlagValue)(def);
+			const desc = normalized.description ?? "";
+			command.option(flagName, desc, normalized.short);
 		}
 	}
-	const uniqueCandidates = /* @__PURE__ */ new Map();
-	for (const c of candidates) uniqueCandidates.set(c.name, c);
-	return [...uniqueCandidates.values()];
 }
 
 //#endregion
 //#region src/index.ts
-const completionsPlugin = (options = {}) => definePlugin({ setup: (cli) => {
-	const { managementCommands = true } = options;
-	cli.store.help?.addGroup({ commands: [["completions", "Completions"]] });
-	const supportedShellEnum = Types.Enum(...tabtab.SUPPORTED_SHELLS);
-	if (managementCommands) {
-		cli.command("completions install", "Install shell completions", {
-			help: { group: "completions" },
-			flags: { shell: {
-				description: "Shell type",
-				type: supportedShellEnum
-			} },
-			parameters: [{
-				key: "[shell]",
-				description: "Shell type",
-				type: supportedShellEnum
-			}]
-		}).on("completions install", async (ctx) => {
-			const shell = ctx.parameters.shell ?? ctx.flags.shell;
-			if (!shell) throw new Error("Please specify the shell type via the --shell flag or the [shell] parameter.");
-			if (!tabtab.SUPPORTED_SHELLS.includes(shell)) throw new Error(`Unsupported shell: ${shell}. Supported shells are: ${tabtab.SUPPORTED_SHELLS.join(", ")}.`);
-			await tabtab.install({
-				name: cli._scriptName,
-				completer: cli._scriptName,
-				shell
-			});
-		});
-		cli.command("completions uninstall", "Uninstall shell completions", { help: { group: "completions" } }).on("completions uninstall", async () => {
-			await tabtab.uninstall({ name: cli._scriptName });
-		});
-	}
-	cli.command("completions", "Generate completions script", {
-		help: { group: "completions" },
+const completionsPlugin = () => definePlugin({ setup: (cli) => {
+	const supportedShellEnum = Types.Enum("zsh", "bash", "fish", "powershell");
+	cli.command("completions", "Generate shell completion scripts", {
 		flags: { shell: {
 			description: "Shell type",
 			type: supportedShellEnum
 		} },
 		parameters: [{
 			key: "[shell]",
-			description: "Shell type",
+			description: "Shell type (zsh, bash, fish, powershell)",
 			type: supportedShellEnum
 		}]
 	}).on("completions", async (ctx) => {
 		const shell = ctx.parameters.shell ?? ctx.flags.shell;
-		if (!shell) throw new Error("Please specify the shell type via the --shell flag or the [shell] parameter.");
-		if (!tabtab.SUPPORTED_SHELLS.includes(shell)) throw new Error(`Unsupported shell: ${shell}. Supported shells are: ${tabtab.SUPPORTED_SHELLS.join(", ")}.`);
-		const script = await tabtab.getCompletionScript({
-			name: cli._scriptName,
-			completer: cli._scriptName,
-			shell
-		});
-		console.log(script);
+		if (!shell) throw new Error("Shell type is required. Please provide it via --shell flag or [shell] parameter.");
+		buildTabModel(cli._globalFlags, cli._commands);
+		t.setup(cli._scriptName, cli._scriptName, shell);
 	});
-	cli.command("completion-server", "Handle completions", {
+	cli.command("complete", {
 		help: { show: false },
-		completions: { show: false }
-	}).on("completion-server", async () => {
-		const env = tabtab.parseEnv(process.env);
-		if (!env.complete) return;
-		const shell = getShellFromEnv(process.env);
-		const candidates = await getCompletion(cli, env);
-		tabtab.log(candidates, shell);
+		completions: { show: false },
+		parameters: ["--", "[input...]"]
+	}).on("complete", async (ctx) => {
+		buildTabModel(cli._globalFlags, cli._commands);
+		const { input } = ctx.parameters;
+		t.parse(input);
 	});
 	return cli;
 } });