@optique/core 1.0.0-dev.489 → 1.0.0-dev.491

package/dist/constructs.d.cts

@@ -106,6 +106,11 @@ declare class DuplicateOptionError extends Error {
   readonly sources: readonly (string | symbol)[];
   constructor(optionName: string, sources: readonly (string | symbol)[]);
 }
+type OrParserArity = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+type OrArityLimitError = {
+  readonly __optiqueOrArityLimit: "or() supports up to 15 parser arguments. Nest or() to combine more.";
+};
+type OrArityGuard<TParsers extends readonly unknown[]> = TParsers["length"] extends OrParserArity ? unknown : OrArityLimitError;
 /**
  * Creates a parser that combines two mutually exclusive parsers into one.
  * The resulting parser will try each of the provided parsers in order,
@@ -399,6 +404,41 @@ declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extend
  * @since 0.3.0
  */
 declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ]>, 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>]>;
+/**
+ * Creates a parser that combines eleven 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK, 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>] | [10, ParserResult<TStateK>]>;
+/**
+ * Creates a parser that combines twelve 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, ML extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TL, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK, TStateL>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>, l: Parser<ML, TL, TStateL>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK | TL, 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>] | [10, ParserResult<TStateK>] | [11, ParserResult<TStateL>]>;
+/**
+ * Creates a parser that combines thirteen 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, ML extends Mode, MM extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TL, TM, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK, TStateL, TStateM>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>, l: Parser<ML, TL, TStateL>, m: Parser<MM, TM, TStateM>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK | TL | TM, 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>] | [10, ParserResult<TStateK>] | [11, ParserResult<TStateL>] | [12, ParserResult<TStateM>]>;
+/**
+ * Creates a parser that combines fourteen 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, ML extends Mode, MM extends Mode, MN extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TL, TM, TN, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK, TStateL, TStateM, TStateN>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>, l: Parser<ML, TL, TStateL>, m: Parser<MM, TM, TStateM>, n: Parser<MN, TN, TStateN>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM, MN]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK | TL | TM | TN, 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>] | [10, ParserResult<TStateK>] | [11, ParserResult<TStateL>] | [12, ParserResult<TStateM>] | [13, ParserResult<TStateN>]>;
+/**
+ * Creates a parser that combines fifteen 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, ML extends Mode, MM extends Mode, MN extends Mode, MO extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TL, TM, TN, TO, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK, TStateL, TStateM, TStateN, TStateO>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>, l: Parser<ML, TL, TStateL>, m: Parser<MM, TM, TStateM>, n: Parser<MN, TN, TStateN>, o: Parser<MO, TO, TStateO>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM, MN, MO]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK | TL | TM | TN | TO, 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>] | [10, ParserResult<TStateK>] | [11, ParserResult<TStateL>] | [12, ParserResult<TStateM>] | [13, ParserResult<TStateN>] | [14, ParserResult<TStateO>]>;
 /**
  * Creates a parser that combines two mutually exclusive parsers into one,
  * with custom error message options.
@@ -425,7 +465,6 @@ declare function or<TA extends Parser<Mode, unknown, unknown>, TB extends Parser
  * @since 0.5.0
  */
 declare function or<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, c: TC, options: OrOptions): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>]>, InferValue<TA> | InferValue<TB> | InferValue<TC>, undefined | [number, ParserResult<unknown>]>;
-declare function or(...parsers: Parser<Mode, unknown, unknown>[]): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
 /**
  * Creates a parser that tries each parser in sequence until one succeeds,
  * with custom error message options.
@@ -434,7 +473,8 @@ declare function or(...parsers: Parser<Mode, unknown, unknown>[]): Parser<Mode,
  * @returns A parser that succeeds if any of the input parsers succeed.
  * @since 0.5.0
  */
-declare function or(parser1: Parser<Mode, unknown, unknown>, ...rest: [...parsers: Parser<Mode, unknown, unknown>[], options: OrOptions]): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
+declare function or<const TParsers extends readonly Parser<Mode, unknown, unknown>[]>(...rest: [...parsers: TParsers, options: OrOptions] & OrArityGuard<TParsers>): Parser<CombineModes<{ readonly [K in keyof TParsers]: ExtractMode<TParsers[K]> }>, InferValue<TParsers[number]>, undefined | [number, ParserResult<unknown>]>;
+declare function or<const TParsers extends readonly Parser<Mode, unknown, unknown>[]>(...parsers: TParsers & OrArityGuard<TParsers>): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
 /**
  * Options for customizing error messages in the {@link longestMatch}
  * combinator.

package/dist/constructs.d.ts

@@ -106,6 +106,11 @@ declare class DuplicateOptionError extends Error {
   readonly sources: readonly (string | symbol)[];
   constructor(optionName: string, sources: readonly (string | symbol)[]);
 }
+type OrParserArity = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+type OrArityLimitError = {
+  readonly __optiqueOrArityLimit: "or() supports up to 15 parser arguments. Nest or() to combine more.";
+};
+type OrArityGuard<TParsers extends readonly unknown[]> = TParsers["length"] extends OrParserArity ? unknown : OrArityLimitError;
 /**
  * Creates a parser that combines two mutually exclusive parsers into one.
  * The resulting parser will try each of the provided parsers in order,
@@ -399,6 +404,41 @@ declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extend
  * @since 0.3.0
  */
 declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ]>, 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>]>;
