allprofanity 2.1.0 → 2.2.0

package/dist/index.d.ts

@@ -6,16 +6,29 @@ export { default as spanishBadWords } from "./languages/spanish-words.js";
 export { default as bengaliBadWords } from "./languages/bengali-words.js";
 export { default as tamilBadWords } from "./languages/tamil-words.js";
 export { default as teluguBadWords } from "./languages/telugu-words.js";
+export { default as brazilianBadWords } from "./languages/brazilian-words.js";
 /**
- * Logging interface for the library
+ * Logger interface for the library.
  */
 export interface Logger {
+    /**
+     * Log informational messages.
+     * @param message - The message to log.
+     */
     info(message: string): void;
+    /**
+     * Log warning messages.
+     * @param message - The message to log.
+     */
     warn(message: string): void;
+    /**
+     * Log error messages.
+     * @param message - The message to log.
+     */
     error(message: string): void;
 }
 /**
- * Configuration options for AllProfanity
+ * Configuration options for AllProfanity.
  */
 export interface AllProfanityOptions {
     languages?: string[];
@@ -27,9 +40,34 @@ export interface AllProfanityOptions {
     strictMode?: boolean;
     detectPartialWords?: boolean;
     logger?: Logger;
+    algorithm?: {
+        matching?: "trie" | "aho-corasick" | "hybrid";
+        useAhoCorasick?: boolean;
+        useBloomFilter?: boolean;
+        useContextAnalysis?: boolean;
+    };
+    bloomFilter?: {
+        enabled?: boolean;
+        expectedItems?: number;
+        falsePositiveRate?: number;
+    };
+    ahoCorasick?: {
+        enabled?: boolean;
+        prebuild?: boolean;
+    };
+    contextAnalysis?: {
+        enabled?: boolean;
+        contextWindow?: number;
+        languages?: string[];
+        scoreThreshold?: number;
+    };
+    performance?: {
+        cacheSize?: number;
+        enableCaching?: boolean;
+    };
 }
 /**
- * Severity levels for profanity detection
+ * Severity levels for profanity detection.
  */
 export declare enum ProfanitySeverity {
     MILD = 1,
@@ -38,7 +76,7 @@ export declare enum ProfanitySeverity {
     EXTREME = 4
 }
 /**
- * Detection result interface
+ * Detection result for profanity detection.
  */
 export interface ProfanityDetectionResult {
     hasProfanity: boolean;
@@ -52,8 +90,7 @@ export interface ProfanityDetectionResult {
     }>;
 }
 /**
- * Advanced AllProfanity - Fixed profanity filter with multi-language support
- * Addresses all critical issues from the original implementation
+ * Main class for profanity detection and filtering.
  */
 export declare class AllProfanity {
     private readonly profanityTrie;
@@ -68,127 +105,216 @@ export declare class AllProfanity {
     private readonly availableLanguages;
     private readonly leetMappings;
     private readonly dynamicWords;
+    private ahoCorasickAutomaton;
+    private bloomFilter;
+    private contextAnalyzer;
+    private matchingAlgorithm;
+    private resultCache;
+    /**
+     * Create an AllProfanity instance.
+     * @param options - Profanity filter configuration options.
+     */
     constructor(options?: AllProfanityOptions);
     /**
-     * Normalize text by converting leet speak to regular characters.
+     * Initialize advanced algorithms based on configuration
+     */
+    private initializeAdvancedAlgorithms;
+    /**
+     * Normalize leet speak to regular characters.
+     * @param text - The input text.
+     * @returns Normalized text.
      */
     private normalizeLeetSpeak;
     /**
-     * Properly escape regex special characters
+     * Escape regex special characters in a string.
+     * @param str - The string to escape.
+     * @returns The escaped string.
      */
     private escapeRegex;
     /**
-     * Check if a position has word boundaries (for strict mode)
+     * Check if a match is bounded by word boundaries (strict mode).
+     * @param text - The text.
+     * @param start - Start index.
+     * @param end - End index.
+     * @returns True if match is at word boundaries, false otherwise.
      */
     private hasWordBoundaries;
     /**
-     * Helper method to verify whole-word matching.
+     * Determine if a match is a whole word.
+     * @param text - The text.
+     * @param start - Start index.
+     * @param end - End index.
+     * @returns True if whole word, false otherwise.
      */
     private isWholeWord;
     /**
-     * Check if a match is whitelisted (by actual matched substring and dictionary word)
+     * Check if a match is whitelisted.
+     * @param word - Word from dictionary.
+     * @param matchedText - Actual matched text.
+     * @returns True if whitelisted, false otherwise.
      */
     private isWhitelistedMatch;
     /**
-     * Remove overlapping matches, keep only the longest at each start position
+     * Remove overlapping matches, keeping only the longest at each start position.
+     * @param matches - Array of match results.
+     * @returns Deduplicated matches.
      */
     private deduplicateMatches;
     /**
-     * Advanced profanity detection using efficient trie-based algorithm
+     * Use Aho-Corasick algorithm for pattern matching
+     */
+    private findMatchesWithAhoCorasick;
+    /**
+     * Hybrid approach: Aho-Corasick for fast matching, Bloom Filter for validation
+     */
+    private findMatchesHybrid;
+    /**
+     * Apply context analysis to filter false positives
+     */
+    private applyContextAnalysis;
+    /**
+     * Detect profanity in a given text.
+     * @param text - The text to check.
+     * @returns Profanity detection result.
      */
     detect(text: string): ProfanityDetectionResult;
     /**
      * Main matching function, with whole-word logic.
+     * @param searchText - The normalized text to search.
+     * @param originalText - The original text.
+     * @param matches - Array to collect matches.
      */
     private findMatches;
     /**
-     * Generate cleaned text by replacing profane words (non-overlapping only)
+     * Generate cleaned text by replacing profane words.
+     * @param originalText - The original text.
+     * @param matches - Array of matches.
+     * @returns Cleaned text.
      */
     private generateCleanedText;
     /**
-     * Simple boolean check for profanity
+     * Check if a string contains profanity.
+     * @param text - The text to check.
+     * @returns True if profanity is found, false otherwise.
      */
     check(text: string): boolean;
     /**
-     * Clean text with custom placeholder
+     * Clean text with a custom placeholder.
+     * @param text - The text to clean.
+     * @param placeholder - The placeholder to use.
+     * @returns Cleaned text.
      */
     clean(text: string, placeholder?: string): string;
     /**
-     * Clean text by replacing each profane word with a single placeholder (word-level)
+     * Clean text by replacing each profane word with a single placeholder (word-level).
+     * @param text - The text to clean.
+     * @param placeholder - The placeholder to use.
+     * @returns Word-level cleaned text.
      */
     cleanWithPlaceholder(text: string, placeholder?: string): string;
     /**
-     * Add word(s) to the profanity list
+     * Add word(s) to the profanity filter.
+     * @param word - Word or array of words to add.
      */
     add(word: string | string[]): void;
     /**
-     * Remove word(s) from the profanity list
+     * Remove word(s) from the profanity filter.
+     * @param word - Word or array of words to remove.
      */
     remove(word: string | string[]): void;
     /**
-     * Add words to whitelist
+     * Add words to the whitelist.
+     * @param words - Words to whitelist.
      */
     addToWhitelist(words: string[]): void;
     /**
-     * Remove words from whitelist
+     * Remove words from the whitelist.
+     * @param words - Words to remove from whitelist.
      */
     removeFromWhitelist(words: string[]): void;
     /**
-     * Helper for whitelist checking with correct normalization
+     * Check if a word is whitelisted.
+     * @param word - The word to check.
+     * @returns True if whitelisted, false otherwise.
      */
     private isWhitelisted;
     /**
-     * Load a built-in language dictionary
+     * Load a built-in language dictionary.
+     * @param language - The language key.
+     * @returns True if loaded, false otherwise.
      */
     loadLanguage(language: string): boolean;
     /**
-     * Load multiple languages at once
+     * Load multiple language dictionaries.
+     * @param languages - Array of languages to load.
+     * @returns Number of successfully loaded languages.
      */
     loadLanguages(languages: string[]): number;
     /**
-     * Load all Indian languages
+     * Load all supported Indian languages.
+     * @returns Number of loaded Indian languages.
      */
     loadIndianLanguages(): number;
     /**
-     * Load a custom dictionary
+     * Load a custom dictionary.
+     * @param name - Name of the dictionary.
+     * @param words - Words to add.
      */
     loadCustomDictionary(name: string, words: string[]): void;
     /**
-     * Add a single word to the trie structure
+     * Add a single word to the trie.
+     * @param word - The word to add.
+     * @returns True if added, false otherwise.
      */
     private addWordToTrie;
     /**
-     * Remove overlapping matches, keep only the longest at each start position
+     * Calculate severity from matches.
+     * @param matches - Array of matches.
+     * @returns Severity level.
      */
     private calculateSeverity;
     /**
-     * Clear all loaded dictionaries
+     * Clear all loaded dictionaries and dynamic words.
      */
     clearList(): void;
     /**
-     * Set placeholder character
+     * Set the placeholder character for filtered words.
+     * @param placeholder - The placeholder character.
      */
     setPlaceholder(placeholder: string): void;
     /**
-     * Get loaded languages
+     * Get the list of loaded languages.
+     * @returns Array of loaded language keys.
      */
     getLoadedLanguages(): string[];
     /**
-     * Get available languages
+     * Get the list of available built-in languages.
+     * @returns Array of available language keys.
      */
     getAvailableLanguages(): string[];
     /**
-     * Get current configuration
+     * Get the current configuration of the profanity filter.
+     * @returns Partial configuration object.
      */
     getConfig(): Partial<AllProfanityOptions>;
     /**
-     * Rebuilds the profanity trie from loaded language dictionaries and dynamic words.
+     * Rebuild the profanity trie from loaded dictionaries and dynamic words.
      */
     private rebuildTrie;
     /**
-     * Update configuration. Rebuild trie if needed.
+     * Update configuration options for the profanity filter.
+     * @param options - Partial configuration object.
      */
     updateConfig(options: Partial<AllProfanityOptions>): void;
+    /**
+     * Create an AllProfanity instance from a configuration object.
+     * @param config - Configuration object
+     * @returns A new AllProfanity instance
+     */
+    static fromConfig(config: AllProfanityOptions | any): AllProfanity;
 }
+/**
+ * Singleton instance of AllProfanity with default configuration.
+ */
 declare const allProfanity: AllProfanity;
 export default allProfanity;