Ignored words work a little better.

Author: goatonabicycle

static/js/pos-core-analyzer.js

@@ -32,6 +32,9 @@ const posAnalyzer = {
 
       sentence.terms.forEach((term, index) => {
         const word = term.text.toLowerCase().trim();
+        if (!word || ignoredWordsSet.has(word)) {
+          return;
+        }
         const tags = term.tags || [];
 
         if (!word || ignoredWordsSet.has(word)) return;

static/js/track-initializer.js

@@ -3,29 +3,54 @@ const trackInitializer = {
     if (!lyricsElement) return;
 
     const track = document.querySelector(`[id^="trackDetails${trackIndex}"]`);
-    const ignoredWordsStr = track?.dataset.ignoredWords || '';
-    const ignoredWords = ignoredWordsStr.split(',').map(w => w.trim().toLowerCase()).filter(Boolean);
-    const ignoredWordsSet = new Set(ignoredWords);
-
-    const words = lyricsElement.innerHTML
-      .split(/\n/)
-      .map(line => line.trim()
-        .split(/(\s+)/)
-        .map(word => {
-          const cleanedWord = cleanWord(word);
-          if (cleanedWord.length > 0 && ignoredWordsSet.has(cleanedWord)) {
-            return word;
-          }
-          if (cleanedWord.length > 0) {
-            return this.createWordSpan(word, cleanedWord, trackIndex);
-          }
-          return word;
-        })
-        .join('')
-      )
-      .join('\n');
-
-    lyricsElement.innerHTML = words;
+
+    const ignoredWords = (track?.dataset.ignoredWords || '').split(',').map(w => w.trim()).filter(Boolean);
+    const patterns = new Set(ignoredWords.filter(w => /[()[\]{}:]/.test(w)));
+    const exactWords = new Set(ignoredWords.filter(w => !/[()[\]{}:]/.test(w)));
+
+    const expandedIgnoredSet = new Set(exactWords);
+    exactWords.forEach(word => {
+      const cleaned = cleanWord(word);
+      if (cleaned) expandedIgnoredSet.add(cleaned);
+    });
+
+    const lines = lyricsElement.innerHTML.split(/\n/);
+    const processedLines = lines.map(line => {
+      let result = line;
+
+      patterns.forEach(ignored => {
+        const escapedIgnored = ignored.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`(${escapedIgnored})`, 'g');
+        result = result.replace(regex, (match) => match);
+      });
+
+      const words = result.split(/(\s+)/);
+      return words.map(segment => {
+        if (!segment.trim()) return segment;
+
+        if (patterns.has(segment)) return segment;
+
+        const cleanedWord = cleanWord(segment);
+        if (!cleanedWord) return segment;
+
+        if (expandedIgnoredSet.has(cleanedWord)) return segment;
+
+        return this.createWordSpan(segment, cleanedWord, trackIndex);
+      }).join('');
+    });
+
+    lyricsElement.innerHTML = processedLines.join('\n');
+
+    const wordCountContainer = track.querySelector('.word-counts');
+    if (wordCountContainer) {
+      const wordCountElements = wordCountContainer.querySelectorAll('[id^="wordCount"]');
+      wordCountElements.forEach(element => {
+        const word = element.getAttribute('data-word');
+        if (expandedIgnoredSet.has(word)) {
+          element.remove();
+        }
+      });
+    }
   },
 
   createWordSpan(originalWord, cleanedWord, trackIndex) {
@@ -158,4 +183,35 @@ function copyDebugInfo(trackIndex) {
   });
 }
 window.copyDebugInfo = copyDebugInfo;
-window.trackInitializer = trackInitializer;
+window.trackInitializer = trackInitializer;
+
+function copyIgnoredWordsInfo(trackIndex) {
+  const trackElement = document.querySelector(`[id^="trackDetails${trackIndex}"]`);
+  const ignoredWordsStr = trackElement?.dataset.ignoredWords || '';
+  const lyrics = document.getElementById(`lyrics${trackIndex}`).innerHTML;
+
+  const info = {
+    trackIndex,
+    ignoredWords: ignoredWordsStr,
+    ignoredWordsList: ignoredWordsStr.split(',').map(w => w.trim()).filter(Boolean),
+    trackHTML: lyrics,
+    wordElements: Array.from(document.querySelectorAll(`.word[data-track="${trackIndex}"]`))
+      .map(el => ({
+        word: el.getAttribute('data-word'),
+        isInteractive: true
+      })),
+    textNodes: Array.from(document.getElementById(`lyrics${trackIndex}`).childNodes)
+      .filter(node => node.nodeType === 3)
+      .map(node => node.textContent.trim())
+      .filter(text => text.length > 0)
+  };
+
+  navigator.clipboard.writeText(JSON.stringify(info, null, 2)).then(() => {
+    const button = document.querySelector(`button[onclick="copyIgnoredWordsInfo(${trackIndex})"]`);
+    button.textContent = 'Copied!';
+    setTimeout(() => {
+      button.textContent = 'Debug Ignored Words';
+    }, 2000);
+  });
+}
+window.copyIgnoredWordsInfo = copyIgnoredWordsInfo;

templates/frontend/pages/album-details.html

@@ -161,6 +161,9 @@ <h3 class="text-lg font-bold">
                                 >
                                 Copy Debug Info
                                 </button>
+                                <button onclick="copyIgnoredWordsInfo({{ $trackIndex }})" class="px-2 py-1 text-xs bg-purple-700 text-white rounded hover:bg-purple-600 transition-colors">
+                                    Debug Ignored Words
+                                </button>
                             {{ end }}
                         </div>
 

words/words.go

@@ -2,6 +2,7 @@ package words
 
 import (
 	"millions-of-words/models"
+	"regexp"
 	"sort"
 	"strings"
 	"unicode"
@@ -21,21 +22,36 @@ func CalculateAndSortWordFrequencies(lyrics string, ignoredWords string) ([]mode
 	}
 
 	ignoredWordsMap := make(map[string]bool)
+	var ignoredPatterns []string
 	if ignoredWords != "" {
 		for _, word := range strings.Split(ignoredWords, ",") {
 			word = strings.TrimSpace(word)
 			if word != "" {
-				ignoredWordsMap[word] = true
+				if strings.ContainsAny(word, "()[]{}:") {
+					ignoredPatterns = append(ignoredPatterns, word)
+				} else {
+					ignoredWordsMap[word] = true
+					cleaned := CleanWord(word)
+					if cleaned != "" {
+						ignoredWordsMap[cleaned] = true
+					}
+				}
 			}
 		}
 	}
 
+	processedLyrics := lyrics
+	for _, pattern := range ignoredPatterns {
+		escapedPattern := regexp.QuoteMeta(pattern)
+		processedLyrics = regexp.MustCompile(escapedPattern).ReplaceAllString(processedLyrics, "")
+	}
+
 	wordCounts := make(map[string]int)
 	vowelCount := 0
 	consonantCount := 0
 	wordLengthDistribution := make(map[int]int)
 
-	words := splitLyricsIntoWords(removeItalics(lyrics))
+	words := splitLyricsIntoWords(removeItalics(processedLyrics))
 
 	for _, word := range words {
 		cleanedWord := CleanWord(word)