tdk-api-wrapper 1.1.0 → 1.2.1

package/README.md

@@ -34,6 +34,7 @@ tdk kurallar
 tdk kural kısaltmalar
 tdk karsilastir kalem kağıt
 tdk analiz "Bu güzel kalem masanın üstünde duruyor"
+tdk oneri kale
 ```
 
 Herhangi bir komuta `--json` bayrağı eklendiğinde çıktı, insan-okunur metin yerine tek satırlık JSON olarak basılır (script/otomasyon kullanımı için):
@@ -67,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)`**: Sıkça yapılan yanlışlar listesini ve TDK veritabanını kullanarak kelimenin doğru yazılıp yazılmadığını kontrol eder. Yanlışsa doğrusunu önerir; tam eşleşme yoksa, aynı listedeki kelimeler arasında edit-distance (Levenshtein) ile en yakınını önerir (not: tüm sözlükte değil, yalnızca bu küçük havuzda arama yapar).
+- **`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.getCompoundWords(word)`**: Aranan kelime ile oluşturulmuş birleşik kelimeleri (Örn: dolma kalem) listeler.
 
 ### 3. Edebi ve Kültürel Analiz
@@ -81,7 +82,7 @@ Aşağıdaki metotlar `TDK` sınıfı üzerinden statik olarak erişilebilir dur
 - **`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.
 
 ### 4. Yardımcı Metotlar
-- **`TDK.getSuggestions(prefix)`**: Kelimenin sadece ilk birkaç harfini girdiğinizde otomatik tamamlama önerilerini çeker.
+- **`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).
 - **`TDK.getAudioUrl(word)`**: TDK'nin bu kelime için gerçekten bir ses kaydı varsa doğrudan indirme URL'sini döner, yoksa `null`. `downloadAudio(word, destPath)` ile cihazınıza indirebilirsiniz.
 - **`TDK.getDailyContent()`**: TDK anasayfasında yer alan "Günün Kelimesi, Atasözü ve Kuralı" içeriklerini çeker.
 - **`TDK.getWordOfTheDay()`**: `getDailyContent()`'in üzerine ince bir katman; günün kelimesini ve tüm anlamlarını `{ word, meanings }` şeklinde döner.

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

@@ -119,23 +119,60 @@ var TDK = class {
     return meanings;
   }
   /**
-   * Returns suggestions (autocomplete) for a given prefix.
+   * `sozluk.gov.tr`'s dedicated `/autocomplete.json` (and `/data/autocomplete.json`)
+   * routes no longer serve JSON — they fall through to the SPA's `index.html`.
+   * The full ~81k-word headword list the site's own autocomplete UI uses is
+   * instead bundled directly into its main JS asset as a
+   * `JSON.parse(\`[{"madde":"..."}]\`)` literal, so this fetches the home
+   * page to find that asset's current hashed filename, downloads it (a few
+   * MB, only once per process), and extracts the literal out of it. Fragile
+   * scraping of an implementation detail — if TDK's build stops embedding
+   * this, this fails closed to `[]` rather than throwing.
+   */
+  static async fetchAutocompleteData() {
+    try {
+      const homeResponse = await fetch(`${this.BASE_URL}/`, {
+        headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
+      });
+      if (!homeResponse.ok)
+        return [];
+      const html = await homeResponse.text();
+      const scriptMatch = html.match(/src="(\/assets\/index-[^"]+\.js)"/);
+      if (!scriptMatch)
+        return [];
+      const bundleResponse = await fetch(`${this.BASE_URL}${scriptMatch[1]}`, {
+        headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
+      });
+      if (!bundleResponse.ok)
+        return [];
+      const bundleJs = await bundleResponse.text();
+      const startMarker = 'JSON.parse(`[{"madde":';
+      const startIdx = bundleJs.indexOf(startMarker);
+      if (startIdx === -1)
+        return [];
+      const jsonStart = startIdx + "JSON.parse(".length + 1;
+      const jsonEnd = bundleJs.indexOf("`)", jsonStart);
+      if (jsonEnd === -1)
+        return [];
+      const data = JSON.parse(bundleJs.slice(jsonStart, jsonEnd));
+      return data.map((item) => item.madde).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Returns autocomplete suggestions for a given prefix, searched over TDK's
+   * full headword list (see `fetchAutocompleteData`). The list is fetched
+   * and cached once per process regardless of `enableCache()` — the same
+   * caching behavior as before — and only cleared by `clearCache()`.
    */
   static async getSuggestions(prefix) {
+    if (!prefix || prefix.trim() === "")
+      return [];
     if (this.autocompleteCache.length === 0) {
-      try {
-        const response = await fetch(`${this.BASE_URL}/autocomplete.json`, {
-          headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
-        });
-        if (response.ok) {
-          const data = await response.json();
-          this.autocompleteCache = data.map((item) => item.madde);
-        }
-      } catch (e) {
-        return [];
-      }
+      this.autocompleteCache = await this.fetchAutocompleteData();
     }
-    const cleanPrefix = prefix.toLocaleLowerCase("tr-TR");
+    const cleanPrefix = prefix.trim().toLocaleLowerCase("tr-TR");
     return this.autocompleteCache.filter((w) => w.toLocaleLowerCase("tr-TR").startsWith(cleanPrefix)).slice(0, 10);
   }
   /**
@@ -353,29 +390,37 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
+    let best = 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 (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -383,7 +428,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -424,10 +469,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -436,16 +483,19 @@ var TDK = class {
    * 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. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * 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.
    */
   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();
+      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);

