@opra/client 0.10.0 → 0.11.0

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

@@ -0,0 +1,123 @@
+/*!
+ * 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 { ATNType } from "./ATNType";
+import { DecisionState } from "./DecisionState";
+import { DFA } from "../dfa/DFA";
+import { IntervalSet } from "../misc/IntervalSet";
+import { LexerAction } from "./LexerAction";
+import { PredictionContext } from "./PredictionContext";
+import { RuleContext } from "../RuleContext";
+import { RuleStartState } from "./RuleStartState";
+import { RuleStopState } from "./RuleStopState";
+import { TokensStartState } from "./TokensStartState";
+/** */
+export declare class ATN {
+    readonly states: ATNState[];
+    /** Each subrule/rule is a decision point and we must track them so we
+     *  can go back later and build DFA predictors for them.  This includes
+     *  all the rules, subrules, optional blocks, ()+, ()* etc...
+     */
+    decisionToState: DecisionState[];
+    /**
+     * Maps from rule index to starting state number.
+     */
+    ruleToStartState: RuleStartState[];
+    /**
+     * Maps from rule index to stop state number.
+     */
+    ruleToStopState: RuleStopState[];
+    modeNameToStartState: Map<string, TokensStartState>;
+    /**
+     * The type of the ATN.
+     */
+    grammarType: ATNType;
+    /**
+     * The maximum value for any symbol recognized by a transition in the ATN.
+     */
+    maxTokenType: number;
+    /**
+     * For lexer ATNs, this maps the rule index to the resulting token type.
+     * For parser ATNs, this maps the rule index to the generated bypass token
+     * type if the
+     * {@link ATNDeserializationOptions#isGenerateRuleBypassTransitions}
+     * deserialization option was specified; otherwise, this is `undefined`.
+     */
+    ruleToTokenType: Int32Array;
+    /**
+     * For lexer ATNs, this is an array of {@link LexerAction} objects which may
+     * be referenced by action transitions in the ATN.
+     */
+    lexerActions: LexerAction[];
+    modeToStartState: TokensStartState[];
+    private contextCache;
+    decisionToDFA: DFA[];
+    modeToDFA: DFA[];
+    LL1Table: Map<number, number>;
+    /** Used for runtime deserialization of ATNs from strings */
+    constructor(grammarType: ATNType, maxTokenType: number);
+    clearDFA(): void;
+    get contextCacheSize(): number;
+    getCachedContext(context: PredictionContext): PredictionContext;
+    getDecisionToDFA(): DFA[];
+    /** Compute the set of valid tokens that can occur starting in state `s`.
+     *  If `ctx` is {@link PredictionContext#EMPTY_LOCAL}, the set of tokens will not include what can follow
+     *  the rule surrounding `s`. In other words, the set will be
+     *  restricted to tokens reachable staying within `s`'s rule.
+     */
+    nextTokens(s: ATNState, /*@NotNull*/ ctx: PredictionContext): IntervalSet;
+    /**
+     * Compute the set of valid tokens that can occur starting in `s` and
+     * staying in same rule. {@link Token#EPSILON} is in set if we reach end of
+     * rule.
+     */
+    nextTokens(/*@NotNull*/ s: ATNState): IntervalSet;
+    addState(state: ATNState): void;
+    removeState(state: ATNState): void;
+    defineMode(name: string, s: TokensStartState): void;
+    defineDecisionState(s: DecisionState): number;
+    getDecisionState(decision: number): DecisionState | undefined;
+    get numberOfDecisions(): number;
+    /**
+     * Computes the set of input symbols which could follow ATN state number
+     * `stateNumber` in the specified full `context`. This method
+     * considers the complete parser context, but does not evaluate semantic
+     * predicates (i.e. all predicates encountered during the calculation are
+     * assumed true). If a path in the ATN exists from the starting state to the
+     * {@link RuleStopState} of the outermost context without matching any
+     * symbols, {@link Token#EOF} is added to the returned set.
+     *
+     * If `context` is `undefined`, it is treated as
+     * {@link ParserRuleContext#EMPTY}.
+     *
+     * Note that this does NOT give you the set of all tokens that could
+     * appear at a given token position in the input phrase.  In other words, it
+     * does not answer:
+     *
+     * > Given a specific partial input phrase, return the set of all
+     * > tokens that can follow the last token in the input phrase.
+     *
+     * The big difference is that with just the input, the parser could land
+     * right in the middle of a lookahead decision. Getting all
+     * *possible* tokens given a partial input stream is a separate
+     * computation. See https://github.com/antlr/antlr4/issues/1428
+     *
+     * For this function, we are specifying an ATN state and call stack to
+     * compute what token(s) can come next and specifically: outside of a
+     * lookahead decision. That is what you want for error reporting and
+     * recovery upon parse error.
+     *
+     * @param stateNumber the ATN state number
+     * @param context the full parse context
+     * @returns The set of potentially valid input symbols which could follow the
+     * specified state in the specified context.
+     * @ if the ATN does not contain a state with
+     * number `stateNumber`
+     */
+    getExpectedTokens(stateNumber: number, context: RuleContext | undefined): IntervalSet;
+}
+export declare namespace ATN {
+    const INVALID_ALT_NUMBER: number;
+}

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

