tdk-api-wrapper 1.5.0 → 1.6.0

package/dist/cli.js

@@ -560,6 +560,13 @@ function getStemCandidates(word2, minStemLength = 2, maxDepth = 4) {
       seen.add(apostropheStem);
     }
   }
+  const bareInfinitives = restoreInfinitive(normalized);
+  for (const inf of bareInfinitives) {
+    if (!seen.has(inf) && inf !== normalized) {
+      seen.add(inf);
+      candidatesWithWeight.push({ candidate: inf, baseLength: normalized.length });
+    }
+  }
   let frontier = [normalized];
   for (let depth = 0; depth < maxDepth; depth++) {
     const nextFrontier = [];
@@ -609,6 +616,210 @@ var path = __toESM(require("path"));
 var os = __toESM(require("os"));
 var https = __toESM(require("https"));
 var tls = __toESM(require("tls"));
+var COMMON_MISSPELLINGS = {
+  // -şey ile biten ve ayrı yazılması zorunlu söz öbekleri
+  her\u015Fey: "her \u015Fey",
+  hersey: "her \u015Fey",
+  bir\u015Fey: "bir \u015Fey",
+  birsey: "bir \u015Fey",
+  hi\u00E7bir\u015Fey: "hi\xE7bir \u015Fey",
+  hicbirsey: "hi\xE7bir \u015Fey",
+  \u00E7ok\u015Fey: "\xE7ok \u015Fey",
+  coksey: "\xE7ok \u015Fey",
+  \u015Feyler: "\u015Feyler",
+  seyler: "\u015Feyler",
+  herhangibir\u015Fey: "herhangi bir \u015Fey",
+  herhangibirsey: "herhangi bir \u015Fey",
+  // Sıkça birleşik yazılan ama ayrı yazılması gereken sözler
+  herg\u00FCn: "her g\xFCn",
+  hergun: "her g\xFCn",
+  herzaman: "her zaman",
+  heran: "her an",
+  heryer: "her yer",
+  herbiri: "her biri",
+  pek\u00E7ok: "pek \xE7ok",
+  pekcok: "pek \xE7ok",
+  pekaz: "pek az",
+  yada: "ya da",
+  tabiki: "tabii ki",
+  tabiiki: "tabii ki",
+  sa\u011Fol: "sa\u011F ol",
+  sagol: "sa\u011F ol",
+  sa\u011Folun: "sa\u011F olun",
+  sagolun: "sa\u011F olun",
+  ho\u015F\u00E7akal: "ho\u015F\xE7a kal",
+  hoscakal: "ho\u015F\xE7a kal",
+  ho\u015Fgeldin: "ho\u015F geldin",
+  hosgeldin: "ho\u015F geldin",
+  ho\u015Fgeldiniz: "ho\u015F geldiniz",
+  hosgeldiniz: "ho\u015F geldiniz",
+  ho\u015Fbulduk: "ho\u015F bulduk",
+  hosbulduk: "ho\u015F bulduk",
+  yan\u0131s\u0131ra: "yan\u0131 s\u0131ra",
+  yanisira: "yan\u0131 s\u0131ra",
+  pe\u015Fis\u0131ra: "pe\u015Fi s\u0131ra",
+  pesisira: "pe\u015Fi s\u0131ra",
+  ard\u0131s\u0131ra: "ard\u0131 s\u0131ra",
+  ardisira: "ard\u0131 s\u0131ra",
+  artarda: "art arda",
+  y\u00FCzy\u00FCze: "y\xFCz y\xFCze",
+  yuzyuze: "y\xFCz y\xFCze",
+  elele: "el ele",
+  g\u00F6zg\u00F6ze: "g\xF6z g\xF6ze",
+  ba\u015Fba\u015Fa: "ba\u015F ba\u015Fa",
+  basbasa: "ba\u015F ba\u015Fa",
+  yanyana: "yan yana",
+  i\u00E7i\u00E7e: "i\xE7 i\xE7e",
+  icice: "i\xE7 i\xE7e",
+  \u00FCst\u00FCste: "\xFCst \xFCste",
+  ustuste: "\xFCst \xFCste",
+  altalta: "alt alta",
+  \u00F6ns\u00F6z: "\xF6n s\xF6z",
+  onsoz: "\xF6n s\xF6z",
+  \u00F6nyarg\u0131: "\xF6n yarg\u0131",
+  onyargi: "\xF6n yarg\u0131",
+  farketmek: "fark etmek",
+  farketti: "fark etti",
+  farkettim: "fark ettim",
+  farkeder: "fark eder",
+  farketmez: "fark etmez",
+  terketmek: "terk etmek",
+  terketti: "terk etti",
+  ay\u0131rdetmek: "ay\u0131rt etmek",
+  ay\u0131rtetmek: "ay\u0131rt etmek",
+  arzetmek: "arz etmek",
+  arzederim: "arz ederim",
+  varolmak: "var olmak",
+  yokolmak: "yok olmak",
+  haketmek: "hak etmek",
+  haketti: "hak etti",
+  hakkaten: "hakikaten",
+  hi\u00E7kimse: "hi\xE7 kimse",
+  hickimse: "hi\xE7 kimse",
+  // Ünlü düşmesi yapılmaması gereken yer bildiren sözler (TDK Kural 15)
+  burda: "burada",
+  burdan: "buradan",
+  \u015Furda: "\u015Furada",
+  surda: "\u015Furada",
+  \u015Furdan: "\u015Furadan",
+  surdan: "\u015Furadan",
+  orda: "orada",
+  ordan: "oradan",
+  i\u00E7erde: "i\xE7eride",
+  icerde: "i\xE7eride",
+  i\u00E7erden: "i\xE7eriden",
+  icerden: "i\xE7eriden",
+  d\u0131\u015Farda: "d\u0131\u015Far\u0131da",
+  disarda: "d\u0131\u015Far\u0131da",
+  d\u0131\u015Fardan: "d\u0131\u015Far\u0131dan",
+  disardan: "d\u0131\u015Far\u0131dan",
+  yukarda: "yukar\u0131da",
+  yukardan: "yukar\u0131dan",
+  // Sıkça yanlış yazılan sözcükler
+  herkez: "herkes",
+  yanl\u0131z: "yaln\u0131z",
+  yaln\u0131\u015F: "yanl\u0131\u015F",
+  orjinal: "orijinal",
+  labaratuar: "laboratuvar",
+  laboratuar: "laboratuvar",
+  \u015F\u00F6f\u00F6r: "\u015Fof\xF6r",
+  sofor: "\u015Fof\xF6r",
+  egzos: "egzoz",
+  eksoz: "egzoz",
+  ekzoz: "egzoz",
+  kiprik: "kirpik",
+  kirbit: "kibrit",
+  klavuz: "k\u0131lavuz",
+  k\u0131ravat: "kravat",
+  s\u00FCpriz: "s\xFCrpriz",
+  supriz: "s\xFCrpriz",
+  raslant\u0131: "rastlant\u0131",
+  hastahane: "hastane",
+  pastahane: "pastane",
+  postahane: "postane",
+  eczahane: "eczane",
+  meyva: "meyve",
+  sarm\u0131sak: "sar\u0131msak",
+  dinazor: "dinozor",
+  pantalon: "pantolon",
+  tesbih: "tespih",
+  ah\u00E7\u0131: "a\u015F\xE7\u0131",
+  matba: "matbaa",
+  idda: "iddia",
+  iddaa: "iddia",
+  muhattap: "muhatap",
+  tra\u015F: "t\u0131ra\u015F",
+  karn\u0131bahar: "karnabahar",
+  kareografi: "koreografi",
+  poa\u00E7a: "po\u011Fa\xE7a",
+  poha\u00E7a: "po\u011Fa\xE7a",
+  \u015Farz: "\u015Farj",
+  sarj: "\u015Farj",
+  makina: "makine",
+  m\u00FCsade: "m\xFCsaade",
+  entellekt\u00FCel: "entelekt\xFCel",
+  inisiyatif: "inisiyatif",
+  insiyatif: "inisiyatif",
+  sezeryan: "sezaryen",
+  dok\u00FCman: "dok\xFCman",
+  d\u00F6k\u00FCman: "dok\xFCman",
+  erozyon: "erozyon",
+  erizyon: "erozyon",
+  anane: "anneanne",
+  babaanne: "babaanne"
+};
+var SEY_EXCEPTIONS = /* @__PURE__ */ new Set(["d\xFC\u015Fey", "e\u015Fey", "konsey", "jersey", "\u015Fey"]);
+var KEYBOARD_ROWS = [
+  ["qwertyu\u0131op\u011F\xFC", 0],
+  ["asdfghjkl\u015Fi", 0.5],
+  ["zxcvbnm\xF6\xE7", 1]
+];
+var KEYBOARD_COORDS = (() => {
+  const coords = {};
+  KEYBOARD_ROWS.forEach(([keys, offset], row) => {
+    [...keys].forEach((key, col) => {
+      coords[key] = [col + offset, row];
+    });
+  });
+  return coords;
+})();
+var DIACRITIC_SIBLINGS = {
+  \u0131: "i",
+  i: "\u0131",
+  \u00F6: "o",
+  o: "\xF6",
+  \u00FC: "u",
+  u: "\xFC",
+  \u015F: "s",
+  s: "\u015F",
+  \u00E7: "c",
+  c: "\xE7",
+  \u011F: "g",
+  g: "\u011F",
+  \u00E2: "a",
+  a: "\xE2"
+};
+var KEYBOARD_ROW_SUB_COST = 0.4;
+var KEYBOARD_DIAGONAL_SUB_COST = 0.55;
+var DIACRITIC_SUB_COST = 0.3;
+var TRANSPOSITION_COST = 0.8;
+function keyboardSubCost(a, b) {
+  if (a === b)
+    return 0;
+  if (DIACRITIC_SIBLINGS[a] === b)
+    return DIACRITIC_SUB_COST;
+  const pa = KEYBOARD_COORDS[a];
+  const pb = KEYBOARD_COORDS[b];
+  if (!pa || !pb)
+    return 1;
+  const dx = Math.abs(pa[0] - pb[0]);
+  const dy = Math.abs(pa[1] - pb[1]);
+  if (dy === 0 && dx <= 1 + 1e-9)
+    return KEYBOARD_ROW_SUB_COST;
+  if (dy === 1 && dx <= 1 + 1e-9)
+    return KEYBOARD_DIAGONAL_SUB_COST;
+  return 1;
+}
 var TDK = class {
   static BASE_URL = "https://sozluk.gov.tr";
   static AUDIO_API_HOST = "api.sozluk.gov.tr";
@@ -1172,25 +1383,45 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
    * Checks spelling and returns suggestions if wrong.
    */
   static async checkSpelling(word2) {
+    if (!word2 || word2.trim() === "") {
+      return { isCorrect: false, word: word2 };
+    }
+    const cleanWord = word2.trim().toLocaleLowerCase("tr-TR");
     const results = await this.getWord(word2);
     if (results.length > 0) {
       return { isCorrect: true, word: word2 };
     }
+    if (COMMON_MISSPELLINGS[cleanWord]) {
+      return { isCorrect: false, word: word2, suggestion: COMMON_MISSPELLINGS[cleanWord] };
+    }
+    const seyMatch = cleanWord.match(/^(.+?)(?:şey|sey)([ıiuaeüodekmnl]+)?$/);
+    if (seyMatch && !SEY_EXCEPTIONS.has(cleanWord)) {
+      let prefix = seyMatch[1];
+      const suffix = seyMatch[2] || "";
+      if (prefix === "hicbir")
+        prefix = "hi\xE7bir";
+      if (prefix === "cok")
+        prefix = "\xE7ok";
+      return {
+        isCorrect: false,
+        word: word2,
+        suggestion: `${prefix} \u015Fey${suffix}`
+      };
+    }
     const daily = await this.getDailyContent();
     if (daily) {
-      const syydMatch = daily.syyd.find((s) => s.yanliskelime.toLocaleLowerCase("tr-TR") === word2.toLocaleLowerCase("tr-TR"));
+      const syydMatch = daily.syyd.find((s) => s.yanliskelime.toLocaleLowerCase("tr-TR") === cleanWord);
       if (syydMatch) {
         return { isCorrect: false, word: word2, suggestion: syydMatch.dogrukelime };
       }
-      const mixMatch = daily.karistirma.find((s) => s.yanlis.toLocaleLowerCase("tr-TR") === word2.toLocaleLowerCase("tr-TR"));
+      const mixMatch = daily.karistirma.find((s) => s.yanlis.toLocaleLowerCase("tr-TR") === cleanWord);
       if (mixMatch) {
         return { isCorrect: false, word: word2, suggestion: mixMatch.dogru };
       }
     }
     const root = await this.findRoot(word2);
     if (root) {
-      const cleanWord2 = word2.trim().toLocaleLowerCase("tr-TR");
-      const isInflected = root !== cleanWord2;
+      const isInflected = root !== cleanWord;
       return {
         isCorrect: true,
         word: word2,
@@ -1201,24 +1432,32 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
     if (this.autocompleteCache.length === 0) {
       this.autocompleteCache = await this.fetchAutocompleteData();
     }
-    const cleanWord = word2.trim().toLocaleLowerCase("tr-TR");
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ")) {
+        const candidateNoSpace = candidate.replace(/\s+/g, "").toLocaleLowerCase("tr-TR");
+        if (candidateNoSpace === cleanWord) {
+          return { isCorrect: false, word: word2, suggestion: candidate };
+        }
+      }
+    }
     let best = null;
     for (const candidate of this.autocompleteCache) {
       if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
         continue;
       if (Math.abs(candidate.length - cleanWord.length) > 2)
         continue;
-      const distance = this.damerauLevenshtein(cleanWord, candidate);
-      if (distance === 0)
+      const rawDist = this.damerauLevenshtein(cleanWord, candidate);
+      if (rawDist === 0 || rawDist > 2)
         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;
+      const score = this.keyboardAwareDistance(cleanWord, candidate) + (firstMismatch > 0 ? 1.2 : 0);
+      const better = !best || score < best.score - 1e-9 || Math.abs(score - best.score) < 1e-9 && firstMismatch < best.firstMismatch || Math.abs(score - best.score) < 1e-9 && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch;
       if (better) {
-        best = { candidate, distance, firstMismatch, lengthMismatch };
+        best = { candidate, score, rawDist, firstMismatch, lengthMismatch };
       }
     }
-    if (best && best.distance <= 2) {
+    if (best && best.rawDist <= 2 && (best.firstMismatch === 0 || best.rawDist <= 1)) {
       return { isCorrect: false, word: word2, suggestion: best.candidate };
     }
     return { isCorrect: false, word: word2 };
@@ -1747,6 +1986,32 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
     }
     return dp[a.length][b.length];
   }
+  /**
+   * Keyboard- and diacritic-aware edit distance: same optimal-string-alignment
+   * recurrence as {@link damerauLevenshtein}, but a substitution is charged by
+   * {@link keyboardSubCost} (a fraction of an edit when the two letters are
+   * adjacent on a Turkish Q keyboard or are ASCII/diacritic siblings) and a
+   * transposition costs {@link TRANSPOSITION_COST}. Insertions and deletions
+   * still cost a full 1. Used only to *rank* spelling candidates; the plain
+   * integer distance still gates whether a suggestion is offered at all.
+   */
+  static keyboardAwareDistance(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;
+    for (let j = 0; j <= b.length; j++)
+      dp[0][j] = j;
+    for (let i = 1; i <= a.length; i++) {
+      for (let j = 1; j <= b.length; j++) {
+        const cost = keyboardSubCost(a[i - 1], b[j - 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] + TRANSPOSITION_COST);
+        }
+      }
+    }
+    return dp[a.length][b.length];
+  }
   /**
    * Fetches multiple words concurrently with a small delay to avoid rate limiting.
    */
@@ -1971,6 +2236,73 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
       "me\u011Ferki",
       "illaki"
     ]);
