@opra/client 0.11.0 → 0.11.2

package/typings/antlr4ts/ParserRuleContext.d.ts

@@ -1,169 +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 "./tree/ErrorNode";
-import { Interval } from "./misc/Interval";
-import { Parser } from "./Parser";
-import { ParseTree } from "./tree/ParseTree";
-import { ParseTreeListener } from "./tree/ParseTreeListener";
-import { RecognitionException } from "./RecognitionException";
-import { RuleContext } from "./RuleContext";
-import { TerminalNode } from "./tree/TerminalNode";
-import { Token } from "./Token";
-/** A rule invocation record for parsing.
- *
- *  Contains all of the information about the current rule not stored in the
- *  RuleContext. It handles parse tree children list, Any ATN state
- *  tracing, and the default values available for rule invocations:
- *  start, stop, rule index, current alt number.
- *
- *  Subclasses made for each rule and grammar track the parameters,
- *  return values, locals, and labels specific to that rule. These
- *  are the objects that are returned from rules.
- *
- *  Note text is not an actual field of a rule return value; it is computed
- *  from start and stop using the input stream's toString() method.  I
- *  could add a ctor to this so that we can pass in and store the input
- *  stream, but I'm not sure we want to do that.  It would seem to be undefined
- *  to get the .text property anyway if the rule matches tokens from multiple
- *  input streams.
- *
- *  I do not use getters for fields of objects that are used simply to
- *  group values such as this aggregate.  The getters/setters are there to
- *  satisfy the superclass interface.
- */
-export declare class ParserRuleContext extends RuleContext {
-    private static readonly EMPTY;
-    /** If we are debugging or building a parse tree for a visitor,
-     *  we need to track all of the tokens and rule invocations associated
-     *  with this rule's context. This is empty for parsing w/o tree constr.
-     *  operation because we don't the need to track the details about
-     *  how we parse this rule.
-     */
-    children?: ParseTree[];
-    /** For debugging/tracing purposes, we want to track all of the nodes in
-     *  the ATN traversed by the parser for a particular rule.
-     *  This list indicates the sequence of ATN nodes used to match
-     *  the elements of the children list. This list does not include
-     *  ATN nodes and other rules used to match rule invocations. It
-     *  traces the rule invocation node itself but nothing inside that
-     *  other rule's ATN submachine.
-     *
-     *  There is NOT a one-to-one correspondence between the children and
-     *  states list. There are typically many nodes in the ATN traversed
-     *  for each element in the children list. For example, for a rule
-     *  invocation there is the invoking state and the following state.
-     *
-     *  The parser state property updates field s and adds it to this list
-     *  if we are debugging/tracing.
-     *
-     *  This does not trace states visited during prediction.
-     */
-    _start: Token;
-    _stop: Token | undefined;
-    /**
-     * The exception that forced this rule to return. If the rule successfully
-     * completed, this is `undefined`.
-     */
-    exception?: RecognitionException;
-    constructor();
-    constructor(parent: ParserRuleContext | undefined, invokingStateNumber: number);
-    static emptyContext(): ParserRuleContext;
-    /**
-     * COPY a ctx (I'm deliberately not using copy constructor) to avoid
-     * confusion with creating node with parent. Does not copy children
-     * (except error leaves).
-     *
-     * This is used in the generated parser code to flip a generic XContext
-     * node for rule X to a YContext for alt label Y. In that sense, it is not
-     * really a generic copy function.
-     *
-     * If we do an error sync() at start of a rule, we might add error nodes
-     * to the generic XContext so this function must copy those nodes to the
-     * YContext as well else they are lost!
-     */
-    copyFrom(ctx: ParserRuleContext): void;
-    enterRule(listener: ParseTreeListener): void;
-    exitRule(listener: ParseTreeListener): void;
-    /** Add a parse tree node to this as a child.  Works for
-     *  internal and leaf nodes. Does not set parent link;
-     *  other add methods must do that. Other addChild methods
-     *  call this.
-     *
-     *  We cannot set the parent pointer of the incoming node
-     *  because the existing interfaces do not have a setParent()
-     *  method and I don't want to break backward compatibility for this.
-     *
-     *  @since 4.7
-     */
-    addAnyChild<T extends ParseTree>(t: T): T;
-    /** Add a token leaf node child and force its parent to be this node. */
-    addChild(t: TerminalNode): void;
-    addChild(ruleInvocation: RuleContext): void;
-    /**
-     * Add a child to this node based upon matchedToken. It
-     * creates a TerminalNodeImpl rather than using
-     * {@link Parser#createTerminalNode(ParserRuleContext, Token)}. I'm leaving this
-     * in for compatibility but the parser doesn't use this anymore.
-     *
-     * @deprecated Use another overload instead.
-     */
-    addChild(matchedToken: Token): TerminalNode;
-    /** Add an error node child and force its parent to be this node.
-     *
-     * @since 4.7
-     */
-    addErrorNode(errorNode: ErrorNode): ErrorNode;
-    /**
-     * Add a child to this node based upon badToken. It
-     * creates a ErrorNode rather than using
-     * {@link Parser#createErrorNode(ParserRuleContext, Token)}. I'm leaving this
-     * in for compatibility but the parser doesn't use this anymore.
-     *
-     * @deprecated Use another overload instead.
-     */
-    addErrorNode(badToken: Token): ErrorNode;
-    /** Used by enterOuterAlt to toss out a RuleContext previously added as
-     *  we entered a rule. If we have # label, we will need to remove
-     *  generic ruleContext object.
-     */
-    removeLastChild(): void;
-    get parent(): ParserRuleContext | undefined;
-    getChild(i: number): ParseTree;
-    getChild<T extends ParseTree>(i: number, ctxType: {
-        new (...args: any[]): T;
-    }): T;
-    tryGetChild<T extends ParseTree>(i: number, ctxType: {
-        new (...args: any[]): T;
-    }): T | undefined;
-    getToken(ttype: number, i: number): TerminalNode;
-    tryGetToken(ttype: number, i: number): TerminalNode | undefined;
-    getTokens(ttype: number): TerminalNode[];
-    get ruleContext(): this;
-    getRuleContext<T extends ParserRuleContext>(i: number, ctxType: {
-        new (...args: any[]): T;
-    }): T;
-    tryGetRuleContext<T extends ParserRuleContext>(i: number, ctxType: {
-        new (...args: any[]): T;
-    }): T | undefined;
-    getRuleContexts<T extends ParserRuleContext>(ctxType: {
-        new (...args: any[]): T;
-    }): T[];
-    get childCount(): number;
-    get sourceInterval(): Interval;
-    /**
-     * Get the initial token in this context.
-     * Note that the range from start to stop is inclusive, so for rules that do not consume anything
-     * (for example, zero length or error productions) this token may exceed stop.
-     */
-    get start(): Token;
-    /**
-     * Get the final token in this context.
-     * Note that the range from start to stop is inclusive, so for rules that do not consume anything
-     * (for example, zero length or error productions) this token may precede start.
-     */
-    get stop(): Token | undefined;
-    /** Used for rule context info debugging during parse-time, not so much for ATN debugging */
-    toInfoString(recognizer: Parser): string;
-}