@@ -0,0 +1,140 @@
+/*!
+ * 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 { Equatable } from "../misc/Stubs";
+import { LexerActionExecutor } from "./LexerActionExecutor";
+import { PredictionContext } from "./PredictionContext";
+import { PredictionContextCache } from "./PredictionContextCache";
+import { Recognizer } from "../Recognizer";
+import { SemanticContext } from "./SemanticContext";
+/**
+ * Represents a location with context in an ATN. The location is identified by the following values:
+ *
+ * * The current ATN state
+ * * The predicted alternative
+ * * The semantic context which must be true for this configuration to be enabled
+ * * The syntactic context, which is represented as a graph-structured stack whose path(s) lead to the root of the rule
+ *   invocations leading to this state
+ *
+ * In addition to these values, `ATNConfig` stores several properties about paths taken to get to the location which
+ * were added over time to help with performance, correctness, and/or debugging.
+ *
+ * * `reachesIntoOuterContext`:: Used to ensure semantic predicates are not evaluated in the wrong context.
+ * * `hasPassedThroughNonGreedyDecision`: Used for enabling first-match-wins instead of longest-match-wins after
+ *   crossing a non-greedy decision.
+ * * `lexerActionExecutor`: Used for tracking the lexer action(s) to execute should this instance be selected during
+ *   lexing.
+ * * `isPrecedenceFilterSuppressed`: A state variable for one of the dynamic disambiguation strategies employed by
+ *   `ParserATNSimulator.applyPrecedenceFilter`.
+ *
+ * Due to the use of a graph-structured stack, a single `ATNConfig` is capable of representing many individual ATN
+ * configurations which reached the same location in an ATN by following different paths.
+ *
+ * PERF: To conserve memory, `ATNConfig` is split into several different concrete types. `ATNConfig` itself stores the
+ * minimum amount of information typically used to define an `ATNConfig` instance. Various derived types provide
+ * additional storage space for cases where a non-default value is used for some of the object properties. The
+ * `ATNConfig.create` and `ATNConfig.transform` methods automatically select the smallest concrete type capable of
+ * representing the unique information for any given `ATNConfig`.
+ */
+export declare class ATNConfig implements Equatable {
+    /** The ATN state associated with this configuration */
+    private _state;
+    /**
+     * This is a bit-field currently containing the following values.
+     *
+     * * 0x00FFFFFF: Alternative
+     * * 0x7F000000: Outer context depth
+     * * 0x80000000: Suppress precedence filter
+     */
+    private altAndOuterContextDepth;
+    /** The stack of invoking states leading to the rule/states associated
+     *  with this config.  We track only those contexts pushed during
+     *  execution of the ATN simulator.
+     */
+    private _context;
+    constructor(/*@NotNull*/ state: ATNState, alt: number, /*@NotNull*/ context: PredictionContext);
+    constructor(/*@NotNull*/ state: ATNState, /*@NotNull*/ c: ATNConfig, /*@NotNull*/ context: PredictionContext);
+    static create(/*@NotNull*/ state: ATNState, alt: number, context: PredictionContext): ATNConfig;
+    static create(/*@NotNull*/ state: ATNState, alt: number, context: PredictionContext, /*@NotNull*/ semanticContext: SemanticContext): ATNConfig;
+    static create(/*@NotNull*/ state: ATNState, alt: number, context: PredictionContext, /*@*/ semanticContext: SemanticContext, lexerActionExecutor: LexerActionExecutor | undefined): ATNConfig;
+    /** Gets the ATN state associated with this configuration */
+    get state(): ATNState;
+    /** What alt (or lexer rule) is predicted by this configuration */
+    get alt(): number;
+    get context(): PredictionContext;
+    set context(context: PredictionContext);
+    get reachesIntoOuterContext(): boolean;
+    /**
+     * We cannot execute predicates dependent upon local context unless
+     * we know for sure we are in the correct context. Because there is
+     * no way to do this efficiently, we simply cannot evaluate
+     * dependent predicates unless we are in the rule that initially
+     * invokes the ATN simulator.
+     *
+     * closure() tracks the depth of how far we dip into the outer context:
+     * depth > 0.  Note that it may not be totally accurate depth since I
+     * don't ever decrement. TODO: make it a boolean then
+     */
+    get outerContextDepth(): number;
+    set outerContextDepth(outerContextDepth: number);
+    get lexerActionExecutor(): LexerActionExecutor | undefined;
+    get semanticContext(): SemanticContext;
+    get hasPassedThroughNonGreedyDecision(): boolean;
+    clone(): ATNConfig;
+    transform(/*@NotNull*/ state: ATNState, checkNonGreedy: boolean): ATNConfig;
+    transform(/*@NotNull*/ state: ATNState, checkNonGreedy: boolean, /*@NotNull*/ semanticContext: SemanticContext): ATNConfig;
+    transform(/*@NotNull*/ state: ATNState, checkNonGreedy: boolean, context: PredictionContext): ATNConfig;
+    transform(/*@NotNull*/ state: ATNState, checkNonGreedy: boolean, lexerActionExecutor: LexerActionExecutor): ATNConfig;
+    private transformImpl;
+    private static checkNonGreedyDecision;
+    appendContext(context: number, contextCache: PredictionContextCache): ATNConfig;
+    appendContext(context: PredictionContext, contextCache: PredictionContextCache): ATNConfig;
+    /**
+     * Determines if this `ATNConfig` fully contains another `ATNConfig`.
+     *
+     * An ATN configuration represents a position (including context) in an ATN during parsing. Since `ATNConfig` stores
+     * the context as a graph, a single `ATNConfig` instance is capable of representing many ATN configurations which
+     * are all in the same "location" but have different contexts. These `ATNConfig` instances are again merged when
+     * they are added to an `ATNConfigSet`. This method supports `ATNConfigSet.contains` by evaluating whether a
+     * particular `ATNConfig` contains all of the ATN configurations represented by another `ATNConfig`.
+     *
+     * An `ATNConfig` _a_ contains another `ATNConfig` _b_ if all of the following conditions are met:
+     *
+     * * The configurations are in the same state (`state`)
+     * * The configurations predict the same alternative (`alt`)
+     * * The semantic context of _a_ implies the semantic context of _b_ (this method performs a weaker equality check)
+     * * Joining the prediction contexts of _a_ and _b_ results in the prediction context of _a_
+     *
+     * This method implements a conservative approximation of containment. As a result, when this method returns `true`
+     * it is known that parsing from `subconfig` can only recognize a subset of the inputs which can be recognized
+     * starting at the current `ATNConfig`. However, due to the imprecise evaluation of implication for the semantic
+     * contexts, no assumptions can be made about the relationship between the configurations when this method returns
+     * `false`.
+     *
+     * @param subconfig The sub configuration.
+     * @returns `true` if this configuration contains `subconfig`; otherwise, `false`.
+     */
+    contains(subconfig: ATNConfig): boolean;
+    get isPrecedenceFilterSuppressed(): boolean;
+    set isPrecedenceFilterSuppressed(value: boolean);
+    /** An ATN configuration is equal to another if both have
+     *  the same state, they predict the same alternative, and
+     *  syntactic/semantic contexts are the same.
+     */
+    equals(o: any): boolean;
+    hashCode(): number;
+    /**
+     * Returns a graphical representation of the current `ATNConfig` in Graphviz format. The graph can be stored to a
+     * **.dot** file and then rendered to an image using Graphviz.
+     *
+     * @returns A Graphviz graph representing the current `ATNConfig`.
+     *
+     * @see http://www.graphviz.org/
+     */
+    toDotString(): string;
+    toString(): string;
+    toString(recog: Recognizer<any, any> | undefined, showAlt: boolean): string;
+    toString(recog: Recognizer<any, any> | undefined, showAlt: boolean, showContext: boolean): string;
+}

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

