@opra/client 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/client",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Opra Client package",
   "author": "Panates",
   "license": "MIT",

package/typings/antlr4ts/ANTLRErrorListener.d.ts

@@ -0,0 +1,43 @@
+/*!
+ * 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.
+ */
+/** How to emit recognition errors. */
+import { Recognizer } from "./Recognizer";
+import { RecognitionException } from "./RecognitionException";
+export interface ANTLRErrorListener<TSymbol> {
+    /**
+     * Upon syntax error, notify any interested parties. This is not how to
+     * recover from errors or compute error messages. {@link ANTLRErrorStrategy}
+     * specifies how to recover from syntax errors and how to compute error
+     * messages. This listener's job is simply to emit a computed message,
+     * though it has enough information to create its own message in many cases.
+     *
+     * The {@link RecognitionException} is non-`undefined` for all syntax errors except
+     * when we discover mismatched token errors that we can recover from
+     * in-line, without returning from the surrounding rule (via the single
+     * token insertion and deletion mechanism).
+     *
+     * @param recognizer
+     *        What parser got the error. From this
+     * 		  object, you can access the context as well
+     * 		  as the input stream.
+     * @param offendingSymbol
+     *        The offending token in the input token
+     * 		  stream, unless recognizer is a lexer (then it's `undefined`). If
+     * 		  no viable alternative error, `e` has token at which we
+     * 		  started production for the decision.
+     * @param line
+     * 		  The line number in the input where the error occurred.
+     * @param charPositionInLine
+     * 		  The character position within that line where the error occurred.
+     * @param msg
+     * 		  The message to emit.
+     * @param e
+     *        The exception generated by the parser that led to
+     *        the reporting of an error. It is `undefined` in the case where
+     *        the parser was able to recover in line without exiting the
+     *        surrounding rule.
+     */
+    syntaxError?: <T extends TSymbol>(recognizer: Recognizer<T, any>, offendingSymbol: T | undefined, line: number, charPositionInLine: number, msg: string, e: RecognitionException | undefined) => void;
+}

package/typings/antlr4ts/ANTLRErrorStrategy.d.ts

@@ -0,0 +1,109 @@
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+import { Parser } from "./Parser";
+import { Token } from "./Token";
+import { RecognitionException } from "./RecognitionException";
+/**
+ * The interface for defining strategies to deal with syntax errors encountered
+ * during a parse by ANTLR-generated parsers. We distinguish between three
+ * different kinds of errors:
+ *
+ * * The parser could not figure out which path to take in the ATN (none of
+ *   the available alternatives could possibly match)
+ * * The current input does not match what we were looking for
+ * * A predicate evaluated to false
+ *
+ * Implementations of this interface report syntax errors by calling
+ * {@link Parser#notifyErrorListeners}.
+ *
+ * TODO: what to do about lexers
+ */
+export interface ANTLRErrorStrategy {
+    /**
+     * Reset the error handler state for the specified `recognizer`.
+     * @param recognizer the parser instance
+     */
+    reset(/*@NotNull*/ recognizer: Parser): void;
+    /**
+     * This method is called when an unexpected symbol is encountered during an
+     * inline match operation, such as {@link Parser#match}. If the error
+     * strategy successfully recovers from the match failure, this method
+     * returns the {@link Token} instance which should be treated as the
+     * successful result of the match.
+     *
+     * This method handles the consumption of any tokens - the caller should
+     * *not* call {@link Parser#consume} after a successful recovery.
+     *
+     * Note that the calling code will not report an error if this method
+     * returns successfully. The error strategy implementation is responsible
+     * for calling {@link Parser#notifyErrorListeners} as appropriate.
+     *
+     * @param recognizer the parser instance
+     * @ if the error strategy was not able to
+     * recover from the unexpected input symbol
+     */
+    recoverInline(/*@NotNull*/ recognizer: Parser): Token;
+    /**
+     * This method is called to recover from exception `e`. This method is
+     * called after {@link #reportError} by the default exception handler
+     * generated for a rule method.
+     *
+     * @see #reportError
+     *
+     * @param recognizer the parser instance
+     * @param e the recognition exception to recover from
+     * @ if the error strategy could not recover from
+     * the recognition exception
+     */
+    recover(/*@NotNull*/ recognizer: Parser, /*@NotNull*/ e: RecognitionException): void;
+    /**
+     * This method provides the error handler with an opportunity to handle
+     * syntactic or semantic errors in the input stream before they result in a
+     * {@link RecognitionException}.
+     *
+     * The generated code currently contains calls to {@link #sync} after
+     * entering the decision state of a closure block (`(...)*` or
+     * `(...)+`).
+     *
+     * For an implementation based on Jim Idle's "magic sync" mechanism, see
+     * {@link DefaultErrorStrategy#sync}.
+     *
+     * @see DefaultErrorStrategy#sync
+     *
+     * @param recognizer the parser instance
+     * @ if an error is detected by the error
+     * strategy but cannot be automatically recovered at the current state in
+     * the parsing process
+     */
+    sync(/*@NotNull*/ recognizer: Parser): void;
+    /**
+     * Tests whether or not `recognizer` is in the process of recovering
+     * from an error. In error recovery mode, {@link Parser#consume} adds
+     * symbols to the parse tree by calling
+     * {@link Parser#createErrorNode(ParserRuleContext, Token)} then
+     * {@link ParserRuleContext#addErrorNode(ErrorNode)} instead of
+     * {@link Parser#createTerminalNode(ParserRuleContext, Token)}.
+     *
+     * @param recognizer the parser instance
+     * @returns `true` if the parser is currently recovering from a parse
+     * error, otherwise `false`
+     */
+    inErrorRecoveryMode(/*@NotNull*/ recognizer: Parser): boolean;
+    /**
+     * This method is called by when the parser successfully matches an input
+     * symbol.
+     *
+     * @param recognizer the parser instance
+     */
+    reportMatch(/*@NotNull*/ recognizer: Parser): void;
+    /**
+     * Report any kind of {@link RecognitionException}. This method is called by
+     * the default exception handler generated for a rule method.
+     *
+     * @param recognizer the parser instance
+     * @param e the recognition exception to report
+     */
+    reportError(recognizer: Parser, e: RecognitionException): void;
+}

