@opra/client 0.8.0 → 0.11.0

package/typings/antlr4ts/atn/LexerModeAction.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 { Lexer } from "../Lexer";
+import { LexerAction } from "./LexerAction";
+import { LexerActionType } from "./LexerActionType";
+/**
+ * Implements the `mode` lexer action by calling {@link Lexer#mode} with
+ * the assigned mode.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+export declare class LexerModeAction implements LexerAction {
+    private readonly _mode;
+    /**
+     * Constructs a new `mode` action with the specified mode value.
+     * @param mode The mode value to pass to {@link Lexer#mode}.
+     */
+    constructor(mode: number);
+    /**
+     * Get the lexer mode this action should transition the lexer to.
+     *
+     * @returns The lexer mode for this `mode` command.
+     */
+    get mode(): number;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns {@link LexerActionType#MODE}.
+     */
+    get actionType(): LexerActionType;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns `false`.
+     */
+    get isPositionDependent(): boolean;
+    /**
+     * {@inheritDoc}
+     *
+     * This action is implemented by calling {@link Lexer#mode} with the
+     * value provided by {@link #getMode}.
+     */
+    execute(lexer: Lexer): void;
+    hashCode(): number;
+    equals(obj: any): boolean;
+    toString(): string;
+}

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

@@ -0,0 +1,47 @@
+/*!
+ * 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 { Lexer } from "../Lexer";
+import { LexerAction } from "./LexerAction";
+import { LexerActionType } from "./LexerActionType";
+/**
+ * Implements the `more` lexer action by calling {@link Lexer#more}.
+ *
+ * The `more` command does not have any parameters, so this action is
+ * implemented as a singleton instance exposed by {@link #INSTANCE}.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+export declare class LexerMoreAction implements LexerAction {
+    /**
+     * Constructs the singleton instance of the lexer `more` command.
+     */
+    constructor();
+    /**
+     * {@inheritDoc}
+     * @returns This method returns {@link LexerActionType#MORE}.
+     */
+    get actionType(): LexerActionType;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns `false`.
+     */
+    get isPositionDependent(): boolean;
+    /**
+     * {@inheritDoc}
+     *
+     * This action is implemented by calling {@link Lexer#more}.
+     */
+    execute(lexer: Lexer): void;
+    hashCode(): number;
+    equals(obj: any): boolean;
+    toString(): string;
+}
+export declare namespace LexerMoreAction {
+    /**
+     * Provides a singleton instance of this parameterless lexer action.
+     */
+    const INSTANCE: LexerMoreAction;
+}

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

@@ -0,0 +1,47 @@
+/*!
+ * 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 { Lexer } from "../Lexer";
+import { LexerAction } from "./LexerAction";
+import { LexerActionType } from "./LexerActionType";
+/**
+ * Implements the `popMode` lexer action by calling {@link Lexer#popMode}.
+ *
+ * The `popMode` command does not have any parameters, so this action is
+ * implemented as a singleton instance exposed by {@link #INSTANCE}.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+export declare class LexerPopModeAction implements LexerAction {
+    /**
+     * Constructs the singleton instance of the lexer `popMode` command.
+     */
+    constructor();
+    /**
+     * {@inheritDoc}
+     * @returns This method returns {@link LexerActionType#POP_MODE}.
+     */
+    get actionType(): LexerActionType;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns `false`.
+     */
+    get isPositionDependent(): boolean;
+    /**
+     * {@inheritDoc}
+     *
+     * This action is implemented by calling {@link Lexer#popMode}.
+     */
+    execute(lexer: Lexer): void;
+    hashCode(): number;
+    equals(obj: any): boolean;
+    toString(): string;
+}
+export declare namespace LexerPopModeAction {
+    /**
+     * Provides a singleton instance of this parameterless lexer action.
+     */
+    const INSTANCE: LexerPopModeAction;
+}

