@sideid/id-profanity-filter 1.11.0 → 1.11.5

package/dist/index.d.ts

@@ -58,4 +58,993 @@ interface RegexOptions {
     indonesianVariation?: boolean;
 }
 
+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
+ */
+declare function findProfanityWithMetadata(text: string, options?: FilterOptions): ProfanityWord[];
+/**
+ * Mencari kategory kata kotor yang ada dalam teks
+ *
+ * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @return Array kategori unik
+ */
+declare function findCategories(matchDetails: ProfanityWord[]): ProfanityCategory[];
+/**
+ * Mencari region kata kotor yang ada dalam teks
+ *
+ * @param matchDetails Hasil pencarian dari fingProfanityWithMetadata()
+ * @return Array region unik
+ */
+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
+ */
+declare function calculateSeverity(matchDetails: ProfanityWord[]): number;
+
+/**
+ * Menyensor kata kotor dalam teks
+ *
+ * @param text Teks yang akan disensor
+ * @param options Opsi untuk filter
+ * @returns FilterResult dengan hasil filter
+ */
+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
+ */
+declare function isProfane(text: string, options?: FilterOptions): boolean;
+
+/**
+ * Menganalisis teks untuk kata kotor
+ *
+ * @param text Teks yang akan dianalisis
+ * @param options Opsi untuk analisis
+ * @return AnalysisResult dengan hasil analisis
+ */
+declare function analyze(text: string, options?: FilterOptions): AnalysisResult;
+/**
+ * Menganalisis daftar teks dan ringkasan
+ *
+ * @param texts Daftar teks yang dianalisis
+ * @param options Opsi untuk analisis
+ * @return Objek dengan ringkasan analisis
+ */
+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
+ */
+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 contextWindowSize Ukuran konteks (jumlah kata) di sekitar kata kotor
+ * @param options Opsi untuk analisis
+ * @returns Konteks di dekat kata kotor
+ */
+declare function analyzeWithContext(text: string, contextWindowSize?: number, options?: FilterOptions): Array<{
+    word: string;
+    context: string;
+    position: {
+        start: number;
+        end: number;
+    };
+}>;
+
+/**
+ * Menyensor kata dengan karakter pengganti
+ *
+ * @param word Kata yang akan disensor
+ * @param replaceChar Karakter pengganti (default: '*')
+ * @param keepFirstAndLast Apakah harus menyimpan huruf pertama dan terakhir
+ * @returns Kata yang telah disensor
+ */
+declare function censorWord(word: string, replaceChar?: string, keepFirstAndLast?: boolean): string;
+/**
+ * Menormalisasi string untuk keperluan pembandingan
+ *
+ * @param text Teks yang akan dinormalisasi
+ * @returns Teks yang telah dinormalisasi
+ */
+declare function normalizeText(text: string): string;
+/**
+ * Mendeteksi apakah string berisi sebagian atau keseluruhan kata dalam wordList
+ *
+ * @param text Teks yang akan diperiksa
+ * @param wordList Daftar kata yang dicari
+ * @param checkSubstring Apakah harus memeriksa substring
+ * @returns Boolean apakah teks mengandung kata-kata dalam wordList
+ */
+declare function containsAnyWord(text: string, wordList: string[], checkSubstring?: boolean): boolean;
+/**
+ * Memerikasa apakah stirng merupakan kode untuk kata kotor
+ * (Menangkap kasus seperti disensor dengan titik atau garis: a**ing, b*bi, dll)
+ *
+ * @param text Teks yang akan diperika
+ * @param wordList daftar kata kotor
+ * @return Boolean apakah teks mengandung kata kotor
+ */
+declare function containsEuphemism(text: string, wordList: string[]): boolean;
+/**
+ * Mendeteksi upaya menghindari filter dengan pemisahan kata
+ * (Tangkap kasus seperti: a n j i n g, b-a-b-i, dll)
+ *
+ * @param text Teks yang akan diperiksa
+ * @param wordList Daftar kata kotor
+ * @returns Boolean apakah teks mengandung upaya menghindari filter
+ */
+declare function detectSplitWords(text: string, wordList: string[]): boolean;
+declare function escapeRegExp(string: string): string;
+/**
+ * Mengganti sebagian kata dengan masking
+ * (berguna untuk email, nomor telepon, dll)
+ *
+ * @param text Teks untuk dimasking
+ * @param visibleStart Jumlah karakter yang terlihat di awal
+ * @param visibleEnd Jumlah karakter yang terlihat di akhir
+ * @param maskChar Karakter masking
+ * @returns Teks yang telah dimasking
+ */
+declare function maskText(text: string, visibleStart?: number, visibleEnd?: number, maskChar?: string): string;
+/**
+ * menguabh sting menjadi bentuk leet speak
+ * (untuk testing filter bypass)
+ *
+ * @param text Teks yang akan diubah
+ * @return Teks yang telah diubah ke leet speak
+ */
+declare function toLeetSpeak(text: string): string;
+/**
+ * memisahkan teks menajdi kelimat
+ *
+ * @param text Teks yang akan dipisahkan
+ * @return Array kalimat yang telah dipisahkan
+ */
+declare function splitIntoSentences(text: string): string[];
+/**
+ * mengambil kata-kata di sekitar indeks tertentu
+ *
+ * @param text Teks yang akan diambil
+ * @param index Indeks dalam teks
+ * @param windowSize jumlah kata di sekitar indeks
+ * @return Kata-kata di sekitar indeks
+ */
+declare function getContextAroundIndex(text: string, index: number, windowSize?: number): string;
+
+/**
+ * Membuat pola regex untuk mencocokkan kata
+ *
+ * @param word Kata yang akan dibuat pola regex-nya
+ * @param options Opsi untuk pembuatan regex
+ * @returns Objek RegExp
+ */
+declare function createWordRegex(word: string, options?: RegexOptions): RegExp;
+/**
+ * Menambahkan variasi leet speak ke pola regex
+ *
+ * Contoh:
+ * - 'a' bisa jadi '4', '@'
+ * - 'i' bisa jadi '1', '!'
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan variasi leet speak
+ */
+declare function addLeetSpeakVariations(pattern: string): string;
+/**
+ * Menambahkan kemungkinan split/pemisahan antar karakter
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan kemungkinan split
+ */
+declare function addSplitVariations(pattern: string): string;
+/**
+ * Membuat regex untuk mencari kata dengan variasi spasi dan karakter penghubung
+ * Berguna untuk mendeteksi upaya menghindari filter dengan menambahkan spasi atau karakter lain
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @returns Objek RegExp
+ */
+declare function createEvasionRegex(word: string): RegExp;
+/**
+ * Menambahkan variasi ejaan Bahasa Indonesia
+ *
+ * @param pattern Pola regex asli
+ * @returns Pola regex dengan variasi ejaan Bahasa Indonesia
+ */
+declare function addIndonesianVariations(pattern: string): string;
+/**
+ * Membuat regex untuk mencocokkan kata dengan mempertimbangkan variasi ejaan Bahasa Indonesia
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @returns Objek RegExp
+ */
+declare function createIndonesianVariationRegex(word: string): RegExp;
+/**
+ * Membuat regex untuk mencocokkan kata dengan konteks
+ *
+ * @param word Kata yang akan dibuat pola regexnya
+ * @param contextSize Jumlah kata konteks sebelum dan sesudah
+ * @returns Objek RegExp
+ */
+declare function createContextRegex(word: string, contextSize?: number): RegExp;
+/**
+ * Membuat regex untuk mencocokkan variasi penulisan kata
+ *
+ * @param word Kata dasar
+ * @returns Objek RegExp untuk mencocokkan berbagai bentuk kata
+ */
+declare function createWordFormRegex(word: string): RegExp;
+
+/**
+ * Menghitung jarak Levenshtein antara dua string
+ * (Jumlah operasi insert, delete, atau replace untuk mengubah string1 menjadi string2)
+ *
+ * @param str1 String pertama
+ * @param str2 String kedua
+ * @returns Jarak Levenshtein
+ */
+declare function levenshteinDistance(str1: string, str2: string): number;
+/**
+ * Menghitung tingkat kesamaan antara dua string
+ *
+ * @param str1 String pertama
+ * @param str2 String kedua
+ * @returns Nilai kesamaan (0-1, di mana 1 berarti identik)
+ */
+declare function stringSimilarity(str1: string, str2: string): number;
+/**
+ * Mencari string yang paling mirip dari array
+ *
+ * @param target String target
+ * @param candidates Array string kandidat
+ * @param threshold Minimum kesamaan yang diterima (0-1)
+ * @returns String yang paling mirip atau null jika tidak ada yang di atas threshold
+ */
+declare function findMostSimilar(target: string, candidates: string[], threshold?: number): string | null;
+/**
+ * Mencari string yang paling mirip dari array menggunakan Levenshtein distance
+ *
+ * @param target String target
+ * @param candidates Array string kandidat
+ * @param threshold Minimum kesamaan yang diterima (0-1)
+ * @param maxDistance Jarak Levenshtein maksimal yang diterima (default: 3)
+ * @returns String yang paling mirip atau null jika tidak ada yang di atas threshold
+ */
+declare function findMostSimilarWithLevenshtein(target: string, candidates: string[], threshold?: number, maxDistance?: number): string | null;
+/**
+ * Cek apakah string mungkin merupakan variasi dari kata kotor
+ * menggunakan kesamaan string
+ *
+ * @param input String yang akan diperiksa
+ * @param profanityWords Daftar kata kotor
+ * @param threshold Batas minimum kesamaan (default: 0.75)
+ * @returns Array [Boolean (apakah variasi), String original (jika ditemukan)]
+ */
+declare function isPossibleProfanityVariation(input: string, profanityWords: string[], threshold?: number): [boolean, string | null];
+/**
+ * Mengelompokkan kata berdasarkan kesamaan
+ *
+ * @param words Daftar kata
+ * @param threshold Batas minimum kesamaan (default: 0.8)
+ * @returns Array kluster kata yang mirip
+ */
+declare function clusterSimilarWords(words: string[], threshold?: number): string[][];
+/**
+ * Cari kata-kata kotor yang mungkin dari teks menggunakan kesamaan string
+ * dengan optimasi untuk mengurangi kompleksitas
+ *
+ * @param text Teks yang akan diperiksa
+ * @param profanityWords Daftar kata kotor
+ * @param threshold Batas minimum kesamaan (default: 0.8)
+ * @returns Array kata yang mungkin merupakan kata kotor
+ */
+/**
+ * Cari kata-kata kotor yang mungkin dari teks berdasarkan kemiripan string
+ * dengan optimasi biar prosesnya nggak terlalu berat
+ *
+ * @param text Teks yang mau dicek
+ * @param profanityWords Daftar kata-kata kotor/kasar
+ * @param threshold Batas minimal kemiripan (default: 0.8)
+ * @returns Array kata yang kemungkinan kata kotor/kasar
+ */
+declare function findPossibleProfanityBySimiliarity(text: string, profanityWords: string[], threshold?: number): Array<{
+    word: string;
+    original: string;
+    similarity: number;
+}>;
+/**
+ * Cari kata-kata kotor yang mungkin dari teks menggunakan Levenshtein distance
+ *
+ * @param text Teks yang akan diperiksa
+ * @param profanityWords Daftar kata kotor
+ * @param threshold Batas minimum kesamaan (default: 0.8)
+ * @param maxDistance Jarak Levenshtein maksimal (default: 2)
+ * @returns Array kata yang mungkin merupakan kata kotor
+ */
+declare function findProfanityByLevenshteinDistance(text: string, profanityWords: string[], threshold?: number, maxDistance?: number): Array<{
+    word: string;
+    original: string;
+    similarity: number;
+    distance: number;
+}>;
+
+declare const DEFAULT_OPTIONS: FilterOptions;
+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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+};
+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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+};
+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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+    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;
+        useLevenshtein?: boolean;
+        maxLevenshteinDistance?: number;
+    };
+};
+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
+ */
+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
+ */
+declare function getPresetOptions(presetName: string, additionalOptions?: Partial<FilterOptions>): FilterOptions;
+/**
+ * Mendapatkan karakter pengganti
+ *
+ * @param type Tipe karakter pengganti
+ * @returns Karakter pengganti
+ */
+declare function getReplacementChar(type?: keyof typeof REPLACEMENT_CHARS): string;
+/**
+ * Membuat karakter pengganti random dari grawlix
+ *
+ * @returns Karakter pengganti random
+ */
+declare function getRandomGrawlix(): string;
+/**
+ * Membuat string pengganti untuk kata menggunakan grawlix random
+ *
+ * @param length Panjang string
+ * @returns String pengganti
+ */
+declare function makeRandomGrawlixString(length: number): string;
+
+declare class IDProfanityFilter {
+    private options;
+    /**
+     * Membuat instance filter baru
+     * @param options Opsi untuk filter
+     */
+    constructor(options?: FilterOptions);
+    /**
+     * Menyensor teks yang diberikan
+     * @param text Teks yang akan disensor
+     * @returns Hasil filter
+     */
+    filter(text: string): FilterResult;
+    /**
+     * Memeriksa apakah teks mengandung kata kotor
+     * @param text Teks yang akan diperiksa
+     * @returns Boolean apakah teks mengandung kata kotor
+     */
+    isProfane(text: string): boolean;
+    /**
+     * Menganalisis teks untuk kata kotor
+     * @param text Teks yang akan dianalisis
+     * @returns Hasil analisis
+     */
+    analyze(text: string): AnalysisResult;
+    /**
+     * Menganalisis batch teks untuk kata kotor
+     * @param texts Array dari teks yang akan dianalisis
+     * @returns Hasil analisis batch
+     */
+    batchAnalyze(texts: string[]): {
+        totalTexts: number;
+        profaneTexts: number;
+        cleanTexts: number;
+        averageSeverity: number;
+        topCategories: ProfanityCategory[];
+        topRegions: Region[];
+        mostFrequentWords: Array<{
+            word: string;
+            count: number;
+        }>;
+    };
+    /**
+     * Menganalisis teks per-kalimat
+     * @param text Teks yang akan dianalisis
+     * @returns Array hasil analisis per-kalimat
+     */
+    analyzeBySentence(text: string): (AnalysisResult & {
+        sentence: string;
+    })[];
+    /**
+     * Menganalisis teks dengan konteks di sekitar kata kotor
+     * @param text Teks yang akan dianalisis
+     * @param contextWindowSize Jumlah kata konteks
+     * @returns Konteks di dekat kata kotor
+     */
+    analyzeWithContext(text: string, contextWindowSize?: number): {
+        word: string;
+        context: string;
+        position: {
+            start: number;
+            end: number;
+        };
+    }[];
+    /**
+     * Mengubah opsi filter
+     * @param options Opsi baru untuk filter
+     */
+    setOptions(options: Partial<FilterOptions>): void;
+    /**
+     * Menggunakan preset yang telah ditentukan
+     * @param presetName Nama preset yang akan digunakan
+     * @param additionalOptions Opsi tambahan untuk override
+     */
+    usePreset(presetName: string, additionalOptions?: Partial<FilterOptions>): void;
+    /**
+     * Menetapkan daftar kata kustom
+     * @param wordList Daftar kata untuk digunakan
+     */
+    setWordList(wordList: string[]): void;
+    /**
+     * Menambahkan kata ke whitelist
+     * @param word Kata yang akan diabaikan
+     */
+    addToWhitelist(word: string): void;
+    /**
+     * Menghapus kata dari whitelist
+     * @param word Kata yang akan dihapus dari whitelist
+     */
+    removeFromWhitelist(word: string): void;
+    /**
+     * Mengaktifkan deteksi variasi ejaan Indonesia
+     */
+    enableIndonesianVariations(): void;
+    /**
+     * Mengaktifkan deteksi kata yang dipisah
+     */
+    enableSplitWordDetection(): void;
+    /**
+     * Mengaktifkan deteksi berdasarkan kesamaan
+     * @param threshold Threshold kesamaan (0-1)
+     * @param useLevenshtein Gunakan algoritma Levenshtein untuk deteksi
+     * @param maxLevenshteinDistance Jarak maksimal Levenshtein (default: 2)
+     */
+    enableSimilarityDetection(threshold?: number, useLevenshtein?: boolean, maxLevenshteinDistance?: number): void;
+    /**
+     * Mengaktifkan deteksi berbasis Levenshtein distance
+     * @param threshold Threshold kesamaan (0-1)
+     * @param maxDistance Jarak maksimal Levenshtein (default: 2)
+     */
+    enableLevenshteinDetection(threshold?: number, maxDistance?: number): void;
+}
+declare const idFilter: {
+    filter: (text: string, options?: FilterOptions) => FilterResult;
+    isProfane: (text: string, options?: FilterOptions) => boolean;
+    analyze: (text: string, options?: FilterOptions) => AnalysisResult;
+    batchAnalyze: (texts: string[], options?: FilterOptions) => {
+        totalTexts: number;
+        profaneTexts: number;
+        cleanTexts: number;
+        averageSeverity: number;
+        topCategories: ProfanityCategory[];
+        topRegions: Region[];
+        mostFrequentWords: Array<{
+            word: string;
+            count: number;
+        }>;
+    };
+    getPresetOptions: typeof getPresetOptions;
+    presets: {
+        filter: {
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+        };
+        category: {
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+        };
+        region: {
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+            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;
+                useLevenshtein?: boolean;
+                maxLevenshteinDistance?: number;
+            };
+        };
+    };
+};
+
+export { CATEGORY_PRESETS, DEFAULT_OPTIONS, FILTER_PRESETS, IDProfanityFilter, REGION_PRESETS, REPLACEMENT_CHARS, addIndonesianVariations, addLeetSpeakVariations, addSplitVariations, analyze, analyzeBySentence, analyzeWithContext, batchAnalyze, calculateSeverity, censorWord, clusterSimilarWords, containsAnyWord, containsEuphemism, createContextRegex, createEvasionRegex, createIndonesianVariationRegex, createOptions, createWordFormRegex, createWordRegex, IDProfanityFilter as default, detectSplitWords, escapeRegExp, filter, findCategories, findMostSimilar, findMostSimilarWithLevenshtein, findPossibleProfanityBySimiliarity, findProfanity, findProfanityByLevenshteinDistance, findProfanityWithMetadata, findRegions, getContextAroundIndex, getPresetOptions, getRandomGrawlix, getReplacementChar, idFilter, isPossibleProfanityVariation, isProfane, levenshteinDistance, makeRandomGrawlixString, maskText, normalizeText, splitIntoSentences, stringSimilarity, toLeetSpeak };
 export type { AnalysisResult, FilterOptions, FilterResult, ProfanityCategory, ProfanityWord, RegexOptions, Region };