@opra/client 0.8.0 → 0.11.0

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

@@ -0,0 +1,268 @@
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+export declare class BitSet implements Iterable<number> {
+    private data;
+    /**
+     * Creates a new bit set. All bits are initially `false`.
+     */
+    constructor();
+    /**
+     * Creates a bit set whose initial size is large enough to explicitly represent bits with indices in the range `0`
+     * through `nbits-1`. All bits are initially `false`.
+     */
+    constructor(nbits: number);
+    /**
+     * Creates a bit set from a iterable list of numbers (including another BitSet);
+     */
+    constructor(numbers: Iterable<number>);
+    /**
+     * Performs a logical **AND** of this target bit set with the argument bit set. This bit set is modified so that
+     * each bit in it has the value `true` if and only if it both initially had the value `true` and the corresponding
+     * bit in the bit set argument also had the value `true`.
+     */
+    and(set: BitSet): void;
+    /**
+     * Clears all of the bits in this `BitSet` whose corresponding bit is set in the specified `BitSet`.
+     */
+    andNot(set: BitSet): void;
+    /**
+     * Returns the number of bits set to `true` in this `BitSet`.
+     */
+    cardinality(): number;
+    /**
+     * Sets all of the bits in this `BitSet` to `false`.
+     */
+    clear(): void;
+    /**
+     * Sets the bit specified by the index to `false`.
+     *
+     * @param bitIndex the index of the bit to be cleared
+     *
+     * @throws RangeError if the specified index is negative
+     */
+    clear(bitIndex: number): void;
+    /**
+     * Sets the bits from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive) to `false`.
+     *
+     * @param fromIndex index of the first bit to be cleared
+     * @param toIndex index after the last bit to be cleared
+     *
+     * @throws RangeError if `fromIndex` is negative, or `toIndex` is negative, or `fromIndex` is larger than `toIndex`
+     */
+    clear(fromIndex: number, toIndex: number): void;
+    /**
+     * Sets the bit at the specified index to the complement of its current value.
+     *
+     * @param bitIndex the index of the bit to flip
+     *
+     * @throws RangeError if the specified index is negative
+     */
+    flip(bitIndex: number): void;
+    /**
+     * Sets each bit from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive) to the complement
+     * of its current value.
+     *
+     * @param fromIndex index of the first bit to flip
+     * @param toIndex index after the last bit to flip
+     *
+     * @throws RangeError if `fromIndex` is negative, or `toIndex` is negative, or `fromIndex` is larger than `toIndex`
+     */
+    flip(fromIndex: number, toIndex: number): void;
+    /**
+     * Returns the value of the bit with the specified index. The value is `true` if the bit with the index `bitIndex`
+     * is currently set in this `BitSet`; otherwise, the result is `false`.
+     *
+     * @param bitIndex the bit index
+     *
+     * @throws RangeError if the specified index is negative
+     */
+    get(bitIndex: number): boolean;
+    /**
+     * Returns a new `BitSet` composed of bits from this `BitSet` from `fromIndex` (inclusive) to `toIndex` (exclusive).
+     *
+     * @param fromIndex index of the first bit to include
+     * @param toIndex index after the last bit to include
+     *
+     * @throws RangeError if `fromIndex` is negative, or `toIndex` is negative, or `fromIndex` is larger than `toIndex`
+     */
+    get(fromIndex: number, toIndex: number): BitSet;
+    /**
+     * Returns true if the specified `BitSet` has any bits set to `true` that are also set to `true` in this `BitSet`.
+     *
+     * @param set `BitSet` to intersect with
+     */
+    intersects(set: BitSet): boolean;
+    /**
+     * Returns true if this `BitSet` contains no bits that are set to `true`.
+     */
+    get isEmpty(): boolean;
+    /**
+     * Returns the "logical size" of this `BitSet`: the index of the highest set bit in the `BitSet` plus one. Returns
+     * zero if the `BitSet` contains no set bits.
+     */
+    length(): number;
+    /**
+     * Returns the index of the first bit that is set to `false` that occurs on or after the specified starting index,
+     * If no such bit exists then `-1` is returned.
+     *
+     * @param fromIndex the index to start checking from (inclusive)
+     *
+     * @throws RangeError if the specified index is negative
+     */
+    nextClearBit(fromIndex: number): number;
+    /**
+     * Returns the index of the first bit that is set to `true` that occurs on or after the specified starting index.
+     * If no such bit exists then `-1` is returned.
+     *
+     * To iterate over the `true` bits in a `BitSet`, use the following loop:
+     *
+     * ```
+     * for (let i = bs.nextSetBit(0); i >= 0; i = bs.nextSetBit(i + 1)) {
+     *   // operate on index i here
+     * }
+     * ```
+     *
+     * @param fromIndex the index to start checking from (inclusive)
+     *
+     * @throws RangeError if the specified index is negative
+     */
+    nextSetBit(fromIndex: number): number;
+    /**
+     * Performs a logical **OR** of this bit set with the bit set argument. This bit set is modified so that a bit in it
+     * has the value `true` if and only if it either already had the value `true` or the corresponding bit in the bit
+     * set argument has the value `true`.
+     */
+    or(set: BitSet): void;
+    /**
+     * Returns the index of the nearest bit that is set to `false` that occurs on or before the specified starting
+     * index. If no such bit exists, or if `-1` is given as the starting index, then `-1` is returned.
+     *
+     * @param fromIndex the index to start checking from (inclusive)
+     *
+     * @throws RangeError if the specified index is less than `-1`
+     */
+    previousClearBit(fromIndex: number): number;
+    /**
+     * Returns the index of the nearest bit that is set to `true` that occurs on or before the specified starting index.
+     * If no such bit exists, or if `-1` is given as the starting index, then `-1` is returned.
+     *
+     * To iterate over the `true` bits in a `BitSet`, use the following loop:
+     *
+     * ```
+     * for (let i = bs.length(); (i = bs.previousSetBit(i-1)) >= 0; ) {
+     *   // operate on index i here
+     * }
+     * ```
+     *
+     * @param fromIndex the index to start checking from (inclusive)
+     *
+     * @throws RangeError if the specified index is less than `-1`
+     */
+    previousSetBit(fromIndex: number): number;
+    /**
+     * Sets the bit at the specified index to `true`.
+     *
+     * @param bitIndex a bit index
+     *
+     * @throws RangeError if the specified index is negative
+     */
+    set(bitIndex: number): void;
+    /**
+     * Sets the bit at the specified index to the specified value.
+     *
+     * @param bitIndex a bit index
+     * @param value a boolean value to set
+     *
+     * @throws RangeError if the specified index is negative
+     */
+    set(bitIndex: number, value: boolean): void;
+    /**
+     * Sets the bits from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive) to `true`.
+     *
+     * @param fromIndex index of the first bit to be set
+     * @param toIndex index after the last bit to be set
+     *
+     * @throws RangeError if `fromIndex` is negative, or `toIndex` is negative, or `fromIndex` is larger than `toIndex`
+     */
+    set(fromIndex: number, toIndex: number): void;
+    /**
+     * Sets the bits from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive) to the specified
+     * value.
+     *
+     * @param fromIndex index of the first bit to be set
+     * @param toIndex index after the last bit to be set
+     * @param value value to set the selected bits to
+     *
+     * @throws RangeError if `fromIndex` is negative, or `toIndex` is negative, or `fromIndex` is larger than `toIndex`
+     */
+    set(fromIndex: number, toIndex: number, value: boolean): void;
+    private _setBits;
+    /**
+     * Returns the number of bits of space actually in use by this `BitSet` to represent bit values. The maximum element
+     * in the set is the size - 1st element.
+     */
+    get size(): number;
+    /**
+     * Returns a new byte array containing all the bits in this bit set.
+     *
+     * More precisely, if
+     * `let bytes = s.toByteArray();`
+     * then `bytes.length === (s.length()+7)/8` and `s.get(n) === ((bytes[n/8] & (1<<(n%8))) != 0)` for all
+     * `n < 8 * bytes.length`.
+     */
+    /**
+     * Returns a new integer array containing all the bits in this bit set.
+     *
+     * More precisely, if
+     * `let integers = s.toIntegerArray();`
+     * then `integers.length === (s.length()+31)/32` and `s.get(n) === ((integers[n/32] & (1<<(n%32))) != 0)` for all
+     * `n < 32 * integers.length`.
+     */
+    hashCode(): number;
+    /**
+     * Compares this object against the specified object. The result is `true` if and only if the argument is not
+     * `undefined` and is a `Bitset` object that has exactly the same set of bits set to `true` as this bit set. That
+     * is, for every nonnegative index `k`,
+     *
+     * ```
+     * ((BitSet)obj).get(k) == this.get(k)
+     * ```
+     *
+     * must be true. The current sizes of the two bit sets are not compared.
+     */
+    equals(obj: any): boolean;
+    /**
+     * Returns a string representation of this bit set. For every index for which this `BitSet` contains a bit in the
+     * set state, the decimal representation of that index is included in the result. Such indices are listed in order
+     * from lowest to highest, separated by ", " (a comma and a space) and surrounded by braces, resulting in the usual
+     * mathematical notation for a set of integers.
+     *
+     * Example:
+     *
+     *     BitSet drPepper = new BitSet();
+     *
+     * Now `drPepper.toString()` returns `"{}"`.
+     *
+     *     drPepper.set(2);
+     *
+     * Now `drPepper.toString()` returns `"{2}"`.
+     *
+     *     drPepper.set(4);
+     *     drPepper.set(10);
+     *
+     * Now `drPepper.toString()` returns `"{2, 4, 10}"`.
+     */
+    toString(): string;
+    /**
+     * Performs a logical **XOR** of this bit set with the bit set argument. This bit set is modified so that a bit in
+     * it has the value `true` if and only if one of the following statements holds:
+     *
+     * * The bit initially has the value `true`, and the corresponding bit in the argument has the value `false`.
+     * * The bit initially has the value `false`, and the corresponding bit in the argument has the value `true`.
+     */
+    xor(set: BitSet): void;
+    clone(): BitSet;
+    [Symbol.iterator](): IterableIterator<number>;
+}

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