package/typings/antlr4ts/atn/LexerPushModeAction.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 { Lexer } from "../Lexer";
+import { LexerAction } from "./LexerAction";
+import { LexerActionType } from "./LexerActionType";
+/**
+ * Implements the `pushMode` lexer action by calling
+ * {@link Lexer#pushMode} with the assigned mode.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+export declare class LexerPushModeAction implements LexerAction {
+    private readonly _mode;
+    /**
+     * Constructs a new `pushMode` action with the specified mode value.
+     * @param mode The mode value to pass to {@link Lexer#pushMode}.
+     */
+    constructor(mode: number);
+    /**
+     * Get the lexer mode this action should transition the lexer to.
+     *
+     * @returns The lexer mode for this `pushMode` command.
+     */
+    get mode(): number;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns {@link LexerActionType#PUSH_MODE}.
+     */
+    get actionType(): LexerActionType;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns `false`.
+     */
+    get isPositionDependent(): boolean;
+    /**
+     * {@inheritDoc}
+     *
+     * This action is implemented by calling {@link Lexer#pushMode} with the
+     * value provided by {@link #getMode}.
+     */
+    execute(lexer: Lexer): void;
+    hashCode(): number;
+    equals(obj: any): boolean;
+    toString(): string;
+}

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

@@ -0,0 +1,47 @@
+/*!
+ * 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 { Lexer } from "../Lexer";
+import { LexerAction } from "./LexerAction";
+import { LexerActionType } from "./LexerActionType";
+/**
+ * Implements the `skip` lexer action by calling {@link Lexer#skip}.
+ *
+ * The `skip` command does not have any parameters, so this action is
+ * implemented as a singleton instance exposed by {@link #INSTANCE}.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+export declare class LexerSkipAction implements LexerAction {
+    /**
+     * Constructs the singleton instance of the lexer `skip` command.
+     */
+    constructor();
+    /**
+     * {@inheritDoc}
+     * @returns This method returns {@link LexerActionType#SKIP}.
+     */
+    get actionType(): LexerActionType;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns `false`.
+     */
+    get isPositionDependent(): boolean;
+    /**
+     * {@inheritDoc}
+     *
+     * This action is implemented by calling {@link Lexer#skip}.
+     */
+    execute(lexer: Lexer): void;
+    hashCode(): number;
+    equals(obj: any): boolean;
+    toString(): string;
+}
+export declare namespace LexerSkipAction {
+    /**
+     * Provides a singleton instance of this parameterless lexer action.
+     */
+    const INSTANCE: LexerSkipAction;
+}

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

