ts-fusion-parser/out/dsl/eel/parser.d.ts

Parser for Neos Fusion Files

import { AbstractNode } from "../../common/AbstractNode";
import { Lexer } from "./lexer";
import { LiteralArrayNode } from "./nodes/LiteralArrayNode";
import { LiteralObjectNode } from "./nodes/LiteralObjectNode";
import { LiteralStringNode } from "./nodes/LiteralStringNode";
import { ObjectFunctionPathNode } from "./nodes/ObjectFunctionPathNode";
import { ObjectNode } from "./nodes/ObjectNode";
import { ObjectOffsetAccessPathNode } from "./nodes/ObjectOffsetAccessPathNode";
import { ObjectPathNode } from "./nodes/ObjectPathNode";
import { OperationNode } from "./nodes/OperationNode";
import { TernaryOperationNode } from "./nodes/TernaryOperationNode";
import { NodePositionInterface } from "../../common/NodePositionInterface";
import { ParserHandoverResult, ParserInterface } from "../parserInterface";
export interface EelParserOptions {
    allowIncompleteObjectPaths: boolean;
    logDebug?: boolean;
}
export declare class Parser implements ParserInterface {
    protected lexer: Lexer;
    nodesByType: Map<typeof AbstractNode, AbstractNode[]>;
    positionOffset: number;
    protected options: EelParserOptions;
    constructor(lexer: Lexer, positionOffset?: number, options?: EelParserOptions);
    setPositionOffset(positionOffset: number): void;
    protected applyOffset(position: NodePositionInterface): NodePositionInterface;
    protected beginPosition(): NodePositionInterface;
    protected endPosition(position: NodePositionInterface): NodePositionInterface;
    parse(checkForEmptyEel?: boolean): any;
    protected parseExpression(parent?: AbstractNode | undefined): any;
    protected parseOperationIfPossible(object: AbstractNode): OperationNode | TernaryOperationNode | null;
    protected parseTernaryOperation(object: AbstractNode): TernaryOperationNode;
    protected parseString(parent?: AbstractNode | undefined): LiteralStringNode;
    protected parseObjectExpression(parent?: AbstractNode | undefined): ObjectNode;
    protected parseObjectExpressionPart(parent: AbstractNode | undefined): ObjectPathNode;
    protected parseObjectFunctionExpressionPart(parent?: AbstractNode | undefined): ObjectFunctionPathNode;
    protected parseObjectPath(parent?: ObjectNode | LiteralObjectNode): ObjectPathNode;
    protected parseObjectOffsetExpression(): ObjectOffsetAccessPathNode | undefined;
    protected parseObjectLiteral(parent?: AbstractNode | undefined): LiteralObjectNode;
    protected parseObjectLiteralEntryKey(): LiteralStringNode | ObjectPathNode;
    protected parseArrayLiteral(parent?: AbstractNode | undefined): LiteralArrayNode;
    protected parseLazyWhitespace(): void;
    handover<T extends AbstractNode>(parser: ParserInterface): T | Array<T>;
    receiveHandover<T extends AbstractNode>(text: string, offset: number): ParserHandoverResult<T>;
    logRemaining(cap?: number | undefined): void;
    protected addNodeToNodesByType<T extends AbstractNode>(node: T): T;
    protected flushNodesByType(): Map<typeof AbstractNode, AbstractNode[]>;
}