package/typings/antlr4ts/ANTLRInputStream.d.ts

@@ -0,0 +1,51 @@
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+import { CharStream } from "./CharStream";
+import { Interval } from "./misc/Interval";
+/**
+ * Vacuum all input from a {@link Reader}/{@link InputStream} and then treat it
+ * like a `char[]` buffer. Can also pass in a {@link String} or
+ * `char[]` to use.
+ *
+ * If you need encoding, pass in stream/reader with correct encoding.
+ *
+ * @deprecated as of 4.7, please use `CharStreams` interface.
+ */
+export declare class ANTLRInputStream implements CharStream {
+    /** The data being scanned */
+    protected data: string;
+    /** How many characters are actually in the buffer */
+    protected n: number;
+    /** 0..n-1 index into string of next char */
+    protected p: number;
+    /** What is name or source of this char stream? */
+    name?: string;
+    /** Copy data in string to a local char array */
+    constructor(input: string);
+    /** Reset the stream so that it's in the same state it was
+     *  when the object was created *except* the data array is not
+     *  touched.
+     */
+    reset(): void;
+    consume(): void;
+    LA(i: number): number;
+    LT(i: number): number;
+    /** Return the current input symbol index 0..n where n indicates the
+     *  last symbol has been read.  The index is the index of char to
+     *  be returned from LA(1).
+     */
+    get index(): number;
+    get size(): number;
+    /** mark/release do nothing; we have entire buffer */
+    mark(): number;
+    release(marker: number): void;
+    /** consume() ahead until p==index; can't just set p=index as we must
+     *  update line and charPositionInLine. If we seek backwards, just set p
+     */
+    seek(index: number): void;
+    getText(interval: Interval): string;
+    get sourceName(): string;
+    toString(): string;
+}

package/typings/antlr4ts/BailErrorStrategy.d.ts

@@ -0,0 +1,48 @@
+/*!
+ * 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 { DefaultErrorStrategy } from "./DefaultErrorStrategy";
+import { Parser } from "./Parser";
+import { RecognitionException } from "./RecognitionException";
+import { Token } from "./Token";
+/**
+ * This implementation of {@link ANTLRErrorStrategy} responds to syntax errors
+ * by immediately canceling the parse operation with a
+ * {@link ParseCancellationException}. The implementation ensures that the
+ * {@link ParserRuleContext#exception} field is set for all parse tree nodes
+ * that were not completed prior to encountering the error.
+ *
+ * This error strategy is useful in the following scenarios.
+ *
+ * * **Two-stage parsing:** This error strategy allows the first
+ *   stage of two-stage parsing to immediately terminate if an error is
+ *   encountered, and immediately fall back to the second stage. In addition to
+ *   avoiding wasted work by attempting to recover from errors here, the empty
+ *   implementation of {@link BailErrorStrategy#sync} improves the performance of
+ *   the first stage.
+ * * **Silent validation:** When syntax errors are not being
+ *   reported or logged, and the parse result is simply ignored if errors occur,
+ *   the {@link BailErrorStrategy} avoids wasting work on recovering from errors
+ *   when the result will be ignored either way.
+ *
+ * ```
+ * myparser.errorHandler = new BailErrorStrategy();
+ * ```
+ *
+ * @see Parser.errorHandler
+ */
+export declare class BailErrorStrategy extends DefaultErrorStrategy {
+    /** Instead of recovering from exception `e`, re-throw it wrapped
+     *  in a {@link ParseCancellationException} so it is not caught by the
+     *  rule function catches.  Use {@link Exception#getCause()} to get the
+     *  original {@link RecognitionException}.
+     */
+    recover(recognizer: Parser, e: RecognitionException): void;
+    /** Make sure we don't attempt to recover inline; if the parser
+     *  successfully recovers, it won't throw an exception.
+     */
+    recoverInline(recognizer: Parser): Token;
+    /** Make sure we don't attempt to recover from problems in subrules. */
+    sync(recognizer: Parser): void;
+}

