@sideid/id-profanity-filter 0.1.0

package/.eslintrc.js

@@ -0,0 +1,16 @@
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  extends: ['plugin:@typescript-eslint/recommended', 'prettier'],
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+  },
+  env: {
+    node: true,
+    jest: true,
+  },
+  rules: {
+    '@typescript-eslint/explicit-function-return-type': 'off',
+    '@typescript-eslint/no-explicit-any': 'off',
+  },
+};

package/CONTRIBUTING.md

@@ -0,0 +1,151 @@
+# Panduan Kontribusi untuk ID-Profanity-Filter
+
+Terima kasih telah mempertimbangkan untuk berkontribusi pada proyek ID-Profanity-Filter! Panduan ini akan menjelaskan proses kontribusi, terutama untuk menambahkan kata kotor baru ke dalam database.
+
+## Cara Berkontribusi
+
+### 1. Fork & Clone Repositori
+
+- Fork repositori ini ke akun GitHub Anda
+- Clone repositori fork Anda ke komputer lokal:
+  ```bash
+  git clone https://github.com/username/id-profanity-filter.git
+  cd id-profanity-filter
+  ```
+
+### 2. Install Dependensi
+
+```bash
+npm install
+```
+
+### 3. Buat Branch Baru
+
+```bash
+git switch -c add-kata-kotor-daerah
+```
+
+## Struktur Kata Kotor
+
+Kata-kata kotor dalam proyek ini dikelompokkan berdasarkan dua dimensi:
+
+### Berdasarkan Daerah Asal
+
+Lokasi file: `src/constants/regions/`
+
+Kata-kata dikelompokkan berdasarkan daerah asalnya di Indonesia, seperti:
+- `general.ts` - Kata-kata umum di Indonesia
+- `jawa.ts` - Kata-kata dari Jawa
+- `sunda.ts` - Kata-kata dari Sunda
+- `betawi.ts` - Kata-kata dari Betawi
+- `batak.ts` - Kata-kata dari Batak
+- ... dan daerah lainnya
+
+### Berdasarkan Kategori
+
+Lokasi file: `src/constants/categories/`
+
+Kata-kata juga dikelompokkan berdasarkan jenisnya:
+- `sexual.ts` - Kata-kata berbau seksual
+- `insult.ts` - Kata-kata penghinaan
+- `profanity.ts` - Umpatan umum
+- `slur.ts` - Kata-kata merendahkan berdasarkan identitas
+- `drugs.ts` - Kata-kata terkait narkoba
+- `disgusting.ts` - Kata-kata menjijikkan
+- `blasphemy.ts` - Kata-kata penistaan agama
+
+## Cara Menambahkan Kata Kotor Baru
+
+### 1. Menambahkan ke File Daerah
+
+Pilih file daerah yang sesuai di `src/constants/regions/` atau buat file baru jika daerah tersebut belum ada. Format entri kata kotor harus mengikuti interface `ProfanityWord`:
+
+```typescript
+{
+  word: 'kata_kotor',        // Kata kotor dalam bentuk dasarnya
+  category: 'insult',        // Kategori kata (sexual, insult, profanity, slur, drugs, disgusting, blasphemy)
+  region: 'nama_daerah',     // Daerah asal kata
+  severity: 0.7,             // Tingkat keparahan (0-1)
+  aliases: ['alias1', 'alias2'], // Variasi atau alias kata (opsional)
+  description: 'Deskripsi kata', // Penjelasan singkat tentang kata (opsional)
+  context: 'Konteks penggunaan' // Informasi konteks penggunaan (opsional)
+}
+```
+
+Contoh menambahkan kata ke file daerah (misalnya `bali.ts`):
+
+```typescript
+import { ProfanityWord } from '../../types';
+
+export const bali: ProfanityWord[] = [
+  // ... kata-kata yang sudah ada
+  {
+    word: 'cicing',
+    category: 'profanity',
+    region: 'bali',
+    severity: 0.6,
+    aliases: ['cicying'],
+    description: 'Secara harfiah berarti anjing dalam Bahasa Bali',
+    context: 'Umpatan umum dalam Bahasa Bali'
+  },
+  // ... tambahkan kata lainnya
+];
+
+export const baliWords = bali.map(item => item.word);
+
+export default bali;
+```
+
+### 2. Menambahkan ke File Kategori (Opsional)
+
+Jika Anda menambahkan kata baru, perbarui juga file kategori yang sesuai (`src/constants/categories/`). Kata-kata tersebut akan otomatis terambil saat library dibuild, tetapi terkadang kategori perlu diperbarui.
+
+### 3. Update File indeks Daerah/Kategori (jika ada daerah baru)
+
+Jika Anda menambahkan daerah baru, pastikan untuk memperbarui file indeks:
+- `src/constants/regions/index.ts`
+- `src/constants/wordList.ts`
+
+### 4. Jalankan Tes (jika ada)
+
+```bash
+npm test
+```
+
+### 5. Build Library
+
+```bash
+npm run build
+```
+
+### 6. Commit dan Push Perubahan Anda
+
+```bash
+git add .
+git commit -m "Menambahkan kata kotor daerah X"
+git push origin add-kata-kotor-daerah
+```
+
+### 7. Buat Pull Request
+
+Buat Pull Request dari branch Anda ke repositori utama.
+
+## Pedoman Penambahan Kata
+
+1. **Validasi Kata**: Pastikan kata tersebut benar-benar dianggap kasar di daerah yang dimaksud.
+2. **Metadata**: Tambahkan metadata yang cukup, terutama tingkat keparahan dan kategori.
+3. **Konteks**: Tambahkan komentar konteks jika diperlukan untuk menjelaskan kata tersebut.
+4. **Bentuk Dasar**: Tambahkan kata dalam bentuk dasarnya, variasi dapat ditambahkan dalam `aliases`.
+5. **Kategorisasi**: Kategorikan kata dengan benar (seksual, hinaan, umpatan, dll).
+6. **Hindari Duplikasi**: Periksa apakah kata tersebut sudah ada sebelum menambahkannya.
+
+## Format Commit
+
+Gunakan format commit yang konsisten:
+- `Add: Menambahkan kata X dari daerah Y`
+- `Update: Memperbaiki metadata kata X`
+- `Fix: Memperbaiki bug pada ...`
+
+## Informasi Tambahan
+
+Untuk pertanyaan atau diskusi, silakan buat issue di GitHub atau hubungi maintainer proyek. Terima kasih atas kontribusi Anda!

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Side ID ~
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,285 @@
+# ID-Profanity-Filter
+
+![License](https://img.shields.io/npm/l/@sideid/id-profanity-filter)
+![Version](https://img.shields.io/npm/v/@sideid/id-profanity-filter)
+![Downloads](https://img.shields.io/npm/dt/@sideid/id-profanity-filter)
+
+Library JavaScript/TypeScript untuk mendeteksi, menyensor, dan menganalisis kata-kata kotor dalam Bahasa Indonesia dan bahasa daerah.
+
+## Fitur Utama
+
+- 🔍 **Deteksi Kata Kotor** - Mendeteksi kata-kata kasar/kotor dalam teks Bahasa Indonesia
+- ⚠️ **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)
+- 🔧 **Kustomisasi** - Opsi untuk menambahkan whitelist dan daftar kata kustom
+
+## Instalasi
+
+```bash
+npm install @sideid/id-profanity-filter
+# atau
+yarn add @sideid/id-profanity-filter
+# atau
+pnpm add @sideid/id-profanity-filter
+```
+
+## Penggunaan Dasar
+
+### JavaScript / TypeScript
+
+```typescript
+import IDProfanityFilter from '@sideid/id-profanity-filter';
+
+// Buat instance filter
+const filter = new IDProfanityFilter();
+
+// Cek apakah teks mengandung kata kotor
+const teks = 'Dasar anjing kamu, jangan banyak bacot!';
+const hasProfanity = filter.isProfane(teks);
+
+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.censored); // Output: 2 (jumlah kata yang disensor)
+
+// Analisis konten
+const analisis = filter.analyze(teks);
+console.log(analisis.severityScore); // Output: 0.65 (contoh skor keparahan)
+console.log(analisis.categories); // Output: ["profanity", "insult"]
+```
+
+### Utilitas Langsung
+
+Anda juga dapat menggunakan fungsi utilitas langsung tanpa membuat instance:
+
+```typescript
+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 ****!"
+```
+
+## Dokumentasi API
+
+### Kelas `IDProfanityFilter`
+
+#### Konstruktor
+
+```typescript
+constructor(options?: FilterOptions)
+```
+
+- **options**: Opsi konfigurasi filter (opsional)
+
+#### Metode
+
+##### `filter(text: string): FilterResult`
+
+Menyensor kata kotor dalam teks.
+
+- **Hasil**: Objek `FilterResult` dengan properti:
+  - `filtered`: String teks yang sudah disensor
+  - `censored`: Jumlah kata yang disensor
+  - `replacements`: Array berisi detail kata yang disensor
+
+##### `isProfane(text: string): boolean`
+
+Memeriksa apakah teks mengandung kata kotor.
+
+- **Hasil**: Boolean `true` jika teks mengandung kata kotor, `false` jika tidak
+
+##### `analyze(text: string): AnalysisResult`
+
+Menganalisis teks untuk mendapatkan informasi detail tentang kata kotor yang ditemukan.
+
+- **Hasil**: Objek `AnalysisResult` dengan properti:
+  - `hasProfanity`: Apakah teks mengandung kata kotor
+  - `matches`: Array kata kotor yang ditemukan
+  - `matchDetails`: Array objek kata kotor dengan metadata
+  - `categories`: Kategori kata kotor yang ditemukan
+  - `regions`: Daerah asal kata kotor yang ditemukan
+  - `severityScore`: Skor keparahan (0-1)
+
+##### `batchAnalyze(texts: string[])`
+
+Menganalisis batch teks sekaligus dan memberikan ringkasan.
+
+- **Hasil**: Objek yang berisi ringkasan analisis
+
+##### `analyzeBySentence(text: string)`
+
+Menganalisis teks per-kalimat.
+
+- **Hasil**: Array dari hasil analisis per-kalimat
+
+##### `analyzeWithContext(text: string, contextWindowSize?: number)`
+
+Menganalisis teks dengan konteks di sekitar kata kotor.
+
+- **Hasil**: Array dari kata kotor dengan konteks di sekitarnya
+
+##### `setOptions(options: Partial<FilterOptions>)`
+
+Mengubah opsi filter.
+
+##### `setWordList(wordList: string[])`
+
+Menetapkan daftar kata kustom.
+
+##### `addToWhitelist(word: string)`
+
+Menambahkan kata ke whitelist (akan diabaikan dalam filter).
+
+##### `removeFromWhitelist(word: string)`
+
+Menghapus kata dari whitelist.
+
+### Opsi Filter
+
+```typescript
+interface FilterOptions {
+  wordList?: string[]; // List kata yang ingin difilter
+  replaceWith?: string; // Karakter pengganti untuk kata yang disensor
+  fullWordCensor?: boolean; // Apakah menyensor seluruh kata atau sebagian
+  detectLeetSpeak?: boolean; // Deteksi variasi penulisan (mis: a=4, e=3)
+  whitelist?: string[]; // Kata-kata yang dikecualikan dari filter
+  checkSubstring?: boolean; // Memeriksa substring (lebih ketat)
+  categories?: ProfanityCategory[]; // Kategori kata yang difilter
+  regions?: Region[]; // Daerah asal kata yang difilter
+  severityThreshold?: number; // Tingkat keparahan minimum (0-1)
+}
+```
+
+## Contoh Penggunaan Lanjutan
+
+### Kustomisasi Opsi Filter
+
+```typescript
+const filter = new IDProfanityFilter({
+  replaceWith: '#', // Menggunakan # sebagai karakter pengganti
+  fullWordCensor: false, // Hanya menyensor sebagian kata
+  detectLeetSpeak: true, // Mendeteksi variasi seperti "b4b1" untuk "babi"
+  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,
+});
+```
+
+### Menggunakan Whitelist
+
+```typescript
+const filter = new IDProfanityFilter();
+
+// Menambahkan kata ke whitelist (akan diabaikan)
+filter.addToWhitelist('anjing');
+
+const teks =
+  'Anjing itu hewan peliharaan yang setia, tidak seperti bajingan itu';
+const hasil = filter.filter(teks);
+
+console.log(hasil.filtered);
+// Output: "Anjing itu hewan peliharaan yang setia, tidak seperti ******* itu"
+```
+
+### Analisis Konten Mendalam
+
+```typescript
+const filter = new IDProfanityFilter();
+const teks = 'Dasar anjing sialan! Kamu ini memang bego dan goblok.';
+
+// Analisis teks
+const analisis = filter.analyze(teks);
+console.log(analisis);
+
+/* Output:
+{
+  hasProfanity: true,
+  matches: ['anjing', 'sialan', 'bego', 'goblok'],
+  matchDetails: [
+    { word: 'anjing', category: 'profanity', region: 'general', severity: 0.7, ... },
+    { word: 'bego', category: 'insult', region: 'general', severity: 0.5, ... },
+    ...
+  ],
+  categories: ['profanity', 'insult'],
+  regions: ['general'],
+  severityScore: 0.64
+}
+*/
+```
+
+### Analisis Batch
+
+```typescript
+const filter = new IDProfanityFilter();
+const komentar = [
+  'Film ini sangat bagus, ceritanya menarik sekali!',
+  'Dasar goblok, sialan kamu!',
+  'Anjing emang filmnya, sampah banget.',
+];
+
+const hasil = filter.batchAnalyze(komentar);
+console.log(hasil);
+
+/* Output:
+{
+  totalTexts: 3,
+  profaneTexts: 2,
+  cleanTexts: 1,
+  averageSeverity: 0.62,
+  topCategories: ['profanity', 'insult'],
+  topRegions: ['general'],
+  mostFrequentWords: [
+    { word: 'anjing', count: 1 },
+    { word: 'goblok', count: 1 },
+    { word: 'sialan', count: 1 },
+    { word: 'sampah', count: 1 }
+  ]
+}
+*/
+```
+
+## Dukungan Regional
+
+Library ini mendukung kata-kata kotor dari berbagai daerah di Indonesia:
+
+- 🇮🇩 **General** - Kata-kata yang umum di seluruh Indonesia
+- 🏝️ **Jawa** - Kata-kata dari bahasa Jawa
+- 🏞️ **Sunda** - Kata-kata dari bahasa Sunda
+- 🏙️ **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:
+
+- `sexual`: Kata-kata berbau seksual
+- `insult`: Kata-kata penghinaan
+- `profanity`: Umpatan umum
+- `slur`: Perkataan merendahkan berdasarkan identitas
+- `drugs`: Terkait narkoba
+- `disgusting`: Kata-kata menjijikkan
+- `blasphemy`: Penistaan agama
+
+## Berkontribusi
+
+Kami sangat menghargai kontribusi Anda! Untuk berkontribusi, silakan lihat [panduan kontribusi](CONTRIBUTING.md).
+
+## Lisensi
+
+Proyek ini dilisensikan di bawah [MIT License](LICENSE).
+
+## Kontak & Dukungan
+
+Jika Anda memiliki pertanyaan atau saran, silakan buka issue di repositori GitHub kami.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/constants/wordList.d.ts

@@ -0,0 +1,34 @@
+import { ProfanityWord } from '../types';
+export declare const wordCategories: {
+    sexual: string[];
+    insult: string[];
+};
+export declare const wordRegions: {
+    general: string[];
+    jawa: string[];
+    sunda: string[];
+    betawi: string[];
+    batak: string[];
+};
+export declare const wordObjects: ProfanityWord[];
+export declare const allWords: string[];
+/**
+ * Kata-kata dengan tingkat keparahan tinggi (subset dari semua kata)
+ */
+export declare const severeWords: string[];
+/**
+ * Mencari kata berdasarkan kategori dan region
+ *
+ * @param category Kategori kata kotor
+ * @param region Daerah asal kata kotor
+ * @returns Array dari kata kotor
+ */
+export declare function getWordsByFilter(category?: string, region?: string): string[];
+/**
+ * Mencari metadata lengkap untuk sebuah kata
+ *
+ * @param word Kata yang dicari
+ * @returns Objek ProfanityWord jika ditemukan, undefined jika tidak
+ */
+export declare function getWordMetadata(word: string): ProfanityWord | undefined;
+export default allWords;

package/dist/core/analyzer.d.ts

@@ -0,0 +1,54 @@
+import { FilterOptions, AnalysisResult, ProfanityCategory, Region } from '../types';
+/**
+ * Menganalisis teks untuk kata kotor
+ *
+ * @param text Teks yang akan dianalisis
+ * @param options Opsi untuk analisis
+ * @return AnalysisResult dengan hasil analisis
+ */
+export declare function analyze(text: string, options?: FilterOptions): AnalysisResult;
+/**
+ * menganalisis daftar teks dan ringkasan
+ *
+ * @param texts Daftar teks yagn dianalisis
+ * @param options Opsi untuk analisis
+ * @return Objek dengan ringkasan analisis
+ */
+export declare function batchAnalyze(texts: string[], options?: FilterOptions): {
+    totalTexts: number;
+    profaneTexts: number;
+    cleanTexts: number;
+    averageSeverity: number;
+    topCategories: ProfanityCategory[];
+    topRegions: Region[];
+    mostFrequentWords: Array<{
+        word: string;
+        count: number;
+    }>;
+};
+/**
+ * Menganalisis per-kalimat untuk melokalisasi kata kotor
+ *
+ * @param text Teks yang akan dianalisis per-kalimat
+ * @param options Opsi untuk analisis
+ * @returns Array hasil analisis per-kalimat
+ */
+export declare function analyzeBySentence(text: string, options?: FilterOptions): Array<AnalysisResult & {
+    sentence: string;
+}>;
+/**
+ * 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 options Opsi untuk analisis
+ * @returns Konteks di dekat kata kotor
+ */
+export declare function analyzeWithContext(text: string, contextWindowSize?: number, options?: FilterOptions): Array<{
+    word: string;
+    context: string;
+    position: {
+        start: number;
+        end: number;
+    };
+}>;

package/dist/core/filter.d.ts

@@ -0,0 +1,17 @@
+import { FilterOptions, FilterResult } from '../types';
+/**
+ * Menyensor kata kotor dalam teks
+ *
+ * @param text Teks yang akan disensor
+ * @param options Opsi untuk filter
+ * @returns FilterResult dengan hasil filter
+ */
+export declare function filter(text: string, options?: FilterOptions): FilterResult;
+/**
+ * Memeriksa apakah teks mengandung kata kotor
+ *
+ * @param text Teks yang akan diperiksa
+ * @param options Opsi untuk pemeriksaan
+ * @returns Boolean apakah teks mengandung kata kotor
+ */
+export declare function isProfane(text: string, options?: FilterOptions): boolean;

package/dist/core/matcher.d.ts

@@ -0,0 +1,31 @@
+import { ProfanityWord, ProfanityCategory, Region, FilterOptions } from '../types';
+export declare 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
+ * @return Array dari objek kata kotor yang ditemukan
+ */
+export declare function findProfanityWithMetadata(text: string, options?: FilterOptions): ProfanityWord[];
+/**
+ * Mencari kategory kata kotor yang ada dalam teks
+ *
+ * @param text matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @param options Opsi untuk pencarian kategori
+ */
+export declare function findCategories(matchDetails: ProfanityWord[]): ProfanityCategory[];
+/**
+ * Mencari region kata kotor yang ada dalam teks
+ *
+ * @param text matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @param options Opsi untuk pencarian region
+ */
+export declare function findRegions(matchDetails: ProfanityWord[]): Region[];
+/**
+ * Menghitung tingkat keparahan kata kotor yang ditemukan
+ *
+ * @param matchDetails Hasil pencarian dari findProfanityWithMetadata()
+ * @return Skor keparahan dari 0-1
+ */
+export declare function calculateSeverity(matchDetails: ProfanityWord[]): number;