+    const PHRASE_MISTAKES = [
+      {
+        regex: /\bhiç\s+bir\b/gi,
+        suggestion: "hi\xE7bir",
+        message: "'hi\xE7bir' belgisiz s\u0131fat\u0131 biti\u015Fik yaz\u0131lmal\u0131d\u0131r.",
+        type: "spelling"
+      },
+      {
+        regex: /\bbir\s+çok\b/gi,
+        suggestion: "bir\xE7ok",
+        message: "'bir\xE7ok' belgisiz s\u0131fat\u0131/zamiri biti\u015Fik yaz\u0131lmal\u0131d\u0131r.",
+        type: "spelling"
+      },
+      {
+        regex: /\bbir\s+kaç\b/gi,
+        suggestion: "birka\xE7",
+        message: "'birka\xE7' belgisiz s\u0131fat\u0131/zamiri biti\u015Fik yaz\u0131lmal\u0131d\u0131r.",
+        type: "spelling"
+      },
+      {
+        regex: /\bbir\s+az\b/gi,
+        suggestion: "biraz",
+        message: "'biraz' s\xF6zc\xFC\u011F\xFC biti\u015Fik yaz\u0131lmal\u0131d\u0131r.",
+        type: "spelling"
+      },
+      {
+        regex: /\bher\s+hangi\b/gi,
+        suggestion: "herhangi",
+        message: "'herhangi' s\xF6zc\xFC\u011F\xFC biti\u015Fik yaz\u0131lmal\u0131d\u0131r.",
+        type: "spelling"
+      },
+      {
+        regex: /\bgit\s+gide\b/gi,
+        suggestion: "gitgide",
+        message: "'gitgide' zarf\u0131 biti\u015Fik yaz\u0131lmal\u0131d\u0131r.",
+        type: "spelling"
+      },
+      {
+        regex: /\bbirden\s+bire\b/gi,
+        suggestion: "birdenbire",
+        message: "'birdenbire' zarf\u0131 biti\u015Fik yaz\u0131lmal\u0131d\u0131r.",
+        type: "spelling"
+      },
+      {
+        regex: /\brast\s+gele\b/gi,
+        suggestion: "rastgele",
+        message: "'rastgele' zarf\u0131 biti\u015Fik yaz\u0131lmal\u0131d\u0131r.",
+        type: "spelling"
+      }
+    ];
+    const coveredRanges = [];
+    for (const pm of PHRASE_MISTAKES) {
+      let pmMatch;
+      while ((pmMatch = pm.regex.exec(text)) !== null) {
+        const start = pmMatch.index;
+        const end = start + pmMatch[0].length;
+        coveredRanges.push({ start, end });
+        issues.push({
+          type: pm.type,
+          word: pmMatch[0],
+          startIndex: start,
+          endIndex: end,
+          suggestion: pm.suggestion,
+          message: pm.message
+        });
+      }
+    }
     const tokenRegex = /[\p{L}0-9'’]+/gu;
     let match;
     while ((match = tokenRegex.exec(text)) !== null) {
@@ -1980,6 +2312,8 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
       const lower = rawWord.toLocaleLowerCase("tr-TR");
       if (/^\d+$/.test(lower))
         continue;
+      if (coveredRanges.some((r) => startIndex >= r.start && endIndex <= r.end))
+        continue;
       let flagged = false;
       const questionMatch = lower.match(/^(.+?)(m[ıiuü](?:sin|sın|sun|sün|siniz|sınız|sunuz|sünüz|yiz|yız|yuz|yüz|m|k)?)$/);
       if (questionMatch) {
@@ -2005,7 +2339,7 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
         if (!SOMBAHCEMI.has(lower)) {
           if (!await this.isHeadword(lower)) {
             const root = await this.findRoot(base);
-            const isVerb = root && (root.endsWith("mek") || root.endsWith("mak")) || base === "demek" || base === "kald\u0131" || base === "yeter" || base === "bilmem" || VERB_CONJUGATION_REGEX.test(base);
+            const isVerb = (base === "demek" || base === "kald\u0131" || base === "yeter" || base === "bilmem" || VERB_CONJUGATION_REGEX.test(base)) && (root ? root.endsWith("mek") || root.endsWith("mak") : true);
             if (isVerb) {
               issues.push({
                 type: "conjunction_ki",
@@ -2025,7 +2359,7 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
         const ending = lower.slice(-2);
         if (!await this.isHeadword(lower)) {
           const root = await this.findRoot(base);
-          const isVerb = root && (root.endsWith("mek") || root.endsWith("mak")) || VERB_CONJUGATION_REGEX.test(base);
+          const isVerb = VERB_CONJUGATION_REGEX.test(base) && (root ? root.endsWith("mek") || root.endsWith("mak") : false);
           if (isVerb) {
             const correctEnding = ending.startsWith("t") ? ending === "te" ? "de" : "da" : ending;
             issues.push({
@@ -2040,6 +2374,47 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
           }
         }
       }
+      const seyMatch = lower.match(/^(.+?)(?:şey|sey)([ıiuaeüodekmnl]+)?$/);
+      if (!flagged && seyMatch && !SEY_EXCEPTIONS.has(lower)) {
+        let prefix = seyMatch[1];
+        const suffix = seyMatch[2] || "";
+        if (prefix === "hicbir")
+          prefix = "hi\xE7bir";
+        if (prefix === "cok")
+          prefix = "\xE7ok";
+        issues.push({
+          type: "spelling",
+          word: rawWord,
+          startIndex,
+          endIndex,
+          suggestion: `${prefix} \u015Fey${suffix}`,
+          message: "'\u015Fey' s\xF6zc\xFC\u011F\xFC kendinden \xF6nceki kelimeden ayr\u0131 yaz\u0131lmal\u0131d\u0131r."
+        });
+        flagged = true;
+      }
+      if (!flagged && lower === "yada") {
+        issues.push({
+          type: "spelling",
+          word: rawWord,
+          startIndex,
+          endIndex,
+          suggestion: "ya da",
+          message: "'ya da' ba\u011Flac\u0131 her zaman ayr\u0131 yaz\u0131l\u0131r."
+        });
+        flagged = true;
+      }
+      if (!flagged && (lower === "burda" || lower === "\u015Furda" || lower === "surda" || lower === "orda" || lower === "i\xE7erde" || lower === "icerde" || lower === "d\u0131\u015Farda" || lower === "disarda" || lower === "yukarda")) {
+        const correct = COMMON_MISSPELLINGS[lower] || lower;
+        issues.push({
+          type: "spelling",
+          word: rawWord,
+          startIndex,
+          endIndex,
+          suggestion: correct,
+          message: `'${rawWord}' s\xF6zc\xFC\u011F\xFCnde \xFCnl\xFC d\xFC\u015Fmesi yap\u0131lmaz.`
+        });
+        flagged = true;
+      }
       if (!flagged) {
         const check = await this.checkSpelling(rawWord);
         if (!check.isCorrect) {
@@ -2049,11 +2424,12 @@ yDFx8r7i9vIJU5HS3moZLkYWAOilMaV9N56A9Bgb6dNcHkvg3NoaYA==
             startIndex,
             endIndex,
             suggestion: check.suggestion,
-            message: check.suggestion ? `'${rawWord}' yanl\u0131\u015F yaz\u0131lm\u0131\u015F olabilir. \xD6neri: '${check.suggestion}'` : `'${rawWord}' s\xF6zl\xFCkte bulunamad\u0131.`
+            message: check.suggestion ? `'${rawWord}' yanl\u0131\u015F yaz\u0131lm\u0131\u015F olabilir.` : `'${rawWord}' s\xF6zl\xFCkte bulunamad\u0131.`
           });
         }
       }
     }
+    issues.sort((a, b) => a.startIndex - b.startIndex);
     return {
       text,
       issues,
@@ -2111,7 +2487,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
 ]);
 var command = args[0];
 var word = args.slice(1).join(" ");
-if (command && !KNOWN_COMMANDS.has(command) && command !== "--help" && command !== "-h") {
+if (command && !KNOWN_COMMANDS.has(command) && command !== "--help" && command !== "-h" && command !== "--version" && command !== "-v") {
   word = args.join(" ");
   command = "anlam";
 }
@@ -2206,6 +2582,10 @@ async function run() {
     console.log("Not: Komut belirtilmezse do\u011Frudan kelime anlam\u0131 aran\u0131r (\xF6rn: tdk selam)");
     process.exit(1);
   }
+  if (command === "--version" || command === "-v") {
+    console.log("tdk-api-wrapper v1.5.1");
+    process.exit(0);
+  }
   if (command === "--help" || command === "-h") {
     console.log("Kullan\u0131m: tdk [komut] <kelime> [--json]");
     console.log(

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TDK
-} from "./chunk-7KJHYRJZ.mjs";
+} from "./chunk-ZFWZXNGY.mjs";
 
 // src/cli.ts
 var rawArgs = process.argv.slice(2);
@@ -52,7 +52,7 @@ var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
 ]);
 var command = args[0];
 var word = args.slice(1).join(" ");
-if (command && !KNOWN_COMMANDS.has(command) && command !== "--help" && command !== "-h") {
+if (command && !KNOWN_COMMANDS.has(command) && command !== "--help" && command !== "-h" && command !== "--version" && command !== "-v") {
   word = args.join(" ");
   command = "anlam";
 }
@@ -147,6 +147,10 @@ async function run() {
     console.log("Not: Komut belirtilmezse do\u011Frudan kelime anlam\u0131 aran\u0131r (\xF6rn: tdk selam)");
     process.exit(1);
   }
+  if (command === "--version" || command === "-v") {
+    console.log("tdk-api-wrapper v1.5.1");
+    process.exit(0);
+  }
   if (command === "--help" || command === "-h") {
     console.log("Kullan\u0131m: tdk [komut] <kelime> [--json]");
     console.log(

package/dist/index.d.mts

@@ -508,6 +508,16 @@ declare class TDK {
      * otherwise misses.
      */
     private static damerauLevenshtein;
+    /**
+     * Keyboard- and diacritic-aware edit distance: same optimal-string-alignment
+     * recurrence as {@link damerauLevenshtein}, but a substitution is charged by
+     * {@link keyboardSubCost} (a fraction of an edit when the two letters are
+     * adjacent on a Turkish Q keyboard or are ASCII/diacritic siblings) and a
+     * transposition costs {@link TRANSPOSITION_COST}. Insertions and deletions
+     * still cost a full 1. Used only to *rank* spelling candidates; the plain
+     * integer distance still gates whether a suggestion is offered at all.
+     */
+    private static keyboardAwareDistance;
     /**
      * Fetches multiple words concurrently with a small delay to avoid rate limiting.
      */

package/dist/index.d.ts

@@ -508,6 +508,16 @@ declare class TDK {
      * otherwise misses.
      */
     private static damerauLevenshtein;
+    /**
+     * Keyboard- and diacritic-aware edit distance: same optimal-string-alignment
+     * recurrence as {@link damerauLevenshtein}, but a substitution is charged by
+     * {@link keyboardSubCost} (a fraction of an edit when the two letters are
+     * adjacent on a Turkish Q keyboard or are ASCII/diacritic siblings) and a
+     * transposition costs {@link TRANSPOSITION_COST}. Insertions and deletions
+     * still cost a full 1. Used only to *rank* spelling candidates; the plain
+     * integer distance still gates whether a suggestion is offered at all.
+     */
+    private static keyboardAwareDistance;
     /**
      * Fetches multiple words concurrently with a small delay to avoid rate limiting.
      */