@sideid/id-profanity-filter 1.11.6 → 1.11.8

package/src/core/filter.ts

@@ -1,8 +1,8 @@
-import { FilterOptions, FilterResult, ProfanityWord } from "../types";
-import { findProfanity, findProfanityWithMetadata } from "./matcher";
-import { censorWord, escapeRegExp } from "../utils/stringUtils";
-import { createWordRegex } from "../utils/regexUtils";
-import { DEFAULT_OPTIONS, makeRandomGrawlixString } from "../config/options";
+import { FilterOptions, FilterResult, ProfanityWord } from '../types';
+import { findProfanity, findProfanityWithMetadata } from './matcher';
+import { censorWord, escapeRegExp } from '../utils/stringUtils';
+import { createWordRegex } from '../utils/regexUtils';
+import { DEFAULT_OPTIONS, makeRandomGrawlixString } from '../config/options';
 
 interface FindProfanityFunction {
   (text: string, options?: FilterOptions): string[];
@@ -16,12 +16,9 @@ interface FindProfanityFunction {
  * @param options Opsi untuk filter
  * @returns FilterResult dengan hasil filter
  */
-export function filter(
-  text: string,
-  options: FilterOptions = {},
-): FilterResult {
+export function filter(text: string, options: FilterOptions = {}): FilterResult {
   const {
-    replaceWith = "*",
+    replaceWith = '*',
     fullWordCensor = true,
     detectLeetSpeak = true,
     whitelist = [],
@@ -74,10 +71,7 @@ export function filter(
     const metadata = matchDetails.find(
       (m) =>
         m.word.toLowerCase() === word.toLowerCase() ||
-        (m.aliases &&
-          m.aliases.some(
-            (alias) => alias.toLowerCase() === word.toLowerCase(),
-          )),
+        (m.aliases && m.aliases.some((alias) => alias.toLowerCase() === word.toLowerCase()))
     );
 
     const variants = actualMatches.get(word.toLowerCase()) || [];
@@ -86,7 +80,7 @@ export function filter(
     const uniqueVariants = [...new Set(variants)];
 
     uniqueVariants.forEach((variant) => {
-      const regex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, "gi");
+      const regex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, 'gi');
 
       let match;
       while ((match = regex.exec(filteredText)) !== null) {
@@ -98,11 +92,7 @@ export function filter(
         if (useRandomGrawlix) {
           censoredWord = makeRandomGrawlixString(originalWord.length);
         } else {
-          censoredWord = censorWord(
-            originalWord,
-            replaceWith,
-            !fullWordCensor && keepFirstAndLast,
-          );
+          censoredWord = censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
         }
 
         replacements.push({
@@ -112,8 +102,8 @@ export function filter(
         });
 
         filteredText = filteredText.replace(
-          new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, "g"),
-          censoredWord,
+          new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'),
+          censoredWord
         );
       }
     });
@@ -141,7 +131,7 @@ export function filter(
             censoredWord = censorWord(
               originalWord,
               replaceWith,
-              !fullWordCensor && keepFirstAndLast,
+              !fullWordCensor && keepFirstAndLast
             );
           }
 
@@ -152,8 +142,8 @@ export function filter(
           });
 
           filteredText = filteredText.replace(
-            new RegExp(escapeRegExp(originalWord), "g"),
-            censoredWord,
+            new RegExp(escapeRegExp(originalWord), 'g'),
+            censoredWord
           );
         }
       }
@@ -180,7 +170,7 @@ export function filter(
             censoredWord = censorWord(
               originalWord,
               replaceWith,
-              !fullWordCensor && keepFirstAndLast,
+              !fullWordCensor && keepFirstAndLast
             );
           }
 
@@ -191,8 +181,8 @@ export function filter(
           });
 
           filteredText = filteredText.replace(
-            new RegExp(escapeRegExp(originalWord), "g"),
-            censoredWord,
+            new RegExp(escapeRegExp(originalWord), 'g'),
+            censoredWord
           );
         }
       }
