@optique/core 0.9.0-dev.211 → 0.9.0-dev.215

package/dist/constructs.d.cts

@@ -1,8 +1,27 @@
 import { Message } from "./message.cjs";
-import { Parser, ParserResult } from "./parser.cjs";
+import { CombineModes, InferValue, Mode, Parser, ParserResult } from "./parser.cjs";
 
 //#region src/constructs.d.ts
 
+/**
+ * Helper type to extract Mode from a Parser.
+ * @internal
+ */
+type ExtractMode<T> = T extends Parser<infer M, unknown, unknown> ? M : never;
+/**
+ * Helper type to combine modes from an object of parsers.
+ * Returns "async" if any parser is async, otherwise "sync".
+ * @internal
+ */
+type CombineObjectModes<T extends {
+  readonly [key: string | symbol]: Parser<Mode, unknown, unknown>;
+}> = CombineModes<{ [K in keyof T]: ExtractMode<T[K]> }[keyof T] extends infer M ? M extends Mode ? readonly [M] : never : never>;
+/**
+ * Helper type to combine modes from a tuple of parsers.
+ * Returns "async" if any parser is async, otherwise "sync".
+ * @internal
+ */
+type CombineTupleModes<T extends readonly Parser<Mode, unknown, unknown>[]> = CombineModes<{ readonly [K in keyof T]: ExtractMode<T[K]> }>;
 /**
  * Options for customizing error messages in the {@link or} combinator.
  * @since 0.5.0
@@ -90,6 +109,8 @@ declare class DuplicateOptionError extends Error {
  * Creates a parser that combines two 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 MA The mode of the first parser.
+ * @template MB The mode of the second 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 TStateA The type of the state used by the first parser.
@@ -99,11 +120,14 @@ declare class DuplicateOptionError extends Error {
  * @returns 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, TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>): Parser<TA | TB, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>]>;
+declare function or<MA extends Mode, MB extends Mode, TA, TB, TStateA, TStateB>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>): Parser<CombineModes<readonly [MA, MB]>, TA | TB, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>]>;
 /**
  * Creates a parser that combines three 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 MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third 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.
@@ -116,11 +140,15 @@ declare function or<TA, TB, TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<
  * @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, TStateA, TStateB, TStateC>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>): Parser<TA | TB | TC, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>]>;
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, TA, TB, TC, TStateA, TStateB, TStateC>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>): Parser<CombineModes<readonly [MA, MB, MC]>, TA | TB | TC, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>]>;
 /**
  * Creates a parser that combines four 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 MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth 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.
@@ -136,11 +164,16 @@ declare function or<TA, TB, TC, TStateA, TStateB, TStateC>(a: Parser<TA, TStateA
  * @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, TStateA, TStateB, TStateC, TStateD>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>): Parser<TA | TB | TC | TD, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>]>;
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>): Parser<CombineModes<readonly [MA, MB, MC, MD]>, TA | TB | TC | TD, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>]>;
 /**
  * Creates a parser that combines five 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 MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth parser.
+ * @template ME The mode of the fifth 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.
@@ -159,11 +192,17 @@ declare function or<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parse
  * @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, 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>]>;
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TStateE>(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>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME]>, 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 MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth parser.
+ * @template ME The mode of the fifth parser.
+ * @template MF The mode of the sixth 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.
@@ -186,11 +225,18 @@ declare function or<TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TSta
  *         in order, returning the result of the first successful parser.
  * @since 0.3.0
  */
-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>]>;
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, TA, TB, TC, TD, TE, TF, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF>(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>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF]>, 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 MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth parser.
+ * @template ME The mode of the fifth parser.
+ * @template MF The mode of the sixth parser.
+ * @template MG The mode of the seventh 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.
@@ -216,11 +262,19 @@ declare function or<TA, TB, TC, TD, TE, TF, TStateA, TStateB, TStateC, TStateD,
  *         in order, returning the result of the first successful parser.
  * @since 0.3.0
  */