@@ -0,0 +1,113 @@
+/*!
+ * 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 { Array2DHashSet } from "../misc/Array2DHashSet";
+import { ATNConfig } from "./ATNConfig";
+import { ATNSimulator } from "./ATNSimulator";
+import { ATNState } from "./ATNState";
+import { BitSet } from "../misc/BitSet";
+import { ConflictInfo } from "./ConflictInfo";
+import { JavaSet } from "../misc/Stubs";
+import { PredictionContextCache } from "./PredictionContextCache";
+/**
+ * Represents a set of ATN configurations (see `ATNConfig`). As configurations are added to the set, they are merged
+ * with other `ATNConfig` instances already in the set when possible using the graph-structured stack.
+ *
+ * An instance of this class represents the complete set of positions (with context) in an ATN which would be associated
+ * with a single DFA state. Its internal representation is more complex than traditional state used for NFA to DFA
+ * conversion due to performance requirements (both improving speed and reducing memory overhead) as well as supporting
+ * features such as semantic predicates and non-greedy operators in a form to support ANTLR's prediction algorithm.
+ *
+ * @author Sam Harwell
+ */
+export declare class ATNConfigSet implements JavaSet<ATNConfig> {
+    /**
+     * This maps (state, alt) -> merged {@link ATNConfig}. The key does not account for
+     * the {@link ATNConfig#getSemanticContext} of the value, which is only a problem if a single
+     * `ATNConfigSet` contains two configs with the same state and alternative
+     * but different semantic contexts. When this case arises, the first config
+     * added to this map stays, and the remaining configs are placed in {@link #unmerged}.
+     *
+     * This map is only used for optimizing the process of adding configs to the set,
+     * and is `undefined` for read-only sets stored in the DFA.
+     */
+    private mergedConfigs?;
+    /**
+     * This is an "overflow" list holding configs which cannot be merged with one
+     * of the configs in {@link #mergedConfigs} but have a colliding key. This
+     * occurs when two configs in the set have the same state and alternative but
+     * different semantic contexts.
+     *
+     * This list is only used for optimizing the process of adding configs to the set,
+     * and is `undefined` for read-only sets stored in the DFA.
+     */
+    private unmerged?;
+    /**
+     * This is a list of all configs in this set.
+     */
+    private configs;
+    private _uniqueAlt;
+    private _conflictInfo?;
+    private _hasSemanticContext;
+    private _dipsIntoOuterContext;
+    /**
+     * When `true`, this config set represents configurations where the entire
+     * outer context has been consumed by the ATN interpreter. This prevents the
+     * {@link ParserATNSimulator#closure} from pursuing the global FOLLOW when a
+     * rule stop state is reached with an empty prediction context.
+     *
+     * Note: `outermostConfigSet` and {@link #dipsIntoOuterContext} should never
+     * be true at the same time.
+     */
+    private outermostConfigSet;
+    private cachedHashCode;
+    constructor();
+    constructor(set: ATNConfigSet, readonly: boolean);
+    /**
+     * Get the set of all alternatives represented by configurations in this
+     * set.
+     */
+    getRepresentedAlternatives(): BitSet;
+    get isReadOnly(): boolean;
+    get isOutermostConfigSet(): boolean;
+    set isOutermostConfigSet(outermostConfigSet: boolean);
+    getStates(): Array2DHashSet<ATNState>;
+    optimizeConfigs(interpreter: ATNSimulator): void;
+    clone(readonly: boolean): ATNConfigSet;
+    get size(): number;
+    get isEmpty(): boolean;
+    contains(o: any): boolean;
+    [Symbol.iterator](): IterableIterator<ATNConfig>;
+    toArray(): ATNConfig[];
+    add(e: ATNConfig): boolean;
+    add(e: ATNConfig, contextCache: PredictionContextCache | undefined): boolean;
+    private updatePropertiesForMergedConfig;
+    private updatePropertiesForAddedConfig;
+    protected canMerge(left: ATNConfig, leftKey: {
+        state: number;
+        alt: number;
+    }, right: ATNConfig): boolean;
+    protected getKey(e: ATNConfig): {
+        state: number;
+        alt: number;
+    };
+    containsAll(c: Iterable<any>): boolean;
+    addAll(c: Iterable<ATNConfig>): boolean;
+    addAll(c: Iterable<ATNConfig>, contextCache: PredictionContextCache): boolean;
+    clear(): void;
+    equals(obj: any): boolean;
+    hashCode(): number;
+    toString(): string;
+    toString(showContext: boolean): string;
+    get uniqueAlt(): number;
+    get hasSemanticContext(): boolean;
+    set hasSemanticContext(value: boolean);
+    get conflictInfo(): ConflictInfo | undefined;
+    set conflictInfo(conflictInfo: ConflictInfo | undefined);
+    get conflictingAlts(): BitSet | undefined;
+    get isExactConflict(): boolean;
+    get dipsIntoOuterContext(): boolean;
+    get(index: number): ATNConfig;
+    protected ensureWritable(): void;
+}

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

