@sideid/id-profanity-filter 1.9.4 → 1.9.6

package/README.md

@@ -12,6 +12,8 @@ Library JavaScript/TypeScript untuk mendeteksi, menyensor, dan menganalisis kata
 - ⚠️ **Analisis Konten** - Menganalisis tingkat keparahan dan kategori kata kotor
 - 🔒 **Penyensoran** - Menyensor kata-kata kotor dengan berbagai opsi kustomisasi
 - 🗺️ **Dukungan Bahasa Daerah** - Mencakup kata-kata dari berbagai daerah di Indonesia (Jawa, Sunda, Batak, dll)
+- 🧠 **Deteksi Cerdas** - Mendeteksi variasi ejaan, kata terpisah, dan kesamaan kata
+- 🛡️ **Preset** - Preset filter siap pakai untuk berbagai kebutuhan
 - 🔧 **Kustomisasi** - Opsi untuk menambahkan whitelist dan daftar kata kustom
 
 ## Instalasi
@@ -42,7 +44,7 @@ console.log(hasProfanity); // Output: true
 
 // Filter kata kotor (sensorisasi)
 const hasil = filter.filter(teks);
-console.log(hasil.filtered); // Output: "Dasar **** kamu, jangan banyak ****!"
+console.log(hasil.filtered); // Output: "Dasar ***** kamu, jangan banyak *****!"
 console.log(hasil.censored); // Output: 2 (jumlah kata yang disensor)
 
 // Analisis konten
@@ -51,6 +53,26 @@ console.log(analisis.severityScore); // Output: 0.65 (contoh skor keparahan)
 console.log(analisis.categories); // Output: ["profanity", "insult"]
 ```
 
+### Menggunakan Preset
+
+```typescript
+import IDProfanityFilter from '@sideid/id-profanity-filter';
+
+// Buat instance filter dengan preset
+const filter = new IDProfanityFilter();
+filter.usePreset('strict');
+
+// Atau dengan opsi tambahan
+filter.usePreset('childSafe', {
+  replaceWith: '#',
+  useRandomGrawlix: true,
+});
+
+const teks = 'Dasar anjing kamu, jangan banyak bacot!';
+const hasil = filter.filter(teks);
+console.log(hasil.filtered); // Output: "Dasar #@$%& kamu, jangan banyak $!@#%!"
+```
+
 ### Utilitas Langsung
 
 Anda juga dapat menggunakan fungsi utilitas langsung tanpa membuat instance:
@@ -60,7 +82,13 @@ import { idFilter } from '@sideid/id-profanity-filter';
 
 const teks = 'Dasar anjing kamu, jangan banyak bacot!';
 const hasil = idFilter.filter(teks);
-console.log(hasil.filtered); // Output: "Dasar **** kamu, jangan banyak ****!"
+console.log(hasil.filtered); // Output: "Dasar ***** kamu, jangan banyak *****!"
+
+// Menggunakan preset dengan API fungsi statis
+const presetResult = idFilter.filter(
+  teks,
+  idFilter.getPresetOptions('moderate'),
+);
 ```
 
 ## Dokumentasi API
@@ -103,6 +131,7 @@ Menganalisis teks untuk mendapatkan informasi detail tentang kata kotor yang dit
   - `categories`: Kategori kata kotor yang ditemukan
   - `regions`: Daerah asal kata kotor yang ditemukan
   - `severityScore`: Skor keparahan (0-1)
+  - `similarWords`: Kata-kata yang mirip dengan kata kotor (jika deteksi kesamaan diaktifkan)
 
 ##### `batchAnalyze(texts: string[])`
 
@@ -122,6 +151,13 @@ Menganalisis teks dengan konteks di sekitar kata kotor.
 
 - **Hasil**: Array dari kata kotor dengan konteks di sekitarnya
 
+##### `usePreset(presetName: string, additionalOptions?: Partial<FilterOptions>)`
+
+Menggunakan preset filter yang telah ditentukan.
+
+- **presetName**: Nama preset ('strict', 'moderate', 'light', 'childSafe', dll)
+- **additionalOptions**: Opsi tambahan untuk override preset (opsional)
+
 ##### `setOptions(options: Partial<FilterOptions>)`
 
 Mengubah opsi filter.
