Code review comment: Is it possible to merge this section with the `lookAheadForDocumentationReference` method?  i.e:  lookAheadForDocumentationReference will process all the tokens and returns the token, instead of the lookahead count

Code under review:
private STToken processQuotedIdentifier() {
        while (!reader.isEOF()) {
            int nextChar = reader.peek();
            if (isIdentifierFollowingChar(nextChar)) {
                reader.advance();
                continue;
            }

            if (nextChar != '\\') {
                break;
            }

            

            nextChar = reader.peek(1);
            switch (nextChar) {
                case LexerTerminals.NEWLINE:
                case LexerTerminals.CARRIAGE_RETURN:
                case LexerTerminals.TAB:
                    break;
                case 'u':
                    
                    if (reader.peek(2) == '{') {
                        processStringNumericEscape();
                    } else {
                        reader.advance(2);
                    }
                    continue;
                default:
                    
                    if ('A' <= nextChar && nextChar <= 'Z') {
                        break;
                    }
                    if ('a' <= nextChar && nextChar <= 'z') {
                        break;
                    }

                    reader.advance(2);
                    continue;
                
            }
            break;
        }

        return getIdentifierToken(getLexeme());
    }

    private STToken processTokenStartWithGt() {
        if (peek() == LexerTerminals.EQUAL) {
            reader.advance();
            return getSyntaxToken(SyntaxKind.GT_EQUAL_TOKEN);
        }

        if (reader.peek() != LexerTerminals.GT) {
            return getSyntaxToken(SyntaxKind.GT_TOKEN);
        }

        char nextChar = reader.peek(1);
        switch (nextChar) {
            case LexerTerminals.GT:
                if (reader.peek(2) == LexerTerminals.EQUAL) {
                    
                    reader.advance(2);
                    return getSyntaxToken(SyntaxKind.TRIPPLE_GT_TOKEN);
                }
                return getSyntaxToken(SyntaxKind.GT_TOKEN);
            case LexerTerminals.EQUAL:
                
                reader.advance(1);
                return getSyntaxToken(SyntaxKind.DOUBLE_GT_TOKEN);
            default:
                return getSyntaxToken(SyntaxKind.GT_TOKEN);
        }
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * INTERPOLATION Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readTokenInInterpolation() {
        reader.mark();
        int nextChar = peek();
        switch (nextChar) {
            case LexerTerminals.OPEN_BRACE:
                
                
                
                
                startMode(ParserMode.INTERPOLATION_BRACED_CONTENT);
                return readToken();
            case LexerTerminals.CLOSE_BRACE:
                
                
                endMode();
                reader.advance();
                return getSyntaxTokenWithoutTrailingTrivia(SyntaxKind.CLOSE_BRACE_TOKEN);
            case LexerTerminals.BACKTICK:
                
                
                
            default:
                
                return readToken();
        }
    }

    private STToken getSyntaxTokenWithoutTrailingTrivia(SyntaxKind kind) {
        STNode leadingTrivia = STNodeFactory.createNodeList(this.leadingTriviaList);
        STNode trailingTrivia = STNodeFactory.createNodeList(new ArrayList<>(0));
        return STNodeFactory.createToken(kind, leadingTrivia, trailingTrivia);
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * INTERPOLATION_BRACED_CONTENT Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readTokenInBracedContentInInterpolation() {
        reader.mark();
        int nextChar = peek();
        switch (nextChar) {
            case LexerTerminals.OPEN_BRACE:
                startMode(ParserMode.INTERPOLATION_BRACED_CONTENT);
                break;
            case LexerTerminals.CLOSE_BRACE:
            case LexerTerminals.BACKTICK:
                endMode();
                break;
            default:
                
                break;
        }

        return readToken();
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationToken() {
        reader.mark();
        int nextChar = peek();
        switch (nextChar) {
            case LexerTerminals.PLUS:
                reader.advance();
                switchMode(ParserMode.DOCUMENTATION_PARAMETER);
                return getDocumentationSyntaxToken(SyntaxKind.PLUS_TOKEN);
            case LexerTerminals.BACKTICK:
                if (reader.peek(1) != LexerTerminals.BACKTICK) {
                    reader.advance();
                    switchMode(ParserMode.DOCUMENTATION_BACKTICK_CONTENT);
                    return getSyntaxToken(SyntaxKind.BACKTICK_TOKEN);
                }
                
            default:
                while (!reader.isEOF()) {
                    switch (nextChar) {
                        case LexerTerminals.NEWLINE:
                        case LexerTerminals.CARRIAGE_RETURN:
                            endMode();
                            break;
                        case LexerTerminals.BACKTICK:
                            if (reader.peek(1) != LexerTerminals.BACKTICK) {
                                break;
                            } else if (reader.peek(2) != LexerTerminals.BACKTICK) {
                                
                                reader.advance(2);
                                advanceReaderForBacktickContent(false);
                            } else {
                                
                                reader.advance(3);
                                advanceReaderForBacktickContent(true);
                            }
                            nextChar = peek();
                            continue;
                        default:
                            if (isIdentifierInitialChar(nextChar)) {
                                
                                
                                
                                int readerAdvanceCount = lookAheadForDocumentationReference(nextChar);
                                if (readerAdvanceCount == 0) {
                                    switchMode(ParserMode.DOCUMENTATION_REFERENCE_TYPE);
                                    if (getLexeme().equals("")) {
                                        
                                        
                                        return readDocumentationReferenceTypeToken();
                                    }
                                    break;
                                }
                                reader.advance(readerAdvanceCount);
                            } else {
                                reader.advance();
                            }
                            nextChar = peek();
                            continue;
                    }
                    break;
                }
        }

        return getTemplateString(SyntaxKind.DOCUMENTATION_DESCRIPTION);
    }

    private void advanceReaderForBacktickContent(boolean isTripleBacktick) {
        int nextChar = peek();
        while (!reader.isEOF()) {
            switch (nextChar) {
                case LexerTerminals.BACKTICK:
                    
                    
                    if (isTripleBacktick) {
                        reader.advance();
                        if (peek() != LexerTerminals.BACKTICK) {
                            nextChar = peek();
                            continue;
                        }
                    }
                    reader.advance();
                    if (peek() != LexerTerminals.BACKTICK) {
                        nextChar = peek();
                        continue;
                    }
                    reader.advance();
                    if (peek() != LexerTerminals.BACKTICK) {
                        return;
                    }
                    nextChar = peek();
                    continue;
                case LexerTerminals.NEWLINE:
                    
                    
                    
                    int lookAheadCount = 1;
                    int lookAheadChar = reader.peek(lookAheadCount);
                    while (lookAheadChar == LexerTerminals.SPACE || lookAheadChar == LexerTerminals.TAB) {
                        lookAheadCount++;
                        lookAheadChar = reader.peek(lookAheadCount);
                    }
                    if (lookAheadChar != LexerTerminals.HASH) {
                        return;
                    }
                    reader.advance(lookAheadCount);
                    nextChar = peek();
                    continue;
                default:
                    reader.advance();
                    nextChar = peek();
            }
        }
    }

    private int lookAheadForDocumentationReference(int nextChar) {
        int lookAheadChar = nextChar;
        int lookAheadCount = 0;
        String identifier = "";

        while (isIdentifierInitialChar(lookAheadChar)) {
            identifier = identifier.concat(String.valueOf((char) lookAheadChar));
            lookAheadCount++;
            lookAheadChar = reader.peek(lookAheadCount);
        }

        switch (identifier) {
            case LexerTerminals.TYPE:
            case LexerTerminals.SERVICE:
            case LexerTerminals.VARIABLE:
            case LexerTerminals.VAR:
            case LexerTerminals.ANNOTATION:
            case LexerTerminals.MODULE:
            case LexerTerminals.FUNCTION:
            case LexerTerminals.PARAMETER:
                
                
                while (true) {
                    switch (lookAheadChar) {
                        case LexerTerminals.SPACE:
                            lookAheadCount++;
                            lookAheadChar = reader.peek(lookAheadCount);
                            continue;
                        case LexerTerminals.BACKTICK:
                            
                            if (reader.peek(lookAheadCount + 1) != LexerTerminals.BACKTICK) {
                                
                                
                                return 0;
                            }
                            
                        default:
                            break;
                    }
                    break;
                }
                
            default:
                return lookAheadCount;
        }
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION_PARAMETER Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationParameterToken() {
        reader.mark();
        int nextChar = peek();
        if (isIdentifierInitialChar(nextChar)) {
            reader.advance();
            while (isIdentifierInitialChar(peek())) {
                reader.advance();
            }
            return getDocumentationLiteral(SyntaxKind.PARAMETER_NAME);
        } else if (nextChar == LexerTerminals.MINUS) {
            reader.advance();
            switchMode(ParserMode.DOCUMENTATION);
            return getDocumentationSyntaxToken(SyntaxKind.MINUS_TOKEN);
        } else {
            switchMode(ParserMode.DOCUMENTATION);
            return readDocumentationToken();
        }
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION_REFERENCE_TYPE Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationReferenceTypeToken() {
        int nextChar = peek();
        if (nextChar == LexerTerminals.BACKTICK) {
            reader.advance();
            switchMode(ParserMode.DOCUMENTATION_BACKTICK_CONTENT);
            return getDocumentationSyntaxToken(SyntaxKind.BACKTICK_TOKEN);
        }

        while (isIdentifierInitialChar(peek())) {
            reader.advance();
        }

        return processReferenceType();
    }

    private STToken processReferenceType() {
        String tokenText = getLexeme();
        switch (tokenText) {
            case LexerTerminals.TYPE:
                return getDocumentationSyntaxToken(SyntaxKind.TYPE_DOC_REFERENCE_TOKEN);
            case LexerTerminals.SERVICE:
                return getDocumentationSyntaxToken(SyntaxKind.SERVICE_DOC_REFERENCE_TOKEN);
            case LexerTerminals.VARIABLE:
                return getDocumentationSyntaxToken(SyntaxKind.VARIABLE_DOC_REFERENCE_TOKEN);
            case LexerTerminals.VAR:
                return getDocumentationSyntaxToken(SyntaxKind.VAR_DOC_REFERENCE_TOKEN);
            case LexerTerminals.ANNOTATION:
                return getDocumentationSyntaxToken(SyntaxKind.ANNOTATION_DOC_REFERENCE_TOKEN);
            case LexerTerminals.MODULE:
                return getDocumentationSyntaxToken(SyntaxKind.MODULE_DOC_REFERENCE_TOKEN);
            case LexerTerminals.FUNCTION:
                return getDocumentationSyntaxToken(SyntaxKind.FUNCTION_DOC_REFERENCE_TOKEN);
            case LexerTerminals.PARAMETER:
                return getDocumentationSyntaxToken(SyntaxKind.PARAMETER_DOC_REFERENCE_TOKEN);
            default:
                throw new IllegalStateException();
        }
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION_BACKTICK_CONTENT Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationBacktickContentToken() {
        reader.mark();
        int nextToken = peek();
        if (nextToken == LexerTerminals.BACKTICK) {
            reader.advance();
            switchMode(ParserMode.DOCUMENTATION);
            return getDocumentationSyntaxToken(SyntaxKind.BACKTICK_TOKEN);
        }

        while (!reader.isEOF()) {
            switch (nextToken) {
                case LexerTerminals.BACKTICK:
                case LexerTerminals.NEWLINE:
                    break;
                default:
                    reader.advance();
                    nextToken = peek();
                    continue;
            }
            break;
        }

        return getDocumentationLiteral(SyntaxKind.BACKTICK_CONTENT);
    }
}

Line commented on: reader.advance(readerAdvanceCount);

Revised code:
private STToken processQuotedIdentifier() {
        while (!reader.isEOF()) {
            int nextChar = reader.peek();
            if (isIdentifierFollowingChar(nextChar)) {
                reader.advance();
                continue;
            }

            if (nextChar != '\\') {
                break;
            }

            

            nextChar = reader.peek(1);
            switch (nextChar) {
                case LexerTerminals.NEWLINE:
                case LexerTerminals.CARRIAGE_RETURN:
                case LexerTerminals.TAB:
                    break;
                case 'u':
                    
                    if (reader.peek(2) == '{') {
                        processStringNumericEscape();
                    } else {
                        reader.advance(2);
                    }
                    continue;
                default:
                    
                    if ('A' <= nextChar && nextChar <= 'Z') {
                        break;
                    }
                    if ('a' <= nextChar && nextChar <= 'z') {
                        break;
                    }

                    reader.advance(2);
                    continue;
                
            }
            break;
        }

        return getIdentifierToken(getLexeme());
    }

    private STToken processTokenStartWithGt() {
        if (peek() == LexerTerminals.EQUAL) {
            reader.advance();
            return getSyntaxToken(SyntaxKind.GT_EQUAL_TOKEN);
        }

        if (reader.peek() != LexerTerminals.GT) {
            return getSyntaxToken(SyntaxKind.GT_TOKEN);
        }

        char nextChar = reader.peek(1);
        switch (nextChar) {
            case LexerTerminals.GT:
                if (reader.peek(2) == LexerTerminals.EQUAL) {
                    
                    reader.advance(2);
                    return getSyntaxToken(SyntaxKind.TRIPPLE_GT_TOKEN);
                }
                return getSyntaxToken(SyntaxKind.GT_TOKEN);
            case LexerTerminals.EQUAL:
                
                reader.advance(1);
                return getSyntaxToken(SyntaxKind.DOUBLE_GT_TOKEN);
            default:
                return getSyntaxToken(SyntaxKind.GT_TOKEN);
        }
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * INTERPOLATION Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readTokenInInterpolation() {
        reader.mark();
        int nextChar = peek();
        switch (nextChar) {
            case LexerTerminals.OPEN_BRACE:
                
                
                
                
                startMode(ParserMode.INTERPOLATION_BRACED_CONTENT);
                return readToken();
            case LexerTerminals.CLOSE_BRACE:
                
                
                endMode();
                reader.advance();
                return getSyntaxTokenWithoutTrailingTrivia(SyntaxKind.CLOSE_BRACE_TOKEN);
            case LexerTerminals.BACKTICK:
                
                
                
            default:
                
                return readToken();
        }
    }

    private STToken getSyntaxTokenWithoutTrailingTrivia(SyntaxKind kind) {
        STNode leadingTrivia = STNodeFactory.createNodeList(this.leadingTriviaList);
        STNode trailingTrivia = STNodeFactory.createNodeList(new ArrayList<>(0));
        return STNodeFactory.createToken(kind, leadingTrivia, trailingTrivia);
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * INTERPOLATION_BRACED_CONTENT Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readTokenInBracedContentInInterpolation() {
        reader.mark();
        int nextChar = peek();
        switch (nextChar) {
            case LexerTerminals.OPEN_BRACE:
                startMode(ParserMode.INTERPOLATION_BRACED_CONTENT);
                break;
            case LexerTerminals.CLOSE_BRACE:
            case LexerTerminals.BACKTICK:
                endMode();
                break;
            default:
                
                break;
        }

        return readToken();
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationToken() {
        int nextChar = peek();
        if (nextChar == LexerTerminals.PLUS) {
            reader.advance();
            switchMode(ParserMode.DOCUMENTATION_PARAMETER);
            return getDocumentationSyntaxToken(SyntaxKind.PLUS_TOKEN);
        }
        return readDocumentationInternalToken();
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION_INTERNAL Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationInternalToken() {
        reader.mark();
        int nextChar = peek();
        if (nextChar == LexerTerminals.BACKTICK && reader.peek(1) != LexerTerminals.BACKTICK) {
            reader.advance();
            switchMode(ParserMode.DOCUMENTATION_BACKTICK_CONTENT);
            return getDocumentationSyntaxToken(SyntaxKind.BACKTICK_TOKEN);
        }

        while (!reader.isEOF()) {
            switch (nextChar) {
                case LexerTerminals.NEWLINE:
                case LexerTerminals.CARRIAGE_RETURN:
                    endMode();
                    break;
                case LexerTerminals.BACKTICK:
                    if (reader.peek(1) != LexerTerminals.BACKTICK) {
                        break;
                    } else if (reader.peek(2) != LexerTerminals.BACKTICK) {
                        
                        reader.advance(2);
                        processDocumentationCodeContent(false);
                    } else {
                        
                        reader.advance(3);
                        processDocumentationCodeContent(true);
                    }
                    nextChar = peek();
                    continue;
                default:
                    if (isIdentifierInitialChar(nextChar)) {
                        boolean hasDocumentationReference = processDocumentationReference(nextChar);
                        if (hasDocumentationReference) {
                            switchMode(ParserMode.DOCUMENTATION_REFERENCE_TYPE);
                            break;
                        }
                    } else {
                        reader.advance();
                    }
                    nextChar = peek();
                    continue;
            }
            break;
        }

        if (getLexeme().isEmpty()) {
            
            
            return readDocumentationReferenceTypeToken();
        }
        return getTemplateString(SyntaxKind.DOCUMENTATION_DESCRIPTION);
    }

    private void processDocumentationCodeContent(boolean isTripleBacktick) {
        int nextChar = peek();
        while (!reader.isEOF()) {
            switch (nextChar) {
                case LexerTerminals.BACKTICK:
                    
                    
                    if (isTripleBacktick) {
                        reader.advance();
                        if (peek() != LexerTerminals.BACKTICK) {
                            nextChar = peek();
                            continue;
                        }
                    }
                    reader.advance();
                    if (peek() != LexerTerminals.BACKTICK) {
                        nextChar = peek();
                        continue;
                    }
                    reader.advance();
                    if (peek() != LexerTerminals.BACKTICK) {
                        return;
                    }
                    nextChar = peek();
                    continue;
                case LexerTerminals.CARRIAGE_RETURN:
                case LexerTerminals.NEWLINE:
                    
                    
                    
                    int lookAheadCount = 1;
                    if (peek() == LexerTerminals.CARRIAGE_RETURN && reader.peek(1) == LexerTerminals.NEWLINE) {
                        lookAheadCount++;
                    }
                    int lookAheadChar = reader.peek(lookAheadCount);
                    while (lookAheadChar == LexerTerminals.SPACE || lookAheadChar == LexerTerminals.TAB) {
                        lookAheadCount++;
                        lookAheadChar = reader.peek(lookAheadCount);
                    }
                    if (lookAheadChar != LexerTerminals.HASH) {
                        return;
                    }
                    reader.advance(lookAheadCount);
                    nextChar = peek();
                    continue;
                default:
                    reader.advance();
                    nextChar = peek();
            }
        }
    }

    private boolean processDocumentationReference(int nextChar) {
        
        
        

        int lookAheadChar = nextChar;
        int lookAheadCount = 0;
        String identifier = "";

        while (isIdentifierInitialChar(lookAheadChar)) {
            identifier = identifier.concat(String.valueOf((char) lookAheadChar));
            lookAheadCount++;
            lookAheadChar = reader.peek(lookAheadCount);
        }

        switch (identifier) {
            case LexerTerminals.TYPE:
            case LexerTerminals.SERVICE:
            case LexerTerminals.VARIABLE:
            case LexerTerminals.VAR:
            case LexerTerminals.ANNOTATION:
            case LexerTerminals.MODULE:
            case LexerTerminals.FUNCTION:
            case LexerTerminals.PARAMETER:
                
                
                while (true) {
                    switch (lookAheadChar) {
                        case LexerTerminals.SPACE:
                        case LexerTerminals.TAB:
                            lookAheadCount++;
                            lookAheadChar = reader.peek(lookAheadCount);
                            continue;
                        case LexerTerminals.BACKTICK:
                            
                            if (reader.peek(lookAheadCount + 1) != LexerTerminals.BACKTICK) {
                                
                                
                                return true;
                            }
                            
                        default:
                            break;
                    }
                    break;
                }
                
            default:
                
                reader.advance(lookAheadCount);
                return false;
        }
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION_PARAMETER Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationParameterToken() {
        reader.mark();
        int nextChar = peek();
        if (isIdentifierInitialChar(nextChar)) {
            STToken token;
            reader.advance();
            while (isIdentifierInitialChar(peek())) {
                reader.advance();
            }
            if (LexerTerminals.RETURN.equals(getLexeme())) {
                token = getDocumentationSyntaxToken(SyntaxKind.RETURN_KEYWORD);
            } else {
                token =  getDocumentationLiteral(SyntaxKind.PARAMETER_NAME);
            }
            
            if (peek() != LexerTerminals.MINUS) {
                switchMode(ParserMode.DOCUMENTATION_INTERNAL);
            }
            return token;
        } else if (nextChar == LexerTerminals.MINUS) {
            reader.advance();
            switchMode(ParserMode.DOCUMENTATION_INTERNAL);
            return getDocumentationSyntaxToken(SyntaxKind.MINUS_TOKEN);
        } else {
            switchMode(ParserMode.DOCUMENTATION_INTERNAL);
            return readDocumentationInternalToken();
        }
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION_REFERENCE_TYPE Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationReferenceTypeToken() {
        int nextChar = peek();
        if (nextChar == LexerTerminals.BACKTICK) {
            reader.advance();
            switchMode(ParserMode.DOCUMENTATION_BACKTICK_CONTENT);
            return getDocumentationSyntaxToken(SyntaxKind.BACKTICK_TOKEN);
        }

        while (isIdentifierInitialChar(peek())) {
            reader.advance();
        }

        return processReferenceType();
    }

    private STToken processReferenceType() {
        String tokenText = getLexeme();
        switch (tokenText) {
            case LexerTerminals.TYPE:
                return getDocumentationSyntaxToken(SyntaxKind.TYPE_DOC_REFERENCE_TOKEN);
            case LexerTerminals.SERVICE:
                return getDocumentationSyntaxToken(SyntaxKind.SERVICE_DOC_REFERENCE_TOKEN);
            case LexerTerminals.VARIABLE:
                return getDocumentationSyntaxToken(SyntaxKind.VARIABLE_DOC_REFERENCE_TOKEN);
            case LexerTerminals.VAR:
                return getDocumentationSyntaxToken(SyntaxKind.VAR_DOC_REFERENCE_TOKEN);
            case LexerTerminals.ANNOTATION:
                return getDocumentationSyntaxToken(SyntaxKind.ANNOTATION_DOC_REFERENCE_TOKEN);
            case LexerTerminals.MODULE:
                return getDocumentationSyntaxToken(SyntaxKind.MODULE_DOC_REFERENCE_TOKEN);
            case LexerTerminals.FUNCTION:
                return getDocumentationSyntaxToken(SyntaxKind.FUNCTION_DOC_REFERENCE_TOKEN);
            case LexerTerminals.PARAMETER:
                return getDocumentationSyntaxToken(SyntaxKind.PARAMETER_DOC_REFERENCE_TOKEN);
            default:
                throw new IllegalStateException();
        }
    }

    /*
     * ------------------------------------------------------------------------------------------------------------
     * DOCUMENTATION_BACKTICK_CONTENT Mode
     * ------------------------------------------------------------------------------------------------------------
     */

    private STToken readDocumentationBacktickContentToken() {
        reader.mark();
        int nextToken = peek();
        if (nextToken == LexerTerminals.BACKTICK) {
            reader.advance();
            switchMode(ParserMode.DOCUMENTATION_INTERNAL);
            return getDocumentationSyntaxToken(SyntaxKind.BACKTICK_TOKEN);
        }

        while (!reader.isEOF()) {
            switch (nextToken) {
                case LexerTerminals.BACKTICK:
                case LexerTerminals.NEWLINE:
                case LexerTerminals.CARRIAGE_RETURN:
                    break;
                default:
                    reader.advance();
                    nextToken = peek();
                    continue;
            }
            break;
        }

        return getDocumentationLiteral(SyntaxKind.BACKTICK_CONTENT);
    }
}