@opra/client 0.11.1 → 0.11.2

package/typings/antlr4ts/tree/TerminalNode.d.ts

@@ -1,27 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { Interval } from "../misc/Interval";
-import { Parser } from "../Parser";
-import { ParseTree } from "./ParseTree";
-import { ParseTreeVisitor } from "./ParseTreeVisitor";
-import { RuleContext } from "../RuleContext";
-import { RuleNode } from "./RuleNode";
-import { Token } from "../Token";
-export declare class TerminalNode implements ParseTree {
-    _symbol: Token;
-    _parent: RuleNode | undefined;
-    constructor(symbol: Token);
-    getChild(i: number): never;
-    get symbol(): Token;
-    get parent(): RuleNode | undefined;
-    setParent(parent: RuleContext): void;
-    get payload(): Token;
-    get sourceInterval(): Interval;
-    get childCount(): number;
-    accept<T>(visitor: ParseTreeVisitor<T>): T;
-    get text(): string;
-    toStringTree(parser?: Parser): string;
-    toString(): string;
-}

package/typings/antlr4ts/tree/Tree.d.ts

@@ -1,36 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-/** The basic notion of a tree has a parent, a payload, and a list of children.
- *  It is the most abstract interface for all the trees used by ANTLR.
- */
-export interface Tree {
-    /** The parent of this node. If the return value is `undefined`, then this
-     *  node is the root of the tree.
-     */
-    readonly parent: Tree | undefined;
-    /**
-     * This method returns whatever object represents the data at this node. For
-     * example, for parse trees, the payload can be a {@link Token} representing
-     * a leaf node or a {@link RuleContext} object representing a rule
-     * invocation. For abstract syntax trees (ASTs), this is a {@link Token}
-     * object.
-     */
-    readonly payload: {
-        text?: string;
-    };
-    /**
-     * If there are children, get the `i`th value indexed from 0. Throws a `RangeError` if `i` is less than zero, or
-     * greater than or equal to `childCount`.
-     */
-    getChild(i: number): Tree;
-    /** How many children are there? If there is none, then this
-     *  node represents a leaf node.
-     */
-    readonly childCount: number;
-    /** Print out a whole tree, not just a node, in LISP format
-     *  `(root child1 .. childN)`. Print just a node if this is a leaf.
-     */
-    toStringTree(): string;
-}

package/typings/antlr4ts/tree/Trees.d.ts

@@ -1,75 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { Parser } from "../Parser";
-import { ParserRuleContext } from "../ParserRuleContext";
-import { ParseTree } from "./ParseTree";
-import { Tree } from "./Tree";
-/** A set of utility routines useful for all kinds of ANTLR trees. */
-export declare class Trees {
-    /** Print out a whole tree in LISP form. {@link #getNodeText} is used on the
-     *  node payloads to get the text for the nodes.  Detect
-     *  parse trees and extract data appropriately.
-     */
-    static toStringTree(/*@NotNull*/ t: Tree): string;
-    /** Print out a whole tree in LISP form. {@link #getNodeText} is used on the
-     *  node payloads to get the text for the nodes.  Detect
-     *  parse trees and extract data appropriately.
-     */
-    static toStringTree(/*@NotNull*/ t: Tree, recog: Parser | undefined): string;
-    /** Print out a whole tree in LISP form. {@link #getNodeText} is used on the
-     *  node payloads to get the text for the nodes.
-     */
-    static toStringTree(/*@NotNull*/ t: Tree, /*@Nullable*/ ruleNames: string[] | undefined): string;
-    static toStringTree(/*@NotNull*/ t: Tree, arg2?: Parser | string[]): string;
-    static getNodeText(/*@NotNull*/ t: Tree, recog: Parser | undefined): string;
-    static getNodeText(/*@NotNull*/ t: Tree, ruleNames: string[] | undefined): string;
-    /** Return ordered list of all children of this node */
-    static getChildren(t: ParseTree): ParseTree[];
-    static getChildren(t: Tree): Tree[];
-    /** Return a list of all ancestors of this node.  The first node of
-     *  list is the root and the last is the parent of this node.
-     *
-     *  @since 4.5.1
-     */
-    static getAncestors(t: ParseTree): ParseTree[];
-    static getAncestors(t: Tree): Tree[];
-    /** Return true if t is u's parent or a node on path to root from u.
-     *  Use === not equals().
-     *
-     *  @since 4.5.1
-     */
-    static isAncestorOf(t: Tree, u: Tree): boolean;
-    static findAllTokenNodes(t: ParseTree, ttype: number): ParseTree[];
-    static findAllRuleNodes(t: ParseTree, ruleIndex: number): ParseTree[];
-    static findAllNodes(t: ParseTree, index: number, findTokens: boolean): ParseTree[];
-    static _findAllNodes(t: ParseTree, index: number, findTokens: boolean, nodes: ParseTree[]): void;
-    /** Get all descendents; includes t itself.
-     *
-     * @since 4.5.1
-     */
-    static getDescendants(t: ParseTree): ParseTree[];
-    /** Find smallest subtree of t enclosing range startTokenIndex..stopTokenIndex
-     *  inclusively using postorder traversal.  Recursive depth-first-search.
-     *
-     *  @since 4.5
-     */
-    static getRootOfSubtreeEnclosingRegion(t: ParseTree, startTokenIndex: number, // inclusive
-    stopTokenIndex: number): ParserRuleContext | undefined;
-    /** Replace any subtree siblings of root that are completely to left
-     *  or right of lookahead range with a CommonToken(Token.INVALID_TYPE,"...")
-     *  node. The source interval for t is not altered to suit smaller range!
-     *
-     *  WARNING: destructive to t.
-     *
-     *  @since 4.5.1
-     */
-    static stripChildrenOutOfRange(t: ParserRuleContext, root: ParserRuleContext, startIndex: number, stopIndex: number): void;
-    /** Return first node satisfying the pred
-     *
-     *  @since 4.5.1
-     */
-    static findNodeSuchThat(t: ParseTree, pred: (tree: ParseTree) => boolean): ParseTree | undefined;
-    static findNodeSuchThat(t: Tree, pred: (tree: Tree) => boolean): Tree | undefined;
-}

