@sideid/id-profanity-filter 1.9.6 → 1.10.5

package/dist/index.js

@@ -8,7 +8,7 @@ const general = [
         category: "profanity",
         region: "general",
         severity: 0.7,
-        aliases: ["anjay", "anjir", "anying", "njing", "anj"],
+        aliases: ["anjay", "anjir", "anying", "njing", "anj", "anjg", "ajg"],
         description: "Mengacu pada hewan anjing, digunakan sebagai umpatan",
         context: "Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan",
     },
@@ -17,7 +17,7 @@ const general = [
         category: "profanity",
         region: "general",
         severity: 0.6,
-        aliases: ["bab1", "b4b1"],
+        aliases: ["bab1", "b4b1", "b4bi", "8481", "8ab1", "ba81"],
         description: "Mengacu pada hewan babi, digunakan sebagai umpatan",
         context: "Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan",
     },
@@ -102,6 +102,105 @@ const general = [
         description: "Kata yang mengacu pada orang yang banyak bicara",
         context: "Hinaan untuk menyebut orang yang banyak bicara atau cerewet",
     },
+    {
+        word: "ngentot",
+        category: "sexual",
+        region: "general",
+        severity: 0.9,
+        aliases: ["ngentod", "ntot", "tod"],
+        description: "Istilah kasar untuk aktivitas seksual",
+        context: "Kata vulgar yang merujuk pada aktivitas seksual",
+    },
+    {
+        word: "sialan",
+        category: "insult",
+        region: "general",
+        severity: 0.5,
+        aliases: ["sialn", "sl"],
+        description: "Kata yang mengacu pada orang yang membawa sial",
+        context: "Hinaan untuk menyebut orang yang dianggap membawa sial",
+    },
+    {
+        word: "pler",
+        category: "sexual",
+        region: "general",
+        severity: 0.9,
+        aliases: ["peler", "plr", "biji"],
+        description: "Istilah kasar untuk alat kelamin laki-laki",
+        context: "Kata vulgar yang merujuk pada alat kelamin laki-laki",
+    },
+    {
+        word: "bokep",
+        category: "sexual",
+        region: "general",
+        severity: 0.7,
+        aliases: ["bkp", "bokap"],
+        description: "Istilah untuk video atau konten pornografi",
+        context: "Kata yang mengacu pada materi pornografi",
+    },
+    {
+        word: "coli",
+        category: "sexual",
+        region: "general",
+        severity: 0.8,
+        aliases: ["col", "coly"],
+        description: "Istilah untuk masturbasi laki-laki",
+        context: "Kata vulgar yang merujuk pada aktivitas seksual pribadi",
+    },
+    {
+        word: "desah",
+        category: "sexual",
+        region: "general",
+        severity: 0.6,
+        aliases: ["ds4h", "dsh"],
+        description: "Istilah untuk suara yang dibuat selama aktivitas seksual",
+        context: "Dapat menjadi vulgar tergantung konteks penggunaan",
+    },
+    {
+        word: "seks",
+        category: "sexual",
+        region: "general",
+        severity: 0.5,
+        aliases: ["sex", "ML"],
+        description: "Istilah untuk aktivitas seksual",
+        context: "Dapat menjadi vulgar tergantung konteks penggunaan",
+    },
+    {
+        word: "kondom",
+        category: "sexual",
+        region: "general",
+        severity: 0.5,
+        aliases: ["kndm", "kondom", "cd"],
+        description: "Alat kontrasepsi",
+        context: "Dapat menjadi vulgar tergantung konteks penggunaan",
+    },
+    {
+        word: "ngewe",
+        category: "sexual",
+        region: "general",
+        severity: 0.9,
+        aliases: ["ngew", "we"],
+        description: "Istilah kasar untuk aktivitas seksual",
+        context: "Kata vulgar yang merujuk pada aktivitas seksual",
+    },
+    {
+        word: "puki",
+        category: "sexual",
+        region: "general",
+        severity: 0.9,
+        aliases: ["puk", "pukih"],
+        description: "Kata vulgar yang mengacu pada alat kelamin perempuan",
+        context: "Kata vulgar yang merujuk pada anatomi seksual",
+    },
+    {
+        word: "xxx",
+        category: "sexual",
+        region: "general",
+        severity: 0.6,
+        aliases: ["xXx", "triplex"],
+        description: "Simbol yang sering digunakan untuk menandai konten pornografi",
+        context: "Digunakan untuk menandai konten seksual eksplisit",
+    },
 ];
 general.map((item) => item.word);
 