@@ -138,10 +174,25 @@ Menambahkan kata ke whitelist (akan diabaikan dalam filter).
 
 Menghapus kata dari whitelist.
 
+##### `enableIndonesianVariations()`
+
+Mengaktifkan deteksi variasi ejaan Bahasa Indonesia.
+
+##### `enableSplitWordDetection()`
+
+Mengaktifkan deteksi kata yang dipisah.
+
+##### `enableSimilarityDetection(threshold: number = 0.8)`
+
+Mengaktifkan deteksi berdasarkan kesamaan kata.
+
+- **threshold**: Ambang batas kesamaan (0-1, default: 0.8)
+
 ### Opsi Filter
 
 ```typescript
 interface FilterOptions {
+  // Opsi dasar
   wordList?: string[]; // List kata yang ingin difilter
   replaceWith?: string; // Karakter pengganti untuk kata yang disensor
   fullWordCensor?: boolean; // Apakah menyensor seluruh kata atau sebagian
@@ -151,9 +202,42 @@ interface FilterOptions {
   categories?: ProfanityCategory[]; // Kategori kata yang difilter
   regions?: Region[]; // Daerah asal kata yang difilter
   severityThreshold?: number; // Tingkat keparahan minimum (0-1)
+
+  // Opsi lanjutan
+  useRandomGrawlix?: boolean; // Gunakan karakter acak untuk sensor (#@$%&!)
+  keepFirstAndLast?: boolean; // Simpan huruf pertama dan terakhir (a***g)
+  indonesianVariation?: boolean; // Deteksi variasi ejaan Bahasa Indonesia
+  detectSimilarity?: boolean; // Deteksi kata berdasarkan kesamaan
+  similarityThreshold?: number; // Ambang batas kesamaan (0-1)
+  detectSplit?: boolean; // Deteksi kata yang dipisah (a-n-j-i-n-g)
 }
 ```
 
+## Preset Filter
+
+Library ini menyediakan beberapa preset yang dapat digunakan:
+
+### Preset Filter
+
+- **strict**: Filter paling ketat, mendeteksi semua jenis kata kotor
+- **moderate**: Filter tingkat menengah, mengabaikan kata-kata dengan tingkat keparahan rendah
+- **light**: Filter ringan, hanya untuk kata-kata paling sensitif
+- **childSafe**: Filter untuk konten anak-anak, sangat ketat
+
+### Preset Kategori
+
+- **sexual**: Hanya memfilter kata-kata berbau seksual
+- **insults**: Hanya memfilter kata-kata penghinaan
+- **profanity**: Hanya memfilter umpatan umum
+
+### Preset Regional
+
+- **general**: Hanya memfilter kata-kata umum di Indonesia
+- **jawa**: Hanya memfilter kata-kata dari Jawa
+- **sunda**: Hanya memfilter kata-kata dari Sunda
+- **betawi**: Hanya memfilter kata-kata dari Betawi
+- **batak**: Hanya memfilter kata-kata dari Batak
+
 ## Contoh Penggunaan Lanjutan
 
 ### Kustomisasi Opsi Filter
@@ -166,12 +250,14 @@ const filter = new IDProfanityFilter({
   categories: ['sexual', 'slur'], // Hanya filter kategori tertentu
   regions: ['jawa', 'general'], // Hanya filter dari daerah tertentu
   severityThreshold: 0.7, // Hanya filter kata dengan tingkat keparahan ≥ 0.7
-});
 
-// Atau mengubah opsi setelah inisialisasi
-filter.setOptions({
-  replaceWith: '@',
-  fullWordCensor: true,
+  // Opsi lanjutan
+  useRandomGrawlix: true, // Gunakan #@$%&! sebagai karakter pengganti
+  keepFirstAndLast: true, // Simpan huruf pertama dan terakhir (a***g)
+  indonesianVariation: true, // Deteksi variasi ejaan Indonesia
+  detectSimilarity: true, // Deteksi kata yang mirip
+  similarityThreshold: 0.8, // Ambang batas kesamaan
+  detectSplit: true, // Deteksi kata yang dipisah
 });
 ```
 
@@ -191,6 +277,74 @@ console.log(hasil.filtered);
 // Output: "Anjing itu hewan peliharaan yang setia, tidak seperti ******* itu"
 ```
 