package/typings/antlr4ts/tree/index.d.ts

@@ -1,16 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-export * from "./AbstractParseTreeVisitor";
-export * from "./ErrorNode";
-export * from "./ParseTree";
-export * from "./ParseTreeListener";
-export * from "./ParseTreeProperty";
-export * from "./ParseTreeVisitor";
-export * from "./ParseTreeWalker";
-export * from "./RuleNode";
-export * from "./SyntaxTree";
-export * from "./TerminalNode";
-export * from "./Tree";
-export * from "./Trees";

package/typings/antlr4ts/tree/pattern/Chunk.d.ts

@@ -1,17 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-/**
- * A chunk is either a token tag, a rule tag, or a span of literal text within a
- * tree pattern.
- *
- * The method {@link ParseTreePatternMatcher#split(String)} returns a list of
- * chunks in preparation for creating a token stream by
- * {@link ParseTreePatternMatcher#tokenize(String)}. From there, we get a parse
- * tree from with {@link ParseTreePatternMatcher#compile(String, int)}. These
- * chunks are converted to {@link RuleTagToken}, {@link TokenTagToken}, or the
- * regular tokens of the text surrounding the tags.
- */
-export declare abstract class Chunk {
-}

package/typings/antlr4ts/tree/pattern/ParseTreeMatch.d.ts

