tdk-api-wrapper 1.2.1 → 1.3.0

package/dist/index.d.ts

@@ -126,6 +126,14 @@ interface WordAnalysis {
     meaning: string | null;
     origin: string | null;
 }
+interface KubbealtiEntry {
+    kelime: string;
+    anlam: string;
+}
+interface WiktionaryEntry {
+    raw: string;
+    sections: Record<string, string>;
+}
 type TDKResponse = WordInfo[] | {
     error: string;
 };
@@ -136,6 +144,20 @@ type TDKResponse = WordInfo[] | {
 declare class TDK {
     private static readonly BASE_URL;
     private static readonly AUDIO_API_HOST;
+    private static readonly KUBBEALTI_HOST;
+    /**
+     * `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.
+     */
+    private static readonly KUBBEALTI_EXTRA_CA;
     private static isCacheEnabled;
     private static wordCache;
     private static dailyContentCache;
@@ -275,13 +297,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>;
     /**
@@ -292,6 +318,58 @@ declare class TDK {
      */
     private static fetchRuleText;
     private static htmlToPlainText;
+    /**
+     * 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.
+     */
+    private static fetchKubbealtiJson;
+    /**
+     * 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 getKubbealti(word: string): Promise<KubbealtiEntry[] | null>;
+    /**
+     * Same as `getKubbealti()` but with each entry's `anlam` HTML stripped to
+     * plain text via `htmlToPlainText()`.
+     */
+    static getKubbealtiMeanings(word: string): Promise<string[] | null>;
+    /**
+     * Autocomplete suggestions from Kubbealtı Lugatı's own typeahead endpoint
+     * (separate from `getSuggestions()`, which uses TDK's data).
+     */
+    static getKubbealtiSuggestions(prefix: string): Promise<string[]>;
+    /**
+     * 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 getNisanyan(word: string): Promise<string | 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 getWiktionary(word: string): Promise<WiktionaryEntry | 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 getWiktionarySection(word: string, sectionName: string): Promise<string | null>;
     /**
      * Returns compound words that contain this word.
      */
@@ -314,12 +392,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.
      */
@@ -362,4 +449,4 @@ declare class TDKNetworkError extends TDKError {
     });
 }
 
-export { type Author, type DailyContent, type DailyPick, type Example, type Feature, type Meaning, type Proverb, type SpellCheckResult, TDK, TDKError, TDKNetworkError, type TDKResponse, type TDKRule, TDKValidationError, type WordAnalysis, type WordComparison, type WordComparisonSide, type WordInfo, type WordOfTheDay };
+export { type Author, type DailyContent, type DailyPick, type Example, type Feature, type KubbealtiEntry, type Meaning, type Proverb, type SpellCheckResult, TDK, TDKError, TDKNetworkError, type TDKResponse, type TDKRule, TDKValidationError, type WiktionaryEntry, type WordAnalysis, type WordComparison, type WordComparisonSide, type WordInfo, type WordOfTheDay };

package/dist/index.js

@@ -69,9 +69,87 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var os = __toESM(require("os"));
 var https = __toESM(require("https"));
+var tls = __toESM(require("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-----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+-----END CERTIFICATE-----`
+  ];
   // Cache Mechanism
   static isCacheEnabled = false;
   static wordCache = /* @__PURE__ */ new Map();
@@ -438,11 +516,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 +604,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;
   }
@@ -567,7 +659,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.
@@ -686,6 +937,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 +961,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 +977,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-SLNXKZKR.mjs";
 export {
   TDK,
   TDKError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdk-api-wrapper",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "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

@@ -22,6 +22,9 @@ const KNOWN_COMMANDS = new Set([
   "karsilastir",
   "analiz",
   "oneri",
+  "kubbealti",
+  "nisanyan",
+  "viki",
 ]);
 
 let command = args[0];
@@ -52,7 +55,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, oneri"
+      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz, oneri, kubbealti, nisanyan, viki"
     );
     console.log("Not: Komut belirtilmezse doğrudan kelime anlamı aranır (örn: tdk selam)");
     process.exit(command ? 0 : 1);
@@ -259,6 +262,43 @@ async function run() {
         break;
       }
 
+      case "kubbealti": {
+        if (!word) throw new Error("Kelime belirtmelisiniz.");
+        const meanings = await TDK.getKubbealtiMeanings(word);
+        printResult(meanings, () => {
+          if (!meanings) {
+            console.log("Kubbealtı Lugatı'na ulaşılamadı.");
+          } else if (meanings.length === 0) {
+            console.log("Sonuç bulunamadı.");
+          } else {
+            meanings.forEach((m, i) => console.log(`${i + 1}. ${m}`));
+          }
+        });
+        break;
+      }
+
+      case "nisanyan": {
+        if (!word) throw new Error("Kelime belirtmelisiniz.");
+        const origin = await TDK.getNisanyan(word);
+        printResult(origin, () => console.log(origin ?? "Sonuç bulunamadı."));
+        break;
+      }
+
+      case "viki": {
+        if (!word) throw new Error("Kelime belirtmelisiniz.");
+        const entry = await TDK.getWiktionary(word);
+        printResult(entry, () => {
+          if (!entry) {
+            console.log("Sonuç bulunamadı.");
+          } else {
+            for (const [title, content] of Object.entries(entry.sections)) {
+              if (content) console.log(`-- ${title} --\n${content}\n`);
+            }
+          }
+        });
+        break;
+      }
+
       default:
         printError("Bilinmeyen komut.");
     }