Most Common Word solution using TypeScript

Below is my TypeScript solution to the LeetCode "Most Common Word" question.

Algorithm: This solution finds the most common word while only needing to iterate over each character in the paragraph once.

• Create a Set from the banned words array. This adds O(m) time complexity, but allows for O(1) lookups on banned words.
• Create a Set of invalid characters.
• Create a Hash Map of encountered words with a value reflecting how many times the given word has occurred.
• Create a pointer at the beginning of the paragraph and iterate over each character.
  • If a character is valid, add it to a word buffer, and move on to the next character.
  • If a character is invalid or whitespace, consider what is in the buffer a word. Update the Hash Map to reflect the additional occurrence of that word then reset the buffer.
• Return the word that occurred the most.

Time Complexity: The solution creates a Set of all banned words, which takes O(m) time, where m represents the number of banned words. It also iterates over each character in the inputted string exactly one time, which takes O(n) time, where n represents each character in the string. This results in an overall time complexity of O(m + n).

Space Complexity: The solution creates a Set of all banned words, which will take O(m) space, where m represents each banned word in the array. It also creates a Hash Map of each encountered word, which will take O(n) space where n represents each character in the inputted string. This results in an overall space complexity of O(m + n).

/**
 * Most Common Word
 * Given a paragraph and a list of banned words, return 
 * the most frequent word that is not in the list of 
 * banned words. It is guaranteed there is at least 
 * one word that isn't banned, and that the answer is unique.
 *
 * Words in the list of banned words are given in lowercase, 
 * and free of punctuation.  Words in the paragraph are not 
 * case sensitive.  The answer is in lowercase.
 *
 * Time Complexity: O(m + n)
 * Space Complexity: O(m + n)
 *
 * mostCommonWord('foo foo bar', []) // 'foo'
 * mostCommonWord('Foo, Bar BAR!', []) // 'bar'
 * mostCommonWord('foo foo bar', ['foo']) // 'bar'
 */
function mostCommonWord(paragraph: string, bannedWords: string[]): string {
    let invalid = new Set(["!","?","'",",",";","."," "]);
    let banned = new Set(bannedWords);
    let words = new Map();
    let buffer = ""
    let result = "";
    
    for(let ptr = 0; ptr < paragraph.length; ptr++) {
        // character is valid, append it to the buffer
        if (!invalid.has(paragraph[ptr])) {
            buffer += paragraph[ptr].toLowerCase();
            // unless it is the last character, end this iteration
            if (ptr !== paragraph.length - 1) {
                continue;
            }
        }
        
        // character is invalid or is the last one
        if (buffer) {
            // if the word is not banned, increment it's count
            if (!banned.has(buffer)) {
                let occurrences = (words.get(buffer) || 0) + 1;
                let mostOccurrences = (words.get(result) || 0);
                words.set(buffer, occurrences);
                if (occurrences > mostOccurrences) {
                    result = buffer;
                }
            }
            buffer = "";
        }
    }
    return result;
};