@opra/client 0.11.0 → 0.11.2

package/typings/antlr4ts/TokenFactory.d.ts

@@ -1,23 +0,0 @@
-/*!
- * 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 { Token } from "./Token";
-import { TokenSource } from "./TokenSource";
-/** The default mechanism for creating tokens. It's used by default in Lexer and
- *  the error handling strategy (to create missing tokens).  Notifying the parser
- *  of a new factory means that it notifies its token source and error strategy.
- */
-export interface TokenFactory {
-    /** This is the method used to create tokens in the lexer and in the
-     *  error handling strategy. If text!=undefined, than the start and stop positions
-     *  are wiped to -1 in the text override is set in the CommonToken.
-     */
-    create(source: {
-        source?: TokenSource;
-        stream?: CharStream;
-    }, type: number, text: string | undefined, channel: number, start: number, stop: number, line: number, charPositionInLine: number): Token;
-    /** Generically useful */
-    createSimple(type: number, text: string): Token;
-}

package/typings/antlr4ts/TokenSource.d.ts

@@ -1,67 +0,0 @@
-/*!
- * 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 { Token } from "./Token";
-import { TokenFactory } from "./TokenFactory";
-/**
- * A source of tokens must provide a sequence of tokens via {@link #nextToken()}
- * and also must reveal it's source of characters; {@link CommonToken}'s text is
- * computed from a {@link CharStream}; it only store indices into the char
- * stream.
- *
- * Errors from the lexer are never passed to the parser. Either you want to keep
- * going or you do not upon token recognition error. If you do not want to
- * continue lexing then you do not want to continue parsing. Just throw an
- * exception not under {@link RecognitionException} and Java will naturally toss
- * you all the way out of the recognizers. If you want to continue lexing then
- * you should not throw an exception to the parser--it has already requested a
- * token. Keep lexing until you get a valid one. Just report errors and keep
- * going, looking for a valid token.
- */
-export interface TokenSource {
-    /**
-     * Return a {@link Token} object from your input stream (usually a
-     * {@link CharStream}). Do not fail/return upon lexing error; keep chewing
-     * on the characters until you get a good one; errors are not passed through
-     * to the parser.
-     */
-    nextToken(): Token;
-    /**
-     * Get the line number for the current position in the input stream. The
-     * first line in the input is line 1.
-     *
-     * @returns The line number for the current position in the input stream, or
-     * 0 if the current token source does not track line numbers.
-     */
-    readonly line: number;
-    /**
-     * Get the index into the current line for the current position in the input
-     * stream. The first character on a line has position 0.
-     *
-     * @returns The line number for the current position in the input stream, or
-     * -1 if the current token source does not track character positions.
-     */
-    readonly charPositionInLine: number;
-    /**
-     * Get the {@link CharStream} from which this token source is currently
-     * providing tokens.
-     *
-     * @returns The {@link CharStream} associated with the current position in
-     * the input, or `undefined` if no input stream is available for the token
-     * source.
-     */
-    readonly inputStream: CharStream | undefined;
-    /**
-     * Gets the name of the underlying input source. This method returns a
-     * non-undefined, non-empty string. If such a name is not known, this method
-     * returns {@link IntStream#UNKNOWN_SOURCE_NAME}.
-     */
-    readonly sourceName: string;
-    /**
-     * Gets or sets the `TokenFactory` this token source is currently using for
-     * creating `Token` objects from the input.
-     */
-    tokenFactory: TokenFactory;
-}

package/typings/antlr4ts/TokenStream.d.ts