@@ -0,0 +1,7 @@
+/*!
+ * 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 function isHighSurrogate(ch: number): boolean;
+export declare function isLowSurrogate(ch: number): boolean;
+export declare function isSupplementaryCodePoint(ch: number): boolean;

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

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

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

@@ -0,0 +1,29 @@
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+/**
+ * This interface provides an abstract concept of object equality independent of
+ * {@link Object#equals} (object equality) and the `==` operator
+ * (reference equality). It can be used to provide algorithm-specific unordered
+ * comparisons without requiring changes to the object itself.
+ *
+ * @author Sam Harwell
+ */
+export interface EqualityComparator<T> {
+    /**
+     * This method returns a hash code for the specified object.
+     *
+     * @param obj The object.
+     * @returns The hash code for `obj`.
+     */
+    hashCode(obj: T): number;
+    /**
+     * This method tests if two objects are equal.
+     *
+     * @param a The first object to compare.
+     * @param b The second object to compare.
+     * @returns `true` if `a` equals `b`, otherwise `false`.
+     */
+    equals(a: T, b: T): boolean;
+}

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

@@ -0,0 +1,129 @@
+/*!
+ * 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.
+ */
+/**
+ * A generic set of integers.
+ *
+ * @see IntervalSet
+ */
+export interface IntSet {
+    /**
+     * Adds the specified value to the current set.
+     *
+     * @param el the value to add
+     *
+     * @exception IllegalStateException if the current set is read-only
+     */
+    add(el: number): void;
+    /**
+     * Modify the current {@link IntSet} object to contain all elements that are
+     * present in itself, the specified `set`, or both.
+     *
+     * @param set The set to add to the current set. An `undefined` argument is
+     * treated as though it were an empty set.
+     * @returns `this` (to support chained calls)
+     *
+     * @exception IllegalStateException if the current set is read-only
+     */
+    addAll(/*@Nullable*/ set: IntSet): IntSet;
+    /**
+     * Return a new {@link IntSet} object containing all elements that are
+     * present in both the current set and the specified set `a`.
+     *
+     * @param a The set to intersect with the current set.
+     * @returns A new {@link IntSet} instance containing the intersection of the
+     * current set and `a`.
+     */
+    and(a: IntSet): IntSet;
+    /**
+     * Return a new {@link IntSet} object containing all elements that are
+     * present in `elements` but not present in the current set. The
+     * following expressions are equivalent for input non-`undefined` {@link IntSet}
+     * instances `x` and `y`.
+     *
+     * * `x.complement(y)`
+     * * `y.subtract(x)`
+     *
+     * @param elements The set to compare with the current set.
+     * @returns A new {@link IntSet} instance containing the elements present in
+     * `elements` but not present in the current set.
+     */
+    complement(elements: IntSet): IntSet;
+    /**
+     * Return a new {@link IntSet} object containing all elements that are
+     * present in the current set, the specified set `a`, or both.
+     *
+     * This method is similar to {@link #addAll(IntSet)}, but returns a new
+     * {@link IntSet} instance instead of modifying the current set.
+     *
+     * @param a The set to union with the current set. An `undefined` argument
+     * is treated as though it were an empty set.
+     * @returns A new {@link IntSet} instance containing the union of the current
+     * set and `a`. The value `undefined` may be returned in place of an
+     * empty result set.
+     */
+    or(/*@Nullable*/ a: IntSet): IntSet;
+    /**
+     * Return a new {@link IntSet} object containing all elements that are
+     * present in the current set but not present in the input set `a`.
+     * The following expressions are equivalent for input non-`undefined`
+     * {@link IntSet} instances `x` and `y`.
+     *
+     * * `y.subtract(x)`
+     * * `x.complement(y)`
+     *
+     * @param a The set to compare with the current set. A `undefined`
+     * argument is treated as though it were an empty set.
+     * @returns A new {@link IntSet} instance containing the elements present in
+     * `elements` but not present in the current set. The value
+     * `undefined` may be returned in place of an empty result set.
+     */
+    subtract(/*@Nullable*/ a: IntSet): IntSet;
+    /**
+     * Return the total number of elements represented by the current set.
+     *
+     * @returns the total number of elements represented by the current set,
+     * regardless of the manner in which the elements are stored.
+     */
+    readonly size: number;
+    /**
+     * Returns `true` if this set contains no elements.
+     *
+     * @returns `true` if the current set contains no elements; otherwise,
+     * `false`.
+     */
+    readonly isNil: boolean;
+    /**
+     * {@inheritDoc}
+     */
+    equals(obj: any): boolean;
+    /**
+     * Returns `true` if the set contains the specified element.
+     *
+     * @param el The element to check for.
+     * @returns `true` if the set contains `el`; otherwise `false`.
+     */
+    contains(el: number): boolean;
+    /**
+     * Removes the specified value from the current set. If the current set does
+     * not contain the element, no changes are made.
+     *
+     * @param el the value to remove
+     *
+     * @exception IllegalStateException if the current set is read-only
+     */
+    remove(el: number): void;
+    /**
+     * Return an array containing the elements represented by the current set. The
+     * array is returned in ascending numerical order.
+     *
+     * @returns An array containing all element present in the current set, sorted
+     * in ascending numerical order.
+     */
+    toArray(): number[];
+    /**
+     * {@inheritDoc}
+     */
+    toString(): string;
+}

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