package/dist/cli.js

@@ -144,23 +144,60 @@ var TDK = class {
     return meanings;
   }
   /**
-   * Returns suggestions (autocomplete) for a given prefix.
+   * `sozluk.gov.tr`'s dedicated `/autocomplete.json` (and `/data/autocomplete.json`)
+   * routes no longer serve JSON — they fall through to the SPA's `index.html`.
+   * The full ~81k-word headword list the site's own autocomplete UI uses is
+   * instead bundled directly into its main JS asset as a
+   * `JSON.parse(\`[{"madde":"..."}]\`)` literal, so this fetches the home
+   * page to find that asset's current hashed filename, downloads it (a few
+   * MB, only once per process), and extracts the literal out of it. Fragile
+   * scraping of an implementation detail — if TDK's build stops embedding
+   * this, this fails closed to `[]` rather than throwing.
+   */
+  static async fetchAutocompleteData() {
+    try {
+      const homeResponse = await fetch(`${this.BASE_URL}/`, {
+        headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
+      });
+      if (!homeResponse.ok)
+        return [];
+      const html = await homeResponse.text();
+      const scriptMatch = html.match(/src="(\/assets\/index-[^"]+\.js)"/);
+      if (!scriptMatch)
+        return [];
+      const bundleResponse = await fetch(`${this.BASE_URL}${scriptMatch[1]}`, {
+        headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
+      });
+      if (!bundleResponse.ok)
+        return [];
+      const bundleJs = await bundleResponse.text();
+      const startMarker = 'JSON.parse(`[{"madde":';
+      const startIdx = bundleJs.indexOf(startMarker);
+      if (startIdx === -1)
+        return [];
+      const jsonStart = startIdx + "JSON.parse(".length + 1;
+      const jsonEnd = bundleJs.indexOf("`)", jsonStart);
+      if (jsonEnd === -1)
+        return [];
+      const data = JSON.parse(bundleJs.slice(jsonStart, jsonEnd));
+      return data.map((item) => item.madde).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Returns autocomplete suggestions for a given prefix, searched over TDK's
+   * full headword list (see `fetchAutocompleteData`). The list is fetched
+   * and cached once per process regardless of `enableCache()` — the same
+   * caching behavior as before — and only cleared by `clearCache()`.
    */
   static async getSuggestions(prefix) {
+    if (!prefix || prefix.trim() === "")
+      return [];
     if (this.autocompleteCache.length === 0) {
-      try {
-        const response = await fetch(`${this.BASE_URL}/autocomplete.json`, {
-          headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
-        });
-        if (response.ok) {
-          const data = await response.json();
-          this.autocompleteCache = data.map((item) => item.madde);
-        }
-      } catch (e) {
-        return [];
-      }
+      this.autocompleteCache = await this.fetchAutocompleteData();
     }
-    const cleanPrefix = prefix.toLocaleLowerCase("tr-TR");
+    const cleanPrefix = prefix.trim().toLocaleLowerCase("tr-TR");
     return this.autocompleteCache.filter((w) => w.toLocaleLowerCase("tr-TR").startsWith(cleanPrefix)).slice(0, 10);
   }
   /**
@@ -378,29 +415,37 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word: word2, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word2.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word: word2, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word2.trim().toLocaleLowerCase("tr-TR");
+    let best = 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 (best && best.distance <= 2) {
+      return { isCorrect: false, word: word2, suggestion: best.candidate };
+    }
     return { isCorrect: false, word: word2 };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -408,7 +453,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -449,10 +494,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -461,16 +508,19 @@ var TDK = class {
    * 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. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * 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.
    */
   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();
+      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);
@@ -741,7 +791,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "kurallar",
   "kural",
   "karsilastir",