@@ -1,145 +0,0 @@
-/*!
- * 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";
-import { RuleContext } from "./RuleContext";
-import { Token } from "./Token";
-import { TokenSource } from "./TokenSource";
-/**
- * An {@link IntStream} whose symbols are {@link Token} instances.
- */
-export interface TokenStream extends IntStream {
-    /**
-     * Get the `Token` instance associated with the value returned by `LA(k)`. This method has the same pre- and
-     * post-conditions as `IntStream.LA`. In addition, when the preconditions of this method are met, the return value
-     * is non-undefined and the value of `LT(k).type === LA(k)`.
-     *
-     * A `RangeError` is thrown if `k<0` and fewer than `-k` calls to `consume()` have occurred from the beginning of
-     * the stream before calling this method.
-     *
-     * See `IntStream.LA`
-     */
-    LT(k: number): Token;
-    /**
-     * Get the `Token` instance associated with the value returned by `LA(k)`. This method has the same pre- and
-     * post-conditions as `IntStream.LA`. In addition, when the preconditions of this method are met, the return value
-     * is non-undefined and the value of `tryLT(k).type === LA(k)`.
-     *
-     * The return value is `undefined` if `k<0` and fewer than `-k` calls to `consume()` have occurred from the
-     * beginning of the stream before calling this method.
-     *
-     * See `IntStream.LA`
-     */
-    tryLT(k: number): Token | undefined;
-    /**
-     * Gets the {@link Token} at the specified `index` in the stream. When
-     * the preconditions of this method are met, the return value is non-undefined.
-     *
-     * The preconditions for this method are the same as the preconditions of
-     * {@link IntStream#seek}. If the behavior of `seek(index)` is
-     * unspecified for the current state and given `index`, then the
-     * behavior of this method is also unspecified.
-     *
-     * The symbol referred to by `index` differs from `seek()` only
-     * in the case of filtering streams where `index` lies before the end
-     * of the stream. Unlike `seek()`, this method does not adjust
-     * `index` to point to a non-ignored symbol.
-     *
-     * @throws IllegalArgumentException if {code index} is less than 0
-     * @throws UnsupportedOperationException if the stream does not support
-     * retrieving the token at the specified index
-     */
-    get(i: number): Token;
-    /**
-     * Gets the underlying {@link TokenSource} which provides tokens for this
-     * stream.
-     */
-    readonly tokenSource: TokenSource;
-    /**
-     * Return the text of all tokens within the specified `interval`. This
-     * method behaves like the following code (including potential exceptions
-     * for violating preconditions of {@link #get}, but may be optimized by the
-     * specific implementation.
-     *
-     * ```
-     * TokenStream stream = ...;
-     * String text = "";
-     * for (int i = interval.a; i <= interval.b; i++) {
-     *   text += stream.get(i).text;
-     * }
-     * ```
-     *
-     * @param interval The interval of tokens within this stream to get text
-     * for.
-     * @returns The text of all tokens within the specified interval in this
-     * stream.
-     *
-     * @throws NullPointerException if `interval` is `undefined`
-     */
-    getText(/*@NotNull*/ interval: Interval): string;
-    /**
-     * Return the text of all tokens in the stream. This method behaves like the
-     * following code, including potential exceptions from the calls to
-     * {@link IntStream#size} and {@link #getText(Interval)}, but may be
-     * optimized by the specific implementation.
-     *
-     * ```
-     * TokenStream stream = ...;
-     * String text = stream.getText(new Interval(0, stream.size));
-     * ```
-     *
-     * @returns The text of all tokens in the stream.
-     */
-    getText(): string;
-    /**
-     * Return the text of all tokens in the source interval of the specified
-     * context. This method behaves like the following code, including potential
-     * exceptions from the call to {@link #getText(Interval)}, but may be
-     * optimized by the specific implementation.
-     *
-     * If `ctx.sourceInterval` does not return a valid interval of
-     * tokens provided by this stream, the behavior is unspecified.
-     *
-     * ```
-     * TokenStream stream = ...;
-     * String text = stream.getText(ctx.sourceInterval);
-     * ```
-     *
-     * @param ctx The context providing the source interval of tokens to get
-     * text for.
-     * @returns The text of all tokens within the source interval of `ctx`.
-     */
-    getText(/*@NotNull*/ ctx: RuleContext): string;
-    /**
-     * Return the text of all tokens in this stream between `start` and
-     * `stop` (inclusive).
-     *
-     * If the specified `start` or `stop` token was not provided by
-     * this stream, or if the `stop` occurred before the `start`}
-     * token, the behavior is unspecified.
-     *
-     * For streams which ensure that the `Token.tokenIndex` method is
-     * accurate for all of its provided tokens, this method behaves like the
-     * following code. Other streams may implement this method in other ways
-     * provided the behavior is consistent with this at a high level.
-     *
-     * ```
-     * TokenStream stream = ...;
-     * String text = "";
-     * for (int i = start.tokenIndex; i <= stop.tokenIndex; i++) {
-     *   text += stream.get(i).text;
-     * }
-     * ```
-     *
-     * @param start The first token in the interval to get text for.
-     * @param stop The last token in the interval to get text for (inclusive).
-     * @returns The text of all tokens lying between the specified `start`
-     * and `stop` tokens.
-     *
-     * @throws UnsupportedOperationException if this stream does not support
-     * this method for the specified tokens
-     */
-    getTextFromRange(start: any, stop: any): string;
-}

