@lokascript/semantic 1.3.0 → 2.0.0

package/src/tokenizers/german.ts

@@ -26,6 +26,7 @@ import {
   type TimeUnitMapping,
 } from './base';
 import { germanProfile } from '../generators/profiles/german';
+import { GermanMorphologicalNormalizer } from './morphology/german-normalizer';
 
 // =============================================================================
 // German Character Classification
@@ -186,6 +187,7 @@ export class GermanTokenizer extends BaseTokenizer {
   constructor() {
     super();
     this.initializeKeywordsFromProfile(germanProfile, GERMAN_EXTRAS);
+    this.normalizer = new GermanMorphologicalNormalizer();
   }
 
   tokenize(input: string): TokenStream {
@@ -207,6 +209,12 @@ export class GermanTokenizer extends BaseTokenizer {
           continue;
         }
 
+        // Check for property access (obj.prop) vs CSS selector (.active)
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
+
         const selectorToken = this.trySelector(input, pos);
         if (selectorToken) {
           tokens.push(selectorToken);
@@ -279,7 +287,14 @@ export class GermanTokenizer extends BaseTokenizer {
     if (PREPOSITIONS.has(lower)) return 'particle';
     // O(1) Map lookup instead of O(n) array search
     if (this.isKeyword(lower)) return 'keyword';
-    if (token.startsWith('#') || token.startsWith('.') || token.startsWith('[')) return 'selector';
+    if (
+      token.startsWith('#') ||
+      token.startsWith('.') ||
+      token.startsWith('[') ||
+      token.startsWith('*') ||
+      token.startsWith('<')
+    )
+      return 'selector';
     if (token.startsWith('"') || token.startsWith("'")) return 'literal';
     if (/^\d/.test(token)) return 'literal';
     return 'identifier';

package/src/tokenizers/he.ts

@@ -216,6 +216,12 @@ export class HebrewTokenizer extends BaseTokenizer {
           continue;
         }
 
+        // Check for property access (obj.prop) vs CSS selector (.active)
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
+
         const selectorToken = this.trySelector(input, pos);
         if (selectorToken) {
           tokens.push(selectorToken);
@@ -318,7 +324,14 @@ export class HebrewTokenizer extends BaseTokenizer {
   classifyToken(token: string): TokenKind {
     if (PREPOSITIONS.has(token)) return 'particle';
     if (this.isKeyword(token)) return 'keyword';
-    if (token.startsWith('#') || token.startsWith('.') || token.startsWith('[')) return 'selector';
+    if (
+      token.startsWith('#') ||
+      token.startsWith('.') ||
+      token.startsWith('[') ||
+      token.startsWith('*') ||
+      token.startsWith('<')
+    )
+      return 'selector';
     if (token.startsWith('"') || token.startsWith("'")) return 'literal';
     if (/^\d/.test(token)) return 'literal';
 

package/src/tokenizers/hindi.ts

@@ -121,6 +121,12 @@ export class HindiTokenizer extends BaseTokenizer {
           continue;
         }
 
+        // Check for property access (obj.prop) vs CSS selector (.active)
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
+
         const selectorToken = this.trySelector(input, pos);
         if (selectorToken) {
           tokens.push(selectorToken);
@@ -268,7 +274,14 @@ export class HindiTokenizer extends BaseTokenizer {
       return 'keyword';
     }
     if (SINGLE_POSTPOSITIONS.has(value)) return 'particle';
-    if (value.startsWith('.') || value.startsWith('#') || value.startsWith('[')) return 'selector';
+    if (
+      value.startsWith('.') ||
+      value.startsWith('#') ||
+      value.startsWith('[') ||
+      value.startsWith('*') ||
+      value.startsWith('<')
+    )
+      return 'selector';
     if (value.startsWith(':')) return 'identifier';
     if (value.startsWith('"') || value.startsWith("'")) return 'literal';
     if (/^-?\d/.test(value)) return 'literal';

package/src/tokenizers/indonesian.ts

@@ -155,6 +155,12 @@ export class IndonesianTokenizer extends BaseTokenizer {
           continue;
         }
 
+        // Check for property access (obj.prop) vs CSS selector (.active)
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
+
         const selectorToken = this.trySelector(input, pos);
         if (selectorToken) {
           tokens.push(selectorToken);
@@ -227,7 +233,14 @@ export class IndonesianTokenizer extends BaseTokenizer {
     if (PREPOSITIONS.has(lower)) return 'particle';
     // O(1) Map lookup instead of O(n) array search
     if (this.isKeyword(lower)) return 'keyword';
-    if (token.startsWith('#') || token.startsWith('.') || token.startsWith('[')) return 'selector';
+    if (
+      token.startsWith('#') ||
+      token.startsWith('.') ||
+      token.startsWith('[') ||
+      token.startsWith('*') ||
+      token.startsWith('<')
+    )
+      return 'selector';
     if (token.startsWith('"') || token.startsWith("'")) return 'literal';
     if (/^\d/.test(token)) return 'literal';
     return 'identifier';

package/src/tokenizers/italian.ts

@@ -273,6 +273,12 @@ export class ItalianTokenizer extends BaseTokenizer {
           continue;
         }
 
+        // Check for property access (obj.prop) vs CSS selector (.active)
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
+
         const selectorToken = this.trySelector(input, pos);
         if (selectorToken) {
           tokens.push(selectorToken);
@@ -361,7 +367,14 @@ export class ItalianTokenizer extends BaseTokenizer {
     if (PREPOSITIONS.has(lower)) return 'particle';
     // O(1) Map lookup instead of O(n) array search
     if (this.isKeyword(lower)) return 'keyword';
-    if (token.startsWith('#') || token.startsWith('.') || token.startsWith('[')) return 'selector';
+    if (
+      token.startsWith('#') ||
+      token.startsWith('.') ||
+      token.startsWith('[') ||
+      token.startsWith('*') ||
+      token.startsWith('<')
+    )
+      return 'selector';
     if (token.startsWith('"') || token.startsWith("'")) return 'literal';
     if (/^\d/.test(token)) return 'literal';
     if (['==', '!=', '<=', '>=', '<', '>', '&&', '||', '!'].includes(token)) return 'operator';

package/src/tokenizers/japanese.ts

@@ -228,6 +228,12 @@ export class JapaneseTokenizer extends BaseTokenizer {
           continue;
         }
 
+        // Check for property access (obj.prop) vs CSS selector (.active)
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
+
         const selectorToken = this.trySelector(input, pos);
         if (selectorToken) {
           tokens.push(selectorToken);
@@ -353,7 +359,14 @@ export class JapaneseTokenizer extends BaseTokenizer {
     if (PARTICLES.has(token)) return 'particle';
     // O(1) Map lookup instead of O(n) array search
     if (this.isKeyword(token)) return 'keyword';
-    if (token.startsWith('#') || token.startsWith('.') || token.startsWith('[')) return 'selector';
+    if (
+      token.startsWith('#') ||
+      token.startsWith('.') ||
+      token.startsWith('[') ||
+      token.startsWith('*') ||
+      token.startsWith('<')
+    )
+      return 'selector';
     if (token.startsWith('"') || token.startsWith("'") || token.startsWith('「')) return 'literal';
     if (/^\d/.test(token)) return 'literal';
 

package/src/tokenizers/korean.ts

@@ -288,6 +288,11 @@ const KOREAN_EXTRAS: KeywordEntry[] = [
   { native: '내', normalized: 'my' },
   { native: '그것의', normalized: 'its' },
 
+  // Then/conjunction (clause chaining)
+  { native: '그다음', normalized: 'then' },
+  { native: '그런후', normalized: 'then' },
+  { native: '그러면', normalized: 'then' },
+
   // Logical
   { native: '그리고', normalized: 'and' },
   { native: '또는', normalized: 'or' },
@@ -359,6 +364,12 @@ export class KoreanTokenizer extends BaseTokenizer {
           continue;
         }
 
+        // Check for property access (obj.prop) vs CSS selector (.active)
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
+
         const selectorToken = this.trySelector(input, pos);
         if (selectorToken) {
           tokens.push(selectorToken);
@@ -485,7 +496,14 @@ export class KoreanTokenizer extends BaseTokenizer {
     if (PARTICLES.has(token)) return 'particle';
     // O(1) Map lookup instead of O(n) array search
     if (this.isKeyword(token)) return 'keyword';
-    if (token.startsWith('#') || token.startsWith('.') || token.startsWith('[')) return 'selector';
+    if (
+      token.startsWith('#') ||
+      token.startsWith('.') ||
+      token.startsWith('[') ||
+      token.startsWith('*') ||
+      token.startsWith('<')
+    )
+      return 'selector';
     if (token.startsWith('"') || token.startsWith("'")) return 'literal';
     if (/^\d/.test(token)) return 'literal';
 

package/src/tokenizers/morphology/index.ts

@@ -44,3 +44,20 @@ export {
 export { FrenchMorphologicalNormalizer, frenchMorphologicalNormalizer } from './french-normalizer';
 
 export { GermanMorphologicalNormalizer, germanMorphologicalNormalizer } from './german-normalizer';
+
+export {
+  ItalianMorphologicalNormalizer,
+  italianMorphologicalNormalizer,
+} from './italian-normalizer';
+
+export { PolishMorphologicalNormalizer, polishMorphologicalNormalizer } from './polish-normalizer';
+
+export {
+  RussianMorphologicalNormalizer,
+  russianMorphologicalNormalizer,
+} from './russian-normalizer';
+
+export {
+  UkrainianMorphologicalNormalizer,
+  ukrainianMorphologicalNormalizer,
+} from './ukrainian-normalizer';

package/src/tokenizers/morphology/polish-normalizer.ts

@@ -15,12 +15,72 @@
  * mapping them back to their base form for keyword matching.
  */
 
-export interface NormalizationResult {
-  stem: string;
-  suffix?: string;
-  confidence: number;
-  originalForm?: string;
-}
+import type { MorphologicalNormalizer, NormalizationResult } from './types';
+import { noChange, normalized } from './types';
+
+/**
+ * Common imperative forms used in Polish software UI,
+ * mapped to their infinitive counterparts.
+ */
+const IMPERATIVE_TO_INFINITIVE = new Map<string, string>([
+  // Core commands
+  ['przełącz', 'przełączać'],
+  ['przelacz', 'przelaczac'],
+  ['dodaj', 'dodawać'],
+  ['usuń', 'usuwać'],
+  ['usun', 'usuwac'],
+  ['umieść', 'umieszczać'],
+  ['umiesc', 'umieszczac'],
+  ['wstaw', 'wstawiać'],
+  ['ustaw', 'ustawiać'],
+  ['pobierz', 'pobierać'],
+  ['weź', 'brać'],
+  ['wez', 'brac'],
+  ['zwiększ', 'zwiększać'],
+  ['zwieksz', 'zwiekszac'],
+  ['zmniejsz', 'zmniejszać'],
+  ['pokaż', 'pokazywać'],
+  ['pokaz', 'pokazywac'],
+  ['ukryj', 'ukrywać'],
+  ['schowaj', 'schowywać'],
+  ['czekaj', 'czekać'],
+  ['poczekaj', 'poczekać'],
+  ['idź', 'iść'],
+  ['idz', 'isc'],
+  ['przejdź', 'przejść'],
+  ['przejdz', 'przejsc'],
+  ['wywołaj', 'wywoływać'],
+  ['wywolaj', 'wywolywac'],
+  ['wyślij', 'wysyłać'],
+  ['wyslij', 'wysylac'],
+  ['loguj', 'logować'],
+  ['wypisz', 'wypisywać'],
+  ['sklonuj', 'sklonować'],
+  ['kopiuj', 'kopiować'],
+  ['zamień', 'zamieniać'],
+  ['zamien', 'zamieniac'],
+  ['utwórz', 'tworzyć'],
+  ['utworz', 'tworzyc'],
+  ['stwórz', 'stwarzać'],
+  ['stworz', 'stwarzac'],
+  ['skup', 'skupiać'],
+  ['rozmyj', 'rozmywać'],
+  ['nawiguj', 'nawigować'],
+  ['załaduj', 'ładować'],
+  ['zaladuj', 'ladowac'],
+  ['powtórz', 'powtarzać'],
+  ['powtorz', 'powtarzac'],
+  ['kontynuuj', 'kontynuować'],
+  ['zatrzymaj', 'zatrzymywać'],
+  ['przerwij', 'przerywać'],
+  ['rzuć', 'rzucać'],
+  ['rzuc', 'rzucac'],
+  ['zwróć', 'zwracać'],
+  ['zwroc', 'zwracac'],
+  ['inicjuj', 'inicjować'],
+  ['zainstaluj', 'instalować'],
+  ['zmierz', 'mierzyć'],
+]);
 
 /**
  * Polish Morphological Normalizer
@@ -30,36 +90,47 @@ export interface NormalizationResult {
  * - Infinitive endings: -ać, -eć, -ić, -yć, -ąć
  * - Present tense endings: -am, -em, -ę, -asz, -esz, -isz, -ysz
  */
-export class PolishMorphologicalNormalizer {
+export class PolishMorphologicalNormalizer implements MorphologicalNormalizer {
+  readonly language = 'pl';
+
   /**
-   * Normalize a Polish verb to its base/infinitive form
+   * Check if a word appears to be a Polish verb form that can be normalized.
+   */
+  isNormalizable(word: string): boolean {
+    if (word.length < 3) return false;
+    // Check for Polish-specific characters or Latin letters
+    return /[a-zA-ZąęćńóśźżłĄĘĆŃÓŚŹŻŁ]/.test(word);
+  }
+
+  /**
+   * Normalize a Polish verb to its base/infinitive form.
    */
   normalize(word: string): NormalizationResult {
     const lower = word.toLowerCase();
 
     // Already in infinitive form (-ać, -eć, -ić, -yć, -ąć, -ować)?
     if (this.isInfinitive(lower)) {
-      return { stem: lower, confidence: 1.0 };
+      return noChange(lower);
     }
 
     // Try imperative normalization
     const imperativeResult = this.tryImperativeNormalization(lower);
     if (imperativeResult) return imperativeResult;
 
+    // Try past tense normalization (before present — longer suffixes like -ałem vs -em)
+    const pastResult = this.tryPastTenseNormalization(lower);
+    if (pastResult) return pastResult;
+
     // Try present tense normalization
     const presentResult = this.tryPresentTenseNormalization(lower);
     if (presentResult) return presentResult;
 
-    // Try past tense normalization
-    const pastResult = this.tryPastTenseNormalization(lower);
-    if (pastResult) return pastResult;
-
     // Return as-is if no normalization found
-    return { stem: lower, confidence: 0.5, originalForm: word };
+    return noChange(lower);
   }
 
   /**
-   * Check if word is already in infinitive form
+   * Check if word is already in infinitive form.
    */
   private isInfinitive(word: string): boolean {
     const infinitiveEndings = ['ać', 'eć', 'ić', 'yć', 'ąć', 'ować', 'iwać', 'ywać'];
@@ -67,7 +138,7 @@ export class PolishMorphologicalNormalizer {
   }
 
   /**
-   * Try to normalize imperative form to infinitive
+   * Try to normalize imperative form to infinitive.
    *
    * Polish imperative (2nd person singular) patterns:
    * - pisać → pisz (write)
@@ -77,74 +148,11 @@ export class PolishMorphologicalNormalizer {
    * - uczyć → ucz (teach)
    */
   private tryImperativeNormalization(word: string): NormalizationResult | null {
-    // Common imperative forms used in Polish software UI
-    const imperativeToInfinitive: Map<string, string> = new Map([
-      // Core commands
-      ['przełącz', 'przełączać'],
-      ['przelacz', 'przelaczac'],
-      ['dodaj', 'dodawać'],
-      ['usuń', 'usuwać'],
-      ['usun', 'usuwac'],
-      ['umieść', 'umieszczać'],
-      ['umiesc', 'umieszczac'],
-      ['wstaw', 'wstawiać'],
-      ['ustaw', 'ustawiać'],
-      ['pobierz', 'pobierać'],
-      ['weź', 'brać'],
-      ['wez', 'brac'],
-      ['zwiększ', 'zwiększać'],
-      ['zwieksz', 'zwiekszac'],
-      ['zmniejsz', 'zmniejszać'],
-      ['pokaż', 'pokazywać'],
-      ['pokaz', 'pokazywac'],
-      ['ukryj', 'ukrywać'],
-      ['schowaj', 'schowywać'],
-      ['czekaj', 'czekać'],
-      ['poczekaj', 'poczekać'],
-      ['idź', 'iść'],
-      ['idz', 'isc'],
-      ['przejdź', 'przejść'],
-      ['przejdz', 'przejsc'],
-      ['wywołaj', 'wywoływać'],
-      ['wywolaj', 'wywolywac'],
-      ['wyślij', 'wysyłać'],
-      ['wyslij', 'wysylac'],
-      ['loguj', 'logować'],
-      ['wypisz', 'wypisywać'],
-      ['sklonuj', 'sklonować'],
-      ['kopiuj', 'kopiować'],
-      ['zamień', 'zamieniać'],
-      ['zamien', 'zamieniac'],
-      ['utwórz', 'tworzyć'],
-      ['utworz', 'tworzyc'],
-      ['stwórz', 'stwarzać'],
-      ['stworz', 'stwarzac'],
-      ['skup', 'skupiać'],
-      ['rozmyj', 'rozmywać'],
-      ['nawiguj', 'nawigować'],
-      ['załaduj', 'ładować'],
-      ['zaladuj', 'ladowac'],
-      ['powtórz', 'powtarzać'],
-      ['powtorz', 'powtarzac'],
-      ['kontynuuj', 'kontynuować'],
-      ['zatrzymaj', 'zatrzymywać'],
-      ['przerwij', 'przerywać'],
-      ['rzuć', 'rzucać'],
-      ['rzuc', 'rzucac'],
-      ['zwróć', 'zwracać'],
-      ['zwroc', 'zwracac'],
-      ['inicjuj', 'inicjować'],
-      ['zainstaluj', 'instalować'],
-      ['zmierz', 'mierzyć'],
-    ]);
-
-    if (imperativeToInfinitive.has(word)) {
-      return {
-        stem: imperativeToInfinitive.get(word)!,
-        suffix: 'imperative',
-        confidence: 0.95,
-        originalForm: word,
-      };
+    if (IMPERATIVE_TO_INFINITIVE.has(word)) {
+      return normalized(IMPERATIVE_TO_INFINITIVE.get(word)!, 0.95, {
+        removedSuffixes: ['imperative'],
+        conjugationType: 'imperative',
+      });
     }
 
     // Generic imperative pattern: ends in consonant or -j
@@ -152,71 +160,89 @@ export class PolishMorphologicalNormalizer {
 
     // Pattern: -aj → -ać (czytaj → czytać)
     if (word.endsWith('aj')) {
-      const stem = word.slice(0, -2) + 'ać';
-      return { stem, suffix: 'aj', confidence: 0.8, originalForm: word };
+      return normalized(word.slice(0, -2) + 'ać', 0.8, {
+        removedSuffixes: ['aj'],
+        conjugationType: 'imperative',
+      });
     }
 
     // Pattern: -uj → -ować (kopiuj → kopiować)
     if (word.endsWith('uj')) {
-      const stem = word.slice(0, -2) + 'ować';
-      return { stem, suffix: 'uj', confidence: 0.8, originalForm: word };
+      return normalized(word.slice(0, -2) + 'ować', 0.8, {
+        removedSuffixes: ['uj'],
+        conjugationType: 'imperative',
+      });
     }
 
     // Pattern: -ij → -ić (rób → robić - irregular)
     if (word.endsWith('ij')) {
-      const stem = word.slice(0, -2) + 'ić';
-      return { stem, suffix: 'ij', confidence: 0.75, originalForm: word };
+      return normalized(word.slice(0, -2) + 'ić', 0.75, {
+        removedSuffixes: ['ij'],
+        conjugationType: 'imperative',
+      });
     }
 
     return null;
   }
 
   /**
-   * Try to normalize present tense form to infinitive
+   * Try to normalize present tense form to infinitive.
    */
   private tryPresentTenseNormalization(word: string): NormalizationResult | null {
+    // Pattern: -uję → -ować (pracuję → pracować) — check before -am/-em
+    if (word.endsWith('uję') || word.endsWith('uje')) {
+      return normalized(word.slice(0, -3) + 'ować', 0.85, {
+        removedSuffixes: ['uję'],
+        conjugationType: 'present',
+      });
+    }
+
     // Pattern: -am → -ać (czytam → czytać)
-    if (word.endsWith('am')) {
-      const stem = word.slice(0, -2) + 'ać';
-      return { stem, suffix: 'am', confidence: 0.8, originalForm: word };
+    if (word.endsWith('am') && word.length > 3) {
+      return normalized(word.slice(0, -2) + 'ać', 0.8, {
+        removedSuffixes: ['am'],
+        conjugationType: 'present',
+      });
     }
 
     // Pattern: -em → -eć (rozumiem → rozumieć)
     if (word.endsWith('em') && word.length > 3) {
-      const stem = word.slice(0, -2) + 'eć';
-      return { stem, suffix: 'em', confidence: 0.75, originalForm: word };
+      return normalized(word.slice(0, -2) + 'eć', 0.75, {
+        removedSuffixes: ['em'],
+        conjugationType: 'present',
+      });
     }
 
     // Pattern: -ę → -ać/-eć (piszę → pisać)
-    if (word.endsWith('ę')) {
-      const stem = word.slice(0, -1) + 'ać';
-      return { stem, suffix: 'ę', confidence: 0.7, originalForm: word };
-    }
-
-    // Pattern: -uję → -ować (pracuję → pracować)
-    if (word.endsWith('uję') || word.endsWith('uje')) {
-      const stem = word.slice(0, -3) + 'ować';
-      return { stem, suffix: 'uję', confidence: 0.85, originalForm: word };
+    if (word.endsWith('ę') && word.length > 2) {
+      return normalized(word.slice(0, -1) + 'ać', 0.7, {
+        removedSuffixes: ['ę'],
+        conjugationType: 'present',
+      });
     }
 
     return null;
   }
 
   /**
-   * Try to normalize past tense form to infinitive
+   * Try to normalize past tense form to infinitive.
    */
   private tryPastTenseNormalization(word: string): NormalizationResult | null {
     // Pattern: -ałem/-ałam → -ać (czytałem → czytać)
     if (word.endsWith('ałem') || word.endsWith('ałam')) {
-      const stem = word.slice(0, -4) + 'ać';
-      return { stem, suffix: word.slice(-4), confidence: 0.85, originalForm: word };
+      return normalized(word.slice(0, -4) + 'ać', 0.85, {
+        removedSuffixes: [word.slice(-4)],
+        conjugationType: 'past',
+      });
     }
 
     // Pattern: -ał/-ała → -ać (czytał → czytać)
     if (word.endsWith('ał') || word.endsWith('ała')) {
       const suffixLen = word.endsWith('ała') ? 3 : 2;
-      const stem = word.slice(0, -suffixLen) + 'ać';
-      return { stem, suffix: word.slice(-suffixLen), confidence: 0.8, originalForm: word };
+      return normalized(word.slice(0, -suffixLen) + 'ać', 0.8, {
+        removedSuffixes: [word.slice(-suffixLen)],
+        conjugationType: 'past',
+      });
     }
 
     // Pattern: -iłem/-iłam → -ić (robiłem → robić)
@@ -226,8 +252,10 @@ export class PolishMorphologicalNormalizer {
       word.endsWith('ilem') ||
       word.endsWith('ilam')
     ) {
-      const stem = word.slice(0, -4) + 'ić';
-      return { stem, suffix: word.slice(-4), confidence: 0.85, originalForm: word };
+      return normalized(word.slice(0, -4) + 'ić', 0.85, {
+        removedSuffixes: [word.slice(-4)],
+        conjugationType: 'past',
+      });
     }
 
     // Pattern: -ił/-iła → -ić (robił → robić)
@@ -238,27 +266,15 @@ export class PolishMorphologicalNormalizer {
       word.endsWith('ila')
     ) {
       const suffixLen = word.endsWith('iła') || word.endsWith('ila') ? 3 : 2;
-      const stem = word.slice(0, -suffixLen) + 'ić';
-      return { stem, suffix: word.slice(-suffixLen), confidence: 0.8, originalForm: word };
+      return normalized(word.slice(0, -suffixLen) + 'ić', 0.8, {
+        removedSuffixes: [word.slice(-suffixLen)],
+        conjugationType: 'past',
+      });
     }
 
     return null;
   }
-
-  /**
-   * Check if two words are morphologically related
-   */
-  areMorphologicallyRelated(word1: string, word2: string): boolean {
-    const norm1 = this.normalize(word1);
-    const norm2 = this.normalize(word2);
-
-    // Same stem
-    if (norm1.stem === norm2.stem) return true;
-
-    // Check if one is prefix of the other (for aspectual pairs)
-    const stems = [norm1.stem, norm2.stem].sort((a, b) => a.length - b.length);
-    if (stems[1].endsWith(stems[0].slice(-4))) return true;
-
-    return false;
-  }
 }
+
+// Export singleton instance
+export const polishMorphologicalNormalizer = new PolishMorphologicalNormalizer();