-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>]>;
+declare function or<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, MF extends Mode, MG extends Mode, TA, TB, TC, TD, TE, TF, TG, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG>(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>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG]>, 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 MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth parser.
+ * @template ME The mode of the fifth parser.
+ * @template MF The mode of the sixth parser.
+ * @template MG The mode of the seventh parser.
+ * @template MH The mode of the eighth 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.
@@ -249,11 +303,20 @@ declare function or<TA, TB, TC, TD, TE, TF, TG, TStateA, TStateB, TStateC, TStat
  *         in order, returning the result of the first successful parser.
  * @since 0.3.0
  */
-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>]>;
+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, TA, TB, TC, TD, TE, TF, TG, TH, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH>(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>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH]>, 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 MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth parser.
+ * @template ME The mode of the fifth parser.
+ * @template MF The mode of the sixth parser.
+ * @template MG The mode of the seventh parser.
+ * @template MH The mode of the eighth parser.
+ * @template MI The mode of the ninth 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.
@@ -285,11 +348,21 @@ declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TStateA, TStateB, TStateC, T
  *         in order, returning the result of the first successful parser.
  * @since 0.3.0
  */
-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>]>;
+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, TA, TB, TC, TD, TE, TF, TG, TH, TI, TStateA, TStateB, TStateC, TStateD, TStateE, TStateF, TStateG, TStateH, TStateI>(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>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME, MF, MG, MH, MI]>, 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 MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth parser.
+ * @template ME The mode of the fifth parser.
+ * @template MF The mode of the sixth parser.
+ * @template MG The mode of the seventh parser.
+ * @template MH The mode of the eighth parser.
+ * @template MI The mode of the ninth parser.
+ * @template MJ The mode of the tenth 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.
@@ -324,8 +397,34 @@ declare function or<TA, TB, TC, TD, TE, TF, TG, TH, TI, TStateA, TStateB, TState
  *         in order, returning the result of the first successful parser.
  * @since 0.3.0
  */
-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>]>;
-declare function or(...parsers: Parser<unknown, unknown>[]): Parser<unknown, undefined | [number, ParserResult<unknown>]>;
+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 two mutually exclusive parsers into one,
+ * with custom error message options.
+ * @template TA The type of the first parser.
+ * @template TB The type of the second parser.
+ * @param a The first {@link Parser} to try.
+ * @param b The second {@link Parser} to try.
+ * @param options Custom error message options.
+ * @return A {@link Parser} that tries to parse using the provided parsers.
+ * @since 0.5.0
+ */
+declare function or<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, options: OrOptions): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>]>, InferValue<TA> | InferValue<TB>, undefined | [number, ParserResult<unknown>]>;
+/**
+ * Creates a parser that combines three mutually exclusive parsers into one,
+ * with custom error message options.
+ * @template TA The type of the first parser.
+ * @template TB The type of the second parser.
+ * @template TC The type of the third 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 options Custom error message options.
+ * @return A {@link Parser} that tries to parse using the provided parsers.
+ * @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.
@@ -334,7 +433,7 @@ declare function or(...parsers: Parser<unknown, unknown>[]): Parser<unknown, und
  * @returns A parser that succeeds if any of the input parsers succeed.
  * @since 0.5.0
  */
-declare function or(parser1: Parser<unknown, unknown>, ...rest: [...parsers: Parser<unknown, unknown>[], options: OrOptions]): Parser<unknown, undefined | [number, ParserResult<unknown>]>;
+declare function or(parser1: Parser<Mode, unknown, unknown>, ...rest: [...parsers: Parser<Mode, unknown, unknown>[], options: OrOptions]): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
 /**
  * Options for customizing error messages in the {@link longestMatch}
  * combinator.
@@ -396,6 +495,8 @@ interface LongestMatchErrorOptions {
  * selecting the parser that consumes the most tokens.
  * The resulting parser will try both parsers and return the result
  * of the parser that consumed more input tokens.
+ * @template MA The mode of the first parser.
+ * @template MB The mode of the second 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 TStateA The type of the state used by the first parser.
@@ -406,12 +507,15 @@ interface LongestMatchErrorOptions {
  *          and returns the result of the parser that consumed more tokens.
  * @since 0.3.0
  */
