@opra/client 0.10.0 → 0.11.0

package/typings/antlr4ts/atn/PredicateTransition.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * 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 { AbstractPredicateTransition } from "./AbstractPredicateTransition";
+import { ATNState } from "./ATNState";
+import { SemanticContext } from "./SemanticContext";
+import { TransitionType } from "./TransitionType";
+/** TODO: this is old comment:
+ *  A tree of semantic predicates from the grammar AST if label==SEMPRED.
+ *  In the ATN, labels will always be exactly one predicate, but the DFA
+ *  may have to combine a bunch of them as it collects predicates from
+ *  multiple ATN configurations into a single DFA state.
+ */
+export declare class PredicateTransition extends AbstractPredicateTransition {
+    ruleIndex: number;
+    predIndex: number;
+    isCtxDependent: boolean;
+    constructor(target: ATNState, ruleIndex: number, predIndex: number, isCtxDependent: boolean);
+    get serializationType(): TransitionType;
+    get isEpsilon(): boolean;
+    matches(symbol: number, minVocabSymbol: number, maxVocabSymbol: number): boolean;
+    get predicate(): SemanticContext.Predicate;
+    toString(): string;
+}

package/typings/antlr4ts/atn/PredictionContext.d.ts

@@ -0,0 +1,89 @@
+/*!
+ * 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 { Array2DHashMap } from "../misc/Array2DHashMap";
+import { ATN } from "./ATN";
+import { EqualityComparator } from "../misc/EqualityComparator";
+import { Equatable } from "../misc/Stubs";
+import { PredictionContextCache } from "./PredictionContextCache";
+import { Recognizer } from "../Recognizer";
+import { RuleContext } from "../RuleContext";
+export declare abstract class PredictionContext implements Equatable {
+    /**
+     * Stores the computed hash code of this {@link PredictionContext}. The hash
+     * code is computed in parts to match the following reference algorithm.
+     *
+     * ```
+     * private int referenceHashCode() {
+     *   int hash = {@link MurmurHash#initialize MurmurHash.initialize}({@link #INITIAL_HASH});
+     *
+     *   for (int i = 0; i < this.size; i++) {
+     *     hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getParent getParent}(i));
+     *   }
+     *
+     *   for (int i = 0; i < this.size; i++) {
+     *     hash = {@link MurmurHash#update MurmurHash.update}(hash, {@link #getReturnState getReturnState}(i));
+     *   }
+     *
+     *   hash = {@link MurmurHash#finish MurmurHash.finish}(hash, 2 * this.size);
+     *   return hash;
+     * }
+     * ```
+     */
+    private readonly cachedHashCode;
+    constructor(cachedHashCode: number);
+    protected static calculateEmptyHashCode(): number;
+    protected static calculateSingleHashCode(parent: PredictionContext, returnState: number): number;
+    protected static calculateHashCode(parents: PredictionContext[], returnStates: number[]): number;
+    abstract readonly size: number;
+    abstract getReturnState(index: number): number;
+    abstract findReturnState(returnState: number): number;
+    abstract getParent(index: number): PredictionContext;
+    protected abstract addEmptyContext(): PredictionContext;
+    protected abstract removeEmptyContext(): PredictionContext;
+    static fromRuleContext(atn: ATN, outerContext: RuleContext, fullContext?: boolean): PredictionContext;
+    private static addEmptyContext;
+    private static removeEmptyContext;
+    static join(context0: PredictionContext, context1: PredictionContext, contextCache?: PredictionContextCache): PredictionContext;
+    static isEmptyLocal(context: PredictionContext): boolean;
+    static getCachedContext(context: PredictionContext, contextCache: Array2DHashMap<PredictionContext, PredictionContext>, visited: PredictionContext.IdentityHashMap): PredictionContext;
+    appendSingleContext(returnContext: number, contextCache: PredictionContextCache): PredictionContext;
+    abstract appendContext(suffix: PredictionContext, contextCache: PredictionContextCache): PredictionContext;
+    getChild(returnState: number): PredictionContext;
+    abstract readonly isEmpty: boolean;
+    abstract readonly hasEmpty: boolean;
+    hashCode(): number;
+    abstract equals(o: any): boolean;
+    toStrings(recognizer: Recognizer<any, any> | undefined, currentState: number, stop?: PredictionContext): string[];
+}
+export declare class SingletonPredictionContext extends PredictionContext {
+    parent: PredictionContext;
+    returnState: number;
+    constructor(parent: PredictionContext, returnState: number);
+    getParent(index: number): PredictionContext;
+    getReturnState(index: number): number;
+    findReturnState(returnState: number): number;
+    get size(): number;
+    get isEmpty(): boolean;
+    get hasEmpty(): boolean;
+    appendContext(suffix: PredictionContext, contextCache: PredictionContextCache): PredictionContext;
+    protected addEmptyContext(): PredictionContext;
+    protected removeEmptyContext(): PredictionContext;
+    equals(o: any): boolean;
+}
+export declare namespace PredictionContext {
+    const EMPTY_LOCAL: PredictionContext;
+    const EMPTY_FULL: PredictionContext;
+    const EMPTY_LOCAL_STATE_KEY: number;
+    const EMPTY_FULL_STATE_KEY: number;
+    class IdentityHashMap extends Array2DHashMap<PredictionContext, PredictionContext> {
+        constructor();
+    }
+    class IdentityEqualityComparator implements EqualityComparator<PredictionContext> {
+        static readonly INSTANCE: IdentityEqualityComparator;
+        private IdentityEqualityComparator;
+        hashCode(obj: PredictionContext): number;
+        equals(a: PredictionContext, b: PredictionContext): boolean;
+    }
+}

