terlik.js 2.2.0

package/dist/index.mjs

@@ -0,0 +1,2004 @@
+// src/dictionary/index.ts
+var Dictionary = class {
+  entries = /* @__PURE__ */ new Map();
+  whitelist;
+  allWords = [];
+  suffixes;
+  /**
+   * Creates a new Dictionary from validated dictionary data.
+   * @param data - Validated dictionary data (entries, suffixes, whitelist).
+   * @param customWords - Additional words to detect.
+   * @param customWhitelist - Additional words to exclude.
+   */
+  constructor(data, customWords, customWhitelist) {
+    this.whitelist = new Set(data.whitelist.map((w) => w.toLowerCase()));
+    this.suffixes = data.suffixes;
+    if (customWhitelist) {
+      for (const w of customWhitelist) {
+        this.whitelist.add(w.toLowerCase());
+      }
+    }
+    for (const entry of data.entries) {
+      this.addEntry({
+        root: entry.root,
+        variants: entry.variants,
+        severity: entry.severity,
+        category: entry.category,
+        suffixable: entry.suffixable
+      });
+    }
+    if (customWords) {
+      for (const word of customWords) {
+        this.addEntry({
+          root: word.toLowerCase(),
+          variants: [],
+          severity: "medium"
+        });
+      }
+    }
+  }
+  addEntry(entry) {
+    const normalizedRoot = entry.root.toLowerCase();
+    this.entries.set(normalizedRoot, entry);
+    this.allWords.push(normalizedRoot);
+    for (const v of entry.variants) {
+      this.allWords.push(v.toLowerCase());
+    }
+  }
+  /** Returns all dictionary entries keyed by root word. */
+  getEntries() {
+    return this.entries;
+  }
+  /** Returns all words (roots + variants) as a flat array. */
+  getAllWords() {
+    return this.allWords;
+  }
+  /** Returns the whitelist as a Set of lowercase strings. */
+  getWhitelist() {
+    return this.whitelist;
+  }
+  /** Returns available grammatical suffixes for the language. */
+  getSuffixes() {
+    return this.suffixes;
+  }
+  /**
+   * Adds words to the dictionary at runtime.
+   * Empty strings and already-existing words are silently skipped.
+   * @param words - Words to add.
+   */
+  addWords(words) {
+    for (const word of words) {
+      const lower = word.toLowerCase().trim();
+      if (lower.length === 0) continue;
+      if (!this.entries.has(lower)) {
+        this.addEntry({
+          root: lower,
+          variants: [],
+          severity: "medium"
+        });
+      }
+    }
+  }
+  /**
+   * Removes words from the dictionary at runtime.
+   * @param words - Words to remove.
+   */
+  removeWords(words) {
+    for (const word of words) {
+      const key = word.toLowerCase();
+      const entry = this.entries.get(key);
+      if (entry) {
+        this.entries.delete(key);
+        this.allWords = this.allWords.filter(
+          (w) => w !== key && !entry.variants.map((v) => v.toLowerCase()).includes(w)
+        );
+      }
+    }
+  }
+  /**
+   * Finds the dictionary entry for a given word (checks root and variants).
+   * @param word - The word to look up.
+   * @returns The matching WordEntry, or undefined if not found.
+   */
+  findRootForWord(word) {
+    const lower = word.toLowerCase();
+    const direct = this.entries.get(lower);
+    if (direct) return direct;
+    for (const [, entry] of this.entries) {
+      if (entry.variants.some((v) => v.toLowerCase() === lower)) {
+        return entry;
+      }
+    }
+    return void 0;
+  }
+};
+
+// src/patterns.ts
+var SEPARATOR = "[^\\p{L}\\p{N}]{0,3}";
+var MAX_PATTERN_LENGTH = 1e4;
+var MAX_SUFFIX_CHAIN = 2;
+var REGEX_TIMEOUT_MS = 250;
+function charToPattern(ch, charClasses) {
+  const cls = charClasses[ch.toLowerCase()];
+  if (cls) return `${cls}+`;
+  return ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "+";
+}
+function wordToPattern(word, charClasses, normalizeFn) {
+  const normalized = normalizeFn(word);
+  const chars = [...normalized];
+  const parts = chars.map((ch) => charToPattern(ch, charClasses));
+  return parts.join(SEPARATOR);
+}
+function buildSuffixGroup(suffixes, charClasses) {
+  if (suffixes.length === 0) return "";
+  const suffixPatterns = suffixes.map((suffix) => {
+    const chars = [...suffix];
+    const parts = chars.map((ch) => charToPattern(ch, charClasses));
+    return parts.join(SEPARATOR);
+  });
+  suffixPatterns.sort((a, b) => b.length - a.length);
+  return `(?:${SEPARATOR}(?:${suffixPatterns.join("|")}))`;
+}
+function compilePatterns(entries, suffixes, charClasses, normalizeFn) {
+  const patterns = [];
+  const suffixGroup = suffixes && suffixes.length > 0 ? buildSuffixGroup(suffixes, charClasses) : "";
+  for (const [, entry] of entries) {
+    const allForms = [entry.root, ...entry.variants];
+    const sortedForms = allForms.map((w) => normalizeFn(w)).filter((w) => w.length > 0).filter((w, i, arr) => arr.indexOf(w) === i).sort((a, b) => b.length - a.length);
+    const formPatterns = sortedForms.map(
+      (w) => wordToPattern(w, charClasses, normalizeFn)
+    );
+    const combined = formPatterns.join("|");
+    const useSuffix = entry.suffixable && suffixGroup.length > 0;
+    let pattern;
+    if (useSuffix) {
+      pattern = `(?<![\\p{L}\\p{N}])(?:${combined})${suffixGroup}{0,${MAX_SUFFIX_CHAIN}}(?![\\p{L}\\p{N}])`;
+    } else {
+      pattern = `(?<![\\p{L}\\p{N}])(?:${combined})(?![\\p{L}\\p{N}])`;
+    }
+    if (pattern.length > MAX_PATTERN_LENGTH && useSuffix) {
+      pattern = `(?<![\\p{L}\\p{N}])(?:${combined})(?![\\p{L}\\p{N}])`;
+    }
+    try {
+      const regex = new RegExp(pattern, "giu");
+      patterns.push({
+        root: entry.root,
+        severity: entry.severity,
+        regex,
+        variants: entry.variants
+      });
+    } catch (err) {
+      if (useSuffix) {
+        try {
+          const fallbackPattern = `(?<![\\p{L}\\p{N}])(?:${combined})(?![\\p{L}\\p{N}])`;
+          const regex = new RegExp(fallbackPattern, "giu");
+          patterns.push({
+            root: entry.root,
+            severity: entry.severity,
+            regex,
+            variants: entry.variants
+          });
+          console.warn(`[terlik] Pattern for "${entry.root}" failed with suffixes, using fallback: ${err instanceof Error ? err.message : String(err)}`);
+        } catch (err2) {
+          console.warn(`[terlik] Pattern for "${entry.root}" failed completely, skipping: ${err2 instanceof Error ? err2.message : String(err2)}`);
+        }
+      } else {
+        console.warn(`[terlik] Pattern for "${entry.root}" failed, skipping: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  return patterns;
+}
+
+// src/fuzzy.ts
+function levenshteinDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(
+        prev[j] + 1,
+        // deletion
+        curr[j - 1] + 1,
+        // insertion
+        prev[j - 1] + cost
+        // substitution
+      );
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function levenshteinSimilarity(a, b) {
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  return 1 - levenshteinDistance(a, b) / maxLen;
+}
+function bigrams(str) {
+  const set = /* @__PURE__ */ new Set();
+  for (let i = 0; i < str.length - 1; i++) {
+    set.add(str.slice(i, i + 2));
+  }
+  return set;
+}
+function diceSimilarity(a, b) {
+  if (a.length < 2 || b.length < 2) {
+    return a === b ? 1 : 0;
+  }
+  const bigramsA = bigrams(a);
+  const bigramsB = bigrams(b);
+  let intersection = 0;
+  for (const bg of bigramsA) {
+    if (bigramsB.has(bg)) intersection++;
+  }
+  return 2 * intersection / (bigramsA.size + bigramsB.size);
+}
+function getFuzzyMatcher(algorithm) {
+  return algorithm === "levenshtein" ? levenshteinSimilarity : diceSimilarity;
+}
+
+// src/detector.ts
+var Detector = class {
+  dictionary;
+  _patterns = null;
+  normalizedWordSet;
+  normalizedWordToRoot;
+  normalizeFn;
+  locale;
+  charClasses;
+  constructor(dictionary, normalizeFn, locale, charClasses) {
+    this.dictionary = dictionary;
+    this.normalizeFn = normalizeFn;
+    this.locale = locale;
+    this.charClasses = charClasses;
+    this.normalizedWordSet = /* @__PURE__ */ new Set();
+    this.normalizedWordToRoot = /* @__PURE__ */ new Map();
+    this.buildNormalizedLookup();
+  }
+  ensureCompiled() {
+    if (this._patterns === null) {
+      this._patterns = compilePatterns(
+        this.dictionary.getEntries(),
+        this.dictionary.getSuffixes(),
+        this.charClasses,
+        this.normalizeFn
+      );
+    }
+    return this._patterns;
+  }
+  compile() {
+    this.ensureCompiled();
+  }
+  recompile() {
+    this._patterns = compilePatterns(
+      this.dictionary.getEntries(),
+      this.dictionary.getSuffixes(),
+      this.charClasses,
+      this.normalizeFn
+    );
+    this.buildNormalizedLookup();
+  }
+  buildNormalizedLookup() {
+    this.normalizedWordSet.clear();
+    this.normalizedWordToRoot.clear();
+    for (const word of this.dictionary.getAllWords()) {
+      const n = this.normalizeFn(word);
+      this.normalizedWordSet.add(n);
+      this.normalizedWordToRoot.set(n, word);
+    }
+  }
+  getPatterns() {
+    const map = /* @__PURE__ */ new Map();
+    for (const p of this.ensureCompiled()) {
+      map.set(p.root, p.regex);
+    }
+    return map;
+  }
+  detect(text, options) {
+    const mode = options?.mode ?? "balanced";
+    const results = [];
+    const whitelist = this.dictionary.getWhitelist();
+    if (mode === "strict") {
+      this.detectStrict(text, whitelist, results);
+    } else {
+      this.detectPattern(text, whitelist, results);
+    }
+    if (mode === "loose" || options?.enableFuzzy) {
+      const threshold = options?.fuzzyThreshold ?? 0.8;
+      const algorithm = options?.fuzzyAlgorithm ?? "levenshtein";
+      this.detectFuzzy(text, whitelist, results, threshold, algorithm);
+    }
+    return this.deduplicateResults(results);
+  }
+  detectStrict(text, whitelist, results) {
+    const normalized = this.normalizeFn(text);
+    const words = normalized.split(/\s+/);
+    const originalWords = text.split(/\s+/);
+    let charIndex = 0;
+    for (let wi = 0; wi < originalWords.length; wi++) {
+      const origWord = originalWords[wi];
+      const normWord = wi < words.length ? words[wi] : "";
+      if (normWord.length === 0) {
+        charIndex += origWord.length + 1;
+        continue;
+      }
+      if (whitelist.has(normWord)) {
+        charIndex += origWord.length + 1;
+        continue;
+      }
+      if (this.normalizedWordSet.has(normWord)) {
+        const dictWord = this.normalizedWordToRoot.get(normWord);
+        const entry = this.dictionary.findRootForWord(dictWord);
+        if (entry) {
+          results.push({
+            word: origWord,
+            root: entry.root,
+            index: charIndex,
+            severity: entry.severity,
+            method: "exact"
+          });
+        }
+      }
+      charIndex += origWord.length + 1;
+    }
+  }
+  detectPattern(text, whitelist, results) {
+    this.runPatterns(text, text, whitelist, results, false);
+    const normalizedText = this.normalizeFn(text);
+    const lowerText = text.toLocaleLowerCase(this.locale);
+    if (normalizedText !== lowerText && normalizedText.length > 0) {
+      this.runPatterns(normalizedText, text, whitelist, results, true);
+    }
+  }
+  runPatterns(searchText, originalText, whitelist, results, isNormalized) {
+    const existingIndices = new Set(results.map((r) => r.index));
+    const patterns = this.ensureCompiled();
+    for (const pattern of patterns) {
+      const patternStart = Date.now();
+      pattern.regex.lastIndex = 0;
+      let match;
+      while ((match = pattern.regex.exec(searchText)) !== null) {
+        if (Date.now() - patternStart > REGEX_TIMEOUT_MS) break;
+        const matchedText = match[0];
+        const matchIndex = match.index;
+        const normalizedMatch = this.normalizeFn(matchedText);
+        if (whitelist.has(normalizedMatch)) continue;
+        const surrounding = this.getSurroundingWord(searchText, matchIndex, matchedText.length);
+        const normalizedSurrounding = this.normalizeFn(surrounding);
+        if (whitelist.has(normalizedSurrounding)) continue;
+        if (isNormalized) {
+          const mapped = this.mapNormalizedToOriginal(originalText, matchIndex, matchedText);
+          if (mapped && !existingIndices.has(mapped.index)) {
+            results.push({
+              word: mapped.word,
+              root: pattern.root,
+              index: mapped.index,
+              severity: pattern.severity,
+              method: "pattern"
+            });
+            existingIndices.add(mapped.index);
+          }
+        } else {
+          if (!existingIndices.has(matchIndex)) {
+            results.push({
+              word: matchedText,
+              root: pattern.root,
+              index: matchIndex,
+              severity: pattern.severity,
+              method: "pattern"
+            });
+            existingIndices.add(matchIndex);
+          }
+        }
+        if (matchedText.length === 0) {
+          pattern.regex.lastIndex++;
+        }
+      }
+    }
+  }
+  mapNormalizedToOriginal(originalText, normIndex, _normMatch) {
+    const origWords = originalText.split(/(\s+)/);
+    let normOffset = 0;
+    let origOffset = 0;
+    for (const segment of origWords) {
+      if (/^\s+$/.test(segment)) {
+        normOffset += 1;
+        origOffset += segment.length;
+        continue;
+      }
+      const normWord = this.normalizeFn(segment);
+      const normEnd = normOffset + normWord.length;
+      if (normIndex >= normOffset && normIndex < normEnd) {
+        return { word: segment, index: origOffset };
+      }
+      normOffset = normEnd;
+      origOffset += segment.length;
+    }
+    return null;
+  }
+  detectFuzzy(text, whitelist, existingResults, threshold, algorithm) {
+    const normalized = this.normalizeFn(text);
+    const normWords = normalized.split(/\s+/);
+    const origWords = text.split(/\s+/);
+    const matcher = getFuzzyMatcher(algorithm);
+    const existingIndices = new Set(existingResults.map((r) => r.index));
+    const startTime = Date.now();
+    let charIndex = 0;
+    for (let wi = 0; wi < origWords.length; wi++) {
+      if (Date.now() - startTime > REGEX_TIMEOUT_MS) break;
+      const origWord = origWords[wi];
+      const word = wi < normWords.length ? normWords[wi] : "";
+      if (word.length < 3 || whitelist.has(word)) {
+        charIndex += origWord.length + 1;
+        continue;
+      }
+      for (const normDict of this.normalizedWordSet) {
+        if (normDict.length < 3) continue;
+        const similarity = matcher(word, normDict);
+        if (similarity >= threshold) {
+          if (!existingIndices.has(charIndex)) {
+            const dictWord = this.normalizedWordToRoot.get(normDict);
+            const entry = this.dictionary.findRootForWord(dictWord);
+            if (entry) {
+              existingResults.push({
+                word: origWord,
+                root: entry.root,
+                index: charIndex,
+                severity: entry.severity,
+                method: "fuzzy"
+              });
+              existingIndices.add(charIndex);
+            }
+          }
+          break;
+        }
+      }
+      charIndex += origWord.length + 1;
+    }
+  }
+  getSurroundingWord(text, index, length) {
+    let start = index;
+    let end = index + length;
+    while (start > 0 && /\p{L}/u.test(text[start - 1])) start--;
+    while (end < text.length && /\p{L}/u.test(text[end])) end++;
+    return text.slice(start, end);
+  }
+  deduplicateResults(results) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      const existing = seen.get(result.index);
+      if (!existing || result.word.length > existing.word.length) {
+        seen.set(result.index, result);
+      }
+    }
+    return [...seen.values()].sort((a, b) => a.index - b.index);
+  }
+};
+
+// src/cleaner.ts
+function maskStars(word) {
+  return "*".repeat(word.length);
+}
+function maskPartial(word) {
+  if (word.length <= 2) return "*".repeat(word.length);
+  return word[0] + "*".repeat(word.length - 2) + word[word.length - 1];
+}
+function maskReplace(replaceMask) {
+  return replaceMask;
+}
+function applyMask(word, style, replaceMask) {
+  switch (style) {
+    case "stars":
+      return maskStars(word);
+    case "partial":
+      return maskPartial(word);
+    case "replace":
+      return maskReplace(replaceMask);
+  }
+}
+function cleanText(text, matches, style, replaceMask) {
+  if (matches.length === 0) return text;
+  const sorted = [...matches].sort((a, b) => b.index - a.index);
+  let result = text;
+  for (const match of sorted) {
+    const masked = applyMask(match.word, style, replaceMask);
+    result = result.slice(0, match.index) + masked + result.slice(match.index + match.word.length);
+  }
+  return result;
+}
+
+// src/utils.ts
+var MAX_INPUT_LENGTH = 1e4;
+function validateInput(text, maxLength) {
+  if (text == null) return "";
+  if (typeof text !== "string") return String(text);
+  if (text.length > maxLength) return text.slice(0, maxLength);
+  return text;
+}
+
+// src/lang/tr/dictionary.json
+var dictionary_default = {
+  version: 1,
+  suffixes: [
+    "tir",
+    "dir",
+    "il",
+    "in",
+    "ik",
+    "uk",
+    "en",
+    "ici",
+    "di",
+    "ti",
+    "dim",
+    "tim",
+    "din",
+    "dik",
+    "tik",
+    "mis",
+    "mus",
+    "iyor",
+    "uyor",
+    "ecek",
+    "acak",
+    "ecem",
+    "acam",
+    "icem",
+    "er",
+    "ir",
+    "ar",
+    "eyim",
+    "ayim",
+    "elim",
+    "alim",
+    "se",
+    "sa",
+    "im",
+    "um",
+    "sin",
+    "sun",
+    "yim",
+    "mek",
+    "mak",
+    "me",
+    "ma",
+    "is",
+    "us",
+    "ler",
+    "lar",
+    "si",
+    "e",
+    "a",
+    "de",
+    "da",
+    "den",
+    "dan",
+    "te",
+    "ta",
+    "ten",
+    "tan",
+    "i",
+    "lik",
+    "luk",
+    "li",
+    "lu",
+    "ci",
+    "cu",
+    "ce",
+    "ca",
+    "le",
+    "la",
+    "ken",
+    "esi",
+    "un",
+    "lari",
+    "leri",
+    "larin",
+    "lerin",
+    "misin",
+    "misiniz",
+    "musun",
+    "musunuz",
+    "miyim",
+    "miyiz",
+    "cesine",
+    "casina"
+  ],
+  entries: [
+    {
+      root: "sik",
+      variants: [
+        "siktir",
+        "sikicem",
+        "siktim",
+        "sikeyim",
+        "sikerim",
+        "sikis",
+        "sikik",
+        "sikim",
+        "sikimle",
+        "sikimin",
+        "sikime",
+        "sike",
+        "siken",
+        "siker",
+        "sikti",
+        "siktiler",
+        "sikmis",
+        "sikmek",
+        "sikecek",
+        "sikiyor",
+        "sikme",
+        "sikici",
+        "siksin",
+        "siktirler",
+        "sikimsonik",
+        "siktirin",
+        "siktiler",
+        "sikerler",
+        "sikiler",
+        "sikti\u011Fimin",
+        "sikermisiniz",
+        "sikermisin",
+        "siktirmi\u015Fcesine"
+      ],
+      severity: "high",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "amk",
+      variants: ["amk", "amina", "aminakoyim", "aminakoydugum", "amq"],
+      severity: "high",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "orospu",
+      variants: ["orospucocugu", "orosbucocugu", "orspu", "oruspu", "orosbu"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "pi\xE7",
+      variants: ["pic", "piclik"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "yarrak",
+      variants: ["yarak", "yarrak", "yarakli", "dalyarak", "dalyarrak"],
+      severity: "high",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "g\xF6t",
+      variants: [
+        "got",
+        "gotunu",
+        "gotlek",
+        "gotveren",
+        "gotverenler",
+        "gote",
+        "gotu",
+        "gotler",
+        "gotlu",
+        "gotunden",
+        "gotune"
+      ],
+      severity: "high",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "am",
+      variants: ["amcik", "amcuk"],
+      severity: "high",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "ta\u015Fak",
+      variants: ["tasak", "tassak", "tassakli"],
+      severity: "medium",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "meme",
+      variants: [],
+      severity: "medium",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "ibne",
+      variants: ["ibneler"],
+      severity: "high",
+      category: "slur",
+      suffixable: true
+    },
+    {
+      root: "gavat",
+      variants: ["gavatlik"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "pezevenk",
+      variants: ["pezo"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "bok",
+      variants: [
+        "boktan",
+        "boka",
+        "boku",
+        "boklu",
+        "boklar",
+        "boklari"
+      ],
+      severity: "medium",
+      category: "general",
+      suffixable: false
+    },
+    {
+      root: "haysiyetsiz",
+      variants: [],
+      severity: "medium",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "salak",
+      variants: ["salaklik"],
+      severity: "low",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "aptal",
+      variants: ["aptallik", "aptalca"],
+      severity: "low",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "gerizekal\u0131",
+      variants: ["gerizekali"],
+      severity: "low",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "mal",
+      variants: [],
+      severity: "low",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "dangalak",
+      variants: [],
+      severity: "low",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "ezik",
+      variants: [],
+      severity: "low",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "pu\u015Ft",
+      variants: ["pust", "pustt"],
+      severity: "high",
+      category: "slur",
+      suffixable: true
+    },
+    {
+      root: "\u015Ferefsiz",
+      variants: ["serefsiz", "serefsizler"],
+      severity: "medium",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "yav\u015Fak",
+      variants: ["yavsak"],
+      severity: "medium",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "d\xF6l",
+      variants: ["dol", "dolunu", "dolcu"],
+      severity: "high",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "kahpe",
+      variants: ["kahpelik"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    }
+  ],
+  whitelist: [
+    "amsterdam",
+    "amateur",
+    "amat\xF6r",
+    "sikke",
+    "sikkeler",
+    "masikler",
+    "sikilasma",
+    "ambalaj",
+    "ambassador",
+    "ambulans",
+    "amel",
+    "ameliyat",
+    "amerika",
+    "amele",
+    "amino",
+    "amonyak",
+    "amper",
+    "ampul",
+    "boks\xF6r",
+    "bokser",
+    "bokluk",
+    "malzeme",
+    "maliyet",
+    "malik",
+    "malikane",
+    "maliye",
+    "mallorca",
+    "malta",
+    "malt",
+    "gotan",
+    "gotik",
+    "gotham",
+    "memento",
+    "memleket",
+    "memur",
+    "memorial",
+    "piknik",
+    "pikachu",
+    "tasselled",
+    "siklet",
+    "kasim",
+    "kas\u0131m",
+    "yarasa",
+    "dolunay",
+    "dolum",
+    "doluluk",
+    "ama",
+    "ami",
+    "amen",
+    "amir",
+    "amil",
+    "dolmen"
+  ]
+};
+
+// src/dictionary/schema.ts
+var VALID_SEVERITIES = ["high", "medium", "low"];
+var VALID_CATEGORIES = ["sexual", "insult", "slur", "general"];
+var MAX_SUFFIXES = 100;
+var SUFFIX_PATTERN = /^[a-z]{1,10}$/;
+function validateDictionary(data) {
+  if (data == null || typeof data !== "object") {
+    throw new Error("Dictionary data must be a non-null object");
+  }
+  const d = data;
+  if (typeof d.version !== "number" || d.version < 1) {
+    throw new Error("Dictionary version must be a positive number");
+  }
+  if (!Array.isArray(d.suffixes)) {
+    throw new Error("Dictionary suffixes must be an array");
+  }
+  if (d.suffixes.length > MAX_SUFFIXES) {
+    throw new Error(`Dictionary suffixes exceed maximum of ${MAX_SUFFIXES}`);
+  }
+  for (const suffix of d.suffixes) {
+    if (typeof suffix !== "string" || !SUFFIX_PATTERN.test(suffix)) {
+      throw new Error(
+        `Invalid suffix "${suffix}": must be 1-10 lowercase letters [a-z]`
+      );
+    }
+  }
+  if (!Array.isArray(d.entries)) {
+    throw new Error("Dictionary entries must be an array");
+  }
+  const seenRoots = /* @__PURE__ */ new Set();
+  for (let i = 0; i < d.entries.length; i++) {
+    const entry = d.entries[i];
+    const label = `entries[${i}]`;
+    if (entry == null || typeof entry !== "object") {
+      throw new Error(`${label}: must be an object`);
+    }
+    if (typeof entry.root !== "string" || entry.root.length === 0) {
+      throw new Error(`${label}: root must be a non-empty string`);
+    }
+    const rootLower = entry.root.toLowerCase();
+    if (seenRoots.has(rootLower)) {
+      throw new Error(`${label}: duplicate root "${entry.root}"`);
+    }
+    seenRoots.add(rootLower);
+    if (!Array.isArray(entry.variants)) {
+      throw new Error(`${label} (root="${entry.root}"): variants must be an array`);
+    }
+    if (typeof entry.severity !== "string" || !VALID_SEVERITIES.includes(entry.severity)) {
+      throw new Error(
+        `${label} (root="${entry.root}"): severity must be one of ${VALID_SEVERITIES.join(", ")}`
+      );
+    }
+    if (typeof entry.category !== "string" || !VALID_CATEGORIES.includes(entry.category)) {
+      throw new Error(
+        `${label} (root="${entry.root}"): category must be one of ${VALID_CATEGORIES.join(", ")}`
+      );
+    }
+    if (typeof entry.suffixable !== "boolean") {
+      throw new Error(`${label} (root="${entry.root}"): suffixable must be a boolean`);
+    }
+  }
+  if (!Array.isArray(d.whitelist)) {
+    throw new Error("Dictionary whitelist must be an array");
+  }
+  const seenWhitelist = /* @__PURE__ */ new Set();
+  for (let i = 0; i < d.whitelist.length; i++) {
+    if (typeof d.whitelist[i] !== "string") {
+      throw new Error(`whitelist[${i}]: must be a string`);
+    }
+    if (d.whitelist[i].length === 0) {
+      throw new Error(`whitelist[${i}]: must not be empty`);
+    }
+    const wlLower = d.whitelist[i].toLowerCase();
+    if (seenWhitelist.has(wlLower)) {
+      throw new Error(`whitelist[${i}]: duplicate entry "${d.whitelist[i]}"`);
+    }
+    seenWhitelist.add(wlLower);
+  }
+  return data;
+}
+
+// src/lang/tr/config.ts
+var validatedData = validateDictionary(dictionary_default);
+var config = {
+  locale: "tr",
+  charMap: {
+    \u00E7: "c",
+    \u00C7: "c",
+    \u011F: "g",
+    \u011E: "g",
+    \u0131: "i",
+    \u0130: "i",
+    \u00F6: "o",
+    \u00D6: "o",
+    \u015F: "s",
+    \u015E: "s",
+    \u00FC: "u",
+    \u00DC: "u"
+  },
+  leetMap: {
+    "0": "o",
+    "1": "i",
+    "2": "i",
+    "3": "e",
+    "4": "a",
+    "5": "s",
+    "6": "g",
+    "7": "t",
+    "8": "b",
+    "9": "g",
+    "@": "a",
+    $: "s",
+    "!": "i"
+  },
+  charClasses: {
+    a: "[a4\xE0\xE1\xE2\xE3\xE4\xE5]",
+    b: "[b8\xDF]",
+    c: "[c\xE7\xC7]",
+    d: "[d]",
+    e: "[e3\xE8\xE9\xEA\xEB]",
+    f: "[f]",
+    g: "[g\u011F\u011E69]",
+    h: "[h]",
+    i: "[i\u0131\u013012\xEC\xED\xEE\xEF]",
+    j: "[j]",
+    k: "[k]",
+    l: "[l1]",
+    m: "[m]",
+    n: "[n\xF1]",
+    o: "[o0\xF6\xD6\xF2\xF3\xF4\xF5]",
+    p: "[p]",
+    q: "[qk]",
+    r: "[r]",
+    s: "[s5\u015F\u015E\xDF]",
+    t: "[t7]",
+    u: "[u\xFC\xDC\xF9\xFA\xFBv]",
+    v: "[vu]",
+    w: "[w]",
+    x: "[x]",
+    y: "[y]",
+    z: "[z2]"
+  },
+  numberExpansions: [
+    ["100", "yuz"],
+    ["50", "elli"],
+    ["10", "on"],
+    ["2", "iki"]
+  ],
+  dictionary: validatedData
+};
+
+// src/lang/en/dictionary.json
+var dictionary_default2 = {
+  version: 1,
+  suffixes: ["ing", "ed", "er", "ers", "s", "es", "ly", "ness"],
+  entries: [
+    {
+      root: "fuck",
+      variants: ["fucking", "fucker", "fucked", "fuckers", "fucks", "fck", "fuk", "fuking", "fcking", "stfu", "motherfucker", "motherfucking", "fuckface", "fuckwit", "clusterfuck", "mindfuck"],
+      severity: "high",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "shit",
+      variants: ["shitty", "bullshit", "shitting", "sht", "shits", "shite", "shithead", "shitstorm", "dipshit", "horseshit", "batshit", "apeshit", "shithole", "shitface", "shitshow"],
+      severity: "high",
+      category: "general",
+      suffixable: true
+    },
+    {
+      root: "ass",
+      variants: ["asses", "arse", "arses", "asshat", "asswipe", "smartass", "dumbass", "fatass", "badass", "jackass", "lardass", "kickass"],
+      severity: "medium",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "asshole",
+      variants: ["assholes", "arsehole", "arseholes"],
+      severity: "high",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "bitch",
+      variants: ["bitches", "bitchy", "biatch", "bitching", "bitchass", "sonofabitch"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "bastard",
+      variants: ["bastards", "bastardy"],
+      severity: "medium",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "dick",
+      variants: ["dickhead", "dickheads", "dicks", "dickwad", "dickweed"],
+      severity: "medium",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "cock",
+      variants: ["cocks", "cocksucker", "cocksucking", "cockhead"],
+      severity: "high",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "cunt",
+      variants: ["cunts", "cunty"],
+      severity: "high",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "whore",
+      variants: ["whores", "whorish", "whorebag"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "slut",
+      variants: ["sluts", "slutty", "slutbag"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "piss",
+      variants: ["pissed", "pissing", "pisser", "pissoff", "pisshead"],
+      severity: "medium",
+      category: "general",
+      suffixable: true
+    },
+    {
+      root: "wank",
+      variants: ["wanker", "wankers", "wanking"],
+      severity: "medium",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "twat",
+      variants: ["twats"],
+      severity: "high",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "bollocks",
+      variants: ["bollock", "bollocked"],
+      severity: "medium",
+      category: "general",
+      suffixable: false
+    },
+    {
+      root: "crap",
+      variants: ["crappy", "craps"],
+      severity: "low",
+      category: "general",
+      suffixable: true
+    },
+    {
+      root: "damn",
+      variants: ["damned", "damnit", "dammit", "goddamn", "goddamnit"],
+      severity: "low",
+      category: "general",
+      suffixable: false
+    },
+    {
+      root: "retard",
+      variants: ["retards", "retarded", "retardation"],
+      severity: "high",
+      category: "slur",
+      suffixable: false
+    },
+    {
+      root: "nigger",
+      variants: ["niggers", "nigga", "niggas", "nigg3r"],
+      severity: "high",
+      category: "slur",
+      suffixable: false
+    },
+    {
+      root: "faggot",
+      variants: ["faggots", "fag", "fags", "faggy"],
+      severity: "high",
+      category: "slur",
+      suffixable: false
+    },
+    {
+      root: "douche",
+      variants: ["douchebag", "douchebags", "douchy", "douchey"],
+      severity: "medium",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "tosser",
+      variants: ["tossers"],
+      severity: "medium",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "wanker",
+      variants: ["wankers"],
+      severity: "medium",
+      category: "insult",
+      suffixable: false
+    }
+  ],
+  whitelist: [
+    "assembly",
+    "assist",
+    "assassin",
+    "bass",
+    "class",
+    "classic",
+    "classify",
+    "grass",
+    "mass",
+    "massive",
+    "pass",
+    "passage",
+    "passenger",
+    "passion",
+    "passive",
+    "passport",
+    "assume",
+    "assignment",
+    "associate",
+    "assertion",
+    "asset",
+    "assess",
+    "dickens",
+    "cocktail",
+    "cockatoo",
+    "peacock",
+    "hancock",
+    "scrap",
+    "scrappy",
+    "shitake",
+    "document",
+    "buckle",
+    "piston",
+    "bassist",
+    "embassy",
+    "cassette",
+    "hassle",
+    "lasso",
+    "massage",
+    "compass",
+    "trespass",
+    "harass"
+  ]
+};
+
+// src/lang/en/config.ts
+var validatedData2 = validateDictionary(dictionary_default2);
+var config2 = {
+  locale: "en",
+  charMap: {},
+  leetMap: {
+    "0": "o",
+    "1": "i",
+    "3": "e",
+    "4": "a",
+    "5": "s",
+    "7": "t",
+    "@": "a",
+    $: "s",
+    "!": "i"
+  },
+  charClasses: {
+    a: "[a4]",
+    b: "[b8]",
+    c: "[c]",
+    d: "[d]",
+    e: "[e3]",
+    f: "[f]",
+    g: "[g9]",
+    h: "[h]",
+    i: "[i1]",
+    j: "[j]",
+    k: "[k]",
+    l: "[l1]",
+    m: "[m]",
+    n: "[n]",
+    o: "[o0]",
+    p: "[p]",
+    q: "[q]",
+    r: "[r]",
+    s: "[s5]",
+    t: "[t7]",
+    u: "[uv]",
+    v: "[vu]",
+    w: "[w]",
+    x: "[x]",
+    y: "[y]",
+    z: "[z]"
+  },
+  dictionary: validatedData2
+};
+
+// src/lang/es/dictionary.json
+var dictionary_default3 = {
+  version: 1,
+  suffixes: ["ado", "ando", "ido", "iendo", "ar", "er", "ir", "os", "as", "es", "ito", "ita", "azo"],
+  entries: [
+    {
+      root: "mierda",
+      variants: ["mierdas", "mierdo", "mierdero", "mierdoso"],
+      severity: "high",
+      category: "general",
+      suffixable: true
+    },
+    {
+      root: "puta",
+      variants: ["putas", "putada", "puto", "putos", "hijoputa", "hijaputa", "putero", "puton", "putear"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "cabron",
+      variants: ["cabrones", "cabrona", "cabronazo", "cabronada"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "joder",
+      variants: ["jodido", "jodida", "jodidos", "jodidas", "joderse", "jodiendo"],
+      severity: "high",
+      category: "general",
+      suffixable: true
+    },
+    {
+      root: "co\xF1o",
+      variants: ["cono", "conos", "co\xF1os"],
+      severity: "high",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "verga",
+      variants: ["vergas", "vergon", "vergudo", "vergota"],
+      severity: "high",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "chingar",
+      variants: ["chingado", "chingada", "chingados", "chinga", "chingas", "chingo", "chingon", "chingona", "chingadera"],
+      severity: "high",
+      category: "general",
+      suffixable: true
+    },
+    {
+      root: "pendejo",
+      variants: ["pendejos", "pendeja", "pendejas", "pendejada", "pendejear"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "marica",
+      variants: ["maricas", "maricon", "maricones", "maricona"],
+      severity: "high",
+      category: "slur",
+      suffixable: false
+    },
+    {
+      root: "carajo",
+      variants: ["carajos"],
+      severity: "medium",
+      category: "general",
+      suffixable: false
+    },
+    {
+      root: "idiota",
+      variants: ["idiotas", "idiotez"],
+      severity: "low",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "culo",
+      variants: ["culos", "culazo", "culear"],
+      severity: "medium",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "zorra",
+      variants: ["zorras", "zorron"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "estupido",
+      variants: ["estupidos", "estupida", "estupidas", "estupidez"],
+      severity: "low",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "imbecil",
+      variants: ["imbeciles"],
+      severity: "low",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "gilipollas",
+      variants: ["gilipolleces", "gilipollez"],
+      severity: "high",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "huevon",
+      variants: ["huevones", "huevona", "huevonazo", "guevon"],
+      severity: "medium",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "mamada",
+      variants: ["mamadas", "mamazo", "mamon", "mamona", "mamones"],
+      severity: "medium",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "pinche",
+      variants: ["pinches"],
+      severity: "medium",
+      category: "general",
+      suffixable: false
+    }
+  ],
+  whitelist: [
+    "putamen",
+    "computadora",
+    "computar",
+    "disputar",
+    "disputa",
+    "reputacion",
+    "imputar",
+    "inocular",
+    "acular",
+    "calcular",
+    "icular",
+    "vehicular",
+    "particular",
+    "articulo",
+    "maricopa"
+  ]
+};
+
+// src/lang/es/config.ts
+var validatedData3 = validateDictionary(dictionary_default3);
+var config3 = {
+  locale: "es",
+  charMap: {
+    \u00F1: "n",
+    \u00D1: "n",
+    \u00E1: "a",
+    \u00C1: "a",
+    \u00E9: "e",
+    \u00C9: "e",
+    \u00ED: "i",
+    \u00CD: "i",
+    \u00F3: "o",
+    \u00D3: "o",
+    \u00FA: "u",
+    \u00DA: "u"
+  },
+  leetMap: {
+    "0": "o",
+    "1": "i",
+    "3": "e",
+    "4": "a",
+    "5": "s",
+    "7": "t",
+    "@": "a",
+    $: "s",
+    "!": "i"
+  },
+  charClasses: {
+    a: "[a4\xE1\xC1]",
+    b: "[b8]",
+    c: "[c]",
+    d: "[d]",
+    e: "[e3\xE9\xC9]",
+    f: "[f]",
+    g: "[g9]",
+    h: "[h]",
+    i: "[i1\xED\xCD]",
+    j: "[j]",
+    k: "[k]",
+    l: "[l1]",
+    m: "[m]",
+    n: "[n\xF1\xD1]",
+    o: "[o0\xF3\xD3]",
+    p: "[p]",
+    q: "[q]",
+    r: "[r]",
+    s: "[s5]",
+    t: "[t7]",
+    u: "[uv\xFA\xDA]",
+    v: "[vu]",
+    w: "[w]",
+    x: "[x]",
+    y: "[y]",
+    z: "[z]"
+  },
+  dictionary: validatedData3
+};
+
+// src/lang/de/dictionary.json
+var dictionary_default4 = {
+  version: 1,
+  suffixes: ["en", "er", "es", "em", "ung", "e", "te", "st"],
+  entries: [
+    {
+      root: "schei\xDFe",
+      variants: ["scheisse", "scheiss", "scheisser", "scheisserei", "beschissen"],
+      severity: "high",
+      category: "general",
+      suffixable: true
+    },
+    {
+      root: "fick",
+      variants: ["ficken", "ficker", "gefickt", "fickend", "fickerei", "abgefickt"],
+      severity: "high",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "arsch",
+      variants: ["arschloch", "arscher", "arschgeige", "arschgesicht", "arschkriecher"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "hurensohn",
+      variants: ["hurensohne", "hurens\xF6hne"],
+      severity: "high",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "hure",
+      variants: ["huren", "hurig"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "fotze",
+      variants: ["fotzen"],
+      severity: "high",
+      category: "sexual",
+      suffixable: true
+    },
+    {
+      root: "wichser",
+      variants: ["wichsern", "wichse", "wichsen", "gewichst"],
+      severity: "high",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "schwanz",
+      variants: ["schw\xE4nze", "schwanze"],
+      severity: "medium",
+      category: "sexual",
+      suffixable: false
+    },
+    {
+      root: "schlampe",
+      variants: ["schlampen", "schlampig"],
+      severity: "high",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "mistkerl",
+      variants: ["mistkerle"],
+      severity: "medium",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "idiot",
+      variants: ["idioten", "idiotin", "idiotisch"],
+      severity: "low",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "dumm",
+      variants: ["dummkopf", "dumme", "dummer", "dummes", "dummheit"],
+      severity: "low",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "depp",
+      variants: ["deppen", "deppert"],
+      severity: "low",
+      category: "insult",
+      suffixable: true
+    },
+    {
+      root: "vollidiot",
+      variants: ["vollidioten"],
+      severity: "medium",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "missgeburt",
+      variants: ["missgeburten"],
+      severity: "high",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "drecksau",
+      variants: ["drecks\xE4ue"],
+      severity: "high",
+      category: "insult",
+      suffixable: false
+    },
+    {
+      root: "dreck",
+      variants: ["dreckig", "dreckiger", "dreckiges"],
+      severity: "medium",
+      category: "general",
+      suffixable: true
+    },
+    {
+      root: "trottel",
+      variants: ["trotteln", "trottelig"],
+      severity: "low",
+      category: "insult",
+      suffixable: false
+    }
+  ],
+  whitelist: [
+    "ficktion",
+    "arschen",
+    "schwanzen"
+  ]
+};
+
+// src/lang/de/config.ts
+var validatedData4 = validateDictionary(dictionary_default4);
+var config4 = {
+  locale: "de",
+  charMap: {
+    \u00E4: "a",
+    \u00C4: "a",
+    \u00F6: "o",
+    \u00D6: "o",
+    \u00FC: "u",
+    \u00DC: "u",
+    \u00DF: "ss"
+  },
+  leetMap: {
+    "0": "o",
+    "1": "i",
+    "3": "e",
+    "4": "a",
+    "5": "s",
+    "7": "t",
+    "@": "a",
+    $: "s",
+    "!": "i"
+  },
+  charClasses: {
+    a: "[a4\xE4\xC4]",
+    b: "[b8]",
+    c: "[c]",
+    d: "[d]",
+    e: "[e3]",
+    f: "[f]",
+    g: "[g9]",
+    h: "[h]",
+    i: "[i1]",
+    j: "[j]",
+    k: "[k]",
+    l: "[l1]",
+    m: "[m]",
+    n: "[n]",
+    o: "[o0\xF6\xD6]",
+    p: "[p]",
+    q: "[q]",
+    r: "[r]",
+    s: "[s5\xDF]",
+    t: "[t7]",
+    u: "[uv\xFC\xDC]",
+    v: "[vu]",
+    w: "[w]",
+    x: "[x]",
+    y: "[y]",
+    z: "[z]"
+  },
+  dictionary: validatedData4
+};
+
+// src/lang/index.ts
+var CORE_DICT_VERSION = 1;
+var REGISTRY = {
+  tr: config,
+  en: config2,
+  es: config3,
+  de: config4
+};
+function getLanguageConfig(lang) {
+  const config5 = REGISTRY[lang];
+  if (!config5) {
+    const available = getSupportedLanguages().join(", ");
+    throw new Error(
+      `Unsupported language: "${lang}". Available languages: ${available}`
+    );
+  }
+  if (config5.dictionary.version < CORE_DICT_VERSION) {
+    throw new Error(
+      `Dictionary version ${config5.dictionary.version} for language "${lang}" is below minimum required version ${CORE_DICT_VERSION}. Please update the language pack.`
+    );
+  }
+  return config5;
+}
+function getSupportedLanguages() {
+  return Object.keys(REGISTRY);
+}
+
+// src/normalizer.ts
+function replaceFromMap(text, map) {
+  let result = "";
+  for (const ch of text) {
+    result += map[ch] ?? ch;
+  }
+  return result;
+}
+function buildNumberExpander(expansions) {
+  if (expansions.length === 0) return null;
+  const regex = new RegExp(
+    expansions.map(([num]) => {
+      const escaped = num.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      return `(?<=\\p{L})${escaped}(?=\\p{L})`;
+    }).join("|"),
+    "gu"
+  );
+  const lookup = Object.fromEntries(expansions);
+  return (text) => text.replace(regex, (match) => lookup[match] ?? match);
+}
+function removePunctuation(text) {
+  return text.replace(/(?<=\p{L})[.\-_*,;:!?]+(?=\p{L})/gu, "");
+}
+function collapseRepeats(text) {
+  return text.replace(/(.)\1{2,}/g, "$1");
+}
+function trimWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function createNormalizer(config5) {
+  const expandNumbers = config5.numberExpansions ? buildNumberExpander(config5.numberExpansions) : null;
+  return function normalize2(text) {
+    let result = text;
+    result = result.toLocaleLowerCase(config5.locale);
+    result = replaceFromMap(result, config5.charMap);
+    if (expandNumbers) {
+      result = expandNumbers(result);
+    }
+    result = replaceFromMap(result, config5.leetMap);
+    result = removePunctuation(result);
+    result = collapseRepeats(result);
+    result = trimWhitespace(result);
+    return result;
+  };
+}
+var TURKISH_CHAR_MAP = {
+  \u00E7: "c",
+  \u00C7: "c",
+  \u011F: "g",
+  \u011E: "g",
+  \u0131: "i",
+  \u0130: "i",
+  \u00F6: "o",
+  \u00D6: "o",
+  \u015F: "s",
+  \u015E: "s",
+  \u00FC: "u",
+  \u00DC: "u"
+};
+var LEET_MAP = {
+  "0": "o",
+  "1": "i",
+  "2": "i",
+  "3": "e",
+  "4": "a",
+  "5": "s",
+  "6": "g",
+  "7": "t",
+  "8": "b",
+  "9": "g",
+  "@": "a",
+  $: "s",
+  "!": "i"
+};
+var TR_NUMBER_MAP = [
+  ["100", "yuz"],
+  ["50", "elli"],
+  ["10", "on"],
+  ["2", "iki"]
+];
+var _turkishNormalize = createNormalizer({
+  locale: "tr",
+  charMap: TURKISH_CHAR_MAP,
+  leetMap: LEET_MAP,
+  numberExpansions: TR_NUMBER_MAP
+});
+function normalize(text) {
+  return _turkishNormalize(text);
+}
+
+// src/terlik.ts
+var Terlik = class _Terlik {
+  dictionary;
+  detector;
+  mode;
+  maskStyle;
+  enableFuzzy;
+  fuzzyThreshold;
+  fuzzyAlgorithm;
+  maxLength;
+  replaceMask;
+  /** The language code this instance was created with. */
+  language;
+  /**
+   * Creates a new Terlik instance.
+   * @param options - Configuration options.
+   * @throws {Error} If the specified language is not supported.
+   */
+  constructor(options) {
+    this.language = options?.language ?? "tr";
+    this.mode = options?.mode ?? "balanced";
+    this.maskStyle = options?.maskStyle ?? "stars";
+    this.enableFuzzy = options?.enableFuzzy ?? false;
+    this.fuzzyAlgorithm = options?.fuzzyAlgorithm ?? "levenshtein";
+    this.replaceMask = options?.replaceMask ?? "[***]";
+    const threshold = options?.fuzzyThreshold ?? 0.8;
+    if (threshold < 0 || threshold > 1) {
+      throw new Error(`fuzzyThreshold must be between 0 and 1, got ${threshold}`);
+    }
+    this.fuzzyThreshold = threshold;
+    const maxLen = options?.maxLength ?? MAX_INPUT_LENGTH;
+    if (maxLen < 1) {
+      throw new Error(`maxLength must be at least 1, got ${maxLen}`);
+    }
+    this.maxLength = maxLen;
+    const langConfig = getLanguageConfig(this.language);
+    const normalizeFn = createNormalizer({
+      locale: langConfig.locale,
+      charMap: langConfig.charMap,
+      leetMap: langConfig.leetMap,
+      numberExpansions: langConfig.numberExpansions
+    });
+    this.dictionary = new Dictionary(
+      langConfig.dictionary,
+      options?.customList,
+      options?.whitelist
+    );
+    this.detector = new Detector(
+      this.dictionary,
+      normalizeFn,
+      langConfig.locale,
+      langConfig.charClasses
+    );
+    if (options?.backgroundWarmup) {
+      setTimeout(() => {
+        this.detector.compile();
+        this.containsProfanity("warmup");
+      }, 0);
+    }
+  }
+  /**
+   * Creates and JIT-warms instances for multiple languages at once.
+   * Useful for server deployments to eliminate cold-start latency.
+   *
+   * @param languages - Language codes to warm up (e.g. `["tr", "en"]`).
+   * @param baseOptions - Shared options applied to all instances.
+   * @returns A map of language code to warmed-up Terlik instance.
+   *
+   * @example
+   * ```ts
+   * const cache = Terlik.warmup(["tr", "en", "es"]);
+   * cache.get("en")!.containsProfanity("fuck"); // true, no cold start
+   * ```
+   */
+  static warmup(languages, baseOptions) {
+    const map = /* @__PURE__ */ new Map();
+    for (const lang of languages) {
+      const instance = new _Terlik({ ...baseOptions, language: lang });
+      instance.containsProfanity("warmup");
+      map.set(lang, instance);
+    }
+    return map;
+  }
+  /**
+   * Checks whether the text contains profanity.
+   * @param text - The text to check.
+   * @param options - Per-call detection options (overrides instance defaults).
+   * @returns `true` if profanity is detected, `false` otherwise.
+   */
+  containsProfanity(text, options) {
+    const input = validateInput(text, this.maxLength);
+    if (input.length === 0) return false;
+    const matches = this.detector.detect(input, this.mergeDetectOptions(options));
+    return matches.length > 0;
+  }
+  /**
+   * Returns all profanity matches with details (word, root, index, severity, method).
+   * @param text - The text to analyze.
+   * @param options - Per-call detection options (overrides instance defaults).
+   * @returns Array of match results, sorted by index.
+   */
+  getMatches(text, options) {
+    const input = validateInput(text, this.maxLength);
+    if (input.length === 0) return [];
+    return this.detector.detect(input, this.mergeDetectOptions(options));
+  }
+  /**
+   * Returns the text with detected profanity masked.
+   * @param text - The text to clean.
+   * @param options - Per-call clean options (overrides instance defaults).
+   * @returns The cleaned text with profanity replaced by mask characters.
+   */
+  clean(text, options) {
+    const input = validateInput(text, this.maxLength);
+    if (input.length === 0) return input;
+    const matches = this.detector.detect(input, this.mergeDetectOptions(options));
+    const style = options?.maskStyle ?? this.maskStyle;
+    const replaceMask = options?.replaceMask ?? this.replaceMask;
+    return cleanText(input, matches, style, replaceMask);
+  }
+  /**
+   * Adds custom words to the detection dictionary at runtime.
+   * Triggers pattern recompilation.
+   * @param words - Words to add.
+   */
+  addWords(words) {
+    this.dictionary.addWords(words);
+    this.detector.recompile();
+  }
+  /**
+   * Removes words from the detection dictionary at runtime.
+   * Triggers pattern recompilation.
+   * @param words - Words to remove.
+   */
+  removeWords(words) {
+    this.dictionary.removeWords(words);
+    this.detector.recompile();
+  }
+  /**
+   * Returns the compiled regex patterns keyed by root word.
+   * Useful for debugging or advanced usage.
+   * @returns Map of root word to compiled RegExp.
+   */
+  getPatterns() {
+    return this.detector.getPatterns();
+  }
+  mergeDetectOptions(options) {
+    return {
+      mode: options?.mode ?? this.mode,
+      enableFuzzy: options?.enableFuzzy ?? this.enableFuzzy,
+      fuzzyThreshold: options?.fuzzyThreshold ?? this.fuzzyThreshold,
+      fuzzyAlgorithm: options?.fuzzyAlgorithm ?? this.fuzzyAlgorithm
+    };
+  }
+};
+export {
+  Terlik,
+  createNormalizer,
+  diceSimilarity,
+  getLanguageConfig,
+  getSupportedLanguages,
+  levenshteinDistance,
+  levenshteinSimilarity,
+  normalize
+};