-declare function longestMatch<TA, TB, TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>): Parser<TA | TB, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>]>;
+declare function longestMatch<MA extends Mode, MB extends Mode, TA, TB, TStateA, TStateB>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>): Parser<CombineModes<readonly [MA, MB]>, TA | TB, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>]>;
 /**
  * Creates a parser that combines three mutually exclusive parsers into one,
  * selecting the parser that consumes the most tokens.
  * The resulting parser will try all parsers and return the result
  * of the parser that consumed the most input tokens.
+ * @template MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third 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.
@@ -425,12 +529,16 @@ declare function longestMatch<TA, TB, TStateA, TStateB>(a: Parser<TA, TStateA>,
  *          and returns the result of the parser that consumed the most tokens.
  * @since 0.3.0
  */
-declare function longestMatch<TA, TB, TC, TStateA, TStateB, TStateC>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>): Parser<TA | TB | TC, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>]>;
+declare function longestMatch<MA extends Mode, MB extends Mode, MC extends Mode, TA, TB, TC, TStateA, TStateB, TStateC>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>): Parser<CombineModes<readonly [MA, MB, MC]>, TA | TB | TC, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>]>;
 /**
  * Creates a parser that combines four mutually exclusive parsers into one,
  * selecting the parser that consumes the most tokens.
  * The resulting parser will try all parsers and return the result
  * of the parser that consumed the most input tokens.
+ * @template MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth 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.
@@ -447,12 +555,17 @@ declare function longestMatch<TA, TB, TC, TStateA, TStateB, TStateC>(a: Parser<T
  *          and returns the result of the parser that consumed the most tokens.
  * @since 0.3.0
  */
-declare function longestMatch<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>): Parser<TA | TB | TC | TD, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>]>;
+declare function longestMatch<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>): Parser<CombineModes<readonly [MA, MB, MC, MD]>, TA | TB | TC | TD, undefined | [0, ParserResult<TStateA>] | [1, ParserResult<TStateB>] | [2, ParserResult<TStateC>] | [3, ParserResult<TStateD>]>;
 /**
  * Creates a parser that combines five mutually exclusive parsers into one,
  * selecting the parser that consumes the most tokens.
  * The resulting parser will try all parsers and return the result
  * of the parser that consumed the most input tokens.
+ * @template MA The mode of the first parser.
+ * @template MB The mode of the second parser.
+ * @template MC The mode of the third parser.
+ * @template MD The mode of the fourth parser.
+ * @template ME The mode of the fifth 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.
@@ -472,8 +585,20 @@ declare function longestMatch<TA, TB, TC, TD, TStateA, TStateB, TStateC, TStateD
  *          and returns the result of the parser that consumed the most tokens.
  * @since 0.3.0
  */
-declare function longestMatch<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>]>;
-declare function longestMatch(...parsers: Parser<unknown, unknown>[]): Parser<unknown, undefined | [number, ParserResult<unknown>]>;
+declare function longestMatch<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, TA, TB, TC, TD, TE, TStateA, TStateB, TStateC, TStateD, TStateE>(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>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME]>, 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 two mutually exclusive parsers into one,
+ * with custom error message options.
+ * @since 0.5.0
+ */
+declare function longestMatch<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, options: LongestMatchOptions): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>]>, InferValue<TA> | InferValue<TB>, undefined | [number, ParserResult<unknown>]>;
+/**
+ * Creates a parser that combines three mutually exclusive parsers into one,
+ * with custom error message options.
+ * @since 0.5.0
+ */
+declare function longestMatch<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: LongestMatchOptions): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>]>, InferValue<TA> | InferValue<TB> | InferValue<TC>, undefined | [number, ParserResult<unknown>]>;
+declare function longestMatch(...parsers: Parser<Mode, unknown, unknown>[]): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
 /**
  * Creates a parser that tries all parsers and selects the one that consumes
  * the most input, with custom error message options.
@@ -483,7 +608,7 @@ declare function longestMatch(...parsers: Parser<unknown, unknown>[]): Parser<un
  *          consumed the most input.
  * @since 0.5.0
  */