package/typings/antlr4ts/atn/PredictionContextCache.d.ts

@@ -0,0 +1,40 @@
+/*!
+ * 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 { PredictionContext } from "./PredictionContext";
+/** Used to cache {@link PredictionContext} objects. Its used for the shared
+ *  context cash associated with contexts in DFA states. This cache
+ *  can be used for both lexers and parsers.
+ *
+ * @author Sam Harwell
+ */
+export declare class PredictionContextCache {
+    static UNCACHED: PredictionContextCache;
+    private contexts;
+    private childContexts;
+    private joinContexts;
+    private enableCache;
+    constructor(enableCache?: boolean);
+    getAsCached(context: PredictionContext): PredictionContext;
+    getChild(context: PredictionContext, invokingState: number): PredictionContext;
+    join(x: PredictionContext, y: PredictionContext): PredictionContext;
+}
+export declare namespace PredictionContextCache {
+    class PredictionContextAndInt {
+        private obj;
+        private value;
+        constructor(obj: PredictionContext, value: number);
+        equals(obj: any): boolean;
+        hashCode(): number;
+    }
+    class IdentityCommutativePredictionContextOperands {
+        private _x;
+        private _y;
+        constructor(x: PredictionContext, y: PredictionContext);
+        get x(): PredictionContext;
+        get y(): PredictionContext;
+        equals(o: any): boolean;
+        hashCode(): number;
+    }
+}

package/typings/antlr4ts/atn/PredictionMode.d.ts