@@ -1,124 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { MultiMap } from "../../misc/MultiMap";
-import { ParseTree } from "../ParseTree";
-import { ParseTreePattern } from "./ParseTreePattern";
-/**
- * Represents the result of matching a {@link ParseTree} against a tree pattern.
- */
-export declare class ParseTreeMatch {
-    /**
-     * This is the backing field for `tree`.
-     */
-    private _tree;
-    /**
-     * This is the backing field for `pattern`.
-     */
-    private _pattern;
-    /**
-     * This is the backing field for `labels`.
-     */
-    private _labels;
-    /**
-     * This is the backing field for `mismatchedNode`.
-     */
-    private _mismatchedNode?;
-    /**
-     * Constructs a new instance of {@link ParseTreeMatch} from the specified
-     * parse tree and pattern.
-     *
-     * @param tree The parse tree to match against the pattern.
-     * @param pattern The parse tree pattern.
-     * @param labels A mapping from label names to collections of
-     * {@link ParseTree} objects located by the tree pattern matching process.
-     * @param mismatchedNode The first node which failed to match the tree
-     * pattern during the matching process.
-     *
-     * @throws {@link Error} if `tree` is not defined
-     * @throws {@link Error} if `pattern` is not defined
-     * @throws {@link Error} if `labels` is not defined
-     */
-    constructor(tree: ParseTree, pattern: ParseTreePattern, labels: MultiMap<string, ParseTree>, mismatchedNode: ParseTree | undefined);
-    /**
-     * Get the last node associated with a specific `label`.
-     *
-     * For example, for pattern `<id:ID>`, `get("id")` returns the
-     * node matched for that `ID`. If more than one node
-     * matched the specified label, only the last is returned. If there is
-     * no node associated with the label, this returns `undefined`.
-     *
-     * Pattern tags like `<ID>` and `<expr>` without labels are
-     * considered to be labeled with `ID` and `expr`, respectively.
-     *
-     * @param label The label to check.
-     *
-     * @returns The last {@link ParseTree} to match a tag with the specified
-     * label, or `undefined` if no parse tree matched a tag with the label.
-     */
-    get(label: string): ParseTree | undefined;
-    /**
-     * Return all nodes matching a rule or token tag with the specified label.
-     *
-     * If the `label` is the name of a parser rule or token in the
-     * grammar, the resulting list will contain both the parse trees matching
-     * rule or tags explicitly labeled with the label and the complete set of
-     * parse trees matching the labeled and unlabeled tags in the pattern for
-     * the parser rule or token. For example, if `label` is `"foo"`,
-     * the result will contain *all* of the following.
-     *
-     * * Parse tree nodes matching tags of the form `<foo:anyRuleName>` and
-     *   `<foo:AnyTokenName>`.
-     * * Parse tree nodes matching tags of the form `<anyLabel:foo>`.
-     * * Parse tree nodes matching tags of the form `<foo>`.
-     *
-     * @param label The label.
-     *
-     * @returns A collection of all {@link ParseTree} nodes matching tags with
-     * the specified `label`. If no nodes matched the label, an empty list
-     * is returned.
-     */
-    getAll(label: string): ParseTree[];
-    /**
-     * Return a mapping from label &rarr; [list of nodes].
-     *
-     * The map includes special entries corresponding to the names of rules and
-     * tokens referenced in tags in the original pattern. For additional
-     * information, see the description of {@link #getAll(String)}.
-     *
-     * @returns A mapping from labels to parse tree nodes. If the parse tree
-     * pattern did not contain any rule or token tags, this map will be empty.
-     */
-    get labels(): MultiMap<string, ParseTree>;
-    /**
-     * Get the node at which we first detected a mismatch.
-     *
-     * @returns the node at which we first detected a mismatch, or `undefined`
-     * if the match was successful.
-     */
-    get mismatchedNode(): ParseTree | undefined;
-    /**
-     * Gets a value indicating whether the match operation succeeded.
-     *
-     * @returns `true` if the match operation succeeded; otherwise,
-     * `false`.
-     */
-    get succeeded(): boolean;
-    /**
-     * Get the tree pattern we are matching against.
-     *
-     * @returns The tree pattern we are matching against.
-     */
-    get pattern(): ParseTreePattern;
-    /**
-     * Get the parse tree we are trying to match to a pattern.
-     *
-     * @returns The {@link ParseTree} we are trying to match to a pattern.
-     */
-    get tree(): ParseTree;
-    /**
-     * {@inheritDoc}
-     */
-    toString(): string;
-}

package/typings/antlr4ts/tree/pattern/ParseTreePattern.d.ts

