@opra/client 0.11.1 → 0.11.2

package/typings/antlr4ts/misc/IntervalSet.d.ts

@@ -1,96 +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 { IntegerList } from "./IntegerList";
-import { Interval } from "./Interval";
-import { IntSet } from "./IntSet";
-import { Vocabulary } from "../Vocabulary";
-/**
- * This class implements the {@link IntSet} backed by a sorted array of
- * non-overlapping intervals. It is particularly efficient for representing
- * large collections of numbers, where the majority of elements appear as part
- * of a sequential range of numbers that are all part of the set. For example,
- * the set { 1, 2, 3, 4, 7, 8 } may be represented as { [1, 4], [7, 8] }.
- *
- * This class is able to represent sets containing any combination of values in
- * the range {@link Integer#MIN_VALUE} to {@link Integer#MAX_VALUE}
- * (inclusive).
- */
-export declare class IntervalSet implements IntSet {
-    private static _COMPLETE_CHAR_SET;
-    static get COMPLETE_CHAR_SET(): IntervalSet;
-    private static _EMPTY_SET;
-    static get EMPTY_SET(): IntervalSet;
-    /** The list of sorted, disjoint intervals. */
-    private _intervals;
-    private readonly;
-    constructor(intervals?: Interval[]);
-    /**
-     * Create a set with all ints within range [a..b] (inclusive). If b is omitted, the set contains the single element
-     * a.
-     */
-    static of(a: number, b?: number): IntervalSet;
-    clear(): void;
-    /** Add interval; i.e., add all integers from a to b to set.
-     *  If b<a, do nothing.
-     *  Keep list in sorted order (by left range value).
-     *  If overlap, combine ranges.  For example,
-     *  If this is {1..5, 10..20}, adding 6..7 yields
-     *  {1..5, 6..7, 10..20}.  Adding 4..8 yields {1..8, 10..20}.
-     */
-    add(a: number, b?: number): void;
-    protected addRange(addition: Interval): void;
-    /** combine all sets in the array returned the or'd value */
-    static or(sets: IntervalSet[]): IntervalSet;
-    addAll(set: IntSet): IntervalSet;
-    complementRange(minElement: number, maxElement: number): IntervalSet;
-    /** {@inheritDoc} */
-    complement(vocabulary: IntSet): IntervalSet;
-    subtract(a: IntSet): IntervalSet;
-    /**
-     * Compute the set difference between two interval sets. The specific
-     * operation is `left - right`.
-     */
-    static subtract(left: IntervalSet, right: IntervalSet): IntervalSet;
-    or(a: IntSet): IntervalSet;
-    /** {@inheritDoc} */
-    and(other: IntSet): IntervalSet;
-    /** {@inheritDoc} */
-    contains(el: number): boolean;
-    /** {@inheritDoc} */
-    get isNil(): boolean;
-    /**
-     * Returns the maximum value contained in the set if not isNil.
-     *
-     * @return the maximum value contained in the set.
-     * @throws RangeError if set is empty
-     */
-    get maxElement(): number;
-    /**
-     * Returns the minimum value contained in the set if not isNil.
-     *
-     * @return the minimum value contained in the set.
-     * @throws RangeError if set is empty
-     */
-    get minElement(): number;
-    /** Return a list of Interval objects. */
-    get intervals(): Interval[];
-    hashCode(): number;
-    /** Are two IntervalSets equal?  Because all intervals are sorted
-     *  and disjoint, equals is a simple linear walk over both lists
-     *  to make sure they are the same.  Interval.equals() is used
-     *  by the List.equals() method to check the ranges.
-     */
-    equals(o: any): boolean;
-    toString(elemAreChar?: boolean): string;
-    toStringVocabulary(vocabulary: Vocabulary): string;
-    protected elementName(vocabulary: Vocabulary, a: number): string;
-    get size(): number;
-    toIntegerList(): IntegerList;
-    toSet(): Set<number>;
-    toArray(): number[];
-    remove(el: number): void;
-    get isReadonly(): boolean;
-    setReadonly(readonly: boolean): void;
-}