@@ -0,0 +1,89 @@
+/*!
+ * 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 "./ATNConfigSet";
+/**
+ * This enumeration defines the prediction modes available in ANTLR 4 along with
+ * utility methods for analyzing configuration sets for conflicts and/or
+ * ambiguities.
+ */
+export declare enum PredictionMode {
+    /**
+     * The SLL(*) prediction mode. This prediction mode ignores the current
+     * parser context when making predictions. This is the fastest prediction
+     * mode, and provides correct results for many grammars. This prediction
+     * mode is more powerful than the prediction mode provided by ANTLR 3, but
+     * may result in syntax errors for grammar and input combinations which are
+     * not SLL.
+     *
+     * When using this prediction mode, the parser will either return a correct
+     * parse tree (i.e. the same parse tree that would be returned with the
+     * {@link #LL} prediction mode), or it will report a syntax error. If a
+     * syntax error is encountered when using the {@link #SLL} prediction mode,
+     * it may be due to either an actual syntax error in the input or indicate
+     * that the particular combination of grammar and input requires the more
+     * powerful {@link #LL} prediction abilities to complete successfully.
+     *
+     * This prediction mode does not provide any guarantees for prediction
+     * behavior for syntactically-incorrect inputs.
+     */
+    SLL = 0,
+    /**
+     * The LL(*) prediction mode. This prediction mode allows the current parser
+     * context to be used for resolving SLL conflicts that occur during
+     * prediction. This is the fastest prediction mode that guarantees correct
+     * parse results for all combinations of grammars with syntactically correct
+     * inputs.
+     *
+     * When using this prediction mode, the parser will make correct decisions
+     * for all syntactically-correct grammar and input combinations. However, in
+     * cases where the grammar is truly ambiguous this prediction mode might not
+     * report a precise answer for *exactly which* alternatives are
+     * ambiguous.
+     *
+     * This prediction mode does not provide any guarantees for prediction
+     * behavior for syntactically-incorrect inputs.
+     */
+    LL = 1,
+    /**
+     * The LL(*) prediction mode with exact ambiguity detection. In addition to
+     * the correctness guarantees provided by the {@link #LL} prediction mode,
+     * this prediction mode instructs the prediction algorithm to determine the
+     * complete and exact set of ambiguous alternatives for every ambiguous
+     * decision encountered while parsing.
+     *
+     * This prediction mode may be used for diagnosing ambiguities during
+     * grammar development. Due to the performance overhead of calculating sets
+     * of ambiguous alternatives, this prediction mode should be avoided when
+     * the exact results are not necessary.
+     *
+     * This prediction mode does not provide any guarantees for prediction
+     * behavior for syntactically-incorrect inputs.
+     */
+    LL_EXACT_AMBIG_DETECTION = 2
+}
+export declare namespace PredictionMode {
+    /**
+     * Checks if any configuration in `configs` is in a
+     * {@link RuleStopState}. Configurations meeting this condition have reached
+     * the end of the decision rule (local context) or end of start rule (full
+     * context).
+     *
+     * @param configs the configuration set to test
+     * @returns `true` if any configuration in `configs` is in a
+     * {@link RuleStopState}, otherwise `false`
+     */
+    function hasConfigInRuleStopState(configs: ATNConfigSet): boolean;
+    /**
+     * Checks if all configurations in `configs` are in a
+     * {@link RuleStopState}. Configurations meeting this condition have reached
+     * the end of the decision rule (local context) or end of start rule (full
+     * context).
+     *
+     * @param configs the configuration set to test
+     * @returns `true` if all configurations in `configs` are in a
+     * {@link RuleStopState}, otherwise `false`
+     */
+    function allConfigsInRuleStopStates(/*@NotNull*/ configs: ATNConfigSet): boolean;
+}

package/typings/antlr4ts/atn/ProfilingATNSimulator.d.ts

@@ -0,0 +1,55 @@
+/*!
+ * 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 "./ATNConfigSet";
+import { BitSet } from "../misc/BitSet";
+import { DecisionInfo } from "./DecisionInfo";
+import { DFA } from "../dfa/DFA";
+import { DFAState } from "../dfa/DFAState";
+import { Parser } from "../Parser";
+import { ParserATNSimulator } from "./ParserATNSimulator";
+import { ParserRuleContext } from "../ParserRuleContext";
+import { PredictionContextCache } from "./PredictionContextCache";
+import { SemanticContext } from "./SemanticContext";
+import { SimulatorState } from "./SimulatorState";
+import { TokenStream } from "../TokenStream";
+/**
+ * @since 4.3
+ */
+export declare class ProfilingATNSimulator extends ParserATNSimulator {
+    protected decisions: DecisionInfo[];
+    protected numDecisions: number;
+    protected _input: TokenStream | undefined;
+    protected _startIndex: number;
+    protected _sllStopIndex: number;
+    protected _llStopIndex: number;
+    protected currentDecision: number;
+    protected currentState: SimulatorState | undefined;
+    /** At the point of LL failover, we record how SLL would resolve the conflict so that
+     *  we can determine whether or not a decision / input pair is context-sensitive.
+     *  If LL gives a different result than SLL's predicted alternative, we have a
+     *  context sensitivity for sure. The converse is not necessarily true, however.
+     *  It's possible that after conflict resolution chooses minimum alternatives,
+     *  SLL could get the same answer as LL. Regardless of whether or not the result indicates
+     *  an ambiguity, it is not treated as a context sensitivity because LL prediction
+     *  was not required in order to produce a correct prediction for this decision and input sequence.
+     *  It may in fact still be a context sensitivity but we don't know by looking at the
+     *  minimum alternatives for the current input.
+     */
+    protected conflictingAltResolvedBySLL: number;
+    constructor(parser: Parser);
+    adaptivePredict(/*@NotNull*/ input: TokenStream, decision: number, outerContext: ParserRuleContext | undefined): number;
+    adaptivePredict(/*@NotNull*/ input: TokenStream, decision: number, outerContext: ParserRuleContext | undefined, useContext: boolean): number;
+    protected getStartState(dfa: DFA, input: TokenStream, outerContext: ParserRuleContext, useContext: boolean): SimulatorState | undefined;
+    protected computeStartState(dfa: DFA, globalContext: ParserRuleContext, useContext: boolean): SimulatorState;
+    protected computeReachSet(dfa: DFA, previous: SimulatorState, t: number, contextCache: PredictionContextCache): SimulatorState | undefined;
+    protected getExistingTargetState(previousD: DFAState, t: number): DFAState | undefined;
+    protected computeTargetState(dfa: DFA, s: DFAState, remainingGlobalContext: ParserRuleContext, t: number, useContext: boolean, contextCache: PredictionContextCache): [DFAState, ParserRuleContext | undefined];
+    protected evalSemanticContextImpl(pred: SemanticContext, parserCallStack: ParserRuleContext, alt: number): boolean;
+    protected reportContextSensitivity(dfa: DFA, prediction: number, acceptState: SimulatorState, startIndex: number, stopIndex: number): void;
+    protected reportAttemptingFullContext(dfa: DFA, conflictingAlts: BitSet, conflictState: SimulatorState, startIndex: number, stopIndex: number): void;
+    protected reportAmbiguity(dfa: DFA, D: DFAState, startIndex: number, stopIndex: number, exact: boolean, ambigAlts: BitSet, configs: ATNConfigSet): void;
+    getDecisionInfo(): DecisionInfo[];
+    getCurrentState(): SimulatorState | undefined;
+}