-declare function longestMatch(parser1: Parser<unknown, unknown>, ...rest: [...parsers: Parser<unknown, unknown>[], options: LongestMatchOptions]): Parser<unknown, undefined | [number, ParserResult<unknown>]>;
+declare function longestMatch(parser1: Parser<Mode, unknown, unknown>, ...rest: [...parsers: Parser<Mode, unknown, unknown>[], options: LongestMatchOptions]): Parser<Mode, unknown, undefined | [number, ParserResult<unknown>]>;
 /**
  * Options for the {@link object} parser.
  * @since 0.5.0
@@ -558,8 +683,8 @@ interface ObjectErrorOptions {
  *          parser.
  */
 declare function object<T extends {
-  readonly [key: string | symbol]: Parser<unknown, unknown>;
-}>(parsers: T): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
+  readonly [key: string | symbol]: Parser<Mode, unknown, unknown>;
+}>(parsers: T): Parser<CombineObjectModes<T>, { readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
 /**
  * Creates a parser that combines multiple parsers into a single object parser.
  * Each parser in the object is applied to parse different parts of the input,
@@ -575,8 +700,8 @@ declare function object<T extends {
  * @since 0.5.0
  */
 declare function object<T extends {
-  readonly [key: string | symbol]: Parser<unknown, unknown>;
-}>(parsers: T, options: ObjectOptions): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
+  readonly [key: string | symbol]: Parser<Mode, unknown, unknown>;
+}>(parsers: T, options: ObjectOptions): Parser<CombineObjectModes<T>, { readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
 /**
  * Creates a labeled parser that combines multiple parsers into a single
  * object parser with an associated label for documentation or error reporting.
@@ -590,8 +715,8 @@ declare function object<T extends {
  *          parser.
  */
 declare function object<T extends {
-  readonly [key: string | symbol]: Parser<unknown, unknown>;
-}>(label: string, parsers: T): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
+  readonly [key: string | symbol]: Parser<Mode, unknown, unknown>;
+}>(label: string, parsers: T): Parser<CombineObjectModes<T>, { readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
 /**
  * Creates a labeled parser that combines multiple parsers into a single
  * object parser with an associated label for documentation or error reporting.
@@ -608,8 +733,8 @@ declare function object<T extends {
  * @since 0.5.0
  */
 declare function object<T extends {
-  readonly [key: string | symbol]: Parser<unknown, unknown>;
-}>(label: string, parsers: T, options: ObjectOptions): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
+  readonly [key: string | symbol]: Parser<Mode, unknown, unknown>;
+}>(label: string, parsers: T, options: ObjectOptions): Parser<CombineObjectModes<T>, { readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
 /**
  * Options for the {@link tuple} parser.
  * @since 0.7.0
@@ -636,7 +761,7 @@ interface TupleOptions {
  *          as the input array, where each element is the result of the
  *          corresponding parser.
  */
-declare function tuple<const T extends readonly Parser<unknown, unknown>[]>(parsers: T, options?: TupleOptions): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
+declare function tuple<const T extends readonly Parser<Mode, unknown, unknown>[]>(parsers: T, options?: TupleOptions): Parser<CombineTupleModes<T>, { readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
 /**
  * Creates a labeled parser that combines multiple parsers into a sequential
  * tuple parser with an associated label for documentation or error reporting.
@@ -650,7 +775,7 @@ declare function tuple<const T extends readonly Parser<unknown, unknown>[]>(pars
  *          as the input array, where each element is the result of the
  *          corresponding parser.
  */
-declare function tuple<const T extends readonly Parser<unknown, unknown>[]>(label: string, parsers: T, options?: TupleOptions): Parser<{ readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
+declare function tuple<const T extends readonly Parser<Mode, unknown, unknown>[]>(label: string, parsers: T, options?: TupleOptions): Parser<CombineTupleModes<T>, { readonly [K in keyof T]: T[K]["$valueType"][number] extends (infer U) ? U : never }, { readonly [K in keyof T]: T[K]["$stateType"][number] extends (infer U2) ? U2 : never }>;
 /**
  * Helper type to check if all members of a union are object-like.
  * This allows merge() to work with parsers like withDefault() that produce union types.
@@ -660,7 +785,7 @@ type AllObjectLike<T> = T extends readonly unknown[] ? never : T extends Record<
  * Helper type to extract object-like types from parser value types,
  * including union types where all members are objects.
  */
-type ExtractObjectTypes<P> = P extends Parser<infer V, unknown> ? [AllObjectLike<V>] extends [never] ? never : V : never;
+type ExtractObjectTypes<P> = P extends Parser<Mode, infer V, unknown> ? [AllObjectLike<V>] extends [never] ? never : V : never;
 /**
  * Options for the {@link merge} parser.
  * @since 0.7.0
@@ -688,7 +813,7 @@ interface MergeOptions {
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -703,7 +828,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB, options: MergeOptions): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB, options: MergeOptions): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -720,7 +845,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>>(label: string, a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>>(label: string, a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -736,7 +861,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB, c: ExtractObjectTypes<TC> extends never ? never : TC): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB, c: ExtractObjectTypes<TC> extends never ? never : TC): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -755,7 +880,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>>(label: string, a: TA, b: TB, c: TC): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -773,7 +898,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, c: TC, d: TD): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>, ExtractMode<TD>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -794,7 +919,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>, ExtractMode<TD>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -814,7 +939,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB, c: ExtractObjectTypes<TC> extends never ? never : TC, d: ExtractObjectTypes<TD> extends never ? never : TD, e: ExtractObjectTypes<TE> extends never ? never : TE): Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>>(a: ExtractObjectTypes<TA> extends never ? never : TA, b: ExtractObjectTypes<TB> extends never ? never : TB, c: ExtractObjectTypes<TC> extends never ? never : TC, d: ExtractObjectTypes<TD> extends never ? never : TD, e: ExtractObjectTypes<TE> extends never ? never : TE): Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>, ExtractMode<TD>, ExtractMode<TE>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -837,7 +962,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  * @return A new {@link object} parser that combines the values and states
  *         of the two parsers into a single object.
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>, ExtractMode<TD>, ExtractMode<TE>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -860,7 +985,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -886,7 +1011,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -911,7 +1036,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>, TG extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -939,7 +1064,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>, TG extends Parser<Mode, unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -966,7 +1091,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>, TG extends Parser<Mode, unknown, unknown>, TH extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -996,7 +1121,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>, TG extends Parser<Mode, unknown, unknown>, TH extends Parser<Mode, unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -1025,7 +1150,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>, TI extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>, TG extends Parser<Mode, unknown, unknown>, TH extends Parser<Mode, unknown, unknown>, TI extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -1057,7 +1182,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>, TI extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>, TG extends Parser<Mode, unknown, unknown>, TH extends Parser<Mode, unknown, unknown>, TI extends Parser<Mode, unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser.
  * It is useful for combining multiple {@link object} parsers so that
@@ -1088,7 +1213,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>, TI extends Parser<unknown, unknown>, TJ extends Parser<unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI, j: TJ): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : ExtractObjectTypes<TJ> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI> & ExtractObjectTypes<TJ>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>, TG extends Parser<Mode, unknown, unknown>, TH extends Parser<Mode, unknown, unknown>, TI extends Parser<Mode, unknown, unknown>, TJ extends Parser<Mode, unknown, unknown>>(a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI, j: TJ): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : ExtractObjectTypes<TJ> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI> & ExtractObjectTypes<TJ>, Record<string | symbol, unknown>>;
 /**
  * Merges multiple {@link object} parsers into a single {@link object} parser
  * with a label for documentation and help text organization.
@@ -1122,7 +1247,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         of the parsers into a single object.
  * @since 0.4.0
  */
-declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<unknown, unknown>, TC extends Parser<unknown, unknown>, TD extends Parser<unknown, unknown>, TE extends Parser<unknown, unknown>, TF extends Parser<unknown, unknown>, TG extends Parser<unknown, unknown>, TH extends Parser<unknown, unknown>, TI extends Parser<unknown, unknown>, TJ extends Parser<unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI, j: TJ): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : ExtractObjectTypes<TJ> extends never ? never : Parser<ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI> & ExtractObjectTypes<TJ>, Record<string | symbol, unknown>>;
+declare function merge<TA extends Parser<Mode, unknown, unknown>, TB extends Parser<Mode, unknown, unknown>, TC extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, unknown, unknown>, TE extends Parser<Mode, unknown, unknown>, TF extends Parser<Mode, unknown, unknown>, TG extends Parser<Mode, unknown, unknown>, TH extends Parser<Mode, unknown, unknown>, TI extends Parser<Mode, unknown, unknown>, TJ extends Parser<Mode, unknown, unknown>>(label: string, a: TA, b: TB, c: TC, d: TD, e: TE, f: TF, g: TG, h: TH, i: TI, j: TJ): ExtractObjectTypes<TA> extends never ? never : ExtractObjectTypes<TB> extends never ? never : ExtractObjectTypes<TC> extends never ? never : ExtractObjectTypes<TD> extends never ? never : ExtractObjectTypes<TE> extends never ? never : ExtractObjectTypes<TF> extends never ? never : ExtractObjectTypes<TG> extends never ? never : ExtractObjectTypes<TH> extends never ? never : ExtractObjectTypes<TI> extends never ? never : ExtractObjectTypes<TJ> extends never ? never : Parser<CombineModes<readonly [ExtractMode<TA>, ExtractMode<TB>, ExtractMode<TC>, ExtractMode<TD>, ExtractMode<TE>, ExtractMode<TF>, ExtractMode<TG>, ExtractMode<TH>, ExtractMode<TI>, ExtractMode<TJ>]>, ExtractObjectTypes<TA> & ExtractObjectTypes<TB> & ExtractObjectTypes<TC> & ExtractObjectTypes<TD> & ExtractObjectTypes<TE> & ExtractObjectTypes<TF> & ExtractObjectTypes<TG> & ExtractObjectTypes<TH> & ExtractObjectTypes<TI> & ExtractObjectTypes<TJ>, Record<string | symbol, unknown>>;
 /**
  * Concatenates two {@link tuple} parsers into a single parser that produces
  * a flattened tuple containing the values from both parsers in order.
@@ -1160,7 +1285,7 @@ declare function merge<TA extends Parser<unknown, unknown>, TB extends Parser<un
  *         into a single flattened tuple.
  * @since 0.2.0
  */
-declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TStateA, TStateB>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>): Parser<[...TA, ...TB], [TStateA, TStateB]>;
+declare function concat<MA extends Mode, MB extends Mode, TA extends readonly unknown[], TB extends readonly unknown[], TStateA, TStateB>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>): Parser<CombineModes<readonly [MA, MB]>, [...TA, ...TB], [TStateA, TStateB]>;
 /**
  * Concatenates three {@link tuple} parsers into a single parser that produces
  * a flattened tuple containing the values from all parsers in order.
@@ -1178,7 +1303,7 @@ declare function concat<TA extends readonly unknown[], TB extends readonly unkno
  *         into a single flattened tuple.
  * @since 0.2.0
  */
-declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TStateA, TStateB, TStateC>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>): Parser<[...TA, ...TB, ...TC], [TStateA, TStateB, TStateC]>;
+declare function concat<MA extends Mode, MB extends Mode, MC extends Mode, TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TStateA, TStateB, TStateC>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>): Parser<CombineModes<readonly [MA, MB, MC]>, [...TA, ...TB, ...TC], [TStateA, TStateB, TStateC]>;
 /**
  * Concatenates four {@link tuple} parsers into a single parser that produces
  * a flattened tuple containing the values from all parsers in order.
@@ -1199,7 +1324,7 @@ declare function concat<TA extends readonly unknown[], TB extends readonly unkno
  *         into a single flattened tuple.
  * @since 0.2.0
  */
-declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TStateA, TStateB, TStateC, TStateD>(a: Parser<TA, TStateA>, b: Parser<TB, TStateB>, c: Parser<TC, TStateC>, d: Parser<TD, TStateD>): Parser<[...TA, ...TB, ...TC, ...TD], [TStateA, TStateB, TStateC, TStateD]>;
+declare function concat<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TStateA, TStateB, TStateC, TStateD>(a: Parser<MA, TA, TStateA>, b: Parser<MB, TB, TStateB>, c: Parser<MC, TC, TStateC>, d: Parser<MD, TD, TStateD>): Parser<CombineModes<readonly [MA, MB, MC, MD]>, [...TA, ...TB, ...TC, ...TD], [TStateA, TStateB, TStateC, TStateD]>;
 /**
  * Concatenates five {@link tuple} parsers into a single parser that produces
  * a flattened tuple containing the values from all parsers in order.
@@ -1223,7 +1348,7 @@ declare function concat<TA extends readonly unknown[], TB extends readonly unkno
  *         into a single flattened tuple.
  * @since 0.2.0
  */