+/**
+ * Creates a parser that combines eleven 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK, 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>] | [10, ParserResult<TStateK>]>;
+/**
+ * Creates a parser that combines twelve 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, ML extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TL, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK, TStateL>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>, l: Parser<ML, TL, TStateL>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK | TL, 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>] | [10, ParserResult<TStateK>] | [11, ParserResult<TStateL>]>;
+/**
+ * Creates a parser that combines thirteen 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, ML extends Mode, MM extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TL, TM, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK, TStateL, TStateM>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>, l: Parser<ML, TL, TStateL>, m: Parser<MM, TM, TStateM>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK | TL | TM, 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>] | [10, ParserResult<TStateK>] | [11, ParserResult<TStateL>] | [12, ParserResult<TStateM>]>;
+/**
+ * Creates a parser that combines fourteen 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, ML extends Mode, MM extends Mode, MN extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TL, TM, TN, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK, TStateL, TStateM, TStateN>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>, l: Parser<ML, TL, TStateL>, m: Parser<MM, TM, TStateM>, n: Parser<MN, TN, TStateN>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM, MN]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK | TL | TM | TN, 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>] | [10, ParserResult<TStateK>] | [11, ParserResult<TStateL>] | [12, ParserResult<TStateM>] | [13, ParserResult<TStateN>]>;
+/**
+ * Creates a parser that combines fifteen 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.
+ * @since 0.9.0
+ */
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, MH extends Mode, MI extends Mode, MJ extends Mode, MK extends Mode, ML extends Mode, MM extends Mode, MN extends Mode, MO extends Mode, TA, TB, TC, TD, TE, TF, TG, TH, TI, TJ, TK, TL, TM, TN, TO, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI, TStateJ, TStateK, TStateL, TStateM, TStateN, TStateO>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>, e: Parser<ME, TE, TStateE>, f: Parser<MF, TF, TStateF>, g: Parser<MG, TG, TStateG>, h: Parser<MH, TH, TStateH>, i: Parser<MI, TI, TStateI>, j: Parser<MJ, TJ, TStateJ>, k: Parser<MK, TK, TStateK>, l: Parser<ML, TL, TStateL>, m: Parser<MM, TM, TStateM>, n: Parser<MN, TN, TStateN>, o: Parser<MO, TO, TStateO>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI, MJ, MK, ML, MM, MN, MO]>, TA | TB | TC | TD | TE | TF | TG | TH | TI | TJ | TK | TL | TM | TN | TO, 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>] | [10, ParserResult<TStateK>] | [11, ParserResult<TStateL>] | [12, ParserResult<TStateM>] | [13, ParserResult<TStateN>] | [14, ParserResult<TStateO>]>;
 /**
  * Creates a parser that combines two mutually exclusive parsers into one,
  * with custom error message options.
@@ -425,7 +465,6 @@ declare function or<TA extends Parser<Mode, unknown, unknown>, TB extends Parser
  * @since 0.5.0
  */
 declare function or<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, c: TC, options: OrOptions): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>]>, InferValue<TA> | InferValue<TB> | InferValue<TC>, undefined | [number, ParserResult<unknown>]>;
-declare function or(...parsers: Parser<Mode, unknown, unknown>[]): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
 /**
  * Creates a parser that tries each parser in sequence until one succeeds,
  * with custom error message options.
@@ -434,7 +473,8 @@ declare function or(...parsers: Parser<Mode, unknown, unknown>[]): Parser<Mode,
  * @returns A parser that succeeds if any of the input parsers succeed.
  * @since 0.5.0
  */
