@clo4/cli 2.0.0 → 3.0.1

package/dist/testing.js

@@ -8,10 +8,64 @@ function makeArray(thing) {
 	if (isArray(thing)) return thing.slice();
 	return [thing];
 }
+/**
+* Like {@link makeArray}, but without copying when the input is already an
+* array. Only safe when the caller treats the result as read-only — use it on
+* the hot path to avoid slicing read-only spec metadata.
+*/
+function asArray(thing) {
+	if (thing === void 0) return [];
+	if (isArray(thing)) return thing;
+	return [thing];
+}
 function assert(expr, msg = "") {
 	if (!expr) throw new Error(msg);
 }
-globalThis.process;
+const nodeProcess = globalThis.process;
+/**
+* Write text to stdout (1) or stderr (2) with a synchronous `write` on the file
+* descriptor.
+*
+* The first `console.log` in a Node process builds the stdout stream, which
+* costs 1-3 ms. That's more than parsing takes, so all of this library's output
+* goes through here instead. Without `node:fs` it falls back to `console`.
+*/
+function writeFd(fd, text) {
+	const fs = nodeProcess?.getBuiltinModule?.("node:fs");
+	if (!fs) {
+		(fd === 1 ? console.log : console.error)(text.endsWith("\n") ? text.slice(0, -1) : text);
+		return;
+	}
+	const bytes = new TextEncoder().encode(text);
+	let offset = 0;
+	try {
+		while (offset < bytes.length) offset += fs.writeSync(fd, bytes, offset, bytes.length - offset);
+	} catch (error) {
+		if (error.code === "EAGAIN") (fd === 1 ? nodeProcess?.stdout : nodeProcess?.stderr)?.write(bytes.subarray(offset));
+	}
+}
+/**
+* Where this library's output goes. Tests replace `write` to capture output.
+*
+* @internal
+*/
+const output = { write: writeFd };
+/** Print a message to stdout, trimming trailing whitespace. */
+function print(text) {
+	output.write(1, `${text.trimEnd()}\n`);
+}
+/**
+* Add the defaults of the arguments from index `from` on to `values`, stopping
+* at the first argument without one. The parser and help both use this, so
+* help only shows the defaults the parser uses.
+*/
+function addDefaults(values, args, from = 0) {
+	for (let i = from; i < args.length; i++) {
+		const value = args[i].default;
+		if (value === void 0) return;
+		values.push(value);
+	}
+}
 /**
 * Returns the minimum number of arguments that satisfies the args.
 *
@@ -35,42 +89,897 @@ function getMaxArgs(args) {
 	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;
+// src/directives.ts
+/** The directives in effect when no command sets any. */
+function defaultDirectives() {
+	return {
+		optionArgSeparators: ["="],
+		flagsArePosixNoncompliant: false,
+		optionsMustPrecedeArguments: false,
+		subcommandsMatchUniquePrefix: false
+	};
+}
 /**
-* Run a function once for each `args` property in the spec (recursive)
-*
-* This will convert single args to an array with one item.
+* Update `directives` for entering `command`. A subcommand inherits each
+* directive until it sets its own.
 */
-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);
+function applyDirectives(directives, command) {
+	const configured = command.parserDirectives;
+	if (!configured) return;
+	if (configured.optionArgSeparators) directives.optionArgSeparators = asArray(configured.optionArgSeparators);
+	if (typeof configured.subcommandsMatchUniquePrefix === "boolean") directives.subcommandsMatchUniquePrefix = configured.subcommandsMatchUniquePrefix;
+	if (typeof configured.optionsMustPrecedeArguments === "boolean") directives.optionsMustPrecedeArguments = configured.optionsMustPrecedeArguments;
+	if (typeof configured.flagsArePosixNoncompliant === "boolean") directives.flagsArePosixNoncompliant = configured.flagsArePosixNoncompliant;
 }
-/** 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);
+// src/subcommands.ts
+/**
+* A token that names no subcommand. The reason is only worked out when asked
+* for, since most tokens the parser tries aren't subcommands.
+*/
+var NoSubcommand = class {
+	subcommands;
+	token;
+	prefixOf;
+	command = null;
+	/**
+	* `prefixOf` are the commands `token` is a prefix of a name of, where
+	* prefixes match. There is never exactly one of them.
+	*/
+	constructor(subcommands, token, prefixOf) {
+		this.subcommands = subcommands;
+		this.token = token;
+		this.prefixOf = prefixOf;
+	}
+	/** Why the token names none of the subcommands, as an error message and suggestions. */
+	reason() {
+		const token = this.token;
+		if (token === "") return { message: "Expected a command, but the value was empty" };
+		if (this.prefixOf.length > 0) return { message: `Ambiguous command '${token}', could be: ${this.prefixOf.flatMap((command) => asArray(command.name).filter((name) => name.startsWith(token))).join(", ")}` };
+		const choices = visibleSubcommands(this.subcommands).map((command) => asArray(command.name));
+		return {
+			message: `Unknown command '${token}'`,
+			didYouMean: {
+				input: token,
+				choices
+			}
+		};
+	}
+};
+/** The subcommands that help, completion and suggestions show. */
+function visibleSubcommands(subcommands) {
+	return subcommands?.filter((subcommand) => !subcommand.hidden) ?? [];
 }