@@ -196,6 +295,15 @@ const jawa = [
         description: "Secara harfiah berarti kepalamu, digunakan sebagai umpatan ringan",
         context: "Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar",
     },
+    {
+        word: "itil",
+        category: "sexual",
+        region: "jawa",
+        severity: 0.9,
+        aliases: ["itl", "itul"],
+        description: "Kata vulgar yang mengacu pada bagian dari alat kelamin perempuan",
+        context: "Kata vulgar yang merujuk pada anatomi seksual",
+    },
 ];
 jawa.map((item) => item.word);
 
@@ -716,7 +824,6 @@ function addLeetSpeakVariations(pattern) {
         t: ["t", "7", "+"],
         z: ["z", "2"],
     };
-    // Ganti tiap karakter dengan variasinya dalam grup character class
     return pattern
         .split("")
         .map((char) => {
@@ -900,6 +1007,37 @@ function findMostSimilar(target, candidates, threshold = 0.7) {
     }
     return mostSimilar;
 }
+/**
+ * Mencari string yang paling mirip dari array menggunakan Levenshtein distance
+ *
+ * @param target String target
+ * @param candidates Array string kandidat
+ * @param threshold Minimum kesamaan yang diterima (0-1)
+ * @param maxDistance Jarak Levenshtein maksimal yang diterima (default: 3)
+ * @returns String yang paling mirip atau null jika tidak ada yang di atas threshold
+ */
+function findMostSimilarWithLevenshtein(target, candidates, threshold = 0.7, maxDistance = 3) {
+    if (!candidates.length)
+        return null;
+    let maxSimilarity = 0;
+    let minDistance = Infinity;
+    let mostSimilar = null;
+    for (const candidate of candidates) {
+        if (Math.abs(target.length - candidate.length) > maxDistance)
+            continue;
+        const distance = levenshteinDistance(target, candidate);
+        const similarity = stringSimilarity(target, candidate);
+        if ((similarity > maxSimilarity && similarity >= threshold) ||
+            (similarity >= threshold && distance < minDistance)) {
+            maxSimilarity = similarity;
+            minDistance = distance;
+            mostSimilar = candidate;
+            if (distance <= 1 || similarity > 0.95)
+                break;
+        }
+    }
+    return mostSimilar;
+}
 /**
  * Cek apakah string mungkin merupakan variasi dari kata kotor
  * menggunakan kesamaan string
@@ -958,10 +1096,8 @@ function clusterSimilarWords(words, threshold = 0.8) {
  */
 function findPossibleProfanityBySimiliarity(text, profanityWords, threshold = 0.8) {
     const result = [];
-    // Pisahkan teks menjadi kata-kata
     const words = text.toLowerCase().split(/\s+/);
     for (const word of words) {
-        // Lewati kata-kata yang terlalu pendek
         if (word.length < 3)
             continue;
         for (const profanity of profanityWords) {
@@ -978,6 +1114,41 @@ function findPossibleProfanityBySimiliarity(text, profanityWords, threshold = 0.
     }
     return result;
 }
+/**
+ * Cari kata-kata kotor yang mungkin dari teks menggunakan Levenshtein distance
+ *
+ * @param text Teks yang akan diperiksa
+ * @param profanityWords Daftar kata kotor
+ * @param threshold Batas minimum kesamaan (default: 0.8)
+ * @param maxDistance Jarak Levenshtein maksimal (default: 2)
+ * @returns Array kata yang mungkin merupakan kata kotor
+ */
+function findProfanityByLevenshteinDistance(text, profanityWords, threshold = 0.8, maxDistance = 2) {
+    const result = [];
+    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;
+                }
+            }
+        }
+    }
+    return result;
+}
 
 const DEFAULT_OPTIONS = {
     replaceWith: "*",
@@ -986,6 +1157,8 @@ const DEFAULT_OPTIONS = {
     checkSubstring: false,
     whitelist: [],
     severityThreshold: 0,
+    useLevenshtein: false,
+    maxLevenshteinDistance: 2,
 };
 const FILTER_PRESETS = {
     strict: {
@@ -1131,31 +1304,44 @@ function makeRandomGrawlixString(length) {
 }
 
 function findProfanity(text, options = {}) {
-    const { wordList = [], detectLeetSpeak = true, checkSubstring = false, whitelist = [], categories, regions, severityThreshold = 0, indonesianVariation = false, detectSimilarity = false, similarityThreshold = 0.8, detectSplit = false, } = { ...DEFAULT_OPTIONS, ...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);
-    let wordsToCheck = wordList.length > 0 ? wordList : [];
-    if (wordsToCheck.length === 0) {
-        if (categories || regions || severityThreshold > 0) {
-            wordsToCheck = wordObjects
-                .filter((word) => {
-                const matchCategory = categories
-                    ? categories.includes(word.category)
-                    : true;
-                const matchRegion = regions ? regions.includes(word.region) : true;
-                const matchSeverity = word.severity >= severityThreshold;
-                return matchCategory && matchRegion && matchSeverity;
-            })
-                .map((word) => word.word);
-        }
-        else {
-            wordsToCheck = wordObjects.map((word) => word.word);
-        }
+    let baseWordsToCheck = wordList.length > 0 ? wordList : [];
+    if (baseWordsToCheck.length === 0) {
+        const filteredWords = wordObjects.filter((word) => {
+            const matchCategory = categories
+                ? categories.includes(word.category)
+                : true;
+            const matchRegion = regions ? regions.includes(word.region) : true;
+            const matchSeverity = word.severity >= severityThreshold;
+            return matchCategory && matchRegion && matchSeverity;
+        });
+        baseWordsToCheck = filteredWords.map((word) => word.word);
     }
-    wordsToCheck = wordsToCheck.filter((word) => !whitelist.includes(word.toLocaleLowerCase()));
+    const aliasMap = new Map();
+    wordObjects.forEach((wordObj) => {
+        if (wordObj.aliases && wordObj.aliases.length > 0) {
+            const matchCategory = categories
+                ? categories.includes(wordObj.category)
+                : true;
+            const matchRegion = regions ? regions.includes(wordObj.region) : true;
+            const matchSeverity = wordObj.severity >= severityThreshold;
+            if (matchCategory && matchRegion && matchSeverity) {
+                wordObj.aliases.forEach((alias) => {
+                    aliasMap.set(alias.toLowerCase(), wordObj.word.toLowerCase());
+                });
+            }
+        }
+    });
+    const wordsToCheck = [
+        ...baseWordsToCheck,
+        ...Array.from(aliasMap.keys()),
+    ].filter((word) => !whitelist.includes(word.toLowerCase()));
     if (wordsToCheck.length === 0) {
         return [];
     }
     const matches = new Set();
+    const actualMatches = new Map();
     wordsToCheck.forEach((word) => {
         const regex = createWordRegex(word, {
             wholeWord: !checkSubstring,
@@ -1164,8 +1350,14 @@ function findProfanity(text, options = {}) {
             detectSplit: false,
             indonesianVariation: false,
         });
-        while ((regex.exec(normalizedText)) !== null) {
-            matches.add(word.toLowerCase());
+        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]);
         }
     });
     if (detectLeetSpeak) {
@@ -1177,8 +1369,14 @@ function findProfanity(text, options = {}) {
                 detectSplit: false,
                 indonesianVariation: false,
             });
-            while ((leetRegex.exec(text)) !== null) {
-                matches.add(word.toLowerCase());
+            let match;
+            while ((match = leetRegex.exec(text)) !== 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]);
             }
         });
     }