@@ -204,19 +194,13 @@ export function filter(
       const metadata = matchDetails.find(
         (m) =>
           m.word.toLowerCase() === word.toLowerCase() ||
-          (m.aliases &&
-            m.aliases.some(
-              (alias) => alias.toLowerCase() === word.toLowerCase(),
-            )),
+          (m.aliases && m.aliases.some((alias) => alias.toLowerCase() === word.toLowerCase()))
       );
 
       const variants = actualMatches.get(word.toLowerCase()) || [];
 
       variants.forEach((variant) => {
-        const exactVariantRegex = new RegExp(
-          `\\b${escapeRegExp(variant)}\\b`,
-          "gi",
-        );
+        const exactVariantRegex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, 'gi');
 
         let match;
         while ((match = exactVariantRegex.exec(filteredText)) !== null) {
@@ -231,7 +215,7 @@ export function filter(
             censoredWord = censorWord(
               originalWord,
               replaceWith,
-              !fullWordCensor && keepFirstAndLast,
+              !fullWordCensor && keepFirstAndLast
             );
           }
 
@@ -242,8 +226,8 @@ export function filter(
           });
 
           filteredText = filteredText.replace(
-            new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, "g"),
-            censoredWord,
+            new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'),
+            censoredWord
           );
         }
       });

package/src/core/matcher.ts

@@ -1,19 +1,14 @@
-import {
-  ProfanityWord,
-  ProfanityCategory,
-  Region,
-  FilterOptions,
-} from "../types";
-
-import { wordObjects } from "../constants/wordList";
-import { normalizeText } from "../utils/stringUtils";
-import { createWordRegex } from "../utils/regexUtils";
+import { ProfanityWord, ProfanityCategory, Region, FilterOptions } from '../types';
+
+import { wordObjects } from '../constants/wordList';
+import { normalizeText } from '../utils/stringUtils';
+import { createWordRegex } from '../utils/regexUtils';
 import {
   findPossibleProfanityBySimiliarity,
   findProfanityByLevenshteinDistance,
-} from "../utils/similarityUtils";
-import { DEFAULT_OPTIONS } from "../config/options";
-import { AhoCorasick } from "../utils/ahoCorasick";
+} from '../utils/similarityUtils';
+import { DEFAULT_OPTIONS } from '../config/options';
+import { AhoCorasick } from '../utils/ahoCorasick';
 
 const globalAhoCorasick = new AhoCorasick();
 let ahoCorasickInitialized = false;
@@ -34,10 +29,7 @@ interface FindProfanityFunction {
   lastActualMatches?: Map<string, string[]>;
 }
 