package/typings/antlr4ts/misc/MultiMap.d.ts

@@ -1,9 +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 declare class MultiMap<K, V> extends Map<K, V[]> {
-    constructor();
-    map(key: K, value: V): void;
-    getPairs(): Array<[K, V]>;
-}

package/typings/antlr4ts/misc/MurmurHash.d.ts

@@ -1,45 +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 { Equatable } from "./Stubs";
-/**
- *
- * @author Sam Harwell
- */
-export declare namespace MurmurHash {
-    /**
-     * Initialize the hash using the specified `seed`.
-     *
-     * @param seed the seed (optional)
-     * @returns the intermediate hash value
-     */
-    function initialize(seed?: number): number;
-    /**
-     * Update the intermediate hash value for the next input `value`.
-     *
-     * @param hash the intermediate hash value
-     * @param value the value to add to the current hash
-     * @returns the updated intermediate hash value
-     */
-    function update(hash: number, value: number | string | Equatable | null | undefined): number;
-    /**
-     * Apply the final computation steps to the intermediate value `hash`
-     * to form the final result of the MurmurHash 3 hash function.
-     *
-     * @param hash the intermediate hash value
-     * @param numberOfWords the number of integer values added to the hash
-     * @returns the final hash result
-     */
-    function finish(hash: number, numberOfWords: number): number;
-    /**
-     * Utility function to compute the hash code of an array using the
-     * MurmurHash algorithm.
-     *
-     * @param <T> the array element type
-     * @param data the array data
-     * @param seed the seed for the MurmurHash algorithm
-     * @returns the hash code of the data
-     */
-    function hashCode<T extends number | string | Equatable>(data: Iterable<T>, seed?: number): number;
-}

package/typings/antlr4ts/misc/ObjectEqualityComparator.d.ts

@@ -1,32 +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 { EqualityComparator } from "./EqualityComparator";
-import { Equatable } from "./Stubs";
-/**
- * This default implementation of {@link EqualityComparator} uses object equality
- * for comparisons by calling {@link Object#hashCode} and {@link Object#equals}.
- *
- * @author Sam Harwell
- */
-export declare class ObjectEqualityComparator implements EqualityComparator<Equatable | null | undefined> {
-    static readonly INSTANCE: ObjectEqualityComparator;
-    /**
-     * {@inheritDoc}
-     *
-     * This implementation returns
-     * `obj.`{@link Object#hashCode hashCode()}.
-     */
-    hashCode(obj: Equatable | null | undefined): number;
-    /**
-     * {@inheritDoc}
-     *
-     * This implementation relies on object equality. If both objects are
-     * `undefined` or `null`, this method returns `true`. Otherwise if only
-     * `a` is `undefined` or `null`, this method returns `false`. Otherwise,
-     * this method returns the result of
-     * `a.`{@link Object#equals equals}`(b)`.
-     */
-    equals(a: Equatable | null | undefined, b: Equatable | null | undefined): boolean;
-}

package/typings/antlr4ts/misc/ParseCancellationException.d.ts

@@ -1,18 +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.
- */
-/**
- * This exception is thrown to cancel a parsing operation. This exception does
- * not extend {@link RecognitionException}, allowing it to bypass the standard
- * error recovery mechanisms. {@link BailErrorStrategy} throws this exception in
- * response to a parse error.
- *
- * @author Sam Harwell
- */
-export declare class ParseCancellationException extends Error {
-    cause: Error;
-    readonly stack?: string;
-    constructor(cause: Error);
-    getCause(): Error;
-}

package/typings/antlr4ts/misc/Stubs.d.ts