@@ -1191,33 +1389,64 @@ function findProfanity(text, options = {}) {
                 detectSplit: false,
                 indonesianVariation: true,
             });
-            while ((variantRegex.exec(text)) !== null) {
-                matches.add(word.toLowerCase());
+            let match;
+            while ((match = variantRegex.exec(text)) !== 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]);
             }
         });
     }
     if (detectSplit) {
-        if (detectSplitWords(text, wordsToCheck)) {
-            wordsToCheck.forEach((word) => {
-                const splitRegex = createWordRegex(word, {
-                    wholeWord: false,
-                    caseSensitive: false,
-                    leetSpeak: false,
-                    detectSplit: true,
-                    indonesianVariation: false,
-                });
-                if (splitRegex.test(text)) {
-                    matches.add(word.toLowerCase());
-                }
+        wordsToCheck.forEach((word) => {
+            const splitRegex = createWordRegex(word, {
+                wholeWord: false,
+                caseSensitive: false,
+                leetSpeak: false,
+                detectSplit: true,
+                indonesianVariation: false,
             });
-        }
+            let match;
+            while ((match = splitRegex.exec(text)) !== 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]);
+            }
+        });
     }
     if (detectSimilarity) {
-        const possibleProfanity = findPossibleProfanityBySimiliarity(text, wordsToCheck, similarityThreshold);
-        possibleProfanity.forEach((item) => {
-            matches.add(item.original.toLowerCase());
-        });
+        if (useLevenshtein) {
+            const possibleProfanity = findProfanityByLevenshteinDistance(text, wordsToCheck, similarityThreshold, maxLevenshteinDistance);
+            possibleProfanity.forEach((item) => {
+                const originalWord = aliasMap.get(item.original.toLowerCase()) ||
+                    item.original.toLowerCase();
+                matches.add(originalWord);
+                if (!actualMatches.has(originalWord)) {
+                    actualMatches.set(originalWord, []);
+                }
+                actualMatches.get(originalWord)?.push(item.word);
+            });
+        }
+        else {
+            const possibleProfanity = findPossibleProfanityBySimiliarity(text, wordsToCheck, similarityThreshold);
+            possibleProfanity.forEach((item) => {
+                matches.add(item.original.toLowerCase());
+                const originalWord = aliasMap.get(item.original.toLowerCase()) ||
+                    item.original.toLowerCase();
+                if (!actualMatches.has(originalWord)) {
+                    actualMatches.set(originalWord, []);
+                }
+                actualMatches.get(originalWord)?.push(item.word);
+            });
+        }
     }
