@lokascript/semantic 1.3.0 → 2.0.0

package/dist/languages/ru.d.ts

@@ -1,37 +1,18 @@
-import { B as BaseTokenizer, T as TokenStream, a as TokenKind, L as LanguageProfile } from '../types-BY3Id07j.js';
-
 /**
- * Russian Tokenizer
+ * Russian Language Module
  *
- * Tokenizes Russian hyperscript input.
- * Russian characteristics:
- * - SVO word order (relatively free, but SVO is common)
- * - Space-separated words
- * - Prepositions
- * - Cyrillic alphabet
- * - Fusional morphology with verb conjugations
- * - Imperative form used in software UI (infinitive also common)
- */
-
-declare class RussianTokenizer extends BaseTokenizer {
-    readonly language = "ru";
-    readonly direction: "ltr";
-    constructor();
-    tokenize(input: string): TokenStream;
-    classifyToken(token: string): TokenKind;
-    private extractWord;
-    private extractNumber;
-}
-declare const russianTokenizer: RussianTokenizer;
-
-/**
- * Russian Language Profile
+ * Self-registering module that sets up Russian language support.
+ * Import this module to enable Russian in the semantic parser.
+ *
+ * @example
+ * ```typescript
+ * // Enable Russian
+ * import '@lokascript/semantic/languages/ru';
  *
- * SVO word order, prepositions, space-separated.
- * Russian is a fusional language with rich verb conjugation.
- * Uses infinitive form in software UI (industry standard).
+ * // Or import everything
+ * import '@lokascript/semantic/languages/_all';
+ * ```
  */
-
-declare const russianProfile: LanguageProfile;
-
-export { russianProfile, russianTokenizer };
+export { russianTokenizer } from '../tokenizers/russian';
+export { russianProfile } from '../generators/profiles/russian';
+//# sourceMappingURL=ru.d.ts.map

package/dist/languages/ru.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ru.d.ts","sourceRoot":"","sources":["../../src/languages/ru.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC"}

package/dist/languages/ru.js

@@ -8,7 +8,7 @@ function registerLanguage(code, tokenizer, profile) {
   patternCache.delete(code);
 }
 
