tdk-api-wrapper 1.2.1 → 1.2.2

package/README.md

@@ -68,7 +68,7 @@ Aşağıdaki metotlar `TDK` sınıfı üzerinden statik olarak erişilebilir dur
 - **`TDK.syllabicate(word)`**: Kelimeyi Türkçe heceleme kurallarına göre doğru hecelerine ayırır (Örn: `['mu', 'vaf', 'fa', 'ki', 'yet']`). API isteği atmaz, çok hızlıdır.
 - **`TDK.checkVowelHarmony(word)`**: Kelimenin büyük ünlü uyumuna uyup uymadığını (boolean) kontrol eder.
 - **`TDK.getPartOfSpeech(word)`**: Kelimenin sözcük türünü (isim, sıfat, zarf vb.) döndürür.
-- **`TDK.checkSpelling(word)`**: Kelimenin doğru yazılıp yazılmadığını kontrol eder. Önce TDK'nin "sık yapılan yanlışlar" listesinde tam eşleşme arar; bulamazsa TDK'nin ~81 bin kelimelik tam madde listesi üzerinde edit-distance (Levenshtein) ile en yakın kelimeyi önerir (örn. `herkez` → `herkes`, `mektub` → `mektup`).
+- **`TDK.checkSpelling(word)`**: Kelimenin doğru yazılıp yazılmadığını kontrol eder. Önce TDK'nin "sık yapılan yanlışlar" listesinde tam eşleşme arar; bulamazsa TDK'nin ~81 bin kelimelik tam madde listesi üzerinde Damerau-Levenshtein edit-distance ile en yakın kelimeyi önerir (bitişik harf yer değiştirmelerini de tek düzeltme sayar; örn. `herkez` → `herkes`, `mektub` → `mektup`, `yanlız` → `yalnız`). Kelime sıklığı verisi olmadığı için nadiren aynı mesafedeki iki aday arasında beklenenden farklı biri seçilebilir.
 - **`TDK.getCompoundWords(word)`**: Aranan kelime ile oluşturulmuş birleşik kelimeleri (Örn: dolma kalem) listeler.
 
 ### 3. Edebi ve Kültürel Analiz