package/typings/antlr4ts/atn/RangeTransition.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * 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 { ATNState } from "./ATNState";
+import { IntervalSet } from "../misc/IntervalSet";
+import { Transition } from "./Transition";
+import { TransitionType } from "./TransitionType";
+export declare class RangeTransition extends Transition {
+    from: number;
+    to: number;
+    constructor(target: ATNState, from: number, to: number);
+    get serializationType(): TransitionType;
+    get label(): IntervalSet;
+    matches(symbol: number, minVocabSymbol: number, maxVocabSymbol: number): boolean;
+    toString(): string;
+}

package/typings/antlr4ts/atn/RuleStartState.d.ts

@@ -0,0 +1,13 @@
+/*!
+ * 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 { ATNState } from "./ATNState";
+import { ATNStateType } from "./ATNStateType";
+import { RuleStopState } from "./RuleStopState";
+export declare class RuleStartState extends ATNState {
+    stopState: RuleStopState;
+    isPrecedenceRule: boolean;
+    leftFactored: boolean;
+    get stateType(): ATNStateType;
+}

package/typings/antlr4ts/atn/RuleStopState.d.ts

@@ -0,0 +1,15 @@
+/*!
+ * 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 { ATNState } from "./ATNState";
+import { ATNStateType } from "./ATNStateType";
+/** The last node in the ATN for a rule, unless that rule is the start symbol.
+ *  In that case, there is one transition to EOF. Later, we might encode
+ *  references to all calls to this rule to compute FOLLOW sets for
+ *  error handling.
+ */
+export declare class RuleStopState extends ATNState {
+    get nonStopStateNumber(): number;
+    get stateType(): ATNStateType;
+}

package/typings/antlr4ts/atn/RuleTransition.d.ts

@@ -0,0 +1,22 @@
+/*!
+ * 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 { ATNState } from "./ATNState";
+import { RuleStartState } from "./RuleStartState";
+import { Transition } from "./Transition";
+import { TransitionType } from "./TransitionType";
+/** */
+export declare class RuleTransition extends Transition {
+    /** Ptr to the rule definition object for this rule ref */
+    ruleIndex: number;
+    precedence: number;
+    /** What node to begin computations following ref to rule */
+    followState: ATNState;
+    tailCall: boolean;
+    optimizedTailCall: boolean;
+    constructor(ruleStart: RuleStartState, ruleIndex: number, precedence: number, followState: ATNState);
+    get serializationType(): TransitionType;
+    get isEpsilon(): boolean;
+    matches(symbol: number, minVocabSymbol: number, maxVocabSymbol: number): boolean;
+}

package/typings/antlr4ts/atn/SemanticContext.d.ts

