How to use the antlr4ts/atn.TransitionType.RULE function in antlr4ts

statePipeline.push({ state: transition.target, tokenIndex: currentEntry.tokenIndex });
                                break;
                            }
                        }
                        continue;
                    }
                    break;

                default:
                    break;
            }

            let transitions = currentEntry.state.getTransitions();
            for (let i = transitions.length - 1; i >= 0; --i) {
                let transition = transitions[i];
                if (transition.serializationType == TransitionType.RULE) {
                    let endStatus = this.processRule(transition.target, currentEntry.tokenIndex, callStack, indentation);
                    statePipeline.push(...endStatus);

                    // See description above for this flag.
                    if (isLeftRecursive && transition.target.ruleIndex == callStack[callStack.length - 1])
                        forceLoopEnd = true;

                } else if (transition.serializationType == TransitionType.PREDICATE) {
                    if (this.checkPredicate(transition as PredicateTransition))
                        statePipeline.push({ state: transition.target, tokenIndex: currentEntry.tokenIndex });
                } else if (transition.isEpsilon) {
                    statePipeline.push({ state: transition.target, tokenIndex: currentEntry.tokenIndex });
                } else if (transition.serializationType == TransitionType.WILDCARD) {
                    if (atCaret) {
                        if (!this.translateToRuleIndex(callStack)) {
                            for (let token of IntervalSet.of(Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType).toList())

if (seen.has(s))
            return;

        seen.add(s);

        if (s == stopState || s.stateType == ATNStateType.RULE_STOP) {
            let set = new FollowSetWithPath();
            set.intervals = IntervalSet.of(Token.EPSILON);
            set.path = ruleStack.slice();
            followSets.push(set);
            return;
        }

        for (let transition of s.getTransitions()) {
            if (transition.serializationType == TransitionType.RULE) {
                let ruleTransition: RuleTransition = transition as RuleTransition;
                if (ruleStack.indexOf(ruleTransition.target.ruleIndex) != -1)
                    continue;

                ruleStack.push(ruleTransition.target.ruleIndex);
                this.collectFollowSets(transition.target, stopState, followSets, seen, ruleStack);
                ruleStack.pop();

            } else if (transition.serializationType == TransitionType.PREDICATE) {
                if (this.checkPredicate(transition as PredicateTransition))
                    this.collectFollowSets(transition.target, stopState, followSets, seen, ruleStack);
            } else if (transition.isEpsilon) {
                this.collectFollowSets(transition.target, stopState, followSets, seen, ruleStack);
            } else if (transition.serializationType == TransitionType.WILDCARD) {
                let set = new FollowSetWithPath();
                set.intervals = IntervalSet.of(Token.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);