@sideid/id-profanity-filter 1.9.4 → 1.9.6

package/dist/index.js

@@ -4,459 +4,459 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 const general = [
     {
-        word: 'anjing',
-        category: 'profanity',
-        region: 'general',
+        word: "anjing",
+        category: "profanity",
+        region: "general",
         severity: 0.7,
-        aliases: ['anjay', 'anjir', 'anying', 'njing', 'anj'],
-        description: 'Mengacu pada hewan anjing, digunakan sebagai umpatan',
-        context: 'Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan',
+        aliases: ["anjay", "anjir", "anying", "njing", "anj"],
+        description: "Mengacu pada hewan anjing, digunakan sebagai umpatan",
+        context: "Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan",
     },
     {
-        word: 'babi',
-        category: 'profanity',
-        region: 'general',
+        word: "babi",
+        category: "profanity",
+        region: "general",
         severity: 0.6,
-        aliases: ['bab1', 'b4b1'],
-        description: 'Mengacu pada hewan babi, digunakan sebagai umpatan',
-        context: 'Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan',
+        aliases: ["bab1", "b4b1"],
+        description: "Mengacu pada hewan babi, digunakan sebagai umpatan",
+        context: "Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan",
     },
     {
-        word: 'bangsat',
-        category: 'insult',
-        region: 'general',
+        word: "bangsat",
+        category: "insult",
+        region: "general",
         severity: 0.8,
-        aliases: ['bangst', 'bngst', 'bgst'],
-        description: 'Secara harfiah berarti kutu busuk, digunakan sebagai umpatan untuk menyebut seseorang yang tidak bermoral',
-        context: 'Umpatan kasar untuk menyebut orang yang dianggap jahat atau merugikan',
+        aliases: ["bangst", "bngst", "bgst"],
+        description: "Secara harfiah berarti kutu busuk, digunakan sebagai umpatan untuk menyebut seseorang yang tidak bermoral",
+        context: "Umpatan kasar untuk menyebut orang yang dianggap jahat atau merugikan",
     },
     {
-        word: 'kontol',
-        category: 'sexual',
-        region: 'general',
+        word: "kontol",
+        category: "sexual",
+        region: "general",
         severity: 0.9,
-        aliases: ['kntl', 'k0ntol', 'k0nt0l'],
-        description: 'Kata vulgar yang mengacu pada alat kelamin laki-laki',
-        context: 'Umpatan kasar atau istilah vulgar untuk alat kelamin',
+        aliases: ["kntl", "k0ntol", "k0nt0l"],
+        description: "Kata vulgar yang mengacu pada alat kelamin laki-laki",
+        context: "Umpatan kasar atau istilah vulgar untuk alat kelamin",
     },
     {
-        word: 'memek',
-        category: 'sexual',
-        region: 'general',
+        word: "memek",
+        category: "sexual",
+        region: "general",
         severity: 0.9,
-        aliases: ['mmk', 'memk'],
-        description: 'Kata vulgar yang mengacu pada alat kelamin perempuan',
-        context: 'Umpatan kasar atau istilah vulgar untuk alat kelamin',
+        aliases: ["mmk", "memk"],
+        description: "Kata vulgar yang mengacu pada alat kelamin perempuan",
+        context: "Umpatan kasar atau istilah vulgar untuk alat kelamin",
     },
     {
-        word: 'bego',
-        category: 'insult',
-        region: 'general',
+        word: "bego",
+        category: "insult",
+        region: "general",
         severity: 0.5,
-        aliases: ['bgo', 'begok'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["bgo", "begok"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
     {
-        word: 'tolol',
-        category: 'insult',
-        region: 'general',
+        word: "tolol",
+        category: "insult",
+        region: "general",
         severity: 0.6,
-        aliases: ['tll', 'tlol'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["tll", "tlol"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
     {
-        word: 'bajingan',
-        category: 'insult',
-        region: 'general',
+        word: "bajingan",
+        category: "insult",
+        region: "general",
         severity: 0.7,
-        aliases: ['bajingn', 'bjgn'],
-        description: 'Kata yang mengacu pada orang jahat atau tidak bermoral',
-        context: 'Hinaan untuk menyebut orang yang dianggap jahat atau tidak bermoral',
+        aliases: ["bajingn", "bjgn"],
+        description: "Kata yang mengacu pada orang jahat atau tidak bermoral",
+        context: "Hinaan untuk menyebut orang yang dianggap jahat atau tidak bermoral",
     },
     {
-        word: 'goblok',
-        category: 'insult',
-        region: 'general',
+        word: "goblok",
+        category: "insult",
+        region: "general",
         severity: 0.6,
-        aliases: ['gblk', 'goblk'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["gblk", "goblk"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
     {
-        word: 'keparat',
-        category: 'insult',
-        region: 'general',
+        word: "keparat",
+        category: "insult",
+        region: "general",
         severity: 0.7,
-        aliases: ['kprt', 'keprat'],
-        description: 'Kata yang mengacu pada orang jahat atau tidak bermoral',
-        context: 'Hinaan untuk menyebut orang yang dianggap jahat atau tidak bermoral',
+        aliases: ["kprt", "keprat"],
+        description: "Kata yang mengacu pada orang jahat atau tidak bermoral",
+        context: "Hinaan untuk menyebut orang yang dianggap jahat atau tidak bermoral",
     },
     {
-        word: 'bacot',
-        category: 'insult',
-        region: 'general',
+        word: "bacot",
+        category: "insult",
+        region: "general",
         severity: 0.5,
-        aliases: ['bcot', 'bacot2'],
-        description: 'Kata yang mengacu pada orang yang banyak bicara',
-        context: 'Hinaan untuk menyebut orang yang banyak bicara atau cerewet',
+        aliases: ["bcot", "bacot2"],
+        description: "Kata yang mengacu pada orang yang banyak bicara",
+        context: "Hinaan untuk menyebut orang yang banyak bicara atau cerewet",
     },
 ];
 general.map((item) => item.word);
 
 const jawa = [
     {
-        word: 'asu',
-        category: 'profanity',
-        region: 'jawa',
+        word: "asu",
+        category: "profanity",
+        region: "jawa",
         severity: 0.7,
-        aliases: ['asyu', 'su'],
-        description: 'Secara harfiah berarti anjing dalam Bahasa Jawa',
-        context: 'Umpatan umum dalam Bahasa Jawa untuk menunjukkan kemarahan',
+        aliases: ["asyu", "su"],
+        description: "Secara harfiah berarti anjing dalam Bahasa Jawa",
+        context: "Umpatan umum dalam Bahasa Jawa untuk menunjukkan kemarahan",
     },
     {
-        word: 'jancok',
-        category: 'sexual',
-        region: 'jawa',
+        word: "jancok",
+        category: "sexual",
+        region: "jawa",
         severity: 0.8,
-        aliases: ['jancuk', 'jncok', 'jancuk', 'jncuk', 'dancok', 'dancuk'],
-        description: 'Kata umpatan kasar dalam Bahasa Jawa',
-        context: 'Umpatan kasar yang umum digunakan di Jawa Timur',
+        aliases: ["jancuk", "jncok", "jancuk", "jncuk", "dancok", "dancuk"],
+        description: "Kata umpatan kasar dalam Bahasa Jawa",
+        context: "Umpatan kasar yang umum digunakan di Jawa Timur",
     },
     {
-        word: 'cuk',
-        category: 'sexual',
-        region: 'jawa',
+        word: "cuk",
+        category: "sexual",
+        region: "jawa",
         severity: 0.7,
-        aliases: ['cok', 'cook'],
-        description: 'Singkatan dari jancok/jancuk',
-        context: 'Umpatan singkat yang umum digunakan di Jawa Timur',
+        aliases: ["cok", "cook"],
+        description: "Singkatan dari jancok/jancuk",
+        context: "Umpatan singkat yang umum digunakan di Jawa Timur",
     },
     {
-        word: 'diancok',
-        category: 'sexual',
-        region: 'jawa',
+        word: "diancok",
+        category: "sexual",
+        region: "jawa",
         severity: 0.8,
-        aliases: ['diancuk', 'dancok', 'ancok'],
-        description: 'Variasi dari jancok/jancuk',
-        context: 'Umpatan kasar yang umum digunakan di Jawa Timur',
+        aliases: ["diancuk", "dancok", "ancok"],
+        description: "Variasi dari jancok/jancuk",
+        context: "Umpatan kasar yang umum digunakan di Jawa Timur",
     },
     {
-        word: 'matamu',
-        category: 'insult',
-        region: 'jawa',
+        word: "matamu",
+        category: "insult",
+        region: "jawa",
         severity: 0.5,
-        aliases: ['mripat mu', 'matane'],
-        description: 'Secara harfiah berarti matamu, digunakan sebagai umpatan ringan',
-        context: 'Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar',
+        aliases: ["mripat mu", "matane"],
+        description: "Secara harfiah berarti matamu, digunakan sebagai umpatan ringan",
+        context: "Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar",
     },
     {
-        word: 'mbokne ancok',
-        category: 'insult',
-        region: 'jawa',
+        word: "mbokne ancok",
+        category: "insult",
+        region: "jawa",
         severity: 0.8,
-        aliases: ['mbokne', 'mbokneancok'],
-        description: 'Umpatan yang menyinggung ibu seseorang',
-        context: 'Umpatan kasar yang menyinggung orangtua orang lain',
+        aliases: ["mbokne", "mbokneancok"],
+        description: "Umpatan yang menyinggung ibu seseorang",
+        context: "Umpatan kasar yang menyinggung orangtua orang lain",
     },
     {
-        word: 'pekok',
-        category: 'insult',
-        region: 'jawa',
+        word: "pekok",
+        category: "insult",
+        region: "jawa",
         severity: 0.6,
-        aliases: ['pekak', 'pekilk'],
-        description: 'Kata hinaan yang menunjukkan kebodohan',
-        context: 'Hinaan untuk menyebut orang yang dianggap sangat bodoh',
+        aliases: ["pekak", "pekilk"],
+        description: "Kata hinaan yang menunjukkan kebodohan",
+        context: "Hinaan untuk menyebut orang yang dianggap sangat bodoh",
     },
     {
-        word: 'sempak',
-        category: 'disgusting',
-        region: 'jawa',
+        word: "sempak",
+        category: "disgusting",
+        region: "jawa",
         severity: 0.5,
-        aliases: ['sempok'],
-        description: 'Mengacu pada pakaian dalam',
-        context: 'Umpatan ringan yang dianggap jorok',
+        aliases: ["sempok"],
+        description: "Mengacu pada pakaian dalam",
+        context: "Umpatan ringan yang dianggap jorok",
     },
     {
-        word: 'taek',
-        category: 'disgusting',
-        region: 'jawa',
+        word: "taek",
+        category: "disgusting",
+        region: "jawa",
         severity: 0.6,
-        aliases: ['tai', 'tahi', 'telek'],
-        description: 'Secara harfiah berarti kotoran/tinja',
-        context: 'Umpatan untuk menunjukkan sesuatu yang menjijikkan atau buruk',
+        aliases: ["tai", "tahi", "telek"],
+        description: "Secara harfiah berarti kotoran/tinja",
+        context: "Umpatan untuk menunjukkan sesuatu yang menjijikkan atau buruk",
     },
     {
-        word: 'ndhasmu',
-        category: 'insult',
-        region: 'jawa',
+        word: "ndhasmu",
+        category: "insult",
+        region: "jawa",
         severity: 0.5,
-        aliases: ['ndas mu', 'dhasmu'],
-        description: 'Secara harfiah berarti kepalamu, digunakan sebagai umpatan ringan',
-        context: 'Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar',
+        aliases: ["ndas mu", "dhasmu"],
+        description: "Secara harfiah berarti kepalamu, digunakan sebagai umpatan ringan",
+        context: "Umpatan ringan untuk menanggapi sesuatu yang dianggap tidak benar",
     },
 ];
 jawa.map((item) => item.word);
 
 const sunda = [
     {
-        word: 'bagong',
-        category: 'insult',
-        region: 'sunda',
+        word: "bagong",
+        category: "insult",
+        region: "sunda",
         severity: 0.5,
-        aliases: ['bagog'],
-        description: 'Secara harfiah berarti babi hutan, digunakan sebagai hinaan',
-        context: 'Hinaan untuk menyebut orang yang dianggap jorok atau rakus',
+        aliases: ["bagog"],
+        description: "Secara harfiah berarti babi hutan, digunakan sebagai hinaan",
+        context: "Hinaan untuk menyebut orang yang dianggap jorok atau rakus",
     },
     {
-        word: 'belegug',
-        category: 'insult',
-        region: 'sunda',
+        word: "belegug",
+        category: "insult",
+        region: "sunda",
         severity: 0.5,
-        aliases: ['belecuk', 'beledog'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["belecuk", "beledog"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
     {
-        word: 'goblog',
-        category: 'insult',
-        region: 'sunda',
+        word: "goblog",
+        category: "insult",
+        region: "sunda",
         severity: 0.6,
-        aliases: ['goblok', 'golbok'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["goblok", "golbok"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
 ];
 sunda.map((item) => item.word);
 
 const betawi = [
     {
-        word: 'jablay',
-        category: 'sexual',
-        region: 'betawi',
+        word: "jablay",
+        category: "sexual",
+        region: "betawi",
         severity: 0.7,
-        aliases: ['jabl4y', 'jalay'],
+        aliases: ["jabl4y", "jalay"],
         description: 'Singkatan dari "jarang dibelai", istilah untuk perempuan yang mudah didekati',
-        context: 'Hinaan yang merendahkan untuk wanita',
+        context: "Hinaan yang merendahkan untuk wanita",
     },
     {
-        word: 'udik',
-        category: 'insult',
-        region: 'betawi',
+        word: "udik",
+        category: "insult",
+        region: "betawi",
         severity: 0.5,
-        aliases: ['kampungan', 'ndeso'],
-        description: 'Kata yang mengacu pada seseorang yang dianggap ketinggalan zaman atau tidak modern',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak modern atau kampungan',
+        aliases: ["kampungan", "ndeso"],
+        description: "Kata yang mengacu pada seseorang yang dianggap ketinggalan zaman atau tidak modern",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak modern atau kampungan",
     },
     {
-        word: 'perek',
-        category: 'sexual',
-        region: 'betawi',
+        word: "perek",
+        category: "sexual",
+        region: "betawi",
         severity: 0.7,
-        aliases: ['perempuan eksperimen', 'prk'],
-        description: 'Istilah untuk perempuan yang dianggap memiliki moral yang rendah',
-        context: 'Hinaan yang merendahkan untuk wanita',
+        aliases: ["perempuan eksperimen", "prk"],
+        description: "Istilah untuk perempuan yang dianggap memiliki moral yang rendah",
+        context: "Hinaan yang merendahkan untuk wanita",
     },
 ];
 betawi.map((item) => item.word);
 
 const sexual = [
-    ...general.filter((word) => word.category === 'sexual'),
-    ...jawa.filter((word) => word.category === 'sexual'),
-    ...sunda.filter((word) => word.category === 'sexual'),
-    ...betawi.filter((word) => word.category === 'sexual'),
+    ...general.filter((word) => word.category === "sexual"),
+    ...jawa.filter((word) => word.category === "sexual"),
+    ...sunda.filter((word) => word.category === "sexual"),
+    ...betawi.filter((word) => word.category === "sexual"),
     {
-        word: 'bokep',
-        category: 'sexual',
-        region: 'general',
+        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',
+        aliases: ["bkp", "bokap"],
+        description: "Istilah untuk video atau konten pornografi",
+        context: "Kata yang mengacu pada materi pornografi",
     },
     {
-        word: 'coli',
-        category: 'sexual',
-        region: 'general',
+        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',
+        aliases: ["col", "coly"],
+        description: "Istilah untuk masturbasi laki-laki",
+        context: "Kata vulgar yang merujuk pada aktivitas seksual pribadi",
     },
     {
-        word: 'desah',
-        category: 'sexual',
-        region: 'general',
+        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',
+        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',
+        word: "seks",
+        category: "sexual",
+        region: "general",
         severity: 0.5,
-        aliases: ['sex', 'ML'],
-        description: 'Istilah untuk aktivitas seksual',
-        context: 'Dapat menjadi vulgar tergantung konteks penggunaan',
+        aliases: ["sex", "ML"],
+        description: "Istilah untuk aktivitas seksual",
+        context: "Dapat menjadi vulgar tergantung konteks penggunaan",
     },
     {
-        word: 'itil',
-        category: 'sexual',
-        region: 'general',
+        word: "itil",
+        category: "sexual",
+        region: "general",
         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',
+        aliases: ["itl", "itul"],
+        description: "Kata vulgar yang mengacu pada bagian dari alat kelamin perempuan",
+        context: "Kata vulgar yang merujuk pada anatomi seksual",
     },
     {
-        word: 'kondom',
-        category: 'sexual',
-        region: 'general',
+        word: "kondom",
+        category: "sexual",
+        region: "general",
         severity: 0.5,
-        aliases: ['kndm', 'kondom', 'cd'],
-        description: 'Alat kontrasepsi',
-        context: 'Dapat menjadi vulgar tergantung konteks penggunaan',
+        aliases: ["kndm", "kondom", "cd"],
+        description: "Alat kontrasepsi",
+        context: "Dapat menjadi vulgar tergantung konteks penggunaan",
     },
     {
-        word: 'ngewe',
-        category: 'sexual',
-        region: 'general',
+        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',
+        aliases: ["ngew", "we"],
+        description: "Istilah kasar untuk aktivitas seksual",
+        context: "Kata vulgar yang merujuk pada aktivitas seksual",
     },
     {
-        word: 'puki',
-        category: 'sexual',
-        region: 'general',
+        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',
+        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',
+        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',
+        aliases: ["xXx", "triplex"],
+        description: "Simbol yang sering digunakan untuk menandai konten pornografi",
+        context: "Digunakan untuk menandai konten seksual eksplisit",
     },
 ];
 sexual.map((item) => item.word);
 
 const insult = [
-    ...general.filter((word) => word.category === 'insult'),
-    ...jawa.filter((word) => word.category === 'insult'),
-    ...sunda.filter((word) => word.category === 'insult'),
-    ...betawi.filter((word) => word.category === 'insult'),
+    ...general.filter((word) => word.category === "insult"),
+    ...jawa.filter((word) => word.category === "insult"),
+    ...sunda.filter((word) => word.category === "insult"),
+    ...betawi.filter((word) => word.category === "insult"),
     {
-        word: 'idiot',
-        category: 'insult',
-        region: 'general',
+        word: "idiot",
+        category: "insult",
+        region: "general",
         severity: 0.6,
-        aliases: ['idi0t', 'idot'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap sangat tidak pintar',
+        aliases: ["idi0t", "idot"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap sangat tidak pintar",
     },
     {
-        word: 'dungu',
-        category: 'insult',
-        region: 'general',
+        word: "dungu",
+        category: "insult",
+        region: "general",
         severity: 0.5,
-        aliases: ['dngu', 'dongu'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["dngu", "dongu"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
     {
-        word: 'sinting',
-        category: 'insult',
-        region: 'general',
+        word: "sinting",
+        category: "insult",
+        region: "general",
         severity: 0.6,
-        aliases: ['sintng', 'senteng'],
-        description: 'Kata yang mengacu pada kegilaan atau ketidakwarasan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap gila atau tidak waras',
+        aliases: ["sintng", "senteng"],
+        description: "Kata yang mengacu pada kegilaan atau ketidakwarasan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap gila atau tidak waras",
     },
     {
-        word: 'sarap',
-        category: 'insult',
-        region: 'general',
+        word: "sarap",
+        category: "insult",
+        region: "general",
         severity: 0.6,
-        aliases: ['saraf', 'srap'],
-        description: 'Kata yang mengacu pada kegilaan atau ketidakwarasan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap gila atau tidak waras',
+        aliases: ["saraf", "srap"],
+        description: "Kata yang mengacu pada kegilaan atau ketidakwarasan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap gila atau tidak waras",
     },
     {
-        word: 'geblek',
-        category: 'insult',
-        region: 'general',
+        word: "geblek",
+        category: "insult",
+        region: "general",
         severity: 0.5,
-        aliases: ['gblk', 'geblk'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["gblk", "geblk"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
     {
-        word: 'kampungan',
-        category: 'insult',
-        region: 'general',
+        word: "kampungan",
+        category: "insult",
+        region: "general",
         severity: 0.5,
-        aliases: ['kmpngn', 'kamphungan'],
-        description: 'Kata yang mengacu pada ketidaksopanan atau kenaifan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak modern atau primitif',
+        aliases: ["kmpngn", "kamphungan"],
+        description: "Kata yang mengacu pada ketidaksopanan atau kenaifan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak modern atau primitif",
     },
     {
-        word: 'udik',
-        category: 'insult',
-        region: 'general',
+        word: "udik",
+        category: "insult",
+        region: "general",
         severity: 0.5,
-        aliases: ['udhik', 'udek'],
-        description: 'Kata yang mengacu pada ketidaksopanan atau kenaifan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak modern atau primitif',
+        aliases: ["udhik", "udek"],
+        description: "Kata yang mengacu pada ketidaksopanan atau kenaifan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak modern atau primitif",
     },
     {
-        word: 'dongo',
-        category: 'insult',
-        region: 'general',
+        word: "dongo",
+        category: "insult",
+        region: "general",
         severity: 0.5,
-        aliases: ['donggo', 'dungu'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["donggo", "dungu"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
     {
-        word: 'tolol',
-        category: 'insult',
-        region: 'general',
+        word: "tolol",
+        category: "insult",
+        region: "general",
         severity: 0.6,
-        aliases: ['tol0l', 'tollo', 'tlol'],
-        description: 'Kata yang mengacu pada kebodohan seseorang',
-        context: 'Hinaan untuk menyebut orang yang dianggap tidak pintar',
+        aliases: ["tol0l", "tollo", "tlol"],
+        description: "Kata yang mengacu pada kebodohan seseorang",
+        context: "Hinaan untuk menyebut orang yang dianggap tidak pintar",
     },
     {
-        word: 'brengsek',
-        category: 'insult',
-        region: 'general',
+        word: "brengsek",
+        category: "insult",
+        region: "general",
         severity: 0.7,
-        aliases: ['brengskek', 'brengsik', 'brengzek'],
-        description: 'Kata yang mengacu pada kelakuan buruk atau tidak bermoral',
-        context: 'Hinaan untuk menyebut orang yang dianggap memiliki kelakuan buruk',
+        aliases: ["brengskek", "brengsik", "brengzek"],
+        description: "Kata yang mengacu pada kelakuan buruk atau tidak bermoral",
+        context: "Hinaan untuk menyebut orang yang dianggap memiliki kelakuan buruk",
     },
 ];
 insult.map((item) => item.word);
 
 const batak = [
     {
-        word: 'sundel',
-        category: 'sexual',
-        region: 'batak',
+        word: "sundel",
+        category: "sexual",
+        region: "batak",
         severity: 0.8,
-        aliases: ['sundal'],
-        description: 'Kata kasar untuk menyebut pekerja seks komersial',
-        context: 'Hinaan kasar untuk wanita',
+        aliases: ["sundal"],
+        description: "Kata kasar untuk menyebut pekerja seks komersial",
+        context: "Hinaan kasar untuk wanita",
     },
 ];
 batak.map((item) => item.word);
@@ -489,10 +489,651 @@ wordObjects
     .filter((word) => word.severity >= 0.8)
     .map((item) => item.word);
 
+/**
+ * Menyensor kata dengan karakter pengganti
+ *
+ * @param word Kata yang akan disensor
+ * @param replaceChar Karakter pengganti (default: '*')
+ * @param keepFirstAndLast Apakah harus menyimpan huruf pertama dan terakhir
+ * @returns Kata yang telah disensor
+ */
+function censorWord(word, replaceChar = "*", keepFirstAndLast = false) {
+    if (word.length <= 2) {
+        return replaceChar.repeat(word.length);
+    }
+    if (keepFirstAndLast) {
+        return `${word[0]}${replaceChar.repeat(word.length - 2)}${word[word.length - 1]}`;
+    }
+    return replaceChar.repeat(word.length);
+}
+/**
+ * Menormalisasi string untuk keperluan pembandingan
+ *
+ * @param text Teks yang akan dinormalisasi
+ * @returns Teks yang telah dinormalisasi
+ */
+function normalizeText(text) {
+    return text
+        .toLowerCase()
+        .normalize("NFD") // Normalisasi Unicode
+        .replace(/[\u0300-\u036f]/g, "") // Hapus diacritic marks
+        .replace(/[^\w\s]/g, "") // Hapus karakter non-alphanumeric
+        .trim(); // Hapus whitespace di awal dan akhir
+}
+/**
+ * Mendeteksi apakah string berisi sebagian atau keseluruhan kata dalam wordList
+ *
+ * @param text Teks yang akan diperiksa
+ * @param wordList Daftar kata yang dicari
+ * @param checkSubstring Apakah harus memeriksa substring
+ * @returns Boolean apakah teks mengandung kata-kata dalam wordList
+ */
+function containsAnyWord(text, wordList, checkSubstring = false) {
+    const normalizedText = normalizeText(text);
+    return wordList.some((word) => {
+        const normalizedWord = normalizeText(word);
+        return checkSubstring
+            ? normalizedText.includes(normalizedWord)
+            : new RegExp(`\\b${escapeRegExp(normalizedWord)}\\b`, "i").test(normalizedText);
+    });
+}
+/**
+ * Memerikasa apakah stirng merupakan kode untuk kata kotor
+ * (Menangkap kasus seperti disensor dengan titik atau garis: a**ing, b*bi, dll)
+ *
+ * @param text Teks yang akan diperika
+ * @param wordList daftar kata kotor
+ * @return Boolean apakah teks mengandung kata kotor
+ */
+function containsEuphemism(text, wordList) {
+    return wordList.some((word) => {
+        if (word.length <= 2)
+            return false;
+        const firstChar = word[0];
+        const lastChar = word[word.length - 1];
+        const pattern = new RegExp(`\\b${escapeRegExp(firstChar)}[*@#\\-_.!?\\s]{${word.length - 2}}${escapeRegExp(lastChar)}\\b`, "i");
+        return pattern.test(text);
+    });
+}
+/**
+ * Mendeteksi upaya menghindari filter dengan pemisahan kata
+ * (Tangkap kasus seperti: a n j i n g, b-a-b-i, dll)
+ *
+ * @param text Teks yang akan diperiksa
+ * @param wordList Daftar kata kotor
+ * @returns Boolean apakah teks mengandung upaya menghindari filter
+ */
+function detectSplitWords(text, wordList) {
+    const compressedText = text.replace(/[\s\-_.!?*]/g, "").toLowerCase();
+    return wordList.some((word) => compressedText.includes(normalizeText(word)));
+}
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Mengganti sebagian kata dengan masking
+ * (berguna untuk email, nomor telepon, dll)
+ *
+ * @param text Teks untuk dimasking
+ * @param visibleStart Jumlah karakter yang terlihat di awal
+ * @param visibleEnd Jumlah karakter yang terlihat di akhir
+ * @param maskChar Karakter masking
+ * @returns Teks yang telah dimasking
+ */
+function maskText(text, visibleStart = 1, visibleEnd = 1, maskChar = "*") {
+    if (!text)
+        return "";
+    if (text.length <= visibleStart + visibleEnd)
+        return text;
+    const start = text.substring(0, visibleStart);
+    const middle = maskChar.repeat(text.length - visibleStart - visibleEnd);
+    const end = text.substring(text.length - visibleEnd);
+    return start + middle + end;
+}
+/**
+ * menguabh sting menjadi bentuk leet speak
+ * (untuk testing filter bypass)
+ *
+ * @param text Teks yang akan diubah
+ * @return Teks yang telah diubah ke leet speak
+ */
+function toLeetSpeak(text) {
+    const leetMap = {
+        a: ["4", "@"],
+        b: ["8", "6"],
+        c: ["<", "(", "{"],
+        e: ["3"],
+        g: ["9"],
+        i: ["1", "!"],
+        l: ["1", "|"],
+        o: ["0"],
+        s: ["5", "$"],
+        t: ["7", "+"],
+        z: ["2"],
+    };
+    return text
+        .split("")
+        .map((char) => {
+        const lowerChar = char.toLowerCase();
+        return leetMap[lowerChar] || char;
+    })
+        .join("");
+}
+/**
+ * memisahkan teks menajdi kelimat
+ *
+ * @param text Teks yang akan dipisahkan
+ * @return Array kalimat yang telah dipisahkan
+ */
+function splitIntoSentences(text) {
+    // split berdasarkan titik, seru, taya yagn diikuti spasi atau akhir string
+    return text
+        .split(/(?<=[.!?])\s+|(?<=[.!?])$/)
+        .filter((sentence) => sentence.trim().length > 0);
+}
+/**
+ * mengambil kata-kata di sekitar indeks tertentu
+ *
+ * @param text Teks yang akan diambil
+ * @param index Indeks dalam teks
+ * @param windowSize jumlah kata di sekitar indeks
+ * @return Kata-kata di sekitar indeks
+ */
+function getContextAroundIndex(text, index, windowSize = 5) {
+    if (!text || index < 0 || index >= text.length)
+        return "";
+    const words = text.split(/\s+/);
+    let currentPosition = 0;
+    let targetWordIndex = -1;
+    for (let i = 0; i < words.length; i++) {
+        const wordLength = words[i].length;
+        if (index >= currentPosition && index < currentPosition + wordLength) {
+            targetWordIndex = i;
+            break;
+        }
+        // Tambahkan panjang kata dan spasi
+        currentPosition += wordLength + 1;
+    }
+    if (targetWordIndex === -1)
+        return "";
+    // Ambil kata-kata di sekitar
+    const startIndex = Math.max(0, targetWordIndex - windowSize);
+    const endIndex = Math.min(words.length, targetWordIndex + windowSize + 1);
+    return words.slice(startIndex, endIndex).join(" ");
+}
+
+/**
+ * Membuat pola regex untuk mencocokkan kata
+ *
+ * @param word Kata yang akan dibuat pola regex-nya
+ * @param options Opsi untuk pembuatan regex
+ * @returns Objek RegExp
+ */
+function createWordRegex(word, options = {}) {
+    const { wholeWord = true, caseSensitive = false, leetSpeak = true, detectSplit = false, indonesianVariation = false, } = options;
+    // Escape karakter khusus regex
+    let pattern = escapeRegExp(word);
+    // Tambahkan variasi leet speak jika diminta
+    if (leetSpeak) {
+        pattern = addLeetSpeakVariations(pattern);
+    }
+    // Tambahkan variasi ejaan Bahasa Indonesia jika diminta
+    if (indonesianVariation) {
+        pattern = addIndonesianVariations(pattern);
+    }
+    // Tambahkan kemungkinan split jika diminta
+    if (detectSplit) {
+        pattern = addSplitVariations(pattern);
+    }
+    // Tambahkan boundary untuk whole word jika diminta
+    if (wholeWord) {
+        pattern = `\\b${pattern}\\b`;
+    }
+    // Buat regex dengan flag case-insensitive jika diminta
+    return new RegExp(pattern, caseSensitive ? "g" : "gi");
+}
+/**
+ * Menambahkan variasi leet speak ke pola regex
+ *
+ * Contoh:
+ * - 'a' bisa jadi '4', '@'
+ * - 'i' bisa jadi '1', '!'
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan variasi leet speak
+ */
+function addLeetSpeakVariations(pattern) {
+    const leetMap = {
+        a: ["a", "4", "@"],
+        b: ["b", "8", "6"],
+        c: ["c", "(", "{", "<"],
+        e: ["e", "3"],
+        g: ["g", "6", "9"],
+        i: ["i", "1", "!", "|"],
+        l: ["l", "1", "|"],
+        o: ["o", "0"],
+        s: ["s", "5", "$"],
+        t: ["t", "7", "+"],
+        z: ["z", "2"],
+    };
+    // Ganti tiap karakter dengan variasinya dalam grup character class
+    return pattern
+        .split("")
+        .map((char) => {
+        const lowerChar = char.toLowerCase();
+        const variations = leetMap[lowerChar];
+        if (variations && variations.length > 1) {
+            return `[${variations.join("")}]`;
+        }
+        return char;
+    })
+        .join("");
+}
+/**
+ * Menambahkan kemungkinan split/pemisahan antar karakter
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan kemungkinan split
+ */
+function addSplitVariations(pattern) {
+    // Tambahkan kemungkinan spasi atau karakter penghubung di antara setiap huruf
+    return pattern.split("").join("[\\s\\-._*+]?");
+}
+/**
+ * Membuat regex untuk mencari kata dengan variasi spasi dan karakter penghubung
+ * Berguna untuk mendeteksi upaya menghindari filter dengan menambahkan spasi atau karakter lain
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @returns Objek RegExp
+ */
+function createEvasionRegex(word) {
+    // Tambahkan kemungkinan spasi atau karakter penghubung di antara setiap huruf
+    const pattern = addSplitVariations(escapeRegExp(word));
+    return new RegExp(pattern, "gi");
+}
+/**
+ * Menambahkan variasi ejaan Bahasa Indonesia
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan variasi ejaan Bahasa Indonesia
+ */
+function addIndonesianVariations(pattern) {
+    // Variasi ejaan dalam Bahasa Indonesia
+    const variationMap = {
+        c: ["c", "k"], // contoh: becok/bekok
+        k: ["k", "c", "q"], // contoh: kacau/qacau
+        j: ["j", "dj"], // contoh: jualan/djualan (ejaan lama)
+        y: ["y", "j"], // contoh: ya/ja
+        u: ["u", "oe"], // contoh: untuk/oentoek (ejaan lama)
+        f: ["f", "p", "v"], // contoh: kafir/kapir
+        z: ["z", "j", "s"], // contoh: zaman/jaman
+        x: ["x", "ks"], // contoh: taxi/taksi
+    };
+    // Ganti tiap karakter dengan variasinya
+    return pattern
+        .split("")
+        .map((char) => {
+        const lowerChar = char.toLowerCase();
+        const variations = variationMap[lowerChar];
+        if (variations && variations.length > 1) {
+            return `[${variations.join("")}]`;
+        }
+        return char;
+    })
+        .join("");
+}
+/**
+ * Membuat regex untuk mencocokkan kata dengan mempertimbangkan variasi ejaan Bahasa Indonesia
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @returns Objek RegExp
+ */
+function createIndonesianVariationRegex(word) {
+    const pattern = addIndonesianVariations(escapeRegExp(word));
+    return new RegExp(`\\b${pattern}\\b`, "gi");
+}
+/**
+ * Membuat regex untuk mencocokkan kata dengan konteks
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @param contextSize Jumlah kata konteks sebelum dan sesudah
+ * @returns Objek RegExp
+ */
+function createContextRegex(word, contextSize = 3) {
+    const wordPattern = escapeRegExp(word);
+    // Membuat pola yang menangkap beberapa kata sebelum dan setelah kata target
+    const pattern = `((?:\\S+\\s+){0,${contextSize}})(\\b${wordPattern}\\b)((?:\\s+\\S+){0,${contextSize}})`;
+    return new RegExp(pattern, "gi");
+}
+/**
+ * Membuat regex untuk mencocokkan variasi penulisan kata
+ *
+ * @param word Kata dasar
+ * @returns Objek RegExp untuk mencocokkan berbagai bentuk kata
+ */
+function createWordFormRegex(word) {
+    // Implementasi sederhana untuk mencocokkan berbagai imbuhan
+    // Ini bisa dikembangkan lebih lanjut untuk mencocokkan bentukan kata yang lebih kompleks
+    const prefixes = ["", "me", "pe", "ber", "di", "ter", "se"];
+    const suffixes = ["", "kan", "an", "i", "nya"];
+    const patterns = [];
+    // Kombinasikan prefix dan suffix
+    for (const prefix of prefixes) {
+        for (const suffix of suffixes) {
+            patterns.push(`\\b${prefix}${escapeRegExp(word)}${suffix}\\b`);
+        }
+    }
+    return new RegExp(patterns.join("|"), "gi");
+}
+
+/**
+ * Menghitung jarak Levenshtein antara dua string
+ * (Jumlah operasi insert, delete, atau replace untuk mengubah string1 menjadi string2)
+ *
+ * @param str1 String pertama
+ * @param str2 String kedua
+ * @returns Jarak Levenshtein
+ */
+function levenshteinDistance(str1, str2) {
+    const s1 = str1.toLowerCase();
+    const s2 = str2.toLowerCase();
+    const len1 = s1.length;
+    const len2 = s2.length;
+    // Inisialisasi matrix
+    const matrix = [];
+    // Inisialisasi baris pertama
+    for (let i = 0; i <= len2; i++) {
+        matrix[0] = matrix[0] || [];
+        matrix[0][i] = i;
+    }
+    // Inisialisasi kolom pertama
+    for (let i = 0; i <= len1; i++) {
+        matrix[i] = matrix[i] || [];
+        matrix[i][0] = i;
+    }
+    // Isi matrix
+    for (let i = 1; i <= len1; i++) {
+        for (let j = 1; j <= len2; j++) {
+            const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+            matrix[i][j] = Math.min(matrix[i - 1][j] + 1, // deletion
+            matrix[i][j - 1] + 1, // insertion
+            matrix[i - 1][j - 1] + cost);
+        }
+    }
+    return matrix[len1][len2];
+}
+/**
+ * Menghitung tingkat kesamaan antara dua string
+ *
+ * @param str1 String pertama
+ * @param str2 String kedua
+ * @returns Nilai kesamaan (0-1, di mana 1 berarti identik)
+ */
+function stringSimilarity(str1, str2) {
+    if (!str1.length && !str2.length)
+        return 1;
+    if (!str1.length || !str2.length)
+        return 0;
+    const distance = levenshteinDistance(str1, str2);
+    const maxLength = Math.max(str1.length, str2.length);
+    return 1 - distance / maxLength;
+}
+/**
+ * Mencari string yang paling mirip dari array
+ *
+ * @param target String target
+ * @param candidates Array string kandidat
+ * @param threshold Minimum kesamaan yang diterima (0-1)
+ * @returns String yang paling mirip atau null jika tidak ada yang di atas threshold
+ */
+function findMostSimilar(target, candidates, threshold = 0.7) {
+    if (!candidates.length)
+        return null;
+    let maxSimilarity = 0;
+    let mostSimilar = null;
+    for (const candidate of candidates) {
+        const similarity = stringSimilarity(target, candidate);
+        if (similarity > maxSimilarity && similarity >= threshold) {
+            maxSimilarity = similarity;
+            mostSimilar = candidate;
+        }
+    }
+    return mostSimilar;
+}
+/**
+ * Cek apakah string mungkin merupakan variasi dari kata kotor
+ * menggunakan kesamaan string
+ *
+ * @param input String yang akan diperiksa
+ * @param profanityWords Daftar kata kotor
+ * @param threshold Batas minimum kesamaan (default: 0.75)
+ * @returns Array [Boolean (apakah variasi), String original (jika ditemukan)]
+ */
+function isPossibleProfanityVariation(input, profanityWords, threshold = 0.75) {
+    if (!input || !profanityWords.length)
+        return [false, null];
+    for (const word of profanityWords) {
+        const similarity = stringSimilarity(input, word);
+        if (similarity >= threshold) {
+            return [true, word];
+        }
+    }
+    return [false, null];
+}
+/**
+ * Mengelompokkan kata berdasarkan kesamaan
+ *
+ * @param words Daftar kata
+ * @param threshold Batas minimum kesamaan (default: 0.8)
+ * @returns Array kluster kata yang mirip
+ */
+function clusterSimilarWords(words, threshold = 0.8) {
+    const clusters = [];
+    const processed = new Set();
+    for (const word of words) {
+        if (processed.has(word))
+            continue;
+        const cluster = [word];
+        processed.add(word);
+        for (const otherWord of words) {
+            if (word === otherWord || processed.has(otherWord))
+                continue;
+            const similarity = stringSimilarity(word, otherWord);
+            if (similarity >= threshold) {
+                cluster.push(otherWord);
+                processed.add(otherWord);
+            }
+        }
+        clusters.push(cluster);
+    }
+    return clusters;
+}
+/**
+ * Cari kata-kata kotor yang mungkin dari teks menggunakan kesamaan string
+ *
+ * @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
+ */
+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) {
+            const similarity = stringSimilarity(word, profanity);
+            if (similarity >= threshold) {
+                result.push({
+                    word,
+                    original: profanity,
+                    similarity,
+                });
+                break;
+            }
+        }
+    }
+    return result;
+}
+
+const DEFAULT_OPTIONS = {
+    replaceWith: "*",
+    fullWordCensor: true,
+    detectLeetSpeak: true,
+    checkSubstring: false,
+    whitelist: [],
+    severityThreshold: 0,
+};
+const FILTER_PRESETS = {
+    strict: {
+        ...DEFAULT_OPTIONS,
+        checkSubstring: true,
+        detectLeetSpeak: true,
+        severityThreshold: 0,
+    },
+    moderate: {
+        ...DEFAULT_OPTIONS,
+        severityThreshold: 0.5,
+    },
+    light: {
+        ...DEFAULT_OPTIONS,
+        severityThreshold: 0.7,
+        categories: ["sexual", "slur", "blasphemy"],
+    },
+    childSafe: {
+        ...DEFAULT_OPTIONS,
+        checkSubstring: true,
+        detectLeetSpeak: true,
+        fullWordCensor: true,
+        severityThreshold: 0,
+    },
+};
+const CATEGORY_PRESETS = {
+    sexual: {
+        ...DEFAULT_OPTIONS,
+        categories: ["sexual"],
+    },
+    insults: {
+        ...DEFAULT_OPTIONS,
+        categories: ["insult"],
+    },
+    profanity: {
+        ...DEFAULT_OPTIONS,
+        categories: ["profanity"],
+    },
+};
+const REGION_PRESETS = {
+    general: {
+        ...DEFAULT_OPTIONS,
+        regions: ["general"],
+    },
+    jawa: {
+        ...DEFAULT_OPTIONS,
+        regions: ["jawa"],
+    },
+    sunda: {
+        ...DEFAULT_OPTIONS,
+        regions: ["sunda"],
+    },
+    betawi: {
+        ...DEFAULT_OPTIONS,
+        regions: ["betawi"],
+    },
+    batak: {
+        ...DEFAULT_OPTIONS,
+        regions: ["batak"],
+    },
+};
+const REPLACEMENT_CHARS = {
+    asterisk: "*",
+    hash: "#",
+    dollar: "$",
+    at: "@",
+    percent: "%",
+    underscore: "_",
+    dash: "-",
+    dot: ".",
+    grawlix: "#@$%&!",
+};
+/**
+ * Membuat opsi custom dengan menggabungkan dengan default
+ *
+ * @param options Opsi yang akan digabungkan dengan default
+ * @returns Opsi yang sudah digabungkan
+ */
+function createOptions(options = {}) {
+    return {
+        ...DEFAULT_OPTIONS,
+        ...options,
+    };
+}
+/**
+ * Mendapatkan opsi dari preset yang ada
+ *
+ * @param presetName Nama preset filter, kategori, atau region
+ * @param additionalOptions Opsi tambahan untuk mengganti preset
+ * @returns Opsi yang sudah digabungkan
+ */
+function getPresetOptions(presetName, additionalOptions = {}) {
+    let presetOptions;
+    if (presetName in FILTER_PRESETS) {
+        presetOptions = FILTER_PRESETS[presetName];
+    }
+    else if (presetName in CATEGORY_PRESETS) {
+        presetOptions =
+            CATEGORY_PRESETS[presetName];
+    }
+    else if (presetName in REGION_PRESETS) {
+        presetOptions = REGION_PRESETS[presetName];
+    }
+    else {
+        presetOptions = FILTER_PRESETS.strict;
+    }
+    return {
+        ...presetOptions,
+        ...additionalOptions,
+    };
+}
+/**
+ * Mendapatkan karakter pengganti
+ *
+ * @param type Tipe karakter pengganti
+ * @returns Karakter pengganti
+ */
+function getReplacementChar(type = "asterisk") {
+    return REPLACEMENT_CHARS[type] || REPLACEMENT_CHARS.asterisk;
+}
+/**
+ * Membuat karakter pengganti random dari grawlix
+ *
+ * @returns Karakter pengganti random
+ */
+function getRandomGrawlix() {
+    const grawlix = REPLACEMENT_CHARS.grawlix;
+    return grawlix[Math.floor(Math.random() * grawlix.length)];
+}
+/**
+ * Membuat string pengganti untuk kata menggunakan grawlix random
+ *
+ * @param length Panjang string
+ * @returns String pengganti
+ */
+function makeRandomGrawlixString(length) {
+    let result = "";
+    const grawlix = REPLACEMENT_CHARS.grawlix;
+    for (let i = 0; i < length; i++) {
+        result += grawlix[Math.floor(Math.random() * grawlix.length)];
+    }
+    return result;
+}
+
 function findProfanity(text, options = {}) {
-    const { wordList = [], detectLeetSpeak = true, checkSubstring = false, whitelist = [], categories, regions, severityThreshold = 0, } = 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;
+    let wordsToCheck = wordList.length > 0 ? wordList : [];
     if (wordsToCheck.length === 0) {
         if (categories || regions || severityThreshold > 0) {
             wordsToCheck = wordObjects
@@ -516,99 +1157,68 @@ function findProfanity(text, options = {}) {
     }
     const matches = new Set();
     wordsToCheck.forEach((word) => {
-        const pattern = checkSubstring ? word : `\\b${escapeRegExp$2(word)}\\b`;
-        const regex = new RegExp(pattern, 'gi');
-        let match;
-        while ((match = regex.exec(normalizedText)) !== null) {
-            matches.add(match[0].toLowerCase());
+        const regex = createWordRegex(word, {
+            wholeWord: !checkSubstring,
+            caseSensitive: false,
+            leetSpeak: false,
+            detectSplit: false,
+            indonesianVariation: false,
+        });
+        while ((regex.exec(normalizedText)) !== null) {
+            matches.add(word.toLowerCase());
         }
     });
-    // jika detectLeetSpeak diaktifkan, cari variasi leet speak
     if (detectLeetSpeak) {
         wordsToCheck.forEach((word) => {
-            // Cek leet speak
-            const leetPattern = createLeetSpeakPattern(word);
-            const leetRegex = new RegExp(checkSubstring ? leetPattern : `\\b${leetPattern}\\b`, 'gi');
+            const leetRegex = createWordRegex(word, {
+                wholeWord: !checkSubstring,
+                caseSensitive: false,
+                leetSpeak: true,
+                detectSplit: false,
+                indonesianVariation: false,
+            });
             while ((leetRegex.exec(text)) !== null) {
                 matches.add(word.toLowerCase());
             }
-            // cek karakter yang dipisah
-            const evasionPattern = createEvasionPattern(word);
-            const evasionRegex = new RegExp(evasionPattern, 'gi');
-            while ((evasionRegex.exec(text)) !== null) {
+        });
+    }
+    if (indonesianVariation) {
+        wordsToCheck.forEach((word) => {
+            const variantRegex = createWordRegex(word, {
+                wholeWord: !checkSubstring,
+                caseSensitive: false,
+                leetSpeak: false,
+                detectSplit: false,
+                indonesianVariation: true,
+            });
+            while ((variantRegex.exec(text)) !== null) {
                 matches.add(word.toLowerCase());
             }
         });
     }
-    return Array.from(matches);
-}
-/**
- * Menormalisasi teks untuk perbandingan
- *
- * @param text Teks untuk dinormalisasi
- * @returns Teks yang dinormalisasi
- */
-function normalizeText(text) {
-    return text
-        .toLowerCase()
-        .normalize('NFD') // Normalisasi Unicode
-        .replace(/[\u0300-\u036f]/g, '') // Hapus diacritic marks
-        .trim();
-}
-/**
- * Escape karakter khusus dalam regex
- *
- * @param string String untuk di-escape
- * @returns String yang sudah di-escape
- */
-function escapeRegExp$2(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Pattern untuk leet speak
- *
- * @param word Kata untuk dibuat pattern leet speak
- * @return Pattern regex untuk leet speak
- */
-function createLeetSpeakPattern(word) {
-    const leetMap = {
-        a: ['a', '4', '@'],
-        b: ['b', '8', '6'],
-        c: ['c', '<', '(', '{'],
-        e: ['e', '3'],
-        g: ['g', '9'],
-        i: ['i', '1', '!'],
-        l: ['l', '1', '|'],
-        o: ['o', '0'],
-        s: ['s', '5', '$'],
-        t: ['t', '7', '+'],
-        z: ['z', '2'],
-    };
-    return word
-        .split('')
-        .map((char) => {
-        const lowerChar = char.toLowerCase();
-        const replacements = leetMap[lowerChar];
-        if (replacements && replacements.length > 0) {
-            return `[${replacements.join('')}]`;
-        }
-        else {
-            return escapeRegExp$2(char);
+    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());
+                }
+            });
         }
-    })
-        .join('');
-}
-/**
- * Pattern untuk deteksi upaya menghindari filter
- *
- * @param word Kata untuk dibuat pattern evasion
- * @return Pattern regex untuk evasion
- */
-function createEvasionPattern(word) {
-    return word
-        .split('')
-        .map((char) => escapeRegExp$2(char))
-        .join('[\\s\\-._*+]?');
+    }
+    if (detectSimilarity) {
+        const possibleProfanity = findPossibleProfanityBySimiliarity(text, wordsToCheck, similarityThreshold);
+        possibleProfanity.forEach((item) => {
+            matches.add(item.original.toLowerCase());
+        });
+    }
+    return Array.from(matches);
 }
 /**
  * Mencari kata kotor lengkap dengan metadata
@@ -634,8 +1244,8 @@ function findProfanityWithMetadata(text, options = {}) {
 /**
  * Mencari kategory kata kotor yang ada dalam teks
  *
- * @param text matchDetails Hasil pencarian dari fingProfanityWithMetadata()
- * @param options Opsi untuk pencarian kategori
+ * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @return Array kategori unik
  */
 function findCategories(matchDetails) {
     const categories = new Set();
@@ -647,8 +1257,8 @@ function findCategories(matchDetails) {
 /**
  * Mencari region kata kotor yang ada dalam teks
  *
- * @param text matchDetails Hasil pencarian dari fingProfanityWithMetadata()
- * @param options Opsi untuk pencarian region
+ * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @return Array region unik
  */
 function findRegions(matchDetails) {
     const regions = new Set();
@@ -697,12 +1307,13 @@ function calculateSeverity(matchDetails) {
  * @returns FilterResult dengan hasil filter
  */
 function filter(text, options = {}) {
-    const { replaceWith = '*', fullWordCensor = true, detectLeetSpeak = true, whitelist = [], checkSubstring = false, } = options;
+    const { replaceWith = "*", fullWordCensor = true, detectLeetSpeak = true, whitelist = [], checkSubstring = false, useRandomGrawlix = false, keepFirstAndLast = false, indonesianVariation = false, } = { ...DEFAULT_OPTIONS, ...options };
     const matches = findProfanity(text, {
         ...options,
         detectLeetSpeak,
         whitelist,
         checkSubstring,
+        indonesianVariation,
     });
     const matchDetails = findProfanityWithMetadata(text, options);
     if (matches.length === 0) {
@@ -718,26 +1329,36 @@ 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 = new RegExp(`\\b${escapeRegExp$1(word)}\\b`, 'gi');
+        const regex = createWordRegex(word, {
+            wholeWord: true,
+            caseSensitive: false,
+            leetSpeak: false,
+            detectSplit: false,
+            indonesianVariation: false,
+        });
         let match;
-        while ((match = regex.exec(filteredText)) !== null) {
+        const textToSearch = filteredText;
+        regex.lastIndex = 0;
+        while ((match = regex.exec(textToSearch)) !== null) {
             const originalWord = match[0];
             if (whitelist.includes(originalWord.toLowerCase()))
                 continue;
-            const censoredWord = fullWordCensor
-                ? replaceWith.repeat(originalWord.length)
-                : censorPartialWord(originalWord, replaceWith);
+            let censoredWord;
+            if (useRandomGrawlix) {
+                censoredWord = makeRandomGrawlixString(originalWord.length);
+            }
+            else {
+                censoredWord = censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
+            }
             replacements.push({
                 original: originalWord,
                 censored: censoredWord,
                 metadata,
             });
-            const replaceRegex = new RegExp(`\\b${escapeRegExp$1(originalWord)}\\b`, 'g');
+            const replaceRegex = new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, "g");
             filteredText = filteredText.replace(replaceRegex, censoredWord);
         }
     });
-    // if (detectLeetSpeak) {
-    // }
     return {
         filtered: filteredText,
         censored: replacements.length,
@@ -755,28 +1376,6 @@ function isProfane(text, options = {}) {
     const matches = findProfanity(text, options);
     return matches.length > 0;
 }
-/**
- * Escape karakter khusus regex
- *
- * @param string String untuk di-escape
- * @returns String yang telah di-escape
- */
-function escapeRegExp$1(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/**
- * Menyensor sebagian kata
- * @param word Kata yang akan disensor
- * @param replaceChar Karakter pengganti
- * @returns Kata yang sudah disensor sebagian
- */
-function censorPartialWord(word, replaceChar) {
-    if (word.length <= 2) {
-        return replaceChar.repeat(word.length);
-    }
-    // Simpan huruf pertama dan terakhir, sensor yang lain
-    return word[0] + replaceChar.repeat(word.length - 2) + word[word.length - 1];
-}
 
 /**
  * Menganalisis teks untuk kata kotor
@@ -786,7 +1385,8 @@ function censorPartialWord(word, replaceChar) {
  * @return AnalysisResult dengan hasil analisis
  */
 function analyze(text, options = {}) {
-    const matches = findProfanity(text, options);
+    const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+    const matches = findProfanity(text, mergedOptions);
     if (matches.length === 0) {
         return {
             hasProfanity: false,
@@ -797,10 +1397,15 @@ function analyze(text, options = {}) {
             severityScore: 0,
         };
     }
-    const matchDetails = findProfanityWithMetadata(text, options);
+    const matchDetails = findProfanityWithMetadata(text, mergedOptions);
     const categories = findCategories(matchDetails);
     const regions = findRegions(matchDetails);
     const severityScore = calculateSeverity(matchDetails);
+    let similarWords = [];
+    if (mergedOptions.detectSimilarity) {
+        const wordList = matchDetails.map((word) => word.word);
+        similarWords = findPossibleProfanityBySimiliarity(text, wordList, mergedOptions.similarityThreshold || 0.8);
+    }
     return {
         hasProfanity: true,
         matches,
@@ -808,17 +1413,19 @@ function analyze(text, options = {}) {
         categories,
         regions,
         severityScore,
+        similarWords: mergedOptions.detectSimilarity ? similarWords : undefined,
     };
 }
 /**
- * menganalisis daftar teks dan ringkasan
+ * Menganalisis daftar teks dan ringkasan
  *
- * @param texts Daftar teks yagn dianalisis
+ * @param texts Daftar teks yang dianalisis
  * @param options Opsi untuk analisis
  * @return Objek dengan ringkasan analisis
  */
 function batchAnalyze(texts, options = {}) {
-    const results = texts.map((text) => analyze(text, options));
+    const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+    const results = texts.map((text) => analyze(text, mergedOptions));
     const profaneTexts = results.filter((result) => result.hasProfanity).length;
     const totalSeverity = results.reduce((sum, result) => sum + result.severityScore, 0);
     const averageSeverity = profaneTexts > 0 ? totalSeverity / profaneTexts : 0;
@@ -865,11 +1472,10 @@ function batchAnalyze(texts, options = {}) {
  * @returns Array hasil analisis per-kalimat
  */
 function analyzeBySentence(text, options = {}) {
-    const sentences = text
-        .split(/(?<=[.!?])\s+/)
-        .filter((sentence) => sentence.trim().length > 0);
+    const sentences = splitIntoSentences(text);
+    const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
     return sentences.map((sentence) => {
-        const result = analyze(sentence, options);
+        const result = analyze(sentence, mergedOptions);
         return {
             ...result,
             sentence,
@@ -880,23 +1486,24 @@ function analyzeBySentence(text, options = {}) {
  * Menganalisis teks untuk menemukan kata kotor pada konteks tertentu
  *
  * @param text Teks yang akan dianalisis
- * @param context Kata konteks untuk dicari di dekat kata kotor
+ * @param contextWindowSize Ukuran konteks (jumlah kata) di sekitar kata kotor
  * @param options Opsi untuk analisis
  * @returns Konteks di dekat kata kotor
  */
 function analyzeWithContext(text, contextWindowSize = 5, options = {}) {
-    const matches = findProfanity(text, options);
+    const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+    const matches = findProfanity(text, mergedOptions);
     if (matches.length === 0) {
         return [];
     }
     const result = [];
     for (const word of matches) {
-        const regex = new RegExp(`((?:\\S+\\s+){0,${contextWindowSize}})(\\b${escapeRegExp(word)}\\b)((?:\\s+\\S+){0,${contextWindowSize}})`, 'gi');
+        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,
@@ -909,9 +1516,6 @@ function analyzeWithContext(text, contextWindowSize = 5, options = {}) {
     }
     return result;
 }
-function escapeRegExp(string) {
-    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 
 class IDProfanityFilter {
     /**
@@ -919,7 +1523,7 @@ class IDProfanityFilter {
      * @param options Opsi untuk filter
      */
     constructor(options = {}) {
-        this.options = options;
+        this.options = { ...DEFAULT_OPTIONS, ...options };
     }
     /**
      * Menyensor teks yang diberikan
@@ -980,6 +1584,14 @@ class IDProfanityFilter {
             ...options,
         };
     }
+    /**
+     * Menggunakan preset yang telah ditentukan
+     * @param presetName Nama preset yang akan digunakan
+     * @param additionalOptions Opsi tambahan untuk override
+     */
+    usePreset(presetName, additionalOptions = {}) {
+        this.options = getPresetOptions(presetName, additionalOptions);
+    }
     /**
      * Menetapkan daftar kata kustom
      * @param wordList Daftar kata untuk digunakan
@@ -1006,26 +1618,86 @@ class IDProfanityFilter {
             return;
         this.options.whitelist = this.options.whitelist.filter((w) => w.toLowerCase() !== word.toLowerCase());
     }
+    /**
+     * Mengaktifkan deteksi variasi ejaan Indonesia
+     */
+    enableIndonesianVariations() {
+        this.options.indonesianVariation = true;
+    }
+    /**
+     * Mengaktifkan deteksi kata yang dipisah
+     */
+    enableSplitWordDetection() {
+        this.options.detectSplit = true;
+    }
+    /**
+     * Mengaktifkan deteksi berdasarkan kesamaan
+     * @param threshold Threshold kesamaan (0-1)
+     */
+    enableSimilarityDetection(threshold = 0.8) {
+        this.options.detectSimilarity = true;
+        this.options.similarityThreshold = threshold;
+    }
 }
 const idFilter = {
-    filter: (text, options) => filter(text, options),
-    isProfane: (text, options) => isProfane(text, options),
-    analyze: (text, options) => analyze(text, options),
-    batchAnalyze: (texts, options) => batchAnalyze(texts, options),
+    filter: (text, options) => filter(text, { ...DEFAULT_OPTIONS, ...options }),
+    isProfane: (text, options) => isProfane(text, { ...DEFAULT_OPTIONS, ...options }),
+    analyze: (text, options) => analyze(text, { ...DEFAULT_OPTIONS, ...options }),
+    batchAnalyze: (texts, options) => batchAnalyze(texts, { ...DEFAULT_OPTIONS, ...options }),
+    getPresetOptions,
+    presets: {
+        filter: FILTER_PRESETS,
+        category: CATEGORY_PRESETS,
+        region: REGION_PRESETS,
+    },
 };
 
+exports.CATEGORY_PRESETS = CATEGORY_PRESETS;
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.FILTER_PRESETS = FILTER_PRESETS;
 exports.IDProfanityFilter = IDProfanityFilter;
+exports.REGION_PRESETS = REGION_PRESETS;
+exports.REPLACEMENT_CHARS = REPLACEMENT_CHARS;
+exports.addIndonesianVariations = addIndonesianVariations;
+exports.addLeetSpeakVariations = addLeetSpeakVariations;
+exports.addSplitVariations = addSplitVariations;
 exports.analyze = analyze;
 exports.analyzeBySentence = analyzeBySentence;
 exports.analyzeWithContext = analyzeWithContext;
 exports.batchAnalyze = batchAnalyze;
 exports.calculateSeverity = calculateSeverity;
+exports.censorWord = censorWord;
+exports.clusterSimilarWords = clusterSimilarWords;
+exports.containsAnyWord = containsAnyWord;
+exports.containsEuphemism = containsEuphemism;
+exports.createContextRegex = createContextRegex;
+exports.createEvasionRegex = createEvasionRegex;
+exports.createIndonesianVariationRegex = createIndonesianVariationRegex;
+exports.createOptions = createOptions;
+exports.createWordFormRegex = createWordFormRegex;
+exports.createWordRegex = createWordRegex;
 exports.default = IDProfanityFilter;
+exports.detectSplitWords = detectSplitWords;
+exports.escapeRegExp = escapeRegExp;
 exports.filter = filter;
 exports.findCategories = findCategories;
+exports.findMostSimilar = findMostSimilar;
+exports.findPossibleProfanityBySimiliarity = findPossibleProfanityBySimiliarity;
 exports.findProfanity = findProfanity;
 exports.findProfanityWithMetadata = findProfanityWithMetadata;
 exports.findRegions = findRegions;
+exports.getContextAroundIndex = getContextAroundIndex;
+exports.getPresetOptions = getPresetOptions;
+exports.getRandomGrawlix = getRandomGrawlix;
+exports.getReplacementChar = getReplacementChar;
 exports.idFilter = idFilter;
+exports.isPossibleProfanityVariation = isPossibleProfanityVariation;
 exports.isProfane = isProfane;
+exports.levenshteinDistance = levenshteinDistance;
+exports.makeRandomGrawlixString = makeRandomGrawlixString;
+exports.maskText = maskText;
+exports.normalizeText = normalizeText;
+exports.splitIntoSentences = splitIntoSentences;
+exports.stringSimilarity = stringSimilarity;
+exports.toLeetSpeak = toLeetSpeak;
 //# sourceMappingURL=index.js.map