@@ -0,0 +1,143 @@
+/*!
+ * 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 { Comparable } from "../misc/Stubs";
+import { Equatable } from "../misc/Stubs";
+import { Recognizer } from "../Recognizer";
+import { RuleContext } from "../RuleContext";
+/** A tree structure used to record the semantic context in which
+ *  an ATN configuration is valid.  It's either a single predicate,
+ *  a conjunction `p1&&p2`, or a sum of products `p1||p2`.
+ *
+ *  I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of
+ *  {@link SemanticContext} within the scope of this outer class.
+ */
+export declare abstract class SemanticContext implements Equatable {
+    private static _NONE;
+    /**
+     * The default {@link SemanticContext}, which is semantically equivalent to
+     * a predicate of the form `{true}?`.
+     */
+    static get NONE(): SemanticContext;
+    /**
+     * For context independent predicates, we evaluate them without a local
+     * context (i.e., unedfined context). That way, we can evaluate them without
+     * having to create proper rule-specific context during prediction (as
+     * opposed to the parser, which creates them naturally). In a practical
+     * sense, this avoids a cast exception from RuleContext to myruleContext.
+     *
+     * For context dependent predicates, we must pass in a local context so that
+     * references such as $arg evaluate properly as _localctx.arg. We only
+     * capture context dependent predicates in the context in which we begin
+     * prediction, so we passed in the outer context here in case of context
+     * dependent predicate evaluation.
+     */
+    abstract eval<T>(parser: Recognizer<T, any>, parserCallStack: RuleContext): boolean;
+    /**
+     * Evaluate the precedence predicates for the context and reduce the result.
+     *
+     * @param parser The parser instance.
+     * @param parserCallStack
+     * @returns The simplified semantic context after precedence predicates are
+     * evaluated, which will be one of the following values.
+     *
+     * * {@link #NONE}: if the predicate simplifies to `true` after
+     *   precedence predicates are evaluated.
+     * * `undefined`: if the predicate simplifies to `false` after
+     *   precedence predicates are evaluated.
+     * * `this`: if the semantic context is not changed as a result of
+     *   precedence predicate evaluation.
+     * * A non-`undefined` {@link SemanticContext}: the new simplified
+     *   semantic context after precedence predicates are evaluated.
+     */
+    evalPrecedence(parser: Recognizer<any, any>, parserCallStack: RuleContext): SemanticContext | undefined;
+    abstract hashCode(): number;
+    abstract equals(obj: any): boolean;
+    static and(a: SemanticContext | undefined, b: SemanticContext): SemanticContext;
+    /**
+     *
+     *  @see ParserATNSimulator#getPredsForAmbigAlts
+     */
+    static or(a: SemanticContext | undefined, b: SemanticContext): SemanticContext;
+}
+export declare namespace SemanticContext {
+    class Predicate extends SemanticContext {
+        ruleIndex: number;
+        predIndex: number;
+        isCtxDependent: boolean;
+        constructor();
+        constructor(ruleIndex: number, predIndex: number, isCtxDependent: boolean);
+        eval<T>(parser: Recognizer<T, any>, parserCallStack: RuleContext): boolean;
+        hashCode(): number;
+        equals(obj: any): boolean;
+        toString(): string;
+    }
+    class PrecedencePredicate extends SemanticContext implements Comparable<PrecedencePredicate> {
+        precedence: number;
+        constructor(precedence: number);
+        eval<T>(parser: Recognizer<T, any>, parserCallStack: RuleContext): boolean;
+        evalPrecedence(parser: Recognizer<any, any>, parserCallStack: RuleContext): SemanticContext | undefined;
+        compareTo(o: PrecedencePredicate): number;
+        hashCode(): number;
+        equals(obj: any): boolean;
+        toString(): string;
+    }
+    /**
+     * This is the base class for semantic context "operators", which operate on
+     * a collection of semantic context "operands".
+     *
+     * @since 4.3
+     */
+    abstract class Operator extends SemanticContext {
+        /**
+         * Gets the operands for the semantic context operator.
+         *
+         * @returns a collection of {@link SemanticContext} operands for the
+         * operator.
+         *
+         * @since 4.3
+         */
+        abstract readonly operands: Iterable<SemanticContext>;
+    }
+    /**
+     * A semantic context which is true whenever none of the contained contexts
+     * is false.
+     */
+    class AND extends Operator {
+        opnds: SemanticContext[];
+        constructor(a: SemanticContext, b: SemanticContext);
+        get operands(): Iterable<SemanticContext>;
+        equals(obj: any): boolean;
+        hashCode(): number;
+        /**
+         * {@inheritDoc}
+         *
+         * The evaluation of predicates by this context is short-circuiting, but
+         * unordered.
+         */
+        eval<T>(parser: Recognizer<T, any>, parserCallStack: RuleContext): boolean;
+        evalPrecedence(parser: Recognizer<any, any>, parserCallStack: RuleContext): SemanticContext | undefined;
+        toString(): string;
+    }
+    /**
+     * A semantic context which is true whenever at least one of the contained
+     * contexts is true.
+     */
+    class OR extends Operator {
+        opnds: SemanticContext[];
+        constructor(a: SemanticContext, b: SemanticContext);
+        get operands(): Iterable<SemanticContext>;
+        equals(obj: any): boolean;
+        hashCode(): number;
+        /**
+         * {@inheritDoc}
+         *
+         * The evaluation of predicates by this context is short-circuiting, but
+         * unordered.
+         */
+        eval<T>(parser: Recognizer<T, any>, parserCallStack: RuleContext): boolean;
+        evalPrecedence(parser: Recognizer<any, any>, parserCallStack: RuleContext): SemanticContext | undefined;
+        toString(): string;
+    }
+}