-export function findProfanity(
-  text: string,
-  options: FilterOptions = {},
-): string[] {
+export function findProfanity(text: string, options: FilterOptions = {}): string[] {
   const {
     wordList = [],
     detectLeetSpeak = true,
@@ -60,9 +52,7 @@ export function findProfanity(
 
   if (baseWordsToCheck.length === 0) {
     const filteredWords = wordObjects.filter((word) => {
-      const matchCategory = categories
-        ? categories.includes(word.category)
-        : true;
+      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;
@@ -74,9 +64,7 @@ export function findProfanity(
   const aliasMap = new Map<string, string>();
   wordObjects.forEach((wordObj) => {
     if (wordObj.aliases && wordObj.aliases.length > 0) {
-      const matchCategory = categories
-        ? categories.includes(wordObj.category)
-        : true;
+      const matchCategory = categories ? categories.includes(wordObj.category) : true;
       const matchRegion = regions ? regions.includes(wordObj.region) : true;
       const matchSeverity = wordObj.severity >= severityThreshold;
 
@@ -88,10 +76,9 @@ export function findProfanity(
     }
   });
 
-  const wordsToCheck = [
-    ...baseWordsToCheck,
-    ...Array.from(aliasMap.keys()),
-  ].filter((word) => !whitelist.includes(word.toLowerCase()));
+  const wordsToCheck = [...baseWordsToCheck, ...Array.from(aliasMap.keys())].filter(
+    (word) => !whitelist.includes(word.toLowerCase())
+  );
 
   if (wordsToCheck.length === 0) {
     return [];
@@ -104,8 +91,7 @@ export function findProfanity(
 
   const basicMatches = globalAhoCorasick.searchUnique(normalizedText);
   for (const match of basicMatches) {
-    const originalWord =
-      aliasMap.get(match.toLowerCase()) || match.toLowerCase();
+    const originalWord = aliasMap.get(match.toLowerCase()) || match.toLowerCase();
     matches.add(originalWord);
 
     if (!actualMatches.has(originalWord)) {
@@ -126,8 +112,7 @@ export function findProfanity(
 
       let match;
       while ((match = leetRegex.exec(text)) !== null) {
-        const originalWord =
-          aliasMap.get(word.toLowerCase()) || word.toLowerCase();
+        const originalWord = aliasMap.get(word.toLowerCase()) || word.toLowerCase();
         matches.add(originalWord);
 
         if (!actualMatches.has(originalWord)) {
@@ -150,8 +135,7 @@ export function findProfanity(
 
       let match;
       while ((match = variantRegex.exec(text)) !== null) {
-        const originalWord =
-          aliasMap.get(word.toLowerCase()) || word.toLowerCase();
+        const originalWord = aliasMap.get(word.toLowerCase()) || word.toLowerCase();
         matches.add(originalWord);
 
         if (!actualMatches.has(originalWord)) {
@@ -174,8 +158,7 @@ export function findProfanity(
 
       let match;
       while ((match = splitRegex.exec(text)) !== null) {
-        const originalWord =
-          aliasMap.get(word.toLowerCase()) || word.toLowerCase();
+        const originalWord = aliasMap.get(word.toLowerCase()) || word.toLowerCase();
         matches.add(originalWord);
 
         if (!actualMatches.has(originalWord)) {
@@ -192,13 +175,12 @@ export function findProfanity(
         text,
         wordsToCheck,
         similarityThreshold,
-        maxLevenshteinDistance,
+        maxLevenshteinDistance
       );
 
       possibleProfanity.forEach((item) => {
         const originalWord =
-          aliasMap.get(item.original.toLowerCase()) ||
-          item.original.toLowerCase();
+          aliasMap.get(item.original.toLowerCase()) || item.original.toLowerCase();
         matches.add(originalWord);
 
         if (!actualMatches.has(originalWord)) {
@@ -210,15 +192,14 @@ export function findProfanity(
       const possibleProfanity = findPossibleProfanityBySimiliarity(
         text,
         wordsToCheck,
-        similarityThreshold,
+        similarityThreshold
       );
 
       possibleProfanity.forEach((item) => {
         matches.add(item.original.toLowerCase());
 
         const originalWord =
-          aliasMap.get(item.original.toLowerCase()) ||
-          item.original.toLowerCase();
+          aliasMap.get(item.original.toLowerCase()) || item.original.toLowerCase();
         if (!actualMatches.has(originalWord)) {
           actualMatches.set(originalWord, []);
         }
@@ -241,7 +222,7 @@ export function findProfanity(
  */
 export function findProfanityWithMetadata(
   text: string,
-  options: FilterOptions = {},
+  options: FilterOptions = {}
 ): ProfanityWord[] {
   const matches = findProfanity(text, options);
   if (matches.length === 0) {
@@ -253,10 +234,7 @@ export function findProfanityWithMetadata(
       const wordObject = wordObjects.find(
         (obj) =>
           obj.word.toLowerCase() === word.toLowerCase() ||
-          (obj.aliases &&
-            obj.aliases.some(
-              (alias) => alias.toLowerCase() === word.toLowerCase(),
-            )),
+          (obj.aliases && obj.aliases.some((alias) => alias.toLowerCase() === word.toLowerCase()))
       );
 
       return wordObject;
@@ -270,9 +248,7 @@ export function findProfanityWithMetadata(
  * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
  * @return Array kategori unik
  */
-export function findCategories(
-  matchDetails: ProfanityWord[],
-): ProfanityCategory[] {
+export function findCategories(matchDetails: ProfanityWord[]): ProfanityCategory[] {
   const categories = new Set<ProfanityCategory>();
 
   matchDetails.forEach((word) => {

package/src/index.ts

@@ -8,12 +8,7 @@ export * from './utils/similarityUtils';
 export * from './config/options';
 
 import { filter, isProfane } from './core/filter';
-import {
-  analyze,
-  batchAnalyze,
-  analyzeBySentence,
-  analyzeWithContext,
-} from './core/analyzer';
+import { analyze, batchAnalyze, analyzeBySentence, analyzeWithContext } from './core/analyzer';
 import { FilterOptions, FilterResult, AnalysisResult } from './types';
 import {
   DEFAULT_OPTIONS,
@@ -105,10 +100,7 @@ export class IDProfanityFilter {
    * @param presetName Nama preset yang akan digunakan
    * @param additionalOptions Opsi tambahan untuk override
    */
-  usePreset(
-    presetName: string,
-    additionalOptions: Partial<FilterOptions> = {},
-  ) {
+  usePreset(presetName: string, additionalOptions: Partial<FilterOptions> = {}) {
     this.options = getPresetOptions(presetName, additionalOptions);
   }
 
@@ -125,10 +117,7 @@ export class IDProfanityFilter {
    * @param word Kata yang akan diabaikan
    */
   addToWhitelist(word: string) {
-    this.options.whitelist = [
-      ...(this.options.whitelist || []),
-      word.toLowerCase(),
-    ];
+    this.options.whitelist = [...(this.options.whitelist || []), word.toLowerCase()];
   }
 
   /**
@@ -139,7 +128,7 @@ export class IDProfanityFilter {
     if (!this.options.whitelist) return;
 
     this.options.whitelist = this.options.whitelist.filter(
-      (w) => w.toLowerCase() !== word.toLowerCase(),
+      (w) => w.toLowerCase() !== word.toLowerCase()
     );
   }
 
@@ -166,7 +155,7 @@ export class IDProfanityFilter {
   enableSimilarityDetection(
     threshold: number = 0.8,
     useLevenshtein: boolean = false,
-    maxLevenshteinDistance: number = 2,
+    maxLevenshteinDistance: number = 2
   ) {
     this.options.detectSimilarity = true;
     this.options.similarityThreshold = threshold;

package/src/types/index.ts

@@ -1,31 +1,32 @@
 export type ProfanityCategory =
-  | "sexual"
-  | "insult"
-  | "profanity"
-  | "slur"
-  | "drugs"
-  | "disgusting"
-  | "blasphemy";
+  | 'sexual'
+  | 'insult'
+  | 'profanity'
+  | 'slur'
+  | 'drugs'
+  | 'disgusting'
+  | 'blasphemy';
 
 export type Region =
-  | "general"
-  | "jawa"
-  | "sunda"
-  | "betawi"
-  | "batak"
-  | "minang"
-  | "bali"
-  | "madura"
-  | "bugis"
-  | "aceh"
-  | "ambon"
-  | "papua"
-  | "manado"
-  | "banjar"
-  | "palembang"
-  | "lampung"
-  | "ntt"
-  | "ntb";
+  | 'general'
+  | 'jawa'
+  | 'sunda'
+  | 'betawi'
+  | 'batak'
+  | 'minang'
+  | 'bali'
+  | 'madura'
+  | 'bugis'
+  | 'aceh'
+  | 'ambon'
+  | 'papua'
+  | 'manado'
+  | 'banjar'
+  | 'palembang'
+  | 'lampung'
+  | 'ntt'
+  | 'mandailing'
+  | 'ntb';
 
 export interface ProfanityWord {
   word: string;

package/src/utils/ahoCorasick.ts

@@ -30,7 +30,7 @@ export class AhoCorasick {
    */
   addPattern(pattern: string): void {
     if (this.built) {
-      throw new Error("Cannot add patterns after the automaton is built");
+      throw new Error('Cannot add patterns after the automaton is built');
     }
 
     let node = this.root;

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');
 }