@@ -0,0 +1,47 @@
+/*!
+ * 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 { Lexer } from "../Lexer";
+import { LexerAction } from "./LexerAction";
+import { LexerActionType } from "./LexerActionType";
+/**
+ * Implements the `type` lexer action by setting `Lexer.type`
+ * with the assigned type.
+ *
+ * @author Sam Harwell
+ * @since 4.2
+ */
+export declare class LexerTypeAction implements LexerAction {
+    private readonly _type;
+    /**
+     * Constructs a new `type` action with the specified token type value.
+     * @param type The type to assign to the token using `Lexer.type`.
+     */
+    constructor(type: number);
+    /**
+     * Gets the type to assign to a token created by the lexer.
+     * @returns The type to assign to a token created by the lexer.
+     */
+    get type(): number;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns {@link LexerActionType#TYPE}.
+     */
+    get actionType(): LexerActionType;
+    /**
+     * {@inheritDoc}
+     * @returns This method returns `false`.
+     */
+    get isPositionDependent(): boolean;
+    /**
+     * {@inheritDoc}
+     *
+     * This action is implemented by setting `Lexer.type` with the
+     * value provided by `type`.
+     */
+    execute(lexer: Lexer): void;
+    hashCode(): number;
+    equals(obj: any): boolean;
+    toString(): string;
+}

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

@@ -0,0 +1,37 @@
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+import { DecisionEventInfo } from "./DecisionEventInfo";
+import { SimulatorState } from "./SimulatorState";
+import { TokenStream } from "../TokenStream";
+/**
+ * This class represents profiling event information for tracking the lookahead
+ * depth required in order to make a prediction.
+ *
+ * @since 4.3
+ */
+export declare class LookaheadEventInfo extends DecisionEventInfo {
+    /** The alternative chosen by adaptivePredict(), not necessarily
+     *  the outermost alt shown for a rule; left-recursive rules have
+     *  user-level alts that differ from the rewritten rule with a (...) block
+     *  and a (..)* loop.
+     */
+    predictedAlt: number;
+    /**
+     * Constructs a new instance of the {@link LookaheadEventInfo} class with
+     * the specified detailed lookahead information.
+     *
+     * @param decision The decision number
+     * @param state The final simulator state containing the necessary
+     * information to determine the result of a prediction, or `undefined` if
+     * the final state is not available
+     * @param input The input token stream
+     * @param startIndex The start index for the current prediction
+     * @param stopIndex The index at which the prediction was finally made
+     * @param fullCtx `true` if the current lookahead is part of an LL
+     * prediction; otherwise, `false` if the current lookahead is part of
+     * an SLL prediction
+     */
+    constructor(decision: number, state: SimulatorState | undefined, predictedAlt: number, input: TokenStream, startIndex: number, stopIndex: number, fullCtx: boolean);
+}

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

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2016 The ANTLR Project. All rights reserved.
+ * Licensed under the BSD-3-Clause license. See LICENSE file in the project root for license information.
+ */
+import { ATNState } from "./ATNState";
+import { ATNStateType } from "./ATNStateType";
+/** Mark the end of a * or + loop. */
+export declare class LoopEndState extends ATNState {
+    loopBackState: ATNState;
+    get stateType(): ATNStateType;
+}

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

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

package/typings/antlr4ts/atn/OrderedATNConfigSet.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 { ATNConfig } from "./ATNConfig";
+import { ATNConfigSet } from "./ATNConfigSet";
+/**
+ *
+ * @author Sam Harwell
+ */
+export declare class OrderedATNConfigSet extends ATNConfigSet {
+    constructor();
+    constructor(set: ATNConfigSet, readonly: boolean);
+    clone(readonly: boolean): ATNConfigSet;
+    protected getKey(e: ATNConfig): {
+        state: number;
+        alt: number;
+    };
+    protected canMerge(left: ATNConfig, leftKey: {
+        state: number;
+        alt: number;
+    }, right: ATNConfig): boolean;
+}

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

@@ -0,0 +1,79 @@
+/*!
+ * 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 { DecisionInfo } from "./DecisionInfo";
+import { ProfilingATNSimulator } from "./ProfilingATNSimulator";
+/**
+ * This class provides access to specific and aggregate statistics gathered
+ * during profiling of a parser.
+ *
+ * @since 4.3
+ */
+export declare class ParseInfo {
+    protected atnSimulator: ProfilingATNSimulator;
+    constructor(atnSimulator: ProfilingATNSimulator);
+    /**
+     * Gets an array of {@link DecisionInfo} instances containing the profiling
+     * information gathered for each decision in the ATN.
+     *
+     * @returns An array of {@link DecisionInfo} instances, indexed by decision
+     * number.
+     */
+    getDecisionInfo(): DecisionInfo[];
+    /**
+     * Gets the decision numbers for decisions that required one or more
+     * full-context predictions during parsing. These are decisions for which
+     * {@link DecisionInfo#LL_Fallback} is non-zero.
+     *
+     * @returns A list of decision numbers which required one or more
+     * full-context predictions during parsing.
+     */
+    getLLDecisions(): number[];
+    /**
+     * Gets the total time spent during prediction across all decisions made
+     * during parsing. This value is the sum of
+     * {@link DecisionInfo#timeInPrediction} for all decisions.
+     */
+    getTotalTimeInPrediction(): number;
+    /**
+     * Gets the total number of SLL lookahead operations across all decisions
+     * made during parsing. This value is the sum of
+     * {@link DecisionInfo#SLL_TotalLook} for all decisions.
+     */
+    getTotalSLLLookaheadOps(): number;
+    /**
+     * Gets the total number of LL lookahead operations across all decisions
+     * made during parsing. This value is the sum of
+     * {@link DecisionInfo#LL_TotalLook} for all decisions.
+     */
+    getTotalLLLookaheadOps(): number;
+    /**
+     * Gets the total number of ATN lookahead operations for SLL prediction
+     * across all decisions made during parsing.
+     */
+    getTotalSLLATNLookaheadOps(): number;
+    /**
+     * Gets the total number of ATN lookahead operations for LL prediction
+     * across all decisions made during parsing.
+     */
+    getTotalLLATNLookaheadOps(): number;
+    /**
+     * Gets the total number of ATN lookahead operations for SLL and LL
+     * prediction across all decisions made during parsing.
+     *
+     * This value is the sum of {@link #getTotalSLLATNLookaheadOps} and
+     * {@link #getTotalLLATNLookaheadOps}.
+     */
+    getTotalATNLookaheadOps(): number;
+    /**
+     * Gets the total number of DFA states stored in the DFA cache for all
+     * decisions in the ATN.
+     */
+    getDFASize(): number;
+    /**
+     * Gets the total number of DFA states stored in the DFA cache for a
+     * particular decision.
+     */
+    getDFASize(decision: number): number;
+}