+/** The action of a command that has none of its own: print the command's help. */
+const usage = ({ help }) => {
+	print(help());
+	return 0;
+};
+// src/scope.ts
 /**
-* Run a function once for each `subcommands` property in the spec (recursive)
+* What a name means at one command on a path: the options, subcommands,
+* directives and argument limits in effect there.
 *
-* This will also run the function for the root spec itself.
+* Moving to a subcommand replaces the local options and adds its persistent
+* options to the inherited ones. A name refers to one option: a local option
+* wins over a persistent one, and a later option wins over an earlier one in
+* the same list. A subcommand wins over an option where the next token can
+* name a subcommand. The parser, help, completion and the spec checker all
+* ask this module what a name refers to, so they can't disagree.
+*/
+var CommandScope = class CommandScope {
+	/** Non-persistent options of the current command, in definition order. */
+	local = [];
+	/** Persistent options from every command on the path, in definition order. */
+	persistent = [];
+	/**
+	* Persistent subcommands of the commands above the current one, nearest
+	* command first, so a nearer one wins a name.
+	*/
+	inheritedSubcommands = [];
+	/** The directives in effect. A subcommand inherits each until it sets its own. */
+	directives = defaultDirectives();
+	current = null;
+	/** The fewest positional arguments the current command takes. */
+	argsMin = 0;
+	/** The most positional arguments the current command takes. */
+	argsMax = 0;
+	/** The scope at the last command on `path`. */
+	static at(path) {
+		const scope = new CommandScope();
+		for (const command of path) scope.enter(command);
+		return scope;
+	}
+	/** Move to `command`, a subcommand of the current one. */
+	enter(command) {
+		const parentSubcommands = this.current?.subcommands;
+		if (parentSubcommands) {
+			const persistent = parentSubcommands.filter((subcommand) => subcommand.isPersistent);
+			if (persistent.length > 0) this.inheritedSubcommands.unshift(...persistent);
+		}
+		this.current = command;
+		this.argsMin = getMinArgs(command.args);
+		this.argsMax = getMaxArgs(command.args);
+		this.local.length = 0;
+		if (command.options) for (const option of command.options) (option.isPersistent ? this.persistent : this.local).push(option);
+		applyDirectives(this.directives, command);
+	}
+	/** The current command. */
+	get command() {
+		if (!this.current) throw new Error("The scope hasn't entered a command");
+		return this.current;
+	}
+	/** Whether the current command has subcommands of its own or inherits any. */
+	get hasSubcommands() {
+		return this.current?.subcommands !== void 0 || this.inheritedSubcommands.length > 0;
+	}
+	/**
+	* The subcommands the next token can name: the current command's own,
+	* followed by each inherited one that an earlier one doesn't shadow a name
+	* of. Hidden ones are included.
+	*/
+	subcommands() {
+		const own = this.current?.subcommands ?? [];
+		if (this.inheritedSubcommands.length === 0) return own;
+		const all = [...own];
+		for (const candidate of this.inheritedSubcommands) if (!asArray(candidate.name).some((name) => all.some((earlier) => hasName(earlier.name, name)))) all.push(candidate);
+		return all;
+	}
+	/**
+	* Find the subcommand `token` names: one of the current command's own, or
+	* else an inherited persistent one. An exact name always wins. With
+	* `subcommandsMatchUniquePrefix`, a token that's a prefix of exactly one of
+	* the command's own names matches that command, unless `exactOnly`. A hidden
+	* or inherited command only matches its exact name, so it can't make a
+	* visible command's prefix ambiguous or take a prefix meant as an argument,
+	* and an empty token is no command's prefix.
+	*/
+	matchSubcommand(token, exactOnly = false) {
+		const own = this.current?.subcommands ?? [];
+		for (const candidate of own) if (hasName(candidate.name, token)) return { command: candidate };
+		for (const candidate of this.inheritedSubcommands) if (hasName(candidate.name, token)) return { command: candidate };
+		const matches = this.directives.subcommandsMatchUniquePrefix && !exactOnly ? prefixMatches(own, token) : [];
+		if (matches.length === 1) return { command: matches[0] };
+		return new NoSubcommand(this.subcommands(), token, matches);
+	}
+	/** The option `name` refers to, if any. */
+	resolve(name) {
+		const { local, persistent } = this;
+		for (let i = local.length - 1; i >= 0; i--) if (hasName(local[i].name, name)) return local[i];
+		for (let i = persistent.length - 1; i >= 0; i--) if (hasName(persistent[i].name, name)) return persistent[i];
+		return null;
+	}
+	/**
+	* The options that can be used here, in definition order, each with only
+	* its live names: the names that still refer to it. Options with every name
+	* shadowed are left out. Where the next token can name a subcommand, as
+	* `subcommands` says, a name that one matches is that subcommand's.
+	*/
+	live(subcommands = null) {
+		const owner = /* @__PURE__ */ new Map();
+		for (const options of [this.persistent, this.local]) for (const option of options) for (const name of asArray(option.name)) owner.set(name, option);
+		const pick = (options) => {
+			const picked = [];
+			for (const option of options) {
+				const names = asArray(option.name).filter((name) => owner.get(name) === option && !(subcommands && this.matchSubcommand(name, subcommands.exactOnly).command));
+				if (names.length > 0) picked.push({
+					option,
+					names
+				});
+			}
+			return picked;
+		};
+		return {
+			local: pick(this.local),
+			persistent: pick(this.persistent)
+		};
+	}
+	/**
+	* The options a user can see at the start of the current command: the
+	* {@link live} ones that aren't hidden, without the names a subcommand takes.
+	*/
+	visible() {
+		const { local, persistent } = this.live(this.hasSubcommands ? { exactOnly: false } : null);
+		const shown = (visible) => !visible.option.hidden;
+		return {
+			local: local.filter(shown),
+			persistent: persistent.filter(shown)
+		};
+	}
+	/** The live names of each option a user could have meant, for "did you mean" suggestions. */
+	suggestionNames() {
+		const { local, persistent } = this.live();
+		const shown = (visible) => !visible.option.hidden;
+		return [...local, ...persistent].filter(shown).map((visible) => visible.names);
+	}
+	/** The options that must be used, local first. */
+	required() {
+		return [...this.local, ...this.persistent].filter((option) => option.isRequired);
+	}
+	/**
+	* How each of `names` is written with `option`'s value here. Help shows
+	* these, completion offers them, and the spec checker reads each one back
+	* through the parser.
+	*/
+	forms(option, names = asArray(option.name)) {
+		const join = (name) => {
+			if (getMaxArgs(option.args) === 0) return null;
+			if (option.requiresSeparator) return this.requiredSeparator(option);
+			return !this.directives.flagsArePosixNoncompliant && (name === "-" || name === "+") ? "" : null;
+		};
+		return names.map((name) => ({
+			name,
+			join: join(name)
+		}));
+	}
+	/**
+	* The separator that must come between `option` and its value, or null if
+	* it can take a value as a separate token.
+	*/
+	requiredSeparator(option) {
+		const required = option.requiresSeparator;
+		if (typeof required === "string") return required;
+		return required ? this.directives.optionArgSeparators[0] ?? "=" : null;
+	}
+	/** Whether the parser splits an option from its value at `separator` here. */
+	readsSeparator(separator) {
+		return this.directives.optionArgSeparators.includes(separator);
+	}
+	/** The separator that `text` starts with, or "" if none. Used after a short option. */
+	leadingSeparator(text) {
+		for (const separator of this.directives.optionArgSeparators) if (text.startsWith(separator)) return separator;
+		return "";
+	}
+	/**
+	* The separator that appears first in `token`, so the value after it can
+	* contain the other separators. When two separators start at the same place,
+	* the longer one wins. Null if there's none, or if the one found is empty.
+	*/
+	firstSeparator(token) {
+		let found = "";
+		let index = -1;
+		for (const candidate of this.directives.optionArgSeparators) {
+			const at = token.indexOf(candidate);
+			if (at === -1) continue;
+			if (index === -1 || at < index || at === index && candidate.length > found.length) {
+				found = candidate;
+				index = at;
+			}
+		}
+		return found ? {
+			index,
+			separator: found
+		} : null;
+	}
+	/**
+	* Why `option`, used as `name`, can't take a value given after `separator`,
+	* or null if it can. A separate token has the separator "".
+	*/
+	separatorProblem(option, name, separator) {
+		const required = option.requiresSeparator;
+		if (typeof required === "string" && separator !== required) return `Incorrect separator, use '${required}' instead of '${separator}'`;
+		if (required === true && separator === "") return `Missing separator, use '${this.requiredSeparator(option)}' between ${name} and its value`;
+		return null;
+	}
+};
+const optionKeys = /* @__PURE__ */ new WeakMap();
+/**
+* A key for the set of `option`'s names. Options with the same names, in any
+* order, get the same key and are one option: the parser continues a
+* repeatable option's uses across them, counts one as used when the other was,
+* and stores their values under the same names, which is how they're read.
+* Options that share only some names are different options, and each shared
+* name refers to whichever one `resolve` picks.
+*/
+function optionKey(option) {
+	let key = optionKeys.get(option);
+	if (key === void 0) {
+		key = typeof option.name === "string" ? option.name : [...option.name].sort().join("\0");
+		optionKeys.set(option, key);
+	}
+	return key;
+}
+function hasName(names, name) {
+	return typeof names === "string" ? names === name : names.includes(name);
+}
+/** The visible commands that `token` is a prefix of a name of, each listed once. */
+function prefixMatches(subcommands, token) {
+	if (token === "") return [];
+	return subcommands.filter((candidate) => !candidate.hidden && asArray(candidate.name).some((name) => name.startsWith(token)));
+}
+// src/help.ts
+/**
+* Show an option's names, each written with its arguments the way `forms`
+* says. Names written the same way share one copy of the arguments.
 */