@@ -0,0 +1,26 @@
+/*!
+ * 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.
+ */
+/**
+ *
+ * @author Sam Harwell
+ */
+export declare class ATNDeserializationOptions {
+    private static _defaultOptions?;
+    private readOnly;
+    private verifyATN;
+    private generateRuleBypassTransitions;
+    private optimize;
+    constructor(options?: ATNDeserializationOptions);
+    static get defaultOptions(): ATNDeserializationOptions;
+    get isReadOnly(): boolean;
+    makeReadOnly(): void;
+    get isVerifyATN(): boolean;
+    set isVerifyATN(verifyATN: boolean);
+    get isGenerateRuleBypassTransitions(): boolean;
+    set isGenerateRuleBypassTransitions(generateRuleBypassTransitions: boolean);
+    get isOptimize(): boolean;
+    set isOptimize(optimize: boolean);
+    protected throwIfReadOnly(): void;
+}

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

@@ -0,0 +1,86 @@
+/*!
+ * 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 { ATN } from "./ATN";
+import { ATNDeserializationOptions } from "./ATNDeserializationOptions";
+import { ATNState } from "./ATNState";
+import { ATNStateType } from "./ATNStateType";
+import { IntervalSet } from "../misc/IntervalSet";
+import { LexerAction } from "./LexerAction";
+import { LexerActionType } from "./LexerActionType";
+import { Transition } from "./Transition";
+import { TransitionType } from "./TransitionType";
+import { UUID } from "../misc/UUID";
+/**
+ *
+ * @author Sam Harwell
+ */
+export declare class ATNDeserializer {
+    static get SERIALIZED_VERSION(): number;
+    /**
+     * This is the earliest supported serialized UUID.
+     */
+    private static readonly BASE_SERIALIZED_UUID;
+    /**
+     * This UUID indicates an extension of {@link #ADDED_PRECEDENCE_TRANSITIONS}
+     * for the addition of lexer actions encoded as a sequence of
+     * {@link LexerAction} instances.
+     */
+    private static readonly ADDED_LEXER_ACTIONS;
+    /**
+     * This UUID indicates the serialized ATN contains two sets of
+     * IntervalSets, where the second set's values are encoded as
+     * 32-bit integers to support the full Unicode SMP range up to U+10FFFF.
+     */
+    private static readonly ADDED_UNICODE_SMP;
+    /**
+     * This list contains all of the currently supported UUIDs, ordered by when
+     * the feature first appeared in this branch.
+     */
+    private static readonly SUPPORTED_UUIDS;
+    /**
+     * This is the current serialized UUID.
+     */
+    private static readonly SERIALIZED_UUID;
+    private readonly deserializationOptions;
+    constructor(deserializationOptions?: ATNDeserializationOptions);
+    /**
+     * Determines if a particular serialized representation of an ATN supports
+     * a particular feature, identified by the {@link UUID} used for serializing
+     * the ATN at the time the feature was first introduced.
+     *
+     * @param feature The {@link UUID} marking the first time the feature was
+     * supported in the serialized ATN.
+     * @param actualUuid The {@link UUID} of the actual serialized ATN which is
+     * currently being deserialized.
+     * @returns `true` if the `actualUuid` value represents a
+     * serialized ATN at or after the feature identified by `feature` was
+     * introduced; otherwise, `false`.
+     */
+    protected static isFeatureSupported(feature: UUID, actualUuid: UUID): boolean;
+    private static getUnicodeDeserializer;
+    deserialize(data: Uint16Array): ATN;
+    private deserializeSets;
+    /**
+     * Analyze the {@link StarLoopEntryState} states in the specified ATN to set
+     * the {@link StarLoopEntryState#precedenceRuleDecision} field to the
+     * correct value.
+     *
+     * @param atn The ATN.
+     */
+    protected markPrecedenceDecisions(atn: ATN): void;
+    protected verifyATN(atn: ATN): void;
+    protected checkCondition(condition: boolean, message?: string): void;
+    private static inlineSetRules;
+    private static combineChainedEpsilons;
+    private static optimizeSets;
+    private static identifyTailCalls;
+    private static testTailCall;
+    protected static toInt(c: number): number;
+    protected static toInt32(data: Uint16Array, offset: number): number;
+    protected static toUUID(data: Uint16Array, offset: number): UUID;
+    protected edgeFactory(atn: ATN, type: TransitionType, src: number, trg: number, arg1: number, arg2: number, arg3: number, sets: IntervalSet[]): Transition;
+    protected stateFactory(type: ATNStateType, ruleIndex: number): ATNState;
+    protected lexerActionFactory(type: LexerActionType, data1: number, data2: number): LexerAction;
+}

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