@@ -1,31 +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 interface Equatable {
-    equals(other: any): boolean;
-    hashCode(): number;
-}
-export interface Comparable<T> {
-    compareTo(o: T): number;
-}
-export interface JavaCollection<E> extends Iterable<E>, Equatable {
-    add(e: E): boolean;
-    addAll(collection: Iterable<E>): boolean;
-    clear(): void;
-    contains(o: any): boolean;
-    containsAll(collection: Iterable<any>): boolean;
-    readonly isEmpty: boolean;
-    readonly size: number;
-    toArray(): E[];
-}
-export interface JavaSet<E> extends JavaCollection<E> {
-}
-export interface JavaMap<K, V> extends Equatable {
-    clear(): void;
-    containsKey(key: K): boolean;
-    get(key: K): V | undefined;
-    readonly isEmpty: boolean;
-    put(key: K, value: V): V | undefined;
-    readonly size: number;
-}

package/typings/antlr4ts/misc/UUID.d.ts

@@ -1,13 +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 { Equatable } from "./Stubs";
-export declare class UUID implements Equatable {
-    private readonly data;
-    constructor(mostSigBits: number, moreSigBits: number, lessSigBits: number, leastSigBits: number);
-    static fromString(data: string): UUID;
-    hashCode(): number;
-    equals(obj: any): boolean;
-    toString(): string;
-}

package/typings/antlr4ts/misc/Utils.d.ts

@@ -1,15 +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 { Equatable } from "./Stubs";
-import { IntegerList } from "./IntegerList";
-export declare function escapeWhitespace(s: string, escapeSpaces: boolean): string;
-export declare function join(collection: Iterable<any>, separator: string): string;
-export declare function equals(x: Equatable | undefined, y: Equatable | undefined): boolean;
-/** Convert array of strings to string&rarr;index map. Useful for
- *  converting rulenames to name&rarr;ruleindex map.
- */
-export declare function toMap(keys: string[]): Map<string, number>;
-export declare function toCharArray(str: string): Uint16Array;
-export declare function toCharArray(data: IntegerList): Uint16Array;

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

@@ -1,25 +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 "./Array2DHashMap";
-export * from "./ArrayEqualityComparator";
-export * from "./Args";
-export * from "./Array2DHashSet";
-export * from "./Arrays";
-export * from "./BitSet";
-export * from "./Character";
-export * from "./DefaultEqualityComparator";
-export * from "./EqualityComparator";
-export * from "./IntegerList";
-export * from "./IntegerStack";
-export * from "./InterpreterDataReader";
-export * from "./Interval";
-export * from "./IntervalSet";
-export * from "./IntSet";
-export * from "./MultiMap";
-export * from "./MurmurHash";
-export * from "./ObjectEqualityComparator";
-export * from "./ParseCancellationException";
-export * from "./Utils";
-export * from "./UUID";

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