-function forEachSubcommand(spec, fn, path = []) {
-	path = path.concat(spec);
-	fn(spec, path);
-	for (const subcommand of makeArray(spec.subcommands)) forEachSubcommand(subcommand, fn, path);
+function optionToString(option, forms) {
+	const optionArgs = makeArray(option.args);
+	const sorted = [...forms].sort((a, b) => a.name.length - b.name.length);
+	return [...new Set(sorted.map((form) => form.join))].map((join) => {
+		return sorted.filter((form) => form.join === join).map((form) => form.name).join(", ") + argumentsAfterName(optionArgs, join);
+	}).join(", ");
+}
+/** The text after an option's name that shows its arguments, joined to the name by `join`. */
+function argumentsAfterName(args, join) {
+	if (args.length === 0) return "";
+	if (join === null) return ` ${summarizeArguments(args)}`;
+	const [first, ...rest] = args;
+	const name = first.name || "argument";
+	const joined = (first.isOptional ? `[${join}${name}]` : `${join}<${name}>`) + (first.isVariadic ? "..." : "");
+	return rest.length > 0 ? `${joined} ${summarizeArguments(rest)}` : joined;
+}
+function summarizeArguments(args) {
+	return args.map((arg) => argToString(arg)).join(" ");
+}
+function argToString(arg) {
+	const name = arg.name || "argument";
+	let lhs = "<";
+	let rhs = ">";
+	let suffix = "";
+	if (arg.isOptional) {
+		lhs = "[";
+		rhs = "]";
+	}
+	if (arg.isVariadic) suffix = "...";
+	return `${lhs}${name}${rhs}${suffix}`;
+}
+// src/errors.ts
+const repr$1 = JSON.stringify;
+/**
+* A command line the parser can't accept. `run` prints the message with the
+* help for the command at `context.path`, and suggests the closest of
+* `didYouMean.choices` if there is one.
+*/
+var ParseError = class extends Error {
+	context;
+	didYouMean;
+	constructor(context, message, didYouMean) {
+		super(message);
+		this.context = context;
+		this.didYouMean = didYouMean;
+		this.name = this.constructor.name;
+	}
+};
+var UnknownOption = class extends ParseError {
+	option;
+	constructor(option, validOptions, context) {
+		const msg = `${repr$1(option)} looks like a flag, but is unknown in this context`;
+		super(context, msg, {
+			input: option,
+			choices: validOptions
+		});
+		this.option = option;
+	}
+};
+var InvalidOptionArg = class extends ParseError {
+	option;
+	constructor(option, context) {
+		super(context, `Option ${option} doesn't take arguments`);
+		this.option = option;
+	}
+};
+var TooManyArguments = class extends ParseError {
+	constructor(value, context) {
+		super(context, `Too many arguments, ${repr$1(value)} was unexpected`);
+	}
+};
+var TooFewOptionArguments = class extends ParseError {
+	constructor(option, min, max, context) {
+		const msg = min === max ? `Option ${option} needs ${min} argument${min === 1 ? "" : "s"}` : !Number.isFinite(max) ? `Option ${option} needs at least ${min} argument${min === 1 ? "" : "s"}` : `Option ${option} needs between ${min} and ${max} arguments`;
+		super(context, msg);
+	}
+};
+var TooFewArguments = class extends ParseError {
+	constructor(min, max, context) {
+		const msg = min === max ? `Expected ${min} argument${min === 1 ? "" : "s"}` : !Number.isFinite(max) ? `Expected at least ${min} argument${min === 1 ? "" : "s"}` : `Expected between ${min} and ${max} arguments`;
+		super(context, msg);
+	}
+};
+var MissingRequiredOption = class extends ParseError {
+	constructor(name, context) {
+		const msg = `Option ${name} is required, but wasn't found`;
+		super(context, msg);
+	}
+};
+// src/parse.ts
+/** How many times `option` can be used. */
+function repeatLimit(option) {
+	return typeof option.isRepeatable === "number" ? option.isRepeatable : Infinity;
+}
+/**
+* Throw if the options used break a `dependsOn` or `exclusiveOn` rule, or if
+* any of `required` is missing.
+*/
+function checkOptionRules(options, seenOptions, required, context) {
+	for (const option of seenOptions) {
+		if (!option.dependsOn) continue;
+		for (const name of option.dependsOn) if (!options.has(name)) throw new ParseError(context, `${asArray(option.name).join("/")} requires ${name}, add it to fix this error`);
+	}
+	for (const option of seenOptions) {
+		if (!option.exclusiveOn) continue;
+		for (const name of option.exclusiveOn) if (options.has(name)) throw new ParseError(context, `${asArray(option.name).join("/")} can't be used together with ${name}`);
+	}
+	for (const option of required) for (const name of asArray(option.name)) if (!options.has(name)) throw new MissingRequiredOption(name, context);
+}
+/**
+* The state of reading one command line, one token at a time. This is the
+* only code that decides what each input token is. It never throws: it skips
+* whatever is invalid and keeps going, so {@link readNext} can still read a
+* line that's wrong at the moment, and it keeps the first problem it finds for
+* {@link parse} to throw. Each method handles one kind of token, and says what
+* the token was read as.
+*/
+var Scanner = class {
+	path;
+	optionAction = void 0;
+	args = [];
+	options = /* @__PURE__ */ new Map();
+	seenOptions = [];
+	argSeparatorIndex = -1;
+	scope = new CommandScope();
+	directives = this.scope.directives;
+	hasFoundArg = false;
+	openOption = null;
+	openOptionName = "";
+	valueCount = 0;
+	valueMin = 0;
+	separateValueMax = 0;
+	values = null;
+	valuesStart = 0;
+	valuesMin = 0;
+	valuesMax = 0;
+	valueArgs = [];
+	/**
+	* Makes the error for the first token that can't be read the way it's
+	* written, like an unknown option or a value an option doesn't take.
+	* {@link parse} stops there.
+	*/
+	problem = null;
+	tooManyArgs = null;
+	repeatedUses = /* @__PURE__ */ new Map();
+	constructor(spec) {
+		this.path = [spec];
+		this.scope.enter(spec);
+	}
+	ctx() {
+		return { path: [...this.path] };
+	}
+	/** Whether the open option can take the next token as a value. */
+	get hasRoomForValue() {
+		return this.valueCount < this.separateValueMax;
+	}
+	findOption(name) {
+		return this.scope.resolve(name);
+	}
+	/**
+	* Keep the problem `make` describes if it's the first. The error is only
+	* made if {@link parse} throws it, since a lenient read never needs it and
+	* an error is slow to make. So `make` can't read anything later tokens change.
+	*/
+	fail(make) {
+		if (!this.problem) {
+			const ctx = this.ctx();
+			this.problem = () => make(ctx);
+		}
+	}
+	/** Keep the first argument the command has no room for, like {@link fail}. */
+	failArgs(make) {
+		if (!this.tooManyArgs) {
+			const ctx = this.ctx();
+			this.tooManyArgs = () => make(ctx);
+		}
+	}
+	unknownOption(option) {
+		if (!this.problem) {
+			const names = this.scope.suggestionNames();
+			this.fail((ctx) => new UnknownOption(option, names, ctx));
+		}
+	}
+	endOption() {
+		const values = this.values;
+		if (values) {
+			const given = values.length - this.valuesStart;
+			if (given < this.valuesMin) {
+				const { openOptionName, valuesMin, valuesMax } = this;
+				this.fail((ctx) => new TooFewOptionArguments(openOptionName, valuesMin, valuesMax, ctx));
+			} else addDefaults(values, this.valueArgs, given);
+		}
+		this.values = null;
+	}
+	/** End the open option, so no later token can be its value. */
+	closeOption() {
+		this.endOption();
+		this.openOption = null;
+		this.valueCount = this.valueMin = this.separateValueMax = 0;
+	}
+	useOption(option, name) {
+		this.endOption();
+		this.openOption = option;
+		this.openOptionName = name;
+		this.valueCount = 0;
+		this.valueMin = getMinArgs(option.args);
+		this.separateValueMax = option.requiresSeparator ? 0 : getMaxArgs(option.args);
+		this.seenOptions.push(option);
+		if (option.action) this.optionAction = option.action;
+		const names = asArray(option.name);
+		const options = this.options;
+		let optionValues;
+		if (option.isRepeatable) {
+			const key = optionKey(option);
+			let uses = this.repeatedUses.get(key);
+			if (!uses) {
+				uses = {
+					values: [],
+					count: 0
+				};
+				this.repeatedUses.set(key, uses);
+			}
+			if (uses.count >= repeatLimit(option)) this.fail((ctx) => new ParseError(ctx, "Too many repetitions"));
+			uses.count += 1;
+			for (const other of names) options.set(other, uses.values);
+			if (!option.args) {
+				uses.values.push("");
+				return;
+			}
+			optionValues = uses.values;
+		} else {
+			optionValues = [];
+			for (const other of names) options.set(other, optionValues);
+		}
+		this.valuesMin = this.valueMin;
+		this.valuesMax = getMaxArgs(option.args);
+		if (this.valuesMax > 0) {
+			this.values = optionValues;
+			this.valuesStart = optionValues.length;
+			this.valueArgs = asArray(option.args);
+		}
+	}
+	/** Add a value to the open option. Returns whether it's a value the option accepts. */
+	addValue(value, separator) {
+		this.valueCount += 1;
+		if (!this.values) {
+			const name = this.openOptionName;
+			this.fail((ctx) => new InvalidOptionArg(name, ctx));
+			return false;
+		}
+		const problem = this.scope.separatorProblem(this.openOption, this.openOptionName, separator);
+		if (problem) this.fail((ctx) => new ParseError(ctx, problem));
+		this.values.push(value);
+		return problem === null;
+	}
+	/** Add a separate token as a value of the open option. */
+	value(token) {
+		this.addValue(token, "");
+		return {
+			kind: "value",
+			option: this.openOption
+		};
+	}
+	/**
+	* Add a value attached to the option's own token, starting at `start`. It's
+	* the option's only value, so no later token can be one. Returns where the
+	* value starts, or null if the option doesn't accept it.
+	*/
+	addAttachedValue(start, value, separator) {
+		const option = this.openOption;
+		const accepted = this.addValue(value, separator);
+		this.valueMin = this.separateValueMax = 0;
+		return accepted ? {
+			option,
+			start
+		} : null;
+	}
+	/**
+	* Whether the command already has all the arguments it takes. A command that
+	* requires a subcommand takes none.
+	*/
+	get argsAreFull() {
+		return this.scope.command.requiresSubcommand === true || this.args.length >= this.scope.argsMax;
+	}
+	addArg(value) {
+		this.endOption();
+		if (this.argsAreFull) this.failArgs((ctx) => new TooManyArguments(value, ctx));
+		this.args.push(value);
+		return { kind: "argument" };
+	}
+	/** Read `--`. Every token after it is an argument. */
+	argSeparator() {
+		this.closeOption();
+		const command = this.scope.command;
+		if (this.argsAreFull && !command.requiresSubcommand) this.failArgs((ctx) => new ParseError(ctx, "Unexpected argument '--', did you mean to use an option instead?"));
+		this.argSeparatorIndex = this.args.length;
+		return { kind: "separator" };
+	}
+	/**
+	* How the next token can name a subcommand, its own or an inherited one, or
+	* null if it can't. It can't once an argument is found, or while the open
+	* option needs the next token as its value. A required or variadic option
+	* value takes priority over a subcommand. A short optional value could be a
+	* prefix of a subcommand's name, so only an exact name can end an option
+	* that still has room.
+	*/
+	get subcommandMatching() {
+		if (this.hasFoundArg || !this.scope.hasSubcommands) return null;
+		if (this.valueCount < this.valueMin || this.hasRoomForValue && this.separateValueMax === Infinity) return null;
+		return { exactOnly: this.hasRoomForValue };
+	}
+	/**
+	* The subcommand the next token enters if it's `token`, or why it enters
+	* none. Null if the next token can't be a subcommand at all.
+	*/
+	subcommandFor(token) {
+		const matching = this.subcommandMatching;
+		return matching && this.scope.matchSubcommand(token, matching.exactOnly);
+	}
+	enterSubcommand(command) {
+		this.closeOption();
+		this.path.push(command);
+		this.scope.enter(command);
+		return {
+			kind: "subcommand",
+			command
+		};
+	}
+	/** Read a token like `-abc`, `+x` or `-ovalue`. */
+	shortOptions(token) {
+		const leadingChar = token[0];
+		const dashOption = this.findOption(leadingChar);
+		if (dashOption?.args && !this.findOption(token.slice(0, 2))) {
+			this.useOption(dashOption, leadingChar);
+			const attached = this.addAttachedValue(1, token.slice(1), "");
+			return {
+				kind: "options",
+				options: [dashOption],
+				attached
+			};
+		}
+		const used = [];
+		let attached = null;
+		for (let char = 1; char < token.length; char++) {
+			const optionName = leadingChar + token[char];
+			const option = this.findOption(optionName);
+			if (!option) {
+				if (char === 1 && this.hasRoomForValue) return this.value(token);
+				this.unknownOption(optionName);
+				continue;
+			}
+			this.useOption(option, optionName);
+			used.push(option);
+			if (char === token.length - 1) break;
+			const sep = this.scope.leadingSeparator(token.slice(char + 1));
+			if (option.args || sep && !this.findOption(leadingChar + token[char + 1])) {
+				const argStart = char + sep.length + 1;
+				attached = this.addAttachedValue(argStart, token.slice(argStart), sep);
+				break;
+			}
+		}
+		return used.length > 0 ? {
+			kind: "options",
+			options: used,
+			attached
+		} : { kind: "unknown" };
+	}
+	/**
+	* Read a token like `--name` or `--name=value`, or any token when options
+	* aren't POSIX compliant. Returns null if the token should be an argument.
+	*/
+	longOption(token) {
+		const found = this.scope.firstSeparator(token);
+		const optionName = found ? token.slice(0, found.index) : token;
+		const option = this.findOption(optionName);
+		if (option) {
+			this.useOption(option, optionName);
+			let attached = null;
+			if (found) {
+				const valueStart = found.index + found.separator.length;
+				attached = this.addAttachedValue(valueStart, token.slice(valueStart), found.separator);
+			}
+			return {
+				kind: "options",
+				options: [option],
+				attached
+			};
+		}
+		if (this.directives.flagsArePosixNoncompliant) return null;
+		if (this.hasRoomForValue) return this.value(token);
+		this.unknownOption(optionName);
+		return { kind: "unknown" };
+	}
+	/**
+	* Read a token that isn't `--`, a subcommand or an option. It's a value of
+	* the open option if that has room, and otherwise an argument, which stops
+	* later tokens from being subcommands. `unmatched` is why the token isn't a
+	* subcommand, if it could have been one.
+	*/
+	valueOrArg(token, unmatched) {
+		if (this.hasRoomForValue) return this.value(token);
+		if (unmatched && this.argsAreFull) {
+			const command = this.scope.command;
+			if (command.subcommands?.length || command.requiresSubcommand) this.failArgs((ctx) => {
+				const { message, didYouMean } = unmatched.reason();
+				return new ParseError(ctx, message, didYouMean);
+			});
+		}
+		this.hasFoundArg = true;
+		return this.addArg(token);
+	}
+	/**
+	* Throw if the finished command line is missing anything. Returns what it
+	* was parsed as. Only call this when there's no {@link problem}.
+	*/
+	finish() {
+		const command = this.scope.command;
+		const showsUsage = command.requiresSubcommand && !command.action && this.args.length === 0;
+		const skipsChecks = this.optionAction !== void 0 || showsUsage;
+		if (!skipsChecks && this.tooManyArgs) throw this.tooManyArgs();
+		if (!skipsChecks && this.args.length < this.scope.argsMin) throw new TooFewArguments(this.scope.argsMin, this.scope.argsMax, this.ctx());
+		this.endOption();
+		if (this.problem) throw this.problem();
+		if (!skipsChecks) checkOptionRules(this.options, this.seenOptions, this.scope.required(), this.ctx());
+		if (!command.requiresSubcommand && this.args.length >= this.scope.argsMin) addDefaults(this.args, asArray(command.args), this.args.length);
+		return {
+			path: this.path,
+			action: this.optionAction ?? command.action ?? usage,
+			args: this.args,
+			argSeparatorIndex: this.argSeparatorIndex,
+			options: this.options,
+			defaults: (name) => this.defaults(name)
+		};
+	}
+	/** See {@link ParseResult.defaults}. */
+	defaults(name) {
+		if (this.options.has(name)) return;
+		const args = asArray(this.scope.resolve(name)?.args);
+		if (args.length === 0 || args[0].isOptional) return;
+		const values = [];
+		addDefaults(values, args);
+		return values.length > 0 ? values : void 0;
+	}
+	/** Whether using `option` next would go over its repeat limit or break an `exclusiveOn` rule. */
+	conflicts(option) {
+		if ((this.repeatedUses.get(optionKey(option))?.count ?? 0) >= repeatLimit(option)) return true;
+		const options = this.options;
+		if (option.exclusiveOn?.some((name) => options.has(name))) return true;
+		const names = asArray(option.name);
+		return this.seenOptions.some((seen) => seen.exclusiveOn?.some((name) => names.includes(name)));
+	}
+	/** The options the next token can use. See {@link NextToken.options}. */
+	usableOptions() {
+		const used = new Set(this.seenOptions.map(optionKey));
+		const { local, persistent } = this.scope.live(this.subcommandMatching);
+		const usable = [];
+		for (const { option, names } of [...local, ...persistent]) {
+			if (this.conflicts(option)) continue;
+			usable.push({
+				option,
+				forms: this.scope.forms(option, names),
+				used: used.has(optionKey(option))
+			});
+		}
+		return usable;
+	}
+	/**
+	* What the next token can be. See {@link readNext}. Reading more tokens
+	* doesn't change what this returns.
+	*/
+	next() {
+		const open = this.openOption && this.hasRoomForValue ? this.openOption : null;
+		const command = this.scope.command;
+		const afterSeparator = this.argSeparatorIndex !== -1;
+		const optionsAllowed = !afterSeparator && this.optionsAllowed;
+		return {
+			path: [...this.path],
+			directives: { ...this.directives },
+			optionsAllowed,
+			subcommands: !afterSeparator && this.subcommandMatching ? this.scope.subcommands() : [],
+			options: optionsAllowed ? this.usableOptions() : [],
+			value: open && {
+				option: open,
+				arg: argAt(asArray(open.args), this.valueCount),
+				required: this.valueCount < this.valueMin
+			},
+			arg: open ? void 0 : argAt(asArray(command.args), this.args.length)
+		};
+	}
+	/** Whether the next token can be an option. Once options must stop, every token is an argument. */
+	get optionsAllowed() {
+		return !(this.directives.optionsMustPrecedeArguments && this.hasFoundArg);
+	}
+	read(token) {
+		if (this.argSeparatorIndex !== -1) return this.addArg(token);
+		const optionsAllowed = this.optionsAllowed;
+		if (token === "--" && optionsAllowed) return this.argSeparator();
+		const subcommand = this.subcommandFor(token);
+		if (subcommand?.command) return this.enterSubcommand(subcommand.command);
+		if (optionsAllowed) {
+			const flagsArePosixNoncompliant = this.directives.flagsArePosixNoncompliant;
+			const first = token.charCodeAt(0);
+			const isDoubleDash = first === 45 && token.charCodeAt(1) === 45;
+			if (!flagsArePosixNoncompliant && token.length > 1 && (first === 45 || first === 43) && !isDoubleDash) return this.shortOptions(token);
+			if (flagsArePosixNoncompliant || token.length > 2 && isDoubleDash) {
+				const reading = this.longOption(token);
+				if (reading) return reading;
+			}
+		}
+		return this.valueOrArg(token, subcommand);
+	}
+};
+/** The argument at `index`, reusing a final variadic argument. */
+function argAt(args, index) {
+	if (index < args.length) return args[index];
+	const last = args[args.length - 1];
+	return last?.isVariadic ? last : void 0;
+}
+/**
+* Start reading a command line for `spec`, to say what each token is read as
+* in turn. Reads leniently, like {@link readNext}.
+*/
+function tokenReader(spec) {
+	return new Scanner(spec);
+}
+/**
+* Say what the parser reads `token` as when it comes after `before`. Reads
+* leniently, like {@link readNext}. To read every token of a line, use
+* {@link tokenReader}.
+*/
+function readToken(spec, before, token) {
+	const s = new Scanner(spec);
+	for (const earlier of before) s.read(earlier);
+	return s.read(token);
+}
+// src/testing.ts
+const repr = JSON.stringify;
+/** One command in the spec, with what's in effect there. */
+var CommandVisit = class {
+	path;
+	own;
+	inherited;
+	built = null;
+	constructor(path, own, inherited) {
+		this.path = path;
+		this.own = own;
+		this.inherited = inherited;
+	}
+	/** The last command on the path. */
+	get command() {
+		return this.path[this.path.length - 1];
+	}
+	/** The options, subcommands and directives in effect here, built on first use. */
+	get scope() {
+		return this.built ??= CommandScope.at(this.path);
+	}
+};
+/**
+* Run a function once for each command in the spec, parents before their
+* subcommands, starting with `spec`. Each visit's path and scope start at
+* `spec`.
+*/
+function forEachCommand(spec, fn) {
+	const visit = (path, inherited) => {
+		const command = path[path.length - 1];
+		const own = makeArray(command.options).map((option, index) => ({
+			option,
+			definedIn: path,
+			index
+		}));
+		fn(new CommandVisit(path, own, inherited));
+		const next = [...inherited, ...own.filter(({ option }) => option.isPersistent)];
+		for (const subcommand of makeArray(command.subcommands)) visit([...path, subcommand], next);
+	};
+	visit([spec], []);
+}
+/**
+* Run a function once for each `args` property in the spec: each command's,
+* then its options'. This will convert single args to an array with one item.
+*/
+function forEachArgArray(spec, fn) {
+	forEachCommand(spec, ({ command, path }) => {
+		fn(makeArray(command.args), path);
+		for (const option of makeArray(command.options)) fn(makeArray(option.args), path);
+	});
 }
 function joinNames(names) {
 	return makeArray(names).sort((a, b) => a.length - b.length).join("|");
 }
-function isSameName(a, b) {
-	if (isArray(a) && isArray(b)) return a.every((item) => b.includes(item)) && b.every((item) => a.includes(item));
-	return a === b;
-}
 /** Compares spec values by shape. Any two functions count as the same shape. */
 function isSameStructure(a, b) {
 	if (a === b) return true;
@@ -84,6 +993,44 @@ function isSameStructure(a, b) {
 function namedArrayToString(...parts) {
 	return `\`${parts.map((named) => joinNames(named.name)).join(" ")}\``;
 }
+/** Name the last command on `path` in a message, with its index among its siblings. */
+function describeCommand(path) {
+	const command = path[path.length - 1];
+	const parent = path[path.length - 2];
+	if (!parent) return `Command ${namedArrayToString(command)}`;
+	const index = makeArray(parent.subcommands).indexOf(command);
+	return `Subcommand ${namedArrayToString(...path)} (index ${index})`;
+}
+/**
+* Name the option at `index` on the last command on `definedIn` in a message,
+* and the command it's used in when that isn't the one that defines it.
+*/
+function describeOption(definedIn, index, usedIn = definedIn) {
+	const option = makeArray(definedIn[definedIn.length - 1].options)[index];
+	const name = `${namedArrayToString(...definedIn, option)} (index ${index})`;
+	return usedIn === definedIn ? `Option ${name}` : `In ${namedArrayToString(...usedIn)}, option ${name}`;
+}
+/**
+* Run a function once for each option at each command it can be used in: the
+* command's own options, in definition order, then the persistent ones it
+* inherits. A check that is about how the option is written skips the uses
+* that aren't `isDefinedHere`. A check that depends on the scope sees the
+* option the way the parser does at each command.
+*/
+function forEachOption(spec, fn) {
+	forEachCommand(spec, ({ path, own, inherited, scope }) => {
+		for (const { option, definedIn, index } of [...own, ...inherited]) {
+			const where = describeOption(definedIn, index, path);
+			fn({
+				option,
+				path,
+				scope,
+				isDefinedHere: definedIn === path,
+				where
+			});
+		}
+	});
+}
 /** Asserts that required arguments do not come after an optional argument */
 function assertRequiredArgumentsDoNotFollowOptionalArguments(spec) {
 	forEachArgArray(spec, (args, path) => {
@@ -96,130 +1043,134 @@ function assertRequiredArgumentsDoNotFollowOptionalArguments(spec) {
 		}
 	});
 }
+/**
+* Asserts that the parser can use every default. A positional argument with a
+* default must be optional. A required option argument's default is only used
+* when the option is left out, so every argument before it needs a default
+* too, and the option can't be required.
+*/
+function assertDefaultsCanBeUsed(spec) {
+	forEachCommand(spec, ({ command, path }) => {
+		for (const [index, arg] of makeArray(command.args).entries()) assert(arg.default === void 0 || arg.isOptional, `In ${namedArrayToString(...path)}, argument ${arg.name || index} has a default, but it's required, so the default is never used`);
+	});
+	forEachOption(spec, ({ option, isDefinedHere, where }) => {
+		if (!isDefinedHere) return;
+		let firstWithout = null;
+		for (const [index, arg] of makeArray(option.args).entries()) {
+			if (arg.default === void 0) {
+				firstWithout ??= index;
+				continue;
+			}
+			if (arg.isOptional) continue;
+			const name = `${where}, argument ${arg.name || index} has a default, but`;
+			assert(!option.isRequired, `${name} the option is required, so the default is never used`);
+			assert(firstWithout === null, `${name} the argument at index ${firstWithout} has none, so the default is never used`);
+		}
+	});
+}
 /** 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`);
-		}
+	forEachOption(spec, ({ option, isDefinedHere, where }) => {
+		if (!isDefinedHere || typeof option.isRepeatable !== "number") return;
+		assert(Number.isSafeInteger(option.isRepeatable), `${where} has its \`isRepeatable\` value set to a number that is not an integer`);
+		assert(!(option.isRepeatable < 1), `${where} has its \`isRepeatable\` value set to a number below 1, which means it can't be used at all`);
+		assert(option.isRepeatable !== 1, `${where} 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) => {
+	forEachCommand(spec, ({ path, own }) => {
 		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.`);
+		for (const { option, index } of own) for (const name of makeArray(option.name)) {
+			assert(!optionNames.has(name), `${describeOption(path, 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.`);
+	forEachCommand(spec, ({ path, own, inherited }) => {
+		for (const { option, index } of own) for (const name of makeArray(option.name)) assert(!inherited.some((persistent) => makeArray(persistent.option.name).includes(name)), `${describeOption(path, index)} shadows the name of a persistent option, ${repr(name)}. Option names can't shadow persistent options.`);
 	});
 }
 /**
-* Asserts that a subcommand's option isn't a different option with exactly the
-* same names as one on a parent.
+* Asserts that when a subcommand's option and a different option on a parent
+* share a name, each of them has a name of its own.
 *
-* Parsed values are looked up by name, so that parent's value would be
-* unreadable. A shared name is fine when each option has a name of its own, and
-* when the options are identical, such as an option kept in a constant.
+* Parsed values are looked up by name, and an option sets every one of its
+* names when it's used. If every name of the parent's option is also the
+* subcommand's, using the subcommand's option replaces the parent's value, so
+* it can't be read. If every name of the subcommand's option is also the
+* parent's, its names hold the parent's value when it isn't used, so it can't
+* tell whether it was. Options with the same names are fine when they're
+* identical, such as an option kept in a constant, because the parser treats
+* them as one option.
 *
 * This skips persistent parent options, because
 * {@link assertOptionsDoNotShadowPersistentOptions} covers those and
 * `allowShadowingPersistentOptions` opts out of it.
 */
 function assertOptionsHaveDifferentNamesFromParents(spec) {
-	forEachOptionArray(spec, (options, path) => {
-		const parents = path.slice(0, -1);
-		for (const [index, option] of options.entries()) for (const parent of parents) for (const parentOption of makeArray(parent.options)) assert(!(!parentOption.isPersistent && isSameName(parentOption.name, option.name) && !isSameStructure({
-			...parentOption,
-			name: 0
-		}, {
-			...option,
-			name: 0
-		})), `The option ${namedArrayToString(...path, option)} (index ${index}) has the same names as a different option, ${namedArrayToString(parent, parentOption)}, so the parent's value can't be read. Add a name that only one of them uses.`);
+	forEachOption(spec, ({ option, path, isDefinedHere, where }) => {
+		if (!isDefinedHere) return;
+		const names = makeArray(option.name);
+		for (const parent of path.slice(0, -1)) for (const parentOption of makeArray(parent.options)) {
+			if (parentOption.isPersistent) continue;
+			const parentNames = makeArray(parentOption.name);
+			const other = namedArrayToString(parent, parentOption);
+			if (optionKey(parentOption) === optionKey(option)) {
+				assert(isSameStructure({
+					...parentOption,
+					name: 0
+				}, {
+					...option,
+					name: 0
+				}), `${where} has the same names as a different option, ${other}, so the parent's value can't be read. Add a name that only one of them uses.`);
+				continue;
+			}
+			assert(!parentNames.every((name) => names.includes(name)), `${where} has every name of a different option, ${other}, so the parent's value can't be read. Add a name that only the parent's option uses.`);
+			assert(!names.every((name) => parentNames.includes(name)), `${where} only has names of a different option, ${other}, so it can't tell whether it was used. Add a name that only the subcommand's option uses.`);
+		}
 	});
 }
 /** Asserts that subcommands don't share a name with a sibling subcommand */
 function assertSubcommandsHaveLocallyUniqueNames(spec) {
-	forEachSubcommand(spec, (spec, path) => {
+	forEachCommand(spec, ({ command, path }) => {
 		const names = /* @__PURE__ */ new Set();
-		for (const [index, subcommand] of makeArray(spec.subcommands).entries()) for (const name of makeArray(subcommand.name)) {
+		for (const [index, subcommand] of makeArray(command.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.`);
-		}
+	forEachCommand(spec, ({ command, path }) => {
+		const separators = makeArray(command.parserDirectives?.optionArgSeparators);
+		for (const [sepIndex, separator] of separators.entries()) assert(separator !== "", `${describeCommand(path)} 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
+* Asserts that the parser reads options named "+" or "-" the way they're
+* written, which needs them to take one argument.
+*
+* @deprecated {@link assertNamesReadBack} checks this for every option.
 */
 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`);
-		}
-	});
+	assertOptionFormsReadBack(spec, (_, name) => name === "-" || name === "+");
 }
 /**
 * 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`);
+	forEachOption(spec, ({ option, isDefinedHere, where }) => {
+		if (!isDefinedHere) return;
+		for (const name of makeArray(option.name)) assert(name === name.trim(), `${where} 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`);
+	forEachCommand(spec, ({ command, path }) => {
+		for (const name of makeArray(command.name)) assert(name === name.trim(), `${describeCommand(path)} 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`);
@@ -230,11 +1181,11 @@ function assertNamesHaveNoExtraWhitespace(spec) {
 */
 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`);
+	forEachOption(spec, ({ option, isDefinedHere, where }) => {
+		if (isDefinedHere) assert(option.description, `${where} 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`);
+	forEachCommand(spec, ({ command, path }) => {
+		assert(command.description, `${describeCommand(path)} has no description`);
 	});
 }
 /**
@@ -242,30 +1193,143 @@ function assertEverythingHasDescription(spec) {
 */
 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`);
+	forEachOption(spec, ({ option, isDefinedHere, where }) => {
+		if (!isDefinedHere || !option.description) return;
+		assert(option.description.split("\n").every((line) => line.length <= 68), `${where} 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`);
+	forEachCommand(spec, ({ command, path }) => {
+		if (command.description) assert(command.description.split("\n").every((line) => line.length <= 68), `${describeCommand(path)} has a description line over 68 characters`);
+		for (const [index, arg] of makeArray(command.args).entries()) assert(!arg.description || arg.description.split("\n").every((line) => line.length <= 68), `In ${namedArrayToString(...path)}, argument ${arg.name || index} has a description line over 68 characters`);
 	});
 }
+/**
+* Asserts that the parser reads options with `requiresSeparator` the way
+* they're written, which needs them to take at most one argument.
+*
+* @deprecated {@link assertNamesReadBack} checks this for every option.
+*/
 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`);
+	assertOptionFormsReadBack(spec, (option) => Boolean(option.requiresSeparator));
+}
+/**
+* What the parser read a token as, for a message. `path` is the command the
+* token came after.
+*/
+function describeReading(reading, path) {
+	switch (reading.kind) {
+		case "separator": return "the end of options, '--'";
+		case "subcommand": return `the subcommand ${namedArrayToString(...path, reading.command)}`;
+		case "options": return reading.options.length === 1 ? `the option ${namedArrayToString(reading.options[0])}` : `the options ${reading.options.map((option) => namedArrayToString(option)).join(", ")}`;
+		case "value": return `a value of the option ${namedArrayToString(reading.option)}`;
+		case "argument": return "an argument";
+		case "unknown": return "an option that doesn't exist";
+	}
+}
+/** Whether the parser read a token as `option` alone. */
+function readsAs(reading, option) {
+	return reading.kind === "options" && reading.options.length === 1 && reading.options[0] === option;
+}
+/**
+* The tokens that reach the last command on `path`, using each command's first
+* name. {@link assertNamesReadBack} checks subcommand names from the root down
+* before options, so each of these is a name the parser reads.
+*/
+function tokensTo(path) {
+	return path.slice(1).map((command) => makeArray(command.name)[0]);
+}
+/**
+* A value for writing options with at the last command on `path`. No name
+* there starts with it, or with it after '-' or '+', so the parser can only
+* read it as a value.
+*/
+function placeholderValue(path, scope) {
+	const names = [...[...scope.local, ...scope.persistent].flatMap((option) => makeArray(option.name)), ...makeArray(path[path.length - 1].subcommands).flatMap((command) => makeArray(command.name))];
+	for (const value of "0123456789abcdefghijklmnopqrstuvwxyz") {
+		const starts = [
+			value,
+			`-${value}`,
+			`+${value}`
+		];
+		if (!names.some((name) => starts.some((start) => name.startsWith(start)))) return value;
+	}
+	return "0";
+}
+/**
+* The tokens that write `form` with every value `option` takes, or one more
+* than its minimum if it takes any number. The first value is joined to the
+* name if the form says so, and the rest are separate tokens.
+*/
+function writeForm(option, form, value) {
+	const max = getMaxArgs(option.args);
+	const count = Number.isFinite(max) ? max : getMinArgs(option.args) + 1;
+	const values = Array.from({ length: count }, () => value);
+	if (form.join === null) return [form.name, ...values];
+	return [form.name + form.join + values[0], ...values.slice(1)];
+}
+/**
+* Asserts that the parser reads each name of the options that `include`
+* picks the way the name is written. See {@link assertNamesReadBack}.
+*/
+function assertOptionFormsReadBack(spec, include) {
+	const root = spec;
+	forEachOption(spec, ({ option, where, scope, path }) => {
+		const before = tokensTo(path);
+		const value = placeholderValue(path, scope);
+		const names = makeArray(option.name).filter((name) => scope.resolve(name) === option);
+		for (const form of scope.forms(option, names)) {
+			if (!include(option, form.name)) continue;
+			const tokens = writeForm(option, form, value);
+			const reader = tokenReader(root);
+			for (const token of before) reader.read(token);
+			const first = reader.read(tokens[0]);
+			if (form.join !== "") {
+				const reading = form.join === null ? first : readToken(root, before, form.name);
+				assert(readsAs(reading, option), `${where} has the name '${form.name}', but the parser reads it as ${describeReading(reading, path)}`);
+			}
+			const written = `${where} is written '${optionToString(option, [form])}'`;
+			if (form.join) assert(scope.readsSeparator(form.join), `${written}, but '${form.join}' isn't one of the option arg separators there (${scope.directives.optionArgSeparators.map((separator) => `'${separator}'`).join(", ") || "none"}). Add it to \`parserDirectives.optionArgSeparators\`.`);
+			if (form.join !== null) {
+				const joined = first.kind === "options" && first.attached?.option === option;
+				assert(readsAs(first, option) && joined, `${written}, but the parser reads '${tokens[0]}' as ${describeReading(first, path)}${joined ? "" : " without a value"}`);
+			}
+			for (let index = 1; index < tokens.length; index++) {
+				const reading = reader.read(tokens[index]);
+				assert(reading.kind === "value" && reading.option === option, `${written}, but in '${tokens.join(" ")}' the parser reads '${tokens[index]}' as ${describeReading(reading, path)}`);
+			}
 		}
 	});
 }
+/**
+* Asserts that the parser reads every name the way it's written: each name of
+* a subcommand enters that subcommand, and each name of an option uses that
+* option, at every command the option can be used in. Each option is also
+* written the way help shows it, with every value it takes, and the parser has
+* to read all of those values as the option's.
+*/
+function assertNamesReadBack(spec) {
+	const root = spec;
+	forEachCommand(spec, ({ command, path }) => {
+		const before = tokensTo(path);
+		for (const subcommand of makeArray(command.subcommands)) for (const name of makeArray(subcommand.name)) {
+			const reading = readToken(root, before, name);
+			if (reading.kind === "subcommand" && reading.command === subcommand) continue;
+			assert(false, `${describeCommand([...path, subcommand])} has the name '${name}', but the parser reads it as ${describeReading(reading, path)}`);
+		}
+	});
+	assertOptionFormsReadBack(spec, () => true);
+}
 function assertCommonOptionsArePersistent(spec) {
 	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)]);
+	forEachCommand(spec, ({ command, path }) => {
+		if (!command.subcommands) return;
+		let common = makeArray(command.options);
+		forEachCommand(command, ({ command: below }) => {
+			const keys = makeArray(below.options).map(optionKey);
+			common = common.filter((option) => keys.includes(optionKey(option)));
+		});
+		for (const option of common) {
+			const key = optionKey(option);
+			if (!failures.some(([failed]) => failed === key)) failures.push([key, 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.
@@ -274,29 +1338,23 @@ ${failures.map(([, line]) => " * " + line).join("\n")}
 }
 /**
 * Asserts that references to other options by name actually refer to options
-* that exist in scope
+* that exist in scope, at every command the option can be used in
 */
 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`);
-		}
+	forEachOption(spec, ({ option, where, scope }) => {
+		for (const name of makeArray(option.dependsOn)) assert(scope.resolve(name) !== null, `${where} depends on an option named ${repr(name)}, which doesn't exist in its scope`);
+		for (const name of makeArray(option.exclusiveOn)) assert(scope.resolve(name) !== null, `${where} 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 }\``);
+	forEachCommand(spec, ({ command, path, scope }) => {
+		if (!scope.directives.subcommandsMatchUniquePrefix) return;
+		assert(!(command.subcommands && command.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);
@@ -313,118 +1371,106 @@ async function runStep(context, name, fn) {
 */
 function test(spec, options = {}) {
 	const { allowShadowingPersistentOptions = false, allowNoDescription = false, allowLongDescriptionLines = false, allowMatchingSubcommandPrefixAndArgs = false, namingStyle = "sentence" } = options;
+	const checks = [
+		[
+			"Required arguments don't follow optional arguments",
+			"assertRequiredArgumentsDoNotFollowOptionalArguments",
+			assertRequiredArgumentsDoNotFollowOptionalArguments,
+			true
+		],
+		[
+			"The parser can use every default",
+			"assertDefaultsCanBeUsed",
+			assertDefaultsCanBeUsed,
+			true
+		],
+		[
+			"Repeatable options that are numbers are integers greater than 1",
+			"assertRepeatableOptionsArePositiveIntegers",
+			assertRepeatableOptionsArePositiveIntegers,
+			true
+		],
+		[
+			"Options have locally unique names",
+			"assertOptionsHaveLocallyUniqueNames",
+			assertOptionsHaveLocallyUniqueNames,
+			true
+		],
+		[
+			"Options don't shadow persistent options",
+			"assertOptionsDoNotShadowPersistentOptions",
+			assertOptionsDoNotShadowPersistentOptions,
+			!allowShadowingPersistentOptions
+		],
+		[
+			"Different options on a subcommand and its parents have different names",
+			"assertOptionsHaveDifferentNamesFromParents",
+			assertOptionsHaveDifferentNamesFromParents,
+			true
+		],
+		[
+			"Subcommands have locally unique names",
+			"assertSubcommandsHaveLocallyUniqueNames",
+			assertSubcommandsHaveLocallyUniqueNames,
+			true
+		],
+		[
+			"The parser reads every option and subcommand the way it's written",
+			"assertNamesReadBack",
+			assertNamesReadBack,
+			true
+		],
+		[
+			"Option arg separators are not an empty string",
+			"assertOptionArgSeparatorsHaveCharacters",
+			assertOptionArgSeparatorsHaveCharacters,
+			true
+		],
+		[
+			"Names have no extra leading or trailing whitespace",
+			"assertNamesHaveNoExtraWhitespace",
+			assertNamesHaveNoExtraWhitespace,
+			true
+		],
+		[
+			"Everything has a description",
+			"assertEverythingHasDescription",
+			assertEverythingHasDescription,
+			!allowNoDescription
+		],
+		[
+			"Each line in descriptions is less than or equal to 68 characters",
+			"assertDescriptionLineLengthUnder69",
+			assertDescriptionLineLengthUnder69,
+			!allowLongDescriptionLines
+		],
+		[
+			"Common options are not defined on every subcommand",
+			"assertCommonOptionsArePersistent",
+			assertCommonOptionsArePersistent,
+			true
+		],
+		[
+			"References to other options by name are valid",
+			"assertOptionNameReferencesExist",
+			assertOptionNameReferencesExist,
+			true
+		],
+		[
+			"Commands with `subcommandsMatchUniquePrefix` don't have arguments and subcommands",
+			"assertPrefixMatchCommandsHaveNoArguments",
+			assertPrefixMatchCommandsHaveNoArguments,
+			!allowMatchingSubcommandPrefixAndArgs
+		]
+	];
 	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 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: "Different options on a subcommand and its parents have different names",
-			function: "assertOptionsHaveDifferentNamesFromParents"
-		}), () => {
-			assertOptionsHaveDifferentNamesFromParents(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);
-		});
+		for (const [sentence, functionName, check, enabled] of checks) {
+			if (!enabled) continue;
+			await runStep(t, namingStyle === "function" ? functionName : sentence, () => check(spec));
+		}
 	};
 }
 const testSpec = test;
-export { assertCommonOptionsArePersistent, assertDescriptionLineLengthUnder69, assertEverythingHasDescription, assertLongOptionNamesDoNotStartWithSingleDash, assertNamesHaveNoExtraWhitespace, assertNothingIsNamedDashDash, assertOptionArgSeparatorsHaveCharacters, assertOptionNameReferencesExist, assertOptionNamesStartWithDashes, assertOptionsDoNotShadowPersistentOptions, assertOptionsHaveDifferentNamesFromParents, assertOptionsHaveLocallyUniqueNames, assertPlusMinusOptionsTakeOneArg, assertPrefixMatchCommandsHaveNoArguments, assertRepeatableOptionsArePositiveIntegers, assertRequiredArgumentsDoNotFollowOptionalArguments, assertRequiresSeparatorTakesOneArg, assertSubcommandsHaveLocallyUniqueNames, test, testSpec };
+export { assertCommonOptionsArePersistent, assertDefaultsCanBeUsed, assertDescriptionLineLengthUnder69, assertEverythingHasDescription, assertNamesHaveNoExtraWhitespace, assertNamesReadBack, assertOptionArgSeparatorsHaveCharacters, assertOptionNameReferencesExist, assertOptionsDoNotShadowPersistentOptions, assertOptionsHaveDifferentNamesFromParents, assertOptionsHaveLocallyUniqueNames, assertPlusMinusOptionsTakeOneArg, assertPrefixMatchCommandsHaveNoArguments, assertRepeatableOptionsArePositiveIntegers, assertRequiredArgumentsDoNotFollowOptionalArguments, assertRequiresSeparatorTakesOneArg, assertSubcommandsHaveLocallyUniqueNames, test, testSpec };
 
 //# sourceMappingURL=testing.js.map