-  "analiz"
+  "analiz",
+  "oneri"
 ]);
 var command = args[0];
 var word = args.slice(1).join(" ");
@@ -767,7 +818,7 @@ async function run() {
   if (!command || command === "--help" || command === "-h") {
     console.log("Kullan\u0131m: tdk [komut] <kelime> [--json]");
     console.log(
-      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz"
+      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz, oneri"
     );
     console.log("Not: Komut belirtilmezse do\u011Frudan kelime anlam\u0131 aran\u0131r (\xF6rn: tdk selam)");
     process.exit(command ? 0 : 1);
@@ -957,6 +1008,19 @@ async function run() {
         });
         break;
       }
+      case "oneri": {
+        if (!word)
+          throw new Error("\xD6nek belirtmelisiniz.");
+        const suggestions = await TDK.getSuggestions(word);
+        printResult(suggestions, () => {
+          if (suggestions.length === 0) {
+            console.log("\xD6neri bulunamad\u0131.");
+          } else {
+            suggestions.forEach((s, i) => console.log(`${i + 1}. ${s}`));
+          }
+        });
+        break;
+      }
       default:
         printError("Bilinmeyen komut.");
     }

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TDK
-} from "./chunk-P3GX7I53.mjs";
+} from "./chunk-6BTOGV2M.mjs";
 
 // src/cli.ts
 var rawArgs = process.argv.slice(2);
@@ -23,7 +23,8 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
   "kurallar",
   "kural",
   "karsilastir",
-  "analiz"
+  "analiz",
+  "oneri"
 ]);
 var command = args[0];
 var word = args.slice(1).join(" ");
@@ -49,7 +50,7 @@ async function run() {
   if (!command || command === "--help" || command === "-h") {
     console.log("Kullan\u0131m: tdk [komut] <kelime> [--json]");
     console.log(
-      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz"
+      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz, oneri"
     );
     console.log("Not: Komut belirtilmezse do\u011Frudan kelime anlam\u0131 aran\u0131r (\xF6rn: tdk selam)");
     process.exit(command ? 0 : 1);
@@ -239,6 +240,19 @@ async function run() {
         });
         break;
       }
+      case "oneri": {
+        if (!word)
+          throw new Error("\xD6nek belirtmelisiniz.");
+        const suggestions = await TDK.getSuggestions(word);
+        printResult(suggestions, () => {
+          if (suggestions.length === 0) {
+            console.log("\xD6neri bulunamad\u0131.");
+          } else {
+            suggestions.forEach((s, i) => console.log(`${i + 1}. ${s}`));
+          }
+        });
+        break;
+      }
       default:
         printError("Bilinmeyen komut.");
     }