@@ -0,0 +1,69 @@
+/*!
+ * 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 { JavaCollection } from "./Stubs";
+/**
+ *
+ * @author Sam Harwell
+ */
+export declare class IntegerList {
+    private _data;
+    private _size;
+    constructor(arg?: number | IntegerList | Iterable<number>);
+    add(value: number): void;
+    addAll(list: number[] | IntegerList | JavaCollection<number>): void;
+    get(index: number): number;
+    contains(value: number): boolean;
+    set(index: number, value: number): number;
+    removeAt(index: number): number;
+    removeRange(fromIndex: number, toIndex: number): void;
+    get isEmpty(): boolean;
+    get size(): number;
+    trimToSize(): void;
+    clear(): void;
+    toArray(): number[];
+    sort(): void;
+    /**
+     * Compares the specified object with this list for equality.  Returns
+     * `true` if and only if the specified object is also an {@link IntegerList},
+     * both lists have the same size, and all corresponding pairs of elements in
+     * the two lists are equal.  In other words, two lists are defined to be
+     * equal if they contain the same elements in the same order.
+     *
+     * This implementation first checks if the specified object is this
+     * list. If so, it returns `true`; if not, it checks if the
+     * specified object is an {@link IntegerList}. If not, it returns `false`;
+     * if so, it checks the size of both lists. If the lists are not the same size,
+     * it returns `false`; otherwise it iterates over both lists, comparing
+     * corresponding pairs of elements.  If any comparison returns `false`,
+     * this method returns `false`.
+     *
+     * @param o the object to be compared for equality with this list
+     * @returns `true` if the specified object is equal to this list
+     */
+    equals(o: any): boolean;
+    /**
+     * Returns the hash code value for this list.
+     *
+     * This implementation uses exactly the code that is used to define the
+     * list hash function in the documentation for the {@link List#hashCode}
+     * method.
+     *
+     * @returns the hash code value for this list
+     */
+    hashCode(): number;
+    /**
+     * Returns a string representation of this list.
+     */
+    toString(): string;
+    binarySearch(key: number, fromIndex?: number, toIndex?: number): number;
+    private ensureCapacity;
+    /** Convert the list to a UTF-16 encoded char array. If all values are less
+     *  than the 0xFFFF 16-bit code point limit then this is just a char array
+     *  of 16-bit char as usual. For values in the supplementary range, encode
+     * them as two UTF-16 code units.
+     */
+    toCharArray(): Uint16Array;
+    private charArraySize;
+}