@@ -1,103 +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 { ErrorNode } from "./ErrorNode";
-import { ParseTree } from "./ParseTree";
-import { ParseTreeVisitor } from "./ParseTreeVisitor";
-import { RuleNode } from "./RuleNode";
-import { TerminalNode } from "./TerminalNode";
-export declare abstract class AbstractParseTreeVisitor<Result> implements ParseTreeVisitor<Result> {
-    /**
-     * {@inheritDoc}
-     *
-     * The default implementation calls {@link ParseTree#accept} on the
-     * specified tree.
-     */
-    visit(tree: ParseTree): Result;
-    /**
-     * {@inheritDoc}
-     *
-     * The default implementation initializes the aggregate result to
-     * {@link #defaultResult defaultResult()}. Before visiting each child, it
-     * calls {@link #shouldVisitNextChild shouldVisitNextChild}; if the result
-     * is `false` no more children are visited and the current aggregate
-     * result is returned. After visiting a child, the aggregate result is
-     * updated by calling {@link #aggregateResult aggregateResult} with the
-     * previous aggregate result and the result of visiting the child.
-     *
-     * The default implementation is not safe for use in visitors that modify
-     * the tree structure. Visitors that modify the tree should override this
-     * method to behave properly in respect to the specific algorithm in use.
-     */
-    visitChildren(node: RuleNode): Result;
-    /**
-     * {@inheritDoc}
-     *
-     * The default implementation returns the result of
-     * {@link #defaultResult defaultResult}.
-     */
-    visitTerminal(node: TerminalNode): Result;
-    /**
-     * {@inheritDoc}
-     *
-     * The default implementation returns the result of
-     * {@link #defaultResult defaultResult}.
-     */
-    visitErrorNode(node: ErrorNode): Result;
-    /**
-     * Gets the default value returned by visitor methods. This value is
-     * returned by the default implementations of
-     * {@link #visitTerminal visitTerminal}, {@link #visitErrorNode visitErrorNode}.
-     * The default implementation of {@link #visitChildren visitChildren}
-     * initializes its aggregate result to this value.
-     *
-     * @returns The default value returned by visitor methods.
-     */
-    protected abstract defaultResult(): Result;
-    /**
-     * Aggregates the results of visiting multiple children of a node. After
-     * either all children are visited or {@link #shouldVisitNextChild} returns
-     * `false`, the aggregate value is returned as the result of
-     * {@link #visitChildren}.
-     *
-     * The default implementation returns `nextResult`, meaning
-     * {@link #visitChildren} will return the result of the last child visited
-     * (or return the initial value if the node has no children).
-     *
-     * @param aggregate The previous aggregate value. In the default
-     * implementation, the aggregate value is initialized to
-     * {@link #defaultResult}, which is passed as the `aggregate` argument
-     * to this method after the first child node is visited.
-     * @param nextResult The result of the immediately preceeding call to visit
-     * a child node.
-     *
-     * @returns The updated aggregate result.
-     */
-    protected aggregateResult(aggregate: Result, nextResult: Result): Result;
-    /**
-     * This method is called after visiting each child in
-     * {@link #visitChildren}. This method is first called before the first
-     * child is visited; at that point `currentResult` will be the initial
-     * value (in the default implementation, the initial value is returned by a
-     * call to {@link #defaultResult}. This method is not called after the last
-     * child is visited.
-     *
-     * The default implementation always returns `true`, indicating that
-     * `visitChildren` should only return after all children are visited.
-     * One reason to override this method is to provide a "short circuit"
-     * evaluation option for situations where the result of visiting a single
-     * child has the potential to determine the result of the visit operation as
-     * a whole.
-     *
-     * @param node The {@link RuleNode} whose children are currently being
-     * visited.
-     * @param currentResult The current aggregate result of the children visited
-     * to the current point.
-     *
-     * @returns `true` to continue visiting children. Otherwise return
-     * `false` to stop visiting children and immediately return the
-     * current aggregate result from {@link #visitChildren}.
-     */
-    protected shouldVisitNextChild(node: RuleNode, currentResult: Result): boolean;
-}

package/typings/antlr4ts/tree/ErrorNode.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.
- */
-import { ParseTreeVisitor } from "./ParseTreeVisitor";
-import { TerminalNode } from "./TerminalNode";
-import { Token } from "../Token";
-/** Represents a token that was consumed during resynchronization
- *  rather than during a valid match operation. For example,
- *  we will create this kind of a node during single token insertion
- *  and deletion as well as during "consume until error recovery set"
- *  upon no viable alternative exceptions.
- */
-export declare class ErrorNode extends TerminalNode {
-    constructor(token: Token);
-    accept<T>(visitor: ParseTreeVisitor<T>): T;
-}

