@opra/client 0.8.0 → 0.11.0

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

@@ -0,0 +1,38 @@
+/*!
+ * 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 { TransitionType } from "./TransitionType";
+/** An ATN transition between any two ATN states.  Subclasses define
+ *  atom, set, epsilon, action, predicate, rule transitions.
+ *
+ *  This is a one way link.  It emanates from a state (usually via a list of
+ *  transitions) and has a target state.
+ *
+ *  Since we never have to change the ATN transitions once we construct it,
+ *  we can fix these transitions as specific classes. The DFA transitions
+ *  on the other hand need to update the labels as it adds transitions to
+ *  the states. We'll use the term Edge for the DFA to distinguish them from
+ *  ATN transitions.
+ */
+export declare abstract class Transition {
+    static readonly serializationNames: string[];
+    /** The target of this transition. */
+    target: ATNState;
+    constructor(target: ATNState);
+    abstract readonly serializationType: TransitionType;
+    /**
+     * Determines if the transition is an "epsilon" transition.
+     *
+     * The default implementation returns `false`.
+     *
+     * @returns `true` if traversing this transition in the ATN does not
+     * consume an input symbol; otherwise, `false` if traversing this
+     * transition consumes (matches) an input symbol.
+     */
+    get isEpsilon(): boolean;
+    get label(): IntervalSet | undefined;
+    abstract matches(symbol: number, minVocabSymbol: number, maxVocabSymbol: number): boolean;
+}

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

@@ -0,0 +1,16 @@
+/*!
+ * 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 const enum TransitionType {
+    EPSILON = 1,
+    RANGE = 2,
+    RULE = 3,
+    PREDICATE = 4,
+    ATOM = 5,
+    ACTION = 6,
+    SET = 7,
+    NOT_SET = 8,
+    WILDCARD = 9,
+    PRECEDENCE = 10
+}

package/typings/antlr4ts/atn/WildcardTransition.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 { Transition } from "./Transition";
+import { TransitionType } from "./TransitionType";
+export declare class WildcardTransition extends Transition {
+    constructor(target: ATNState);
+    get serializationType(): TransitionType;
+    matches(symbol: number, minVocabSymbol: number, maxVocabSymbol: number): boolean;
+    toString(): string;
+}

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

@@ -0,0 +1,73 @@
+/*!
+ * 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 "./AbstractPredicateTransition";
+export * from "./ActionTransition";
+export * from "./AmbiguityInfo";
+export * from "./ATN";
+export * from "./ATNConfig";
+export * from "./ATNConfigSet";
+export * from "./ATNDeserializationOptions";
+export * from "./ATNDeserializer";
+export * from "./ATNSimulator";
+export * from "./ATNState";
+export * from "./ATNStateType";
+export * from "./ATNType";
+export * from "./AtomTransition";
+export * from "./BasicBlockStartState";
+export * from "./BasicState";
+export * from "./BlockEndState";
+export * from "./BlockStartState";
+export * from "./CodePointTransitions";
+export * from "./ConflictInfo";
+export * from "./ContextSensitivityInfo";
+export * from "./DecisionEventInfo";
+export * from "./DecisionInfo";
+export * from "./DecisionState";
+export * from "./EpsilonTransition";
+export * from "./ErrorInfo";
+export * from "./InvalidState";
+export * from "./LexerAction";
+export * from "./LexerActionExecutor";
+export * from "./LexerActionType";
+export * from "./LexerATNSimulator";
+export * from "./LexerChannelAction";
+export * from "./LexerCustomAction";
+export * from "./LexerIndexedCustomAction";
+export * from "./LexerModeAction";
+export * from "./LexerMoreAction";
+export * from "./LexerPopModeAction";
+export * from "./LexerPushModeAction";
+export * from "./LexerSkipAction";
+export * from "./LexerTypeAction";
+export * from "./LL1Analyzer";
+export * from "./LookaheadEventInfo";
+export * from "./LoopEndState";
+export * from "./NotSetTransition";
+export * from "./OrderedATNConfigSet";
+export * from "./ParseInfo";
+export * from "./ParserATNSimulator";
+export * from "./PlusBlockStartState";
+export * from "./PlusLoopbackState";
+export * from "./PrecedencePredicateTransition";
+export * from "./PredicateEvalInfo";
+export * from "./PredicateTransition";
+export * from "./PredictionContext";
+export * from "./PredictionContextCache";
+export * from "./PredictionMode";
+export * from "./ProfilingATNSimulator";
+export * from "./RangeTransition";
+export * from "./RuleStartState";
+export * from "./RuleStopState";
+export * from "./RuleTransition";
+export * from "./SemanticContext";
+export * from "./SetTransition";
+export * from "./SimulatorState";
+export * from "./StarBlockStartState";
+export * from "./StarLoopbackState";
+export * from "./StarLoopEntryState";
+export * from "./TokensStartState";
+export * from "./Transition";
+export * from "./TransitionType";
+export * from "./WildcardTransition";

package/typings/antlr4ts/dfa/AcceptStateInfo.d.ts

@@ -0,0 +1,33 @@
+/*!
+ * 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 { LexerActionExecutor } from "../atn/LexerActionExecutor";
+/**
+ * Stores information about a {@link DFAState} which is an accept state under
+ * some condition. Certain settings, such as
+ * {@link ParserATNSimulator#getPredictionMode()}, may be used in addition to
+ * this information to determine whether or not a particular state is an accept
+ * state.
+ *
+ * @author Sam Harwell
+ */
+export declare class AcceptStateInfo {
+    private readonly _prediction;
+    private readonly _lexerActionExecutor?;
+    constructor(prediction: number);
+    constructor(prediction: number, lexerActionExecutor: LexerActionExecutor | undefined);
+    /**
+     * Gets the prediction made by this accept state. Note that this value
+     * assumes the predicates, if any, in the {@link DFAState} evaluate to
+     * `true`. If predicate evaluation is enabled, the final prediction of
+     * the accept state will be determined by the result of predicate
+     * evaluation.
+     */
+    get prediction(): number;
+    /**
+     * Gets the {@link LexerActionExecutor} which can be used to execute actions
+     * and/or commands after the lexer matches a token.
+     */
+    get lexerActionExecutor(): LexerActionExecutor | undefined;
+}

