How to use the antlr4/index.Parser function in antlr4

"BOOLEAN", "ID", "INT", "FLOAT", "STRING", "EQ", "WS" ];

var ruleNames =  [ "mini", "mainExpr", "expr", "function_call", "number", 
                   "seq", "id_seq", "call_arguments", "positional_arguments", 
                   "named_arguments", "named_argument", "array", "object" ];

function MiniParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

MiniParser.prototype = Object.create(antlr4.Parser.prototype);
MiniParser.prototype.constructor = MiniParser;

Object.defineProperty(MiniParser.prototype, "atn", {
	get : function() {
		return atn;
	}
});

MiniParser.EOF = antlr4.Token.EOF;
MiniParser.T__0 = 1;
MiniParser.T__1 = 2;
MiniParser.T__2 = 3;
MiniParser.T__3 = 4;
MiniParser.T__4 = 5;
MiniParser.T__5 = 6;
MiniParser.T__6 = 7;

null, null, "HEX", "INT", "FLOAT", "COMPLEX", "STRING", 
                      "ID", "USER_OP", "NL", "WS" ];

var ruleNames =  [ "prog", "expr", "exprlist", "formlist", "form", "sublist", 
                   "sub" ];

function RParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

RParser.prototype = Object.create(antlr4.Parser.prototype);
RParser.prototype.constructor = RParser;

Object.defineProperty(RParser.prototype, "atn", {
	get : function() {
		return atn;
	}
});

RParser.EOF = antlr4.Token.EOF;
RParser.T__0 = 1;
RParser.T__1 = 2;
RParser.T__2 = 3;
RParser.T__3 = 4;
RParser.T__4 = 5;
RParser.T__5 = 6;
RParser.T__6 = 7;

function TokenWithLineFeedParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

function SkippedTokenParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

var literalNames = [  ];

var symbolicNames = [ null, "COMMENT" ];

var ruleNames =  [ "start" ];

function TokenWithLineFeedParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

TokenWithLineFeedParser.prototype = Object.create(antlr4.Parser.prototype);
TokenWithLineFeedParser.prototype.constructor = TokenWithLineFeedParser;

Object.defineProperty(TokenWithLineFeedParser.prototype, "atn", {
	get : function() {
		return atn;
	}
});

TokenWithLineFeedParser.EOF = antlr4.Token.EOF;
TokenWithLineFeedParser.COMMENT = 1;

TokenWithLineFeedParser.RULE_start = 0;

function StartContext(parser, parent, invokingState) {
	if(parent===undefined) {
	    parent = null;

function RFilter (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;

	  this.curlies = 0;

    return this;
}

function LUFileParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

function SingleTokenParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

"args", "functiondef", "funcbody", "parlist", "tableconstructor", 
                   "fieldlist", "field", "fieldsep", "operatorOr", "operatorAnd", 
                   "operatorComparison", "operatorStrcat", "operatorAddSub", 
                   "operatorMulDivMod", "operatorBitwise", "operatorUnary", 
                   "operatorPower", "number", "string" ];

function LuaParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

LuaParser.prototype = Object.create(antlr4.Parser.prototype);
LuaParser.prototype.constructor = LuaParser;

Object.defineProperty(LuaParser.prototype, "atn", {
	get : function() {
		return atn;
	}
});

LuaParser.EOF = antlr4.Token.EOF;
LuaParser.T__0 = 1;
LuaParser.T__1 = 2;
LuaParser.T__2 = 3;
LuaParser.T__3 = 4;
LuaParser.T__4 = 5;
LuaParser.T__5 = 6;
LuaParser.T__6 = 7;

"defineMacroDirective", "undefineDirective", "functionSpec", 
                   "functionArgs", "directivePayload", "blockContent", "ifBlock", 
                   "elifBlock", "elseBlock", "ifDirective", "elseDirective", 
                   "elifDirective", "endifDirective", "forBlock", "forDirective", 
                   "doneDirective", "endDirective" ];

function SolParser (input) {
	antlr4.Parser.call(this, input);
    this._interp = new antlr4.atn.ParserATNSimulator(this, atn, decisionsToDFA, sharedContextCache);
    this.ruleNames = ruleNames;
    this.literalNames = literalNames;
    this.symbolicNames = symbolicNames;
    return this;
}

SolParser.prototype = Object.create(antlr4.Parser.prototype);
SolParser.prototype.constructor = SolParser;

Object.defineProperty(SolParser.prototype, "atn", {
	get : function() {
		return atn;
	}
});

SolParser.EOF = antlr4.Token.EOF;
SolParser.PP_LINE_BEGIN = 1;
SolParser.PP_BLOCK_BEGIN = 2;
SolParser.BLOCK_COMMENT = 3;
SolParser.LINE_COMMENT = 4;
SolParser.STRING_LITERAL = 5;
SolParser.NUMBER_LITERAL = 6;
SolParser.BOOLEAN_LITERAL = 7;