@sideid/id-profanity-filter 1.9.5 → 1.10.2

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,114 @@ 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",
+    },
+    {
+        word: "xnxx",
+        category: "sexual",
+        region: "general",
+        severity: 0.6,
+        aliases: ["xnxx", "xnx"],
+        description: "simbol yang sering digunakan untuk menandai konten pornografi",
+        context: "Digunakan untuk menandai konten seksual eksplisit",
+    }
 ];
 general.map((item) => item.word);
 
@@ -119,7 +227,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",
@@ -155,7 +263,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",
@@ -164,7 +272,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",
@@ -196,6 +304,257 @@ 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",
+        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 +1075,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 +1258,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
@@ -950,34 +1339,156 @@ 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 = [];
-    // Pisahkan teks menjadi kata-kata
+    // 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) {
-        // Lewati kata-kata yang terlalu pendek
         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;
 }
+/**
+ * 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 = [];
+    // 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;
+        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: "*",
@@ -986,6 +1497,8 @@ const DEFAULT_OPTIONS = {
     checkSubstring: false,
     whitelist: [],
     severityThreshold: 0,
+    useLevenshtein: false,
+    maxLevenshteinDistance: 2,
 };
 const FILTER_PRESETS = {
     strict: {
@@ -1130,44 +1643,206 @@ function makeRandomGrawlixString(length) {
     return result;
 }
 
-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 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);
+/**
+ * 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");
         }
-        else {
-            wordsToCheck = wordObjects.map((word) => word.word);
+        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;
     }
-    wordsToCheck = wordsToCheck.filter((word) => !whitelist.includes(word.toLocaleLowerCase()));
+    /**
+     * 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);
+    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);
+    }
+    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();
-    wordsToCheck.forEach((word) => {
-        const regex = createWordRegex(word, {
-            wholeWord: !checkSubstring,
-            caseSensitive: false,
-            leetSpeak: false,
-            detectSplit: false,
-            indonesianVariation: false,
-        });
-        while ((regex.exec(normalizedText)) !== null) {
-            matches.add(word.toLowerCase());
+    const actualMatches = new Map();
+    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, {
@@ -1177,8 +1852,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 +1872,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 +2019,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 +2047,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,
@@ -1403,8 +2205,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,
@@ -1633,10 +2447,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 +2511,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;