+### Deteksi Variasi Ejaan dan Kata Terpisah
+
+```typescript
+// Aktifkan deteksi variasi ejaan dan kata terpisah
+const filter = new IDProfanityFilter({
+  indonesianVariation: true,
+  detectSplit: true,
+  detectLeetSpeak: true,
+});
+
+// Uji dengan variasi ejaan
+const teks1 = 'Dasar kamu ini sangat bodoh, benar-benar b0d0h dan b-o-d-o-h!';
+const hasil1 = filter.filter(teks1);
+console.log(hasil1.filtered);
+// Output: "Dasar kamu ini sangat *****, benar-benar ***** dan *********!"
+
+// Uji dengan ejaan Indonesia yang berbeda
+const teks2 = 'Dia sangat djail dan djudes dengan temannya';
+const hasil2 = filter.filter(teks2);
+console.log(hasil2.filtered);
+// Output: "Dia sangat ***** dan ****** dengan temannya"
+```
+
+### Deteksi Berdasarkan Kesamaan
+
+```typescript
+// Aktifkan deteksi kesamaan
+const filter = new IDProfanityFilter();
+filter.enableSimilarityDetection(0.75); // Set threshold kesamaan ke 0.75
+
+const teks = 'Dia benar-benar anjiing dan gooblok!';
+const analisis = filter.analyze(teks);
+
+console.log(analisis.similarWords);
+/* Output:
+[
+  { word: "anjiing", original: "anjing", similarity: 0.83 },
+  { word: "gooblok", original: "goblok", similarity: 0.85 }
+]
+*/
+
+const hasil = filter.filter(teks);
+console.log(hasil.filtered);
+// Output: "Dia benar-benar ****** dan *******!"
+```
+
+### Variasi Sensor Kata
+
+```typescript
+// Sensor standar (asterisk)
+const filter1 = new IDProfanityFilter();
+console.log(filter1.filter('Dasar anjing kamu!').filtered);
+// Output: "Dasar ***** kamu!"
+
+// Sensor dengan grawlix random
+const filter2 = new IDProfanityFilter({ useRandomGrawlix: true });
+console.log(filter2.filter('Dasar anjing kamu!').filtered);
+// Output: "Dasar #@$%& kamu!"
+
+// Sensor dengan menyimpan huruf pertama dan terakhir
+const filter3 = new IDProfanityFilter({
+  fullWordCensor: false,
+  keepFirstAndLast: true,
+});
+console.log(filter3.filter('Dasar anjing kamu!').filtered);
+// Output: "Dasar a***g kamu!"
+```
+
 ### Analisis Konten Mendalam
 
 ```typescript
@@ -217,6 +371,57 @@ console.log(analisis);
 */
 ```
 