package/dist/index.d.mts

@@ -158,7 +158,22 @@ declare class TDK {
      */
     static getMeanings(word: string): Promise<string[]>;
     /**
-     * Returns suggestions (autocomplete) for a given prefix.
+     * `sozluk.gov.tr`'s dedicated `/autocomplete.json` (and `/data/autocomplete.json`)
+     * routes no longer serve JSON — they fall through to the SPA's `index.html`.
+     * The full ~81k-word headword list the site's own autocomplete UI uses is
+     * instead bundled directly into its main JS asset as a
+     * `JSON.parse(\`[{"madde":"..."}]\`)` literal, so this fetches the home
+     * page to find that asset's current hashed filename, downloads it (a few
+     * MB, only once per process), and extracts the literal out of it. Fragile
+     * scraping of an implementation detail — if TDK's build stops embedding
+     * this, this fails closed to `[]` rather than throwing.
+     */
+    private static fetchAutocompleteData;
+    /**
+     * Returns autocomplete suggestions for a given prefix, searched over TDK's
+     * full headword list (see `fetchAutocompleteData`). The list is fetched
+     * and cached once per process regardless of `enableCache()` — the same
+     * caching behavior as before — and only cleared by `clearCache()`.
      */
     static getSuggestions(prefix: string): Promise<string[]>;
     /**
@@ -229,8 +244,13 @@ declare class TDK {
     static checkSpelling(word: string): Promise<SpellCheckResult>;
     /**
      * Fetches daily content (word of the day, proverbs, rules, etc).
+     * `bypassCache` skips both reading and writing `dailyContentCache` even
+     * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+     * needs a fresh random `/icerik` draw on every attempt; without it, once
+     * caching is enabled the loop would just re-read the same cached response
+     * 25 times and could never find a rule outside that first random draw.
      */
-    static getDailyContent(): Promise<DailyContent | null>;
+    static getDailyContent(bypassCache?: boolean): Promise<DailyContent | null>;
     /**
      * Returns today's word of the day along with all of its listed meanings.
      */
@@ -245,18 +265,23 @@ declare class TDK {
      * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
      * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
      * appears to hand back a single randomly-rotated rule per request, so two
-     * calls a second apart can return entirely different rules.
+     * calls a second apart can return entirely different rules. `bypassCache`
+     * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+     * draw even when `enableCache(true)` is on.
      */
-    static getKurallar(): Promise<TDKRule[]>;
+    static getKurallar(bypassCache?: boolean): Promise<TDKRule[]>;
     /**
      * Fetches the full plain-text content of a named spelling rule (matched
      * 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. Returns `null` if no
-     * match turns up within the attempt budget or the matched page can't be
-     * parsed.
+     * 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.
      */
     static getRule(name: string): Promise<string | null>;
     /**

package/dist/index.d.ts

@@ -158,7 +158,22 @@ declare class TDK {
      */
     static getMeanings(word: string): Promise<string[]>;
     /**
-     * Returns suggestions (autocomplete) for a given prefix.
+     * `sozluk.gov.tr`'s dedicated `/autocomplete.json` (and `/data/autocomplete.json`)
+     * routes no longer serve JSON — they fall through to the SPA's `index.html`.
+     * The full ~81k-word headword list the site's own autocomplete UI uses is
+     * instead bundled directly into its main JS asset as a
+     * `JSON.parse(\`[{"madde":"..."}]\`)` literal, so this fetches the home
+     * page to find that asset's current hashed filename, downloads it (a few
+     * MB, only once per process), and extracts the literal out of it. Fragile
+     * scraping of an implementation detail — if TDK's build stops embedding
+     * this, this fails closed to `[]` rather than throwing.
+     */
+    private static fetchAutocompleteData;
+    /**
+     * Returns autocomplete suggestions for a given prefix, searched over TDK's
+     * full headword list (see `fetchAutocompleteData`). The list is fetched
+     * and cached once per process regardless of `enableCache()` — the same
+     * caching behavior as before — and only cleared by `clearCache()`.
      */
     static getSuggestions(prefix: string): Promise<string[]>;
     /**
@@ -229,8 +244,13 @@ declare class TDK {
     static checkSpelling(word: string): Promise<SpellCheckResult>;
     /**
      * Fetches daily content (word of the day, proverbs, rules, etc).
+     * `bypassCache` skips both reading and writing `dailyContentCache` even
+     * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+     * needs a fresh random `/icerik` draw on every attempt; without it, once
+     * caching is enabled the loop would just re-read the same cached response
+     * 25 times and could never find a rule outside that first random draw.
      */
-    static getDailyContent(): Promise<DailyContent | null>;
+    static getDailyContent(bypassCache?: boolean): Promise<DailyContent | null>;
     /**
      * Returns today's word of the day along with all of its listed meanings.
      */
@@ -245,18 +265,23 @@ declare class TDK {
      * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
      * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
      * appears to hand back a single randomly-rotated rule per request, so two
-     * calls a second apart can return entirely different rules.
+     * calls a second apart can return entirely different rules. `bypassCache`
+     * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+     * draw even when `enableCache(true)` is on.
      */
-    static getKurallar(): Promise<TDKRule[]>;
+    static getKurallar(bypassCache?: boolean): Promise<TDKRule[]>;
     /**
      * Fetches the full plain-text content of a named spelling rule (matched
      * 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. Returns `null` if no
-     * match turns up within the attempt budget or the matched page can't be
-     * parsed.
+     * 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.
      */
     static getRule(name: string): Promise<string | null>;
     /**

package/dist/index.js

@@ -158,23 +158,60 @@ var TDK = class {
     return meanings;
   }
   /**
-   * Returns suggestions (autocomplete) for a given prefix.
+   * `sozluk.gov.tr`'s dedicated `/autocomplete.json` (and `/data/autocomplete.json`)
+   * routes no longer serve JSON — they fall through to the SPA's `index.html`.
+   * The full ~81k-word headword list the site's own autocomplete UI uses is
+   * instead bundled directly into its main JS asset as a
+   * `JSON.parse(\`[{"madde":"..."}]\`)` literal, so this fetches the home
+   * page to find that asset's current hashed filename, downloads it (a few
+   * MB, only once per process), and extracts the literal out of it. Fragile
+   * scraping of an implementation detail — if TDK's build stops embedding
+   * this, this fails closed to `[]` rather than throwing.
+   */
+  static async fetchAutocompleteData() {
+    try {
+      const homeResponse = await fetch(`${this.BASE_URL}/`, {
+        headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
+      });
+      if (!homeResponse.ok)
+        return [];
+      const html = await homeResponse.text();
+      const scriptMatch = html.match(/src="(\/assets\/index-[^"]+\.js)"/);
+      if (!scriptMatch)
+        return [];
+      const bundleResponse = await fetch(`${this.BASE_URL}${scriptMatch[1]}`, {
+        headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
+      });
+      if (!bundleResponse.ok)
+        return [];
+      const bundleJs = await bundleResponse.text();
+      const startMarker = 'JSON.parse(`[{"madde":';
+      const startIdx = bundleJs.indexOf(startMarker);
+      if (startIdx === -1)
+        return [];
+      const jsonStart = startIdx + "JSON.parse(".length + 1;
+      const jsonEnd = bundleJs.indexOf("`)", jsonStart);
+      if (jsonEnd === -1)
+        return [];
+      const data = JSON.parse(bundleJs.slice(jsonStart, jsonEnd));
+      return data.map((item) => item.madde).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Returns autocomplete suggestions for a given prefix, searched over TDK's
+   * full headword list (see `fetchAutocompleteData`). The list is fetched
+   * and cached once per process regardless of `enableCache()` — the same
+   * caching behavior as before — and only cleared by `clearCache()`.
    */
   static async getSuggestions(prefix) {
+    if (!prefix || prefix.trim() === "")
+      return [];
     if (this.autocompleteCache.length === 0) {
-      try {
-        const response = await fetch(`${this.BASE_URL}/autocomplete.json`, {
-          headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" }
-        });
-        if (response.ok) {
-          const data = await response.json();
-          this.autocompleteCache = data.map((item) => item.madde);
-        }
-      } catch (e) {
-        return [];
-      }
+      this.autocompleteCache = await this.fetchAutocompleteData();
     }
-    const cleanPrefix = prefix.toLocaleLowerCase("tr-TR");
+    const cleanPrefix = prefix.trim().toLocaleLowerCase("tr-TR");
     return this.autocompleteCache.filter((w) => w.toLocaleLowerCase("tr-TR").startsWith(cleanPrefix)).slice(0, 10);
   }
   /**
@@ -392,29 +429,37 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
+    let best = 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 (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -422,7 +467,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -463,10 +508,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -475,16 +522,19 @@ var TDK = class {
    * 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. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * 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.
    */
   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();
+      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);

package/dist/index.mjs

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

package/package.json

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

package/src/cli.ts

@@ -21,6 +21,7 @@ const KNOWN_COMMANDS = new Set([
   "kural",
   "karsilastir",
   "analiz",
+  "oneri",
 ]);
 
 let command = args[0];
@@ -51,7 +52,7 @@ async function run() {
   if (!command || command === "--help" || command === "-h") {
     console.log("Kullanım: tdk [komut] <kelime> [--json]");
     console.log(
-      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz"
+      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz, oneri"
     );
     console.log("Not: Komut belirtilmezse doğrudan kelime anlamı aranır (örn: tdk selam)");
     process.exit(command ? 0 : 1);
@@ -245,6 +246,19 @@ async function run() {
         break;
       }
 
+      case "oneri": {
+        if (!word) throw new Error("Önek belirtmelisiniz.");
+        const suggestions = await TDK.getSuggestions(word);
+        printResult(suggestions, () => {
+          if (suggestions.length === 0) {
+            console.log("Öneri bulunamadı.");
+          } else {
+            suggestions.forEach((s, i) => console.log(`${i + 1}. ${s}`));
+          }
+        });
+        break;
+      }
+
       default:
         printError("Bilinmeyen komut.");
     }

package/src/tdk.ts

@@ -119,24 +119,61 @@ export class TDK {
   }
 
   /**
-   * Returns suggestions (autocomplete) for a given prefix.
+   * `sozluk.gov.tr`'s dedicated `/autocomplete.json` (and `/data/autocomplete.json`)
+   * routes no longer serve JSON — they fall through to the SPA's `index.html`.
+   * The full ~81k-word headword list the site's own autocomplete UI uses is
+   * instead bundled directly into its main JS asset as a
+   * `JSON.parse(\`[{"madde":"..."}]\`)` literal, so this fetches the home
+   * page to find that asset's current hashed filename, downloads it (a few
+   * MB, only once per process), and extracts the literal out of it. Fragile
+   * scraping of an implementation detail — if TDK's build stops embedding
+   * this, this fails closed to `[]` rather than throwing.
+   */
+  private static async fetchAutocompleteData(): Promise<string[]> {
+    try {
+      const homeResponse = await fetch(`${this.BASE_URL}/`, {
+        headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" },
+      });
+      if (!homeResponse.ok) return [];
+      const html = await homeResponse.text();
+
+      const scriptMatch = html.match(/src="(\/assets\/index-[^"]+\.js)"/);
+      if (!scriptMatch) return [];
+
+      const bundleResponse = await fetch(`${this.BASE_URL}${scriptMatch[1]}`, {
+        headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" },
+      });
+      if (!bundleResponse.ok) return [];
+      const bundleJs = await bundleResponse.text();
+
+      const startMarker = 'JSON.parse(`[{"madde":';
+      const startIdx = bundleJs.indexOf(startMarker);
+      if (startIdx === -1) return [];
+      const jsonStart = startIdx + "JSON.parse(".length + 1;
+      const jsonEnd = bundleJs.indexOf("`)", jsonStart);
+      if (jsonEnd === -1) return [];
+
+      const data = JSON.parse(bundleJs.slice(jsonStart, jsonEnd)) as { madde: string }[];
+      return data.map((item) => item.madde).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Returns autocomplete suggestions for a given prefix, searched over TDK's
+   * full headword list (see `fetchAutocompleteData`). The list is fetched
+   * and cached once per process regardless of `enableCache()` — the same
+   * caching behavior as before — and only cleared by `clearCache()`.
    */
   public static async getSuggestions(prefix: string): Promise<string[]> {
+    if (!prefix || prefix.trim() === "") return [];
+
     if (this.autocompleteCache.length === 0) {
-      try {
-        const response = await fetch(`${this.BASE_URL}/autocomplete.json`, {
-          headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" },
-        });
-        if (response.ok) {
-          const data = await response.json() as { madde: string }[];
-          this.autocompleteCache = data.map(item => item.madde);
-        }
-      } catch (e) {
-        return [];
-      }
+      this.autocompleteCache = await this.fetchAutocompleteData();
     }
-    
-    const cleanPrefix = prefix.toLocaleLowerCase("tr-TR");
+
+    const cleanPrefix = prefix.trim().toLocaleLowerCase("tr-TR");
     return this.autocompleteCache
       .filter(w => w.toLocaleLowerCase("tr-TR").startsWith(cleanPrefix))
       .slice(0, 10);
@@ -352,8 +389,10 @@ export class TDK {
     if (results.length > 0) {
       return { isCorrect: true, word };
     }
-    
-    // 2. If not, check "sıkça yapılan yanlışlar" from DailyContent
+
+    // 2. If not, check "sıkça yapılan yanlışlar" from DailyContent — an exact
+    // match here is TDK explicitly saying "X is often confused with Y", so
+    // it's authoritative when it hits (but only 2-3 rotating entries per call).
     const daily = await this.getDailyContent();
     if (daily) {
       const syydMatch = daily.syyd.find(s => s.yanliskelime.toLocaleLowerCase("tr-TR") === word.toLocaleLowerCase("tr-TR"));
@@ -364,43 +403,49 @@ export class TDK {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
+    }
 
-      // 3. No exact match in TDK's fixed lists: fall back to the closest word
-      // (by edit distance) within that same small pool. This is NOT a search
-      // over the full dictionary — TDK exposes no such lookup — just a
-      // best-effort nudge using the "sık yapılan yanlışlar" data we already have.
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde),
-      ];
-      let best: { candidate: string; distance: number } | null = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    // 3. No exact match in TDK's curated lists: fall back to the closest
+    // 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.
+    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;
+    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 (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
 
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  public static async getDailyContent(): Promise<DailyContent | null> {
-    if (this.isCacheEnabled && this.dailyContentCache) return this.dailyContentCache;
-    
+  public static async getDailyContent(bypassCache = false): Promise<DailyContent | null> {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache) return this.dailyContentCache;
+
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
         headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" },
       });
       if (response.ok) {
         const data = await response.json() as DailyContent;
-        if (this.isCacheEnabled) this.dailyContentCache = data;
+        if (!bypassCache && this.isCacheEnabled) this.dailyContentCache = data;
         return data;
       }
     } catch {
@@ -443,10 +488,12 @@ export class TDK {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  public static async getKurallar(): Promise<TDKRule[]> {
-    const daily = await this.getDailyContent();
+  public static async getKurallar(bypassCache = false): Promise<TDKRule[]> {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
 
@@ -456,16 +503,19 @@ export class TDK {
    * 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. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * 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.
    */
   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();
+      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);