-declare function concat<TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TE extends readonly unknown[], 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], [TStateA, TStateB, TStateC, TStateD, TStateE]>;
+declare function concat<MA extends Mode, MB extends Mode, MC extends Mode, MD extends Mode, ME extends Mode, TA extends readonly unknown[], TB extends readonly unknown[], TC extends readonly unknown[], TD extends readonly unknown[], TE extends readonly unknown[], TStateA, TStateB, TStateC, TStateD, TStateE>(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>): Parser<CombineModes<readonly [MA, MB, MC, MD, ME]>, [...TA, ...TB, ...TC, ...TD, ...TE], [TStateA, TStateB, TStateC, TStateD, TStateE]>;
 /**
  * Wraps a parser with a group label for documentation purposes.
  *
@@ -1266,7 +1391,7 @@ declare function concat<TA extends readonly unknown[], TB extends readonly unkno
  *          but generates documentation within a labeled section.
  * @since 0.4.0
  */
-declare function group<TValue, TState>(label: string, parser: Parser<TValue, TState>): Parser<TValue, TState>;
+declare function group<M extends Mode, TValue, TState>(label: string, parser: Parser<M, TValue, TState>): Parser<M, TValue, TState>;
 /**
  * Tagged union type representing which branch is selected.
  * Uses tagged union to avoid collision with discriminator values.
@@ -1317,17 +1442,12 @@ interface ConditionalOptions {
  * Helper type to infer result type without default branch.
  * @internal
  */