+    findProfanity.lastActualMatches = actualMatches;
     return Array.from(matches);
 }
 /**
@@ -1307,14 +1536,20 @@ 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, } = { ...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,
         whitelist,
         checkSubstring,
         indonesianVariation,
+        detectSplit,
+        detectSimilarity,
+        useLevenshtein,
+        maxLevenshteinDistance,
+        similarityThreshold,
     });
+    const actualMatches = findProfanity.lastActualMatches || new Map();
     const matchDetails = findProfanityWithMetadata(text, options);
     if (matches.length === 0) {
         return {
@@ -1329,36 +1564,120 @@ function filter(text, options = {}) {
         const metadata = matchDetails.find((m) => m.word.toLowerCase() === word.toLowerCase() ||
             (m.aliases &&
                 m.aliases.some((alias) => alias.toLowerCase() === word.toLowerCase())));
-        const regex = createWordRegex(word, {
-            wholeWord: true,
-            caseSensitive: false,
-            leetSpeak: false,
-            detectSplit: false,
-            indonesianVariation: false,
+        const variants = actualMatches.get(word.toLowerCase()) || [];
+        variants.push(word);
+        const uniqueVariants = [...new Set(variants)];
+        uniqueVariants.forEach((variant) => {
+            const regex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, 'gi');
+            let match;
+            while ((match = regex.exec(filteredText)) !== null) {
+                const originalWord = match[0];
+                if (whitelist.includes(originalWord.toLowerCase()))
+                    continue;
+                let censoredWord;
+                if (useRandomGrawlix) {
+                    censoredWord = makeRandomGrawlixString(originalWord.length);
+                }
+                else {
+                    censoredWord = censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
+                }
+                replacements.push({
+                    original: originalWord,
+                    censored: censoredWord,
+                    metadata,
+                });
+                filteredText = filteredText.replace(new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'), censoredWord);
+            }
         });
-        let match;
-        const textToSearch = filteredText;
-        regex.lastIndex = 0;
-        while ((match = regex.exec(textToSearch)) !== null) {
-            const originalWord = match[0];
-            if (whitelist.includes(originalWord.toLowerCase()))
-                continue;
-            let censoredWord;
-            if (useRandomGrawlix) {
-                censoredWord = makeRandomGrawlixString(originalWord.length);
+        if (detectSplit || detectLeetSpeak) {
+            if (detectLeetSpeak) {
+                const leetRegex = createWordRegex(word, {
+                    wholeWord: true,
+                    caseSensitive: false,
+                    leetSpeak: true,
+                    detectSplit: false,
+                    indonesianVariation: false,
+                });
+                let match;
+                while ((match = leetRegex.exec(filteredText)) !== null) {
+                    const originalWord = match[0];
+                    if (whitelist.includes(originalWord.toLowerCase()))
+                        continue;
+                    let censoredWord;
+                    if (useRandomGrawlix) {
+                        censoredWord = makeRandomGrawlixString(originalWord.length);
+                    }
+                    else {
+                        censoredWord = censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
+                    }
+                    replacements.push({
+                        original: originalWord,
+                        censored: censoredWord,
+                        metadata,
+                    });
+                    filteredText = filteredText.replace(new RegExp(escapeRegExp(originalWord), 'g'), censoredWord);
+                }
             }
-            else {
-                censoredWord = censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
+            if (detectSplit) {
+                const splitRegex = createWordRegex(word, {
+                    wholeWord: false,
+                    caseSensitive: false,
+                    leetSpeak: false,
+                    detectSplit: true,
+                    indonesianVariation: false,
+                });
+                let match;
+                while ((match = splitRegex.exec(filteredText)) !== null) {
+                    const originalWord = match[0];
+                    if (whitelist.includes(originalWord.toLowerCase()))
+                        continue;
+                    let censoredWord;
+                    if (useRandomGrawlix) {
+                        censoredWord = makeRandomGrawlixString(originalWord.length);
+                    }
+                    else {
+                        censoredWord = censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
+                    }
+                    replacements.push({
+                        original: originalWord,
+                        censored: censoredWord,
+                        metadata,
+                    });
+                    filteredText = filteredText.replace(new RegExp(escapeRegExp(originalWord), 'g'), censoredWord);
+                }
             }
-            replacements.push({
-                original: originalWord,
-                censored: censoredWord,
-                metadata,
-            });
-            const replaceRegex = new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, "g");
-            filteredText = filteredText.replace(replaceRegex, censoredWord);
         }
     });
+    if (detectSimilarity && useLevenshtein) {
+        matches.forEach((word) => {
+            const metadata = matchDetails.find((m) => m.word.toLowerCase() === word.toLowerCase() ||
+                (m.aliases &&
+                    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');
+                let match;
+                while ((match = exactVariantRegex.exec(filteredText)) !== null) {
+                    const originalWord = match[0];
+                    if (whitelist.includes(originalWord.toLowerCase()))
+                        continue;
+                    let censoredWord;
+                    if (useRandomGrawlix) {
+                        censoredWord = makeRandomGrawlixString(originalWord.length);
+                    }
+                    else {
+                        censoredWord = censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
+                    }
+                    replacements.push({
+                        original: originalWord,
+                        censored: censoredWord,
+                        metadata,
+                    });
+                    filteredText = filteredText.replace(new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'), censoredWord);
+                }
+            });
+        });
+    }
     return {
         filtered: filteredText,
         censored: replacements.length,
@@ -1501,9 +1820,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,
@@ -1633,10 +1952,25 @@ class IDProfanityFilter {
     /**
      * Mengaktifkan deteksi berdasarkan kesamaan
      * @param threshold Threshold kesamaan (0-1)
+     * @param useLevenshtein Gunakan algoritma Levenshtein untuk deteksi
+     * @param maxLevenshteinDistance Jarak maksimal Levenshtein (default: 2)
+     */
+    enableSimilarityDetection(threshold = 0.8, useLevenshtein = false, maxLevenshteinDistance = 2) {
+        this.options.detectSimilarity = true;
+        this.options.similarityThreshold = threshold;
+        this.options.useLevenshtein = useLevenshtein;
+        this.options.maxLevenshteinDistance = maxLevenshteinDistance;
+    }
+    /**
+     * Mengaktifkan deteksi berbasis Levenshtein distance
+     * @param threshold Threshold kesamaan (0-1)
+     * @param maxDistance Jarak maksimal Levenshtein (default: 2)
      */
-    enableSimilarityDetection(threshold = 0.8) {
+    enableLevenshteinDetection(threshold = 0.8, maxDistance = 2) {
         this.options.detectSimilarity = true;
+        this.options.useLevenshtein = true;
         this.options.similarityThreshold = threshold;
+        this.options.maxLevenshteinDistance = maxDistance;
     }
 }
 const idFilter = {
@@ -1682,8 +2016,10 @@ exports.escapeRegExp = escapeRegExp;
 exports.filter = filter;
 exports.findCategories = findCategories;
 exports.findMostSimilar = findMostSimilar;
+exports.findMostSimilarWithLevenshtein = findMostSimilarWithLevenshtein;
 exports.findPossibleProfanityBySimiliarity = findPossibleProfanityBySimiliarity;
 exports.findProfanity = findProfanity;
+exports.findProfanityByLevenshteinDistance = findProfanityByLevenshteinDistance;
 exports.findProfanityWithMetadata = findProfanityWithMetadata;
 exports.findRegions = findRegions;
 exports.getContextAroundIndex = getContextAroundIndex;