package/typings/antlr4ts/BufferedTokenStream.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 { Interval } from "./misc/Interval";
+import { RuleContext } from "./RuleContext";
+import { Token } from "./Token";
+import { TokenSource } from "./TokenSource";
+import { TokenStream } from "./TokenStream";
+/**
+ * This implementation of {@link TokenStream} loads tokens from a
+ * {@link TokenSource} on-demand, and places the tokens in a buffer to provide
+ * access to any previous token by index.
+ *
+ * This token stream ignores the value of {@link Token#getChannel}. If your
+ * parser requires the token stream filter tokens to only those on a particular
+ * channel, such as {@link Token#DEFAULT_CHANNEL} or
+ * {@link Token#HIDDEN_CHANNEL}, use a filtering token stream such a
+ * {@link CommonTokenStream}.
+ */
+export declare class BufferedTokenStream implements TokenStream {
+    /**
+     * The {@link TokenSource} from which tokens for this stream are fetched.
+     */
+    private _tokenSource;
+    /**
+     * A collection of all tokens fetched from the token source. The list is
+     * considered a complete view of the input once {@link #fetchedEOF} is set
+     * to `true`.
+     */
+    protected tokens: Token[];
+    /**
+     * The index into {@link #tokens} of the current token (next token to
+     * {@link #consume}). {@link #tokens}`[`{@link #p}`]` should be
+     * {@link #LT LT(1)}.
+     *
+     * This field is set to -1 when the stream is first constructed or when
+     * {@link #setTokenSource} is called, indicating that the first token has
+     * not yet been fetched from the token source. For additional information,
+     * see the documentation of {@link IntStream} for a description of
+     * Initializing Methods.
+     */
+    protected p: number;
+    /**
+     * Indicates whether the {@link Token#EOF} token has been fetched from
+     * {@link #tokenSource} and added to {@link #tokens}. This field improves
+     * performance for the following cases:
+     *
+     * * {@link #consume}: The lookahead check in {@link #consume} to prevent
+     *   consuming the EOF symbol is optimized by checking the values of
+     *   {@link #fetchedEOF} and {@link #p} instead of calling {@link #LA}.
+     * * {@link #fetch}: The check to prevent adding multiple EOF symbols into
+     *   {@link #tokens} is trivial with this field.
+     */
+    protected fetchedEOF: boolean;
+    constructor(tokenSource: TokenSource);
+    get tokenSource(): TokenSource;
+    /** Reset this token stream by setting its token source. */
+    set tokenSource(tokenSource: TokenSource);
+    get index(): number;
+    mark(): number;
+    release(marker: number): void;
+    seek(index: number): void;
+    get size(): number;
+    consume(): void;
+    /** Make sure index `i` in tokens has a token.
+     *
+     * @returns `true` if a token is located at index `i`, otherwise
+     *    `false`.
+     * @see #get(int i)
+     */
+    protected sync(i: number): boolean;
+    /** Add `n` elements to buffer.
+     *
+     * @returns The actual number of elements added to the buffer.
+     */
+    protected fetch(n: number): number;
+    get(i: number): Token;
+    /** Get all tokens from start..stop inclusively. */
+    getRange(start: number, stop: number): Token[];
+    LA(i: number): number;
+    protected tryLB(k: number): Token | undefined;
+    LT(k: number): Token;
+    tryLT(k: number): Token | undefined;
+    /**
+     * Allowed derived classes to modify the behavior of operations which change
+     * the current stream position by adjusting the target token index of a seek
+     * operation. The default implementation simply returns `i`. If an
+     * exception is thrown in this method, the current stream index should not be
+     * changed.
+     *
+     * For example, {@link CommonTokenStream} overrides this method to ensure that
+     * the seek target is always an on-channel token.
+     *
+     * @param i The target token index.
+     * @returns The adjusted target token index.
+     */
+    protected adjustSeekIndex(i: number): number;
+    protected lazyInit(): void;
+    protected setup(): void;
+    getTokens(): Token[];
+    getTokens(start: number, stop: number): Token[];
+    getTokens(start: number, stop: number, types: Set<number>): Token[];
+    getTokens(start: number, stop: number, ttype: number): Token[];
+    /**
+     * Given a starting index, return the index of the next token on channel.
+     * Return `i` if `tokens[i]` is on channel. Return the index of
+     * the EOF token if there are no tokens on channel between `i` and
+     * EOF.
+     */
+    protected nextTokenOnChannel(i: number, channel: number): number;
+    /**
+     * Given a starting index, return the index of the previous token on
+     * channel. Return `i` if `tokens[i]` is on channel. Return -1
+     * if there are no tokens on channel between `i` and 0.
+     *
+     * If `i` specifies an index at or after the EOF token, the EOF token
+     * index is returned. This is due to the fact that the EOF token is treated
+     * as though it were on every channel.
+     */
+    protected previousTokenOnChannel(i: number, channel: number): number;
+    /** Collect all tokens on specified channel to the right of
+     *  the current token up until we see a token on {@link Lexer#DEFAULT_TOKEN_CHANNEL} or
+     *  EOF. If `channel` is `-1`, find any non default channel token.
+     */
+    getHiddenTokensToRight(tokenIndex: number, channel?: number): Token[];
+    /** Collect all tokens on specified channel to the left of
+     *  the current token up until we see a token on {@link Lexer#DEFAULT_TOKEN_CHANNEL}.
+     *  If `channel` is `-1`, find any non default channel token.
+     */
+    getHiddenTokensToLeft(tokenIndex: number, channel?: number): Token[];
+    protected filterForChannel(from: number, to: number, channel: number): Token[];
+    get sourceName(): string;
+    /** Get the text of all tokens in this buffer. */
+    getText(): string;
+    getText(interval: Interval): string;
+    getText(context: RuleContext): string;
+    getTextFromRange(start: any, stop: any): string;
+    /** Get all tokens from lexer until EOF. */
+    fill(): void;
+    private isWritableToken;
+    private isToken;
+}