package/typings/antlr4ts/tree/ParseTree.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.
- */
-import { Parser } from "../Parser";
-import { ParseTreeVisitor } from "./ParseTreeVisitor";
-import { RuleContext } from "../RuleContext";
-import { SyntaxTree } from "./SyntaxTree";
-/** An interface to access the tree of {@link RuleContext} objects created
- *  during a parse that makes the data structure look like a simple parse tree.
- *  This node represents both internal nodes, rule invocations,
- *  and leaf nodes, token matches.
- *
- *  The payload is either a {@link Token} or a {@link RuleContext} object.
- */
-export interface ParseTree extends SyntaxTree {
-    readonly parent: ParseTree | undefined;
-    /**
-     * Set the parent for this node.
-     *
-     * @since 4.7
-     */
-    setParent(parent: RuleContext): void;
-    getChild(i: number): ParseTree;
-    /** The {@link ParseTreeVisitor} needs a double dispatch method. */
-    accept<T>(visitor: ParseTreeVisitor<T>): T;
-    /** Return the combined text of all leaf nodes. Does not get any
-     *  off-channel tokens (if any) so won't return whitespace and
-     *  comments if they are sent to parser on hidden channel.
-     */
-    readonly text: string;
-    /** Specialize toStringTree so that it can print out more information
-     * 	based upon the parser.
-     */
-    toStringTree(parser?: Parser): string;
-}

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

@@ -1,26 +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 { ErrorNode } from "./ErrorNode";
-import { ParserRuleContext } from "../ParserRuleContext";
-import { TerminalNode } from "./TerminalNode";
-/** This interface describes the minimal core of methods triggered
- *  by {@link ParseTreeWalker}. E.g.,
- *
- * ```
- * ParseTreeWalker walker = new ParseTreeWalker();
- * walker.walk(myParseTreeListener, myParseTree); <-- triggers events in your listener
- * ```
- *
- *  If you want to trigger events in multiple listeners during a single
- *  tree walk, you can use the ParseTreeDispatcher object available at
- *
- * 		https://github.com/antlr/antlr4/issues/841
- */
-export interface ParseTreeListener {
-    visitTerminal?: (/*@NotNull*/ node: TerminalNode) => void;
-    visitErrorNode?: (/*@NotNull*/ node: ErrorNode) => void;
-    enterEveryRule?: (/*@NotNull*/ ctx: ParserRuleContext) => void;
-    exitEveryRule?: (/*@NotNull*/ ctx: ParserRuleContext) => void;
-}

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

@@ -1,28 +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";
-/**
- * Associate a property with a parse tree node. Useful with parse tree listeners
- * that need to associate values with particular tree nodes, kind of like
- * specifying a return value for the listener event method that visited a
- * particular node. Example:
- *
- * ```
- * ParseTreeProperty<Integer> values = new ParseTreeProperty<Integer>();
- * values.put(tree, 36);
- * int x = values.get(tree);
- * values.removeFrom(tree);
- * ```
- *
- * You would make one decl (values here) in the listener and use lots of times
- * in your event methods.
- */
-export declare class ParseTreeProperty<V> {
-    private _symbol;
-    constructor(name?: string);
-    get(node: ParseTree): V;
-    set(node: ParseTree, value: V): void;
-    removeFrom(node: ParseTree): V;
-}

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

@@ -1,48 +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 { ErrorNode } from "./ErrorNode";
-import { ParseTree } from "./ParseTree";
-import { RuleNode } from "./RuleNode";
-import { TerminalNode } from "./TerminalNode";
-/**
- * This interface defines the basic notion of a parse tree visitor. Generated
- * visitors implement this interface and the `XVisitor` interface for
- * grammar `X`.
- *
- * @author Sam Harwell
- * @param <Result> The return type of the visit operation. Use {@link Void} for
- * operations with no return type.
- */
-export interface ParseTreeVisitor<Result> {
-    /**
-     * Visit a parse tree, and return a user-defined result of the operation.
-     *
-     * @param tree The {@link ParseTree} to visit.
-     * @returns The result of visiting the parse tree.
-     */
-    visit(/*@NotNull*/ tree: ParseTree): Result;
-    /**
-     * Visit the children of a node, and return a user-defined result
-     * of the operation.
-     *
-     * @param node The {@link RuleNode} whose children should be visited.
-     * @returns The result of visiting the children of the node.
-     */
-    visitChildren(/*@NotNull*/ node: RuleNode): Result;
-    /**
-     * Visit a terminal node, and return a user-defined result of the operation.
-     *
-     * @param node The {@link TerminalNode} to visit.
-     * @returns The result of visiting the node.
-     */
-    visitTerminal(/*@NotNull*/ node: TerminalNode): Result;
-    /**
-     * Visit an error node, and return a user-defined result of the operation.
-     *
-     * @param node The {@link ErrorNode} to visit.
-     * @returns The result of visiting the node.
-     */
-    visitErrorNode(/*@NotNull*/ node: ErrorNode): Result;
-}

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

