Huge News!Announcing our $40M Series B led by Abstract Ventures.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@spellu/engine

Package Overview
Dependencies
Maintainers
2
Versions
21
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@spellu/engine - npm Package Compare versions

Comparing version 0.1.0 to 0.1.1

LICENSE.txt

5

package.json
{
"name": "@spellu/engine",
"version": "0.1.0",
"version": "0.1.1",
"license": "MIT",

@@ -22,3 +22,4 @@ "description": "Spellu is a parser combinator engine.",

"registry": "https://registry.npmjs.org/"
}
},
"gitHead": "6a75afcfce0050588b0485785b3fee6719dfa0a6"
}

1080

spellu-engine.d.ts
declare namespace spellu {
type Dictionary<V> = {
[name: string]: V;
};
interface SourceFile {
path: string;
text: string;
}
interface TextRange {
begin: number;
end: number;
}
interface Location {
lineNo: number;
columnNo: number;
}
interface Node {
syntax: string;
range?: TextRange;
}
interface Token extends Node {
string: string;
value?: string;
sequence?: Token[];
}
type Dictionary<V> = {
[name: string]: V;
};
interface SourceFile {
path: string;
text: string;
}
interface TextRange {
begin: number;
end: number;
}
interface Location {
lineNo: number;
columnNo: number;
}
interface Node {
range: TextRange;
syntax: string;
}
interface Token extends Node {
syntax: string;
string: string;
value: string;
comments?: Comment[];
}
type Comment = Token[];
interface Indent extends Node {
syntax: 'text.indent';
string: string;
level: number;
}
interface Recipe {
name: string;
spacePattern?: string | RegExp;
commentRule?: string;
rules: Dictionary<Rule | ParserBox<any>>;
}
interface Rule {
sticky?: boolean;
parser: string;
argument?: any;
options?: {};
multiplicity?: number | [number, number];
optional?: boolean;
}
interface Processor {
recipe: Recipe;
parts: Dictionary<(_: any) => any>;
}
class SpelluError extends Error {
}
}
declare namespace spellu {
interface SourceOption {
normalize?: boolean;
}
class Source {
readonly input: string;
protected location: string;
protected linePositions?: number[];
constructor(input: string, location: string, option?: SourceOption);
protected normalizeSource(string: string): string;
protected stripUtf8Bom(string: string): string;
protected normalizeNewLine(string: string): string;
protected addTrailNewLine(string: string): string;
stream(position?: number): SourceStream;
position2d(position: number): Location;
getLinePositions(): number[];
getLine(line: number): string | null;
getExcerpt(position: number, maxLength: number): string;
}
interface SourceOption {
normalize?: boolean;
}
class Source {
readonly input: string;
protected location: string;
protected linePositions?: number[];
constructor(input: string, location: string, option?: SourceOption);
protected normalizeSource(string: string): string;
protected stripUtf8Bom(string: string): string;
protected normalizeNewLine(string: string): string;
protected addTrailNewLine(string: string): string;
stream(position?: number): SourceStream;
position2d(position: number): Location;
getLinePositions(): number[];
getLine(line: number): string | null;
getExcerpt(position: number, maxLength: number): string;
}
}
declare namespace spellu {
interface SourceStreamOption {
length?: number;
position?: number;
}
class SourceStream {
readonly input: string;
readonly length: number;
position: number;
constructor(input: string, option?: SourceStreamOption);
clone(): SourceStream;
charCodeAt(offset?: number): number;
substring(length: number): string;
nowEol(): boolean;
nowEos(): boolean;
startsWith(pattern: string): boolean;
test(pattern: string | RegExp): boolean;
skip(length: number): number;
consume(pattern: string | RegExp): boolean;
scan(syntax: string, pattern: string | RegExp, matchIndex?: number): Token | null;
scanBlock(syntax: string, openString: string, closeString: string, option?: {
allowRecursive?: boolean;
allowMultiline?: boolean;
innerPattern?: string;
}): Token | null;
read<T>(pattern: string | RegExp, converter: (result: string[]) => T, defaultValue: T): T;
match<T>(pattern: string | RegExp, converter: (result: string[]) => T, defaultValue: T, option?: {
locationUpdate?: boolean;
}): T;
matchString<T>(pattern: string, converter: (result: string[]) => T, defaultValue: T, option?: {
locationUpdate?: boolean;
}): T;
matchRegex<T>(pattern: RegExp, converter: (result: string[]) => T, defaultValue: T, option?: {
locationUpdate?: boolean;
}): T;
protected isEosPattern(stringOrPattern: string | RegExp): boolean;
protected regexp(stringOrPattern: string | RegExp): RegExp;
protected matchBlock(openString: string, closeString: string, innerPattern: string): number;
protected matchBlockRecursive(openString: string, closeString: string, innerPattern: string): number;
protected escapeForReadAhead(string: string): string;
token(syntax: string, position: number, string?: string, value?: string): Token;
protected updateLocation(string: string): void;
}
interface SourceStreamOption {
length?: number;
position?: number;
}
class SourceStream {
readonly input: string;
readonly length: number;
position: number;
constructor(input: string, option?: SourceStreamOption);
clone(): SourceStream;
charCodeAt(offset?: number): number;
substring(length: number): string;
nowEol(): boolean;
nowEos(): boolean;
startsWith(pattern: string): boolean;
test(pattern: string | RegExp): boolean;
skip(length: number): number;
consume(pattern: string | RegExp): boolean;
fetch(syntax: string, pattern: string | RegExp, matchIndex?: number): Token | null;
scan(syntax: string, pattern: string | RegExp, matchIndex?: number): Token | null;
fetchIndent(pattern?: string | RegExp): Indent;
scanIndent(pattern?: string | RegExp): Indent;
read<T>(pattern: string | RegExp, converter: (result: string[]) => T, defaultValue: T): T;
match<T>(pattern: string | RegExp, converter: (result: string[]) => T, defaultValue: T, option?: {
locationUpdate?: boolean;
}): T;
matchString<T>(pattern: string, converter: (result: string[]) => T, defaultValue: T, option?: {
locationUpdate?: boolean;
}): T;
matchRegex<T>(pattern: RegExp, converter: (result: string[]) => T, defaultValue: T, option?: {
locationUpdate?: boolean;
}): T;
protected regexp(stringOrPattern: string | RegExp): RegExp;
token(syntax: string, position: number, string: string | undefined, value: string): Token;
indent(position: number, string: string | undefined, level: number): Indent;
protected updateLocation(string: string): void;
}
}
declare namespace spellu {
type TextPrinterOptions = {
indent?: number | 'tab';
lineBreak?: string;
};
class TextPrinter {
_indent: number | 'tab';
_lineBreak: string;
_lines: string[];
_indentLevel: number;
_line: string;
constructor(options?: TextPrinterOptions);
indentUp(level?: number): this;
indentDown(level?: number): this;
text(...texts: (string | undefined)[]): this;
quote(quote: string, text: string): this;
newLine(indentLevel?: number): this;
indentString(): string;
flash(): string;
}
type TextPrinterOptions = {
indent?: number | 'tab';
lineBreak?: string;
};
class TextPrinter {
_indent: number | 'tab';
_lineBreak: string;
_lines: string[];
_indentLevel: number;
_line: string;
constructor(options?: TextPrinterOptions);
indentUp(level?: number): this;
indentDown(level?: number): this;
text(...texts: (string | undefined)[]): this;
quote(quote: string, text: string): this;
newLine(indentLevel?: number): this;
indentString(): string;
flash(): string;
}
}
declare namespace spellu {
interface Expected {
position: number;
expected: string;
}
interface ParsedValue<S, F> {
isSuccess(): this is Success<S>;
isFailure(): this is Failure<F>;
success(callback: (value: S) => void): ParsedValue<S, F>;
failure(callback: (diagnosis: F) => void): ParsedValue<S, F>;
extract(): S | F;
resolve<T>(left?: (diagnosis: F) => T, right?: (value: S) => T): T | null;
}
class Success<V> implements ParsedValue<V, never> {
readonly value: V;
constructor(value: V);
isSuccess(): this is Success<V>;
isFailure(): this is Failure<never>;
success(callback: (value: V) => void): this;
failure(callback: (diagnosis: never) => void): this;
extract(): V;
resolve<T>(left?: (diagnosis: never) => T, right?: (value: V) => T): T | null;
}
class Failure<V> implements ParsedValue<never, V> {
readonly value: V;
constructor(value: V);
isSuccess(): this is Success<never>;
isFailure(): this is Failure<V>;
success(callback: (value: never) => void): this;
failure(callback: (value: V) => void): this;
extract(): V;
resolve<T>(left?: (value: V) => T, right?: (value: never) => T): T | null;
}
interface Diagnosis {
position: number;
}
class DiagnosticMessage implements Diagnosis {
position: number;
message: string;
constructor(position: number, message: string);
}
class DiagnosticExpectedRule implements Diagnosis {
position: number;
rules: string[];
constructor(position: number, rules: string[]);
}
type ParserResult<V> = Success<V> | Failure<string>;
class Parser<V> {
readonly runner: (m: Circuit<any>) => ParserResult<V>;
readonly name?: string;
readonly args?: any[];
constructor(runner: (m: Circuit<any>) => ParserResult<V>, name?: string, args?: any[]);
run(m: Circuit<any>): ParserResult<V>;
andL<T>(parser: Parser<T>): Parser<V>;
andR<T>(parser: Parser<T>): Parser<T>;
or<W>(parser: Parser<W>): Parser<V | W | null>;
multiplicity(multiplicity: number | [number, number]): Parser<V[]>;
optional(): Parser<V | null>;
times(count: number): Parser<V[]>;
timesMany(min: number): Parser<V[]>;
timesBetween(min: number, max: number): Parser<V[]>;
$0(): Parser<V[]>;
$1(): Parser<V[]>;
$_(): Parser<V | null>;
recover(callback: (m: Circuit<any>) => void): Parser<V>;
toString(): string;
hook(callback: (m: Circuit<any>, r: ParserResult<V>) => void): Parser<V>;
accept<T>(callback: (value: V) => T): Parser<T>;
log(callback?: (result: ParserResult<V>) => any, depth?: number): Parser<V>;
}
class Circuit<W = null> {
input: SourceStream;
spacePattern: RegExp;
cluster: Dictionary<Module>;
expectedRules: Expected[];
diagnoses: Diagnosis[];
logs: string[];
constructor(input: SourceStream, cluster: Dictionary<Module>);
run<V>(parser: Parser<V>): ParserResult<V>;
success<V>(value: V): Success<V>;
failure<V>(value: V): Failure<V>;
expect(label: string): Failure<string>;
error(message: string): Failure<string>;
skipSpaces(): this;
retrieve<V>(path: string): Parser<V>;
fixExpectedRules(): void;
clearExpectedRules(): void;
}
interface ParserBox<V> {
(...args: any[]): Parser<V>;
}
function syntactic<V>(box: ParserBox<V>, ...args: any[]): Parser<V>;
function lexical<V>(box: ParserBox<V>, ...args: any[]): Parser<V>;
interface TokenPattern {
syntax: string;
pattern: string | RegExp;
label?: string;
capture?: number;
value?: string;
}
function token(pattern: TokenPattern | TokenPattern[]): Parser<Token>;
interface Expected {
position: number;
expected: string;
}
interface ParsedValue<S, F> {
isSuccess(): this is Success<S>;
isFailure(): this is Failure<F>;
success(callback: (value: S) => void): ParsedValue<S, F>;
failure(callback: (diagnosis: F) => void): ParsedValue<S, F>;
extract(): S | F;
resolve<T>(left?: (diagnosis: F) => T, right?: (value: S) => T): T | null;
}
class Success<V> implements ParsedValue<V, never> {
readonly value: V;
constructor(value: V);
isSuccess(): this is Success<V>;
isFailure(): this is Failure<never>;
success(callback: (value: V) => void): this;
failure(callback: (diagnosis: never) => void): this;
extract(): V;
resolve<T>(left?: (diagnosis: never) => T, right?: (value: V) => T): T | null;
}
class Failure<V> implements ParsedValue<never, V> {
readonly value: V;
constructor(value: V);
isSuccess(): this is Success<never>;
isFailure(): this is Failure<V>;
success(callback: (value: never) => void): this;
failure(callback: (value: V) => void): this;
extract(): V;
resolve<T>(left?: (value: V) => T, right?: (value: never) => T): T | null;
}
interface Diagnosis {
position: number;
}
class DiagnosticMessage implements Diagnosis {
position: number;
message: string;
constructor(position: number, message: string);
}
class DiagnosticExpectedRule implements Diagnosis {
position: number;
rules: string[];
constructor(position: number, rules: string[]);
}
type ParserResult<V> = Success<V> | Failure<string>;
class Parser<V> {
readonly runner: (m: Machine) => ParserResult<V>;
readonly name?: string;
readonly args?: any[];
constructor(runner: (m: Machine) => ParserResult<V>, name?: string, args?: any[]);
run(m: Machine): ParserResult<V>;
andL<T>(parser: Parser<T>): Parser<V>;
andR<T>(parser: Parser<T>): Parser<T>;
or<W>(parser: Parser<W>): Parser<V | W | null>;
multiplicity(value: number | [number, number]): Parser<V[]>;
optional(): Parser<V | null>;
times(count: number): Parser<V[]>;
timesMany(min: number): Parser<V[]>;
timesBetween(min: number, max: number): Parser<V[]>;
$0(): Parser<V[]>;
$1(): Parser<V[]>;
$_(): Parser<V | null>;
recover(callback: (m: Machine) => void): Parser<V>;
toString(): string;
hook(callback: (m: Machine, r: ParserResult<V>) => void): Parser<V>;
accept<T>(callback: (value: V) => T): Parser<T>;
log(callback?: (result: ParserResult<V>) => any, depth?: number): Parser<V>;
}
const SPACE_PATTERN: RegExp;
const EOL_PATTERN: RegExp;
const BLANKLINE_PATTERN: RegExp;
class Machine {
constructor(input: SourceStream, cluster: Dictionary<Board>);
input: SourceStream;
cluster: Dictionary<Board>;
spacePattern: RegExp;
commentParser: Parser<Token> | null;
commentStack: Comment[];
indentStack: string[];
inSkipComment: boolean;
expectedRules: Expected[];
diagnoses: Diagnosis[];
logs: string[];
run<V>(parser: Parser<V>): ParserResult<V>;
success<V>(value: V): Success<V>;
failure<V>(value: V): Failure<V>;
expect(label: string): Failure<string>;
error(message: string): Failure<string>;
saveState(): Dictionary<any>;
loadState(state: Dictionary<any>): void;
skipSpaces(): this;
scanComments(): void;
consumeSkippedComments(): Comment[];
retrieve<V>(path: string): Parser<V>;
fixExpectedRules(): void;
clearExpectedRules(): void;
}
interface ParserBox<V> {
(...args: any[]): Parser<V>;
}
function delay<V>(box: ParserBox<V>, ...args: any[]): Parser<V>;
interface TokenPattern {
syntax: string;
pattern: string | RegExp;
label?: string;
capture?: number;
value?: string;
}
function token(sticky: boolean, pattern: TokenPattern | TokenPattern[]): Parser<Token>;
function indentUp<V>(parser: Parser<V>): Parser<V | null>;
function indent(): Parser<Indent>;
function eol(): Parser<Comment[]>;
function ruleRef<V>(rulePath: string): Parser<V>;
}
declare namespace spellu {
class SpelluError extends Error {
}
type Recipe = Dictionary<Rule | ParserBox<any>>;
interface Rule {
syntactic?: boolean;
parser: string;
argument?: any;
options?: any;
multiplicity?: number | [number, number];
optional?: boolean;
}
interface Machine {
name: string;
recipe: Recipe;
processors: Dictionary<(_: any) => any>;
}
class Module {
constructor(name: string, rules: Dictionary<ParserBox<any>>);
protected _name: string;
protected _rules: Dictionary<ParserBox<any>>;
protected _parsers: Dictionary<Parser<any>>;
protected _first?: string;
name(): string;
ruleExists(name: string): boolean;
ruleNames(): string[];
rule(name: string): Parser<any> | null;
first(): Parser<any> | null;
}
function prepare(machine: Machine): Module;
class Board {
constructor(name: string, rules: Dictionary<ParserBox<any>>, spacePattern?: RegExp, commentRuleName?: string);
protected _name: string;
protected _rules: Dictionary<ParserBox<any>>;
protected _spacePattern: RegExp;
protected _commentRuleName?: string;
protected _parsers: Dictionary<Parser<any>>;
name(): string;
spacePattern(): RegExp;
ruleExists(name: string): boolean;
ruleNames(): string[];
rule(name: string): Parser<any> | null;
firstRule(): Parser<any> | null;
commentRule(): Parser<any> | null;
}
function prepare(processor: Processor): Board;
}
declare namespace spellu {
function and<V1>(p1: Parser<V1>): Parser<V1>;
function and<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2]>;
function and<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3]>;
function and<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4]>;
function and<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5]>;
function and<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6]>;
function and<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7]>;
function and<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8]>;
function and<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9]>;
function and(...parsers: Parser<any>[]): Parser<any[]>;
function or<V1>(p1: Parser<V1>): Parser<V1>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<V1 | V2>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<V1 | V2 | V3>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | V2 | V3 | V4>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | V2 | V3 | V4 | V5>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V2 | V3 | V4 | V5 | V6>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9>;
function or(...parsers: Parser<any>[]): Parser<any>;
function optional<V>(parser: Parser<V>): Parser<V | null>;
function many<V>(parser: Parser<V>, min: number, max?: number): Parser<V[]>;
function recover<V>(parser: Parser<V>, callback: (circuit: Circuit<any>) => void): Parser<V>;
function $$<V1>(p1: Parser<V1>): Parser<V1>;
function $$<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2]>;
function $$<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3]>;
function $$<V1, V3>(p1: Parser<V1>, p2: '|', p3: Parser<V3>): Parser<V1 | V3>;
function $$<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4]>;
function $$<V1, V3, V4>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | [V3, V4]>;
function $$<V1, V2, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>): Parser<[V1, V2] | V4>;
function $$<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5]>;
function $$<V1, V3, V4, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | [V3, V4, V5]>;
function $$<V1, V2, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2] | [V4, V5]>;
function $$<V1, V2, V3, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<[V1, V2, V3] | V5>;
function $$<V1, V3, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<V1 | V3 | V5>;
function $$<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6]>;
function $$<V1, V3, V4, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | [V3, V4, V5, V6]>;
function $$<V1, V2, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2] | [V4, V5, V6]>;
function $$<V1, V2, V3, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3] | [V5, V6]>;
function $$<V1, V2, V3, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<[V1, V2, V3, V4] | V6>;
function $$<V1, V3, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V3 | [V5, V6]>;
function $$<V1, V3, V4, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<V1 | [V3, V4] | V6>;
function $$<V1, V2, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<[V1, V2] | V4 | V6>;
function $$<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7]>;
function $$<V1, V3, V5, V7>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>): Parser<V1 | V3 | V5 | V7>;
function $$<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8]>;
function $$<V1, V2, V4, V5, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2] | [V4, V5] | [V7, V8]>;
function $$<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9]>;
function $$<V1, V3, V5, V7, V9>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>): Parser<V1 | V3 | V5 | V7 | V9>;
function $$<V1, V3, V5, V7, V9, V11>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>): Parser<V1 | V3 | V5 | V7 | V9 | V11>;
function $$<V1, V3, V5, V7, V9, V11, V13>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13>;
function $$<V1, V3, V5, V7, V9, V11, V13, V15>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15>;
function $$<V1, V3, V5, V7, V9, V11, V13, V15, V17>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>, p16: '|', p17: Parser<V17>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | V17>;
function $$(p1: Parser<any>, ...parsers: ('|' | Parser<any>)[]): Parser<any>;
namespace $$ {
function L<V>(p1: Parser<V>, ...parsers: Parser<any>[]): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<any>, p9: Parser<V>): Parser<V>;
function M<V2>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<any>): Parser<V2>;
function M<V2, V3>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<any>): Parser<[V2, V3]>;
function M<V2, V3, V4>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<any>): Parser<[V2, V3, V4]>;
function M<V2, V3, V4, V5>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<any>): Parser<[V2, V3, V4, V5]>;
function M<V2, V3, V4, V5, V6>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>): Parser<[V2, V3, V4, V5, V6]>;
function M<V2, V3, V4, V5, V6, V7>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7]>;
function M<V2, V3, V4, V5, V6, V7, V8>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>, p8: Parser<V8>, p9: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7, V8]>;
function or<V1>(p1: Parser<V1>): Parser<V1>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<V1 | V2>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<V1 | V2 | V3>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | V2 | V3 | V4>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | V2 | V3 | V4 | V5>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V2 | V3 | V4 | V5 | V6>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9>;
function or(parser: Parser<any>, ...parsers: Parser<any>[]): Parser<any>;
}
function $0<V1>(p1: Parser<V1>): Parser<V1[]>;
function $0<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2][]>;
function $0<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3][]>;
function $0<V1, V3>(p1: Parser<V1>, p2: '|', p3: Parser<V3>): Parser<(V1 | V3)[]>;
function $0<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4][]>;
function $0<V1, V3, V4>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>): Parser<(V1 | [V3, V4])[]>;
function $0<V1, V2, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>): Parser<([V1, V2] | V4)[]>;
function $0<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5][]>;
function $0<V1, V3, V4, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<(V1 | [V3, V4, V5])[]>;
function $0<V1, V2, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>): Parser<([V1, V2] | [V4, V5])[]>;
function $0<V1, V2, V3, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<([V1, V2, V3] | V5)[]>;
function $0<V1, V3, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<(V1 | V3 | V5)[]>;
function $0<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6][]>;
function $0<V1, V3, V4, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | [V3, V4, V5, V6])[]>;
function $0<V1, V2, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<([V1, V2] | [V4, V5, V6])[]>;
function $0<V1, V2, V3, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<([V1, V2, V3] | [V5, V6])[]>;
function $0<V1, V2, V3, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<([V1, V2, V3, V4] | V6)[]>;
function $0<V1, V3, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | V3 | [V5, V6])[]>;
function $0<V1, V3, V4, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<(V1 | [V3, V4] | V6)[]>;
function $0<V1, V2, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<([V1, V2] | V4 | V6)[]>;
function $0<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7][]>;
function $0<V1, V3, V5, V7>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>): Parser<(V1 | V3 | V5 | V7)[]>;
function $0<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8][]>;
function $0<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9][]>;
function $0<V1, V3, V5, V7, V9>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>): Parser<(V1 | V3 | V5 | V7 | V9)[]>;
function $0<V1, V3, V5, V7, V9, V11>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>): Parser<(V1 | V3 | V5 | V7 | V9 | V11)[]>;
function $0<V1, V3, V5, V7, V9, V11, V13>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13)[]>;
function $0<V1, V3, V5, V7, V9, V11, V13, V15>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15)[]>;
function $0<V1, V3, V5, V7, V9, V11, V13, V15, V17>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>, p16: '|', p17: Parser<V17>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | V17)[]>;
function $0(parser: Parser<any>, ...parsers: ('|' | Parser<any>)[]): Parser<any[][]>;
namespace $0 {
function L<V>(p1: Parser<V>, ...parsers: Parser<any>[]): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<any>, p9: Parser<V>): Parser<V[]>;
function M<V2>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<any>): Parser<V2[]>;
function M<V2, V3>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<any>): Parser<[V2, V3][]>;
function M<V2, V3, V4>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<any>): Parser<[V2, V3, V4][]>;
function M<V2, V3, V4, V5>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<any>): Parser<[V2, V3, V4, V5][]>;
function M<V2, V3, V4, V5, V6>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>): Parser<[V2, V3, V4, V5, V6][]>;
function M<V2, V3, V4, V5, V6, V7>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7][]>;
function M<V2, V3, V4, V5, V6, V7, V8>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>, p8: Parser<V8>, p9: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7, V8][]>;
function or<V1>(p1: Parser<V1>): Parser<V1[]>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<(V1 | V2)[]>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<(V1 | V2 | V3)[]>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<(V1 | V2 | V3 | V4)[]>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<(V1 | V2 | V3 | V4 | V5)[]>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | V2 | V3 | V4 | V5 | V6)[]>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7)[]>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8)[]>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9)[]>;
function or(parser: Parser<any>, ...parsers: Parser<any>[]): Parser<any>;
}
function $1<V1>(p1: Parser<V1>): Parser<V1[]>;
function $1<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2][]>;
function $1<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3][]>;
function $1<V1, V3>(p1: Parser<V1>, p2: '|', p3: Parser<V3>): Parser<(V1 | V3)[]>;
function $1<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4][]>;
function $1<V1, V3, V4>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>): Parser<(V1 | [V3, V4])[]>;
function $1<V1, V2, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>): Parser<([V1, V2] | V4)[]>;
function $1<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5][]>;
function $1<V1, V3, V4, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<(V1 | [V3, V4, V5])[]>;
function $1<V1, V2, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>): Parser<([V1, V2] | [V4, V5])[]>;
function $1<V1, V2, V3, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<([V1, V2, V3] | V5)[]>;
function $1<V1, V3, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<(V1 | V3 | V5)[]>;
function $1<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6][]>;
function $1<V1, V3, V4, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | [V3, V4, V5, V6])[]>;
function $1<V1, V2, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<([V1, V2] | [V4, V5, V6])[]>;
function $1<V1, V2, V3, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<([V1, V2, V3] | [V5, V6])[]>;
function $1<V1, V2, V3, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<([V1, V2, V3, V4] | V6)[]>;
function $1<V1, V3, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | V3 | [V5, V6])[]>;
function $1<V1, V3, V4, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<(V1 | [V3, V4] | V6)[]>;
function $1<V1, V2, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<([V1, V2] | V4 | V6)[]>;
function $1<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7][]>;
function $1<V1, V3, V5, V7>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>): Parser<(V1 | V3 | V5 | V7)[]>;
function $1<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8][]>;
function $1<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9][]>;
function $1<V1, V3, V5, V7, V9>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>): Parser<(V1 | V3 | V5 | V7 | V9)[]>;
function $1<V1, V3, V5, V7, V9, V11>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>): Parser<(V1 | V3 | V5 | V7 | V9 | V11)[]>;
function $1<V1, V3, V5, V7, V9, V11, V13>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13)[]>;
function $1<V1, V3, V5, V7, V9, V11, V13, V15>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15)[]>;
function $1<V1, V3, V5, V7, V9, V11, V13, V15, V17>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>, p16: '|', p17: Parser<V17>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | V17)[]>;
function $1(parser: Parser<any>, ...parsers: ('|' | Parser<any>)[]): Parser<any[][]>;
namespace $1 {
function L<V>(p1: Parser<V>, ...parsers: Parser<any>[]): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<any>, p9: Parser<V>): Parser<V[]>;
function M<V2>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<any>): Parser<V2[]>;
function M<V2, V3>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<any>): Parser<[V2, V3][]>;
function M<V2, V3, V4>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<any>): Parser<[V2, V3, V4][]>;
function M<V2, V3, V4, V5>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<any>): Parser<[V2, V3, V4, V5][]>;
function M<V2, V3, V4, V5, V6>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>): Parser<[V2, V3, V4, V5, V6][]>;
function M<V2, V3, V4, V5, V6, V7>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7][]>;
function M<V2, V3, V4, V5, V6, V7, V8>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>, p8: Parser<V8>, p9: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7, V8][]>;
function or<V1>(p1: Parser<V1>): Parser<V1[]>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<(V1 | V2)[]>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<(V1 | V2 | V3)[]>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<(V1 | V2 | V3 | V4)[]>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<(V1 | V2 | V3 | V4 | V5)[]>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | V2 | V3 | V4 | V5 | V6)[]>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7)[]>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8)[]>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9)[]>;
function or(parser: Parser<any>, ...parsers: Parser<any>[]): Parser<any>;
}
function $_<V1>(p1: Parser<V1>): Parser<V1 | null>;
function $_<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2] | null>;
function $_<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3] | null>;
function $_<V1, V3>(p1: Parser<V1>, p2: '|', p3: Parser<V3>): Parser<V1 | V3 | null>;
function $_<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4] | null>;
function $_<V1, V3, V4>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | [V3, V4] | null>;
function $_<V1, V2, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>): Parser<[V1, V2] | V4 | null>;
function $_<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5] | null>;
function $_<V1, V3, V4, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | [V3, V4, V5] | null>;
function $_<V1, V2, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2] | [V4, V5] | null>;
function $_<V1, V2, V3, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<[V1, V2, V3] | V5 | null>;
function $_<V1, V3, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<V1 | V3 | V5 | null>;
function $_<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6] | null>;
function $_<V1, V3, V4, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | [V3, V4, V5, V6] | null>;
function $_<V1, V2, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2] | [V4, V5, V6] | null>;
function $_<V1, V2, V3, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3] | [V5, V6] | null>;
function $_<V1, V2, V3, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<[V1, V2, V3, V4] | V6 | null>;
function $_<V1, V3, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V3 | [V5, V6] | null>;
function $_<V1, V3, V4, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<V1 | [V3, V4] | V6 | null>;
function $_<V1, V2, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<[V1, V2] | V4 | V6 | null>;
function $_<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7] | null>;
function $_<V1, V3, V5, V7>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>): Parser<V1 | V3 | V5 | V7 | null>;
function $_<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8] | null>;
function $_<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9] | null>;
function $_<V1, V3, V5, V7, V9>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>): Parser<V1 | V3 | V5 | V7 | V9 | null>;
function $_<V1, V3, V5, V7, V9, V11>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | null>;
function $_<V1, V3, V5, V7, V9, V11, V13>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | null>;
function $_<V1, V3, V5, V7, V9, V11, V13, V15>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | null>;
function $_<V1, V3, V5, V7, V9, V11, V13, V15, V17>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>, p16: '|', p17: Parser<V17>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | V17 | null>;
namespace $_ {
function L<V>(p1: Parser<V>, ...parsers: Parser<any>[]): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<any>, p9: Parser<V>): Parser<V | null>;
function M<V2>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<any>): Parser<V2 | null>;
function M<V2, V3>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<any>): Parser<[V2, V3] | null>;
function M<V2, V3, V4>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<any>): Parser<[V2, V3, V4] | null>;
function M<V2, V3, V4, V5>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<any>): Parser<[V2, V3, V4, V5] | null>;
function M<V2, V3, V4, V5, V6>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>): Parser<[V2, V3, V4, V5, V6] | null>;
function M<V2, V3, V4, V5, V6, V7>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7] | null>;
function M<V2, V3, V4, V5, V6, V7, V8>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>, p8: Parser<V8>, p9: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7, V8] | null>;
function or<V1>(p1: Parser<V1>): Parser<V1 | null>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<V1 | V2 | null>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<V1 | V2 | V3 | null>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | V2 | V3 | V4 | null>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | V2 | V3 | V4 | V5 | null>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | null>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | null>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | null>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | null>;
function or(parser: Parser<any>, ...parsers: Parser<any>[]): Parser<any>;
}
function $<V>(box: ParserBox<V>, ...args: any[]): Parser<V>;
function _<V>(box: ParserBox<V>, ...args: any[]): Parser<V>;
namespace $ {
function always(): Parser<undefined>;
function always<V>(value: V): Parser<V>;
function never<V>(message_?: string): Parser<V>;
function start<V>(parser: Parser<V>): Parser<V>;
function end(): Parser<null>;
function not<V>(parser: Parser<V>): Parser<null>;
function listOf<V, S>(valueParser: Parser<V>, sepalatorParser: Parser<S>, options: {
allowTrailingSeparator: boolean;
}): Parser<V[]>;
function any(syntax: string): Parser<Token>;
function space(syntax: string, label: string): Parser<Token>;
function string(syntax: string, string: string): Parser<Token>;
function regex(syntax: string, pattern: string | RegExp, index?: number): Parser<Token>;
function token(pattern: TokenPattern | TokenPattern[]): Parser<Token>;
function module<V>(nameOrModule: string | Module, ruleName: string): Parser<V>;
function tap<T>(object: T, callback: (object: T) => void): T;
function node<N extends Node>(syntax: string, data: {}, range?: TextRange): N;
function range(mostLeftNode: Node, mostRightNode: Node): TextRange | undefined;
}
function and<V1>(p1: Parser<V1>): Parser<V1>;
function and<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2]>;
function and<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3]>;
function and<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4]>;
function and<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5]>;
function and<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6]>;
function and<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7]>;
function and<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8]>;
function and<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9]>;
function and(...parsers: Parser<any>[]): Parser<any[]>;
function or<V1>(p1: Parser<V1>): Parser<V1>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<V1 | V2>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<V1 | V2 | V3>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | V2 | V3 | V4>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | V2 | V3 | V4 | V5>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V2 | V3 | V4 | V5 | V6>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9>;
function or(...parsers: Parser<any>[]): Parser<any>;
function optional<V>(parser: Parser<V>): Parser<V | null>;
function many<V>(parser: Parser<V>, min: number, max?: number): Parser<V[]>;
function recover<V>(parser: Parser<V>, callback: (machine: Machine) => void): Parser<V>;
function $$<V1>(p1: Parser<V1>): Parser<V1>;
function $$<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2]>;
function $$<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3]>;
function $$<V1, V3>(p1: Parser<V1>, p2: '|', p3: Parser<V3>): Parser<V1 | V3>;
function $$<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4]>;
function $$<V1, V3, V4>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | [V3, V4]>;
function $$<V1, V2, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>): Parser<[V1, V2] | V4>;
function $$<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5]>;
function $$<V1, V3, V4, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | [V3, V4, V5]>;
function $$<V1, V2, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2] | [V4, V5]>;
function $$<V1, V2, V3, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<[V1, V2, V3] | V5>;
function $$<V1, V3, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<V1 | V3 | V5>;
function $$<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6]>;
function $$<V1, V3, V4, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | [V3, V4, V5, V6]>;
function $$<V1, V2, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2] | [V4, V5, V6]>;
function $$<V1, V2, V3, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3] | [V5, V6]>;
function $$<V1, V2, V3, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<[V1, V2, V3, V4] | V6>;
function $$<V1, V3, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V3 | [V5, V6]>;
function $$<V1, V3, V4, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<V1 | [V3, V4] | V6>;
function $$<V1, V2, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<[V1, V2] | V4 | V6>;
function $$<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7]>;
function $$<V1, V3, V5, V7>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>): Parser<V1 | V3 | V5 | V7>;
function $$<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8]>;
function $$<V1, V2, V4, V5, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2] | [V4, V5] | [V7, V8]>;
function $$<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9]>;
function $$<V1, V3, V5, V7, V9>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>): Parser<V1 | V3 | V5 | V7 | V9>;
function $$<V1, V3, V5, V7, V9, V11>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>): Parser<V1 | V3 | V5 | V7 | V9 | V11>;
function $$<V1, V3, V5, V7, V9, V11, V13>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13>;
function $$<V1, V3, V5, V7, V9, V11, V13, V15>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15>;
function $$<V1, V3, V5, V7, V9, V11, V13, V15, V17>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>, p16: '|', p17: Parser<V17>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | V17>;
function $$(p1: Parser<any>, ...parsers: ('|' | Parser<any>)[]): Parser<any>;
namespace $$ {
function L<V>(p1: Parser<V>, ...parsers: Parser<any>[]): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<V>): Parser<V>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<any>, p9: Parser<V>): Parser<V>;
function M<V2>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<any>): Parser<V2>;
function M<V2, V3>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<any>): Parser<[V2, V3]>;
function M<V2, V3, V4>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<any>): Parser<[V2, V3, V4]>;
function M<V2, V3, V4, V5>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<any>): Parser<[V2, V3, V4, V5]>;
function M<V2, V3, V4, V5, V6>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>): Parser<[V2, V3, V4, V5, V6]>;
function M<V2, V3, V4, V5, V6, V7>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7]>;
function M<V2, V3, V4, V5, V6, V7, V8>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>, p8: Parser<V8>, p9: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7, V8]>;
function or<V1>(p1: Parser<V1>): Parser<V1>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<V1 | V2>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<V1 | V2 | V3>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | V2 | V3 | V4>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | V2 | V3 | V4 | V5>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V2 | V3 | V4 | V5 | V6>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9>;
function or(parser: Parser<any>, ...parsers: Parser<any>[]): Parser<any>;
}
function $0<V1>(p1: Parser<V1>): Parser<V1[]>;
function $0<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2][]>;
function $0<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3][]>;
function $0<V1, V3>(p1: Parser<V1>, p2: '|', p3: Parser<V3>): Parser<(V1 | V3)[]>;
function $0<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4][]>;
function $0<V1, V3, V4>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>): Parser<(V1 | [V3, V4])[]>;
function $0<V1, V2, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>): Parser<([V1, V2] | V4)[]>;
function $0<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5][]>;
function $0<V1, V3, V4, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<(V1 | [V3, V4, V5])[]>;
function $0<V1, V2, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>): Parser<([V1, V2] | [V4, V5])[]>;
function $0<V1, V2, V3, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<([V1, V2, V3] | V5)[]>;
function $0<V1, V3, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<(V1 | V3 | V5)[]>;
function $0<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6][]>;
function $0<V1, V3, V4, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | [V3, V4, V5, V6])[]>;
function $0<V1, V2, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<([V1, V2] | [V4, V5, V6])[]>;
function $0<V1, V2, V3, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<([V1, V2, V3] | [V5, V6])[]>;
function $0<V1, V2, V3, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<([V1, V2, V3, V4] | V6)[]>;
function $0<V1, V3, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | V3 | [V5, V6])[]>;
function $0<V1, V3, V4, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<(V1 | [V3, V4] | V6)[]>;
function $0<V1, V2, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<([V1, V2] | V4 | V6)[]>;
function $0<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7][]>;
function $0<V1, V3, V5, V7>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>): Parser<(V1 | V3 | V5 | V7)[]>;
function $0<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8][]>;
function $0<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9][]>;
function $0<V1, V3, V5, V7, V9>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>): Parser<(V1 | V3 | V5 | V7 | V9)[]>;
function $0<V1, V3, V5, V7, V9, V11>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>): Parser<(V1 | V3 | V5 | V7 | V9 | V11)[]>;
function $0<V1, V3, V5, V7, V9, V11, V13>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13)[]>;
function $0<V1, V3, V5, V7, V9, V11, V13, V15>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15)[]>;
function $0<V1, V3, V5, V7, V9, V11, V13, V15, V17>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>, p16: '|', p17: Parser<V17>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | V17)[]>;
function $0(parser: Parser<any>, ...parsers: ('|' | Parser<any>)[]): Parser<any[][]>;
namespace $0 {
function L<V>(p1: Parser<V>, ...parsers: Parser<any>[]): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<any>, p9: Parser<V>): Parser<V[]>;
function M<V2>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<any>): Parser<V2[]>;
function M<V2, V3>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<any>): Parser<[V2, V3][]>;
function M<V2, V3, V4>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<any>): Parser<[V2, V3, V4][]>;
function M<V2, V3, V4, V5>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<any>): Parser<[V2, V3, V4, V5][]>;
function M<V2, V3, V4, V5, V6>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>): Parser<[V2, V3, V4, V5, V6][]>;
function M<V2, V3, V4, V5, V6, V7>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7][]>;
function M<V2, V3, V4, V5, V6, V7, V8>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>, p8: Parser<V8>, p9: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7, V8][]>;
function or<V1>(p1: Parser<V1>): Parser<V1[]>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<(V1 | V2)[]>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<(V1 | V2 | V3)[]>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<(V1 | V2 | V3 | V4)[]>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<(V1 | V2 | V3 | V4 | V5)[]>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | V2 | V3 | V4 | V5 | V6)[]>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7)[]>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8)[]>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9)[]>;
function or(parser: Parser<any>, ...parsers: Parser<any>[]): Parser<any>;
}
function $1<V1>(p1: Parser<V1>): Parser<V1[]>;
function $1<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2][]>;
function $1<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3][]>;
function $1<V1, V3>(p1: Parser<V1>, p2: '|', p3: Parser<V3>): Parser<(V1 | V3)[]>;
function $1<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4][]>;
function $1<V1, V3, V4>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>): Parser<(V1 | [V3, V4])[]>;
function $1<V1, V2, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>): Parser<([V1, V2] | V4)[]>;
function $1<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5][]>;
function $1<V1, V3, V4, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<(V1 | [V3, V4, V5])[]>;
function $1<V1, V2, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>): Parser<([V1, V2] | [V4, V5])[]>;
function $1<V1, V2, V3, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<([V1, V2, V3] | V5)[]>;
function $1<V1, V3, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<(V1 | V3 | V5)[]>;
function $1<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6][]>;
function $1<V1, V3, V4, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | [V3, V4, V5, V6])[]>;
function $1<V1, V2, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<([V1, V2] | [V4, V5, V6])[]>;
function $1<V1, V2, V3, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<([V1, V2, V3] | [V5, V6])[]>;
function $1<V1, V2, V3, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<([V1, V2, V3, V4] | V6)[]>;
function $1<V1, V3, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | V3 | [V5, V6])[]>;
function $1<V1, V3, V4, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<(V1 | [V3, V4] | V6)[]>;
function $1<V1, V2, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<([V1, V2] | V4 | V6)[]>;
function $1<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7][]>;
function $1<V1, V3, V5, V7>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>): Parser<(V1 | V3 | V5 | V7)[]>;
function $1<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8][]>;
function $1<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9][]>;
function $1<V1, V3, V5, V7, V9>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>): Parser<(V1 | V3 | V5 | V7 | V9)[]>;
function $1<V1, V3, V5, V7, V9, V11>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>): Parser<(V1 | V3 | V5 | V7 | V9 | V11)[]>;
function $1<V1, V3, V5, V7, V9, V11, V13>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13)[]>;
function $1<V1, V3, V5, V7, V9, V11, V13, V15>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15)[]>;
function $1<V1, V3, V5, V7, V9, V11, V13, V15, V17>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>, p16: '|', p17: Parser<V17>): Parser<(V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | V17)[]>;
function $1(parser: Parser<any>, ...parsers: ('|' | Parser<any>)[]): Parser<any[][]>;
namespace $1 {
function L<V>(p1: Parser<V>, ...parsers: Parser<any>[]): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<V>): Parser<V[]>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<any>, p9: Parser<V>): Parser<V[]>;
function M<V2>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<any>): Parser<V2[]>;
function M<V2, V3>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<any>): Parser<[V2, V3][]>;
function M<V2, V3, V4>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<any>): Parser<[V2, V3, V4][]>;
function M<V2, V3, V4, V5>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<any>): Parser<[V2, V3, V4, V5][]>;
function M<V2, V3, V4, V5, V6>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>): Parser<[V2, V3, V4, V5, V6][]>;
function M<V2, V3, V4, V5, V6, V7>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7][]>;
function M<V2, V3, V4, V5, V6, V7, V8>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>, p8: Parser<V8>, p9: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7, V8][]>;
function or<V1>(p1: Parser<V1>): Parser<V1[]>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<(V1 | V2)[]>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<(V1 | V2 | V3)[]>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<(V1 | V2 | V3 | V4)[]>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<(V1 | V2 | V3 | V4 | V5)[]>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<(V1 | V2 | V3 | V4 | V5 | V6)[]>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7)[]>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8)[]>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<(V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9)[]>;
function or(parser: Parser<any>, ...parsers: Parser<any>[]): Parser<any>;
}
function $_<V1>(p1: Parser<V1>): Parser<V1 | null>;
function $_<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<[V1, V2] | null>;
function $_<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<[V1, V2, V3] | null>;
function $_<V1, V3>(p1: Parser<V1>, p2: '|', p3: Parser<V3>): Parser<V1 | V3 | null>;
function $_<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<[V1, V2, V3, V4] | null>;
function $_<V1, V3, V4>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | [V3, V4] | null>;
function $_<V1, V2, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>): Parser<[V1, V2] | V4 | null>;
function $_<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2, V3, V4, V5] | null>;
function $_<V1, V3, V4, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | [V3, V4, V5] | null>;
function $_<V1, V2, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>): Parser<[V1, V2] | [V4, V5] | null>;
function $_<V1, V2, V3, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<[V1, V2, V3] | V5 | null>;
function $_<V1, V3, V5>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>): Parser<V1 | V3 | V5 | null>;
function $_<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3, V4, V5, V6] | null>;
function $_<V1, V3, V4, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | [V3, V4, V5, V6] | null>;
function $_<V1, V2, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2] | [V4, V5, V6] | null>;
function $_<V1, V2, V3, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<[V1, V2, V3] | [V5, V6] | null>;
function $_<V1, V2, V3, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<[V1, V2, V3, V4] | V6 | null>;
function $_<V1, V3, V5, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V3 | [V5, V6] | null>;
function $_<V1, V3, V4, V6>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<V1 | [V3, V4] | V6 | null>;
function $_<V1, V2, V4, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: '|', p4: Parser<V4>, p5: '|', p6: Parser<V6>): Parser<[V1, V2] | V4 | V6 | null>;
function $_<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<[V1, V2, V3, V4, V5, V6, V7] | null>;
function $_<V1, V3, V5, V7>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>): Parser<V1 | V3 | V5 | V7 | null>;
function $_<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8] | null>;
function $_<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<[V1, V2, V3, V4, V5, V6, V7, V8, V9] | null>;
function $_<V1, V3, V5, V7, V9>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>): Parser<V1 | V3 | V5 | V7 | V9 | null>;
function $_<V1, V3, V5, V7, V9, V11>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | null>;
function $_<V1, V3, V5, V7, V9, V11, V13>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | null>;
function $_<V1, V3, V5, V7, V9, V11, V13, V15>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | null>;
function $_<V1, V3, V5, V7, V9, V11, V13, V15, V17>(p1: Parser<V1>, p2: '|', p3: Parser<V3>, p4: '|', p5: Parser<V5>, p6: '|', p7: Parser<V7>, p8: '|', p9: Parser<V9>, p10: '|', p11: Parser<V11>, p12: '|', p13: Parser<V13>, p14: '|', p15: Parser<V15>, p16: '|', p17: Parser<V17>): Parser<V1 | V3 | V5 | V7 | V9 | V11 | V13 | V15 | V17 | null>;
namespace $_ {
function L<V>(p1: Parser<V>, ...parsers: Parser<any>[]): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<V>): Parser<V | null>;
function R<V>(p1: Parser<any>, p2: Parser<any>, p3: Parser<any>, p4: Parser<any>, p5: Parser<any>, p6: Parser<any>, p7: Parser<any>, p8: Parser<any>, p9: Parser<V>): Parser<V | null>;
function M<V2>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<any>): Parser<V2 | null>;
function M<V2, V3>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<any>): Parser<[V2, V3] | null>;
function M<V2, V3, V4>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<any>): Parser<[V2, V3, V4] | null>;
function M<V2, V3, V4, V5>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<any>): Parser<[V2, V3, V4, V5] | null>;
function M<V2, V3, V4, V5, V6>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>): Parser<[V2, V3, V4, V5, V6] | null>;
function M<V2, V3, V4, V5, V6, V7>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7] | null>;
function M<V2, V3, V4, V5, V6, V7, V8>(p1: Parser<any>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<any>, p8: Parser<V8>, p9: Parser<any>): Parser<[V2, V3, V4, V5, V6, V7, V8] | null>;
function or<V1>(p1: Parser<V1>): Parser<V1 | null>;
function or<V1, V2>(p1: Parser<V1>, p2: Parser<V2>): Parser<V1 | V2 | null>;
function or<V1, V2, V3>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>): Parser<V1 | V2 | V3 | null>;
function or<V1, V2, V3, V4>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>): Parser<V1 | V2 | V3 | V4 | null>;
function or<V1, V2, V3, V4, V5>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>): Parser<V1 | V2 | V3 | V4 | V5 | null>;
function or<V1, V2, V3, V4, V5, V6>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | null>;
function or<V1, V2, V3, V4, V5, V6, V7>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | null>;
function or<V1, V2, V3, V4, V5, V6, V7, V8>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | null>;
function or<V1, V2, V3, V4, V5, V6, V7, V8, V9>(p1: Parser<V1>, p2: Parser<V2>, p3: Parser<V3>, p4: Parser<V4>, p5: Parser<V5>, p6: Parser<V6>, p7: Parser<V7>, p8: Parser<V8>, p9: Parser<V9>): Parser<V1 | V2 | V3 | V4 | V5 | V6 | V7 | V8 | V9 | null>;
function or(parser: Parser<any>, ...parsers: Parser<any>[]): Parser<any>;
}
function $<V>(box: ParserBox<V>, ...args: any[]): Parser<V>;
namespace $ {
function always(): Parser<undefined>;
function always<V>(value: V): Parser<V>;
function never<V>(message_?: string): Parser<V>;
function start<V>(parser: Parser<V>): Parser<V>;
function end(): Parser<null>;
function not<V>(parser: Parser<V>): Parser<null>;
function repeat<V, S>(valueParser: Parser<V>, sepalatorParser: Parser<S>, options: {
allowTrailingSeparator: boolean;
}): Parser<V[]>;
function alternate<V, C>(valueParser: Parser<V>, combinorParser: Parser<C>): Parser<(V | C)[]>;
function any(syntax: string): Parser<Token>;
function comment(): Parser<Comment[]>;
function string(syntax: string, string: string): Parser<Token>;
function regex(syntax: string, pattern: string | RegExp, index?: number): Parser<Token>;
function token(pattern: TokenPattern | TokenPattern[]): Parser<Token>;
function annex(pattern: TokenPattern | TokenPattern[]): Parser<Token>;
function indentUp<V>(parser: Parser<V>): Parser<V | null>;
function indent(): Parser<Indent>;
function eol(): Parser<Comment[]>;
function tap<T>(object: T, callback: (object: T) => void): T;
function node<N extends Node>(scaned: Node | (Node | null)[] | any, syntax: string, properties: {}): N;
}
}
declare namespace spellu {
type ScanOptions = {
modules?: Module[];
startPosition?: number;
wholeMatch?: boolean;
};
function scan<V>(ruleOrParser: string | Parser<V>, source: Source, options?: ScanOptions): Success<V> | Failure<Diagnosis[]>;
type ScanOptions = {
boards?: Board[];
startPosition?: number;
wholeMatch?: boolean;
};
function source(string: string, location?: string): Source;
function scan<V>(ruleOrParser: string | Parser<V>, source: Source, options?: ScanOptions): Success<V> | Failure<Diagnosis[]>;
}
declare namespace spellu {
function build<V>(ruleOrParser: string | Parser<V>, source: Source, options?: ScanOptions): V | null;
function build<V>(ruleOrParser: string | Parser<V>, source: Source, options?: ScanOptions): V | null;
}
declare namespace spellu {
type TraceOptions = {
state?: any;
startPosition?: number;
color?: boolean;
};
class TraceResult {
lines: string[];
toString(): string;
}
function trace<V>(parser: Parser<V>, source: Source, options_?: TraceOptions): TraceResult;
type TraceOptions = ScanOptions & {
state?: any;
color?: boolean;
};
class TraceResult {
lines: string[];
toString(): string;
}
function trace<V>(ruleOrParser: string | Parser<V>, source: Source, options_?: TraceOptions): TraceResult;
}
declare namespace spellu {
function flatten(cluster: Token | Token[]): Token[];
}
export default spellu;
export declare const $: typeof spellu.$;
spellu-engine.mjs

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc