cariboujs 2.0.1 → 2.0.2

package/.build/grammars-v4/_scripts/templates/JavaScript/st.Test.js

@@ -1,212 +0,0 @@
-// Generated from trgen <version>
-
-import antlr4 from 'antlr4';
-<tool_grammar_tuples: {x | import <x.GrammarAutomName> from './<x.GeneratedFileName>';
-} >
-import BinaryCharStream from './BinaryCharStream.js';
-import strops from 'typescript-string-operations';
-import fs from 'fs-extra';
-import pkg from 'timer-node';
-import * as readline from 'node:readline';
-
-const { Timer, Time, TimerOptions } = pkg;
-
-function getChar() {
-    let buffer = Buffer.alloc(1);
-    var xx = 0;
-    try {
-        xx = fs.readSync(0, buffer, 0, 1);
-    } catch (err) {
-    }
-    if (xx === 0) {
-        return '';
-    }
-    return buffer.toString('utf8');
-}
-
-
-class MyErrorListener extends antlr4.error.ErrorListener {
-
-    constructor(quiet, tee, output) {
-        super();
-        this._quiet = quiet;
-        this._tee = tee;
-        this._output = output;
-        this.had_error = false;
-    }
-
-    syntaxError(recognizer, offendingSymbol, line, column, msg, err) {
-        this.had_error = true;
-        if (tee) {
-            fs.writeSync(this._output, `line ${line}:${column} ${msg}\n`);
-        }
-        if (! quiet) {
-            console.error(`line ${line}:${column} ${msg}`);
-        }
-    }
-}
-
-var tee = false;
-var show_profile = false;
-var show_tree = false;
-var show_tokens = false;
-var show_trace = false;
-var error_code = 0;
-var quiet = false;
-var enc = '<file_encoding>';
-var binary = <binary>;
-var string_instance = 0;
-var prefix = '';
-var inputs = [];
-var is_fns = [];
-
-function splitLines(t) { return t.split(/\r\n|\r|\n/); }
-
-function main() {
-    for (let i = 2; i \< process.argv.length; ++i)
-    {
-        switch (process.argv[i]) {
-            case '-tokens':
-                show_tokens = true;
-                break;
-            case '-tree':
-                show_tree = true;
-                break;
-            case '-prefix':
-                prefix = process.argv[++i] + ' ';
-                break;
-            case '-input':
-                inputs.push(process.argv[++i]);
-                is_fns.push(false);
-                break;
-            case '-tee':
-                tee = true;
-                break;
-            case '-encoding':
-                enc = process.argv[++i];
-                break;
-            case '-x':
-                var sb = new strops.StringBuilder();
-                var ch;
-                while ((ch = getChar()) != '') {
-                    sb.Append(ch);
-                }
-                var input = sb.ToString();
-                var sp = splitLines(input);
-                for (var ii of sp) {
-                    if ( ii == '' ) continue;
-                    inputs.push(ii);
-                    is_fns.push(true);
-                }
-                break;
-            case '-q':
-                quiet = true;
-                break;
-            case '-trace':
-                show_trace = true;
-                break;
-            default:
-                inputs.push(process.argv[i]);
-                is_fns.push(true);
-                break;
-        }
-    }
-    if (inputs.length == 0) {
-        ParseStdin();
-    }
-    else {
-        const timer = new Timer({ label: 'test-timer' });
-        timer.start();
-        for (var f = 0; f \< inputs.length; ++f)
-        {
-            if (is_fns[f])
-                ParseFilename(inputs[f], f);
-            else
-                ParseString(inputs[f], f);
-        }
-        timer.stop();
-        var t = timer.time().m * 60 + timer.time().s + timer.time().ms / 1000;
-        if (!quiet) console.error(prefix + 'Total Time: ' + t);
-    }
-    process.exitCode = error_code;
-}
-
-function ParseStdin() {
-    var sb = new strops.StringBuilder();
-    var ch;
-    while ((ch = getChar()) != '') {
-        sb.Append(ch);
-    }
-    var input = sb.ToString();
-    var str = antlr4.CharStreams.fromString(input);
-    DoParse(str, "stdin", 0);
-}
-
-function ParseString(input, row_number) {
-    var str = antlr4.CharStreams.fromString(input);
-    DoParse(str, "string" + string_instance++, row_number);
-}
-
-function ParseFilename(input, row_number) {
-    if (enc === '') enc = 'utf8';
-    var str = antlr4.CharStreams.fromPathSync(input, enc);
-    DoParse(str, input, row_number);
-}
-
-function DoParse(str, input_name, row_number) {
-    if (binary) str = new BinaryCharStream(str);
-    const lexer = new <lexer_name>(str);
-    const tokens = new antlr4.CommonTokenStream(lexer);
-    const parser = new <parser_name>(tokens);
-    lexer.removeErrorListeners();
-    parser.removeErrorListeners();
-    var output = tee ? fs.openSync(input_name + ".errors", 'w') : 1;
-    var listener_parser = new MyErrorListener(quiet, tee, output);
-    var listener_lexer = new MyErrorListener(quiet, tee, output);
-    parser.addErrorListener(listener_parser);
-    lexer.addErrorListener(listener_lexer);
-    if (show_tokens) {
-        for (var i = 0; ; ++i) {
-            var ro_token = lexer.nextToken();
-            var token = ro_token;
-            token.tokenIndex = i;
-            console.error(token.toString());
-            if (token.type === antlr4.Token.EOF)
-                break;
-        }
-        lexer.reset();
-    }
-    if (show_trace) {
-//        parser._interp.trace_atn_sim = true;
-//        antlr4.context.PredictionContext.trace_atn_sim = true;
-    }
-    const timer = new Timer({ label: 'test-timer2' });
-    timer.start();
-    const tree = parser.<start_symbol>();
-    timer.stop();
-    var result = "";
-    if (listener_parser.had_error || listener_lexer.had_error) {
-        result = 'fail';
-        error_code = 1;
-    }
-    else {
-        result = 'success';
-    }
-    var t = timer.time().m * 60 + timer.time().s + timer.time().ms / 1000;
-    if (show_tree) {
-        if (tee) {
-            fs.writeFileSync(input_name + ".tree", tree.toStringTree(parser.ruleNames));
-        } else {
-            console.error(tree.toStringTree(parser.ruleNames));
-        }
-    }
-    if (! quiet) {
-        console.error(prefix + 'JavaScript ' + row_number + ' ' + input_name + ' ' + result + ' ' + t);
-    }
-    if (tee) {
-        fs.closeSync(output);
-    }
-}
-
-
-main()

package/.build/grammars-v4/antlr/antlr2/JavaScript/LexerAdaptor.js

@@ -1,118 +0,0 @@
-import antlr4 from 'antlr4';
-import ANTLRv2Lexer from './ANTLRv2Lexer.js';
-
-export default class LexerAdaptor extends antlr4.Lexer
-{
-
-    constructor(input)
-    {
-        super(input);
-        /**
-         *  Generic type for OPTIONS, TOKENS and CHANNELS
-         */
-        this.PREQUEL_CONSTRUCT = -10;
-
-        /**
-         * Track whether we are inside of a rule and whether it is lexical parser. _currentRuleType==Token.INVALID_TYPE
-         * means that we are outside of a rule. At the first sign of a rule name reference and _currentRuleType==invalid, we
-         * can assume that we are starting a parser rule. Similarly, seeing a token reference when not already in rule means
-         * starting a token rule. The terminating ';' of a rule, flips this back to invalid type.
-         *
-         * This is not perfect logic but works. For example, "grammar T;" means that we start and stop a lexical rule for
-         * the "T;". Dangerous but works.
-         *
-         * The whole point of this state information is to distinguish between [..arg actions..] and [charsets]. Char sets
-         * can only occur in lexical rules and arg actions cannot occur.
-         */
-        this._currentRuleType = antlr4.Token.INVALID_TYPE;
-    }
-
-    getCurrentRuleType()
-    {
-        return this._currentRuleType;
-    }
-
-    setCurrentRuleType(ruleType)
-    {
-        this._currentRuleType = ruleType;
-    }
-
-    handleBeginArgument()
-    {
-        if (this.inLexerRule()) {
-            this.pushMode(ANTLRv2Lexer.LexerCharSet);
-            this.more();
-        } else {
-            this.pushMode(ANTLRv2Lexer.Argument);
-        }
-    }
-
-    handleEndArgument()
-    {
-        this.popMode();
-        if (this._modeStack.length > 0) {
-            this._type = ANTLRv2Lexer.ARGUMENT_CONTENT;
-        }
-    }
-
-    handleEndAction()
-    {
-        var oldMode = this._mode;
-        var newMode = this.popMode();
-        var isActionWithinAction = this._modeStack.length > 0
-           && newMode == ANTLRv2Lexer.Actionx
-           && oldMode == newMode;
-
-        if (isActionWithinAction) {
-            this._type = ANTLRv2Lexer.ACTION_CONTENT;
-        }
-    }
-
-    handleOptionsLBrace() {
-		this._type = ANTLRv2Lexer.LBRACE;
-    }
-
-    emit()
-    {
-        if ((this._type == ANTLRv2Lexer.OPTIONS || this._type == ANTLRv2Lexer.TOKENS)
-            && this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // enter prequel construct ending with an RBRACE
-            this.setCurrentRuleType(this.PREQUEL_CONSTRUCT);
-        } else if (this._type == ANTLRv2Lexer.RBRACE && this.getCurrentRuleType() == this.PREQUEL_CONSTRUCT) { // exit prequel construct
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        } else if (this._type == ANTLRv2Lexer.AT && this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // enter action
-            this.setCurrentRuleType(ANTLRv2Lexer.AT);
-        } else if (this._type == ANTLRv2Lexer.END_ACTION && this.getCurrentRuleType() == ANTLRv2Lexer.AT) { // exit action
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        } else if (this._type == ANTLRv2Lexer.ID) {
-            var firstChar = this._input.getText(this._tokenStartCharIndex, this._tokenStartCharIndex);
-            var c = firstChar.charAt(0);
-            if (c == c.toUpperCase()) {
-                this._type = ANTLRv2Lexer.TOKEN_REF;
-            } else {
-                this._type = ANTLRv2Lexer.RULE_REF;
-            }
-
-            if (this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // if outside of rule def
-                this.setCurrentRuleType(this._type); // set to inside lexer or parser rule
-            }
-        } else if (this._type == ANTLRv2Lexer.SEMI) { // exit rule def
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        }
-
-        return super.emit();
-    }
-
-    inLexerRule() {
-        return this.getCurrentRuleType() == ANTLRv2Lexer.TOKEN_REF;
-    }
-
-    inParserRule() { // not used, but added for clarity
-        return this.getCurrentRuleType() == ANTLRv2Lexer.RULE_REF;
-    }
-
-    reset()
-    {
-        this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        super.reset();
-    }
-}

package/.build/grammars-v4/antlr/antlr3/JavaScript/LexerAdaptor.js

@@ -1,118 +0,0 @@
-import antlr4 from 'antlr4';
-import ANTLRv3Lexer from './ANTLRv3Lexer.js';
-
-export default class LexerAdaptor extends antlr4.Lexer
-{
-
-    constructor(input)
-    {
-        super(input);
-        /**
-         *  Generic type for OPTIONS, TOKENS and CHANNELS
-         */
-        this.PREQUEL_CONSTRUCT = -10;
-
-        /**
-         * Track whether we are inside of a rule and whether it is lexical parser. _currentRuleType==Token.INVALID_TYPE
-         * means that we are outside of a rule. At the first sign of a rule name reference and _currentRuleType==invalid, we
-         * can assume that we are starting a parser rule. Similarly, seeing a token reference when not already in rule means
-         * starting a token rule. The terminating ';' of a rule, flips this back to invalid type.
-         *
-         * This is not perfect logic but works. For example, "grammar T;" means that we start and stop a lexical rule for
-         * the "T;". Dangerous but works.
-         *
-         * The whole point of this state information is to distinguish between [..arg actions..] and [charsets]. Char sets
-         * can only occur in lexical rules and arg actions cannot occur.
-         */
-        this._currentRuleType = antlr4.Token.INVALID_TYPE;
-    }
-
-    getCurrentRuleType()
-    {
-        return this._currentRuleType;
-    }
-
-    setCurrentRuleType(ruleType)
-    {
-        this._currentRuleType = ruleType;
-    }
-
-    handleBeginArgument()
-    {
-        if (this.inLexerRule()) {
-            this.pushMode(ANTLRv3Lexer.LexerCharSet);
-            this.more();
-        } else {
-            this.pushMode(ANTLRv3Lexer.Argument);
-        }
-    }
-
-    handleEndArgument()
-    {
-        this.popMode();
-        if (this._modeStack.length > 0) {
-            this._type = ANTLRv3Lexer.ARGUMENT_CONTENT;
-        }
-    }
-
-    handleEndAction()
-    {
-        var oldMode = this._mode;
-        var newMode = this.popMode();
-        var isActionWithinAction = this._modeStack.length > 0
-           && newMode == ANTLRv3Lexer.Actionx
-           && oldMode == newMode;
-
-        if (isActionWithinAction) {
-            this._type = ANTLRv3Lexer.ACTION_CONTENT;
-        }
-    }
-
-    handleOptionsLBrace() {
-		this._type = ANTLRv3Lexer.LBRACE;
-    }
-
-    emit()
-    {
-        if ((this._type == ANTLRv3Lexer.OPTIONS || this._type == ANTLRv3Lexer.TOKENS)
-            && this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // enter prequel construct ending with an RBRACE
-            this.setCurrentRuleType(this.PREQUEL_CONSTRUCT);
-        } else if (this._type == ANTLRv3Lexer.RBRACE && this.getCurrentRuleType() == this.PREQUEL_CONSTRUCT) { // exit prequel construct
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        } else if (this._type == ANTLRv3Lexer.AT && this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // enter action
-            this.setCurrentRuleType(ANTLRv3Lexer.AT);
-        } else if (this._type == ANTLRv3Lexer.END_ACTION && this.getCurrentRuleType() == ANTLRv3Lexer.AT) { // exit action
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        } else if (this._type == ANTLRv3Lexer.ID) {
-            var firstChar = this._input.getText(this._tokenStartCharIndex, this._tokenStartCharIndex);
-            var c = firstChar.charAt(0);
-            if (c == c.toUpperCase()) {
-                this._type = ANTLRv3Lexer.TOKEN_REF;
-            } else {
-                this._type = ANTLRv3Lexer.RULE_REF;
-            }
-
-            if (this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // if outside of rule def
-                this.setCurrentRuleType(this._type); // set to inside lexer or parser rule
-            }
-        } else if (this._type == ANTLRv3Lexer.SEMI) { // exit rule def
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        }
-
-        return super.emit();
-    }
-
-    inLexerRule() {
-        return this.getCurrentRuleType() == ANTLRv3Lexer.TOKEN_REF;
-    }
-
-    inParserRule() { // not used, but added for clarity
-        return this.getCurrentRuleType() == ANTLRv3Lexer.RULE_REF;
-    }
-
-    reset()
-    {
-        this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        super.reset();
-    }
-}