package/typings/antlr4ts/ProxyErrorListener.d.ts

@@ -1,20 +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 { ANTLRErrorListener } from "./ANTLRErrorListener";
-import { RecognitionException } from "./RecognitionException";
-import { Recognizer } from "./Recognizer";
-/**
- * This implementation of {@link ANTLRErrorListener} dispatches all calls to a
- * collection of delegate listeners. This reduces the effort required to support multiple
- * listeners.
- *
- * @author Sam Harwell
- */
-export declare class ProxyErrorListener<TSymbol, TListener extends ANTLRErrorListener<TSymbol>> implements ANTLRErrorListener<TSymbol> {
-    private delegates;
-    constructor(delegates: TListener[]);
-    protected getDelegates(): ReadonlyArray<TListener>;
-    syntaxError<T extends TSymbol>(recognizer: Recognizer<T, any>, offendingSymbol: T | undefined, line: number, charPositionInLine: number, msg: string, e: RecognitionException | undefined): void;
-}

package/typings/antlr4ts/ProxyParserErrorListener.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 { ATNConfigSet } from "./atn/ATNConfigSet";
-import { BitSet } from "./misc/BitSet";
-import { DFA } from "./dfa/DFA";
-import { Parser } from "./Parser";
-import { ProxyErrorListener } from "./ProxyErrorListener";
-import { ParserErrorListener } from "./ParserErrorListener";
-import { SimulatorState } from "./atn/SimulatorState";
-import { Token } from "./Token";
-/**
- * @author Sam Harwell
- */
-export declare class ProxyParserErrorListener extends ProxyErrorListener<Token, ParserErrorListener> implements ParserErrorListener {
-    constructor(delegates: ParserErrorListener[]);
-    reportAmbiguity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, exact: boolean, ambigAlts: BitSet | undefined, configs: ATNConfigSet): void;
-    reportAttemptingFullContext(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, conflictingAlts: BitSet | undefined, conflictState: SimulatorState): void;
-    reportContextSensitivity(recognizer: Parser, dfa: DFA, startIndex: number, stopIndex: number, prediction: number, acceptState: SimulatorState): void;
-}

