xast/build/Parser.d.ts

AST parsing library

import { Location } from './Location';
import { Token } from './Token';
import { Lexer } from './Lexer';
import { TokenKind } from './TokenKind';
import { SchemaNode } from './parsers/schema';
export interface Node {
    readonly kind: string;
    readonly loc?: Location;
}
export interface ParseOptions {
    enableLocation?: boolean | undefined;
    maxTokens?: number | undefined;
}
export interface Trigger {
    readonly kind: TokenKind;
    readonly keyword?: string;
}
export interface NodeParser<N extends Node> {
    readonly kind: N['kind'];
    readonly trigger?: Trigger;
    parse(parser: Parser): N | undefined;
    [key: string]: unknown;
}
type NodeParserResult<P extends NodeParser<Node>> = ReturnType<P["parse"]>;
type MustNodeParserResult<P extends NodeParser<Node>> = NonNullable<NodeParserResult<P>>;
export declare class Parser {
    lexer: Lexer;
    protected _options: ParseOptions;
    protected _tokenCounter: number;
    protected _parsersMap: Map<TokenKind, Map<string | symbol, NodeParser<any>[]>>;
    constructor(lexer: Lexer, options?: ParseOptions);
    parseSchema(): SchemaNode;
    add<N extends Node>(nodeParser: NodeParser<N>): void;
    parseToken(token: Token): Node | undefined;
    optionalParse<P extends NodeParser<any>>(nodeParser: P): NodeParserResult<P>;
    expectParse<P extends NodeParser<any>>(nodeParser: P): MustNodeParserResult<P>;
    node<T extends {
        loc?: Location | undefined;
    }>(startToken: Token, node: T): T;
    peek(kind: TokenKind): boolean;
    expectToken(kind: TokenKind): Token;
    expectOptionalToken(kind: TokenKind): boolean;
    expectKeyword(value: string): void;
    expectOptionalKeyword(value: string): boolean;
    unexpected(atToken?: Token | null | undefined): Error;
    any<P extends NodeParser<any>>(openKind: TokenKind, nodeParser: P, closeKind: TokenKind): MustNodeParserResult<P>[];
    many<P extends NodeParser<N>, N extends Node>(openKind: TokenKind, nodeParser: P, closeKind: TokenKind): MustNodeParserResult<P>[];
    optionalMany<P extends NodeParser<N>, N extends Node>(openKind: TokenKind, nodeParser: P, closeKind: TokenKind): MustNodeParserResult<P>[];
    delimitedMany<P extends NodeParser<N>, N extends Node>(delimiterKind: TokenKind, nodeParser: P): MustNodeParserResult<P>[];
    advanceLexer(): void;
}
export {};