TypeError on collectCandidates about antlr4-c3 HOT 5 CLOSED

const suggestExpression = (input) => {
	const inputStream = new antlr4.InputStream(input);
	const lexer = new ExprLexer(inputStream);
	const tokenStream = new antlr4.CommonTokenStream(lexer);

	const parser = new ExprParser(tokenStream);
	const errorListener = new antlr4.error.ErrorListener();
	parser.addErrorListener(errorListener);
	parser.inputStream = tokenStream;
	parser.atn.states.forEach((state) => {
		state.getTransitions = () => state.transitions;
	});

	const tree = parser.expression();
	const core = new c3.CodeCompletionCore(parser);
	return core.collectCandidates(input - 1);
};

            let inputStream = new ANTLRInputStream("var c = a + b()");
            let lexer = new ExprLexer(inputStream);
            let tokenStream = new CommonTokenStream(lexer);

            let parser = new ExprParser(tokenStream);
            let errorListener = new ErrorListener();
            parser.addErrorListener(errorListener);
            let tree = parser.expression();
            expect(errorListener.errorCount, "Test 1").equals(0);

            let core = new c3.CodeCompletionCore(parser);

            // 1) At the input start.
            let candidates = core.collectCandidates(0);

            expect(candidates.tokens.size, "Test 2").to.equal(3);
            expect(candidates.tokens.has(ExprLexer.VAR), "Test 3").to.equal(true);
            expect(candidates.tokens.has(ExprLexer.LET), "Test 4").to.equal(true);
            expect(candidates.tokens.has(ExprLexer.ID), "Test 5").to.equal(true);

            expect(candidates.tokens.get(ExprLexer.VAR), "Test 6").to.eql([ExprLexer.ID, ExprLexer.EQUAL]);
            expect(candidates.tokens.get(ExprLexer.LET), "Test 7").to.eql([ExprLexer.ID, ExprLexer.EQUAL]);
            expect(candidates.tokens.get(ExprLexer.ID), "Test 8").to.eql([]);

grammar Expr;
expression: assignment | simpleExpression;

assignment: (VAR | LET) ID EQUAL simpleExpression;

simpleExpression
    : simpleExpression (PLUS | MINUS) simpleExpression
    | simpleExpression (MULTIPLY | DIVIDE) simpleExpression
    | variableRef
    | functionRef
;

variableRef: ID;
functionRef: ID OPEN_PAR CLOSE_PAR;

VAR: [vV] [aA] [rR];
LET: [lL] [eE] [tT];

PLUS: '+';
MINUS: '-';
MULTIPLY: '*';
DIVIDE: '/';
EQUAL: '=';
OPEN_PAR: '(';
CLOSE_PAR: ')';
ID: [a-zA-Z] [a-zA-Z0-9_]*;
WS: [ \n\r\t] -> channel(HIDDEN);

import antlr4 from 'antlr4';
import * as c3 from 'antlr4-c3';

const suggestExpression = (input) => {
	const inputStream = new antlr4.InputStream(input);
	const lexer = new ExprLexer(inputStream);
	const tokenStream = new antlr4.CommonTokenStream(lexer);
	const parser = new ExprParser(tokenStream);
	const errorListener = new antlr4.error.ErrorListener();
	parser.addErrorListener(errorListener);

	const tree = parser.expression();
	const core = new c3.CodeCompletionCore(parser);
	return core.collectCandidates(0);
};

CodeCompletionCore.js:67 Uncaught TypeError: Cannot read property 'index' of undefined
    at CodeCompletionCore.collectCandidates (CodeCompletionCore.js:67)

import BaseExprParser from './ExprParser.ts';

class ExprParser extends BaseExprParser {
	constructor(...args) {
		super(...args);

		// The antlr4ts Parser expects `tryLT` to be defined on the token stream
		// and `LT` to defer to the `tryLT`.
		// @see 'node_modules/antlr4ts/Parser.js
		// @see 'node_modules/antlr4ts/BufferedTokenStream.js:203
		this._input.tryLT = this._input.LT;
		this._input.LT = function (k) {
			const result = this.tryLT(k);
			if (result === undefined) {
				throw new RangeError('requested lookback index out of range');
			}
			return result;
		};
	}
}