@@ -1,98 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { ParseTree } from "../ParseTree";
-import { ParseTreeMatch } from "./ParseTreeMatch";
-import { ParseTreePatternMatcher } from "./ParseTreePatternMatcher";
-/**
- * A pattern like `<ID> = <expr>;` converted to a {@link ParseTree} by
- * {@link ParseTreePatternMatcher#compile(String, int)}.
- */
-export declare class ParseTreePattern {
-    /**
-     * This is the backing field for `patternRuleIndex`.
-     */
-    private _patternRuleIndex;
-    /**
-     * This is the backing field for `pattern`.
-     */
-    private _pattern;
-    /**
-     * This is the backing field for `patternTree`.
-     */
-    private _patternTree;
-    /**
-     * This is the backing field for `matcher`.
-     */
-    private _matcher;
-    /**
-     * Construct a new instance of the {@link ParseTreePattern} class.
-     *
-     * @param matcher The {@link ParseTreePatternMatcher} which created this
-     * tree pattern.
-     * @param pattern The tree pattern in concrete syntax form.
-     * @param patternRuleIndex The parser rule which serves as the root of the
-     * tree pattern.
-     * @param patternTree The tree pattern in {@link ParseTree} form.
-     */
-    constructor(matcher: ParseTreePatternMatcher, pattern: string, patternRuleIndex: number, patternTree: ParseTree);
-    /**
-     * Match a specific parse tree against this tree pattern.
-     *
-     * @param tree The parse tree to match against this tree pattern.
-     * @returns A {@link ParseTreeMatch} object describing the result of the
-     * match operation. The `ParseTreeMatch.succeeded` method can be
-     * used to determine whether or not the match was successful.
-     */
-    match(tree: ParseTree): ParseTreeMatch;
-    /**
-     * Determine whether or not a parse tree matches this tree pattern.
-     *
-     * @param tree The parse tree to match against this tree pattern.
-     * @returns `true` if `tree` is a match for the current tree
-     * pattern; otherwise, `false`.
-     */
-    matches(tree: ParseTree): boolean;
-    /**
-     * Find all nodes using XPath and then try to match those subtrees against
-     * this tree pattern.
-     *
-     * @param tree The {@link ParseTree} to match against this pattern.
-     * @param xpath An expression matching the nodes
-     *
-     * @returns A collection of {@link ParseTreeMatch} objects describing the
-     * successful matches. Unsuccessful matches are omitted from the result,
-     * regardless of the reason for the failure.
-     */
-    findAll(tree: ParseTree, xpath: string): ParseTreeMatch[];
-    /**
-     * Get the {@link ParseTreePatternMatcher} which created this tree pattern.
-     *
-     * @returns The {@link ParseTreePatternMatcher} which created this tree
-     * pattern.
-     */
-    get matcher(): ParseTreePatternMatcher;
-    /**
-     * Get the tree pattern in concrete syntax form.
-     *
-     * @returns The tree pattern in concrete syntax form.
-     */
-    get pattern(): string;
-    /**
-     * Get the parser rule which serves as the outermost rule for the tree
-     * pattern.
-     *
-     * @returns The parser rule which serves as the outermost rule for the tree
-     * pattern.
-     */
-    get patternRuleIndex(): number;
-    /**
-     * Get the tree pattern as a {@link ParseTree}. The rule and token tags from
-     * the pattern are present in the parse tree as terminal nodes with a symbol
-     * of type {@link RuleTagToken} or {@link TokenTagToken}.
-     *
-     * @returns The tree pattern as a {@link ParseTree}.
-     */
-    get patternTree(): ParseTree;
-}

package/typings/antlr4ts/tree/pattern/ParseTreePatternMatcher.d.ts

