@sideid/id-profanity-filter 1.12.0 → 1.13.0

package/package.json

@@ -1,14 +1,21 @@
 {
   "name": "@sideid/id-profanity-filter",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "description": "Library filter kata kotor dalam Bahasa Indonesia",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.esm.js",
+      "require": "./dist/index.js"
+    }
+  },
   "scripts": {
     "build": "rollup -c",
     "test": "jest",
-    "lint": "eslint --ext .ts src/",
+    "lint": "eslint src/",
     "format": "prettier --write \"src/**/*.ts\""
   },
   "keywords": [

package/rollup.config.mjs

@@ -3,7 +3,11 @@ import commonjs from '@rollup/plugin-commonjs';
 import typescript from '@rollup/plugin-typescript';
 import json from '@rollup/plugin-json';
 import dts from 'rollup-plugin-dts';
-import pkg from './package.json' assert { type: 'json' };
+import { readFileSync } from 'node:fs';
+
+const pkg = JSON.parse(
+  readFileSync(new URL('./package.json', import.meta.url), 'utf-8')
+);
 
 export default [
   {

package/src/constants/categories/sexual.ts

@@ -79,7 +79,7 @@ export const sexual: ProfanityWord[] = [
     category: 'sexual',
     region: 'general',
     severity: 0.9,
-    aliases: ['ngew', 'we'],
+    aliases: ['ngew'],
     description: 'Istilah kasar untuk aktivitas seksual',
     context: 'Kata vulgar yang merujuk pada aktivitas seksual',
   },

package/src/constants/regions/general.ts

@@ -6,7 +6,7 @@ export const general: ProfanityWord[] = [
     category: 'profanity',
     region: 'general',
     severity: 0.7,
-    aliases: ['anjay', 'anjir', 'anying', 'njing', 'anj', 'anjg', 'ajg'],
+    aliases: ['anjay', 'anjir', 'anying', 'njing', 'anj', 'anjg', 'ajg', 'anjic', 'anjink'],
     description: 'Mengacu pada hewan anjing, digunakan sebagai umpatan',
     context: 'Umpatan umum untuk menunjukkan kemarahan atau ketidaksetujuan',
   },
@@ -115,7 +115,7 @@ export const general: ProfanityWord[] = [
     category: 'insult',
     region: 'general',
     severity: 0.5,
-    aliases: ['sialn', 'sl'],
+    aliases: ['sialn'],
     description: 'Kata yang mengacu pada orang yang membawa sial',
     context: 'Hinaan untuk menyebut orang yang dianggap membawa sial',
   },
@@ -178,7 +178,7 @@ export const general: ProfanityWord[] = [
     category: 'sexual',
     region: 'general',
     severity: 0.9,
-    aliases: ['ngew', 'we'],
+    aliases: ['ngew'],
     description: 'Istilah kasar untuk aktivitas seksual',
     context: 'Kata vulgar yang merujuk pada aktivitas seksual',
   },

package/src/constants/wordList.ts

@@ -15,16 +15,7 @@ import { batak, batakWords } from './regions/batak';
 import { minang, minangWords } from './regions/minang';
 import { bali, baliWords } from './regions/bali';
 import { madura, maduraWords } from './regions/madura';
-// import { bugis, bugisWords } from './regions/bugis';
 import { aceh, acehWords } from './regions/aceh';
-// import { ambon, ambonWords } from './regions/ambon';
-// import { papua, papuaWords } from './regions/papua';
-// import { manado, manadoWords } from './regions/manado';
-// import { banjar, banjarWords } from './regions/banjar';
-// import { palembang, palembangWords } from './regions/palembang';
-// import { lampung, lampungWords } from './regions/lampung';
-// import { ntt, nttWords } from './regions/ntt';
-// import { ntb, ntbWords } from './regions/ntb';
 
 export const wordCategories = {
   sexual: sexualWords,
@@ -45,16 +36,7 @@ export const wordRegions = {
   minang: minangWords,
   bali: baliWords,
   madura: maduraWords,
-  // bugis: bugisWords,
   aceh: acehWords,
-  // ambon: ambonWords,
-  // papua: papuaWords,
-  // manado: manadoWords,
-  // banjar: banjarWords,
-  // palembang: palembangWords,
-  // lampung: lampungWords,
-  // ntt: nttWords,
-  // ntb: ntbWords,
 };
 
 export const wordObjects: ProfanityWord[] = [
@@ -66,16 +48,7 @@ export const wordObjects: ProfanityWord[] = [
   ...minang,
   ...bali,
   ...madura,
-  // ...bugis,
   ...aceh,
-  // ...ambon,
-  // ...papua,
-  // ...manado,
-  // ...banjar,
-  // ...palembang,
-  // ...lampung,
-  // ...ntt,
-  // ...ntb,
 ];
 
 export const allWords: string[] = wordObjects.map((item) => item.word);

package/src/core/filter.ts

@@ -17,6 +17,7 @@ interface FindProfanityFunction {
  * @returns FilterResult dengan hasil filter
  */
 export function filter(text: string, options: FilterOptions = {}): FilterResult {
+  const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
   const {
     replaceWith = '*',
     fullWordCensor = true,
@@ -25,31 +26,10 @@ export function filter(text: string, options: FilterOptions = {}): FilterResult
     checkSubstring = false,
     useRandomGrawlix = false,
     keepFirstAndLast = false,
-    indonesianVariation = false,
     detectSplit = false,
-    detectSimilarity = false,
-    useLevenshtein = false,
-    maxLevenshteinDistance = 2,
-    similarityThreshold = 0.8,
-  } = { ...DEFAULT_OPTIONS, ...options };
-
-  const matches = findProfanity(text, {
-    ...options,
-    detectLeetSpeak,
-    whitelist,
-    checkSubstring,
-    indonesianVariation,
-    detectSplit,
-    detectSimilarity,
-    useLevenshtein,
-    maxLevenshteinDistance,
-    similarityThreshold,
-  });
+  } = mergedOptions;
 
-  const actualMatches: Map<string, string[]> =
-    (findProfanity as FindProfanityFunction).lastActualMatches || new Map();
-
-  const matchDetails = findProfanityWithMetadata(text, options);
+  const matches = findProfanity(text, mergedOptions);
 
   if (matches.length === 0) {
     return {
@@ -59,15 +39,42 @@ export function filter(text: string, options: FilterOptions = {}): FilterResult
     };
   }
 
-  let filteredText = text;
+  const actualMatches: Map<string, string[]> =
+    (findProfanity as FindProfanityFunction).lastActualMatches || new Map();
+  const matchDetails = findProfanityWithMetadata(text, mergedOptions);
+  const normalizedWhitelist = whitelist.map((w) => w.toLowerCase());
 
+  let filteredText = text;
   const replacements: Array<{
     original: string;
     censored: string;
     metadata?: ProfanityWord;
   }> = [];
 
-  matches.forEach((word) => {
+  const getCensoredWord = (originalWord: string): string => {
+    if (useRandomGrawlix) {
+      return makeRandomGrawlixString(originalWord.length);
+    }
+    return censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
+  };
+
+  const applyReplacement = (pattern: RegExp, metadata?: ProfanityWord) => {
+    filteredText = filteredText.replace(pattern, (matchedStr) => {
+      if (normalizedWhitelist.includes(matchedStr.toLowerCase())) {
+        return matchedStr;
+      }
+
+      const censored = getCensoredWord(matchedStr);
+      replacements.push({
+        original: matchedStr,
+        censored,
+        metadata,
+      });
+      return censored;
+    });
+  };
+
+  for (const word of matches) {
     const metadata = matchDetails.find(
       (m) =>
         m.word.toLowerCase() === word.toLowerCase() ||
@@ -75,163 +82,36 @@ export function filter(text: string, options: FilterOptions = {}): FilterResult
     );
 
     const variants = actualMatches.get(word.toLowerCase()) || [];
-    variants.push(word);
+    const allVariants = [...new Set([...variants, word])].sort((a, b) => b.length - a.length);
 
-    const uniqueVariants = [...new Set(variants)];
-
-    uniqueVariants.forEach((variant) => {
-      const regex = new RegExp(`\\b${escapeRegExp(variant)}\\b`, 'gi');
-
-      let match;
-      while ((match = regex.exec(filteredText)) !== null) {
-        const originalWord = match[0];
-
-        if (whitelist.includes(originalWord.toLowerCase())) continue;
-
-        let censoredWord;
-        if (useRandomGrawlix) {
-          censoredWord = makeRandomGrawlixString(originalWord.length);
-        } else {
-          censoredWord = censorWord(originalWord, replaceWith, !fullWordCensor && keepFirstAndLast);
-        }
-
-        replacements.push({
-          original: originalWord,
-          censored: censoredWord,
-          metadata,
-        });
-
-        filteredText = filteredText.replace(
-          new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'),
-          censoredWord
-        );
-      }
-    });
-
-    if (detectSplit || detectLeetSpeak) {
-      if (detectLeetSpeak) {
-        const leetRegex = createWordRegex(word, {
-          wholeWord: true,
-          caseSensitive: false,
-          leetSpeak: true,
-          detectSplit: false,
-          indonesianVariation: false,
-        });
-
-        let match;
-        while ((match = leetRegex.exec(filteredText)) !== null) {
-          const originalWord = match[0];
-
-          if (whitelist.includes(originalWord.toLowerCase())) continue;
-
-          let censoredWord;
-          if (useRandomGrawlix) {
-            censoredWord = makeRandomGrawlixString(originalWord.length);
-          } else {
-            censoredWord = censorWord(
-              originalWord,
-              replaceWith,
-              !fullWordCensor && keepFirstAndLast
-            );
-          }
-
-          replacements.push({
-            original: originalWord,
-            censored: censoredWord,
-            metadata,
-          });
-
-          filteredText = filteredText.replace(
-            new RegExp(escapeRegExp(originalWord), 'g'),
-            censoredWord
-          );
-        }
-      }
+    for (const variant of allVariants) {
+      const boundaryPattern = checkSubstring
+        ? escapeRegExp(variant)
+        : `\\b${escapeRegExp(variant)}\\b`;
+      applyReplacement(new RegExp(boundaryPattern, 'gi'), metadata);
+    }
 
-      if (detectSplit) {
-        const splitRegex = createWordRegex(word, {
-          wholeWord: false,
-          caseSensitive: false,
-          leetSpeak: false,
-          detectSplit: true,
-          indonesianVariation: false,
-        });
-
-        let match;
-        while ((match = splitRegex.exec(filteredText)) !== null) {
-          const originalWord = match[0];
-
-          if (whitelist.includes(originalWord.toLowerCase())) continue;
-
-          let censoredWord;
-          if (useRandomGrawlix) {
-            censoredWord = makeRandomGrawlixString(originalWord.length);
-          } else {
-            censoredWord = censorWord(
-              originalWord,
-              replaceWith,
-              !fullWordCensor && keepFirstAndLast
-            );
-          }
-
-          replacements.push({
-            original: originalWord,
-            censored: censoredWord,
-            metadata,
-          });
-
-          filteredText = filteredText.replace(
-            new RegExp(escapeRegExp(originalWord), 'g'),
-            censoredWord
-          );
-        }
-      }
+    if (detectLeetSpeak) {
+      const leetRegex = createWordRegex(word, {
+        wholeWord: !checkSubstring,
+        caseSensitive: false,
+        leetSpeak: true,
+        detectSplit: false,
+        indonesianVariation: false,
+      });
+      applyReplacement(leetRegex, metadata);
     }
-  });
-
-  if (detectSimilarity && useLevenshtein) {
-    matches.forEach((word) => {
-      const metadata = matchDetails.find(
-        (m) =>
-          m.word.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');
-
-        let match;
-        while ((match = exactVariantRegex.exec(filteredText)) !== null) {
-          const originalWord = match[0];
-
-          if (whitelist.includes(originalWord.toLowerCase())) continue;
-
-          let censoredWord;
-          if (useRandomGrawlix) {
-            censoredWord = makeRandomGrawlixString(originalWord.length);
-          } else {
-            censoredWord = censorWord(
-              originalWord,
-              replaceWith,
-              !fullWordCensor && keepFirstAndLast
-            );
-          }
-
-          replacements.push({
-            original: originalWord,
-            censored: censoredWord,
-            metadata,
-          });
-
-          filteredText = filteredText.replace(
-            new RegExp(`\\b${escapeRegExp(originalWord)}\\b`, 'g'),
-            censoredWord
-          );
-        }
+
+    if (detectSplit) {
+      const splitRegex = createWordRegex(word, {
+        wholeWord: false,
+        caseSensitive: false,
+        leetSpeak: false,
+        detectSplit: true,
+        indonesianVariation: false,
       });
-    });
+      applyReplacement(splitRegex, metadata);
+    }
   }
 
   return {

package/src/core/matcher.ts

@@ -10,18 +10,23 @@ import {
 import { DEFAULT_OPTIONS } from '../config/options';
 import { AhoCorasick } from '../utils/ahoCorasick';
 
-const globalAhoCorasick = new AhoCorasick();
-let ahoCorasickInitialized = false;
-
-function initializeAhoCorasick(words: string[]) {
-  if (ahoCorasickInitialized) return;
-
-  for (const word of words) {
-    globalAhoCorasick.addPattern(word);
+let defaultAhoCorasick: AhoCorasick | null = null;
+
+function getDefaultAhoCorasick(): AhoCorasick {
+  if (!defaultAhoCorasick) {
+    const ac = new AhoCorasick();
+    for (const wordObj of wordObjects) {
+      ac.addPattern(wordObj.word);
+      if (wordObj.aliases) {
+        for (const alias of wordObj.aliases) {
+          ac.addPattern(alias);
+        }
+      }
+    }
+    ac.build();
+    defaultAhoCorasick = ac;
   }
-
-  globalAhoCorasick.build();
-  ahoCorasickInitialized = true;
+  return defaultAhoCorasick;
 }
 
 interface FindProfanityFunction {
@@ -54,13 +59,16 @@ export function findProfanity(text: string, options: FilterOptions = {}): string
     maxLevenshteinDistance = 2,
   } = { ...DEFAULT_OPTIONS, ...options };
 
+  const hasCustomWordList = Boolean(wordList && wordList.length > 0);
   const normalizedWhitelist = whitelist.map((w) => w.toLowerCase());
-
   const normalizedText = normalizeText(text);
 
-  let baseWordsToCheck: string[] = wordList.length > 0 ? wordList : [];
+  let baseWordsToCheck: string[] = [];
+  const aliasMap = new Map<string, string>();
 
-  if (baseWordsToCheck.length === 0) {
+  if (hasCustomWordList) {
+    baseWordsToCheck = wordList;
+  } else {
     const filteredWords = wordObjects.filter((word) => {
       const matchCategory = categories ? categories.includes(word.category) : true;
       const matchRegion = regions ? regions.includes(word.region) : true;
@@ -69,26 +77,15 @@ export function findProfanity(text: string, options: FilterOptions = {}): string
     });
 
     baseWordsToCheck = filteredWords.map((word) => word.word);
-  }
 
-  const aliasMap = new Map<string, string>();
-  wordObjects.forEach((wordObj) => {
-    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());
-      });
-    }
-  });
+    filteredWords.forEach((wordObj) => {
+      if (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) => !normalizedWhitelist.includes(word.toLowerCase())
@@ -103,6 +100,7 @@ export function findProfanity(text: string, options: FilterOptions = {}): string
 
   const passesFilters = (word: string): boolean => {
     if (normalizedWhitelist.includes(word.toLowerCase())) return false;
+    if (hasCustomWordList) return true;
 
     const metadata = getWordMetadata(word);
     if (!metadata) return false;
@@ -114,10 +112,29 @@ export function findProfanity(text: string, options: FilterOptions = {}): string
     return matchCategory && matchRegion && matchSeverity;
   };
 
-  initializeAhoCorasick(wordsToCheck);
+  let ac: AhoCorasick;
+  if (hasCustomWordList) {
+    ac = new AhoCorasick();
+    for (const w of wordsToCheck) {
+      ac.addPattern(w);
+    }
+    ac.build();
+  } else {
+    ac = getDefaultAhoCorasick();
+  }
+
+  const occurrences = ac.searchWithPositions(normalizedText);
+  for (const occ of occurrences) {
+    const { pattern: match, start, end } = occ;
+
+    if (!checkSubstring) {
+      const isWordStart = start === 0 || !/[a-z0-9_]/i.test(normalizedText[start - 1]);
+      const isWordEnd = end === normalizedText.length || !/[a-z0-9_]/i.test(normalizedText[end]);
+      if (!isWordStart || !isWordEnd) {
+        continue;
+      }
+    }
 
-  const basicMatches = globalAhoCorasick.searchUnique(normalizedText);
-  for (const match of basicMatches) {
     if (normalizedWhitelist.includes(match.toLowerCase())) continue;
 
     const originalWord = aliasMap.get(match.toLowerCase()) || match.toLowerCase();
@@ -274,8 +291,8 @@ export function findProfanity(text: string, options: FilterOptions = {}): string
 /**
  * Mencari kata kotor lengkap dengan metadata
  *
- * @param text Teks yang akan diperika
- * @param options Opsi utnuk pencarian kata kotor
+ * @param text Teks yang akan diperiksa
+ * @param options Opsi untuk pencarian kata kotor
  * @return Array dari objek kata kotor yang ditemukan
  */
 export function findProfanityWithMetadata(
@@ -295,15 +312,24 @@ export function findProfanityWithMetadata(
           (obj.aliases && obj.aliases.some((alias) => alias.toLowerCase() === word.toLowerCase()))
       );
 
-      return wordObject;
+      if (wordObject) {
+        return wordObject;
+      }
+
+      return {
+        word,
+        category: 'profanity' as ProfanityCategory,
+        region: 'general' as Region,
+        severity: 0.5,
+      };
     })
     .filter((word): word is ProfanityWord => word !== undefined);
 }
 
 /**
- * Mencari kategory kata kotor yang ada dalam teks
+ * Mencari kategori kata kotor yang ada dalam teks
  *
- * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @param matchDetails Hasil pencarian dari findProfanityWithMetadata()
  * @return Array kategori unik
  */
 export function findCategories(matchDetails: ProfanityWord[]): ProfanityCategory[] {
@@ -319,7 +345,7 @@ export function findCategories(matchDetails: ProfanityWord[]): ProfanityCategory
 /**
  * Mencari region kata kotor yang ada dalam teks
  *
- * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @param matchDetails Hasil pencarian dari findProfanityWithMetadata()
  * @return Array region unik
  */
 export function findRegions(matchDetails: ProfanityWord[]): Region[] {
@@ -343,7 +369,7 @@ export function calculateSeverity(matchDetails: ProfanityWord[]): number {
     return 0;
   }
 
-  const countFactor = Math.min(matchDetails.length / 10, 1); // Maksimal 10 kata
+  const countFactor = Math.min(matchDetails.length / 10, 1);
 
   const categoryWeights: Record<ProfanityCategory, number> = {
     sexual: 0.9,

package/src/index.ts

@@ -95,6 +95,14 @@ export class IDProfanityFilter {
     };
   }
 
+  /**
+   * Mengatur ulang opsi filter ke default
+   * @param options Opsi baru untuk override default
+   */
+  resetOptions(options: FilterOptions = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+
   /**
    * Menggunakan preset yang telah ditentukan
    * @param presetName Nama preset yang akan digunakan

package/src/types/index.ts

@@ -16,17 +16,7 @@ export type Region =
   | 'minang'
   | 'bali'
   | 'madura'
-  | 'bugis'
-  | 'aceh'
-  | 'ambon'
-  | 'papua'
-  | 'manado'
-  | 'banjar'
-  | 'palembang'
-  | 'lampung'
-  | 'ntt'
-  | 'mandailing'
-  | 'ntb';
+  | 'aceh';
 
 export interface ProfanityWord {
   word: string;

package/src/utils/ahoCorasick.ts

@@ -145,6 +145,43 @@ export class AhoCorasick {
     return new Set(matches.keys());
   }
 
+  /**
+   * Mencari semua kemunculan pola beserta posisi indeks awal dan akhirnya
+   * @param text Teks yang akan dicari
+   * @returns Array objek berisi pattern, start, dan end
+   */
+  searchWithPositions(text: string): Array<{ pattern: string; start: number; end: number }> {
+    if (!this.built) {
+      this.build();
+    }
+
+    const results: Array<{ pattern: string; start: number; end: number }> = [];
+    const normalizedText = text.toLowerCase();
+    let node = this.root;
+
+    for (let i = 0; i < normalizedText.length; i++) {
+      const char = normalizedText[i];
+
+      while (node !== this.root && !node.children.has(char)) {
+        node = node.fail!;
+      }
+
+      if (node.children.has(char)) {
+        node = node.children.get(char)!;
+      }
+
+      for (const match of node.output) {
+        results.push({
+          pattern: match,
+          start: i + 1 - match.length,
+          end: i + 1,
+        });
+      }
+    }
+
+    return results;
+  }
+
   /**
    * Mengecek apakah teks mengandung setidaknya satu pola
    * @param text Teks yang akan dicari

package/src/utils/regexUtils.ts

@@ -164,8 +164,7 @@ export function addIndonesianVariations(pattern: string): string {
     const variations = variationMap[lowerChar];
 
     if (variations && variations.length > 1) {
-      // Create a character class with all variations
-      result += `[${variations.join('')}]`;
+      result += `(?:${variations.join('|')})`;
     } else {
       result += char;
     }