@sideid/id-profanity-filter 0.1.0

package/dist/index.js

@@ -0,0 +1,1031 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const 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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+];
+general.map((item) => item.word);
+
+const 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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        word: 'sempak',
+        category: 'disgusting',
+        region: 'jawa',
+        severity: 0.5,
+        aliases: ['sempok'],
+        description: 'Mengacu pada pakaian dalam',
+        context: 'Umpatan ringan yang dianggap jorok',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+];
+jawa.map((item) => item.word);
+
+const 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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+];
+sunda.map((item) => item.word);
+
+const betawi = [
+    {
+        word: 'jablay',
+        category: 'sexual',
+        region: 'betawi',
+        severity: 0.7,
+        aliases: ['jabl4y', 'jalay'],
+        description: 'Singkatan dari "jarang dibelai", istilah untuk perempuan yang mudah didekati',
+        context: 'Hinaan yang merendahkan untuk wanita',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+];
+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'),
+    {
+        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: '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',
+    },
+    {
+        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',
+    },
+];
+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'),
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+    {
+        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',
+    },
+];
+insult.map((item) => item.word);
+
+const 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',
+    },
+];
+batak.map((item) => item.word);
+
+const wordObjects = [
+    ...general,
+    ...jawa,
+    ...sunda,
+    ...betawi,
+    ...batak,
+    // ...minang,
+    // ...bali,
+    // ...madura,
+    // ...bugis,
+    // ...aceh,
+    // ...ambon,
+    // ...papua,
+    // ...manado,
+    // ...banjar,
+    // ...palembang,
+    // ...lampung,
+    // ...ntt,
+    // ...ntb,
+];
+wordObjects.map((item) => item.word);
+/**
+ * Kata-kata dengan tingkat keparahan tinggi (subset dari semua kata)
+ */
+wordObjects
+    .filter((word) => word.severity >= 0.8)
+    .map((item) => item.word);
+
+function findProfanity(text, options = {}) {
+    const { wordList = [], detectLeetSpeak = true, checkSubstring = false, whitelist = [], categories, regions, severityThreshold = 0, } = options;
+    const normalizedText = normalizeText(text);
+    let wordsToCheck = wordList;
+    if (wordsToCheck.length === 0) {
+        if (categories || regions || severityThreshold > 0) {
+            wordsToCheck = wordObjects
+                .filter((word) => {
+                const matchCategory = categories
+                    ? categories.includes(word.category)
+                    : true;
+                const matchRegion = regions ? regions.includes(word.region) : true;
+                const matchSeverity = word.severity >= severityThreshold;
+                return matchCategory && matchRegion && matchSeverity;
+            })
+                .map((word) => word.word);
+        }
+        else {
+            wordsToCheck = wordObjects.map((word) => word.word);
+        }
+    }
+    wordsToCheck = wordsToCheck.filter((word) => !whitelist.includes(word.toLocaleLowerCase()));
+    if (wordsToCheck.length === 0) {
+        return [];
+    }
+    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());
+        }
+    });
+    // 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');
+            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) {
+                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);
+        }
+    })
+        .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\\-._*+]?');
+}
+/**
+ * Mencari kata kotor lengkap dengan metadata
+ *
+ * @param text Teks yang akan diperika
+ * @param options Opsi utnuk pencarian kata kotor
+ * @return Array dari objek kata kotor yang ditemukan
+ */
+function findProfanityWithMetadata(text, options = {}) {
+    const matches = findProfanity(text, options);
+    if (matches.length === 0) {
+        return [];
+    }
+    return matches
+        .map((word) => {
+        const wordObject = wordObjects.find((obj) => obj.word.toLowerCase() === word.toLowerCase() ||
+            (obj.aliases &&
+                obj.aliases.some((alias) => alias.toLowerCase() === word.toLowerCase())));
+        return wordObject;
+    })
+        .filter((word) => word !== undefined);
+}
+/**
+ * Mencari kategory kata kotor yang ada dalam teks
+ *
+ * @param text matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @param options Opsi untuk pencarian kategori
+ */
+function findCategories(matchDetails) {
+    const categories = new Set();
+    matchDetails.forEach((word) => {
+        categories.add(word.category);
+    });
+    return Array.from(categories);
+}
+/**
+ * Mencari region kata kotor yang ada dalam teks
+ *
+ * @param text matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @param options Opsi untuk pencarian region
+ */
+function findRegions(matchDetails) {
+    const regions = new Set();
+    matchDetails.forEach((word) => {
+        regions.add(word.region);
+    });
+    return Array.from(regions);
+}
+/**
+ * Menghitung tingkat keparahan kata kotor yang ditemukan
+ *
+ * @param matchDetails Hasil pencarian dari findProfanityWithMetadata()
+ * @return Skor keparahan dari 0-1
+ */
+function calculateSeverity(matchDetails) {
+    if (matchDetails.length === 0) {
+        return 0;
+    }
+    const countFactor = Math.min(matchDetails.length / 10, 1); // Maksimal 10 kata
+    const categoryWeights = {
+        sexual: 0.9,
+        blasphemy: 0.9,
+        slur: 0.8,
+        profanity: 0.7,
+        insult: 0.6,
+        drugs: 0.5,
+        disgusting: 0.5,
+    };
+    let severitySum = 0;
+    matchDetails.forEach((word) => {
+        const categoryWeight = categoryWeights[word.category] || 0.5;
+        const wordSeverity = word.severity * categoryWeight;
+        severitySum += wordSeverity;
+    });
+    const severityAvg = severitySum / matchDetails.length;
+    // Gabungkan jumlah kata dan keparahan rata-rata
+    // 70% keparahan kata + 30% faktor jumlah
+    return 0.7 * severityAvg + 0.3 * countFactor;
+}
+
+/**
+ * Menyensor kata kotor dalam teks
+ *
+ * @param text Teks yang akan disensor
+ * @param options Opsi untuk filter
+ * @returns FilterResult dengan hasil filter
+ */
+function filter(text, options = {}) {
+    const { replaceWith = '*', fullWordCensor = true, detectLeetSpeak = true, whitelist = [], checkSubstring = false, } = options;
+    const matches = findProfanity(text, {
+        ...options,
+        detectLeetSpeak,
+        whitelist,
+        checkSubstring,
+    });
+    const matchDetails = findProfanityWithMetadata(text, options);
+    if (matches.length === 0) {
+        return {
+            filtered: text,
+            censored: 0,
+            replacements: [],
+        };
+    }
+    let filteredText = text;
+    const replacements = [];
+    matches.forEach((word) => {
+        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');
+        let match;
+        while ((match = regex.exec(filteredText)) !== null) {
+            const originalWord = match[0];
+            if (whitelist.includes(originalWord.toLowerCase()))
+                continue;
+            const censoredWord = fullWordCensor
+                ? replaceWith.repeat(originalWord.length)
+                : censorPartialWord(originalWord, replaceWith);
+            replacements.push({
+                original: originalWord,
+                censored: censoredWord,
+                metadata,
+            });
+            const replaceRegex = new RegExp(`\\b${escapeRegExp$1(originalWord)}\\b`, 'g');
+            filteredText = filteredText.replace(replaceRegex, censoredWord);
+        }
+    });
+    // if (detectLeetSpeak) {
+    // }
+    return {
+        filtered: filteredText,
+        censored: replacements.length,
+        replacements,
+    };
+}
+/**
+ * Memeriksa apakah teks mengandung kata kotor
+ *
+ * @param text Teks yang akan diperiksa
+ * @param options Opsi untuk pemeriksaan
+ * @returns Boolean apakah teks mengandung kata kotor
+ */
+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
+ *
+ * @param text Teks yang akan dianalisis
+ * @param options Opsi untuk analisis
+ * @return AnalysisResult dengan hasil analisis
+ */
+function analyze(text, options = {}) {
+    const matches = findProfanity(text, options);
+    if (matches.length === 0) {
+        return {
+            hasProfanity: false,
+            matches: [],
+            matchDetails: [],
+            categories: [],
+            regions: [],
+            severityScore: 0,
+        };
+    }
+    const matchDetails = findProfanityWithMetadata(text, options);
+    const categories = findCategories(matchDetails);
+    const regions = findRegions(matchDetails);
+    const severityScore = calculateSeverity(matchDetails);
+    return {
+        hasProfanity: true,
+        matches,
+        matchDetails,
+        categories,
+        regions,
+        severityScore,
+    };
+}
+/**
+ * menganalisis daftar teks dan ringkasan
+ *
+ * @param texts Daftar teks yagn dianalisis
+ * @param options Opsi untuk analisis
+ * @return Objek dengan ringkasan analisis
+ */
+function batchAnalyze(texts, options = {}) {
+    const results = texts.map((text) => analyze(text, options));
+    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;
+    const allCategories = results.flatMap((result) => result.categories);
+    const categoryCount = {};
+    allCategories.forEach((category) => {
+        categoryCount[category] = (categoryCount[category] || 0) + 1;
+    });
+    const topCategories = Object.entries(categoryCount)
+        .sort((a, b) => b[1] - a[1])
+        .map(([category]) => category);
+    const allRegions = results.flatMap((result) => result.regions);
+    const regionCount = {};
+    allRegions.forEach((region) => {
+        regionCount[region] = (regionCount[region] || 0) + 1;
+    });
+    const topRegions = Object.entries(regionCount)
+        .sort((a, b) => b[1] - a[1])
+        .map(([region]) => region);
+    const allWords = results.flatMap((result) => result.matches);
+    const wordCount = {};
+    allWords.forEach((word) => {
+        wordCount[word] = (wordCount[word] || 0) + 1;
+    });
+    const mostFrequentWords = Object.entries(wordCount)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([word, count]) => ({ word, count }));
+    return {
+        totalTexts: texts.length,
+        profaneTexts,
+        cleanTexts: texts.length - profaneTexts,
+        averageSeverity,
+        topCategories,
+        topRegions,
+        mostFrequentWords,
+    };
+}
+/**
+ * Menganalisis per-kalimat untuk melokalisasi kata kotor
+ *
+ * @param text Teks yang akan dianalisis per-kalimat
+ * @param options Opsi untuk analisis
+ * @returns Array hasil analisis per-kalimat
+ */
+function analyzeBySentence(text, options = {}) {
+    const sentences = text
+        .split(/(?<=[.!?])\s+/)
+        .filter((sentence) => sentence.trim().length > 0);
+    return sentences.map((sentence) => {
+        const result = analyze(sentence, options);
+        return {
+            ...result,
+            sentence,
+        };
+    });
+}
+/**
+ * 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 options Opsi untuk analisis
+ * @returns Konteks di dekat kata kotor
+ */
+function analyzeWithContext(text, contextWindowSize = 5, options = {}) {
+    const matches = findProfanity(text, options);
+    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');
+        let match;
+        while ((match = regex.exec(text)) !== null) {
+            const beforeContext = match[1] || '';
+            const wordMatch = match[2];
+            const afterContext = match[3] || '';
+            result.push({
+                word: wordMatch,
+                context: beforeContext + wordMatch + afterContext,
+                position: {
+                    start: match.index,
+                    end: match.index + match[0].length,
+                },
+            });
+        }
+    }
+    return result;
+}
+function escapeRegExp(string) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+class IDProfanityFilter {
+    /**
+     * Membuat instance filter baru
+     * @param options Opsi untuk filter
+     */
+    constructor(options = {}) {
+        this.options = options;
+    }
+    /**
+     * Menyensor teks yang diberikan
+     * @param text Teks yang akan disensor
+     * @returns Hasil filter
+     */
+    filter(text) {
+        return filter(text, this.options);
+    }
+    /**
+     * Memeriksa apakah teks mengandung kata kotor
+     * @param text Teks yang akan diperiksa
+     * @returns Boolean apakah teks mengandung kata kotor
+     */
+    isProfane(text) {
+        return isProfane(text, this.options);
+    }
+    /**
+     * Menganalisis teks untuk kata kotor
+     * @param text Teks yang akan dianalisis
+     * @returns Hasil analisis
+     */
+    analyze(text) {
+        return analyze(text, this.options);
+    }
+    /**
+     * Menganalisis batch teks untuk kata kotor
+     * @param texts Array dari teks yang akan dianalisis
+     * @returns Hasil analisis batch
+     */
+    batchAnalyze(texts) {
+        return batchAnalyze(texts, this.options);
+    }
+    /**
+     * Menganalisis teks per-kalimat
+     * @param text Teks yang akan dianalisis
+     * @returns Array hasil analisis per-kalimat
+     */
+    analyzeBySentence(text) {
+        return analyzeBySentence(text, this.options);
+    }
+    /**
+     * Menganalisis teks dengan konteks di sekitar kata kotor
+     * @param text Teks yang akan dianalisis
+     * @param contextWindowSize Jumlah kata konteks
+     * @returns Konteks di dekat kata kotor
+     */
+    analyzeWithContext(text, contextWindowSize = 5) {
+        return analyzeWithContext(text, contextWindowSize, this.options);
+    }
+    /**
+     * Mengubah opsi filter
+     * @param options Opsi baru untuk filter
+     */
+    setOptions(options) {
+        this.options = {
+            ...this.options,
+            ...options,
+        };
+    }
+    /**
+     * Menetapkan daftar kata kustom
+     * @param wordList Daftar kata untuk digunakan
+     */
+    setWordList(wordList) {
+        this.options.wordList = wordList;
+    }
+    /**
+     * Menambahkan kata ke whitelist
+     * @param word Kata yang akan diabaikan
+     */
+    addToWhitelist(word) {
+        this.options.whitelist = [
+            ...(this.options.whitelist || []),
+            word.toLowerCase(),
+        ];
+    }
+    /**
+     * Menghapus kata dari whitelist
+     * @param word Kata yang akan dihapus dari whitelist
+     */
+    removeFromWhitelist(word) {
+        if (!this.options.whitelist)
+            return;
+        this.options.whitelist = this.options.whitelist.filter((w) => w.toLowerCase() !== word.toLowerCase());
+    }
+}
+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),
+};
+
+exports.IDProfanityFilter = IDProfanityFilter;
+exports.analyze = analyze;
+exports.analyzeBySentence = analyzeBySentence;
+exports.analyzeWithContext = analyzeWithContext;
+exports.batchAnalyze = batchAnalyze;
+exports.calculateSeverity = calculateSeverity;
+exports.default = IDProfanityFilter;
+exports.filter = filter;
+exports.findCategories = findCategories;
+exports.findProfanity = findProfanity;
+exports.findProfanityWithMetadata = findProfanityWithMetadata;
+exports.findRegions = findRegions;
+exports.idFilter = idFilter;
+exports.isProfane = isProfane;
+//# sourceMappingURL=index.js.map