package/typings/antlr4ts/dfa/DFA.d.ts

@@ -0,0 +1,94 @@
+/*!
+ * 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 { ATN } from "../atn/ATN";
+import { ATNState } from "../atn/ATNState";
+import { DecisionState } from "../atn/DecisionState";
+import { DFAState } from "./DFAState";
+import { TokensStartState } from "../atn/TokensStartState";
+import { Vocabulary } from "../Vocabulary";
+export declare class DFA {
+    /**
+     * A set of all states in the `DFA`.
+     *
+     * Note that this collection of states holds the DFA states for both SLL and LL prediction. Only the start state
+     * needs to be differentiated for these cases, which is tracked by the `s0` and `s0full` fields.
+     */
+    readonly states: Array2DHashSet<DFAState>;
+    s0: DFAState | undefined;
+    s0full: DFAState | undefined;
+    readonly decision: number;
+    /** From which ATN state did we create this DFA? */
+    atnStartState: ATNState;
+    /**
+     * Note: this field is accessed as `atnStartState.atn` in other targets. The TypeScript target keeps a separate copy
+     * to avoid a number of additional null/undefined checks each time the ATN is accessed.
+     */
+    atn: ATN;
+    private nextStateNumber;
+    /**
+     * `true` if this DFA is for a precedence decision; otherwise,
+     * `false`. This is the backing field for {@link #isPrecedenceDfa}.
+     */
+    private precedenceDfa;
+    /**
+     * Constructs a `DFA` instance associated with a lexer mode.
+     *
+     * The start state for a `DFA` constructed with this constructor should be a `TokensStartState`, which is the start
+     * state for a lexer mode. The prediction made by this DFA determines the lexer rule which matches the current
+     * input.
+     *
+     * @param atnStartState The start state for the mode.
+     */
+    constructor(atnStartState: TokensStartState);
+    /**
+     * Constructs a `DFA` instance associated with a decision.
+     *
+     * @param atnStartState The decision associated with this DFA.
+     * @param decision The decision number.
+     */
+    constructor(atnStartState: DecisionState, decision: number);
+    /**
+     * Gets whether this DFA is a precedence DFA. Precedence DFAs use a special
+     * start state {@link #s0} which is not stored in {@link #states}. The
+     * {@link DFAState#edges} array for this start state contains outgoing edges
+     * supplying individual start states corresponding to specific precedence
+     * values.
+     *
+     * @returns `true` if this is a precedence DFA; otherwise,
+     * `false`.
+     * @see Parser.precedence
+     */
+    get isPrecedenceDfa(): boolean;
+    /**
+     * Get the start state for a specific precedence value.
+     *
+     * @param precedence The current precedence.
+     * @returns The start state corresponding to the specified precedence, or
+     * `undefined` if no start state exists for the specified precedence.
+     *
+     * @ if this is not a precedence DFA.
+     * @see `isPrecedenceDfa`
+     */
+    getPrecedenceStartState(precedence: number, fullContext: boolean): DFAState | undefined;
+    /**
+     * Set the start state for a specific precedence value.
+     *
+     * @param precedence The current precedence.
+     * @param startState The start state corresponding to the specified
+     * precedence.
+     *
+     * @ if this is not a precedence DFA.
+     * @see `isPrecedenceDfa`
+     */
+    setPrecedenceStartState(precedence: number, fullContext: boolean, startState: DFAState): void;
+    get isEmpty(): boolean;
+    get isContextSensitive(): boolean;
+    addState(state: DFAState): DFAState;
+    toString(): string;
+    toString(/*@NotNull*/ vocabulary: Vocabulary): string;
+    toString(/*@NotNull*/ vocabulary: Vocabulary, ruleNames: string[] | undefined): string;
+    toLexerString(): string;
+}

