@optique/core 0.2.0 → 0.3.0-dev.35

package/dist/index.cjs

@@ -11,6 +11,7 @@ exports.choice = require_valueparser.choice;
 exports.command = require_parser.command;
 exports.concat = require_parser.concat;
 exports.constant = require_parser.constant;
+exports.flag = require_parser.flag;
 exports.float = require_valueparser.float;
 exports.formatDocPage = require_doc.formatDocPage;
 exports.formatMessage = require_message.formatMessage;

package/dist/index.d.cts

@@ -2,6 +2,6 @@ import { Message, MessageFormatOptions, MessageTerm, formatMessage, message, met
 import { OptionName, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, formatUsage, formatUsageTerm, normalizeUsage } from "./usage.cjs";
 import { DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, formatDocPage } from "./doc.cjs";
 import { ChoiceOptions, FloatOptions, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, StringOptions, UrlOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, choice, float, integer, isValueParser, locale, string, url, uuid } from "./valueparser.cjs";
-import { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.cjs";
+import { ArgumentOptions, CommandOptions, FlagOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, flag, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.cjs";
 import { RunError, RunOptions, run } from "./facade.cjs";
-export { ArgumentOptions, ChoiceOptions, CommandOptions, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, FloatOptions, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, Message, MessageFormatOptions, MessageTerm, MultipleOptions, OptionName, OptionOptions, Parser, ParserContext, ParserResult, Result, RunError, RunOptions, StringOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, argument, choice, command, concat, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };
+export { ArgumentOptions, ChoiceOptions, CommandOptions, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, FlagOptions, FloatOptions, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, Message, MessageFormatOptions, MessageTerm, MultipleOptions, OptionName, OptionOptions, Parser, ParserContext, ParserResult, Result, RunError, RunOptions, StringOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, argument, choice, command, concat, constant, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };

package/dist/index.d.ts

@@ -2,6 +2,6 @@ import { Message, MessageFormatOptions, MessageTerm, formatMessage, message, met
 import { OptionName, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, formatUsage, formatUsageTerm, normalizeUsage } from "./usage.js";
 import { DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, formatDocPage } from "./doc.js";
 import { ChoiceOptions, FloatOptions, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, StringOptions, UrlOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, choice, float, integer, isValueParser, locale, string, url, uuid } from "./valueparser.js";
-import { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.js";
+import { ArgumentOptions, CommandOptions, FlagOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, flag, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.js";
 import { RunError, RunOptions, run } from "./facade.js";
-export { ArgumentOptions, ChoiceOptions, CommandOptions, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, FloatOptions, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, Message, MessageFormatOptions, MessageTerm, MultipleOptions, OptionName, OptionOptions, Parser, ParserContext, ParserResult, Result, RunError, RunOptions, StringOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, argument, choice, command, concat, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };
+export { ArgumentOptions, ChoiceOptions, CommandOptions, DocEntry, DocFragment, DocFragments, DocPage, DocPageFormatOptions, DocSection, FlagOptions, FloatOptions, InferValue, IntegerOptionsBigInt, IntegerOptionsNumber, LocaleOptions, Message, MessageFormatOptions, MessageTerm, MultipleOptions, OptionName, OptionOptions, Parser, ParserContext, ParserResult, Result, RunError, RunOptions, StringOptions, UrlOptions, Usage, UsageFormatOptions, UsageTerm, UsageTermFormatOptions, Uuid, UuidOptions, ValueParser, ValueParserResult, argument, choice, command, concat, constant, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };

package/dist/index.js

@@ -2,7 +2,7 @@ import { formatMessage, message, metavar, optionName, optionNames, text, value,
 import { formatUsage, formatUsageTerm, normalizeUsage } from "./usage.js";
 import { formatDocPage } from "./doc.js";
 import { choice, float, integer, isValueParser, locale, string, url, uuid } from "./valueparser.js";
-import { argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.js";
+import { argument, command, concat, constant, flag, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault } from "./parser.js";
 import { RunError, run } from "./facade.js";
 
-export { RunError, argument, choice, command, concat, constant, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };
+export { RunError, argument, choice, command, concat, constant, flag, float, formatDocPage, formatMessage, formatUsage, formatUsageTerm, getDocPage, integer, isValueParser, locale, map, merge, message, metavar, multiple, normalizeUsage, object, option, optionName, optionNames, optional, or, parse, run, string, text, tuple, url, uuid, value, values, withDefault };

package/dist/parser.cjs

@@ -222,6 +222,163 @@ function option(...args) {
 	};
 }
 /**
+* Creates a parser for command-line flags that must be explicitly provided.
+* Unlike {@link option}, this parser fails if the flag is not present, making
+* it suitable for required boolean flags that don't have a meaningful default.
+*
+* The key difference from {@link option} is:
+* - {@link option} without a value parser: Returns `false` when not present
+* - {@link flag}: Fails parsing when not present, only produces `true`
+*
+* This is useful for dependent options where the presence of a flag changes
+* the shape of the result type.
+*
+* @param args The {@link OptionName}s to parse, followed by an optional
+*             {@link FlagOptions} object that allows you to specify
+*             a description or other metadata.
+* @returns A {@link Parser} that produces `true` when the flag is present
+*          and fails when it is not present.
+*
+* @example
+* ```typescript
+* // Basic flag usage
+* const parser = flag("-f", "--force");
+* // Succeeds with true: parse(parser, ["-f"])
+* // Fails: parse(parser, [])
+*
+* // With description
+* const verboseFlag = flag("-v", "--verbose", {
+*   description: "Enable verbose output"
+* });
+* ```
+*/
+function flag(...args) {
+	const lastArg = args.at(-1);
+	let optionNames$1;
+	let options = {};
+	if (typeof lastArg === "object" && lastArg != null && !Array.isArray(lastArg)) {
+		options = lastArg;
+		optionNames$1 = args.slice(0, -1);
+	} else optionNames$1 = args;
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: 10,
+		usage: [{
+			type: "option",
+			names: optionNames$1
+		}],
+		initialState: void 0,
+		parse(context) {
+			if (context.optionsTerminated) return {
+				success: false,
+				consumed: 0,
+				error: require_message.message`No more options can be parsed.`
+			};
+			else if (context.buffer.length < 1) return {
+				success: false,
+				consumed: 0,
+				error: require_message.message`Expected an option, but got end of input.`
+			};
+			if (context.buffer[0] === "--") return {
+				success: true,
+				next: {
+					...context,
+					buffer: context.buffer.slice(1),
+					state: context.state,
+					optionsTerminated: true
+				},
+				consumed: context.buffer.slice(0, 1)
+			};
+			if (optionNames$1.includes(context.buffer[0])) {
+				if (context.state?.success) return {
+					success: false,
+					consumed: 1,
+					error: require_message.message`${require_message.optionName(context.buffer[0])} cannot be used multiple times.`
+				};
+				return {
+					success: true,
+					next: {
+						...context,
+						state: {
+							success: true,
+							value: true
+						},
+						buffer: context.buffer.slice(1)
+					},
+					consumed: context.buffer.slice(0, 1)
+				};
+			}
+			const prefixes = optionNames$1.filter((name) => name.startsWith("--") || name.startsWith("/")).map((name) => name.startsWith("/") ? `${name}:` : `${name}=`);
+			for (const prefix of prefixes) if (context.buffer[0].startsWith(prefix)) {
+				const value = context.buffer[0].slice(prefix.length);
+				return {
+					success: false,
+					consumed: 1,
+					error: require_message.message`Flag ${require_message.optionName(prefix.slice(0, -1))} does not accept a value, but got: ${value}.`
+				};
+			}
+			const shortOptions = optionNames$1.filter((name) => name.match(/^-[^-]$/));
+			for (const shortOption of shortOptions) {
+				if (!context.buffer[0].startsWith(shortOption)) continue;
+				if (context.state?.success) return {
+					success: false,
+					consumed: 1,
+					error: require_message.message`${require_message.optionName(shortOption)} cannot be used multiple times.`
+				};
+				return {
+					success: true,
+					next: {
+						...context,
+						state: {
+							success: true,
+							value: true
+						},
+						buffer: [`-${context.buffer[0].slice(2)}`, ...context.buffer.slice(1)]
+					},
+					consumed: [context.buffer[0].slice(0, 2)]
+				};
+			}
+			return {
+				success: false,
+				consumed: 0,
+				error: require_message.message`No matched option for ${require_message.optionName(context.buffer[0])}.`
+			};
+		},
+		complete(state) {
+			if (state == null) return {
+				success: false,
+				error: require_message.message`Required flag ${require_message.optionNames(optionNames$1)} is missing.`
+			};
+			if (state.success) return {
+				success: true,
+				value: true
+			};
+			return {
+				success: false,
+				error: require_message.message`${require_message.optionNames(optionNames$1)}: ${state.error}`
+			};
+		},
+		getDocFragments(_state, _defaultValue) {
+			const fragments = [{
+				type: "entry",
+				term: {
+					type: "option",
+					names: optionNames$1
+				},
+				description: options.description
+			}];
+			return {
+				fragments,
+				description: options.description
+			};
+		},
+		[Symbol.for("Deno.customInspect")]() {
+			return `flag(${optionNames$1.map((o) => JSON.stringify(o)).join(", ")})`;
+		}
+	};
+}
+/**
 * Creates a parser that expects a single argument value.
 * This parser is typically used for positional arguments
 * that are not options or flags.
@@ -1231,6 +1388,7 @@ exports.argument = argument;
 exports.command = command;
 exports.concat = concat;
 exports.constant = constant;
+exports.flag = flag;
 exports.getDocPage = getDocPage;
 exports.map = map;
 exports.merge = merge;

package/dist/parser.d.cts

@@ -189,6 +189,47 @@ declare function option(...optionNames: readonly OptionName[]): Parser<boolean,
  *          values.
  */
 declare function option(...args: readonly [...readonly OptionName[], OptionOptions]): Parser<boolean, ValueParserResult<boolean> | undefined>;
+/**
+ * Options for the {@link flag} parser.
+ */
+interface FlagOptions {
+  /**
+   * The description of the flag, which can be used for help messages.
+   */
+  readonly description?: Message;
+}
+/**
+ * Creates a parser for command-line flags that must be explicitly provided.
+ * Unlike {@link option}, this parser fails if the flag is not present, making
+ * it suitable for required boolean flags that don't have a meaningful default.
+ *
+ * The key difference from {@link option} is:
+ * - {@link option} without a value parser: Returns `false` when not present
+ * - {@link flag}: Fails parsing when not present, only produces `true`
+ *
+ * This is useful for dependent options where the presence of a flag changes
+ * the shape of the result type.
+ *
+ * @param args The {@link OptionName}s to parse, followed by an optional
+ *             {@link FlagOptions} object that allows you to specify
+ *             a description or other metadata.
+ * @returns A {@link Parser} that produces `true` when the flag is present
+ *          and fails when it is not present.
+ *
+ * @example
+ * ```typescript
+ * // Basic flag usage
+ * const parser = flag("-f", "--force");
+ * // Succeeds with true: parse(parser, ["-f"])
+ * // Fails: parse(parser, [])
+ *
+ * // With description
+ * const verboseFlag = flag("-v", "--verbose", {
+ *   description: "Enable verbose output"
+ * });
+ * ```
+ */
+declare function flag(...args: readonly [...readonly OptionName[], FlagOptions] | readonly OptionName[]): Parser<true, ValueParserResult<true> | undefined>;
 /**
  * Options for the {@link argument} parser.
  */
@@ -434,6 +475,166 @@ declare function or<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parse
  *         in order, returning the result of the first successful parser.
  */
 declare function or<TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<TA | TB | TC | TD | TE, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>]>;
+/**
+ * Creates a parser that combines six mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>): Parser<TA | TB | TC | TD | TE | TF, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>]>;
+/**
+ * Creates a parser that combines seven mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>): Parser<TA | TB | TC | TD | TE | TF | TG, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>]>;
+/**
+ * Creates a parser that combines eight mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>): Parser<TA | TB | TC | TD | TE | TF | TG | TH, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>]>;
+/**
+ * Creates a parser that combines nine mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TI The type of the value returned by the ninth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @template TStateI The type of the state used by the ninth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @param i The ninth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>]>;
+/**
+ * Creates a parser that combines ten mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TI The type of the value returned by the ninth parser.
+ * @template TJ The type of the value returned by the tenth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @template TStateI The type of the state used by the ninth parser.
+ * @template TStateJ The type of the state used by the tenth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @param i The ninth {@link Parser} to try.
+ * @param j The tenth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>, j: Parser<TJ, TStateJ>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>] | [9, ParserResult<TStateJ>]>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -712,4 +913,4 @@ declare function parse<T>(parser: Parser<T, unknown>, args: readonly string[]):
  */
 declare function getDocPage(parser: Parser<unknown, unknown>, args?: readonly string[]): DocPage | undefined;
 //#endregion
-export { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };
+export { ArgumentOptions, CommandOptions, FlagOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, flag, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };

package/dist/parser.d.ts

@@ -189,6 +189,47 @@ declare function option(...optionNames: readonly OptionName[]): Parser<boolean,
  *          values.
  */
 declare function option(...args: readonly [...readonly OptionName[], OptionOptions]): Parser<boolean, ValueParserResult<boolean> | undefined>;
+/**
+ * Options for the {@link flag} parser.
+ */
+interface FlagOptions {
+  /**
+   * The description of the flag, which can be used for help messages.
+   */
+  readonly description?: Message;
+}
+/**
+ * Creates a parser for command-line flags that must be explicitly provided.
+ * Unlike {@link option}, this parser fails if the flag is not present, making
+ * it suitable for required boolean flags that don't have a meaningful default.
+ *
+ * The key difference from {@link option} is:
+ * - {@link option} without a value parser: Returns `false` when not present
+ * - {@link flag}: Fails parsing when not present, only produces `true`
+ *
+ * This is useful for dependent options where the presence of a flag changes
+ * the shape of the result type.
+ *
+ * @param args The {@link OptionName}s to parse, followed by an optional
+ *             {@link FlagOptions} object that allows you to specify
+ *             a description or other metadata.
+ * @returns A {@link Parser} that produces `true` when the flag is present
+ *          and fails when it is not present.
+ *
+ * @example
+ * ```typescript
+ * // Basic flag usage
+ * const parser = flag("-f", "--force");
+ * // Succeeds with true: parse(parser, ["-f"])
+ * // Fails: parse(parser, [])
+ *
+ * // With description
+ * const verboseFlag = flag("-v", "--verbose", {
+ *   description: "Enable verbose output"
+ * });
+ * ```
+ */
+declare function flag(...args: readonly [...readonly OptionName[], FlagOptions] | readonly OptionName[]): Parser<true, ValueParserResult<true> | undefined>;
 /**
  * Options for the {@link argument} parser.
  */
@@ -434,6 +475,166 @@ declare function or<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parse
  *         in order, returning the result of the first successful parser.
  */
 declare function or<TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TStateE>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>): Parser<TA | TB | TC | TD | TE, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>]>;
+/**
+ * Creates a parser that combines six mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>): Parser<TA | TB | TC | TD | TE | TF, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>]>;
+/**
+ * Creates a parser that combines seven mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>): Parser<TA | TB | TC | TD | TE | TF | TG, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>]>;
+/**
+ * Creates a parser that combines eight mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>): Parser<TA | TB | TC | TD | TE | TF | TG | TH, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>]>;
+/**
+ * Creates a parser that combines nine mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TI The type of the value returned by the ninth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @template TStateI The type of the state used by the ninth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @param i The ninth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>]>;
+/**
+ * Creates a parser that combines ten mutually exclusive parsers into one.
+ * The resulting parser will try each of the provided parsers in order,
+ * and return the result of the first successful parser.
+ * @template TA The type of the value returned by the first parser.
+ * @template TB The type of the value returned by the second parser.
+ * @template TC The type of the value returned by the third parser.
+ * @template TD The type of the value returned by the fourth parser.
+ * @template TE The type of the value returned by the fifth parser.
+ * @template TF The type of the value returned by the sixth parser.
+ * @template TG The type of the value returned by the seventh parser.
+ * @template TH The type of the value returned by the eighth parser.
+ * @template TI The type of the value returned by the ninth parser.
+ * @template TJ The type of the value returned by the tenth parser.
+ * @template TStateA The type of the state used by the first parser.
+ * @template TStateB The type of the state used by the second parser.
+ * @template TStateC The type of the state used by the third parser.
+ * @template TStateD The type of the state used by the fourth parser.
+ * @template TStateE The type of the state used by the fifth parser.
+ * @template TStateF The type of the state used by the sixth parser.
+ * @template TStateG The type of the state used by the seventh parser.
+ * @template TStateH The type of the state used by the eighth parser.
+ * @template TStateI The type of the state used by the ninth parser.
+ * @template TStateJ The type of the state used by the tenth parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param c The third {@link Parser} to try.
+ * @param d The fourth {@link Parser} to try.
+ * @param e The fifth {@link Parser} to try.
+ * @param f The sixth {@link Parser} to try.
+ * @param g The seventh {@link Parser} to try.
+ * @param h The eighth {@link Parser} to try.
+ * @param i The ninth {@link Parser} to try.
+ * @param j The tenth {@link Parser} to try.
+ * @return A {@link Parser} that tries to parse using the provided parsers
+ *         in order, returning the result of the first successful parser.
+ */
+declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>, e: Parser<TE, TStateE>, f: Parser<TF, TStateF>, g: Parser<TG, TStateG>, h: Parser<TH, TStateH>, i: Parser<TI, TStateI>, j: Parser<TJ, TStateJ>): Parser<TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>] | [4, ParserResult<TStateE>] | [5, ParserResult<TStateF>] | [6, ParserResult<TStateG>] | [7, ParserResult<TStateH>] | [8, ParserResult<TStateI>] | [9, ParserResult<TStateJ>]>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -712,4 +913,4 @@ declare function parse<T>(parser: Parser<T, unknown>, args: readonly string[]):
  */
 declare function getDocPage(parser: Parser<unknown, unknown>, args?: readonly string[]): DocPage | undefined;
 //#endregion
-export { ArgumentOptions, CommandOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };
+export { ArgumentOptions, CommandOptions, FlagOptions, InferValue, MultipleOptions, OptionOptions, Parser, ParserContext, ParserResult, Result, argument, command, concat, constant, flag, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };

package/dist/parser.js

@@ -222,6 +222,163 @@ function option(...args) {
 	};
 }
 /**
+* Creates a parser for command-line flags that must be explicitly provided.
+* Unlike {@link option}, this parser fails if the flag is not present, making
+* it suitable for required boolean flags that don't have a meaningful default.
+*
+* The key difference from {@link option} is:
+* - {@link option} without a value parser: Returns `false` when not present
+* - {@link flag}: Fails parsing when not present, only produces `true`
+*
+* This is useful for dependent options where the presence of a flag changes
+* the shape of the result type.
+*
+* @param args The {@link OptionName}s to parse, followed by an optional
+*             {@link FlagOptions} object that allows you to specify
+*             a description or other metadata.
+* @returns A {@link Parser} that produces `true` when the flag is present
+*          and fails when it is not present.
+*
+* @example
+* ```typescript
+* // Basic flag usage
+* const parser = flag("-f", "--force");
+* // Succeeds with true: parse(parser, ["-f"])
+* // Fails: parse(parser, [])
+*
+* // With description
+* const verboseFlag = flag("-v", "--verbose", {
+*   description: "Enable verbose output"
+* });
+* ```
+*/
+function flag(...args) {
+	const lastArg = args.at(-1);
+	let optionNames$1;
+	let options = {};
+	if (typeof lastArg === "object" && lastArg != null && !Array.isArray(lastArg)) {
+		options = lastArg;
+		optionNames$1 = args.slice(0, -1);
+	} else optionNames$1 = args;
+	return {
+		$valueType: [],
+		$stateType: [],
+		priority: 10,
+		usage: [{
+			type: "option",
+			names: optionNames$1
+		}],
+		initialState: void 0,
+		parse(context) {
+			if (context.optionsTerminated) return {
+				success: false,
+				consumed: 0,
+				error: message`No more options can be parsed.`
+			};
+			else if (context.buffer.length < 1) return {
+				success: false,
+				consumed: 0,
+				error: message`Expected an option, but got end of input.`
+			};
+			if (context.buffer[0] === "--") return {
+				success: true,
+				next: {
+					...context,
+					buffer: context.buffer.slice(1),
+					state: context.state,
+					optionsTerminated: true
+				},
+				consumed: context.buffer.slice(0, 1)
+			};
+			if (optionNames$1.includes(context.buffer[0])) {
+				if (context.state?.success) return {
+					success: false,
+					consumed: 1,
+					error: message`${optionName(context.buffer[0])} cannot be used multiple times.`
+				};
+				return {
+					success: true,
+					next: {
+						...context,
+						state: {
+							success: true,
+							value: true
+						},
+						buffer: context.buffer.slice(1)
+					},
+					consumed: context.buffer.slice(0, 1)
+				};
+			}
+			const prefixes = optionNames$1.filter((name) => name.startsWith("--") || name.startsWith("/")).map((name) => name.startsWith("/") ? `${name}:` : `${name}=`);
+			for (const prefix of prefixes) if (context.buffer[0].startsWith(prefix)) {
+				const value = context.buffer[0].slice(prefix.length);
+				return {
+					success: false,
+					consumed: 1,
+					error: message`Flag ${optionName(prefix.slice(0, -1))} does not accept a value, but got: ${value}.`
+				};
+			}
+			const shortOptions = optionNames$1.filter((name) => name.match(/^-[^-]$/));
+			for (const shortOption of shortOptions) {
+				if (!context.buffer[0].startsWith(shortOption)) continue;
+				if (context.state?.success) return {
+					success: false,
+					consumed: 1,
+					error: message`${optionName(shortOption)} cannot be used multiple times.`
+				};
+				return {
+					success: true,
+					next: {
+						...context,
+						state: {
+							success: true,
+							value: true
+						},
+						buffer: [`-${context.buffer[0].slice(2)}`, ...context.buffer.slice(1)]
+					},
+					consumed: [context.buffer[0].slice(0, 2)]
+				};
+			}
+			return {
+				success: false,
+				consumed: 0,
+				error: message`No matched option for ${optionName(context.buffer[0])}.`
+			};
+		},
+		complete(state) {
+			if (state == null) return {
+				success: false,
+				error: message`Required flag ${optionNames(optionNames$1)} is missing.`
+			};
+			if (state.success) return {
+				success: true,
+				value: true
+			};
+			return {
+				success: false,
+				error: message`${optionNames(optionNames$1)}: ${state.error}`
+			};
+		},
+		getDocFragments(_state, _defaultValue) {
+			const fragments = [{
+				type: "entry",
+				term: {
+					type: "option",
+					names: optionNames$1
+				},
+				description: options.description
+			}];
+			return {
+				fragments,
+				description: options.description
+			};
+		},
+		[Symbol.for("Deno.customInspect")]() {
+			return `flag(${optionNames$1.map((o) => JSON.stringify(o)).join(", ")})`;
+		}
+	};
+}
+/**
 * Creates a parser that expects a single argument value.
 * This parser is typically used for positional arguments
 * that are not options or flags.
@@ -1227,4 +1384,4 @@ function getDocPage(parser, args = []) {
 }
 
 //#endregion
-export { argument, command, concat, constant, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };
+export { argument, command, concat, constant, flag, getDocPage, map, merge, multiple, object, option, optional, or, parse, tuple, withDefault };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optique/core",
-  "version": "0.2.0",
+  "version": "0.3.0-dev.35+3445f3b8",
   "description": "Type-safe combinatorial command-line interface parser",
   "keywords": [
     "CLI",