tdk-api-wrapper 1.2.1 → 1.3.0

package/README.md

@@ -35,6 +35,9 @@ tdk kural kısaltmalar
 tdk karsilastir kalem kağıt
 tdk analiz "Bu güzel kalem masanın üstünde duruyor"
 tdk oneri kale
+tdk kubbealti merhaba
+tdk nisanyan merhaba
+tdk viki merhaba
 ```
 
 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):
@@ -68,7 +71,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 +82,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 +91,15 @@ 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.
+
+### 5. Diğer Sözlük Kaynakları
+
+TDK dışındaki bu üç kaynak da her zaman kullanılabilir/dokümante edilmiş resmî API'ler değildir; her biri **fragile scraping** (kırılgan, dokümante edilmemiş entegrasyon) — kaynak taraflarında bir değişiklik olursa `null`/`[]` dönerler, hataya düşmezler. Verinin telif/kullanım koşulları kaynağa göre farklıdır: Wiktionary içeriği CC BY-SA lisanslıdır (açık); Nişanyan Sözlük ücretsiz, açık bir kişisel/akademik kaynaktır; **Kubbealtı Lugatı ise ticari bir sözlük ürünüdür** — bu kütüphane onu da dokümante edilmemiş bir uç noktadan çekebiliyor olsa da, kullanımınızı Kubbealtı'nın kendi kullanım şartlarına göre değerlendirmeniz önerilir.
+
+- **`TDK.getKubbealti(word)`**: Kubbealtı Lugatı'nın ("Misalli Büyük Türkçe Sözlük") verilerini `{ kelime, anlam }` dizisi olarak döner (`anlam` zengin tipografi içeren ham HTML'dir). `getKubbealtiMeanings(word)` aynı veriyi düz metne çevirir. `getKubbealtiSuggestions(prefix)` Kubbealtı'nın kendi otomatik tamamlama uç noktasını kullanır (TDK'nin `getSuggestions()`'ından bağımsız, ayrı bir veri kaynağı). Not: Kubbealtı'nın veri sunucusu (`eski.lugatim.com`) sertifika zincirini eksik gönderiyor; bu kütüphane eksik ara sertifikaları ekleyerek zinciri düzgün doğruluyor (doğrulamayı kapatmıyor) — Let's Encrypt bu ara sertifikayı döndürürse bu entegrasyon `null` dönmeye başlar.
+- **`TDK.getNisanyan(word)`**: Nişanyan Sözlük'ten kelimenin etimoloji paragrafını düz metin olarak döner; kelime bulunamazsa `null`.
+- **`TDK.getWiktionary(word)`**: Türkçe Vikisözlük'ten (`tr.wiktionary.org`) resmî MediaWiki API'si (`action=query&prop=extracts`) üzerinden veri çeker — bu üçü arasında scraping olmayan, resmî ve en kararlı olanı. `{ raw, sections }` döner; `sections` metni `== Köken ==`, `=== Söyleniş ===` gibi başlıklara göre bir sözlüğe ayırır. `getWiktionarySection(word, sectionName)` tek bir bölümü (örn. `"Köken"`) büyük/küçük harf duyarsız süzer.
 
 ## Hata Yönetimi
 

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

@@ -30,9 +30,87 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import * as https from "https";
+import * as tls from "tls";
 var TDK = class {
   static BASE_URL = "https://sozluk.gov.tr";
   static AUDIO_API_HOST = "api.sozluk.gov.tr";
+  static KUBBEALTI_HOST = "eski.lugatim.com";
+  /**
+   * `eski.lugatim.com` (Kubbealtı Lugatı's data API) sends only its leaf
+   * certificate during the TLS handshake, omitting the intermediates a
+   * correctly configured server would include — a server-side misconfiguration,
+   * not something we should paper over by disabling verification. These are
+   * the two certificates the server *should* be sending (fetched from the
+   * leaf's own Authority Information Access URLs), supplied here so Node can
+   * still build a full, properly verified chain up to a root it already
+   * trusts (ISRG Root X1). If Let's Encrypt rotates this intermediate, this
+   * stops working and every Kubbealtı call fails closed to `null` — same
+   * fail-closed contract as the rest of this file's fragile integrations.
+   */
+  static KUBBEALTI_EXTRA_CA = [
+    `-----BEGIN CERTIFICATE-----
+MIIE2jCCAsKgAwIBAgIQTr0klH4k05SALYSlL9WzGTANBgkqhkiG9w0BAQsFADAu
+MQswCQYDVQQGEwJVUzENMAsGA1UEChMESVNSRzEQMA4GA1UEAxMHUm9vdCBZUjAe
+Fw0yNTA5MDMwMDAwMDBaFw0yODA5MDIyMzU5NTlaMDMxCzAJBgNVBAYTAlVTMRYw
+FAYDVQQKEw1MZXQncyBFbmNyeXB0MQwwCgYDVQQDEwNZUjIwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDZ0LxwBppqh84luqMerV/eeL/fXQ7mLQQv1Lnp
+WKZbyvGpx6wh6AfnslAnF6ewTkcHA+gSOoBvm3Dfm06AuGiF+KRut4fAcowqnAQQ
+CW98+QPP/eOv/wug7Iyk4NkOxf2I6g2f55T6nJoOTLFcukeRq80JGQEYan+dPFr9
+OGUgQK2hGKgNkW87pappsOAuUJcroYhRt5uUis4qaZireiseu32gzDJNBAiKtsvd
+6HX4v25bpkRNcS/B/Gtc9kVbUpD+2PLPxdei3Tim55k4tfAEXwD2qyiPTxrTNq6l
+N+AMr5g2c1dNqkOTwjxeV6L5lpP1rGiYvLnRaPlOqyZRPW+5AgMBAAGjge4wgesw
+DgYDVR0PAQH/BAQDAgGGMBMGA1UdJQQMMAoGCCsGAQUFBwMBMBIGA1UdEwEB/wQI
+MAYBAf8CAQAwHQYDVR0OBBYEFEAVLSZ57TIgnt+ach3WMh+BDIEMMB8GA1UdIwQY
+MBaAFN7nW2DQIm1AKH0/DQH+pLVStFGUMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEF
+BQcwAoYWaHR0cDovL3lyLmkubGVuY3Iub3JnLzATBgNVHSAEDDAKMAgGBmeBDAEC
+ATAnBgNVHR8EIDAeMBygGqAYhhZodHRwOi8veXIuYy5sZW5jci5vcmcvMA0GCSqG
+SIb3DQEBCwUAA4ICAQB0ZUQWZ9/Yn9COEpo+JfecMnB0h0vwDm/M66IqXqw3LoaL
+mx9lZvRTeDIS67PUeI3yCA2W6PKRD0/FE/G57lOmS+Xy5AaaL00ICGOqjNcCaMWW
+8o8nevHOd4i4lqgtznE/28QwlcdJyF8yBiWHpnyjhEpmNWJURgOCOg2xpwRMBCsj
+MScqYPtOhBeuYQvSwAEeTML2Ukh6uGuX4E14q65Ja8cdjF5bAldnP1eE4FBaAwsZ
+G2fOqqrKV03Y85Nw2btedP1AtliQuJZs/Jo/gXxXdc7LrH3McgnpnbTiAncX7yES
+hP6kzQejllqMCIt52HOjxDGWafS7Xw+DKwqmH+Eqy8dcbOuag/1AYlQoKNVK3F5q
+Hh6tEDiMqQcLIibGKteE6iHo4A/bIScbzrhXUYuism42ZYzmc48FMVIH3qy4L84E
+TdAH2gtxw0PAhvRVXp8HP7wfngpzsN/8xOTpeRSbM4+Qbc56G6+Bifmv6sk1ieQb
+NA3wJdl4DDUuQSV8hBgx6zoI1ZSGORprDFux7c6rhc77QZMSRrEgomBeklervEve
+86ylWmZ3WWHV6RLMi8xNvjd71r4EPIGgY7BZU/VPBkq+uA7Gb6mbJnFgV43uh3xy
+LRFgxIAphIukwTGSMZZR+AI+Qnp0BYTWovHXozOf3H8r6hozEoT02JHn0AeTfA==
+-----END CERTIFICATE-----`,
+    `-----BEGIN CERTIFICATE-----
+MIIF9DCCA9ygAwIBAgIRAPJLbRf52a18scn+p4eCaZ8wDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMjYwNTEzMDAwMDAw
+WhcNMzIwOTAyMjM1OTU5WjAuMQswCQYDVQQGEwJVUzENMAsGA1UEChMESVNSRzEQ
+MA4GA1UEAxMHUm9vdCBZUjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
+ANvGJnN78CTJdWL3+eGfsLN5TrNBJs+VH9hRXqRbwxu9sGNiB0BD1fcOxbSUQCJI
+M1xE13Db+5Cw1w0s0EBYsvuIP/6joF0w8cuImbgR1OGgYbSQ4OpzI+DG8SGuTlcE
+873OCS+kh3srlo6vl43M5OJg4Aeo1sfHp6kTJDoIiFBNJAY+OKfX/FUvYKuhjT+n
+o49lmqmupSBI5PkBQiqrEGtWU5uxU/cQWHGu8jSjFBznZqvbNPLMXMLFxCb3WTfr
+JBXXjqvWG+v4bjzxjjeAtOlU7qarRDvNOyAuQYLln904M+faKx8hnLCpJ15ZqaEg
+cNlY+9MMWcC5yvL2A2j3l9+2buggZX+dOE91zYmIdawTvSZuVvlbRrAlLxIB6pwM
+BjneXCjYQ8+3BCCjssbSNpZU3hTcBDdhfAlEDlYr6pEatnMdmDT5BqnKC92bd0Eh
+M1fbLHioLccLCuievT8ZkPhZrq7Mii7gNXAcUEAR8+lzYal+9zTg7C5DALyVOeG/
+CqfRAMn1KSHCR0NSA6P8tn/mGRlnCct5rtVCLnVySVpU6H1qGg3DgTOuskf8eahT
+MiYbI5ezPJmO5ertalskQ1utp74+eDy92PI4ftHKTbq9IWhH4YZKh3WnJEIt+oQv
+lYZbY8tpEroKrFB6PFGzrJIDRyts4HqvuH52RFj2zv/BAgMBAAGjgeswgegwDgYD
+VR0PAQH/BAQDAgEGMBMGA1UdJQQMMAoGCCsGAQUFBwMBMA8GA1UdEwEB/wQFMAMB
+Af8wHQYDVR0OBBYEFN7nW2DQIm1AKH0/DQH+pLVStFGUMB8GA1UdIwQYMBaAFHm0
+WeZ7tuXkAXOACIjIGlj26ZtuMDIGCCsGAQUFBwEBBCYwJDAiBggrBgEFBQcwAoYW
+aHR0cDovL3gxLmkubGVuY3Iub3JnLzATBgNVHSAEDDAKMAgGBmeBDAECATAnBgNV
+HR8EIDAeMBygGqAYhhZodHRwOi8veDEuYy5sZW5jci5vcmcvMA0GCSqGSIb3DQEB
+CwUAA4ICAQA8spSI95KKfn2W6GMmDpHBJSPaLbsS3W93cijJCRCYAc1fsJgL1FIL
+7C0C9ecPOdcwB2fi0Dk2p94j9iTJCxmt5CFSKLRWwnXT2MMSXexVxqoVB79BdWPx
+VXETkVme/qYSAuKVHh5Ps+5BixgmwS1JkjSAc+MfrUbNssVEEnH0aEiAh+rotXAV
+JSP/Ye7LJPEwD9DWG72vVWbhAcuOf5OLjz57Ctk7MgQHynZ7+PlHJtajroCaIbtC
+r6tcZZaAwUQm+jQyeWdV+2hv9deOYFmKeQyjjcSrN5Nadrw+L9DZJLbA1HqeNvLh
+BgqpP0fvJq2N6EtD574N6eMI7uMsJTnji2UDz9el5XLSv9fqJMuDQtYVb2oTNoKp
+oUqhxPVC0aq4eG5MESaIdn8b5ZGSSeAJLMHXljEdlNza+ncfkviXk1POLnnFdvx8
+/gk6M374WbLWFXw8N141B/Rl/tINGfl1TxOIiqtiMYkL02RSGb1kq34BL9NPP27z
+RGMuHGnzS3hFIrRTfKxrzUZ9RzQWzEG3K6fJ3r2nqSltkeytis9DIBoFY9VmVyjL
+M71DMi+y1+TRSJVClEMwvA4yL++7q9XZx5r5wBRWB4kQTKH5qyoZnDw7iiuh1lID
+yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
+-----END CERTIFICATE-----`
+  ];
   // Cache Mechanism
   static isCacheEnabled = false;
   static wordCache = /* @__PURE__ */ new Map();
@@ -399,11 +477,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 +565,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;
   }
@@ -528,7 +620,166 @@ var TDK = class {
     }
   }
   static htmlToPlainText(html) {
-    return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div)>/gi, "\n\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&quot;/gi, '"').replace(/&#39;|&rsquo;/gi, "'").replace(/[ \t]+/g, " ").replace(/[ \t]*\n[ \t]*/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+    return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div)>/gi, "\n\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/gi, " ").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;|&rsquo;/gi, "'").replace(/&amp;/gi, "&").replace(/[ \t]+/g, " ").replace(/[ \t]*\n[ \t]*/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+  }
+  /**
+   * GETs a JSON path from Kubbealtı Lugatı's data API (`eski.lugatim.com`),
+   * supplying `KUBBEALTI_EXTRA_CA` to work around that host's incomplete
+   * certificate chain (see the constant's doc comment). Fails closed to
+   * `null` on any error — network, TLS, HTTP, or JSON parse.
+   */
+  static fetchKubbealtiJson(path2) {
+    return new Promise((resolve) => {
+      const req = https.request(
+        {
+          hostname: this.KUBBEALTI_HOST,
+          path: path2,
+          method: "GET",
+          ca: [...tls.rootCertificates, ...this.KUBBEALTI_EXTRA_CA],
+          headers: {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36"
+          }
+        },
+        (res) => {
+          if (res.statusCode !== 200) {
+            res.resume();
+            resolve(null);
+            return;
+          }
+          let body = "";
+          res.on("data", (chunk) => body += chunk);
+          res.on("end", () => {
+            try {
+              resolve(JSON.parse(body));
+            } catch {
+              resolve(null);
+            }
+          });
+        }
+      );
+      req.on("error", () => resolve(null));
+      req.end();
+    });
+  }
+  /**
+   * Returns Kubbealtı Lugatı ("Misalli Büyük Türkçe Sözlük") entries for a
+   * word, scraped from the site's own data API — undocumented, and Kubbealtı
+   * Lugatı is a commercial dictionary product, unlike TDK's or Wiktionary's
+   * openly-published data, so use this in line with their terms. `anlam` is
+   * raw HTML (rich typography markup); use `getKubbealtiMeanings()` for
+   * plain text. Returns `null` on any fetch/parse failure, `[]` if the word
+   * isn't found.
+   */
+  static async getKubbealti(word) {
+    if (!word || word.trim() === "")
+      return null;
+    const data = await this.fetchKubbealtiJson(`/rest/s/${encodeURIComponent(word.trim())}/`);
+    if (!data || !Array.isArray(data.content))
+      return null;
+    return data.content.map((entry) => ({ kelime: entry.kelime, anlam: entry.anlam }));
+  }
+  /**
+   * Same as `getKubbealti()` but with each entry's `anlam` HTML stripped to
+   * plain text via `htmlToPlainText()`.
+   */
+  static async getKubbealtiMeanings(word) {
+    const entries = await this.getKubbealti(word);
+    if (!entries)
+      return null;
+    return entries.map((e) => this.htmlToPlainText(e.anlam));
+  }
+  /**
+   * Autocomplete suggestions from Kubbealtı Lugatı's own typeahead endpoint
+   * (separate from `getSuggestions()`, which uses TDK's data).
+   */
+  static async getKubbealtiSuggestions(prefix) {
+    if (!prefix || prefix.trim() === "")
+      return [];
+    const data = await this.fetchKubbealtiJson(`/rest/word-search/${encodeURIComponent(prefix.trim())}`);
+    if (!Array.isArray(data))
+      return [];
+    return data.map((item) => item.display).filter(Boolean);
+  }
+  /**
+   * Returns the etymology paragraph for a word from Nişanyan Sözlük, scraped
+   * from that page's server-rendered `<meta name="description">` tag (the
+   * page already puts the full etymology text there for SEO, so no need to
+   * parse the site's internal SvelteKit data format). Returns `null` if the
+   * word isn't found (the page falls back to a generic site tagline in that
+   * case) or the request fails.
+   */
+  static async getNisanyan(word) {
+    if (!word || word.trim() === "")
+      return null;
+    try {
+      const response = await fetch(
+        `https://www.nisanyansozluk.com/kelime/${encodeURIComponent(word.trim().toLocaleLowerCase("tr-TR"))}`,
+        { headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" } }
+      );
+      if (!response.ok)
+        return null;
+      const html = await response.text();
+      const match = html.match(/<meta name="description" content="([^"]*)"/);
+      if (!match)
+        return null;
+      const description = this.htmlToPlainText(match[1]);
+      if (description === "\xC7a\u011Fda\u015F T\xFCrk\xE7enin Etimolojisi")
+        return null;
+      return description;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Returns the Turkish Wiktionary (`tr.wiktionary.org`) entry for a word,
+   * via MediaWiki's official Action API (`action=query&prop=extracts`) — no
+   * scraping involved, this is a stable, documented public API. `sections`
+   * splits the plain-text extract on its `== Heading ==`/`=== Heading ===`
+   * markers (e.g. "Köken", "Söyleniş", "Ad") for convenience; `raw` has the
+   * unsplit text. Returns `null` if the page doesn't exist or the request
+   * fails.
+   */
+  static async getWiktionary(word) {
+    if (!word || word.trim() === "")
+      return null;
+    try {
+      const url = `https://tr.wiktionary.org/w/api.php?action=query&prop=extracts&titles=${encodeURIComponent(
+        word.trim()
+      )}&format=json&explaintext=1&formatversion=2`;
+      const response = await fetch(url, { headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" } });
+      if (!response.ok)
+        return null;
+      const data = await response.json();
+      const page = data?.query?.pages?.[0];
+      if (!page || page.missing || !page.extract)
+        return null;
+      const raw = page.extract;
+      const sections = {};
+      const parts = raw.split(/\n(={2,4})\s*(.+?)\s*\1\n/);
+      for (let i = 1; i < parts.length; i += 3) {
+        const title = parts[i + 1]?.trim();
+        const content = parts[i + 2]?.trim();
+        if (title)
+          sections[title] = content ?? "";
+      }
+      return { raw, sections };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Convenience filter over `getWiktionary()`: returns just one section's
+   * text (e.g. `getWiktionarySection(word, "Köken")` for etymology), matched
+   * case-insensitively. Returns `null` if the word or the section isn't found.
+   */
+  static async getWiktionarySection(word, sectionName) {
+    const entry = await this.getWiktionary(word);
+    if (!entry)
+      return null;
+    const key = Object.keys(entry.sections).find(
+      (k) => k.toLocaleLowerCase("tr-TR") === sectionName.trim().toLocaleLowerCase("tr-TR")
+    );
+    return key ? entry.sections[key] : null;
   }
   /**
    * Returns compound words that contain this word.
@@ -647,6 +898,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 +922,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 +938,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];