@sideid/id-profanity-filter 1.11.11 → 1.11.13

package/dist/index.esm.js

@@ -2373,14 +2373,14 @@ function addLeetSpeakVariations(pattern) {
     const leetMap = {
         a: ['a', '4', '@'],
         b: ['b', '8', '6'],
-        c: ['c', '(', '{', '<'],
+        c: ['c', '\\(', '\\{', '<'],
         e: ['e', '3'],
         g: ['g', '6', '9'],
-        i: ['i', '1', '!', '|'],
-        l: ['l', '1', '|'],
+        i: ['i', '1', '!', '\\|'],
+        l: ['l', '1', '\\|'],
         o: ['o', '0'],
-        s: ['s', '5', '$'],
-        t: ['t', '7', '+'],
+        s: ['s', '5', '\\$'],
+        t: ['t', '7', '\\+'],
         z: ['z', '2'],
     };
     return pattern
@@ -2402,8 +2402,20 @@ function addLeetSpeakVariations(pattern) {
  * @returns Pola regex dengan kemungkinan split
  */
 function addSplitVariations(pattern) {
-    // Tambahkan kemungkinan spasi atau karakter penghubung di antara setiap huruf
-    return pattern.split('').join('[\\s\\-._*+]?');
+    // Instead of joining character by character with a separator pattern,
+    // we'll create a simpler version that matches the pattern with optional separators
+    // Convert each character to a pattern that allows optional separators before it
+    // except for the first character
+    let result = '';
+    const chars = pattern.split('');
+    for (let i = 0; i < chars.length; i++) {
+        if (i > 0) {
+            // Add optional separator before each character except the first
+            result += '[\\s\\-._*+]?';
+        }
+        result += chars[i];
+    }
+    return result;
 }
 /**
  * Membuat regex untuk mencari kata dengan variasi spasi dan karakter penghubung
@@ -2413,9 +2425,20 @@ function addSplitVariations(pattern) {
  * @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');
+    // Escape karakter khusus regex
+    const escaped = escapeRegExp(word);
+    // Create a regex pattern that allows any separator between characters
+    let result = '';
+    const chars = escaped.split('');
+    for (let i = 0; i < chars.length; i++) {
+        // Add the character
+        result += chars[i];
+        // Add optional separator after each character except the last
+        if (i < chars.length - 1) {
+            result += '[\\s\\-._*+]?';
+        }
+    }
+    return new RegExp(result, 'gi');
 }
 /**
  * Menambahkan variasi ejaan Bahasa Indonesia
@@ -2428,25 +2451,27 @@ function addIndonesianVariations(pattern) {
     const variationMap = {
         c: ['c', 'k'], // contoh: becok/bekok
         k: ['k', 'c', 'q'], // contoh: kacau/qacau
-        j: ['j', 'dj'], // contoh: jualan/djualan (ejaan lama)
+        j: ['j', 'd'], // contoh: jualan/dualan (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) => {
+    // Go through each character in the pattern and replace with variations
+    let result = '';
+    for (const char of pattern) {
         const lowerChar = char.toLowerCase();
         const variations = variationMap[lowerChar];
         if (variations && variations.length > 1) {
-            return `[${variations.join('')}]`;
+            // Create a character class with all variations
+            result += `[${variations.join('')}]`;
         }
-        return char;
-    })
-        .join('');
+        else {
+            result += char;
+        }
+    }
+    return result;
 }
 /**
  * Membuat regex untuk mencocokkan kata dengan mempertimbangkan variasi ejaan Bahasa Indonesia
@@ -2455,7 +2480,8 @@ function addIndonesianVariations(pattern) {
  * @returns Objek RegExp
  */
 function createIndonesianVariationRegex(word) {
-    const pattern = addIndonesianVariations(escapeRegExp(word));
+    const escapedWord = escapeRegExp(word);
+    const pattern = addIndonesianVariations(escapedWord);
     return new RegExp(`\\b${pattern}\\b`, 'gi');
 }
 /**
@@ -2479,16 +2505,33 @@ function createContextRegex(word, contextSize = 3) {
  */
 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 escapedWord = escapeRegExp(word);
+    // Common Indonesian prefixes and suffixes
+    const prefixes = [
+        '',
+        'me',
+        'pe',
+        'ber',
+        'di',
+        'ter',
+        'se',
+        'ke',
+        'mem',
+        'pem',
+        'bel',
+        'peng',
+        'meng',
+    ];
+    const suffixes = ['', 'kan', 'an', 'i', 'nya', 'lah', 'kah'];
     const patterns = [];
-    // Kombinasikan prefix dan suffix
     for (const prefix of prefixes) {
         for (const suffix of suffixes) {
-            patterns.push(`\\b${prefix}${escapeRegExp(word)}${suffix}\\b`);
+            patterns.push(`\\b${prefix}${escapedWord}${suffix}\\b`);
         }
     }
+    if (/^[aiueo]/.test(word)) {
+        patterns.push(`\\bng${escapedWord}\\b`);
+    }
     return new RegExp(patterns.join('|'), 'gi');
 }
 
@@ -3100,8 +3143,13 @@ function initializeAhoCorasick(words) {
     globalAhoCorasick.build();
     ahoCorasickInitialized = true;
 }
+function getWordMetadata(word) {
+    return wordObjects.find((obj) => obj.word.toLowerCase() === word.toLowerCase() ||
+        (obj.aliases && obj.aliases.some((alias) => alias.toLowerCase() === word.toLowerCase())));
+}
 function findProfanity(text, options = {}) {
     const { wordList = [], detectLeetSpeak = true, checkSubstring = false, whitelist = [], categories, regions, severityThreshold = 0, indonesianVariation = false, detectSimilarity = false, similarityThreshold = 0.8, detectSplit = false, useLevenshtein = false, maxLevenshteinDistance = 2, } = { ...DEFAULT_OPTIONS, ...options };
+    const normalizedWhitelist = whitelist.map((w) => w.toLowerCase());
     const normalizedText = normalizeText(text);
     let baseWordsToCheck = wordList.length > 0 ? wordList : [];
     if (baseWordsToCheck.length === 0) {
@@ -3115,27 +3163,44 @@ function findProfanity(text, options = {}) {
     }
     const aliasMap = new Map();
     wordObjects.forEach((wordObj) => {
-        if (wordObj.aliases && wordObj.aliases.length > 0) {
-            const matchCategory = categories ? categories.includes(wordObj.category) : true;
-            const matchRegion = regions ? regions.includes(wordObj.region) : true;
-            const matchSeverity = wordObj.severity >= severityThreshold;
-            if (matchCategory && matchRegion && matchSeverity) {
-                wordObj.aliases.forEach((alias) => {
-                    aliasMap.set(alias.toLowerCase(), wordObj.word.toLowerCase());
-                });
-            }
+        const matchCategory = categories ? categories.includes(wordObj.category) : true;
+        const matchRegion = regions ? regions.includes(wordObj.region) : true;
+        const matchSeverity = wordObj.severity >= severityThreshold;
+        if (matchCategory &&
+            matchRegion &&
+            matchSeverity &&
+            wordObj.aliases &&
+            wordObj.aliases.length > 0) {
+            wordObj.aliases.forEach((alias) => {
+                aliasMap.set(alias.toLowerCase(), wordObj.word.toLowerCase());
+            });
         }
     });
-    const wordsToCheck = [...baseWordsToCheck, ...Array.from(aliasMap.keys())].filter((word) => !whitelist.includes(word.toLowerCase()));
+    const wordsToCheck = [...baseWordsToCheck, ...Array.from(aliasMap.keys())].filter((word) => !normalizedWhitelist.includes(word.toLowerCase()));
     if (wordsToCheck.length === 0) {
         return [];
     }
     const matches = new Set();
     const actualMatches = new Map();
+    const passesFilters = (word) => {
+        if (normalizedWhitelist.includes(word.toLowerCase()))
+            return false;
+        const metadata = getWordMetadata(word);
+        if (!metadata)
+            return false;
+        const matchCategory = categories ? categories.includes(metadata.category) : true;
+        const matchRegion = regions ? regions.includes(metadata.region) : true;
+        const matchSeverity = metadata.severity >= severityThreshold;
+        return matchCategory && matchRegion && matchSeverity;
+    };
     initializeAhoCorasick(wordsToCheck);
     const basicMatches = globalAhoCorasick.searchUnique(normalizedText);
     for (const match of basicMatches) {
+        if (normalizedWhitelist.includes(match.toLowerCase()))
+            continue;
         const originalWord = aliasMap.get(match.toLowerCase()) || match.toLowerCase();
+        if (!passesFilters(originalWord))
+            continue;
         matches.add(originalWord);
         if (!actualMatches.has(originalWord)) {
             actualMatches.set(originalWord, []);
@@ -3153,7 +3218,12 @@ function findProfanity(text, options = {}) {
             });
             let match;
             while ((match = leetRegex.exec(text)) !== null) {
+                const matchedText = match[0];
+                if (normalizedWhitelist.includes(matchedText.toLowerCase()))
+                    continue;
                 const originalWord = aliasMap.get(word.toLowerCase()) || word.toLowerCase();
+                if (!passesFilters(originalWord))
+                    continue;
                 matches.add(originalWord);
                 if (!actualMatches.has(originalWord)) {
                     actualMatches.set(originalWord, []);
@@ -3173,7 +3243,12 @@ function findProfanity(text, options = {}) {
             });
             let match;
             while ((match = variantRegex.exec(text)) !== null) {
+                const matchedText = match[0];
+                if (normalizedWhitelist.includes(matchedText.toLowerCase()))
+                    continue;
                 const originalWord = aliasMap.get(word.toLowerCase()) || word.toLowerCase();
+                if (!passesFilters(originalWord))
+                    continue;
                 matches.add(originalWord);
                 if (!actualMatches.has(originalWord)) {
                     actualMatches.set(originalWord, []);
@@ -3193,7 +3268,12 @@ function findProfanity(text, options = {}) {
             });
             let match;
             while ((match = splitRegex.exec(text)) !== null) {
+                const matchedText = match[0];
+                if (normalizedWhitelist.includes(matchedText.toLowerCase()))
+                    continue;
                 const originalWord = aliasMap.get(word.toLowerCase()) || word.toLowerCase();
+                if (!passesFilters(originalWord))
+                    continue;
                 matches.add(originalWord);
                 if (!actualMatches.has(originalWord)) {
                     actualMatches.set(originalWord, []);
@@ -3206,7 +3286,11 @@ function findProfanity(text, options = {}) {
         if (useLevenshtein) {
             const possibleProfanity = findProfanityByLevenshteinDistance(text, wordsToCheck, similarityThreshold, maxLevenshteinDistance);
             possibleProfanity.forEach((item) => {
+                if (normalizedWhitelist.includes(item.word.toLowerCase()))
+                    return;
                 const originalWord = aliasMap.get(item.original.toLowerCase()) || item.original.toLowerCase();
+                if (!passesFilters(originalWord))
+                    return;
                 matches.add(originalWord);
                 if (!actualMatches.has(originalWord)) {
                     actualMatches.set(originalWord, []);
@@ -3217,8 +3301,12 @@ function findProfanity(text, options = {}) {
         else {
             const possibleProfanity = findPossibleProfanityBySimiliarity(text, wordsToCheck, similarityThreshold);
             possibleProfanity.forEach((item) => {
-                matches.add(item.original.toLowerCase());
+                if (normalizedWhitelist.includes(item.word.toLowerCase()))
+                    return;
                 const originalWord = aliasMap.get(item.original.toLowerCase()) || item.original.toLowerCase();
+                if (!passesFilters(originalWord))
+                    return;
+                matches.add(originalWord);
                 if (!actualMatches.has(originalWord)) {
                     actualMatches.set(originalWord, []);
                 }
@@ -3302,8 +3390,6 @@ function calculateSeverity(matchDetails) {
         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;
 }
 
@@ -3482,6 +3568,9 @@ function isProfane(text, options = {}) {
  */
 function analyze(text, options = {}) {
     const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+    if (mergedOptions.whitelist) {
+        mergedOptions.whitelist = mergedOptions.whitelist.map((w) => w.toLowerCase());
+    }
     const matches = findProfanity(text, mergedOptions);
     if (matches.length === 0) {
         return {