-declare function or(parser1: Parser<Mode, unknown, unknown>, ...rest: [...parsers: Parser<Mode, unknown, unknown>[], options: OrOptions]): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
+declare function or<const TParsers extends readonly Parser<Mode, unknown, unknown>[]>(...rest: [...parsers: TParsers, options: OrOptions] & OrArityGuard<TParsers>): Parser<CombineModes<{ readonly [K in keyof TParsers]: ExtractMode<TParsers[K]> }>, InferValue<TParsers[number]>, undefined | [number, ParserResult<unknown>]>;
+declare function or<const TParsers extends readonly Parser<Mode, unknown, unknown>[]>(...parsers: TParsers & OrArityGuard<TParsers>): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
 /**
  * Options for customizing error messages in the {@link longestMatch}
  * combinator.

package/dist/parser.cjs

@@ -416,14 +416,26 @@ function buildDocPage(parser, context, args) {
 	}
 	const sections = buildingSections;
 	const usage = [...require_usage.normalizeUsage(parser.usage)];
+	const maybeApplyCommandUsageLine = (term, arg, isLastArg, usageIndex) => {
+		if (term?.type !== "command" || term.name !== arg || !isLastArg || term.usageLine == null) return;
+		const defaultUsageLine = usage.slice(usageIndex + 1);
+		const customUsageLine = typeof term.usageLine === "function" ? term.usageLine(defaultUsageLine) : term.usageLine;
+		const normalizedCustomUsageLine = require_usage.normalizeUsage(customUsageLine);
+		usage.splice(usageIndex + 1, usage.length - (usageIndex + 1), ...normalizedCustomUsageLine);
+	};
 	let i = 0;
-	for (const arg of args) {
+	for (let argIndex = 0; argIndex < args.length; argIndex++) {
+		const arg = args[argIndex];
 		if (i >= usage.length) break;
-		const term = usage[i];
+		let term = usage[i];
 		if (term.type === "exclusive") {
 			const found = findCommandInExclusive(term, arg);
-			if (found) usage.splice(i, 1, ...found);
+			if (found) {
+				usage.splice(i, 1, ...found);
+				term = usage[i];
+			}
 		}
+		maybeApplyCommandUsageLine(term, arg, argIndex === args.length - 1, i);
 		i++;
 	}
 	return {

package/dist/parser.js

@@ -416,14 +416,26 @@ function buildDocPage(parser, context, args) {
 	}
 	const sections = buildingSections;
 	const usage = [...normalizeUsage(parser.usage)];
+	const maybeApplyCommandUsageLine = (term, arg, isLastArg, usageIndex) => {
+		if (term?.type !== "command" || term.name !== arg || !isLastArg || term.usageLine == null) return;
+		const defaultUsageLine = usage.slice(usageIndex + 1);
+		const customUsageLine = typeof term.usageLine === "function" ? term.usageLine(defaultUsageLine) : term.usageLine;
+		const normalizedCustomUsageLine = normalizeUsage(customUsageLine);
+		usage.splice(usageIndex + 1, usage.length - (usageIndex + 1), ...normalizedCustomUsageLine);
+	};
 	let i = 0;
-	for (const arg of args) {
+	for (let argIndex = 0; argIndex < args.length; argIndex++) {
+		const arg = args[argIndex];
 		if (i >= usage.length) break;
-		const term = usage[i];
+		let term = usage[i];
 		if (term.type === "exclusive") {
 			const found = findCommandInExclusive(term, arg);
-			if (found) usage.splice(i, 1, ...found);
+			if (found) {
+				usage.splice(i, 1, ...found);
+				term = usage[i];
+			}
 		}
+		maybeApplyCommandUsageLine(term, arg, argIndex === args.length - 1, i);
 		i++;
 	}
 	return {

package/dist/primitives.cjs

@@ -927,6 +927,7 @@ function command(name, parser, options = {}) {
 		usage: [{
 			type: "command",
 			name,
+			...options.usageLine != null && { usageLine: options.usageLine },
 			...options.hidden != null && { hidden: options.hidden }
 		}, ...parser.usage],
 		initialState: void 0,

package/dist/primitives.d.cts

@@ -1,5 +1,5 @@
 import { Message } from "./message.cjs";
-import { HiddenVisibility, OptionName } from "./usage.cjs";
+import { HiddenVisibility, OptionName, Usage } from "./usage.cjs";
 import { ValueParser, ValueParserResult } from "./valueparser.cjs";
 import { DeferredParseState, PendingDependencySourceState } from "./dependency.cjs";
 import { Mode, Parser } from "./parser.cjs";
@@ -326,6 +326,19 @@ interface CommandOptions {
    * @since 0.6.0
    */
   readonly footer?: Message;
+  /**
+   * Usage line override for this command's own help page.
+   *
+   * This option customizes the usage tail shown when rendering help for this
+   * command itself (e.g., `myapp config --help`). It does not change parsing
+   * behavior or shell completion.
+   *
+   * - `Usage`: Replaces the default usage tail.
+   * - `(defaultUsageLine) => Usage`: Computes the usage tail from the default.
+   *
+   * @since 1.0.0
+   */
+  readonly usageLine?: Usage | ((defaultUsageLine: Usage) => Usage);
   /**
    * Controls command visibility:
    *

package/dist/primitives.d.ts

@@ -1,5 +1,5 @@
 import { Message } from "./message.js";
-import { HiddenVisibility, OptionName } from "./usage.js";
+import { HiddenVisibility, OptionName, Usage } from "./usage.js";
 import { ValueParser, ValueParserResult } from "./valueparser.js";
 import { DeferredParseState, PendingDependencySourceState } from "./dependency.js";
 import { Mode, Parser } from "./parser.js";
@@ -326,6 +326,19 @@ interface CommandOptions {
    * @since 0.6.0
    */
   readonly footer?: Message;