package/typings/antlr4ts/atn/SetTransition.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * 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 { ATNState } from "./ATNState";
+import { IntervalSet } from "../misc/IntervalSet";
+import { Transition } from "./Transition";
+import { TransitionType } from "./TransitionType";
+/** A transition containing a set of values. */
+export declare class SetTransition extends Transition {
+    set: IntervalSet;
+    constructor(target: ATNState, set: IntervalSet);
+    get serializationType(): TransitionType;
+    get label(): IntervalSet;
+    matches(symbol: number, minVocabSymbol: number, maxVocabSymbol: number): boolean;
+    toString(): string;
+}

package/typings/antlr4ts/atn/SimulatorState.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * 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 { DFAState } from "../dfa/DFAState";
+import { ParserRuleContext } from "../ParserRuleContext";
+/**
+ *
+ * @author Sam Harwell
+ */
+export declare class SimulatorState {
+    outerContext: ParserRuleContext;
+    s0: DFAState;
+    useContext: boolean;
+    remainingOuterContext: ParserRuleContext | undefined;
+    constructor(outerContext: ParserRuleContext, s0: DFAState, useContext: boolean, remainingOuterContext: ParserRuleContext | undefined);
+}

package/typings/antlr4ts/atn/StarBlockStartState.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * 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 { ATNStateType } from "./ATNStateType";
+import { BlockStartState } from "./BlockStartState";
+/** The block that begins a closure loop. */
+export declare class StarBlockStartState extends BlockStartState {
+    get stateType(): ATNStateType;
+}

package/typings/antlr4ts/atn/StarLoopEntryState.d.ts

@@ -0,0 +1,37 @@
+/*!
+ * 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 { ATNStateType } from "./ATNStateType";
+import { BitSet } from "../misc/BitSet";
+import { DecisionState } from "./DecisionState";
+import { StarLoopbackState } from "./StarLoopbackState";
+export declare class StarLoopEntryState extends DecisionState {
+    loopBackState: StarLoopbackState;
+    /**
+     * Indicates whether this state can benefit from a precedence DFA during SLL
+     * decision making.
+     *
+     * This is a computed property that is calculated during ATN deserialization
+     * and stored for use in {@link ParserATNSimulator} and
+     * {@link ParserInterpreter}.
+     *
+     * @see `DFA.isPrecedenceDfa`
+     */
+    precedenceRuleDecision: boolean;
+    /**
+     * For precedence decisions, this set marks states *S* which have all
+     * of the following characteristics:
+     *
+     * * One or more invocation sites of the current rule returns to
+     *   *S*.
+     * * The closure from *S* includes the current decision without
+     *   passing through any rule invocations or stepping out of the current
+     *   rule.
+     *
+     * This field is not used when {@link #precedenceRuleDecision} is
+     * `false`.
+     */
+    precedenceLoopbackStates: BitSet;
+    get stateType(): ATNStateType;
+}

package/typings/antlr4ts/atn/StarLoopbackState.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * 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 { ATNState } from "./ATNState";
+import { ATNStateType } from "./ATNStateType";
+import { StarLoopEntryState } from "./StarLoopEntryState";
+export declare class StarLoopbackState extends ATNState {
+    get loopEntryState(): StarLoopEntryState;
+    get stateType(): ATNStateType;
+}

package/typings/antlr4ts/atn/TokensStartState.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * 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 { ATNStateType } from "./ATNStateType";
+import { DecisionState } from "./DecisionState";
+/** The Tokens rule start state linking to each lexer rule start state */
+export declare class TokensStartState extends DecisionState {
+    get stateType(): ATNStateType;
+}