package/typings/antlr4ts/CharStream.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.
+ */
+import { Interval } from "./misc/Interval";
+import { IntStream } from "./IntStream";
+/** A source of characters for an ANTLR lexer. */
+export interface CharStream extends IntStream {
+    /**
+     * This method returns the text for a range of characters within this input
+     * stream. This method is guaranteed to not throw an exception if the
+     * specified `interval` lies entirely within a marked range. For more
+     * information about marked ranges, see {@link IntStream#mark}.
+     *
+     * @param interval an interval within the stream
+     * @returns the text of the specified interval
+     *
+     * @throws NullPointerException if `interval` is `undefined`
+     * @throws IllegalArgumentException if `interval.a < 0`, or if
+     * `interval.b < interval.a - 1`, or if `interval.b` lies at or
+     * past the end of the stream
+     * @throws UnsupportedOperationException if the stream does not support
+     * getting the text of the specified interval
+     */
+    getText(/*@NotNull*/ interval: Interval): string;
+}

package/typings/antlr4ts/CharStreams.d.ts

@@ -0,0 +1,54 @@
+/*!
+ * 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 { CodePointCharStream } from "./CodePointCharStream";
+/** This class represents the primary interface for creating {@link CharStream}s
+ *  from a variety of sources as of 4.7.  The motivation was to support
+ *  Unicode code points > U+FFFF.  {@link ANTLRInputStream} and
+ *  {@link ANTLRFileStream} are now deprecated in favor of the streams created
+ *  by this interface.
+ *
+ *  DEPRECATED: {@code new ANTLRFileStream("myinputfile")}
+ *  NEW:        {@code CharStreams.fromFileName("myinputfile")}
+ *
+ *  WARNING: If you use both the deprecated and the new streams, you will see
+ *  a nontrivial performance degradation. This speed hit is because the
+ *  {@link Lexer}'s internal code goes from a monomorphic to megamorphic
+ *  dynamic dispatch to get characters from the input stream. Java's
+ *  on-the-fly compiler (JIT) is unable to perform the same optimizations
+ *  so stick with either the old or the new streams, if performance is
+ *  a primary concern. See the extreme debugging and spelunking
+ *  needed to identify this issue in our timing rig:
+ *
+ *      https://github.com/antlr/antlr4/pull/1781
+ *
+ *  The ANTLR character streams still buffer all the input when you create
+ *  the stream, as they have done for ~20 years. If you need unbuffered
+ *  access, please note that it becomes challenging to create
+ *  parse trees. The parse tree has to point to tokens which will either
+ *  point into a stale location in an unbuffered stream or you have to copy
+ *  the characters out of the buffer into the token. That defeats the purpose
+ *  of unbuffered input. Per the ANTLR book, unbuffered streams are primarily
+ *  useful for processing infinite streams *during the parse.*
+ *
+ *  The new streams also use 8-bit buffers when possible so this new
+ *  interface supports character streams that use half as much memory
+ *  as the old {@link ANTLRFileStream}, which assumed 16-bit characters.
+ *
+ *  A big shout out to Ben Hamilton (github bhamiltoncx) for his superhuman
+ *  efforts across all targets to get true Unicode 3.1 support for U+10FFFF.
+ *
+ *  @since 4.7
+ */
+export declare namespace CharStreams {
+    /**
+     * Creates a {@link CharStream} given a {@link String}.
+     */
+    function fromString(s: string): CodePointCharStream;
+    /**
+     * Creates a {@link CharStream} given a {@link String} and the {@code sourceName}
+     * from which it came.
+     */
+    function fromString(s: string, sourceName: string): CodePointCharStream;
+}