package/typings/antlr4ts/misc/IntegerStack.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 { IntegerList } from "./IntegerList";
+/**
+ *
+ * @author Sam Harwell
+ */
+export declare class IntegerStack extends IntegerList {
+    constructor(arg?: number | IntegerStack);
+    push(value: number): void;
+    pop(): number;
+    peek(): number;
+}

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

@@ -0,0 +1,39 @@
+/*!
+ * 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 { Vocabulary } from "../Vocabulary";
+export declare namespace InterpreterDataReader {
+    /**
+     * The structure of the data file is very simple. Everything is line based with empty lines
+     * separating the different parts. For lexers the layout is:
+     * token literal names:
+     * ...
+     *
+     * token symbolic names:
+     * ...
+     *
+     * rule names:
+     * ...
+     *
+     * channel names:
+     * ...
+     *
+     * mode names:
+     * ...
+     *
+     * atn:
+     * <a single line with comma separated int values> enclosed in a pair of squared brackets.
+     *
+     * Data for a parser does not contain channel and mode names.
+     */
+    function parseFile(fileName: string): Promise<InterpreterDataReader.InterpreterData>;
+    class InterpreterData {
+        atn?: ATN;
+        vocabulary: Vocabulary;
+        ruleNames: string[];
+        channels?: string[];
+        modes?: string[];
+    }
+}

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