package/.build/grammars-v4/antlr/antlr4/JavaScript/LexerAdaptor.js

@@ -1,107 +0,0 @@
-import antlr4 from 'antlr4';
-import ANTLRv4Lexer from './ANTLRv4Lexer.js';
-
-export default class LexerAdaptor extends antlr4.Lexer
-{
-
-    constructor(input)
-    {
-        super(input);
-        /**
-         *  Generic type for OPTIONS, TOKENS and CHANNELS
-         */
-        this.PREQUEL_CONSTRUCT = -10;
-        this.OPTIONS_CONSTRUCT = -11;
-
-        /**
-         * Track whether we are inside of a rule and whether it is lexical parser. _currentRuleType==Token.INVALID_TYPE
-         * means that we are outside of a rule. At the first sign of a rule name reference and _currentRuleType==invalid, we
-         * can assume that we are starting a parser rule. Similarly, seeing a token reference when not already in rule means
-         * starting a token rule. The terminating ';' of a rule, flips this back to invalid type.
-         *
-         * This is not perfect logic but works. For example, "grammar T;" means that we start and stop a lexical rule for
-         * the "T;". Dangerous but works.
-         *
-         * The whole point of this state information is to distinguish between [..arg actions..] and [charsets]. Char sets
-         * can only occur in lexical rules and arg actions cannot occur.
-         */
-        this._currentRuleType = antlr4.Token.INVALID_TYPE;
-    }
-
-    getCurrentRuleType()
-    {
-        return this._currentRuleType;
-    }
-
-    setCurrentRuleType(ruleType)
-    {
-        this._currentRuleType = ruleType;
-    }
-
-    handleBeginArgument()
-    {
-        if (this.inLexerRule()) {
-            this.pushMode(ANTLRv4Lexer.LexerCharSet);
-            this.more();
-        } else {
-            this.pushMode(ANTLRv4Lexer.Argument);
-        }
-    }
-
-    handleEndArgument()
-    {
-        this.popMode();
-        if (this._modeStack.length > 0) {
-            this._type = ANTLRv4Lexer.ARGUMENT_CONTENT;
-        }
-    }
-
-    emit()
-    {
-        if ((this._type == ANTLRv4Lexer.OPTIONS || this._type == ANTLRv4Lexer.TOKENS || this._type == ANTLRv4Lexer.CHANNELS)
-            && this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // enter prequel construct ending with an RBRACE
-            this.setCurrentRuleType(this.PREQUEL_CONSTRUCT);
-        } else if (this._type == ANTLRv4Lexer.OPTIONS && this.getCurrentRuleType() == ANTLRv4Lexer.TOKEN_REF) {
-            this.setCurrentRuleType(this.OPTIONS_CONSTRUCT);
-        } else if (this._type == ANTLRv4Lexer.RBRACE && this.getCurrentRuleType() == this.PREQUEL_CONSTRUCT) { // exit prequel construct
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        } else if (this._type == ANTLRv4Lexer.RBRACE && this.getCurrentRuleType() == this.OPTIONS_CONSTRUCT) { // exit options
-            this.setCurrentRuleType(ANTLRv4Lexer.TOKEN_REF);
-        } else if (this._type == ANTLRv4Lexer.AT && this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // enter action
-            this.setCurrentRuleType(ANTLRv4Lexer.AT);
-        } else if (this._type == ANTLRv4Lexer.SEMI && this.getCurrentRuleType() == this.OPTIONS_CONSTRUCT) { // ';' in options { .... }. Don't change anything.
-        } else if (this._type == ANTLRv4Lexer.ACTION && this.getCurrentRuleType() == ANTLRv4Lexer.AT) { // exit action
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        } else if (this._type == ANTLRv4Lexer.ID) {
-            var firstChar = this._input.getText(this._tokenStartCharIndex, this._tokenStartCharIndex);
-            var c = firstChar.charAt(0);
-            if (c == c.toUpperCase()) {
-                this._type = ANTLRv4Lexer.TOKEN_REF;
-            } else {
-                this._type = ANTLRv4Lexer.RULE_REF;
-            }
-
-            if (this.getCurrentRuleType() == antlr4.Token.INVALID_TYPE) { // if outside of rule def
-                this.setCurrentRuleType(this._type); // set to inside lexer or parser rule
-            }
-        } else if (this._type == ANTLRv4Lexer.SEMI) { // exit rule def
-            this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        }
-
-        return super.emit();
-    }
-
-    inLexerRule() {
-        return this.getCurrentRuleType() == ANTLRv4Lexer.TOKEN_REF;
-    }
-
-    inParserRule() { // not used, but added for clarity
-        return this.getCurrentRuleType() == ANTLRv4Lexer.RULE_REF;
-    }
-
-    reset()
-    {
-        this.setCurrentRuleType(antlr4.Token.INVALID_TYPE);
-        super.reset();
-    }
-}

