@html-eslint/template-syntax-parser/types/parser.d.ts

Parse template syntax

export = Parser;
declare class Parser {
    /**
     * @param {string} code
     * @param {[string, string][]} syntaxPairs
     * @param {Range[]} skipRanges
     */
    constructor(code: string, syntaxPairs: [string, string][], skipRanges: Range[]);
    /**
     * @type {string}
     */
    code: string;
    /**
     * @type {[string, string][]}
     */
    syntaxPairs: [string, string][];
    /**
     * @type {Range[]}
     */
    skipRanges: Range[];
    /**
     * @type {OpenSyntax[]}
     */
    syntaxStack: OpenSyntax[];
    /**
     * @type {TemplateSyntax[]}
     */
    result: TemplateSyntax[];
    /**
     * @private
     * @param {number} index
     * @returns {Range | undefined}
     */
    private findSkipRange;
    /**
     * @param {string} syntax
     * @param {number} position
     * @returns {number}
     */
    indexOf(syntax: string, position: number): number;
    /**
     * @param {number} position
     * @returns {OpenSyntax | null}
     */
    findOpenSyntax(position: number): OpenSyntax | null;
    /**
     * @param {number} position
     * @returns {CloseSyntax | null}
     */
    findCloseSyntax(position: number): CloseSyntax | null;
    /**
     * @returns {OpenSyntax[]}
     */
    findAllOpenSyntax(): OpenSyntax[];
    /**
     * @returns {CloseSyntax[]}
     */
    findAllCloseSyntax(): CloseSyntax[];
    /**
     * @returns {(CloseSyntax | OpenSyntax)[]}
     */
    findAllSyntax(): (CloseSyntax | OpenSyntax)[];
    /**
     * @param {OpenSyntax} open
     * @returns {string}
     */
    getPossibleCloseValueOf(open: OpenSyntax): string;
    /**
     * @param {CloseSyntax | OpenSyntax} syntax
     */
    eatSyntax(syntax: CloseSyntax | OpenSyntax): void;
    /**
     * @returns {TemplateSyntaxParserResult}
     */
    parse(): TemplateSyntaxParserResult;
}
declare namespace Parser {
    export { Range, TemplateSyntax, OpenSyntax, CloseSyntax, TemplateSyntaxParserResult };
}
type Range = import("eslint").AST.Range;
type TemplateSyntax = import("./types").TemplateSyntax;
type OpenSyntax = import("./types").OpenSyntax;
type CloseSyntax = import("./types").CloseSyntax;
type TemplateSyntaxParserResult = import("./types").TemplateSyntaxParserResult;
//# sourceMappingURL=parser.d.ts.map