-type ConditionalResultWithoutDefault<TDiscriminator extends string, TBranches extends Record<string, Parser<unknown, unknown>>> = { [K in keyof TBranches & string]: readonly [K, InferValue<TBranches[K]>] }[keyof TBranches & string];
+type ConditionalResultWithoutDefault<TDiscriminator extends string, TBranches extends Record<string, Parser<Mode, unknown, unknown>>> = { [K in keyof TBranches & string]: readonly [K, InferValue<TBranches[K]>] }[keyof TBranches & string];
 /**
  * Helper type to infer result type with default branch.
  * @internal
  */
-type ConditionalResultWithDefault<TDiscriminator extends string, TBranches extends Record<string, Parser<unknown, unknown>>, TDefault extends Parser<unknown, unknown>> = ConditionalResultWithoutDefault<TDiscriminator, TBranches> | readonly [undefined, InferValue<TDefault>];
-/**
- * Helper type to infer value type from a parser.
- * @internal
- */
-type InferValue<T> = T extends Parser<infer V, unknown> ? V : never;
+type ConditionalResultWithDefault<TDiscriminator extends string, TBranches extends Record<string, Parser<Mode, unknown, unknown>>, TDefault extends Parser<Mode, unknown, unknown>> = ConditionalResultWithoutDefault<TDiscriminator, TBranches> | readonly [undefined, InferValue<TDefault>];
 /**
  * Creates a conditional parser without a default branch.
  * The discriminator option is required; parsing fails if not provided.
@@ -1339,7 +1459,7 @@ type InferValue<T> = T extends Parser<infer V, unknown> ? V : never;
  * @returns A parser that produces a tuple `[discriminatorValue, branchResult]`.
  * @since 0.8.0
  */