package/.build/grammars-v4/bison/JavaScript/BisonLexerBase.js

@@ -1,32 +0,0 @@
-import antlr4 from 'antlr4';
-import BisonLexer from './BisonLexer.js';
-
-export default class BisonLexerBase extends antlr4.Lexer {
-    constructor(input) {
-        super(input);
-        this.percent_percent_count = 0;
-    }
-
-    NextMode()
-    {
-	    ++this.percent_percent_count;
-	    if (this.percent_percent_count == 1)
-	    {
-		    return;
-	    } else if (this.percent_percent_count == 2)
-	    {
-		    this.pushMode(BisonLexer.EpilogueMode);
-		    return;
-	    } else
-	    {
-		    this.type = BisonLexer.PercentPercent;
-		    return;
-	    }
-    }
-
-    reset() {
-        this.percent_percent_count = 0;
-        super.reset();
-    }
-}
-

package/.build/grammars-v4/bnf/JavaScript/bnfParserBase.js

@@ -1,18 +0,0 @@
-import antlr4 from 'antlr4';
-import bnfParser from './bnfParser.js';
-import bnfLexer from './bnfLexer.js';
-
-export default class bnfParserBase extends antlr4.Parser {
-
-	constructor(input) {
-		super(input);
-	}
-
-	NotNL()
-	{
-		var i = 1;
-		var c = this._input.LT(i);
-		var v = c.Type != bnfParser.NL;
-		return v;
-	}
-}