@@ -1,166 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { Chunk } from "./Chunk";
-import { Lexer } from "../../Lexer";
-import { MultiMap } from "../../misc/MultiMap";
-import { Parser } from "../../Parser";
-import { ParseTree } from "../ParseTree";
-import { ParseTreeMatch } from "./ParseTreeMatch";
-import { ParseTreePattern } from "./ParseTreePattern";
-import { RuleTagToken } from "./RuleTagToken";
-import { Token } from "../../Token";
-/**
- * A tree pattern matching mechanism for ANTLR {@link ParseTree}s.
- *
- * Patterns are strings of source input text with special tags representing
- * token or rule references such as:
- *
- * ```
- * <ID> = <expr>;
- * ```
- *
- * Given a pattern start rule such as `statement`, this object constructs
- * a {@link ParseTree} with placeholders for the `ID` and `expr`
- * subtree. Then the {@link #match} routines can compare an actual
- * {@link ParseTree} from a parse with this pattern. Tag `<ID>` matches
- * any `ID` token and tag `<expr>` references the result of the
- * `expr` rule (generally an instance of `ExprContext`.
- *
- * Pattern `x = 0;` is a similar pattern that matches the same pattern
- * except that it requires the identifier to be `x` and the expression to
- * be `0`.
- *
- * The {@link #matches} routines return `true` or `false` based
- * upon a match for the tree rooted at the parameter sent in. The
- * {@link #match} routines return a {@link ParseTreeMatch} object that
- * contains the parse tree, the parse tree pattern, and a map from tag name to
- * matched nodes (more below). A subtree that fails to match, returns with
- * {@link ParseTreeMatch#mismatchedNode} set to the first tree node that did not
- * match.
- *
- * For efficiency, you can compile a tree pattern in string form to a
- * {@link ParseTreePattern} object.
- *
- * See `TestParseTreeMatcher` for lots of examples.
- * {@link ParseTreePattern} has two static helper methods:
- * {@link ParseTreePattern#findAll} and {@link ParseTreePattern#match} that
- * are easy to use but not super efficient because they create new
- * {@link ParseTreePatternMatcher} objects each time and have to compile the
- * pattern in string form before using it.
- *
- * The lexer and parser that you pass into the {@link ParseTreePatternMatcher}
- * constructor are used to parse the pattern in string form. The lexer converts
- * the `<ID> = <expr>;` into a sequence of four tokens (assuming lexer
- * throws out whitespace or puts it on a hidden channel). Be aware that the
- * input stream is reset for the lexer (but not the parser; a
- * {@link ParserInterpreter} is created to parse the input.). Any user-defined
- * fields you have put into the lexer might get changed when this mechanism asks
- * it to scan the pattern string.
- *
- * Normally a parser does not accept token `<expr>` as a valid
- * `expr` but, from the parser passed in, we create a special version of
- * the underlying grammar representation (an {@link ATN}) that allows imaginary
- * tokens representing rules (`<expr>`) to match entire rules. We call
- * these *bypass alternatives*.
- *
- * Delimiters are `<`} and `>`}, with `\` as the escape string
- * by default, but you can set them to whatever you want using
- * {@link #setDelimiters}. You must escape both start and stop strings
- * `\<` and `\>`.
- */
-export declare class ParseTreePatternMatcher {
-    /**
-     * This is the backing field for `lexer`.
-     */
-    private _lexer;
-    /**
-     * This is the backing field for `parser`.
-     */
-    private _parser;
-    protected start: string;
-    protected stop: string;
-    protected escape: string;
-    /**
-     * Regular expression corresponding to escape, for global replace
-     */
-    protected escapeRE: RegExp;
-    /**
-     * Constructs a {@link ParseTreePatternMatcher} or from a {@link Lexer} and
-     * {@link Parser} object. The lexer input stream is altered for tokenizing
-     * the tree patterns. The parser is used as a convenient mechanism to get
-     * the grammar name, plus token, rule names.
-     */
-    constructor(lexer: Lexer, parser: Parser);
-    /**
-     * Set the delimiters used for marking rule and token tags within concrete
-     * syntax used by the tree pattern parser.
-     *
-     * @param start The start delimiter.
-     * @param stop The stop delimiter.
-     * @param escapeLeft The escape sequence to use for escaping a start or stop delimiter.
-     *
-     * @throws {@link Error} if `start` is not defined or empty.
-     * @throws {@link Error} if `stop` is not defined or empty.
-     */
-    setDelimiters(start: string, stop: string, escapeLeft: string): void;
-    /** Does `pattern` matched as rule `patternRuleIndex` match `tree`? */
-    matches(tree: ParseTree, pattern: string, patternRuleIndex: number): boolean;
-    /** Does `pattern` matched as rule patternRuleIndex match tree? Pass in a
-     *  compiled pattern instead of a string representation of a tree pattern.
-     */
-    matches(tree: ParseTree, pattern: ParseTreePattern): boolean;
-    /**
-     * Compare `pattern` matched as rule `patternRuleIndex` against
-     * `tree` and return a {@link ParseTreeMatch} object that contains the
-     * matched elements, or the node at which the match failed.
-     */
-    match(tree: ParseTree, pattern: string, patternRuleIndex: number): ParseTreeMatch;
-    /**
-     * Compare `pattern` matched against `tree` and return a
-     * {@link ParseTreeMatch} object that contains the matched elements, or the
-     * node at which the match failed. Pass in a compiled pattern instead of a
-     * string representation of a tree pattern.
-     */
-    match(tree: ParseTree, pattern: ParseTreePattern): ParseTreeMatch;
-    /**
-     * For repeated use of a tree pattern, compile it to a
-     * {@link ParseTreePattern} using this method.
-     */
-    compile(pattern: string, patternRuleIndex: number): ParseTreePattern;
-    /**
-     * Used to convert the tree pattern string into a series of tokens. The
-     * input stream is reset.
-     */
-    get lexer(): Lexer;
-    /**
-     * Used to collect to the grammar file name, token names, rule names for
-     * used to parse the pattern into a parse tree.
-     */
-    get parser(): Parser;
-    /**
-     * Recursively walk `tree` against `patternTree`, filling
-     * `match.`{@link ParseTreeMatch#labels labels}.
-     *
-     * @returns the first node encountered in `tree` which does not match
-     * a corresponding node in `patternTree`, or `undefined` if the match
-     * was successful. The specific node returned depends on the matching
-     * algorithm used by the implementation, and may be overridden.
-     */
-    protected matchImpl(tree: ParseTree, patternTree: ParseTree, labels: MultiMap<string, ParseTree>): ParseTree | undefined;
-    /** Is `t` `(expr <expr>)` subtree? */
-    protected getRuleTagToken(t: ParseTree): RuleTagToken | undefined;
-    tokenize(pattern: string): Token[];
-    /** Split `<ID> = <e:expr> ;` into 4 chunks for tokenizing by {@link #tokenize}. */
-    split(pattern: string): Chunk[];
-}
-export declare namespace ParseTreePatternMatcher {
-    class CannotInvokeStartRule extends Error {
-        error: Error;
-        constructor(error: Error);
-    }
-    class StartRuleDoesNotConsumeFullPattern extends Error {
-        constructor();
-    }
-}