+### Analisis Konteks
+
+```typescript
+const filter = new IDProfanityFilter();
+const teks =
+  'Saya sangat marah dengan sikapnya, dia benar-benar anjing dan bajingan!';
+
+// Analisis konteks
+const konteks = filter.analyzeWithContext(teks, 3);
+console.log(konteks);
+
+/* Output:
+[
+  {
+    word: "anjing",
+    context: "benar-benar anjing dan bajingan",
+    position: { start: 43, end: 62 }
+  },
+  {
+    word: "bajingan",
+    context: "anjing dan bajingan!",
+    position: { start: 54, end: 63 }
+  }
+]
+*/
+```
+
+### Analisis Per-Kalimat
+
+```typescript
+const filter = new IDProfanityFilter();
+const teks =
+  'Filmnya bagus sekali. Tetapi pemainnya seperti anjing, sangat buruk aktingnya.';
+
+// Analisis per-kalimat
+const kalimat = filter.analyzeBySentence(teks);
+console.log(
+  kalimat.map(
+    (k) =>
+      k.sentence + (k.hasProfanity ? ' (Mengandung kata kotor)' : ' (Bersih)'),
+  ),
+);
+
+/* Output:
+[
+  "Filmnya bagus sekali. (Bersih)",
+  "Tetapi pemainnya seperti anjing, sangat buruk aktingnya. (Mengandung kata kotor)"
+]
+*/
+```
+
 ### Analisis Batch
 
 ```typescript
@@ -258,8 +463,6 @@ Library ini mendukung kata-kata kotor dari berbagai daerah di Indonesia:
 - 🏙️ **Betawi** - Kata-kata dari bahasa Betawi
 - 🌋 **Batak** - Kata-kata dari bahasa Batak
 
-Dan daerah lainnya yang terus bertambah.
-
 ## Kategori Kata
 
 Kata-kata dikelompokkan berdasarkan kategori:
@@ -276,6 +479,24 @@ Kata-kata dikelompokkan berdasarkan kategori:
 
 Kami sangat menghargai kontribusi Anda! Untuk berkontribusi, silakan lihat [panduan kontribusi](CONTRIBUTING.md).
 
+### Menambahkan Kata Baru
+
+Jika Anda ingin menambahkan kata baru ke database, silakan buat pull request dengan mengubah file yang sesuai di `src/constants/categories/` atau `src/constants/regions/`.
+
+Format untuk menambahkan kata baru:
+
+```json
+{
+  "word": "kata_kotor", // Kata yang akan difilter
+  "category": "insult", // Kategori kata
+  "region": "general", // Daerah asal kata
+  "severity": 0.7, // Tingkat keparahan (0-1)
+  "aliases": ["k4t4_kotor", "kata_k0t0r"], // Alias atau variasi umum
+  "description": "Deskripsi tentang kata", // Penjelasan tentang kata (opsional)
+  "context": "Konteks penggunaan kata" // Konteks penggunaan (opsional)
+}
+```
+
 ## Lisensi
 
 Proyek ini dilisensikan di bawah [MIT License](LICENSE).

package/dist/config/options.d.ts

@@ -0,0 +1,258 @@
+import { FilterOptions, ProfanityCategory, Region } from "../types";
+export declare const DEFAULT_OPTIONS: FilterOptions;
+export declare const FILTER_PRESETS: {
+    strict: {
+        checkSubstring: boolean;
+        detectLeetSpeak: boolean;
+        severityThreshold: number;
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        regions?: Region[];
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    moderate: {
+        severityThreshold: number;
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        regions?: Region[];
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    light: {
+        severityThreshold: number;
+        categories: ProfanityCategory[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        regions?: Region[];
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    childSafe: {
+        checkSubstring: boolean;
+        detectLeetSpeak: boolean;
+        fullWordCensor: boolean;
+        severityThreshold: number;
+        replaceWith?: string;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        regions?: Region[];
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+};
+export declare const CATEGORY_PRESETS: {
+    sexual: {
+        categories: ProfanityCategory[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        regions?: Region[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    insults: {
+        categories: ProfanityCategory[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        regions?: Region[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    profanity: {
+        categories: ProfanityCategory[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        regions?: Region[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+};
+export declare const REGION_PRESETS: {
+    general: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    jawa: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    sunda: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    betawi: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+    batak: {
+        regions: Region[];
+        replaceWith?: string;
+        fullWordCensor?: boolean;
+        detectLeetSpeak?: boolean;
+        checkSubstring?: boolean;
+        wordList?: string[];
+        whitelist?: string[];
+        categories?: ProfanityCategory[];
+        severityThreshold?: number;
+        useRandomGrawlix?: boolean;
+        keepFirstAndLast?: boolean;
+        indonesianVariation?: boolean;
+        detectSimilarity?: boolean;
+        similarityThreshold?: number;
+        detectSplit?: boolean;
+    };
+};
+export declare const REPLACEMENT_CHARS: {
+    asterisk: string;
+    hash: string;
+    dollar: string;
+    at: string;
+    percent: string;
+    underscore: string;
+    dash: string;
+    dot: string;
+    grawlix: string;
+};
+/**
+ * Membuat opsi custom dengan menggabungkan dengan default
+ *
+ * @param options Opsi yang akan digabungkan dengan default
+ * @returns Opsi yang sudah digabungkan
+ */
+export declare function createOptions(options?: Partial<FilterOptions>): FilterOptions;
+/**
+ * Mendapatkan opsi dari preset yang ada
+ *
+ * @param presetName Nama preset filter, kategori, atau region
+ * @param additionalOptions Opsi tambahan untuk mengganti preset
+ * @returns Opsi yang sudah digabungkan
+ */
+export declare function getPresetOptions(presetName: string, additionalOptions?: Partial<FilterOptions>): FilterOptions;
+/**
+ * Mendapatkan karakter pengganti
+ *
+ * @param type Tipe karakter pengganti
+ * @returns Karakter pengganti
+ */
+export declare function getReplacementChar(type?: keyof typeof REPLACEMENT_CHARS): string;
+/**
+ * Membuat karakter pengganti random dari grawlix
+ *
+ * @returns Karakter pengganti random
+ */
+export declare function getRandomGrawlix(): string;
+/**
+ * Membuat string pengganti untuk kata menggunakan grawlix random
+ *
+ * @param length Panjang string
+ * @returns String pengganti
+ */
+export declare function makeRandomGrawlixString(length: number): string;

package/dist/constants/categories/index.d.ts

@@ -0,0 +1,9 @@
+import { sexual } from './sexual';
+import { insult } from './insult';
+export declare const categories: {
+    sexual: import("../..").ProfanityWord[];
+    insult: import("../..").ProfanityWord[];
+};
+export { sexual, insult };
+export declare const allCategoryWords: import("../..").ProfanityWord[];
+export default allCategoryWords;

package/dist/constants/categories/insult.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from '../../types';
+import { ProfanityWord } from "../../types";
 export declare const insult: ProfanityWord[];
 export declare const insultWords: string[];
 export default insult;

package/dist/constants/categories/sexual.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from '../../types';
+import { ProfanityWord } from "../../types";
 export declare const sexual: ProfanityWord[];
 export declare const sexualWords: string[];
 export default sexual;

package/dist/constants/regions/batak.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from '../../types';
+import { ProfanityWord } from "../../types";
 export declare const batak: ProfanityWord[];
 export declare const batakWords: string[];
 export default batak;

package/dist/constants/regions/betawi.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from '../../types';
+import { ProfanityWord } from "../../types";
 export declare const betawi: ProfanityWord[];
 export declare const betawiWords: string[];
 export default betawi;

package/dist/constants/regions/general.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from '../../types';
+import { ProfanityWord } from "../../types";
 export declare const general: ProfanityWord[];
 export declare const generalWords: string[];
 export default general;

package/dist/constants/regions/index.d.ts

@@ -0,0 +1,8 @@
+import { general } from './general';
+import { jawa } from './jawa';
+import { sunda } from './sunda';
+import { betawi } from './betawi';
+import { batak } from './batak';
+export { general, jawa, sunda, betawi, batak, };
+export declare const allRegionWords: import("../..").ProfanityWord[];
+export default allRegionWords;

package/dist/constants/regions/jawa.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from '../../types';
+import { ProfanityWord } from "../../types";
 export declare const jawa: ProfanityWord[];
 export declare const jawaWords: string[];
 export default jawa;

package/dist/constants/regions/sunda.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from '../../types';
+import { ProfanityWord } from "../../types";
 export declare const sunda: ProfanityWord[];
 export declare const sundaWords: string[];
 export default sunda;

package/dist/constants/wordList.d.ts

@@ -1,4 +1,4 @@
-import { ProfanityWord } from '../types';
+import { ProfanityWord } from "../types";
 export declare const wordCategories: {
     sexual: string[];
     insult: string[];

package/dist/core/analyzer.d.ts

@@ -1,4 +1,4 @@
-import { FilterOptions, AnalysisResult, ProfanityCategory, Region } from '../types';
+import { FilterOptions, AnalysisResult, ProfanityCategory, Region } from "../types";
 /**
  * Menganalisis teks untuk kata kotor
  *
@@ -8,9 +8,9 @@ import { FilterOptions, AnalysisResult, ProfanityCategory, Region } from '../typ
  */
 export declare function analyze(text: string, options?: FilterOptions): AnalysisResult;
 /**
- * menganalisis daftar teks dan ringkasan
+ * Menganalisis daftar teks dan ringkasan
  *
- * @param texts Daftar teks yagn dianalisis
+ * @param texts Daftar teks yang dianalisis
  * @param options Opsi untuk analisis
  * @return Objek dengan ringkasan analisis
  */
@@ -40,7 +40,7 @@ export declare function analyzeBySentence(text: string, options?: FilterOptions)
  * 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 contextWindowSize Ukuran konteks (jumlah kata) di sekitar kata kotor
  * @param options Opsi untuk analisis
  * @returns Konteks di dekat kata kotor
  */