package/typings/antlr4ts/TokenStreamRewriter.d.ts

@@ -1,216 +0,0 @@
-/*!
- * 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 { Token } from "./Token";
-import { TokenStream } from "./TokenStream";
-/**
- * Useful for rewriting out a buffered input token stream after doing some
- * augmentation or other manipulations on it.
- *
- * You can insert stuff, replace, and delete chunks. Note that the operations
- * are done lazily--only if you convert the buffer to a {@link String} with
- * {@link TokenStream#getText()}. This is very efficient because you are not
- * moving data around all the time. As the buffer of tokens is converted to
- * strings, the {@link #getText()} method(s) scan the input token stream and
- * check to see if there is an operation at the current index. If so, the
- * operation is done and then normal {@link String} rendering continues on the
- * buffer. This is like having multiple Turing machine instruction streams
- * (programs) operating on a single input tape. :)
- *
- * This rewriter makes no modifications to the token stream. It does not ask the
- * stream to fill itself up nor does it advance the input cursor. The token
- * stream `TokenStream.index` will return the same value before and
- * after any {@link #getText()} call.
- *
- * The rewriter only works on tokens that you have in the buffer and ignores the
- * current input cursor. If you are buffering tokens on-demand, calling
- * {@link #getText()} halfway through the input will only do rewrites for those
- * tokens in the first half of the file.
- *
- * Since the operations are done lazily at {@link #getText}-time, operations do
- * not screw up the token index values. That is, an insert operation at token
- * index `i` does not change the index values for tokens
- * `i`+1..n-1.
- *
- * Because operations never actually alter the buffer, you may always get the
- * original token stream back without undoing anything. Since the instructions
- * are queued up, you can easily simulate transactions and roll back any changes
- * if there is an error just by removing instructions. For example,
- *
- * ```
- * CharStream input = new ANTLRFileStream("input");
- * TLexer lex = new TLexer(input);
- * CommonTokenStream tokens = new CommonTokenStream(lex);
- * T parser = new T(tokens);
- * TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
- * parser.startRule();
- * ```
- *
- * Then in the rules, you can execute (assuming rewriter is visible):
- *
- * ```
- * Token t,u;
- * ...
- * rewriter.insertAfter(t, "text to put after t");}
- * rewriter.insertAfter(u, "text after u");}
- * System.out.println(rewriter.getText());
- * ```
- *
- * You can also have multiple "instruction streams" and get multiple rewrites
- * from a single pass over the input. Just name the instruction streams and use
- * that name again when printing the buffer. This could be useful for generating
- * a C file and also its header file--all from the same buffer:
- *
- * ```
- * rewriter.insertAfter("pass1", t, "text to put after t");}
- * rewriter.insertAfter("pass2", u, "text after u");}
- * System.out.println(rewriter.getText("pass1"));
- * System.out.println(rewriter.getText("pass2"));
- * ```
- *
- * If you don't use named rewrite streams, a "default" stream is used as the
- * first example shows.
- */
-export declare class TokenStreamRewriter {
-    static readonly DEFAULT_PROGRAM_NAME: string;
-    static readonly PROGRAM_INIT_SIZE: number;
-    static readonly MIN_TOKEN_INDEX: number;
-    /** Our source stream */
-    protected tokens: TokenStream;
-    /** You may have multiple, named streams of rewrite operations.
-     *  I'm calling these things "programs."
-     *  Maps String (name) → rewrite (List)
-     */
-    protected programs: Map<string, RewriteOperation[]>;
-    /** Map String (program name) &rarr; Integer index */
-    protected lastRewriteTokenIndexes: Map<string, number>;
-    constructor(tokens: TokenStream);
-    getTokenStream(): TokenStream;
-    rollback(instructionIndex: number): void;
-    /** Rollback the instruction stream for a program so that
-     *  the indicated instruction (via instructionIndex) is no
-     *  longer in the stream. UNTESTED!
-     */
-    rollback(instructionIndex: number, programName: string): void;
-    deleteProgram(): void;
-    /** Reset the program so that no instructions exist */
-    deleteProgram(programName: string): void;
-    insertAfter(t: Token, text: {}): void;
-    insertAfter(index: number, text: {}): void;
-    insertAfter(t: Token, text: {}, programName: string): void;
-    insertAfter(index: number, text: {}, programName: string): void;
-    insertBefore(t: Token, text: {}): void;
-    insertBefore(index: number, text: {}): void;
-    insertBefore(t: Token, text: {}, programName: string): void;
-    insertBefore(index: number, text: {}, programName: string): void;
-    replaceSingle(index: number, text: {}): void;
-    replaceSingle(indexT: Token, text: {}): void;
-    replace(from: number, to: number, text: {}): void;
-    replace(from: Token, to: Token, text: {}): void;
-    replace(from: number, to: number, text: {}, programName: string): void;
-    replace(from: Token, to: Token, text: {}, programName: string): void;
-    delete(index: number): void;
-    delete(from: number, to: number): void;
-    delete(indexT: Token): void;
-    delete(from: Token, to: Token): void;
-    delete(from: number, to: number, programName: string): void;
-    delete(from: Token, to: Token, programName: string): void;
-    protected getLastRewriteTokenIndex(): number;
-    protected getLastRewriteTokenIndex(programName: string): number;
-    protected setLastRewriteTokenIndex(programName: string, i: number): void;
-    protected getProgram(name: string): RewriteOperation[];
-    private initializeProgram;
-    /** Return the text from the original tokens altered per the
-     *  instructions given to this rewriter.
-     */
-    getText(): string;
-    /** Return the text from the original tokens altered per the
-     *  instructions given to this rewriter in programName.
-     *
-     * @since 4.5
-     */
-    getText(programName: string): string;
-    /** Return the text associated with the tokens in the interval from the
-     *  original token stream but with the alterations given to this rewriter.
-     *  The interval refers to the indexes in the original token stream.
-     *  We do not alter the token stream in any way, so the indexes
-     *  and intervals are still consistent. Includes any operations done
-     *  to the first and last token in the interval. So, if you did an
-     *  insertBefore on the first token, you would get that insertion.
-     *  The same is true if you do an insertAfter the stop token.
-     */
-    getText(interval: Interval): string;
-    getText(interval: Interval, programName: string): string;
-    /** We need to combine operations and report invalid operations (like
-     *  overlapping replaces that are not completed nested). Inserts to
-     *  same index need to be combined etc...  Here are the cases:
-     *
-     *  I.i.u I.j.v								leave alone, nonoverlapping
-     *  I.i.u I.i.v								combine: Iivu
-     *
-     *  R.i-j.u R.x-y.v	| i-j in x-y			delete first R
-     *  R.i-j.u R.i-j.v							delete first R
-     *  R.i-j.u R.x-y.v	| x-y in i-j			ERROR
-     *  R.i-j.u R.x-y.v	| boundaries overlap	ERROR
-     *
-     *  Delete special case of replace (text==undefined):
-     *  D.i-j.u D.x-y.v	| boundaries overlap	combine to max(min)..max(right)
-     *
-     *  I.i.u R.x-y.v | i in (x+1)-y			delete I (since insert before
-     * 											we're not deleting i)
-     *  I.i.u R.x-y.v | i not in (x+1)-y		leave alone, nonoverlapping
-     *  R.x-y.v I.i.u | i in x-y				ERROR
-     *  R.x-y.v I.x.u 							R.x-y.uv (combine, delete I)
-     *  R.x-y.v I.i.u | i not in x-y			leave alone, nonoverlapping
-     *
-     *  I.i.u = insert u before op @ index i
-     *  R.x-y.u = replace x-y indexed tokens with u
-     *
-     *  First we need to examine replaces. For any replace op:
-     *
-     * 		1. wipe out any insertions before op within that range.
-     * 		2. Drop any replace op before that is contained completely within
-     * 	 that range.
-     * 		3. Throw exception upon boundary overlap with any previous replace.
-     *
-     *  Then we can deal with inserts:
-     *
-     * 		1. for any inserts to same index, combine even if not adjacent.
-     * 		2. for any prior replace with same left boundary, combine this
-     * 	 insert with replace and delete this replace.
-     * 		3. throw exception if index in same range as previous replace
-     *
-     *  Don't actually delete; make op undefined in list. Easier to walk list.
-     *  Later we can throw as we add to index &rarr; op map.
-     *
-     *  Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
-     *  inserted stuff would be before the replace range. But, if you
-     *  add tokens in front of a method body '{' and then delete the method
-     *  body, I think the stuff before the '{' you added should disappear too.
-     *
-     *  Return a map from token index to operation.
-     */
-    protected reduceToSingleOperationPerIndex(rewrites: Array<RewriteOperation | undefined>): Map<number, RewriteOperation>;
-    protected catOpText(a: {}, b: {}): string;
-    /** Get all operations before an index of a particular kind */
-    protected getKindOfOps<T extends RewriteOperation>(rewrites: Array<RewriteOperation | undefined>, kind: {
-        new (...args: any[]): T;
-    }, before: number): T[];
-}
-export declare class RewriteOperation {
-    protected readonly tokens: TokenStream;
-    /** What index into rewrites List are we? */
-    readonly instructionIndex: number;
-    /** Token buffer index. */
-    index: number;
-    text: {};
-    constructor(tokens: TokenStream, index: number, instructionIndex: number);
-    constructor(tokens: TokenStream, index: number, instructionIndex: number, text: {});
-    /** Execute the rewrite operation by possibly adding to the buffer.
-     *  Return the index of the next token to operate on.
-     */
-    execute(buf: string[]): number;
-    toString(): string;
-}