+  /**
+   * Usage line override for this command's own help page.
+   *
+   * This option customizes the usage tail shown when rendering help for this
+   * command itself (e.g., `myapp config --help`). It does not change parsing
+   * behavior or shell completion.
+   *
+   * - `Usage`: Replaces the default usage tail.
+   * - `(defaultUsageLine) => Usage`: Computes the usage tail from the default.
+   *
+   * @since 1.0.0
+   */
+  readonly usageLine?: Usage | ((defaultUsageLine: Usage) => Usage);
   /**
    * Controls command visibility:
    *

package/dist/primitives.js

@@ -927,6 +927,7 @@ function command(name, parser, options = {}) {
 		usage: [{
 			type: "command",
 			name,
+			...options.usageLine != null && { usageLine: options.usageLine },
 			...options.hidden != null && { hidden: options.hidden }
 		}, ...parser.usage],
 		initialState: void 0,

package/dist/usage.cjs

@@ -419,6 +419,12 @@ function* formatUsageTermInternal(term, options) {
 			text: options?.colors ? `\x1b[2m${text}\x1b[0m` : text,
 			width: 5
 		};
+	} else if (term.type === "ellipsis") {
+		const text = "...";
+		yield {
+			text: options?.colors ? `\x1b[2m${text}\x1b[0m` : text,
+			width: 3
+		};
 	} else throw new TypeError(`Unknown usage term type: ${term["type"]}.`);
 }
 

package/dist/usage.d.cts

@@ -98,6 +98,12 @@ type UsageTerm =
    * in the command-line usage.
    */
   readonly name: string;
+  /**
+   * Optional usage line override for this command's own help page.
+   * This affects help/documentation rendering only.
+   * @since 1.0.0
+   */
+  readonly usageLine?: Usage | ((defaultUsageLine: Usage) => Usage);
   /**
    * Visibility controls for this term.
    * @since 0.9.0
@@ -181,6 +187,17 @@ type UsageTerm =
    * @since 0.9.0
    */
   readonly hidden?: HiddenVisibility;
+}
+/**
+ * An ellipsis term, which represents a summary placeholder in usage output.
+ * Unlike {@link passthrough}, this term has no parsing semantics and is used
+ * only for display.
+ * @since 1.0.0
+ */ | {
+  /**
+   * The type of the term, which is always `"ellipsis"` for this term.
+   */
+  readonly type: "ellipsis";
 };
 /**
  * Represents a command-line usage description, which is a sequence of

package/dist/usage.d.ts

@@ -98,6 +98,12 @@ type UsageTerm =
    * in the command-line usage.
    */
   readonly name: string;
+  /**
+   * Optional usage line override for this command's own help page.
+   * This affects help/documentation rendering only.
+   * @since 1.0.0
+   */
+  readonly usageLine?: Usage | ((defaultUsageLine: Usage) => Usage);
   /**
    * Visibility controls for this term.
    * @since 0.9.0
@@ -181,6 +187,17 @@ type UsageTerm =
    * @since 0.9.0
    */
   readonly hidden?: HiddenVisibility;
+}
+/**
+ * An ellipsis term, which represents a summary placeholder in usage output.
+ * Unlike {@link passthrough}, this term has no parsing semantics and is used
+ * only for display.
+ * @since 1.0.0
+ */ | {
+  /**
+   * The type of the term, which is always `"ellipsis"` for this term.
+   */
+  readonly type: "ellipsis";
 };
 /**
  * Represents a command-line usage description, which is a sequence of

package/dist/usage.js

@@ -418,6 +418,12 @@ function* formatUsageTermInternal(term, options) {
 			text: options?.colors ? `\x1b[2m${text}\x1b[0m` : text,
 			width: 5
 		};
+	} else if (term.type === "ellipsis") {
+		const text = "...";
+		yield {
+			text: options?.colors ? `\x1b[2m${text}\x1b[0m` : text,
+			width: 3
+		};
 	} else throw new TypeError(`Unknown usage term type: ${term["type"]}.`);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@optique/core",
-  "version": "1.0.0-dev.489+709d13c5",
+  "version": "1.0.0-dev.491+13b4eec0",
   "description": "Type-safe combinatorial command-line interface parser",
   "keywords": [
     "CLI",