package/typings/antlr4ts/CodePointBuffer.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.
+ */
+/**
+ * Wrapper for `Uint8Array` / `Uint16Array` / `Int32Array`.
+ */
+export declare class CodePointBuffer {
+    private readonly buffer;
+    private _position;
+    private _size;
+    constructor(buffer: Uint8Array | Uint16Array | Int32Array, size: number);
+    static withArray(buffer: Uint8Array | Uint16Array | Int32Array): CodePointBuffer;
+    get position(): number;
+    set position(newPosition: number);
+    get remaining(): number;
+    get(offset: number): number;
+    array(): Uint8Array | Uint16Array | Int32Array;
+    static builder(initialBufferSize: number): CodePointBuffer.Builder;
+}
+export declare namespace CodePointBuffer {
+    class Builder {
+        private type;
+        private buffer;
+        private prevHighSurrogate;
+        private position;
+        constructor(initialBufferSize: number);
+        build(): CodePointBuffer;
+        private static roundUpToNextPowerOfTwo;
+        ensureRemaining(remainingNeeded: number): void;
+        append(utf16In: Uint16Array): void;
+        private appendArray;
+        private appendArrayByte;
+        private appendArrayChar;
+        private appendArrayInt;
+        private byteToCharBuffer;
+        private byteToIntBuffer;
+        private charToIntBuffer;
+    }
+}

package/typings/antlr4ts/CodePointCharStream.d.ts

@@ -0,0 +1,45 @@
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+import { CharStream } from "./CharStream";
+import { CodePointBuffer } from "./CodePointBuffer";
+import { Interval } from "./misc/Interval";
+/**
+ * Alternative to {@link ANTLRInputStream} which treats the input
+ * as a series of Unicode code points, instead of a series of UTF-16
+ * code units.
+ *
+ * Use this if you need to parse input which potentially contains
+ * Unicode values > U+FFFF.
+ */
+export declare class CodePointCharStream implements CharStream {
+    private readonly _array;
+    private readonly _size;
+    private readonly _name;
+    private _position;
+    protected constructor(array: Uint8Array | Uint16Array | Int32Array, position: number, remaining: number, name: string);
+    get internalStorage(): Uint8Array | Uint16Array | Int32Array;
+    /**
+     * Constructs a {@link CodePointCharStream} which provides access
+     * to the Unicode code points stored in {@code codePointBuffer}.
+     */
+    static fromBuffer(codePointBuffer: CodePointBuffer): CodePointCharStream;
+    /**
+     * Constructs a named {@link CodePointCharStream} which provides access
+     * to the Unicode code points stored in {@code codePointBuffer}.
+     */
+    static fromBuffer(codePointBuffer: CodePointBuffer, name: string): CodePointCharStream;
+    consume(): void;
+    get index(): number;
+    get size(): number;
+    /** mark/release do nothing; we have entire buffer */
+    mark(): number;
+    release(marker: number): void;
+    seek(index: number): void;
+    get sourceName(): string;
+    toString(): string;
+    LA(i: number): number;
+    /** Return the UTF-16 encoded string for the given interval */
+    getText(interval: Interval): string;
+}