-// src/tokenizers/base.ts
+// src/tokenizers/token-utils.ts
 var TokenStreamImpl = class {
   constructor(tokens, language) {
     this.pos = 0;
@@ -73,18 +73,15 @@ function createToken(value, kind, position, normalizedOrOptions) {
     return { value, kind, position, normalized: normalizedOrOptions };
   }
   if (normalizedOrOptions) {
-    const { normalized, stem, stemConfidence } = normalizedOrOptions;
-    const token = { value, kind, position };
-    if (normalized !== void 0) {
-      token.normalized = normalized;
-    }
-    if (stem !== void 0) {
-      token.stem = stem;
-      if (stemConfidence !== void 0) {
-        token.stemConfidence = stemConfidence;
-      }
-    }
-    return token;
+    const { normalized: normalized2, stem, stemConfidence } = normalizedOrOptions;
+    return {
+      value,
+      kind,
+      position,
+      ...normalized2 !== void 0 && { normalized: normalized2 },
+      ...stem !== void 0 && { stem },
+      ...stemConfidence !== void 0 && { stemConfidence }
+    };
   }
   return { value, kind, position };
 }
@@ -106,11 +103,15 @@ function isAsciiLetter(char) {
 function isAsciiIdentifierChar(char) {
   return /[a-zA-Z0-9_-]/.test(char);
 }
+
+// src/tokenizers/char-classifiers.ts
 function createLatinCharClassifiers(letterPattern) {
   const isLetter = (char) => letterPattern.test(char);
   const isIdentifierChar = (char) => isLetter(char) || /[0-9_-]/.test(char);
   return { isLetter, isIdentifierChar };
 }
+
+// src/tokenizers/extractors.ts
 function extractCssSelector(input, startPos) {
   if (startPos >= input.length) return null;
   const char = input[startPos];
@@ -368,6 +369,8 @@ function extractNumber(input, startPos) {
   }
   return number;
 }
+
+// src/tokenizers/base-tokenizer.ts
 var _BaseTokenizer = class _BaseTokenizer {
   constructor() {
     /** Keywords derived from profile, sorted longest-first for greedy matching */
@@ -375,6 +378,34 @@ var _BaseTokenizer = class _BaseTokenizer {
     /** Map for O(1) keyword lookups by lowercase native word */
     this.profileKeywordMap = /* @__PURE__ */ new Map();
   }
+  /**
+   * Check if current position is a property access (obj.prop) vs CSS selector (.active).
+   * Property access: no whitespace before '.', previous token is identifier/keyword/selector.
+   * Also detects standalone method calls: .identifier( pattern.
+   *
+   * Returns true if '.' was emitted as an operator token and pos should advance by 1.
+   * Returns false if this is a CSS selector and should be handled by trySelector().
+   */
+  tryPropertyAccess(input, pos, tokens) {
+    if (input[pos] !== ".") return false;
+    const lastToken = tokens[tokens.length - 1];
+    const hasWhitespaceBefore = lastToken && lastToken.position.end < pos;
+    const isPropertyAccess = lastToken && !hasWhitespaceBefore && (lastToken.kind === "identifier" || lastToken.kind === "keyword" || lastToken.kind === "selector");
+    if (isPropertyAccess) {
+      tokens.push(createToken(".", "operator", createPosition(pos, pos + 1)));
+      return true;
+    }
+    const methodStart = pos + 1;
+    let methodEnd = methodStart;
+    while (methodEnd < input.length && isAsciiIdentifierChar(input[methodEnd])) {
+      methodEnd++;
+    }
+    if (methodEnd < input.length && input[methodEnd] === "(") {
+      tokens.push(createToken(".", "operator", createPosition(pos, pos + 1)));
+      return true;
+    }
+    return false;
+  }
   /**
    * Initialize keyword mappings from a language profile.
    * Builds a list of native→english mappings from:
@@ -391,24 +422,29 @@ var _BaseTokenizer = class _BaseTokenizer {
   initializeKeywordsFromProfile(profile, extras = []) {
     const keywordMap = /* @__PURE__ */ new Map();
     if (profile.keywords) {
-      for (const [normalized, translation] of Object.entries(profile.keywords)) {
+      for (const [normalized2, translation] of Object.entries(profile.keywords)) {
         keywordMap.set(translation.primary, {
           native: translation.primary,
-          normalized: translation.normalized || normalized
+          normalized: translation.normalized || normalized2
         });
         if (translation.alternatives) {
           for (const alt of translation.alternatives) {
             keywordMap.set(alt, {
               native: alt,
-              normalized: translation.normalized || normalized
+              normalized: translation.normalized || normalized2
             });
           }
         }
       }
     }
     if (profile.references) {
-      for (const [normalized, native] of Object.entries(profile.references)) {
-        keywordMap.set(native, { native, normalized });
+      for (const [normalized2, native] of Object.entries(profile.references)) {
+        keywordMap.set(native, { native, normalized: normalized2 });
+      }
+      for (const canonical of Object.keys(profile.references)) {
+        if (!keywordMap.has(canonical)) {
+          keywordMap.set(canonical, { native: canonical, normalized: canonical });
+        }
       }
     }
     if (profile.roleMarkers) {
@@ -432,9 +468,9 @@ var _BaseTokenizer = class _BaseTokenizer {
     this.profileKeywordMap = /* @__PURE__ */ new Map();
     for (const keyword of this.profileKeywords) {
       this.profileKeywordMap.set(keyword.native.toLowerCase(), keyword);
-      const normalized = this.removeDiacritics(keyword.native);
-      if (normalized !== keyword.native && !this.profileKeywordMap.has(normalized.toLowerCase())) {
-        this.profileKeywordMap.set(normalized.toLowerCase(), keyword);
+      const normalized2 = this.removeDiacritics(keyword.native);
+      if (normalized2 !== keyword.native && !this.profileKeywordMap.has(normalized2.toLowerCase())) {
+        this.profileKeywordMap.set(normalized2.toLowerCase(), keyword);
       }
     }
   }
@@ -1022,6 +1058,12 @@ var russianProfile = {
       normalized: "measure",
       form: "infinitive"
     },
+    beep: { primary: "\u0437\u0432\u0443\u043A", normalized: "beep" },
+    break: { primary: "\u043F\u0440\u0435\u0440\u0432\u0430\u0442\u044C", normalized: "break" },
+    copy: { primary: "\u043A\u043E\u043F\u0438\u0440\u043E\u0432\u0430\u0442\u044C", normalized: "copy" },
+    exit: { primary: "\u0432\u044B\u0439\u0442\u0438", normalized: "exit" },
+    pick: { primary: "\u0432\u044B\u0431\u0440\u0430\u0442\u044C", normalized: "pick" },
+    render: { primary: "\u043E\u0442\u043E\u0431\u0440\u0430\u0437\u0438\u0442\u044C", normalized: "render" },
     // Modifiers
     into: { primary: "\u0432", alternatives: ["\u0432\u043E"], normalized: "into" },
     before: { primary: "\u0434\u043E", alternatives: ["\u043F\u0435\u0440\u0435\u0434"], normalized: "before" },
@@ -1043,6 +1085,307 @@ var russianProfile = {
   }
 };
 
+// src/tokenizers/morphology/types.ts
+function noChange(word) {
+  return { stem: word, confidence: 1 };
+}
+function normalized(stem, confidence, metadata) {
+  if (metadata) {
+    return { stem, confidence, metadata };
+  }
+  return { stem, confidence };
+}
+
+// src/tokenizers/morphology/russian-normalizer.ts
+function isCyrillic(char) {
+  return /[а-яА-ЯёЁ]/.test(char);
+}
+function hasCyrillic(word) {
+  for (const char of word) {
+    if (isCyrillic(char)) return true;
+  }
+  return false;
+}
+var IMPERATIVE_TO_INFINITIVE = /* @__PURE__ */ new Map([
+  // Core commands (from Russian language profile)
+  ["\u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0438", "\u043F\u0435\u0440\u0435\u043A\u043B\u044E\u0447\u0438\u0442\u044C"],
+  ["\u0434\u043E\u0431\u0430\u0432\u044C", "\u0434\u043E\u0431\u0430\u0432\u0438\u0442\u044C"],
+  ["\u0443\u0434\u0430\u043B\u0438", "\u0443\u0434\u0430\u043B\u0438\u0442\u044C"],
+  ["\u0443\u0431\u0435\u0440\u0438", "\u0443\u0431\u0440\u0430\u0442\u044C"],
+  ["\u043F\u043E\u043B\u043E\u0436\u0438", "\u043F\u043E\u043B\u043E\u0436\u0438\u0442\u044C"],
+  ["\u043F\u043E\u043C\u0435\u0441\u0442\u0438", "\u043F\u043E\u043C\u0435\u0441\u0442\u0438\u0442\u044C"],
+  ["\u0432\u0441\u0442\u0430\u0432\u044C", "\u0432\u0441\u0442\u0430\u0432\u0438\u0442\u044C"],
+  ["\u0432\u043E\u0437\u044C\u043C\u0438", "\u0432\u0437\u044F\u0442\u044C"],
+  ["\u0441\u043E\u0437\u0434\u0430\u0439", "\u0441\u043E\u0437\u0434\u0430\u0442\u044C"],
+  ["\u043A\u043B\u043E\u043D\u0438\u0440\u0443\u0439", "\u043A\u043B\u043E\u043D\u0438\u0440\u043E\u0432\u0430\u0442\u044C"],
+  ["\u043F\u043E\u043C\u0435\u043D\u044F\u0439", "\u043F\u043E\u043C\u0435\u043D\u044F\u0442\u044C"],
+  ["\u0442\u0440\u0430\u043D\u0441\u0444\u043E\u0440\u043C\u0438\u0440\u0443\u0439", "\u0442\u0440\u0430\u043D\u0441\u0444\u043E\u0440\u043C\u0438\u0440\u043E\u0432\u0430\u0442\u044C"],
+  ["\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u0438", "\u0443\u0441\u0442\u0430\u043D\u043E\u0432\u0438\u0442\u044C"],
+  ["\u0437\u0430\u0434\u0430\u0439", "\u0437\u0430\u0434\u0430\u0442\u044C"],
+  ["\u043F\u043E\u043B\u0443\u0447\u0438", "\u043F\u043E\u043B\u0443\u0447\u0438\u0442\u044C"],
+  ["\u0443\u0432\u0435\u043B\u0438\u0447\u044C", "\u0443\u0432\u0435\u043B\u0438\u0447\u0438\u0442\u044C"],
+  ["\u0443\u043C\u0435\u043D\u044C\u0448\u0438", "\u0443\u043C\u0435\u043D\u044C\u0448\u0438\u0442\u044C"],
+  ["\u0437\u0430\u043F\u0438\u0448\u0438", "\u0437\u0430\u043F\u0438\u0441\u0430\u0442\u044C"],
+  ["\u043F\u043E\u043A\u0430\u0436\u0438", "\u043F\u043E\u043A\u0430\u0437\u0430\u0442\u044C"],
+  ["\u0441\u043A\u0440\u043E\u0439", "\u0441\u043A\u0440\u044B\u0442\u044C"],
+  ["\u0441\u043F\u0440\u044F\u0447\u044C", "\u0441\u043F\u0440\u044F\u0442\u0430\u0442\u044C"],
+  ["\u0430\u043D\u0438\u043C\u0438\u0440\u0443\u0439", "\u0430\u043D\u0438\u043C\u0438\u0440\u043E\u0432\u0430\u0442\u044C"],
+  ["\u0432\u044B\u0437\u043E\u0432\u0438", "\u0432\u044B\u0437\u0432\u0430\u0442\u044C"],
+  ["\u043E\u0442\u043F\u0440\u0430\u0432\u044C", "\u043E\u0442\u043F\u0440\u0430\u0432\u0438\u0442\u044C"],
+  ["\u0441\u0444\u043E\u043A\u0443\u0441\u0438\u0440\u0443\u0439", "\u0441\u0444\u043E\u043A\u0443\u0441\u0438\u0440\u043E\u0432\u0430\u0442\u044C"],
+  ["\u0440\u0430\u0437\u043C\u043E\u0439", "\u0440\u0430\u0437\u043C\u044B\u0442\u044C"],
+  ["\u043F\u0435\u0440\u0435\u0439\u0434\u0438", "\u043F\u0435\u0440\u0435\u0439\u0442\u0438"],
+  ["\u0438\u0434\u0438", "\u0438\u0434\u0442\u0438"],
+  ["\u0436\u0434\u0438", "\u0436\u0434\u0430\u0442\u044C"],
+  ["\u043F\u043E\u0434\u043E\u0436\u0434\u0438", "\u043F\u043E\u0434\u043E\u0436\u0434\u0430\u0442\u044C"],
+  ["\u0437\u0430\u0433\u0440\u0443\u0437\u0438", "\u0437\u0430\u0433\u0440\u0443\u0437\u0438\u0442\u044C"],
+  ["\u043F\u043E\u0432\u0442\u043E\u0440\u0438", "\u043F\u043E\u0432\u0442\u043E\u0440\u0438\u0442\u044C"],
+  ["\u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0438", "\u043F\u0440\u043E\u0434\u043E\u043B\u0436\u0438\u0442\u044C"],
+  ["\u0431\u0440\u043E\u0441\u044C", "\u0431\u0440\u043E\u0441\u0438\u0442\u044C"],
+  ["\u0432\u0435\u0440\u043D\u0438", "\u0432\u0435\u0440\u043D\u0443\u0442\u044C"],
+  ["\u0441\u043A\u0430\u0436\u0438", "\u0441\u043A\u0430\u0437\u0430\u0442\u044C"],
+  ["\u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u0443\u0439", "\u0438\u043D\u0438\u0446\u0438\u0430\u043B\u0438\u0437\u0438\u0440\u043E\u0432\u0430\u0442\u044C"],
+  ["\u0438\u0437\u043C\u0435\u0440\u044C", "\u0438\u0437\u043C\u0435\u0440\u0438\u0442\u044C"]
+]);
+var RussianMorphologicalNormalizer = class {
+  constructor() {
+    this.language = "ru";
+  }
+  /**
+   * Check if a word might be a Russian verb that can be normalized.
+   */
+  isNormalizable(word) {
+    if (word.length < 3) return false;
+    return hasCyrillic(word);
+  }
+  /**
+   * Normalize a Russian word to its infinitive form.
+   */
+  normalize(word) {
+    const lower = word.toLowerCase();
+    if (lower.endsWith("\u0441\u044F") || lower.endsWith("\u0441\u044C")) {
+      const reflexiveResult = this.tryReflexiveNormalization(lower);
+      if (reflexiveResult) return reflexiveResult;
+    }
+    if (lower.endsWith("\u0442\u044C") || lower.endsWith("\u0442\u0438") || lower.endsWith("\u0447\u044C")) {
+      return noChange(word);
+    }
+    const imperativeLookup = this.tryImperativeLookup(lower);
+    if (imperativeLookup) return imperativeLookup;
+    const pastResult = this.tryPastTenseNormalization(lower);
+    if (pastResult) return pastResult;
+    const presentResult = this.tryPresentTenseNormalization(lower);
+    if (presentResult) return presentResult;
+    const imperativeGeneric = this.tryGenericImperativeNormalization(lower);
+    if (imperativeGeneric) return imperativeGeneric;
+    return noChange(word);
+  }
+  /**
+   * Try to normalize reflexive verbs (-ся/-сь).
+   * Strip the reflexive suffix, normalize the base, then append -ться.
+   */
+  tryReflexiveNormalization(word) {
+    const suffixLen = word.endsWith("\u0441\u044F") ? 2 : 2;
+    const base = word.slice(0, -suffixLen);
+    if (word.endsWith("\u0442\u044C\u0441\u044F") || word.endsWith("\u0442\u0438\u0441\u044C") || word.endsWith("\u0447\u044C\u0441\u044F")) {
+      return noChange(word);
+    }
+    const baseResult = this.normalizeNonReflexive(base);
+    if (baseResult.confidence < 1) {
+      const infinitive = baseResult.stem.endsWith("\u0442\u044C") ? baseResult.stem.slice(0, -2) + "\u0442\u044C\u0441\u044F" : baseResult.stem + "\u0441\u044F";
+      return normalized(infinitive, baseResult.confidence * 0.95, {
+        removedSuffixes: ["\u0441\u044F", ...baseResult.metadata?.removedSuffixes || []],
+        conjugationType: "reflexive"
+      });
+    }
+    return null;
+  }
+  /**
+   * Normalize a non-reflexive verb form.
+   */
+  normalizeNonReflexive(word) {
+    if (word.endsWith("\u0442\u044C") || word.endsWith("\u0442\u0438") || word.endsWith("\u0447\u044C")) {
+      return noChange(word);
+    }
+    const imperativeLookup = this.tryImperativeLookup(word);
+    if (imperativeLookup) return imperativeLookup;
+    const pastResult = this.tryPastTenseNormalization(word);
+    if (pastResult) return pastResult;
+    const presentResult = this.tryPresentTenseNormalization(word);
+    if (presentResult) return presentResult;
+    const imperativeGeneric = this.tryGenericImperativeNormalization(word);
+    if (imperativeGeneric) return imperativeGeneric;
+    return noChange(word);
+  }
+  /**
+   * Try imperative → infinitive via lookup table only.
+   */
+  tryImperativeLookup(word) {
+    if (IMPERATIVE_TO_INFINITIVE.has(word)) {
+      return normalized(IMPERATIVE_TO_INFINITIVE.get(word), 0.95, {
+        removedSuffixes: ["imperative"],
+        conjugationType: "imperative"
+      });
+    }
+    return null;
+  }
+  /**
+   * Try generic imperative patterns (lower confidence fallback).
+   */
+  tryGenericImperativeNormalization(word) {
+    if (word.endsWith("\u0439\u0442\u0435") && word.length > 5) {
+      return normalized(word.slice(0, -3) + "\u0442\u044C", 0.8, {
+        removedSuffixes: ["\u0439\u0442\u0435"],
+        conjugationType: "imperative"
+      });
+    }
+    if (word.endsWith("\u0438\u0442\u0435") && word.length > 5) {
+      return normalized(word.slice(0, -3) + "\u0438\u0442\u044C", 0.8, {
+        removedSuffixes: ["\u0438\u0442\u0435"],
+        conjugationType: "imperative"
+      });
+    }
+    if (word.endsWith("\u0439") && word.length > 3) {
+      return normalized(word.slice(0, -1) + "\u0442\u044C", 0.75, {
+        removedSuffixes: ["\u0439"],
+        conjugationType: "imperative"
+      });
+    }
+    if (word.endsWith("\u0438") && word.length > 3) {
+      return normalized(word + "\u0442\u044C", 0.7, {
+        removedSuffixes: ["\u0438\u2192\u0438\u0442\u044C"],
+        conjugationType: "imperative"
+      });
+    }
+    return null;
+  }
+  /**
+   * Try past tense → infinitive.
+   *
+   * Russian past tense endings:
+   * - masculine: -л (делал → делать)
+   * - feminine: -ла (делала → делать)
+   * - neuter: -ло (делало → делать)
+   * - plural: -ли (делали → делать)
+   */
+  tryPastTenseNormalization(word) {
+    if (word.endsWith("\u0430\u043B\u0430") && word.length > 4) {
+      return normalized(word.slice(0, -3) + "\u0430\u0442\u044C", 0.85, {
+        removedSuffixes: ["\u0430\u043B\u0430"],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("\u0438\u043B\u0430") && word.length > 4) {
+      return normalized(word.slice(0, -3) + "\u0438\u0442\u044C", 0.85, {
+        removedSuffixes: ["\u0438\u043B\u0430"],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("\u0435\u043B\u043E") && word.length > 4) {
+      return normalized(word.slice(0, -3) + "\u0435\u0442\u044C", 0.82, {
+        removedSuffixes: ["\u0435\u043B\u043E"],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("\u0430\u0431\u043E") && word.length > 4) {
+      return normalized(word.slice(0, -3) + "\u0430\u0442\u044C", 0.82, {
+        removedSuffixes: ["\u0430\u0431\u043E"],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("\u0430\u043B\u0438") && word.length > 4) {
+      return normalized(word.slice(0, -3) + "\u0430\u0442\u044C", 0.85, {
+        removedSuffixes: ["\u0430\u043B\u0438"],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("\u0438\u043B\u0438") && word.length > 4) {
+      return normalized(word.slice(0, -3) + "\u0438\u0442\u044C", 0.85, {
+        removedSuffixes: ["\u0438\u043B\u0438"],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("\u0430\u043B") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0430\u0442\u044C", 0.82, {
+        removedSuffixes: ["\u0430\u043B"],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("\u0438\u043B") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0438\u0442\u044C", 0.82, {
+        removedSuffixes: ["\u0438\u043B"],
+        conjugationType: "past"
+      });
+    }
+    return null;
+  }
+  /**
+   * Try present tense → infinitive.
+   *
+   * Russian present tense endings (imperfective verbs):
+   * 1st conj: -ю/-у, -ешь, -ет, -ем, -ете, -ют/-ут
+   * 2nd conj: -ю/-у, -ишь, -ит, -им, -ите, -ят/-ат
+   */
+  tryPresentTenseNormalization(word) {
+    if (word.endsWith("\u0438\u0448\u044C") && word.length > 4) {
+      return normalized(word.slice(0, -3) + "\u0438\u0442\u044C", 0.8, {
+        removedSuffixes: ["\u0438\u0448\u044C"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u0438\u0442") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0438\u0442\u044C", 0.78, {
+        removedSuffixes: ["\u0438\u0442"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u0438\u043C") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0438\u0442\u044C", 0.78, {
+        removedSuffixes: ["\u0438\u043C"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u044F\u0442") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0438\u0442\u044C", 0.78, {
+        removedSuffixes: ["\u044F\u0442"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u0435\u0448\u044C") && word.length > 4) {
+      return normalized(word.slice(0, -3) + "\u0430\u0442\u044C", 0.75, {
+        removedSuffixes: ["\u0435\u0448\u044C"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u0435\u0442") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0430\u0442\u044C", 0.72, {
+        removedSuffixes: ["\u0435\u0442"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u0435\u043C") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0430\u0442\u044C", 0.72, {
+        removedSuffixes: ["\u0435\u043C"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u044E\u0442") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0430\u0442\u044C", 0.75, {
+        removedSuffixes: ["\u044E\u0442"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u0443\u0442") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "\u0430\u0442\u044C", 0.72, {
+        removedSuffixes: ["\u0443\u0442"],
+        conjugationType: "present"
+      });
+    }
+    return null;
+  }
+};
+var russianMorphologicalNormalizer = new RussianMorphologicalNormalizer();
+
 // src/tokenizers/russian.ts
 var { isLetter: isRussianLetter, isIdentifierChar: isRussianIdentifierChar } = createLatinCharClassifiers(/[a-zA-Zа-яА-ЯёЁ]/);
 var PREPOSITIONS = /* @__PURE__ */ new Set([
@@ -1176,6 +1519,7 @@ var RussianTokenizer = class extends BaseTokenizer {
     this.language = "ru";
     this.direction = "ltr";
     this.initializeKeywordsFromProfile(russianProfile, RUSSIAN_EXTRAS);
+    this.normalizer = new RussianMorphologicalNormalizer();
   }
   tokenize(input) {
     const tokens = [];
@@ -1192,6 +1536,10 @@ var RussianTokenizer = class extends BaseTokenizer {
           pos = modifierToken.position.end;
           continue;
         }
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
         const selectorToken = this.trySelector(input, pos);
         if (selectorToken) {
           tokens.push(selectorToken);
@@ -1251,7 +1599,8 @@ var RussianTokenizer = class extends BaseTokenizer {
     const lower = token.toLowerCase();
     if (PREPOSITIONS.has(lower)) return "particle";
     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";