@@ -79,7 +79,7 @@ Aşağıdaki metotlar `TDK` sınıfı üzerinden statik olarak erişilebilir dur
 - **`TDK.groupByOrigin(words)`**: Bir kelime listesini etimolojik kökenlerine göre gruplar (bulunamayanlar `"Bilinmiyor"` altında toplanır).
 - **`TDK.getSynonyms(word)`** / **`TDK.getAntonyms(word)`**: Kelimenin eş/zıt anlamlılarını döner (undocumented `gts-yeni` endpoint'i üzerinden; sonuç bulunamazsa `[]`).
 - **`TDK.compareWords(a, b)`**: İki kelimeyi anlam sayısı, köken, hece bölünüşü ve büyük ünlü uyumu açısından yan yana karşılaştırır.
-- **`TDK.analyzeText(text)`**: Bir metindeki (Türkçe bağlaçlar/edatlar hariç) her benzersiz kelimeyi tek tek arayıp ilk anlamını ve kökenini döner.
+- **`TDK.analyzeText(text)`**: Bir metindeki (Türkçe bağlaçlar/edatlar hariç) her benzersiz kelimeyi tek tek arayıp ilk anlamını ve kökenini döner. Not: TDK yalnızca yalın (sözlük) biçimleri indeksliyor, morfolojik analiz yapmıyor — bu yüzden "evde", "dildir" gibi ek almış kelimeler kökleri (`ev`, `dil`) sözlükte olsa bile `found: false` döner; bu veri kaynağının doğal bir sınırlılığıdır.
 
 ### 4. Yardımcı Metotlar
 - **`TDK.getSuggestions(prefix)`**: TDK'nin ~81 bin kelimelik tam madde listesi üzerinden önek bazlı otomatik tamamlama önerileri döner (ilk çağrıda listeyi indirip önbelleğe alır, sonraki çağrılar anlıktır).
@@ -88,7 +88,7 @@ Aşağıdaki metotlar `TDK` sınıfı üzerinden statik olarak erişilebilir dur
 - **`TDK.getWordOfTheDay()`**: `getDailyContent()`'in üzerine ince bir katman; günün kelimesini ve tüm anlamlarını `{ word, meanings }` şeklinde döner.
 - **`TDK.getRandomWord()`**: Günün içeriğindeki kelime ve atasözü havuzundan rastgele bir tanesini `{ type: "kelime" | "atasoz", madde, anlam }` şeklinde seçer (not: tüm sözlük değil, sadece o günkü içerik havuzundan seçim yapar).
 - **`TDK.getKurallar()`**: TDK'nin `/icerik` akışının o an döndürdüğü yazım kuralı sayfa(lar)ını `{ adi, url }` şeklinde listeler. Not: bu sabit bir katalog değildir — `/icerik` her istekte, yaklaşık yirmi kurallık bir havuzdan rastgele tek bir kural döndürür.
-- **`TDK.getRule(name)`**: Adı verilen (küçük/büyük harf duyarsız, alt dize eşleşmesi) yazım kuralının tam metnini `tdk.gov.tr`'den çekip düz metne çevirir. `getKurallar()`'ın rastgeleliği yüzünden istenen kuralı bulana kadar sınırlı sayıda (en fazla 25, aralarda kısa bekleme ile) yeniden dener; bulamazsa veya sayfa ayrıştırılamazsa `null` döner.
+- **`TDK.getRule(name)`**: Adı verilen (küçük/büyük harf duyarsız, alt dize eşleşmesi) yazım kuralının tam metnini `tdk.gov.tr`'den çekip düz metne çevirir. `getKurallar()`'ın rastgeleliği yüzünden istenen kuralı bulana kadar eşzamanlı gruplar hâlinde (toplam en fazla 25 deneme, ~5 round-trip'e sığdırılmış) yeniden dener; bulamazsa veya sayfa ayrıştırılamazsa `null` döner.
 
 ## Hata Yönetimi
 

package/dist/{chunk-6BTOGV2M.mjs → chunk-SNY3KUCF.mjs}

@@ -399,11 +399,16 @@ var TDK = class {
     for (const candidate of this.autocompleteCache) {
       if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
         continue;
-      const distance = this.levenshtein(cleanWord, candidate);
-      if (distance > 0 && (!best || distance < best.distance)) {
-        best = { candidate, distance };
-        if (distance === 1)
-          break;
+      if (Math.abs(candidate.length - cleanWord.length) > 2)
+        continue;
+      const distance = this.damerauLevenshtein(cleanWord, candidate);
+      if (distance === 0)
+        continue;
+      const firstMismatch = candidate[0] === cleanWord[0] ? 0 : 1;
+      const lengthMismatch = candidate.length === cleanWord.length ? 0 : 1;
+      const better = !best || distance < best.distance || distance === best.distance && firstMismatch < best.firstMismatch || distance === best.distance && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch;
+      if (better) {
+        best = { candidate, distance, firstMismatch, lengthMismatch };
       }
     }
     if (best && best.distance <= 2) {
@@ -482,24 +487,33 @@ var TDK = class {
    * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-   * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Every attempt bypasses
-   * `dailyContentCache` — without that, once `enableCache(true)` is on, all
-   * 25 attempts would just re-read the same cached `/icerik` response and
-   * could never find a rule outside whatever the first draw happened to be.
-   * Returns `null` if no match turns up within the attempt budget or the
-   * matched page can't be parsed.
+   * draw would rarely match a given name — this re-draws until it finds a
+   * match or gives up. Draws happen in concurrent batches (each `/icerik`
+   * request is independent and stateless) rather than one-at-a-time with a
+   * delay: same total sample size (25) and hit probability as a sequential
+   * loop, but bounded to a handful of round-trips instead of 25 of them, so
+   * a miss resolves in roughly one round-trip time instead of several
+   * seconds. Every draw bypasses `dailyContentCache` — without that, once
+   * `enableCache(true)` is on, every attempt would just re-read the same
+   * cached `/icerik` response and could never find a rule outside whatever
+   * the first draw happened to be. Returns `null` if no match turns up
+   * within the attempt budget or the matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
-    for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar(true);
-      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
-      if (match)
-        return this.fetchRuleText(match.url);
-      await this.delay(100);
+    const BATCH_SIZE = 5;
+    const ROUNDS = 5;
+    for (let round = 0; round < ROUNDS; round++) {
+      const batches = await Promise.all(
+        Array.from({ length: BATCH_SIZE }, () => this.getKurallar(true))
+      );
+      for (const rules of batches) {
+        const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+        if (match)
+          return this.fetchRuleText(match.url);
+      }
     }
     return null;
   }
@@ -647,6 +661,11 @@ var TDK = class {
    * Analyzes every distinct word in a text (Turkish stopwords filtered out),
    * returning each word's first meaning and etymological origin if found.
    * Looks each word up individually (throttled), so scales with text length.
+   * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+   * it does no morphological analysis, and neither does this method: a
+   * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+   * suffix) will come back `found: false` even though the root is a real
+   * headword. This is an inherent limitation of the data source, not a bug.
    */
   static async analyzeText(text) {
     const words = text.toLocaleLowerCase("tr-TR").replace(/[^\p{L}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 1 && !this.STOPWORDS.has(w));
@@ -666,9 +685,13 @@ var TDK = class {
     return analyses;
   }
   /**
-   * Classic edit-distance between two strings.
+   * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+   * like classic Levenshtein but also counts an adjacent-character
+   * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+   * two substitutions — a very common class of typo that plain Levenshtein
+   * otherwise misses.
    */
-  static levenshtein(a, b) {
+  static damerauLevenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i++)
       dp[i][0] = i;
@@ -678,6 +701,9 @@ var TDK = class {
       for (let j = 1; j <= b.length; j++) {
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + cost);
+        }
       }
     }
     return dp[a.length][b.length];

package/dist/cli.js

@@ -424,11 +424,16 @@ var TDK = class {
     for (const candidate of this.autocompleteCache) {
       if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
         continue;
-      const distance = this.levenshtein(cleanWord, candidate);
-      if (distance > 0 && (!best || distance < best.distance)) {
-        best = { candidate, distance };
-        if (distance === 1)
-          break;
+      if (Math.abs(candidate.length - cleanWord.length) > 2)
+        continue;
+      const distance = this.damerauLevenshtein(cleanWord, candidate);
+      if (distance === 0)
+        continue;
+      const firstMismatch = candidate[0] === cleanWord[0] ? 0 : 1;
+      const lengthMismatch = candidate.length === cleanWord.length ? 0 : 1;
+      const better = !best || distance < best.distance || distance === best.distance && firstMismatch < best.firstMismatch || distance === best.distance && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch;
+      if (better) {
+        best = { candidate, distance, firstMismatch, lengthMismatch };
       }
     }
     if (best && best.distance <= 2) {
@@ -507,24 +512,33 @@ var TDK = class {
    * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-   * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Every attempt bypasses
-   * `dailyContentCache` — without that, once `enableCache(true)` is on, all
-   * 25 attempts would just re-read the same cached `/icerik` response and
-   * could never find a rule outside whatever the first draw happened to be.
-   * Returns `null` if no match turns up within the attempt budget or the
-   * matched page can't be parsed.
+   * draw would rarely match a given name — this re-draws until it finds a
+   * match or gives up. Draws happen in concurrent batches (each `/icerik`
+   * request is independent and stateless) rather than one-at-a-time with a
+   * delay: same total sample size (25) and hit probability as a sequential
+   * loop, but bounded to a handful of round-trips instead of 25 of them, so
+   * a miss resolves in roughly one round-trip time instead of several
+   * seconds. Every draw bypasses `dailyContentCache` — without that, once
+   * `enableCache(true)` is on, every attempt would just re-read the same
+   * cached `/icerik` response and could never find a rule outside whatever
+   * the first draw happened to be. Returns `null` if no match turns up
+   * within the attempt budget or the matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
-    for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar(true);
-      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
-      if (match)
-        return this.fetchRuleText(match.url);
-      await this.delay(100);
+    const BATCH_SIZE = 5;
+    const ROUNDS = 5;
+    for (let round = 0; round < ROUNDS; round++) {
+      const batches = await Promise.all(
+        Array.from({ length: BATCH_SIZE }, () => this.getKurallar(true))
+      );
+      for (const rules of batches) {
+        const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+        if (match)
+          return this.fetchRuleText(match.url);
+      }
     }
     return null;
   }
@@ -672,6 +686,11 @@ var TDK = class {
    * Analyzes every distinct word in a text (Turkish stopwords filtered out),
    * returning each word's first meaning and etymological origin if found.
    * Looks each word up individually (throttled), so scales with text length.
+   * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+   * it does no morphological analysis, and neither does this method: a
+   * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+   * suffix) will come back `found: false` even though the root is a real
+   * headword. This is an inherent limitation of the data source, not a bug.
    */
   static async analyzeText(text) {
     const words = text.toLocaleLowerCase("tr-TR").replace(/[^\p{L}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 1 && !this.STOPWORDS.has(w));
@@ -691,9 +710,13 @@ var TDK = class {
     return analyses;
   }
   /**
-   * Classic edit-distance between two strings.
+   * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+   * like classic Levenshtein but also counts an adjacent-character
+   * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+   * two substitutions — a very common class of typo that plain Levenshtein
+   * otherwise misses.
    */
-  static levenshtein(a, b) {
+  static damerauLevenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i++)
       dp[i][0] = i;
@@ -703,6 +726,9 @@ var TDK = class {
       for (let j = 1; j <= b.length; j++) {
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + cost);
+        }
       }
     }
     return dp[a.length][b.length];

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TDK
-} from "./chunk-6BTOGV2M.mjs";
+} from "./chunk-SNY3KUCF.mjs";
 
 // src/cli.ts
 var rawArgs = process.argv.slice(2);

package/dist/index.d.mts

@@ -275,13 +275,17 @@ declare class TDK {
      * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
      * hands back a single randomly-rotated rule per request (out of a pool of
      * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-     * draw would rarely match a given name — this re-draws (bounded, with a
-     * short delay) until it finds a match or gives up. Every attempt bypasses
-     * `dailyContentCache` — without that, once `enableCache(true)` is on, all
-     * 25 attempts would just re-read the same cached `/icerik` response and
-     * could never find a rule outside whatever the first draw happened to be.
-     * Returns `null` if no match turns up within the attempt budget or the
-     * matched page can't be parsed.
+     * draw would rarely match a given name — this re-draws until it finds a
+     * match or gives up. Draws happen in concurrent batches (each `/icerik`
+     * request is independent and stateless) rather than one-at-a-time with a
+     * delay: same total sample size (25) and hit probability as a sequential
+     * loop, but bounded to a handful of round-trips instead of 25 of them, so
+     * a miss resolves in roughly one round-trip time instead of several
+     * seconds. Every draw bypasses `dailyContentCache` — without that, once
+     * `enableCache(true)` is on, every attempt would just re-read the same
+     * cached `/icerik` response and could never find a rule outside whatever
+     * the first draw happened to be. Returns `null` if no match turns up
+     * within the attempt budget or the matched page can't be parsed.
      */
     static getRule(name: string): Promise<string | null>;
     /**
@@ -314,12 +318,21 @@ declare class TDK {
      * Analyzes every distinct word in a text (Turkish stopwords filtered out),
      * returning each word's first meaning and etymological origin if found.
      * Looks each word up individually (throttled), so scales with text length.
+     * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+     * it does no morphological analysis, and neither does this method: a
+     * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+     * suffix) will come back `found: false` even though the root is a real
+     * headword. This is an inherent limitation of the data source, not a bug.
      */
     static analyzeText(text: string): Promise<WordAnalysis[]>;
     /**
-     * Classic edit-distance between two strings.
+     * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+     * like classic Levenshtein but also counts an adjacent-character
+     * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+     * two substitutions — a very common class of typo that plain Levenshtein
+     * otherwise misses.
      */
-    private static levenshtein;
+    private static damerauLevenshtein;
     /**
      * Fetches multiple words concurrently with a small delay to avoid rate limiting.
      */

package/dist/index.d.ts

@@ -275,13 +275,17 @@ declare class TDK {
      * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
      * hands back a single randomly-rotated rule per request (out of a pool of
      * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-     * draw would rarely match a given name — this re-draws (bounded, with a
-     * short delay) until it finds a match or gives up. Every attempt bypasses
-     * `dailyContentCache` — without that, once `enableCache(true)` is on, all
-     * 25 attempts would just re-read the same cached `/icerik` response and
-     * could never find a rule outside whatever the first draw happened to be.
-     * Returns `null` if no match turns up within the attempt budget or the
-     * matched page can't be parsed.
+     * draw would rarely match a given name — this re-draws until it finds a
+     * match or gives up. Draws happen in concurrent batches (each `/icerik`
+     * request is independent and stateless) rather than one-at-a-time with a
+     * delay: same total sample size (25) and hit probability as a sequential
+     * loop, but bounded to a handful of round-trips instead of 25 of them, so
+     * a miss resolves in roughly one round-trip time instead of several
+     * seconds. Every draw bypasses `dailyContentCache` — without that, once
+     * `enableCache(true)` is on, every attempt would just re-read the same
+     * cached `/icerik` response and could never find a rule outside whatever
+     * the first draw happened to be. Returns `null` if no match turns up
+     * within the attempt budget or the matched page can't be parsed.
      */
     static getRule(name: string): Promise<string | null>;
     /**
@@ -314,12 +318,21 @@ declare class TDK {
      * Analyzes every distinct word in a text (Turkish stopwords filtered out),
      * returning each word's first meaning and etymological origin if found.
      * Looks each word up individually (throttled), so scales with text length.
+     * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+     * it does no morphological analysis, and neither does this method: a
+     * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+     * suffix) will come back `found: false` even though the root is a real
+     * headword. This is an inherent limitation of the data source, not a bug.
      */
     static analyzeText(text: string): Promise<WordAnalysis[]>;
     /**
-     * Classic edit-distance between two strings.
+     * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+     * like classic Levenshtein but also counts an adjacent-character
+     * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+     * two substitutions — a very common class of typo that plain Levenshtein
+     * otherwise misses.
      */
-    private static levenshtein;
+    private static damerauLevenshtein;
     /**
      * Fetches multiple words concurrently with a small delay to avoid rate limiting.
      */

package/dist/index.js

@@ -438,11 +438,16 @@ var TDK = class {
     for (const candidate of this.autocompleteCache) {
       if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
         continue;
-      const distance = this.levenshtein(cleanWord, candidate);
-      if (distance > 0 && (!best || distance < best.distance)) {
-        best = { candidate, distance };
-        if (distance === 1)
-          break;
+      if (Math.abs(candidate.length - cleanWord.length) > 2)
+        continue;
+      const distance = this.damerauLevenshtein(cleanWord, candidate);
+      if (distance === 0)
+        continue;
+      const firstMismatch = candidate[0] === cleanWord[0] ? 0 : 1;
+      const lengthMismatch = candidate.length === cleanWord.length ? 0 : 1;
+      const better = !best || distance < best.distance || distance === best.distance && firstMismatch < best.firstMismatch || distance === best.distance && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch;
+      if (better) {
+        best = { candidate, distance, firstMismatch, lengthMismatch };
       }
     }
     if (best && best.distance <= 2) {
@@ -521,24 +526,33 @@ var TDK = class {
    * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-   * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Every attempt bypasses
-   * `dailyContentCache` — without that, once `enableCache(true)` is on, all
-   * 25 attempts would just re-read the same cached `/icerik` response and
-   * could never find a rule outside whatever the first draw happened to be.
-   * Returns `null` if no match turns up within the attempt budget or the
-   * matched page can't be parsed.
+   * draw would rarely match a given name — this re-draws until it finds a
+   * match or gives up. Draws happen in concurrent batches (each `/icerik`
+   * request is independent and stateless) rather than one-at-a-time with a
+   * delay: same total sample size (25) and hit probability as a sequential
+   * loop, but bounded to a handful of round-trips instead of 25 of them, so
+   * a miss resolves in roughly one round-trip time instead of several
+   * seconds. Every draw bypasses `dailyContentCache` — without that, once
+   * `enableCache(true)` is on, every attempt would just re-read the same
+   * cached `/icerik` response and could never find a rule outside whatever
+   * the first draw happened to be. Returns `null` if no match turns up
+   * within the attempt budget or the matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
-    for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar(true);
-      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
-      if (match)
-        return this.fetchRuleText(match.url);
-      await this.delay(100);
+    const BATCH_SIZE = 5;
+    const ROUNDS = 5;
+    for (let round = 0; round < ROUNDS; round++) {
+      const batches = await Promise.all(
+        Array.from({ length: BATCH_SIZE }, () => this.getKurallar(true))
+      );
+      for (const rules of batches) {
+        const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+        if (match)
+          return this.fetchRuleText(match.url);
+      }
     }
     return null;
   }
@@ -686,6 +700,11 @@ var TDK = class {
    * Analyzes every distinct word in a text (Turkish stopwords filtered out),
    * returning each word's first meaning and etymological origin if found.
    * Looks each word up individually (throttled), so scales with text length.
+   * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+   * it does no morphological analysis, and neither does this method: a
+   * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+   * suffix) will come back `found: false` even though the root is a real
+   * headword. This is an inherent limitation of the data source, not a bug.
    */
   static async analyzeText(text) {
     const words = text.toLocaleLowerCase("tr-TR").replace(/[^\p{L}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 1 && !this.STOPWORDS.has(w));
@@ -705,9 +724,13 @@ var TDK = class {
     return analyses;
   }
   /**
-   * Classic edit-distance between two strings.
+   * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+   * like classic Levenshtein but also counts an adjacent-character
+   * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+   * two substitutions — a very common class of typo that plain Levenshtein
+   * otherwise misses.
    */
-  static levenshtein(a, b) {
+  static damerauLevenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i++)
       dp[i][0] = i;
@@ -717,6 +740,9 @@ var TDK = class {
       for (let j = 1; j <= b.length; j++) {
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + cost);
+        }
       }
     }
     return dp[a.length][b.length];

package/dist/index.mjs

@@ -3,7 +3,7 @@ import {
   TDKError,
   TDKNetworkError,
   TDKValidationError
-} from "./chunk-6BTOGV2M.mjs";
+} from "./chunk-SNY3KUCF.mjs";
 export {
   TDK,
   TDKError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdk-api-wrapper",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "TDK (Türk Dil Kurumu) unofficial live data API wrapper for Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/tdk.ts

@@ -409,17 +409,35 @@ export class TDK {
     // headword (by edit distance) across TDK's full ~81k-word list (the same
     // data `getSuggestions()` uses). Restricted to single-token, lowercase
     // headwords so it doesn't suggest compounds/phrases or proper nouns.
+    // Candidates whose length differs too much are skipped before running
+    // the O(n*m) distance calculation, both for speed and because a huge
+    // length gap can't be within the distance threshold anyway. Ties (same
+    // distance) prefer a matching first letter, then a matching length —
+    // typos rarely change the first letter, and this avoids picking
+    // whatever happens to sort alphabetically first. There's no word
+    // frequency data available, so a genuine tie can still land on a
+    // technically-correct but less commonly intended word.
     if (this.autocompleteCache.length === 0) {
       this.autocompleteCache = await this.fetchAutocompleteData();
     }
     const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
-    let best: { candidate: string; distance: number } | null = null;
+    let best: { candidate: string; distance: number; firstMismatch: number; lengthMismatch: number } | null = null;
     for (const candidate of this.autocompleteCache) {
       if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR")) continue;
-      const distance = this.levenshtein(cleanWord, candidate);
-      if (distance > 0 && (!best || distance < best.distance)) {
-        best = { candidate, distance };
-        if (distance === 1) break;
+      if (Math.abs(candidate.length - cleanWord.length) > 2) continue;
+
+      const distance = this.damerauLevenshtein(cleanWord, candidate);
+      if (distance === 0) continue;
+
+      const firstMismatch = candidate[0] === cleanWord[0] ? 0 : 1;
+      const lengthMismatch = candidate.length === cleanWord.length ? 0 : 1;
+      const better =
+        !best ||
+        distance < best.distance ||
+        (distance === best.distance && firstMismatch < best.firstMismatch) ||
+        (distance === best.distance && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch);
+      if (better) {
+        best = { candidate, distance, firstMismatch, lengthMismatch };
       }
     }
     if (best && best.distance <= 2) {
@@ -502,23 +520,32 @@ export class TDK {
    * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-   * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Every attempt bypasses
-   * `dailyContentCache` — without that, once `enableCache(true)` is on, all
-   * 25 attempts would just re-read the same cached `/icerik` response and
-   * could never find a rule outside whatever the first draw happened to be.
-   * Returns `null` if no match turns up within the attempt budget or the
-   * matched page can't be parsed.
+   * draw would rarely match a given name — this re-draws until it finds a
+   * match or gives up. Draws happen in concurrent batches (each `/icerik`
+   * request is independent and stateless) rather than one-at-a-time with a
+   * delay: same total sample size (25) and hit probability as a sequential
+   * loop, but bounded to a handful of round-trips instead of 25 of them, so
+   * a miss resolves in roughly one round-trip time instead of several
+   * seconds. Every draw bypasses `dailyContentCache` — without that, once
+   * `enableCache(true)` is on, every attempt would just re-read the same
+   * cached `/icerik` response and could never find a rule outside whatever
+   * the first draw happened to be. Returns `null` if no match turns up
+   * within the attempt budget or the matched page can't be parsed.
    */
   public static async getRule(name: string): Promise<string | null> {
     if (!name || name.trim() === "") return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
 
-    for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar(true);
-      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
-      if (match) return this.fetchRuleText(match.url);
-      await this.delay(100);
+    const BATCH_SIZE = 5;
+    const ROUNDS = 5;
+    for (let round = 0; round < ROUNDS; round++) {
+      const batches = await Promise.all(
+        Array.from({ length: BATCH_SIZE }, () => this.getKurallar(true))
+      );
+      for (const rules of batches) {
+        const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+        if (match) return this.fetchRuleText(match.url);
+      }
     }
     return null;
   }
@@ -654,6 +681,11 @@ export class TDK {
    * Analyzes every distinct word in a text (Turkish stopwords filtered out),
    * returning each word's first meaning and etymological origin if found.
    * Looks each word up individually (throttled), so scales with text length.
+   * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+   * it does no morphological analysis, and neither does this method: a
+   * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+   * suffix) will come back `found: false` even though the root is a real
+   * headword. This is an inherent limitation of the data source, not a bug.
    */
   public static async analyzeText(text: string): Promise<WordAnalysis[]> {
     const words = text
@@ -679,9 +711,13 @@ export class TDK {
   }
 
   /**
-   * Classic edit-distance between two strings.
+   * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+   * like classic Levenshtein but also counts an adjacent-character
+   * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+   * two substitutions — a very common class of typo that plain Levenshtein
+   * otherwise misses.
    */
-  private static levenshtein(a: string, b: string): number {
+  private static damerauLevenshtein(a: string, b: string): number {
     const dp: number[][] = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i++) dp[i][0] = i;
     for (let j = 0; j <= b.length; j++) dp[0][j] = j;
@@ -689,6 +725,9 @@ export class TDK {
       for (let j = 1; j <= b.length; j++) {
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + cost);
+        }
       }
     }
     return dp[a.length][b.length];