-declare function conditional<TDiscriminator extends string, TBranches extends { [K in TDiscriminator]: Parser<unknown, unknown> }>(discriminator: Parser<TDiscriminator, unknown>, branches: TBranches): Parser<ConditionalResultWithoutDefault<TDiscriminator, TBranches>, ConditionalState<TDiscriminator>>;
+declare function conditional<TDiscriminator extends string, TBranches extends { [K in TDiscriminator]: Parser<Mode, unknown, unknown> }, TD extends Parser<Mode, TDiscriminator, unknown>>(discriminator: TD, branches: TBranches): Parser<CombineModes<readonly [ExtractMode<TD>, ...{ [K in keyof TBranches]: ExtractMode<TBranches[K]> }[keyof TBranches][]]>, ConditionalResultWithoutDefault<TDiscriminator, TBranches>, ConditionalState<TDiscriminator>>;
 /**
  * Creates a conditional parser with a default branch.
  * The default branch is used when the discriminator option is not provided.
@@ -1354,6 +1474,6 @@ declare function conditional<TDiscriminator extends string, TBranches extends {
  * @returns A parser that produces a tuple `[discriminatorValue | undefined, branchResult]`.
  * @since 0.8.0
  */
-declare function conditional<TDiscriminator extends string, TBranches extends { [K in TDiscriminator]: Parser<unknown, unknown> }, TDefault extends Parser<unknown, unknown>>(discriminator: Parser<TDiscriminator, unknown>, branches: TBranches, defaultBranch: TDefault, options?: ConditionalOptions): Parser<ConditionalResultWithDefault<TDiscriminator, TBranches, TDefault>, ConditionalState<TDiscriminator>>;
+declare function conditional<TDiscriminator extends string, TBranches extends { [K in TDiscriminator]: Parser<Mode, unknown, unknown> }, TDefault extends Parser<Mode, unknown, unknown>, TD extends Parser<Mode, TDiscriminator, unknown>>(discriminator: TD, branches: TBranches, defaultBranch: TDefault, options?: ConditionalOptions): Parser<CombineModes<readonly [ExtractMode<TD>, ExtractMode<TDefault>, ...{ [K in keyof TBranches]: ExtractMode<TBranches[K]> }[keyof TBranches][]]>, ConditionalResultWithDefault<TDiscriminator, TBranches, TDefault>, ConditionalState<TDiscriminator>>;
 //#endregion
 export { ConditionalErrorOptions, ConditionalOptions, DuplicateOptionError, LongestMatchErrorOptions, LongestMatchOptions, MergeOptions, NoMatchContext, ObjectErrorOptions, ObjectOptions, OrErrorOptions, OrOptions, TupleOptions, concat, conditional, group, longestMatch, merge, object, or, tuple };