package/typings/antlr4ts/RecognitionException.d.ts

@@ -1,87 +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 { IntervalSet } from "./misc/IntervalSet";
-import { IntStream } from "./IntStream";
-import { Lexer } from "./Lexer";
-import { ParserRuleContext } from "./ParserRuleContext";
-import { Recognizer } from "./Recognizer";
-import { RuleContext } from "./RuleContext";
-import { Token } from "./Token";
-/** The root of the ANTLR exception hierarchy. In general, ANTLR tracks just
- *  3 kinds of errors: prediction errors, failed predicate errors, and
- *  mismatched input errors. In each case, the parser knows where it is
- *  in the input, where it is in the ATN, the rule invocation stack,
- *  and what kind of problem occurred.
- */
-export declare class RecognitionException extends Error {
-    /** The {@link Recognizer} where this exception originated. */
-    private _recognizer?;
-    private ctx?;
-    private input?;
-    /**
-     * The current {@link Token} when an error occurred. Since not all streams
-     * support accessing symbols by index, we have to track the {@link Token}
-     * instance itself.
-     */
-    private offendingToken?;
-    private _offendingState;
-    constructor(lexer: Lexer | undefined, input: CharStream);
-    constructor(recognizer: Recognizer<Token, any> | undefined, input: IntStream | undefined, ctx: ParserRuleContext | undefined);
-    constructor(recognizer: Recognizer<Token, any> | undefined, input: IntStream | undefined, ctx: ParserRuleContext | undefined, message: string);
-    /**
-     * Get the ATN state number the parser was in at the time the error
-     * occurred. For {@link NoViableAltException} and
-     * {@link LexerNoViableAltException} exceptions, this is the
-     * {@link DecisionState} number. For others, it is the state whose outgoing
-     * edge we couldn't match.
-     *
-     * If the state number is not known, this method returns -1.
-     */
-    get offendingState(): number;
-    protected setOffendingState(offendingState: number): void;
-    /**
-     * Gets the set of input symbols which could potentially follow the
-     * previously matched symbol at the time this exception was thrown.
-     *
-     * If the set of expected tokens is not known and could not be computed,
-     * this method returns `undefined`.
-     *
-     * @returns The set of token types that could potentially follow the current
-     * state in the ATN, or `undefined` if the information is not available.
-     */
-    get expectedTokens(): IntervalSet | undefined;
-    /**
-     * Gets the {@link RuleContext} at the time this exception was thrown.
-     *
-     * If the context is not available, this method returns `undefined`.
-     *
-     * @returns The {@link RuleContext} at the time this exception was thrown.
-     * If the context is not available, this method returns `undefined`.
-     */
-    get context(): RuleContext | undefined;
-    /**
-     * Gets the input stream which is the symbol source for the recognizer where
-     * this exception was thrown.
-     *
-     * If the input stream is not available, this method returns `undefined`.
-     *
-     * @returns The input stream which is the symbol source for the recognizer
-     * where this exception was thrown, or `undefined` if the stream is not
-     * available.
-     */
-    get inputStream(): IntStream | undefined;
-    getOffendingToken(recognizer?: Recognizer<Token, any>): Token | undefined;
-    protected setOffendingToken<TSymbol extends Token>(recognizer: Recognizer<TSymbol, any>, offendingToken?: TSymbol): void;
-    /**
-     * Gets the {@link Recognizer} where this exception occurred.
-     *
-     * If the recognizer is not available, this method returns `undefined`.
-     *
-     * @returns The recognizer where this exception occurred, or `undefined` if
-     * the recognizer is not available.
-     */
-    get recognizer(): Recognizer<any, any> | undefined;
-}

