@sideid/id-profanity-filter 1.11.7 → 1.11.8

package/src/utils/regexUtils.ts

@@ -1,5 +1,5 @@
-import { escapeRegExp } from "./stringUtils";
-import { RegexOptions } from "../types";
+import { escapeRegExp } from './stringUtils';
+import { RegexOptions } from '../types';
 
 /**
  * Membuat pola regex untuk mencocokkan kata
@@ -8,10 +8,7 @@ import { RegexOptions } from "../types";
  * @param options Opsi untuk pembuatan regex
  * @returns Objek RegExp
  */
-export function createWordRegex(
-  word: string,
-  options: RegexOptions = {},
-): RegExp {
+export function createWordRegex(word: string, options: RegexOptions = {}): RegExp {
   const {
     wholeWord = true,
     caseSensitive = false,
@@ -44,7 +41,7 @@ export function createWordRegex(
   }
 
   // Buat regex dengan flag case-insensitive jika diminta
-  return new RegExp(pattern, caseSensitive ? "g" : "gi");
+  return new RegExp(pattern, caseSensitive ? 'g' : 'gi');
 }
 
 /**
@@ -59,32 +56,32 @@ export function createWordRegex(
  */
 export function addLeetSpeakVariations(pattern: string): string {
   const leetMap: Record<string, string[]> = {
-    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"],
+    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'],
   };
 
   return pattern
-    .split("")
+    .split('')
     .map((char) => {
       const lowerChar = char.toLowerCase();
       const variations = leetMap[lowerChar];
 
       if (variations && variations.length > 1) {
-        return `[${variations.join("")}]`;
+        return `[${variations.join('')}]`;
       }
 
       return char;
     })
-    .join("");
+    .join('');
 }
 
 /**
@@ -95,7 +92,7 @@ export function addLeetSpeakVariations(pattern: string): string {
  */
 export function addSplitVariations(pattern: string): string {
   // Tambahkan kemungkinan spasi atau karakter penghubung di antara setiap huruf
-  return pattern.split("").join("[\\s\\-._*+]?");
+  return pattern.split('').join('[\\s\\-._*+]?');
 }
 
 /**
@@ -109,7 +106,7 @@ export function createEvasionRegex(word: string): RegExp {
   // Tambahkan kemungkinan spasi atau karakter penghubung di antara setiap huruf
   const pattern = addSplitVariations(escapeRegExp(word));
 
-  return new RegExp(pattern, "gi");
+  return new RegExp(pattern, 'gi');
 }
 
 /**
@@ -121,30 +118,30 @@ export function createEvasionRegex(word: string): RegExp {
 export function addIndonesianVariations(pattern: string): string {
   // Variasi ejaan dalam Bahasa Indonesia
   const variationMap: Record<string, string[]> = {
-    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
+    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("")
+    .split('')
     .map((char) => {
       const lowerChar = char.toLowerCase();
       const variations = variationMap[lowerChar];
 
       if (variations && variations.length > 1) {
-        return `[${variations.join("")}]`;
+        return `[${variations.join('')}]`;
       }
 
       return char;
     })
-    .join("");
+    .join('');
 }
 
 /**
@@ -155,7 +152,7 @@ export function addIndonesianVariations(pattern: string): string {
  */
 export function createIndonesianVariationRegex(word: string): RegExp {
   const pattern = addIndonesianVariations(escapeRegExp(word));
-  return new RegExp(`\\b${pattern}\\b`, "gi");
+  return new RegExp(`\\b${pattern}\\b`, 'gi');
 }
 
 /**
@@ -165,16 +162,13 @@ export function createIndonesianVariationRegex(word: string): RegExp {
  * @param contextSize Jumlah kata konteks sebelum dan sesudah
  * @returns Objek RegExp
  */
-export function createContextRegex(
-  word: string,
-  contextSize: number = 3,
-): RegExp {
+export function createContextRegex(word: string, contextSize: number = 3): RegExp {
   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");
+  return new RegExp(pattern, 'gi');
 }
 
 /**
@@ -186,8 +180,8 @@ export function createContextRegex(
 export function createWordFormRegex(word: string): RegExp {
   // 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 prefixes = ['', 'me', 'pe', 'ber', 'di', 'ter', 'se'];
+  const suffixes = ['', 'kan', 'an', 'i', 'nya'];
 
   const patterns = [];
 
@@ -198,5 +192,5 @@ export function createWordFormRegex(word: string): RegExp {
     }
   }
 
-  return new RegExp(patterns.join("|"), "gi");
+  return new RegExp(patterns.join('|'), 'gi');
 }

package/src/utils/similarityUtils.ts

@@ -36,7 +36,7 @@ export function levenshteinDistance(str1: string, str2: string): number {
       matrix[i][j] = Math.min(
         matrix[i - 1][j] + 1, // deletion
         matrix[i][j - 1] + 1, // insertion
-        matrix[i - 1][j - 1] + cost, // substitution
+        matrix[i - 1][j - 1] + cost // substitution
       );
     }
   }
@@ -72,7 +72,7 @@ export function stringSimilarity(str1: string, str2: string): number {
 export function findMostSimilar(
   target: string,
   candidates: string[],
-  threshold: number = 0.7,
+  threshold: number = 0.7
 ): string | null {
   if (!candidates.length) return null;
 
@@ -104,7 +104,7 @@ export function findMostSimilarWithLevenshtein(
   target: string,
   candidates: string[],
   threshold: number = 0.7,
-  maxDistance: number = 3,
+  maxDistance: number = 3
 ): string | null {
   if (!candidates.length) return null;
 
@@ -145,7 +145,7 @@ export function findMostSimilarWithLevenshtein(
 export function isPossibleProfanityVariation(
   input: string,
   profanityWords: string[],
-  threshold: number = 0.75,
+  threshold: number = 0.75
 ): [boolean, string | null] {
   if (!input || !profanityWords.length) return [false, null];
 
@@ -167,10 +167,7 @@ export function isPossibleProfanityVariation(
  * @param threshold Batas minimum kesamaan (default: 0.8)
  * @returns Array kluster kata yang mirip
  */
-export function clusterSimilarWords(
-  words: string[],
-  threshold: number = 0.8,
-): string[][] {
+export function clusterSimilarWords(words: string[], threshold: number = 0.8): string[][] {
   const clusters: string[][] = [];
   const processed: Set<string> = new Set();
 
@@ -217,10 +214,9 @@ export function clusterSimilarWords(
 export function findPossibleProfanityBySimiliarity(
   text: string,
   profanityWords: string[],
-  threshold: number = 0.8,
+  threshold: number = 0.8
 ): Array<{ word: string; original: string; similarity: number }> {
-  const result: Array<{ word: string; original: string; similarity: number }> =
-    [];
+  const result: Array<{ word: string; original: string; similarity: number }> = [];
 
   // Optimasi dengan bikin map kata-kata kotor berdasarkan huruf pertama
   const profanityMap = new Map<string, string[]>();
@@ -262,7 +258,7 @@ export function findPossibleProfanityBySimiliarity(
 
     // Filter kandidat berdasarkan perbedaan panjang sebelum ngitung kemiripannya
     const lengthFilteredCandidates = allCandidates.filter(
-      (candidate) => Math.abs(candidate.length - word.length) <= 2,
+      (candidate) => Math.abs(candidate.length - word.length) <= 2
     );
 
     // Cari yang paling cocok
@@ -275,10 +271,7 @@ export function findPossibleProfanityBySimiliarity(
     for (const profanity of lengthFilteredCandidates) {
       const similarity = stringSimilarity(word, profanity);
 
-      if (
-        similarity >= threshold &&
-        (!bestMatch || similarity > bestMatch.similarity)
-      ) {
+      if (similarity >= threshold && (!bestMatch || similarity > bestMatch.similarity)) {
         bestMatch = {
           word,
           original: profanity,
@@ -308,7 +301,7 @@ export function findProfanityByLevenshteinDistance(
   text: string,
   profanityWords: string[],
   threshold: number = 0.8,
-  maxDistance: number = 2,
+  maxDistance: number = 2
 ): Array<{
   word: string;
   original: string;
@@ -361,13 +354,9 @@ export function findProfanityByLevenshteinDistance(
         const distance = levenshteinDistance(word, profanity);
 
         if (distance <= maxDistance) {
-          const similarity =
-            1 - distance / Math.max(word.length, profanity.length);
+          const similarity = 1 - distance / Math.max(word.length, profanity.length);
 
-          if (
-            similarity >= threshold &&
-            (!bestMatch || similarity > bestMatch.similarity)
-          ) {
+          if (similarity >= threshold && (!bestMatch || similarity > bestMatch.similarity)) {
             bestMatch = {
               word,
               original: profanity,
@@ -395,11 +384,7 @@ export function findProfanityByLevenshteinDistance(
  * Helper function to efficiently check if character counts between two strings
  * are similar enough to warrant a full Levenshtein calculation
  */
-function isCharacterCountSimilar(
-  str1: string,
-  str2: string,
-  maxDifference: number,
-): boolean {
+function isCharacterCountSimilar(str1: string, str2: string, maxDifference: number): boolean {
   const charCount1: Record<string, number> = {};
   const charCount2: Record<string, number> = {};
 

package/src/utils/stringUtils.ts

@@ -8,8 +8,8 @@
  */
 export function censorWord(
   word: string,
-  replaceChar: string = "*",
-  keepFirstAndLast: boolean = false,
+  replaceChar: string = '*',
+  keepFirstAndLast: boolean = false
 ): string {
   if (word.length <= 2) {
     return replaceChar.repeat(word.length);
@@ -31,9 +31,9 @@ export function censorWord(
 export function normalizeText(text: string): string {
   return text
     .toLowerCase()
-    .normalize("NFD") // Normalisasi Unicode
-    .replace(/[\u0300-\u036f]/g, "") // Hapus diacritic marks
-    .replace(/[^\w\s]/g, "") // Hapus karakter non-alphanumeric
+    .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
 }
 
@@ -48,7 +48,7 @@ export function normalizeText(text: string): string {
 export function containsAnyWord(
   text: string,
   wordList: string[],
-  checkSubstring: boolean = false,
+  checkSubstring: boolean = false
 ): boolean {
   const normalizedText = normalizeText(text);
 
@@ -56,9 +56,7 @@ export function containsAnyWord(
     const normalizedWord = normalizeText(word);
     return checkSubstring
       ? normalizedText.includes(normalizedWord)
-      : new RegExp(`\\b${escapeRegExp(normalizedWord)}\\b`, "i").test(
-          normalizedText,
-        );
+      : new RegExp(`\\b${escapeRegExp(normalizedWord)}\\b`, 'i').test(normalizedText);
   });
 }
 
@@ -78,7 +76,7 @@ export function containsEuphemism(text: string, wordList: string[]): boolean {
     const lastChar = word[word.length - 1];
     const pattern = new RegExp(
       `\\b${escapeRegExp(firstChar)}[*@#\\-_.!?\\s]{${word.length - 2}}${escapeRegExp(lastChar)}\\b`,
-      "i",
+      'i'
     );
 
     return pattern.test(text);
@@ -94,13 +92,13 @@ export function containsEuphemism(text: string, wordList: string[]): boolean {
  * @returns Boolean apakah teks mengandung upaya menghindari filter
  */
 export function detectSplitWords(text: string, wordList: string[]): boolean {
-  const compressedText = text.replace(/[\s\-_.!?*]/g, "").toLowerCase();
+  const compressedText = text.replace(/[\s\-_.!?*]/g, '').toLowerCase();
 
   return wordList.some((word) => compressedText.includes(normalizeText(word)));
 }
 
 export function escapeRegExp(string: string): string {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
 
 /**
@@ -117,9 +115,9 @@ export function maskText(
   text: string,
   visibleStart: number = 1,
   visibleEnd: number = 1,
-  maskChar: string = "*",
+  maskChar: string = '*'
 ): string {
-  if (!text) return "";
+  if (!text) return '';
   if (text.length <= visibleStart + visibleEnd) return text;
 
   const start = text.substring(0, visibleStart);
@@ -138,26 +136,26 @@ export function maskText(
  */
 export function toLeetSpeak(text: string): string {
   const leetMap: Record<string, string[]> = {
-    a: ["4", "@"],
-    b: ["8", "6"],
-    c: ["<", "(", "{"],
-    e: ["3"],
-    g: ["9"],
-    i: ["1", "!"],
-    l: ["1", "|"],
-    o: ["0"],
-    s: ["5", "$"],
-    t: ["7", "+"],
-    z: ["2"],
+    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("")
+    .split('')
     .map((char) => {
       const lowerChar = char.toLowerCase();
       return leetMap[lowerChar] || char;
     })
-    .join("");
+    .join('');
 }
 
 /**
@@ -168,9 +166,7 @@ export function toLeetSpeak(text: string): string {
  */
 export function splitIntoSentences(text: string): string[] {
   // split berdasarkan titik, seru, taya yagn diikuti spasi atau akhir string
-  return text
-    .split(/(?<=[.!?])\s+|(?<=[.!?])$/)
-    .filter((sentence) => sentence.trim().length > 0);
+  return text.split(/(?<=[.!?])\s+|(?<=[.!?])$/).filter((sentence) => sentence.trim().length > 0);
 }
 
 /**
@@ -181,12 +177,8 @@ export function splitIntoSentences(text: string): string[] {
  * @param windowSize jumlah kata di sekitar indeks
  * @return Kata-kata di sekitar indeks
  */
-export function getContextAroundIndex(
-  text: string,
-  index: number,
-  windowSize: number = 5,
-): string {
-  if (!text || index < 0 || index >= text.length) return "";
+export function getContextAroundIndex(text: string, index: number, windowSize: number = 5): string {
+  if (!text || index < 0 || index >= text.length) return '';
 
   const words = text.split(/\s+/);
 
@@ -203,11 +195,11 @@ export function getContextAroundIndex(
     currentPosition += wordLength + 1;
   }
 
-  if (targetWordIndex === -1) return "";
+  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(" ");
+  return words.slice(startIndex, endIndex).join(' ');
 }