package/typings/antlr4ts/Vocabulary.d.ts

@@ -1,117 +0,0 @@
-/*!
- * 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 information about the vocabulary used by a
- * recognizer.
- *
- * @see Recognizer.vocabulary
- * @author Sam Harwell
- */
-export interface Vocabulary {
-    /**
-     * Returns the highest token type value. It can be used to iterate from
-     * zero to that number, inclusively, thus querying all stored entries.
-     * @returns the highest token type value
-     */
-    readonly maxTokenType: number;
-    /**
-     * Gets the string literal associated with a token type. The string returned
-     * by this method, when not `undefined`, can be used unaltered in a parser
-     * grammar to represent this token type.
-     *
-     * The following table shows examples of lexer rules and the literal
-     * names assigned to the corresponding token types.
-     *
-     * <table>
-     *  <tr>
-     *   <th>Rule</th>
-     *   <th>Literal Name</th>
-     *   <th>Java String Literal</th>
-     *  </tr>
-     *  <tr>
-     *   <td>`THIS : 'this';`</td>
-     *   <td>`'this'`</td>
-     *   <td>`"'this'"`</td>
-     *  </tr>
-     *  <tr>
-     *   <td>`SQUOTE : '\'';`</td>
-     *   <td>`'\''`</td>
-     *   <td>`"'\\''"`</td>
-     *  </tr>
-     *  <tr>
-     *   <td>`ID : [A-Z]+;`</td>
-     *   <td>n/a</td>
-     *   <td>`undefined`</td>
-     *  </tr>
-     * </table>
-     *
-     * @param tokenType The token type.
-     *
-     * @returns The string literal associated with the specified token type, or
-     * `undefined` if no string literal is associated with the type.
-     */
-    getLiteralName(tokenType: number): string | undefined;
-    /**
-     * Gets the symbolic name associated with a token type. The string returned
-     * by this method, when not `undefined`, can be used unaltered in a parser
-     * grammar to represent this token type.
-     *
-     * This method supports token types defined by any of the following
-     * methods:
-     *
-     * * Tokens created by lexer rules.
-     * * Tokens defined in a `tokens{}` block in a lexer or parser
-     *   grammar.
-     * * The implicitly defined `EOF` token, which has the token type
-     *   {@link Token#EOF}.
-     *
-     * The following table shows examples of lexer rules and the literal
-     * names assigned to the corresponding token types.
-     *
-     * <table>
-     *  <tr>
-     *   <th>Rule</th>
-     *   <th>Symbolic Name</th>
-     *  </tr>
-     *  <tr>
-     *   <td>`THIS : 'this';`</td>
-     *   <td>`THIS`</td>
-     *  </tr>
-     *  <tr>
-     *   <td>`SQUOTE : '\'';`</td>
-     *   <td>`SQUOTE`</td>
-     *  </tr>
-     *  <tr>
-     *   <td>`ID : [A-Z]+;`</td>
-     *   <td>`ID`</td>
-     *  </tr>
-     * </table>
-     *
-     * @param tokenType The token type.
-     *
-     * @returns The symbolic name associated with the specified token type, or
-     * `undefined` if no symbolic name is associated with the type.
-     */
-    getSymbolicName(tokenType: number): string | undefined;
-    /**
-     * Gets the display name of a token type.
-     *
-     * ANTLR provides a default implementation of this method, but
-     * applications are free to override the behavior in any manner which makes
-     * sense for the application. The default implementation returns the first
-     * result from the following list which produces a non-`undefined`
-     * result.
-     *
-     * 1. The result of {@link #getLiteralName}
-     * 1. The result of {@link #getSymbolicName}
-     * 1. The result of {@link Integer#toString}
-     *
-     * @param tokenType The token type.
-     *
-     * @returns The display name of the token type, for use in error reporting or
-     * other user-visible messages which reference specific token types.
-     */
-    getDisplayName(tokenType: number): string;
-}