package/typings/antlr4ts/Recognizer.d.ts

@@ -1,101 +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 { ANTLRErrorListener } from "./ANTLRErrorListener";
-import { ATN } from "./atn/ATN";
-import { ATNSimulator } from "./atn/ATNSimulator";
-import { IntStream } from "./IntStream";
-import { ParseInfo } from "./atn/ParseInfo";
-import { RecognitionException } from "./RecognitionException";
-import { RuleContext } from "./RuleContext";
-import { Vocabulary } from "./Vocabulary";
-export declare abstract class Recognizer<TSymbol, ATNInterpreter extends ATNSimulator> {
-    static readonly EOF: number;
-    private static tokenTypeMapCache;
-    private static ruleIndexMapCache;
-    private readonly _listeners;
-    protected _interp: ATNInterpreter;
-    private _stateNumber;
-    abstract readonly ruleNames: string[];
-    /**
-     * Get the vocabulary used by the recognizer.
-     *
-     * @returns A {@link Vocabulary} instance providing information about the
-     * vocabulary used by the grammar.
-     */
-    abstract readonly vocabulary: Vocabulary;
-    /**
-     * Get a map from token names to token types.
-     *
-     * Used for XPath and tree pattern compilation.
-     */
-    getTokenTypeMap(): ReadonlyMap<string, number>;
-    /**
-     * Get a map from rule names to rule indexes.
-     *
-     * Used for XPath and tree pattern compilation.
-     */
-    getRuleIndexMap(): ReadonlyMap<string, number>;
-    getTokenType(tokenName: string): number;
-    /**
-     * If this recognizer was generated, it will have a serialized ATN
-     * representation of the grammar.
-     *
-     * For interpreters, we don't know their serialized ATN despite having
-     * created the interpreter from it.
-     */
-    get serializedATN(): string;
-    /** For debugging and other purposes, might want the grammar name.
-     *  Have ANTLR generate an implementation for this method.
-     */
-    abstract readonly grammarFileName: string;
-    /**
-     * Get the {@link ATN} used by the recognizer for prediction.
-     *
-     * @returns The {@link ATN} used by the recognizer for prediction.
-     */
-    get atn(): ATN;
-    /**
-     * Get the ATN interpreter used by the recognizer for prediction.
-     *
-     * @returns The ATN interpreter used by the recognizer for prediction.
-     */
-    get interpreter(): ATNInterpreter;
-    /**
-     * Set the ATN interpreter used by the recognizer for prediction.
-     *
-     * @param interpreter The ATN interpreter used by the recognizer for
-     * prediction.
-     */
-    set interpreter(interpreter: ATNInterpreter);
-    /** If profiling during the parse/lex, this will return DecisionInfo records
-     *  for each decision in recognizer in a ParseInfo object.
-     *
-     * @since 4.3
-     */
-    get parseInfo(): Promise<ParseInfo | undefined>;
-    /** What is the error header, normally line/character position information? */
-    getErrorHeader(e: RecognitionException): string;
-    /**
-     * @exception NullPointerException if `listener` is `undefined`.
-     */
-    addErrorListener(listener: ANTLRErrorListener<TSymbol>): void;
-    removeErrorListener(listener: ANTLRErrorListener<TSymbol>): void;
-    removeErrorListeners(): void;
-    getErrorListeners(): Array<ANTLRErrorListener<TSymbol>>;
-    getErrorListenerDispatch(): ANTLRErrorListener<TSymbol>;
-    sempred(_localctx: RuleContext | undefined, ruleIndex: number, actionIndex: number): boolean;
-    precpred(localctx: RuleContext | undefined, precedence: number): boolean;
-    action(_localctx: RuleContext | undefined, ruleIndex: number, actionIndex: number): void;
-    get state(): number;
-    /** Indicate that the recognizer has changed internal state that is
-     *  consistent with the ATN state passed in.  This way we always know
-     *  where we are in the ATN as the parser goes along. The rule
-     *  context objects form a stack that lets us see the stack of
-     *  invoking rules. Combine this and we have complete ATN
-     *  configuration information.
-     */
-    set state(atnState: number);
-    abstract readonly inputStream: IntStream | undefined;
-}