@@ -0,0 +1,57 @@
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+import { Equatable } from "./Stubs";
+/** An immutable inclusive interval a..b */
+export declare class Interval implements Equatable {
+    a: number;
+    b: number;
+    private static _INVALID;
+    static get INVALID(): Interval;
+    private static readonly cache;
+    /**
+     * @param a The start of the interval
+     * @param b The end of the interval (inclusive)
+     */
+    constructor(a: number, b: number);
+    /** Interval objects are used readonly so share all with the
+     *  same single value a==b up to some max size.  Use an array as a perfect hash.
+     *  Return shared object for 0..INTERVAL_POOL_MAX_VALUE or a new
+     *  Interval object with a..a in it.  On Java.g4, 218623 IntervalSets
+     *  have a..a (set with 1 element).
+     */
+    static of(a: number, b: number): Interval;
+    /** return number of elements between a and b inclusively. x..x is length 1.
+     *  if b < a, then length is 0.  9..10 has length 2.
+     */
+    get length(): number;
+    equals(o: any): boolean;
+    hashCode(): number;
+    /** Does this start completely before other? Disjoint */
+    startsBeforeDisjoint(other: Interval): boolean;
+    /** Does this start at or before other? Nondisjoint */
+    startsBeforeNonDisjoint(other: Interval): boolean;
+    /** Does this.a start after other.b? May or may not be disjoint */
+    startsAfter(other: Interval): boolean;
+    /** Does this start completely after other? Disjoint */
+    startsAfterDisjoint(other: Interval): boolean;
+    /** Does this start after other? NonDisjoint */
+    startsAfterNonDisjoint(other: Interval): boolean;
+    /** Are both ranges disjoint? I.e., no overlap? */
+    disjoint(other: Interval): boolean;
+    /** Are two intervals adjacent such as 0..41 and 42..42? */
+    adjacent(other: Interval): boolean;
+    properlyContains(other: Interval): boolean;
+    /** Return the interval computed from combining this and other */
+    union(other: Interval): Interval;
+    /** Return the interval in common between this and o */
+    intersection(other: Interval): Interval;
+    /** Return the interval with elements from `this` not in `other`;
+     *  `other` must not be totally enclosed (properly contained)
+     *  within `this`, which would result in two disjoint intervals
+     *  instead of the single one returned by this method.
+     */
+    differenceNotProperlyContained(other: Interval): Interval | undefined;
+    toString(): string;
+}