package/typings/antlr4ts/dfa/DFASerializer.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * 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/ATN";
+import { DFA } from "./DFA";
+import { DFAState } from "./DFAState";
+import { Recognizer } from "../Recognizer";
+import { Vocabulary } from "../Vocabulary";
+/** A DFA walker that knows how to dump them to serialized strings. */
+export declare class DFASerializer {
+    private dfa;
+    private vocabulary;
+    ruleNames?: string[];
+    atn?: ATN;
+    constructor(/*@NotNull*/ dfa: DFA, /*@NotNull*/ vocabulary: Vocabulary);
+    constructor(/*@NotNull*/ dfa: DFA, /*@Nullable*/ parser: Recognizer<any, any> | undefined);
+    constructor(/*@NotNull*/ dfa: DFA, /*@NotNull*/ vocabulary: Vocabulary, /*@Nullable*/ ruleNames: string[] | undefined, /*@Nullable*/ atn: ATN | undefined);
+    toString(): string;
+    protected getContextLabel(i: number): string;
+    protected getEdgeLabel(i: number): string;
+    getStateString(s: DFAState): string;
+}

package/typings/antlr4ts/dfa/DFAState.d.ts

@@ -0,0 +1,95 @@
+/*!
+ * 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 { AcceptStateInfo } from "./AcceptStateInfo";
+import { ATN } from "../atn/ATN";
+import { ATNConfigSet } from "../atn/ATNConfigSet";
+import { LexerActionExecutor } from "../atn/LexerActionExecutor";
+import { SemanticContext } from "../atn/SemanticContext";
+/** A DFA state represents a set of possible ATN configurations.
+ *  As Aho, Sethi, Ullman p. 117 says "The DFA uses its state
+ *  to keep track of all possible states the ATN can be in after
+ *  reading each input symbol.  That is to say, after reading
+ *  input a1a2..an, the DFA is in a state that represents the
+ *  subset T of the states of the ATN that are reachable from the
+ *  ATN's start state along some path labeled a1a2..an."
+ *  In conventional NFA→DFA conversion, therefore, the subset T
+ *  would be a bitset representing the set of states the
+ *  ATN could be in.  We need to track the alt predicted by each
+ *  state as well, however.  More importantly, we need to maintain
+ *  a stack of states, tracking the closure operations as they
+ *  jump from rule to rule, emulating rule invocations (method calls).
+ *  I have to add a stack to simulate the proper lookahead sequences for
+ *  the underlying LL grammar from which the ATN was derived.
+ *
+ *  I use a set of ATNConfig objects not simple states.  An ATNConfig
+ *  is both a state (ala normal conversion) and a RuleContext describing
+ *  the chain of rules (if any) followed to arrive at that state.
+ *
+ *  A DFA state may have multiple references to a particular state,
+ *  but with different ATN contexts (with same or different alts)
+ *  meaning that state was reached via a different set of rule invocations.
+ */
+export declare class DFAState {
+    stateNumber: number;
+    configs: ATNConfigSet;
+    /** `edges.get(symbol)` points to target of symbol.
+     */
+    private readonly edges;
+    private _acceptStateInfo;
+    /** These keys for these edges are the top level element of the global context. */
+    private readonly contextEdges;
+    /** Symbols in this set require a global context transition before matching an input symbol. */
+    private contextSymbols;
+    /**
+     * This list is computed by {@link ParserATNSimulator#predicateDFAState}.
+     */
+    predicates: DFAState.PredPrediction[] | undefined;
+    /**
+     * Constructs a new `DFAState`.
+     *
+     * @param configs The set of ATN configurations defining this state.
+     */
+    constructor(configs: ATNConfigSet);
+    get isContextSensitive(): boolean;
+    isContextSymbol(symbol: number): boolean;
+    setContextSymbol(symbol: number): void;
+    setContextSensitive(atn: ATN): void;
+    get acceptStateInfo(): AcceptStateInfo | undefined;
+    set acceptStateInfo(acceptStateInfo: AcceptStateInfo | undefined);
+    get isAcceptState(): boolean;
+    get prediction(): number;
+    get lexerActionExecutor(): LexerActionExecutor | undefined;
+    getTarget(symbol: number): DFAState | undefined;
+    setTarget(symbol: number, target: DFAState): void;
+    getEdgeMap(): Map<number, DFAState>;
+    getContextTarget(invokingState: number): DFAState | undefined;
+    setContextTarget(invokingState: number, target: DFAState): void;
+    getContextEdgeMap(): Map<number, DFAState>;
+    hashCode(): number;
+    /**
+     * Two {@link DFAState} instances are equal if their ATN configuration sets
+     * are the same. This method is used to see if a state already exists.
+     *
+     * Because the number of alternatives and number of ATN configurations are
+     * finite, there is a finite number of DFA states that can be processed.
+     * This is necessary to show that the algorithm terminates.
+     *
+     * Cannot test the DFA state numbers here because in
+     * {@link ParserATNSimulator#addDFAState} we need to know if any other state
+     * exists that has this exact set of ATN configurations. The
+     * {@link #stateNumber} is irrelevant.
+     */
+    equals(o: any): boolean;
+    toString(): string;
+}
+export declare namespace DFAState {
+    /** Map a predicate to a predicted alternative. */
+    class PredPrediction {
+        pred: SemanticContext;
+        alt: number;
+        constructor(pred: SemanticContext, alt: number);
+        toString(): string;
+    }
+}