package/typings/antlr4ts/RuleContext.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 { Parser } from "./Parser";
-import { Recognizer } from "./Recognizer";
-import { RuleNode } from "./tree/RuleNode";
-import { ParseTree } from "./tree/ParseTree";
-import { Interval } from "./misc/Interval";
-import { ParseTreeVisitor } from "./tree/ParseTreeVisitor";
-/** A rule context is a record of a single rule invocation.
- *
- *  We form a stack of these context objects using the parent
- *  pointer. A parent pointer of `undefined` indicates that the current
- *  context is the bottom of the stack. The ParserRuleContext subclass
- *  as a children list so that we can turn this data structure into a
- *  tree.
- *
- *  The root node always has a `undefined` pointer and invokingState of -1.
- *
- *  Upon entry to parsing, the first invoked rule function creates a
- *  context object (a subclass specialized for that rule such as
- *  SContext) and makes it the root of a parse tree, recorded by field
- *  Parser._ctx.
- *
- *  public final SContext s() throws RecognitionException {
- *      SContext _localctx = new SContext(_ctx, state); <-- create new node
- *      enterRule(_localctx, 0, RULE_s);                     <-- push it
- *      ...
- *      exitRule();                                          <-- pop back to _localctx
- *      return _localctx;
- *  }
- *
- *  A subsequent rule invocation of r from the start rule s pushes a
- *  new context object for r whose parent points at s and use invoking
- *  state is the state with r emanating as edge label.
- *
- *  The invokingState fields from a context object to the root
- *  together form a stack of rule indication states where the root
- *  (bottom of the stack) has a -1 sentinel value. If we invoke start
- *  symbol s then call r1, which calls r2, the  would look like
- *  this:
- *
- *     SContext[-1]   <- root node (bottom of the stack)
- *     R1Context[p]   <- p in rule s called r1
- *     R2Context[q]   <- q in rule r1 called r2
- *
- *  So the top of the stack, _ctx, represents a call to the current
- *  rule and it holds the return address from another rule that invoke
- *  to this rule. To invoke a rule, we must always have a current context.
- *
- *  The parent contexts are useful for computing lookahead sets and
- *  getting error information.
- *
- *  These objects are used during parsing and prediction.
- *  For the special case of parsers, we use the subclass
- *  ParserRuleContext.
- *
- *  @see ParserRuleContext
- */
-export declare class RuleContext extends RuleNode {
-    _parent: RuleContext | undefined;
-    invokingState: number;
-    constructor();
-    constructor(parent: RuleContext | undefined, invokingState: number);
-    static getChildContext(parent: RuleContext, invokingState: number): RuleContext;
-    depth(): number;
-    /** A context is empty if there is no invoking state; meaning nobody called
-     *  current context.
-     */
-    get isEmpty(): boolean;
-    get sourceInterval(): Interval;
-    get ruleContext(): RuleContext;
-    get parent(): RuleContext | undefined;
-    /** @since 4.7. {@see ParseTree#setParent} comment */
-    setParent(parent: RuleContext): void;
-    get payload(): RuleContext;
-    /** Return the combined text of all child nodes. This method only considers
-     *  tokens which have been added to the parse tree.
-     *
-     *  Since tokens on hidden channels (e.g. whitespace or comments) are not
-     *  added to the parse trees, they will not appear in the output of this
-     *  method.
-     */
-    get text(): string;
-    get ruleIndex(): number;
-    /** For rule associated with this parse tree internal node, return
-     *  the outer alternative number used to match the input. Default
-     *  implementation does not compute nor store this alt num. Create
-     *  a subclass of ParserRuleContext with backing field and set
-     *  option contextSuperClass.
-     *  to set it.
-     *
-     *  @since 4.5.3
-     */
-    get altNumber(): number;
-    /** Set the outer alternative number for this context node. Default
-     *  implementation does nothing to avoid backing field overhead for
-     *  trees that don't need it.  Create
-     *  a subclass of ParserRuleContext with backing field and set
-     *  option contextSuperClass.
-     *
-     *  @since 4.5.3
-     */
-    set altNumber(altNumber: number);
-    getChild(i: number): ParseTree;
-    get childCount(): number;
-    accept<T>(visitor: ParseTreeVisitor<T>): T;
-    /** Print out a whole tree, not just a node, in LISP format
-     *  (root child1 .. childN). Print just a node if this is a leaf.
-     *  We have to know the recognizer so we can get rule names.
-     */
-    toStringTree(recog: Parser): string;
-    /** 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(ruleNames: string[] | undefined): string;
-    toStringTree(): string;
-    toString(): string;
-    toString(recog: Recognizer<any, any> | undefined): string;
-    toString(ruleNames: string[] | undefined): string;
-    toString(recog: Recognizer<any, any> | undefined, stop: RuleContext | undefined): string;
-    toString(ruleNames: string[] | undefined, stop: RuleContext | undefined): string;
-}

package/typings/antlr4ts/RuleContextWithAltNum.d.ts

@@ -1,22 +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 { ParserRuleContext } from "./ParserRuleContext";
-/** A handy class for use with
- *
- *  options {contextSuperClass=org.antlr.v4.runtime.RuleContextWithAltNum;}
- *
- *  that provides a backing field / impl for the outer alternative number
- *  matched for an internal parse tree node.
- *
- *  I'm only putting into Java runtime as I'm certain I'm the only one that
- *  will really every use this.
- */
-export declare class RuleContextWithAltNum extends ParserRuleContext {
-    private _altNumber;
-    constructor();
-    constructor(parent: ParserRuleContext | undefined, invokingStateNumber: number);
-    get altNumber(): number;
-    set altNumber(altNum: number);
-}

package/typings/antlr4ts/RuleDependency.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 { Dependents } from "./Dependents";
-import { Parser } from "./Parser";
-/**
- * Declares a dependency upon a grammar rule, along with a set of zero or more dependent rules.
- *
- * Version numbers within a grammar should be assigned on a monotonically increasing basis to allow for accurate
- * tracking of dependent rules.
- *
- * @author Sam Harwell
- */
-export declare function RuleDependency(dependency: DependencySpecification): (target: object, propertyKey: PropertyKey, propertyDescriptor: PropertyDescriptor) => void;
-export interface DependencySpecification {
-    readonly recognizer: {
-        new (...args: any[]): Parser;
-    };
-    readonly rule: number;
-    readonly version: number;
-    /**
-     * Specifies the set of grammar rules related to `rule` which the annotated element depends on. Even when absent
-     * from this set, the annotated element is implicitly dependent upon the explicitly specified `rule`, which
-     * corresponds to the `Dependents.SELF` element.
-     *
-     * By default, the annotated element is dependent upon the specified `rule` and its `Dependents.PARENTS`, i.e. the
-     * rule within one level of context information. The parents are included since the most frequent assumption about a
-     * rule is where it's used in the grammar.
-     */
-    readonly dependents?: Dependents[];
-}

package/typings/antlr4ts/RuleVersion.d.ts

@@ -1,11 +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";
-/**
- *
- * @author Sam Harwell
- */
-export declare function RuleVersion(version: number): <T extends ParserRuleContext>(target: Parser, propertyKey: PropertyKey, propertyDescriptor: TypedPropertyDescriptor<(...args: any[]) => T>) => void;

package/typings/antlr4ts/Token.d.ts

@@ -1,83 +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 { TokenSource } from "./TokenSource";
-/** A token has properties: text, type, line, character position in the line
- *  (so we can ignore tabs), token channel, index, and source from which
- *  we obtained this token.
- */
-export interface Token {
-    /**
-     * Get the text of the token.
-     */
-    readonly text: string | undefined;
-    /** Get the token type of the token */
-    readonly type: number;
-    /** The line number on which the 1st character of this token was matched,
-     *  line=1..n
-     */
-    readonly line: number;
-    /** The index of the first character of this token relative to the
-     *  beginning of the line at which it occurs, 0..n-1
-     */
-    readonly charPositionInLine: number;
-    /** Return the channel this token. Each token can arrive at the parser
-     *  on a different channel, but the parser only "tunes" to a single channel.
-     *  The parser ignores everything not on DEFAULT_CHANNEL.
-     */
-    readonly channel: number;
-    /** An index from 0..n-1 of the token object in the input stream.
-     *  This must be valid in order to print token streams and
-     *  use TokenRewriteStream.
-     *
-     *  Return -1 to indicate that this token was conjured up since
-     *  it doesn't have a valid index.
-     */
-    readonly tokenIndex: number;
-    /** The starting character index of the token
-     *  This method is optional; return -1 if not implemented.
-     */
-    readonly startIndex: number;
-    /** The last character index of the token.
-     *  This method is optional; return -1 if not implemented.
-     */
-    readonly stopIndex: number;
-    /** Gets the {@link TokenSource} which created this token.
-     */
-    readonly tokenSource: TokenSource | undefined;
-    /**
-     * Gets the {@link CharStream} from which this token was derived.
-     */
-    readonly inputStream: CharStream | undefined;
-}
-export declare namespace Token {
-    const INVALID_TYPE: number;
-    /** During lookahead operations, this "token" signifies we hit rule end ATN state
-     *  and did not follow it despite needing to.
-     */
-    const EPSILON: number;
-    const MIN_USER_TOKEN_TYPE: number;
-    const EOF: number;
-    /** All tokens go to the parser (unless skip() is called in that rule)
-     *  on a particular "channel".  The parser tunes to a particular channel
-     *  so that whitespace etc... can go to the parser on a "hidden" channel.
-     */
-    const DEFAULT_CHANNEL: number;
-    /** Anything on different channel than DEFAULT_CHANNEL is not parsed
-     *  by parser.
-     */
-    const HIDDEN_CHANNEL: number;
-    /**
-     * This is the minimum constant value which can be assigned to a
-     * user-defined token channel.
-     *
-     * The non-negative numbers less than {@link #MIN_USER_CHANNEL_VALUE} are
-     * assigned to the predefined channels {@link #DEFAULT_CHANNEL} and
-     * {@link #HIDDEN_CHANNEL}.
-     *
-     * @see `Token.channel`
-     */
-    const MIN_USER_CHANNEL_VALUE: number;
-}