package/.build/grammars-v4/cpp/JavaScript/CPP14ParserBase.js

@@ -1,20 +0,0 @@
-import antlr4 from 'antlr4';
-import CPP14Parser from './CPP14Parser.js';
-
-export default class CPP14ParserBase extends antlr4.Parser {
-    constructor(input) {
-        super(input);
-    }
-
-    IsPureSpecifierAllowed() {
-        try {
-            var x = this._ctx; // memberDeclarator
-            var c = x.getChild(0).getChild(0);
-            var c2 = c.getChild(0);
-            var p = c2.getChild(1);
-            return p.constructor === CPP14Parser.ParametersAndQualifiersContext;
-        } catch (e) {
-        }
-        return false;
-    }
-}

package/.build/grammars-v4/dart2/JavaScript/Dart2LexerBase.js

@@ -1,12 +0,0 @@
-import antlr4 from 'antlr4';
-import Dart2Lexer from './Dart2Lexer.js';
-
-export default class Dart2LexerBase extends antlr4.Lexer {
-    constructor(input) {
-        super(input);
-    }
-    CheckNotOpenBrace() {
-        return this._input.LA(1) !== "{".codePointAt(0);
-    }
-}
-

package/.build/grammars-v4/fortran/fortran77/JavaScript/Fortran77LexerBase.js

@@ -1,8 +0,0 @@
-import antlr4 from 'antlr4';
-import Fortran77Lexer from './Fortran77Lexer.js';
-
-export default class Fortran77LexerBase extends antlr4.Lexer {
-	IsColumnZero(pos) {
-		return this.column == 0;
-	}
-}

package/.build/grammars-v4/fortran/fortran90/JavaScript/Fortran90LexerBase.js

@@ -1,8 +0,0 @@
-import antlr4 from 'antlr4';
-import Fortran90Lexer from './Fortran90Lexer.js';
-
-export default class Fortran90LexerBase extends antlr4.Lexer {
-	IsColumnZero(pos) {
-		return this.column == 0;
-	}
-}

package/.build/grammars-v4/golang/JavaScript/GoParserBase.js

@@ -1,27 +0,0 @@
-import { Parser, Token } from 'antlr4';
-import GoLexer from './GoLexer.js';
-
-export default class GoParserBase extends Parser {
-    constructor(input) {
-        super(input);
-    }
-
-    closingBracket() {
-        const stream = this._input;
-        const la = stream.LA(1);
-        return la === GoLexer.R_CURLY || la === GoLexer.R_PAREN || la === Token.EOF;
-    }
-
-    isType() {
-        const stream = this._input;
-        const la = stream.LA(1);
-        return la !== GoLexer.IDENTIFIER;
-    }
-
-    isNotReceive() {
-        const stream = this._input;
-        const la = stream.LA(2);
-        return la !== GoLexer.RECEIVE;
-    }
-}
-