package/typings/antlr4ts/dfa/LexerDFASerializer.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 { DFA } from "./DFA";
+import { DFASerializer } from "./DFASerializer";
+export declare class LexerDFASerializer extends DFASerializer {
+    constructor(dfa: DFA);
+    protected getEdgeLabel(i: number): string;
+}

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

@@ -0,0 +1,9 @@
+/*!
+ * 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 "./AcceptStateInfo";
+export * from "./DFA";
+export * from "./DFASerializer";
+export * from "./DFAState";
+export * from "./LexerDFASerializer";

package/typings/antlr4ts/index.d.ts

@@ -0,0 +1,49 @@
+/*!
+ * 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 "./ANTLRErrorListener";
+export * from "./ANTLRErrorStrategy";
+export * from "./ANTLRInputStream";
+export * from "./BailErrorStrategy";
+export * from "./BufferedTokenStream";
+export * from "./CharStream";
+export * from "./CharStreams";
+export * from "./CodePointBuffer";
+export * from "./CodePointCharStream";
+export * from "./CommonToken";
+export * from "./CommonTokenFactory";
+export * from "./CommonTokenStream";
+export * from "./ConsoleErrorListener";
+export * from "./DefaultErrorStrategy";
+export * from "./Dependents";
+export * from "./DiagnosticErrorListener";
+export * from "./FailedPredicateException";
+export * from "./InputMismatchException";
+export * from "./InterpreterRuleContext";
+export * from "./IntStream";
+export * from "./Lexer";
+export * from "./LexerInterpreter";
+export * from "./LexerNoViableAltException";
+export * from "./ListTokenSource";
+export * from "./NoViableAltException";
+export * from "./Parser";
+export * from "./ParserErrorListener";
+export * from "./ParserInterpreter";
+export * from "./ParserRuleContext";
+export * from "./ProxyErrorListener";
+export * from "./ProxyParserErrorListener";
+export * from "./RecognitionException";
+export * from "./Recognizer";
+export * from "./RuleContext";
+export * from "./RuleContextWithAltNum";
+export * from "./RuleDependency";
+export * from "./RuleVersion";
+export * from "./Token";
+export * from "./TokenFactory";
+export * from "./TokenSource";
+export * from "./TokenStream";
+export * from "./TokenStreamRewriter";
+export * from "./Vocabulary";
+export * from "./VocabularyImpl";
+export * from "./WritableToken";

package/typings/antlr4ts/misc/Args.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.
+ */
+/**
+ * Validates that an argument is not `null` or `undefined`.
+ *
+ * @param parameterName The name of the parameter
+ * @param value The argument value
+ *
+ * @throws `TypeError` if `value` is `null` or `undefined`.
+ */
+export declare function notNull(parameterName: string, value: any): void;

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

