@clo4/cli 0.0.0-stage → 1.0.0

package/dist/testing.js

@@ -0,0 +1,519 @@
+// \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
+// src/util.ts
+function isArray(o) {
+	return Array.isArray(o);
+}
+/** Convert the value, if any, to an array with 0 or more elements */
+function makeArray(thing) {
+	if (thing === void 0) return [];
+	if (isArray(thing)) return thing.slice();
+	return [thing];
+}
+function assert(expr, msg = "") {
+	if (!expr) throw new Error(msg);
+}
+(/* @__PURE__ */ __commonJSMin(((exports) => {
+	exports.__esModule = true;
+	exports.distance = exports.closest = void 0;
+	var peq = /* @__PURE__ */ 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 = 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;
+	var closest = function(str, arr) {
+		var min_distance = Infinity;
+		var min_index = 0;
+		for (var i = 0; i < arr.length; i++) {
+			var dist = distance(str, arr[i]);
+			if (dist < min_distance) {
+				min_distance = dist;
+				min_index = i;
+			}
+		}
+		return arr[min_index];
+	};
+	exports.closest = closest;
+})))();
+// src/parse.ts
+/**
+* Returns the minimum number of arguments that satisfies the args.
+*
+* Accepts the raw spec value (a single arg, an array, or `undefined`) so the
+* hot path doesn't have to copy it into an array first.
+*/
+function getMinArgs(args) {
+	if (args === void 0) return 0;
+	if (!isArray(args)) return args.isOptional ? 0 : 1;
+	let count = 0;
+	for (let i = 0; i < args.length; i++) {
+		if (args[i].isOptional) break;
+		count++;
+	}
+	return count;
+}
+/** Returns the maximum number of arguments that satisfies the args. */
+function getMaxArgs(args) {
+	if (args === void 0) return 0;
+	if (!isArray(args)) return args.isVariadic ? Infinity : 1;
+	for (let i = 0; i < args.length; i++) if (args[args.length - 1 - i].isVariadic) return Infinity;
+	return args.length;
+}
+// src/testing.ts
+const repr = JSON.stringify;
+/**
+* Run a function once for each `args` property in the spec (recursive)
+*
+* This will convert single args to an array with one item.
+*/
+function forEachArgArray(spec, fn, path = []) {
+	path = path.concat(spec);
+	fn(makeArray(spec.args), path);
+	for (const option of makeArray(spec.options)) fn(makeArray(option.args), path);
+	for (const subcommand of makeArray(spec.subcommands)) forEachArgArray(subcommand, fn, path);
+}
+/** Run a function once for each `options` property in the spec (recursive) */
+function forEachOptionArray(spec, fn, path = []) {
+	path = path.concat(spec);
+	fn(makeArray(spec.options), path);
+	for (const subcommand of makeArray(spec.subcommands)) forEachOptionArray(subcommand, fn, path);
+}
+/**
+* Run a function once for each `subcommands` property in the spec (recursive)
+*
+* This will also run the function for the root spec itself.
+*/
+function forEachSubcommand(spec, fn, path = []) {
+	path = path.concat(spec);
+	fn(spec, path);
+	for (const subcommand of makeArray(spec.subcommands)) forEachSubcommand(subcommand, fn, path);
+}
+function joinNames(names) {
+	return makeArray(names).sort((a, b) => a.length - b.length).join("|");
+}
+function namedArrayToString(...parts) {
+	return `\`${parts.map((named) => joinNames(named.name)).join(" ")}\``;
+}
+/** Asserts that required arguments do not come after an optional argument */
+function assertRequiredArgumentsDoNotFollowOptionalArguments(spec) {
+	forEachArgArray(spec, (args, path) => {
+		let remainingMustBeOptional = false;
+		let firstOptionalArgIndex = null;
+		for (const [index, arg] of args.entries()) if (remainingMustBeOptional) assert(arg.isOptional, `In ${namedArrayToString(...path)}, argument ${arg.name || index} is required, but it must be optional since the argument at index ${firstOptionalArgIndex} is optional`);
+		else if (arg.isOptional) {
+			remainingMustBeOptional = true;
+			firstOptionalArgIndex ??= index;
+		}
+	});
+}
+/** Asserts that options with `isRepeatable: true` don't have arguments */
+function assertRepeatableOptionsHaveNoArguments(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		for (const [index, option] of options.entries()) assert(!(option.args && option.isRepeatable), `The option ${namedArrayToString(...path, option)} (index ${index}) has arguments and is repeatable. Repeatable options cannot have arguments, but you can use a variadic argument instead.`);
+	});
+}
+/** Asserts that `isRepeatable` is only assigned a positive integer */
+function assertRepeatableOptionsArePositiveIntegers(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		for (const [index, option] of options.entries()) if (typeof option.isRepeatable === "number") {
+			assert(Number.isSafeInteger(option.isRepeatable), `The option ${namedArrayToString(...path, option)} (index ${index}) has its \`isRepeatable\` value set to a number that is not an integer`);
+			assert(!(option.isRepeatable < 1), `The option ${namedArrayToString(...path, option)} (index ${index}) has its \`isRepeatable\` value set to a number below 1, which means it can't be used at all`);
+			assert(option.isRepeatable !== 1, `The option ${namedArrayToString(...path, option)} (index ${index}) has its \`isRepeatable\` value set to 1, which is no different that omitting the property entirely`);
+		}
+	});
+}
+/** Asserts that options have unique names in their scope */
+function assertOptionsHaveLocallyUniqueNames(spec) {
+	forEachSubcommand(spec, (spec, path) => {
+		const optionNames = /* @__PURE__ */ new Set();
+		for (const [index, option] of makeArray(spec.options).entries()) for (const name of makeArray(option.name)) {
+			assert(!optionNames.has(name), `Option ${namedArrayToString(...path, option)} (index ${index}) has a non-unique name, '${name}'. Option names must be unique.`);
+			optionNames.add(name);
+		}
+	});
+}
+/** Asserts that options don't shadow a persistent option */
+function assertOptionsDoNotShadowPersistentOptions(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		const persistentOptionNames = new Set(path.slice(0, -1).flatMap((subcommand) => subcommand.options ? subcommand.options.filter((option) => option.isPersistent).flatMap((option) => option.name) : []));
+		for (const [index, option] of makeArray(options).entries()) for (const name of makeArray(option.name)) assert(!persistentOptionNames.has(name), `The option ${namedArrayToString(...path, option)} (index ${index}) shadows the name of a persistent option, ${repr(name)}. Option names can't shadow persistent options.`);
+	});
+}
+/** Asserts that subcommands don't share a name with a sibling subcommand */
+function assertSubcommandsHaveLocallyUniqueNames(spec) {
+	forEachSubcommand(spec, (spec, path) => {
+		const names = /* @__PURE__ */ new Set();
+		for (const [index, subcommand] of makeArray(spec.subcommands).entries()) for (const name of makeArray(subcommand.name)) {
+			assert(!names.has(name), `The subcommand ${namedArrayToString(...path, subcommand)} (index ${index}) has a non-unique name, ${repr(name)}. Subcommand names must be unique among the subcommands in the same array.`);
+			names.add(name);
+		}
+	});
+}
+/**
+* Asserts that option names starting with a single dash aren't longer
+* than two characters, unless parserDirectives.flagsArePosixNoncompliant is
+* set on an ancestor command.
+*/
+function assertLongOptionNamesDoNotStartWithSingleDash(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		if (path.map((command) => command.parserDirectives?.flagsArePosixNoncompliant).filter((value) => value !== void 0).at(-1) || false) return;
+		for (const [index, option] of makeArray(options).entries()) for (const name of makeArray(option.name)) assert(!((name.startsWith("-") || name.startsWith("+")) && !name.startsWith("--") && name.length > 2), `Option ${namedArrayToString(...path, option)} (index ${index}) has a name that the parser is unable to parse, as it starts with a single '${name[0]}'. Tokens starting with that character are interpreted as short options, so passing '${name}' will be interpreted as '${Array.from(name.slice(1), (letter) => name[0] + letter).join(" ")}'. \`parserDirectives.flagsArePosixNoncompliant\` must be \`true\` on an ancestor command.`);
+	});
+}
+/**
+* Asserts that all option names start with dashes
+*/
+function assertOptionNamesStartWithDashes(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		if (path.map((command) => command.parserDirectives?.flagsArePosixNoncompliant).filter((value) => value !== void 0).at(-1) || false) return;
+		for (const [index, option] of makeArray(options).entries()) for (const name of makeArray(option.name)) assert(name.startsWith("-") || name.startsWith("+"), `Option ${namedArrayToString(...path, option)} (index ${index}) doesn't start with a dash or plus, the parser will be unable to find matching options without \`parserDirectives.flagsAreNonPosixCompliant\` being set to 'true' on an ancestor command`);
+	});
+}
+/**
+* Asserts that nothing is named exactly '--'
+*/
+function assertNothingIsNamedDashDash(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		for (const [index, option] of makeArray(options).entries()) for (const name of makeArray(option.name)) assert(name !== "--", `Option ${namedArrayToString(...path, option)} (index ${index}) is named '--', which is a special instruction to the parser to treat all following tokens as arguments. This will never be matched`);
+	});
+	forEachSubcommand(spec, (subcommands, path) => {
+		for (const [index, subcommand] of makeArray(subcommands).entries()) for (const name of makeArray(subcommand.name)) assert(name !== "--", `Subcommand ${namedArrayToString(...path, subcommand)} (index ${index}) is named '--', which is a special instruction to the parser to treat all following tokens as arguments. This will never be matched`);
+	});
+}
+/**
+* Asserts that no option arg separator is an empty string
+*/
+function assertOptionArgSeparatorsHaveCharacters(spec) {
+	forEachSubcommand(spec, (subcommands, path) => {
+		for (const [index, subcommand] of makeArray(subcommands).entries()) {
+			const separators = makeArray(subcommand.parserDirectives?.optionArgSeparators);
+			for (const [sepIndex, separator] of separators.entries()) assert(separator !== "", `Subcommand ${namedArrayToString(...path, subcommand)} (index ${index}) has an empty string for an option arg separator at index ${sepIndex}. If you wanted to disable option arg separators, use an empty array.`);
+		}
+	});
+}
+/**
+* Asserts that options named "+" or "-" takes one arg
+*/
+function assertPlusMinusOptionsTakeOneArg(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		if (path.map((command) => command.parserDirectives?.flagsArePosixNoncompliant).filter((value) => value !== void 0).at(-1) || false) return;
+		for (const [index, option] of makeArray(options).entries()) for (const name of makeArray(option.name)) {
+			if (name !== "-" && name !== "+") continue;
+			assert(option.args && !Array.isArray(option.args), `Option ${namedArrayToString(...path, option)} (index ${index}) must take exactly one argument`);
+		}
+	});
+}
+/**
+* Asserts that names do not have leading or trailing whitespace
+*/
+function assertNamesHaveNoExtraWhitespace(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		for (const [index, option] of makeArray(options).entries()) for (const name of makeArray(option.name)) assert(name === name.trim(), `Option ${namedArrayToString(...path, option)} (index ${index}) has a name with extra whitespace`);
+	});
+	forEachSubcommand(spec, (subcommands, path) => {
+		for (const [index, subcommand] of makeArray(subcommands).entries()) for (const name of makeArray(subcommand.name)) assert(name === name.trim(), `Subcommand ${namedArrayToString(...path, subcommand)} (index ${index}) has a name with extra whitespace`);
+	});
+	forEachArgArray(spec, (args, path) => {
+		for (const [index, arg] of makeArray(args).entries()) for (const name of makeArray(arg.name)) assert(name === name.trim(), `Arg in ${namedArrayToString(...path)} (at index ${index}) has a name with extra whitespace`);
+	});
+}
+/**
+* Asserts that everything has a description
+*/
+function assertEverythingHasDescription(spec) {
+	assert(spec.description, `Spec has no description`);
+	forEachOptionArray(spec, (options, path) => {
+		for (const [index, option] of makeArray(options).entries()) assert(option.description, `Option ${namedArrayToString(...path, option)} (index ${index}) has no description`);
+	});
+	forEachSubcommand(spec, (subcommands, path) => {
+		for (const [index, subcommand] of makeArray(subcommands).entries()) assert(subcommand.description, `Subcommand ${namedArrayToString(...path, subcommand)} (index ${index}) has no description`);
+	});
+}
+/**
+* Asserts that descriptions have line length < 69
+*/
+function assertDescriptionLineLengthUnder69(spec) {
+	if (spec.description) assert(spec.description.split("\n").every((line) => line.length <= 68), `Spec has a description line over 68 characters`);
+	forEachOptionArray(spec, (options, path) => {
+		for (const [index, option] of makeArray(options).entries()) if (option.description) assert(option.description.split("\n").every((line) => line.length <= 68), `Option ${namedArrayToString(...path, option)} (index ${index}) has a description line over 68 characters`);
+	});
+	forEachSubcommand(spec, (subcommands, path) => {
+		for (const [index, subcommand] of makeArray(subcommands).entries()) if (subcommand.description) assert(subcommand.description.split("\n").every((line) => line.length <= 68), `Subcommand ${namedArrayToString(...path, subcommand)} (index ${index}) has a description line over 68 characters`);
+	});
+}
+function assertRequiresSeparatorTakesOneArg(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		for (const [index, option] of makeArray(options).entries()) if (option.requiresSeparator) {
+			const args = makeArray(option.args);
+			assert(getMinArgs(args) <= 1, `Option ${namedArrayToString(...path, option)} (index ${index}) takes a minimum of ${getMinArgs(args)} arg(s), but because of requiresSeparator, it must instead be 0 or 1`);
+			assert(getMaxArgs(args) === 1, `Option ${namedArrayToString(...path, option)} (index ${index}) takes a maximum of ${getMaxArgs(args)} arg(s), but because of requiresSeparator, it's only able to take 1`);
+		}
+	});
+}
+function assertCommonOptionsArePersistent(spec) {
+	const isSameName = (a, b) => {
+		if (isArray(a) && isArray(b)) return a.every((item) => b.includes(item)) && b.every((item) => a.includes(item));
+		return a === b;
+	};
+	const failures = [];
+	forEachSubcommand(spec, (subcommand, path) => {
+		if (!subcommand.subcommands) return;
+		for (const option of makeArray(subcommand.options)) {
+			const allChildSubcommands = [];
+			forEachSubcommand(subcommand, (cmd) => allChildSubcommands.push(cmd));
+			if (allChildSubcommands.every((cmd) => makeArray(cmd.options).some((o) => isSameName(option.name, o.name))) && !failures.some(([name]) => isSameName(name, option.name))) failures.push([option.name, namedArrayToString(...path, option)]);
+		}
+	});
+	assert(failures.length === 0, `The following options were also defined by all subcommands. Instead, define the option once, and use \`isPersistent: true\` to persist it across all subcommands.
+${failures.map(([, line]) => " * " + line).join("\n")}
+`);
+}
+/**
+* Asserts that references to other options by name actually refer to options
+* that exist in scope
+*/
+function assertOptionNameReferencesExist(spec) {
+	forEachOptionArray(spec, (options, path) => {
+		const optionNames = /* @__PURE__ */ new Set([...path.slice(0, -1).flatMap((subcommand) => subcommand.options ? subcommand.options.filter((option) => option.isPersistent).flatMap((option) => option.name) : []), ...options.flatMap((option) => option.name)]);
+		for (const [index, option] of makeArray(options).entries()) {
+			for (const name of makeArray(option.dependsOn)) assert(optionNames.has(name), `The option ${namedArrayToString(...path, option)} (index ${index}) depends on an option named ${repr(name)}, which doesn't exist in its scope`);
+			for (const name of makeArray(option.exclusiveOn)) assert(optionNames.has(name), `The option ${namedArrayToString(...path, option)} (index ${index}) is exclusive on an option named ${repr(name)}, which doesn't exist in its scope`);
+		}
+	});
+}
+/**
+* Asserts that commands that will match subcommands by prefix do not take arguments
+*/
+function assertPrefixMatchCommandsHaveNoArguments(spec) {
+	forEachSubcommand(spec, (subcommand, path) => {
+		if (!path.some((cmd) => cmd.parserDirectives?.subcommandsMatchUniquePrefix === true)) return;
+		assert(!(subcommand.subcommands && subcommand.args), `The command ${namedArrayToString(...path)} has at least one argument and subcommand, but matches subcommands based on unique prefixes. To fix this, use \`parserDirectives: { subcommandsMatchUniquePrefix: false }\``);
+	});
+}
+function getName(namingStyle, names) {
+	return names[namingStyle];
+}
+async function runStep(context, name, fn) {
+	if (context) {
+		await context.step(name, fn);
+		return;
+	}
+	await fn();
+}
+/**
+* Validate your CLI in your test suite
+*
+* This enforces certain constraints that the type system cannot. The parser
+* may ignore these issues, producing correct output that _appears_ to be
+* wrong.
+*/
+function test(spec, options = {}) {
+	const { allowShadowingPersistentOptions = false, allowNoDescription = false, allowLongDescriptionLines = false, allowMatchingSubcommandPrefixAndArgs = false, namingStyle = "sentence" } = options;
+	return async (t) => {
+		await runStep(t, getName(namingStyle, {
+			sentence: "Required arguments don't follow optional arguments",
+			function: "assertRequiredArgumentsDoNotFollowOptionalArguments"
+		}), () => {
+			assertRequiredArgumentsDoNotFollowOptionalArguments(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Repeatable options don't have arguments",
+			function: "assertRepeatableOptionsHaveNoArguments"
+		}), () => {
+			assertRepeatableOptionsHaveNoArguments(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Repeatable options that are numbers are integers greater than 1",
+			function: "assertRepeatableOptionsArePositiveIntegers"
+		}), () => {
+			assertRepeatableOptionsArePositiveIntegers(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Long option names don't start with a single dash",
+			function: "assertLongOptionNamesDoNotStartWithSingleDash"
+		}), () => {
+			assertLongOptionNamesDoNotStartWithSingleDash(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Option names all start with dashes",
+			function: "assertOptionNamesStartWithDashes"
+		}), () => {
+			assertOptionNamesStartWithDashes(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Options have locally unique names",
+			function: "assertOptionsHaveLocallyUniqueNames"
+		}), () => {
+			assertOptionsHaveLocallyUniqueNames(spec);
+		});
+		if (!allowShadowingPersistentOptions) await runStep(t, getName(namingStyle, {
+			sentence: "Options don't shadow persistent options",
+			function: "assertOptionsDoNotShadowPersistentOptions"
+		}), () => {
+			assertOptionsDoNotShadowPersistentOptions(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Subcommands have locally unique names",
+			function: "assertSubcommandsHaveLocallyUniqueNames"
+		}), () => {
+			assertSubcommandsHaveLocallyUniqueNames(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Nothing is named '--'",
+			function: "assertNothingIsNamedDashDash"
+		}), () => {
+			assertNothingIsNamedDashDash(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Option arg separators are not an empty string",
+			function: "assertOptionArgSeparatorsHaveCharacters"
+		}), () => {
+			assertOptionArgSeparatorsHaveCharacters(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Options named '-' or '+' take exactly one argument",
+			function: "assertPlusMinusOptionsTakeOneArg"
+		}), () => {
+			assertPlusMinusOptionsTakeOneArg(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Names have no extra leading or trailing whitespace",
+			function: "assertNamesHaveNoExtraWhitespace"
+		}), () => {
+			assertNamesHaveNoExtraWhitespace(spec);
+		});
+		if (!allowNoDescription) await runStep(t, getName(namingStyle, {
+			sentence: "Everything has a description",
+			function: "assertEverythingHasDescription"
+		}), () => {
+			assertEverythingHasDescription(spec);
+		});
+		if (!allowLongDescriptionLines) await runStep(t, getName(namingStyle, {
+			sentence: "Each line in descriptions is less than or equal to 68 characters",
+			function: "assertDescriptionLineLengthUnder69"
+		}), () => {
+			assertDescriptionLineLengthUnder69(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Options with `requiresSeparator` take exactly one argument",
+			function: "assertRequiresSeparatorTakesOneArg"
+		}), () => {
+			assertRequiresSeparatorTakesOneArg(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "Common options are not defined on every subcommand",
+			function: "assertCommonOptionsArePersistent"
+		}), () => {
+			assertCommonOptionsArePersistent(spec);
+		});
+		await runStep(t, getName(namingStyle, {
+			sentence: "References to other options by name are valid",
+			function: "assertOptionNameReferencesExist"
+		}), () => {
+			assertOptionNameReferencesExist(spec);
+		});
+		if (!allowMatchingSubcommandPrefixAndArgs) await runStep(t, getName(namingStyle, {
+			sentence: "Commands with `subcommandsMatchUniquePrefix` don't have arguments and subcommands",
+			function: "assertPrefixMatchCommandsHaveNoArguments"
+		}), () => {
+			assertPrefixMatchCommandsHaveNoArguments(spec);
+		});
+	};
+}
+const testSpec = test;
+export { assertCommonOptionsArePersistent, assertDescriptionLineLengthUnder69, assertEverythingHasDescription, assertLongOptionNamesDoNotStartWithSingleDash, assertNamesHaveNoExtraWhitespace, assertNothingIsNamedDashDash, assertOptionArgSeparatorsHaveCharacters, assertOptionNameReferencesExist, assertOptionNamesStartWithDashes, assertOptionsDoNotShadowPersistentOptions, assertOptionsHaveLocallyUniqueNames, assertPlusMinusOptionsTakeOneArg, assertPrefixMatchCommandsHaveNoArguments, assertRepeatableOptionsArePositiveIntegers, assertRepeatableOptionsHaveNoArguments, assertRequiredArgumentsDoNotFollowOptionalArguments, assertRequiresSeparatorTakesOneArg, assertSubcommandsHaveLocallyUniqueNames, test, testSpec };
+
+//# sourceMappingURL=testing.js.map