package/typings/antlr4ts/VocabularyImpl.d.ts

@@ -1,47 +0,0 @@
-/*!
- * 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 { Vocabulary } from "./Vocabulary";
-/**
- * This class provides a default implementation of the {@link Vocabulary}
- * interface.
- *
- * @author Sam Harwell
- */
-export declare class VocabularyImpl implements Vocabulary {
-    /**
-     * Gets an empty {@link Vocabulary} instance.
-     *
-     * No literal or symbol names are assigned to token types, so
-     * {@link #getDisplayName(int)} returns the numeric value for all tokens
-     * except {@link Token#EOF}.
-     */
-    static readonly EMPTY_VOCABULARY: VocabularyImpl;
-    private readonly literalNames;
-    private readonly symbolicNames;
-    private readonly displayNames;
-    private _maxTokenType;
-    /**
-     * Constructs a new instance of {@link VocabularyImpl} from the specified
-     * literal, symbolic, and display token names.
-     *
-     * @param literalNames The literal names assigned to tokens, or an empty array
-     * if no literal names are assigned.
-     * @param symbolicNames The symbolic names assigned to tokens, or
-     * an empty array if no symbolic names are assigned.
-     * @param displayNames The display names assigned to tokens, or an empty array
-     * to use the values in `literalNames` and `symbolicNames` as
-     * the source of display names, as described in
-     * {@link #getDisplayName(int)}.
-     *
-     * @see #getLiteralName(int)
-     * @see #getSymbolicName(int)
-     * @see #getDisplayName(int)
-     */
-    constructor(literalNames: Array<string | undefined>, symbolicNames: Array<string | undefined>, displayNames: Array<string | undefined>);
-    get maxTokenType(): number;
-    getLiteralName(tokenType: number): string | undefined;
-    getSymbolicName(tokenType: number): string | undefined;
-    getDisplayName(tokenType: number): string;
-}

package/typings/antlr4ts/WritableToken.d.ts

@@ -1,13 +0,0 @@
-/*!
- * 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 { Token } from "./Token";
-export interface WritableToken extends Token {
-    text: string | undefined;
-    type: number;
-    line: number;
-    charPositionInLine: number;
-    channel: number;
-    tokenIndex: number;
-}