@@ -1,35 +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 { ParseTreeListener } from "./ParseTreeListener";
-import { RuleNode } from "./RuleNode";
-export declare class ParseTreeWalker {
-    /**
-     * Performs a walk on the given parse tree starting at the root and going down recursively
-     * with depth-first search. On each node, {@link ParseTreeWalker#enterRule} is called before
-     * recursively walking down into child nodes, then
-     * {@link ParseTreeWalker#exitRule} is called after the recursive call to wind up.
-     * @param listener The listener used by the walker to process grammar rules
-     * @param t The parse tree to be walked on
-     */
-    walk<T extends ParseTreeListener>(listener: T, t: ParseTree): void;
-    /**
-     * Enters a grammar rule by first triggering the generic event {@link ParseTreeListener#enterEveryRule}
-     * then by triggering the event specific to the given parse tree node
-     * @param listener The listener responding to the trigger events
-     * @param r The grammar rule containing the rule context
-     */
-    protected enterRule(listener: ParseTreeListener, r: RuleNode): void;
-    /**
-     * Exits a grammar rule by first triggering the event specific to the given parse tree node
-     * then by triggering the generic event {@link ParseTreeListener#exitEveryRule}
-     * @param listener The listener responding to the trigger events
-     * @param r The grammar rule containing the rule context
-     */
-    protected exitRule(listener: ParseTreeListener, r: RuleNode): void;
-}
-export declare namespace ParseTreeWalker {
-    const DEFAULT: ParseTreeWalker;
-}

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

@@ -1,21 +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 { RuleContext } from "../RuleContext";
-import { ParseTree } from "./ParseTree";
-import { ParseTreeVisitor } from "./ParseTreeVisitor";
-import { Parser } from "../Parser";
-import { Interval } from "../misc/Interval";
-export declare abstract class RuleNode implements ParseTree {
-    abstract readonly ruleContext: RuleContext;
-    abstract readonly parent: RuleNode | undefined;
-    abstract setParent(parent: RuleContext): void;
-    abstract getChild(i: number): ParseTree;
-    abstract accept<T>(visitor: ParseTreeVisitor<T>): T;
-    abstract readonly text: string;
-    abstract toStringTree(parser?: Parser | undefined): string;
-    abstract readonly sourceInterval: Interval;
-    abstract readonly payload: any;
-    abstract readonly childCount: number;
-}

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

@@ -1,29 +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 { Tree } from "./Tree";
-import { Interval } from "../misc/Interval";
-/** A tree that knows about an interval in a token stream
- *  is some kind of syntax tree. Subinterfaces distinguish
- *  between parse trees and other kinds of syntax trees we might want to create.
- */
-export interface SyntaxTree extends Tree {
-    /**
-     * Return an {@link Interval} indicating the index in the
-     * {@link TokenStream} of the first and last token associated with this
-     * subtree. If this node is a leaf, then the interval represents a single
-     * token and has interval i..i for token index i.
-     *
-     * An interval of i..i-1 indicates an empty interval at position
-     * i in the input stream, where 0 <= i <= the size of the input
-     * token stream.  Currently, the code base can only have i=0..n-1 but
-     * in concept one could have an empty interval after EOF.
-     *
-     * If source interval is unknown, this returns {@link Interval#INVALID}.
-     *
-     * As a weird special case, the source interval for rules matched after
-     * EOF is unspecified.
-     */
-    readonly sourceInterval: Interval;
-}