@@ -0,0 +1,28 @@
+/*!
+ * 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 { ATN } from "./ATN";
+import { DFAState } from "../dfa/DFAState";
+export declare abstract class ATNSimulator {
+    /** Must distinguish between missing edge and edge we know leads nowhere */
+    private static _ERROR;
+    static get ERROR(): DFAState;
+    atn: ATN;
+    constructor(atn: ATN);
+    abstract reset(): void;
+    /**
+     * Clear the DFA cache used by the current instance. Since the DFA cache may
+     * be shared by multiple ATN simulators, this method may affect the
+     * performance (but not accuracy) of other parsers which are being used
+     * concurrently.
+     *
+     * @ if the current instance does not
+     * support clearing the DFA.
+     *
+     * @since 4.3
+     */
+    clearDFA(): void;
+}
+export declare namespace ATNSimulator {
+}

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

@@ -0,0 +1,111 @@
+/*!
+ * 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 { ATN } from "./ATN";
+import { ATNStateType } from "./ATNStateType";
+import { IntervalSet } from "../misc/IntervalSet";
+import { Transition } from "./Transition";
+/**
+ * The following images show the relation of states and
+ * {@link ATNState#transitions} for various grammar constructs.
+ *
+ * * Solid edges marked with an ε indicate a required
+ *   {@link EpsilonTransition}.
+ *
+ * * Dashed edges indicate locations where any transition derived from
+ *   {@link Transition} might appear.
+ *
+ * * Dashed nodes are place holders for either a sequence of linked
+ *   {@link BasicState} states or the inclusion of a block representing a nested
+ *   construct in one of the forms below.
+ *
+ * * Nodes showing multiple outgoing alternatives with a `...` support
+ *   any number of alternatives (one or more). Nodes without the `...` only
+ *   support the exact number of alternatives shown in the diagram.
+ *
+ * <h2>Basic Blocks</h2>
+ *
+ * <h3>Rule</h3>
+ *
+ * <embed src="images/Rule.svg" type="image/svg+xml"/>
+ *
+ * <h3>Block of 1 or more alternatives</h3>
+ *
+ * <embed src="images/Block.svg" type="image/svg+xml"/>
+ *
+ * <h2>Greedy Loops</h2>
+ *
+ * <h3>Greedy Closure: `(...)*`</h3>
+ *
+ * <embed src="images/ClosureGreedy.svg" type="image/svg+xml"/>
+ *
+ * <h3>Greedy Positive Closure: `(...)+`</h3>
+ *
+ * <embed src="images/PositiveClosureGreedy.svg" type="image/svg+xml"/>
+ *
+ * <h3>Greedy Optional: `(...)?`</h3>
+ *
+ * <embed src="images/OptionalGreedy.svg" type="image/svg+xml"/>
+ *
+ * <h2>Non-Greedy Loops</h2>
+ *
+ * <h3>Non-Greedy Closure: `(...)*?`</h3>
+ *
+ * <embed src="images/ClosureNonGreedy.svg" type="image/svg+xml"/>
+ *
+ * <h3>Non-Greedy Positive Closure: `(...)+?`</h3>
+ *
+ * <embed src="images/PositiveClosureNonGreedy.svg" type="image/svg+xml"/>
+ *
+ * <h3>Non-Greedy Optional: `(...)??`</h3>
+ *
+ * <embed src="images/OptionalNonGreedy.svg" type="image/svg+xml"/>
+ */
+export declare abstract class ATNState {
+    /** Which ATN are we in? */
+    atn?: ATN;
+    stateNumber: number;
+    ruleIndex: number;
+    epsilonOnlyTransitions: boolean;
+    /** Track the transitions emanating from this ATN state. */
+    protected transitions: Transition[];
+    protected optimizedTransitions: Transition[];
+    /** Used to cache lookahead during parsing, not used during construction */
+    nextTokenWithinRule?: IntervalSet;
+    /**
+     * Gets the state number.
+     *
+     * @returns the state number
+     */
+    getStateNumber(): number;
+    /**
+     * For all states except {@link RuleStopState}, this returns the state
+     * number. Returns -1 for stop states.
+     *
+     * @returns -1 for {@link RuleStopState}, otherwise the state number
+     */
+    get nonStopStateNumber(): number;
+    hashCode(): number;
+    equals(o: any): boolean;
+    get isNonGreedyExitState(): boolean;
+    toString(): string;
+    getTransitions(): Transition[];
+    get numberOfTransitions(): number;
+    addTransition(e: Transition, index?: number): void;
+    transition(i: number): Transition;
+    setTransition(i: number, e: Transition): void;
+    removeTransition(index: number): Transition;
+    abstract readonly stateType: ATNStateType;
+    get onlyHasEpsilonTransitions(): boolean;
+    setRuleIndex(ruleIndex: number): void;
+    get isOptimized(): boolean;
+    get numberOfOptimizedTransitions(): number;
+    getOptimizedTransition(i: number): Transition;
+    addOptimizedTransition(e: Transition): void;
+    setOptimizedTransition(i: number, e: Transition): void;
+    removeOptimizedTransition(i: number): void;
+}
+export declare namespace ATNState {
+    const INVALID_STATE_NUMBER: number;
+}

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

@@ -0,0 +1,19 @@
+/*!
+ * 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 enum ATNStateType {
+    INVALID_TYPE = 0,
+    BASIC = 1,
+    RULE_START = 2,
+    BLOCK_START = 3,
+    PLUS_BLOCK_START = 4,
+    STAR_BLOCK_START = 5,
+    TOKEN_START = 6,
+    RULE_STOP = 7,
+    BLOCK_END = 8,
+    STAR_LOOP_BACK = 9,
+    STAR_LOOP_ENTRY = 10,
+    PLUS_LOOP_BACK = 11,
+    LOOP_END = 12
+}

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

@@ -0,0 +1,19 @@
+/*!
+ * 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.
+ */
+/**
+ * Represents the type of recognizer an ATN applies to.
+ *
+ * @author Sam Harwell
+ */
+export declare const enum ATNType {
+    /**
+     * A lexer grammar.
+     */
+    LEXER = 0,
+    /**
+     * A parser grammar.
+     */
+    PARSER = 1
+}