@sideid/id-profanity-filter 1.10.6 → 1.11.0

package/dist/index.esm.js

@@ -214,7 +214,7 @@ const jawa = [
         word: "jancok",
         category: "sexual",
         region: "jawa",
-        severity: 0.8,
+        severity: 0.9,
         aliases: ["jancuk", "jncok", "jancuk", "jncuk", "dancok", "dancuk"],
         description: "Kata umpatan kasar dalam Bahasa Jawa",
         context: "Umpatan kasar yang umum digunakan di Jawa Timur",
@@ -250,7 +250,7 @@ const jawa = [
         word: "mbokne ancok",
         category: "insult",
         region: "jawa",
-        severity: 0.8,
+        severity: 0.9,
         aliases: ["mbokne", "mbokneancok"],
         description: "Umpatan yang menyinggung ibu seseorang",
         context: "Umpatan kasar yang menyinggung orangtua orang lain",
@@ -259,7 +259,7 @@ const jawa = [
         word: "pekok",
         category: "insult",
         region: "jawa",
-        severity: 0.6,
+        severity: 0.7,
         aliases: ["pekak", "pekilk"],
         description: "Kata hinaan yang menunjukkan kebodohan",
         context: "Hinaan untuk menyebut orang yang dianggap sangat bodoh",
@@ -291,6 +291,248 @@ const jawa = [
         description: "Secara harfiah berarti kepalamu, digunakan sebagai umpatan ringan",
         context: "Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar",
     },
+    {
+        word: "kontol",
+        category: "sexual",
+        region: "jawa",
+        severity: 0.8,
+        aliases: ["kntl", "kontl"],
+        description: "Mengacu ke alat kelamin laki-laki",
+        context: "Kata vulgar yang sering digunakan sebagai umpatan kasar",
+    },
+    {
+        word: "tempek",
+        category: "sexual",
+        region: "jawa",
+        severity: 0.8,
+        aliases: ["mpek", "torok", "tempk"],
+        description: "Mengacu pada alat kelamin perempuan",
+        context: "Kata vulgar yang digunakan sebagai umpatan atau hinaan",
+    },
+    {
+        word: "silit",
+        category: "insult",
+        region: "jawa",
+        severity: 0.6,
+        aliases: ["selet", "tilis"],
+        description: "Mengacu pada bagian dubur atau anus",
+        context: "Kata kasar yang digunakan sebagai hinaan",
+    },
+    {
+        word: "mbahmu",
+        category: "insult",
+        region: "jawa",
+        severity: 0.6,
+        aliases: ["mbahmu kiper", "mbah mu"],
+        description: "Hinaan yang menyinggung nenek/kakek seseorang",
+        context: "Umpatan ringan untuk menanggapi sesuatu yang tidak masuk akal",
+    },
+    {
+        word: "makmu",
+        category: "insult",
+        region: "jawa",
+        severity: 0.7,
+        aliases: ["mak mu", "mamamu"],
+        description: "Hinaan yang menyinggung ibu seseorang",
+        context: "Umpatan yang dianggap kasar karena menyinggung orang tua",
+    },
+    {
+        word: "bajingan",
+        category: "insult",
+        region: "jawa",
+        severity: 0.7,
+        aliases: [
+            "bajilak",
+            "bajhingan",
+            "bajingak",
+            "bajingseng",
+            "bajindul",
+            "bajigur",
+            "jingan",
+        ],
+        description: "Sebutan untuk orang yang dianggap jahat atau tidak bermoral",
+        context: "Umpatan untuk mengekspresikan kemarahan atau kekesalan",
+    },
+    {
+        word: "cocote",
+        category: "insult",
+        region: "jawa",
+        severity: 0.6,
+        aliases: ["cocot", "bacot", "nyocot"],
+        description: "Mengacu pada mulut dengan konotasi negatif",
+        context: "Umpatan untuk menyuruh seseorang berhenti berbicara",
+    },
+    {
+        word: "ngentot",
+        category: "sexual",
+        region: "jawa",
+        severity: 0.9,
+        aliases: ["kentu", "kentot", "iclik", "ngtt", "iclk"],
+        description: "Mengacu pada aktivitas seksual",
+        context: "Kata vulgar yang digunakan sebagai umpatan kasar",
+    },
+    {
+        word: "edan",
+        category: "insult",
+        region: "jawa",
+        severity: 0.5,
+        aliases: ["gendeng", "gila", "gendheng", "sarap"],
+        description: "Secara harfiah berarti gila atau tidak waras",
+        context: "Umpatan untuk menyebut seseorang yang dianggap tidak masuk akal",
+    },
+    {
+        word: "dapuranmu",
+        category: "insult",
+        region: "jawa",
+        severity: 0.6,
+        aliases: ["raimu", "rai mu"],
+        description: "Secara harfiah mengacu pada wajah atau rupa seseorang",
+        context: "Umpatan untuk menghina penampilan atau wajah seseorang",
+    },
+    {
+        word: "damput",
+        category: "insult",
+        region: "jawa",
+        severity: 0.7,
+        aliases: ["diamput"],
+        description: "Variasi bentuk umpatan dengan makna serupa dengan jancok",
+        context: "Umpatan kasar untuk mengekspresikan kemarahan",
+    },
+    {
+        word: "mbathang",
+        category: "insult",
+        region: "jawa",
+        severity: 0.7,
+        aliases: ["mbatang"],
+        description: "Secara harfiah berarti bangkai",
+        context: "Umpatan kasar untuk menghina seseorang",
+    },
+    {
+        word: "ndlogok",
+        category: "insult",
+        region: "jawa",
+        severity: 0.6,
+        aliases: ["ndelodok", "ndlodok"],
+        description: "Mengacu pada tindakan yang dianggap bodoh atau tidak masuk akal",
+        context: "Hinaan untuk mengkritik tindakan seseorang",
+    },
+    {
+        word: "nggateli",
+        category: "insult",
+        region: "jawa",
+        severity: 0.5,
+        aliases: ["gateli", "gathel"],
+        description: "Secara harfiah berarti gatal atau menyebalkan",
+        context: "Ungkapan untuk menunjukkan kekesalan terhadap perilaku seseorang",
+    },
+    {
+        word: "perek",
+        category: "sexual",
+        region: "jawa",
+        severity: 0.8,
+        aliases: ["lonthe", "pelacur"],
+        description: "Istilah merendahkan untuk pekerja seks komersial",
+        context: "Kata kasar untuk menghina wanita",
+    },
+    {
+        word: "picek",
+        category: "insult",
+        region: "jawa",
+        severity: 0.6,
+        aliases: ["pcek", "buta"],
+        description: "Secara harfiah berarti buta atau tidak bisa melihat",
+        context: "Hinaan untuk orang yang dianggap tidak bisa melihat kenyataan",
+    },
+    {
+        word: "untumu",
+        category: "insult",
+        region: "jawa",
+        severity: 0.5,
+        aliases: ["gigimu", "untu mu"],
+        description: "Secara harfiah berarti gigimu",
+        context: "Umpatan ringan untuk menanggapi sesuatu yang tidak disetujui",
+    },
+    {
+        word: "goblog",
+        category: "insult",
+        region: "jawa",
+        severity: 0.7,
+        aliases: ["ghoblog", "goblok", "gobhlok", "pekok"],
+        description: "Kata hinaan yang menunjukkan kebodohan ekstrem",
+        context: "Hinaan untuk menyebut seseorang yang dianggap sangat bodoh",
+    },
+    {
+        word: "tolol",
+        category: "insult",
+        region: "jawa",
+        severity: 0.7,
+        aliases: ["tholol", "tlol"],
+        description: "Kata hinaan yang menunjukkan kebodohan",
+        context: "Hinaan untuk menyebut seseorang yang dianggap bodoh",
+    },
+    {
+        word: "budheg",
+        category: "insult",
+        region: "jawa",
+        severity: 0.6,
+        aliases: ["budeg", "bdeg"],
+        description: "Secara harfiah berarti tuli atau tidak bisa mendengar",
+        context: "Hinaan untuk orang yang dianggap tidak mau mendengarkan",
+    },
+    {
+        word: "jiangkrik",
+        category: "insult",
+        region: "jawa",
+        severity: 0.4,
+        aliases: ["jiangkrek", "jangkrik"],
+        description: "Secara harfiah berarti jangkrik, digunakan sebagai eufemisme",
+        context: "Umpatan ringan sebagai pengganti kata kasar yang lebih vulgar",
+    },
+    {
+        word: "diamput",
+        category: "insult",
+        region: "jawa",
+        severity: 0.8,
+        aliases: ["damput", "djamput"],
+        description: "Bentuk umpatan kasar dengan makna serupa jancok",
+        context: "Kata kasar untuk mengekspresikan kemarahan",
+    },
+    {
+        word: "celeng",
+        category: "insult",
+        region: "jawa",
+        severity: 0.6,
+        aliases: ["cleng", "babi hutan"],
+        description: "Secara harfiah berarti babi hutan",
+        context: "Hinaan untuk orang yang dianggap jorok atau rakus",
+    },
+    {
+        word: "kampret",
+        category: "insult",
+        region: "jawa",
+        severity: 0.5,
+        aliases: ["kmpret", "kmprt"],
+        description: "Secara harfiah berarti kelelawar kecil",
+        context: "Umpatan ringan untuk mengekspresikan kekesalan",
+    },
+    {
+        word: "ndeso",
+        category: "insult",
+        region: "jawa",
+        severity: 0.4,
+        aliases: ["ndesa", "deso"],
+        description: "Secara harfiah berarti dari desa atau kampungan",
+        context: "Hinaan untuk orang yang dianggap kurang modern atau berpendidikan",
+    },
+    {
+        word: "kere",
+        category: "insult",
+        region: "jawa",
+        severity: 0.5,
+        aliases: ["miskin", "mlarat"],
+        description: "Secara harfiah berarti miskin atau tidak punya uang",
+        context: "Hinaan untuk status ekonomi seseorang yang dianggap rendah",
+    },
     {
         word: "itil",
         category: "sexual",
@@ -1084,29 +1326,73 @@ function clusterSimilarWords(words, threshold = 0.8) {
 }
 /**
  * Cari kata-kata kotor yang mungkin dari teks menggunakan kesamaan string
+ * dengan optimasi untuk mengurangi kompleksitas
  *
  * @param text Teks yang akan diperiksa
  * @param profanityWords Daftar kata kotor
  * @param threshold Batas minimum kesamaan (default: 0.8)
  * @returns Array kata yang mungkin merupakan kata kotor
  */
+/**
+ * Cari kata-kata kotor yang mungkin dari teks berdasarkan kemiripan string
+ * dengan optimasi biar prosesnya nggak terlalu berat
+ *
+ * @param text Teks yang mau dicek
+ * @param profanityWords Daftar kata-kata kotor/kasar
+ * @param threshold Batas minimal kemiripan (default: 0.8)
+ * @returns Array kata yang kemungkinan kata kotor/kasar
+ */
 function findPossibleProfanityBySimiliarity(text, profanityWords, threshold = 0.8) {
     const result = [];
+    // Optimasi dengan bikin map kata-kata kotor berdasarkan huruf pertama
+    const profanityMap = new Map();
+    // Kelompokkan kata-kata kotor berdasarkan huruf pertama biar pencariannya lebih cepat
+    for (const word of profanityWords) {
+        if (word.length < 1)
+            continue;
+        const firstChar = word[0].toLowerCase();
+        if (!profanityMap.has(firstChar)) {
+            profanityMap.set(firstChar, []);
+        }
+        profanityMap.get(firstChar).push(word);
+    }
     const words = text.toLowerCase().split(/\s+/);
     for (const word of words) {
         if (word.length < 3)
             continue;
-        for (const profanity of profanityWords) {
+        // Cuma bandingin dengan kata-kata kotor yang huruf pertamanya sama
+        // atau yang perbedaan panjangnya masih masuk akal
+        const firstChar = word[0];
+        const candidateWords = profanityMap.get(firstChar) || [];
+        // Cek juga huruf-huruf yang berdekatan (buat antisipasi typo di huruf pertama)
+        // Ini opsional tapi bikin deteksinya lebih bagus
+        const charCode = firstChar.charCodeAt(0);
+        const prevChar = String.fromCharCode(charCode - 1);
+        const nextChar = String.fromCharCode(charCode + 1);
+        const adjacentCandidates = [
+            ...(profanityMap.get(prevChar) || []),
+            ...(profanityMap.get(nextChar) || []),
+        ];
+        // Gabungin kandidat-kandidatnya, prioritasin yang huruf pertamanya sama persis
+        const allCandidates = [...candidateWords, ...adjacentCandidates];
+        // Filter kandidat berdasarkan perbedaan panjang sebelum ngitung kemiripannya
+        const lengthFilteredCandidates = allCandidates.filter((candidate) => Math.abs(candidate.length - word.length) <= 2);
+        // Cari yang paling cocok
+        let bestMatch = null;
+        for (const profanity of lengthFilteredCandidates) {
             const similarity = stringSimilarity(word, profanity);
-            if (similarity >= threshold) {
-                result.push({
+            if (similarity >= threshold &&
+                (!bestMatch || similarity > bestMatch.similarity)) {
+                bestMatch = {
                     word,
                     original: profanity,
                     similarity,
-                });
-                break;
+                };
             }
         }
+        if (bestMatch) {
+            result.push(bestMatch);
+        }
     }
     return result;
 }
@@ -1121,30 +1407,75 @@ function findPossibleProfanityBySimiliarity(text, profanityWords, threshold = 0.
  */
 function findProfanityByLevenshteinDistance(text, profanityWords, threshold = 0.8, maxDistance = 2) {
     const result = [];
+    // map kata-kata kotor dikelompokkan sesuai panjangnya
+    const profanityByLength = new Map();
+    // Kelompokkin kata-kata kotor berdasarkan panjangnya biar pencarian lebih cepat
+    for (const word of profanityWords) {
+        const length = word.length;
+        if (!profanityByLength.has(length)) {
+            profanityByLength.set(length, []);
+        }
+        profanityByLength.get(length).push(word);
+    }
     const words = text.toLowerCase().split(/\s+/);
     for (const word of words) {
         if (word.length < 3)
             continue;
-        for (const profanity of profanityWords) {
-            if (Math.abs(word.length - profanity.length) > maxDistance)
-                continue;
-            const distance = levenshteinDistance(word, profanity);
-            if (distance <= maxDistance) {
-                const similarity = stringSimilarity(word, profanity);
-                if (similarity >= threshold) {
-                    result.push({
-                        word,
-                        original: profanity,
-                        similarity,
-                        distance,
-                    });
-                    break;
+        let bestMatch = null;
+        for (let len = Math.max(3, word.length - maxDistance); len <= word.length + maxDistance; len++) {
+            const candidates = profanityByLength.get(len) || [];
+            for (const profanity of candidates) {
+                if (!isCharacterCountSimilar(word, profanity, maxDistance)) {
+                    continue;
+                }
+                const distance = levenshteinDistance(word, profanity);
+                if (distance <= maxDistance) {
+                    const similarity = 1 - distance / Math.max(word.length, profanity.length);
+                    if (similarity >= threshold &&
+                        (!bestMatch || similarity > bestMatch.similarity)) {
+                        bestMatch = {
+                            word,
+                            original: profanity,
+                            similarity,
+                            distance,
+                        };
+                        if (distance === 0 || similarity > 0.95) {
+                            break;
+                        }
+                    }
                 }
             }
         }
+        if (bestMatch) {
+            result.push(bestMatch);
+        }
     }
     return result;
 }
+/**
+ * Helper function to efficiently check if character counts between two strings
+ * are similar enough to warrant a full Levenshtein calculation
+ */
+function isCharacterCountSimilar(str1, str2, maxDifference) {
+    const charCount1 = {};
+    const charCount2 = {};
+    for (const char of str1) {
+        charCount1[char] = (charCount1[char] || 0) + 1;
+    }
+    for (const char of str2) {
+        charCount2[char] = (charCount2[char] || 0) + 1;
+    }
+    let diffCount = 0;
+    for (const char in charCount1) {
+        diffCount += Math.abs((charCount1[char] || 0) - (charCount2[char] || 0));
+    }
+    for (const char in charCount2) {
+        if (!charCount1[char]) {
+            diffCount += charCount2[char];
+        }
+    }
+    return diffCount <= maxDifference * 2;
+}
 
 const DEFAULT_OPTIONS = {
     replaceWith: "*",
@@ -1299,6 +1630,157 @@ function makeRandomGrawlixString(length) {
     return result;
 }
 
+/**
+ * Implementasi algoritma Aho-Corasick untuk pencocokan string
+ * Algoritma ini memungkinkan pencarian banyak pola dalam satu kali pembacaan teks
+ */
+class AhoCorasick {
+    constructor() {
+        this.built = false;
+        this.root = {
+            children: new Map(),
+            fail: null,
+            output: new Set(),
+            depth: 0,
+        };
+    }
+    /**
+     * Menambahkan pola ke dalam trie
+     * @param pattern Pola yang akan ditambahkan
+     */
+    addPattern(pattern) {
+        if (this.built) {
+            throw new Error("Cannot add patterns after the automaton is built");
+        }
+        let node = this.root;
+        const normalizedPattern = pattern.toLowerCase();
+        for (let i = 0; i < normalizedPattern.length; i++) {
+            const char = normalizedPattern[i];
+            if (!node.children.has(char)) {
+                node.children.set(char, {
+                    children: new Map(),
+                    fail: null,
+                    output: new Set(),
+                    depth: node.depth + 1,
+                    char,
+                });
+            }
+            node = node.children.get(char);
+        }
+        node.output.add(normalizedPattern);
+    }
+    /**
+     * Membangun fungsi failure
+     */
+    build() {
+        if (this.built)
+            return;
+        const queue = [];
+        // Set fail pointer for depth 1 nodes to root
+        for (const child of this.root.children.values()) {
+            child.fail = this.root;
+            queue.push(child);
+        }
+        // BFS to build failure links
+        while (queue.length > 0) {
+            const current = queue.shift();
+            for (const [char, child] of current.children.entries()) {
+                queue.push(child);
+                let failNode = current.fail;
+                // Find the longest proper suffix that is also a prefix
+                while (failNode !== null && !failNode.children.has(char)) {
+                    failNode = failNode.fail;
+                }
+                if (failNode === null) {
+                    child.fail = this.root;
+                }
+                else {
+                    child.fail = failNode.children.get(char);
+                    // Add outputs from the fail state to this node
+                    for (const output of child.fail.output) {
+                        child.output.add(output);
+                    }
+                }
+            }
+        }
+        this.built = true;
+    }
+    /**
+     * Mencari semua kemunculan pola dalam teks
+     * @param text Teks yang akan dicari
+     * @returns Map pola yang ditemukan dengan jumlah kemunculannya
+     */
+    search(text) {
+        if (!this.built) {
+            this.build();
+        }
+        const matches = new Map();
+        const normalizedText = text.toLowerCase();
+        let node = this.root;
+        for (let i = 0; i < normalizedText.length; i++) {
+            const char = normalizedText[i];
+            // Follow failure links until we find a matching transition or reach root
+            while (node !== this.root && !node.children.has(char)) {
+                node = node.fail;
+            }
+            // Try to follow the transition
+            if (node.children.has(char)) {
+                node = node.children.get(char);
+            }
+            // Check for any matches at this node
+            for (const match of node.output) {
+                matches.set(match, (matches.get(match) || 0) + 1);
+            }
+        }
+        return matches;
+    }
+    /**
+     * Mencari semua kemunculan pola dalam teks dan mengembalikan hanya pola unik
+     * @param text Teks yang akan dicari
+     * @returns Set pola yang ditemukan
+     */
+    searchUnique(text) {
+        const matches = this.search(text);
+        return new Set(matches.keys());
+    }
+    /**
+     * Mengecek apakah teks mengandung setidaknya satu pola
+     * @param text Teks yang akan dicari
+     * @returns Boolean apakah pola ditemukan
+     */
+    containsAny(text) {
+        if (!this.built) {
+            this.build();
+        }
+        const normalizedText = text.toLowerCase();
+        let node = this.root;
+        for (let i = 0; i < normalizedText.length; i++) {
+            const char = normalizedText[i];
+            while (node !== this.root && !node.children.has(char)) {
+                node = node.fail;
+            }
+            if (node.children.has(char)) {
+                node = node.children.get(char);
+            }
+            if (node.output.size > 0) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+const globalAhoCorasick = new AhoCorasick();
+let ahoCorasickInitialized = false;
+function initializeAhoCorasick(words) {
+    if (ahoCorasickInitialized)
+        return;
+    for (const word of words) {
+        globalAhoCorasick.addPattern(word);
+    }
+    globalAhoCorasick.build();
+    ahoCorasickInitialized = true;
+}
 function findProfanity(text, options = {}) {
     const { wordList = [], detectLeetSpeak = true, checkSubstring = false, whitelist = [], categories, regions, severityThreshold = 0, indonesianVariation = false, detectSimilarity = false, similarityThreshold = 0.8, detectSplit = false, useLevenshtein = false, maxLevenshteinDistance = 2, } = { ...DEFAULT_OPTIONS, ...options };
     const normalizedText = normalizeText(text);
@@ -1338,24 +1820,16 @@ function findProfanity(text, options = {}) {
     }
     const matches = new Set();
     const actualMatches = new Map();
-    wordsToCheck.forEach((word) => {
-        const regex = createWordRegex(word, {
-            wholeWord: !checkSubstring,
-            caseSensitive: false,
-            leetSpeak: false,
-            detectSplit: false,
-            indonesianVariation: false,
-        });
-        let match;
-        while ((match = regex.exec(normalizedText)) !== null) {
-            const originalWord = aliasMap.get(word.toLowerCase()) || word.toLowerCase();
-            matches.add(originalWord);
-            if (!actualMatches.has(originalWord)) {
-                actualMatches.set(originalWord, []);
-            }
-            actualMatches.get(originalWord)?.push(match[0]);
+    initializeAhoCorasick(wordsToCheck);
+    const basicMatches = globalAhoCorasick.searchUnique(normalizedText);
+    for (const match of basicMatches) {
+        const originalWord = aliasMap.get(match.toLowerCase()) || match.toLowerCase();
+        matches.add(originalWord);
+        if (!actualMatches.has(originalWord)) {
+            actualMatches.set(originalWord, []);
         }
-    });
+        actualMatches.get(originalWord)?.push(match);
+    }
     if (detectLeetSpeak) {
         wordsToCheck.forEach((word) => {
             const leetRegex = createWordRegex(word, {
@@ -1532,7 +2006,7 @@ function calculateSeverity(matchDetails) {
  * @returns FilterResult dengan hasil filter
  */
 function filter(text, options = {}) {
-    const { replaceWith = '*', fullWordCensor = true, detectLeetSpeak = true, whitelist = [], checkSubstring = false, useRandomGrawlix = false, keepFirstAndLast = false, indonesianVariation = false, detectSplit = false, detectSimilarity = false, useLevenshtein = false, maxLevenshteinDistance = 2, similarityThreshold = 0.8, } = { ...DEFAULT_OPTIONS, ...options };
+    const { replaceWith = "*", fullWordCensor = true, detectLeetSpeak = true, whitelist = [], checkSubstring = false, useRandomGrawlix = false, keepFirstAndLast = false, indonesianVariation = false, detectSplit = false, detectSimilarity = false, useLevenshtein = false, maxLevenshteinDistance = 2, similarityThreshold = 0.8, } = { ...DEFAULT_OPTIONS, ...options };
     const matches = findProfanity(text, {
         ...options,
         detectLeetSpeak,
@@ -1564,7 +2038,7 @@ function filter(text, options = {}) {
         variants.push(word);
         const uniqueVariants = [...new Set(variants)];
         uniqueVariants.forEach((variant) => {
-            const regex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, 'gi');
+            const regex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, "gi");
             let match;
             while ((match = regex.exec(filteredText)) !== null) {
                 const originalWord = match[0];
@@ -1582,7 +2056,7 @@ function filter(text, options = {}) {
                     censored: censoredWord,
                     metadata,
                 });
-                filteredText = filteredText.replace(new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'), censoredWord);
+                filteredText = filteredText.replace(new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, "g"), censoredWord);
             }
         });
         if (detectSplit || detectLeetSpeak) {
@@ -1611,7 +2085,7 @@ function filter(text, options = {}) {
                         censored: censoredWord,
                         metadata,
                     });
-                    filteredText = filteredText.replace(new RegExp(escapeRegExp(originalWord), 'g'), censoredWord);
+                    filteredText = filteredText.replace(new RegExp(escapeRegExp(originalWord), "g"), censoredWord);
                 }
             }
             if (detectSplit) {
@@ -1639,7 +2113,7 @@ function filter(text, options = {}) {
                         censored: censoredWord,
                         metadata,
                     });
-                    filteredText = filteredText.replace(new RegExp(escapeRegExp(originalWord), 'g'), censoredWord);
+                    filteredText = filteredText.replace(new RegExp(escapeRegExp(originalWord), "g"), censoredWord);
                 }
             }
         }
@@ -1651,7 +2125,7 @@ function filter(text, options = {}) {
                     m.aliases.some((alias) => alias.toLowerCase() === word.toLowerCase())));
             const variants = actualMatches.get(word.toLowerCase()) || [];
             variants.forEach((variant) => {
-                const exactVariantRegex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, 'gi');
+                const exactVariantRegex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, "gi");
                 let match;
                 while ((match = exactVariantRegex.exec(filteredText)) !== null) {
                     const originalWord = match[0];
@@ -1669,7 +2143,7 @@ function filter(text, options = {}) {
                         censored: censoredWord,
                         metadata,
                     });
-                    filteredText = filteredText.replace(new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'), censoredWord);
+                    filteredText = filteredText.replace(new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, "g"), censoredWord);
                 }
             });
         });
@@ -1718,8 +2192,20 @@ function analyze(text, options = {}) {
     const severityScore = calculateSeverity(matchDetails);
     let similarWords = [];
     if (mergedOptions.detectSimilarity) {
-        const wordList = matchDetails.map((word) => word.word);
-        similarWords = findPossibleProfanityBySimiliarity(text, wordList, mergedOptions.similarityThreshold || 0.8);
+        if (matchDetails.length > 0) {
+            const wordList = matchDetails.map((word) => word.word);
+            if (mergedOptions.useLevenshtein) {
+                const levenshteinResults = findProfanityByLevenshteinDistance(text, wordList, mergedOptions.similarityThreshold || 0.8, mergedOptions.maxLevenshteinDistance || 2);
+                similarWords = levenshteinResults.map((item) => ({
+                    word: item.word,
+                    original: item.original,
+                    similarity: item.similarity,
+                }));
+            }
+            else {
+                similarWords = findPossibleProfanityBySimiliarity(text, wordList, mergedOptions.similarityThreshold || 0.8);
+            }
+        }
     }
     return {
         hasProfanity: true,
@@ -1816,9 +2302,9 @@ function analyzeWithContext(text, contextWindowSize = 5, options = {}) {
         const regex = createContextRegex(word, contextWindowSize);
         let match;
         while ((match = regex.exec(text)) !== null) {
-            const beforeContext = match[1] || '';
+            const beforeContext = match[1] || "";
             const wordMatch = match[2];
-            const afterContext = match[3] || '';
+            const afterContext = match[3] || "";
             result.push({
                 word: wordMatch,
                 context: beforeContext + wordMatch + afterContext,