package/typings/antlr4ts/tree/pattern/RuleTagToken.d.ts

@@ -1,122 +0,0 @@
-/*!
- * Copyright 2016 The ANTLR Project. All rights reserved.
- * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
- */
-import { CharStream } from "../../CharStream";
-import { Token } from "../../Token";
-import { TokenSource } from "../../TokenSource";
-/**
- * A {@link Token} object representing an entire subtree matched by a parser
- * rule; e.g., `<expr>`. These tokens are created for {@link TagChunk}
- * chunks where the tag corresponds to a parser rule.
- */
-export declare class RuleTagToken implements Token {
-    /**
-     * This is the backing field for `ruleName`.
-     */
-    private _ruleName;
-    /**
-     * The token type for the current token. This is the token type assigned to
-     * the bypass alternative for the rule during ATN deserialization.
-     */
-    private bypassTokenType;
-    /**
-     * This is the backing field for `label`.
-     */
-    private _label?;
-    /**
-     * Constructs a new instance of {@link RuleTagToken} with the specified rule
-     * name, bypass token type, and label.
-     *
-     * @param ruleName The name of the parser rule this rule tag matches.
-     * @param bypassTokenType The bypass token type assigned to the parser rule.
-     * @param label The label associated with the rule tag, or `undefined` if
-     * the rule tag is unlabeled.
-     *
-     * @exception IllegalArgumentException if `ruleName` is not defined
-     * or empty.
-     */
-    constructor(ruleName: string, bypassTokenType: number, label?: string);
-    /**
-     * Gets the name of the rule associated with this rule tag.
-     *
-     * @returns The name of the parser rule associated with this rule tag.
-     */
-    get ruleName(): string;
-    /**
-     * Gets the label associated with the rule tag.
-     *
-     * @returns The name of the label associated with the rule tag, or
-     * `undefined` if this is an unlabeled rule tag.
-     */
-    get label(): string | undefined;
-    /**
-     * {@inheritDoc}
-     *
-     * Rule tag tokens are always placed on the {@link #DEFAULT_CHANNEL}.
-     */
-    get channel(): number;
-    /**
-     * {@inheritDoc}
-     *
-     * This method returns the rule tag formatted with `<` and `>`
-     * delimiters.
-     */
-    get text(): string;
-    /**
-     * {@inheritDoc}
-     *
-     * Rule tag tokens have types assigned according to the rule bypass
-     * transitions created during ATN deserialization.
-     */
-    get type(): number;
-    /**
-     * {@inheritDoc}
-     *
-     * The implementation for {@link RuleTagToken} always returns 0.
-     */
-    get line(): number;
-    /**
-     * {@inheritDoc}
-     *
-     * The implementation for {@link RuleTagToken} always returns -1.
-     */
-    get charPositionInLine(): number;
-    /**
-     * {@inheritDoc}
-     *
-     * The implementation for {@link RuleTagToken} always returns -1.
-     */
-    get tokenIndex(): number;
-    /**
-     * {@inheritDoc}
-     *
-     * The implementation for {@link RuleTagToken} always returns -1.
-     */
-    get startIndex(): number;
-    /**
-     * {@inheritDoc}
-     *
-     * The implementation for {@link RuleTagToken} always returns -1.
-     */
-    get stopIndex(): number;
-    /**
-     * {@inheritDoc}
-     *
-     * The implementation for {@link RuleTagToken} always returns `undefined`.
-     */
-    get tokenSource(): TokenSource | undefined;
-    /**
-     * {@inheritDoc}
-     *
-     * The implementation for {@link RuleTagToken} always returns `undefined`.
-     */
-    get inputStream(): CharStream | undefined;
-    /**
-     * {@inheritDoc}
-     *
-     * The implementation for {@link RuleTagToken} returns a string of the form
-     * `ruleName:bypassTokenType`.
-     */
-    toString(): string;
-}