@@ -0,0 +1,20 @@
+/*!
+ * 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 { JavaMap } from "./Stubs";
+export declare class Array2DHashMap<K, V> implements JavaMap<K, V> {
+    private backingStore;
+    constructor(keyComparer: EqualityComparator<K>);
+    constructor(map: Array2DHashMap<K, V>);
+    clear(): void;
+    containsKey(key: K): boolean;
+    get(key: K): V | undefined;
+    get isEmpty(): boolean;
+    put(key: K, value: V): V | undefined;
+    putIfAbsent(key: K, value: V): V | undefined;
+    get size(): number;
+    hashCode(): number;
+    equals(o: any): boolean;
+}

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

@@ -0,0 +1,62 @@
+/*!
+ * 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 { JavaCollection, JavaSet } from "./Stubs";
+export declare class Array2DHashSet<T extends {
+    toString(): string;
+}> implements JavaSet<T> {
+    protected comparator: EqualityComparator<T>;
+    protected buckets: Array<T[] | undefined>;
+    /** How many elements in set */
+    protected n: number;
+    protected threshold: number;
+    constructor(comparator?: EqualityComparator<T>, initialCapacity?: number);
+    constructor(set: Array2DHashSet<T>);
+    /**
+     * Add `o` to set if not there; return existing value if already
+     * there. This method performs the same operation as {@link #add} aside from
+     * the return value.
+     */
+    getOrAdd(o: T): T;
+    protected getOrAddImpl(o: T): T;
+    get(o: T): T | undefined;
+    protected getBucket(o: T): number;
+    hashCode(): number;
+    equals(o: any): boolean;
+    protected expand(): void;
+    add(t: T): boolean;
+    get size(): number;
+    get isEmpty(): boolean;
+    contains(o: any): boolean;
+    containsFast(obj: T): boolean;
+    [Symbol.iterator](): IterableIterator<T>;
+    toArray(): T[];
+    containsAll(collection: JavaCollection<T>): boolean;
+    addAll(c: Iterable<T>): boolean;
+    clear(): void;
+    toString(): string;
+    toTableString(): string;
+    /**
+     * Return `o` as an instance of the element type `T`. If
+     * `o` is non-undefined but known to not be an instance of `T`, this
+     * method returns `undefined`. The base implementation does not perform any
+     * type checks; override this method to provide strong type checks for the
+     * {@link #contains} and {@link #remove} methods to ensure the arguments to
+     * the {@link EqualityComparator} for the set always have the expected
+     * types.
+     *
+     * @param o the object to try and cast to the element type of the set
+     * @returns `o` if it could be an instance of `T`, otherwise
+     * `undefined`.
+     */
+    protected asElementType(o: any): T;
+    /**
+     * Return an array of `T[]` with length `capacity`.
+     *
+     * @param capacity the length of the array to return
+     * @returns the newly constructed array
+     */
+    protected createBuckets(capacity: number): Array<T[] | undefined>;
+}

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

@@ -0,0 +1,32 @@
+/*!
+ * 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 ArrayEqualityComparator implements EqualityComparator<Equatable[]> {
+    static readonly INSTANCE: ArrayEqualityComparator;
+    /**
+     * {@inheritDoc}
+     *
+     * This implementation returns
+     * `obj.`{@link Object#hashCode hashCode()}.
+     */
+    hashCode(obj: Equatable[]): number;
+    /**
+     * {@inheritDoc}
+     *
+     * This implementation relies on object equality. If both objects are
+     * `undefined`, this method returns `true`. Otherwise if only
+     * `a` is `undefined`, this method returns `false`. Otherwise,
+     * this method returns the result of
+     * `a.`{@link Object#equals equals}`(b)`.
+     */
+    equals(a: Equatable[], b: Equatable[]): boolean;
+}

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

@@ -0,0 +1,18 @@
+/*!
+ * 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 namespace Arrays {
+    /**
+     * Searches the specified array of numbers for the specified value using the binary search algorithm. The array must
+     * be sorted prior to making this call. If it is not sorted, the results are unspecified. If the array contains
+     * multiple elements with the specified value, there is no guarantee which one will be found.
+     *
+     * @returns index of the search key, if it is contained in the array; otherwise, (-(insertion point) - 1). The
+     * insertion point is defined as the point at which the key would be inserted into the array: the index of the first
+     * element greater than the key, or array.length if all elements in the array are less than the specified key. Note
+     * that this guarantees that the return value will be >= 0 if and only if the key is found.
+     */
+    function binarySearch(array: ArrayLike<number>, key: number, fromIndex?: number, toIndex?: number): number;
+    function toString<T>(array: Iterable<T>): string;
+}