allprofanity 2.1.0 → 2.2.0

package/dist/index.js

@@ -1,4 +1,4 @@
-// Import language dictionaries (assuming these exist)
+// Language dictionaries imports
 import englishBadWords from "./languages/english-words.js";
 import hindiBadWords from "./languages/hindi-words.js";
 import frenchBadWords from "./languages/french-words.js";
@@ -7,6 +7,11 @@ import spanishBadWords from "./languages/spanish-words.js";
 import bengaliBadWords from "./languages/bengali-words.js";
 import tamilBadWords from "./languages/tamil-words.js";
 import teluguBadWords from "./languages/telugu-words.js";
+import brazilianBadWords from "./languages/brazilian-words.js";
+// Advanced algorithm imports
+import { AhoCorasick } from "./algos/aho-corasick.js";
+import { BloomFilter } from "./algos/bloom-filter.js";
+import { ContextAnalyzer } from "./algos/context-patterns.js";
 // Export language dictionaries for direct access
 export { default as englishBadWords } from "./languages/english-words.js";
 export { default as hindiBadWords } from "./languages/hindi-words.js";
@@ -16,8 +21,9 @@ 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";
 /**
- * Default console logger implementation
+ * Default console logger implementation.
  */
 class ConsoleLogger {
     info(message) {
@@ -31,7 +37,7 @@ class ConsoleLogger {
     }
 }
 /**
- * Severity levels for profanity detection
+ * Severity levels for profanity detection.
  */
 export var ProfanitySeverity;
 (function (ProfanitySeverity) {
@@ -41,7 +47,11 @@ export var ProfanitySeverity;
     ProfanitySeverity[ProfanitySeverity["EXTREME"] = 4] = "EXTREME";
 })(ProfanitySeverity = ProfanitySeverity || (ProfanitySeverity = {}));
 /**
- * Validates input parameters
+ * Validate a string parameter.
+ * @param input - The input to validate.
+ * @param paramName - The name of the parameter.
+ * @returns The validated string.
+ * @throws {TypeError} If input is not a string.
  */
 function validateString(input, paramName) {
     if (typeof input !== "string") {
@@ -49,6 +59,13 @@ function validateString(input, paramName) {
     }
     return input;
 }
+/**
+ * Validate a string array parameter.
+ * @param input - The input to validate.
+ * @param paramName - The name of the parameter.
+ * @returns The validated string array.
+ * @throws {TypeError} If input is not an array.
+ */
 function validateStringArray(input, paramName) {
     if (!Array.isArray(input)) {
         throw new TypeError(`${paramName} must be an array`);
@@ -62,7 +79,7 @@ function validateStringArray(input, paramName) {
     });
 }
 /**
- * Efficient Trie data structure for fast string matching
+ * Trie node for efficient string matching.
  */
 class TrieNode {
     constructor() {
@@ -71,7 +88,8 @@ class TrieNode {
         this.word = "";
     }
     /**
-     * Add a word to the trie
+     * Add a word to the trie.
+     * @param word - The word to add.
      */
     addWord(word) {
         let current = this;
@@ -88,7 +106,9 @@ class TrieNode {
         current.word = word;
     }
     /**
-     * Remove a word from the trie
+     * Remove a word from the trie.
+     * @param word - The word to remove.
+     * @returns True if the word was removed, false otherwise.
      */
     removeWord(word) {
         return this.removeHelper(word, 0);
@@ -112,7 +132,11 @@ class TrieNode {
         return false;
     }
     /**
-     * Find all matches starting at a given position
+     * Find all matches starting at a given position.
+     * @param text - The text to search.
+     * @param startPos - The start position.
+     * @param allowPartial - Whether to allow partial word matches.
+     * @returns Array of matches.
      */
     findMatches(text, startPos, allowPartial) {
         const matches = [];
@@ -146,7 +170,7 @@ class TrieNode {
         return matches;
     }
     /**
-     * Clear all words from the trie
+     * Clear all words from the trie.
      */
     clear() {
         this.children.clear();
@@ -155,22 +179,23 @@ class TrieNode {
     }
 }
 /**
- * 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 class AllProfanity {
+    /**
+     * Create an AllProfanity instance.
+     * @param options - Profanity filter configuration options.
+     */
     constructor(options) {
         var _a, _b, _c, _d, _e;
         this.profanityTrie = new TrieNode();
         this.whitelistSet = new Set();
         this.loadedLanguages = new Set();
-        // Configuration
         this.defaultPlaceholder = "*";
         this.enableLeetSpeak = true;
         this.caseSensitive = false;
         this.strictMode = false;
         this.detectPartialWords = false;
-        // Available language dictionaries
         this.availableLanguages = {
             english: englishBadWords || [],
             hindi: hindiBadWords || [],
@@ -180,8 +205,8 @@ export class AllProfanity {
             bengali: bengaliBadWords || [],
             tamil: tamilBadWords || [],
             telugu: teluguBadWords || [],
+            brazilian: brazilianBadWords || [],
         };
-        // Fixed leet speak mappings
         this.leetMappings = new Map([
             ["@", "a"],
             ["^", "a"],
@@ -240,10 +265,14 @@ export class AllProfanity {
             ["2", "z"],
             ["7_", "z"],
         ]);
-        // Dynamic words added at runtime
         this.dynamicWords = new Set();
+        // Advanced algorithms
+        this.ahoCorasickAutomaton = null;
+        this.bloomFilter = null;
+        this.contextAnalyzer = null;
+        this.matchingAlgorithm = "trie";
+        this.resultCache = null;
         this.logger = (options === null || options === void 0 ? void 0 : options.logger) || new ConsoleLogger();
-        // Validate and set configuration
         if ((options === null || options === void 0 ? void 0 : options.defaultPlaceholder) !== undefined) {
             this.setPlaceholder(options.defaultPlaceholder);
         }
@@ -251,18 +280,17 @@ export class AllProfanity {
         this.caseSensitive = (_b = options === null || options === void 0 ? void 0 : options.caseSensitive) !== null && _b !== void 0 ? _b : false;
         this.strictMode = (_c = options === null || options === void 0 ? void 0 : options.strictMode) !== null && _c !== void 0 ? _c : false;
         this.detectPartialWords = (_d = options === null || options === void 0 ? void 0 : options.detectPartialWords) !== null && _d !== void 0 ? _d : false;
-        // Load whitelist
         if (options === null || options === void 0 ? void 0 : options.whitelistWords) {
             this.addToWhitelist(options.whitelistWords);
         }
-        // Load default languages
+        // Initialize advanced algorithms BEFORE loading dictionaries
+        // so that words can be added to all data structures
+        this.initializeAdvancedAlgorithms(options);
         this.loadLanguage("english");
         this.loadLanguage("hindi");
-        // Load additional languages
         if ((_e = options === null || options === void 0 ? void 0 : options.languages) === null || _e === void 0 ? void 0 : _e.length) {
             options.languages.forEach((lang) => this.loadLanguage(lang));
         }
-        // Load custom dictionaries
         if (options === null || options === void 0 ? void 0 : options.customDictionaries) {
             Object.entries(options.customDictionaries).forEach(([name, words]) => {
                 this.loadCustomDictionary(name, words);
@@ -270,7 +298,55 @@ export class AllProfanity {
         }
     }
     /**
-     * Normalize text by converting leet speak to regular characters.
+     * Initialize advanced algorithms based on configuration
+     */
+    initializeAdvancedAlgorithms(options) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        // Set matching algorithm
+        if ((_a = options === null || options === void 0 ? void 0 : options.algorithm) === null || _a === void 0 ? void 0 : _a.matching) {
+            this.matchingAlgorithm = options.algorithm.matching;
+        }
+        // Initialize Bloom Filter if enabled
+        const bloomEnabled = ((_b = options === null || options === void 0 ? void 0 : options.algorithm) === null || _b === void 0 ? void 0 : _b.useBloomFilter) ||
+            ((_c = options === null || options === void 0 ? void 0 : options.bloomFilter) === null || _c === void 0 ? void 0 : _c.enabled) ||
+            this.matchingAlgorithm === "hybrid";
+        if (bloomEnabled) {
+            const expectedItems = ((_d = options === null || options === void 0 ? void 0 : options.bloomFilter) === null || _d === void 0 ? void 0 : _d.expectedItems) || 10000;
+            const falsePositiveRate = ((_e = options === null || options === void 0 ? void 0 : options.bloomFilter) === null || _e === void 0 ? void 0 : _e.falsePositiveRate) || 0.01;
+            this.bloomFilter = new BloomFilter(expectedItems, falsePositiveRate);
+            this.logger.info(`Bloom Filter initialized with ${expectedItems} expected items and ${(falsePositiveRate * 100).toFixed(2)}% false positive rate`);
+        }
+        // Initialize Aho-Corasick if enabled
+        const ahoEnabled = ((_f = options === null || options === void 0 ? void 0 : options.algorithm) === null || _f === void 0 ? void 0 : _f.useAhoCorasick) ||
+            ((_g = options === null || options === void 0 ? void 0 : options.ahoCorasick) === null || _g === void 0 ? void 0 : _g.enabled) ||
+            this.matchingAlgorithm === "aho-corasick" ||
+            this.matchingAlgorithm === "hybrid";
+        if (ahoEnabled) {
+            this.ahoCorasickAutomaton = new AhoCorasick([]);
+            this.logger.info("Aho-Corasick automaton initialized");
+        }
+        // Initialize Context Analyzer if enabled
+        const contextEnabled = ((_h = options === null || options === void 0 ? void 0 : options.algorithm) === null || _h === void 0 ? void 0 : _h.useContextAnalysis) ||
+            ((_j = options === null || options === void 0 ? void 0 : options.contextAnalysis) === null || _j === void 0 ? void 0 : _j.enabled);
+        if (contextEnabled) {
+            const contextLanguages = ((_k = options === null || options === void 0 ? void 0 : options.contextAnalysis) === null || _k === void 0 ? void 0 : _k.languages) || ["en"];
+            this.contextAnalyzer = new ContextAnalyzer(contextLanguages);
+            if ((_l = options === null || options === void 0 ? void 0 : options.contextAnalysis) === null || _l === void 0 ? void 0 : _l.contextWindow) {
+                this.contextAnalyzer.setContextWindow(options.contextAnalysis.contextWindow);
+            }
+            this.logger.info(`Context Analyzer initialized for languages: ${contextLanguages.join(", ")}`);
+        }
+        // Initialize result cache if enabled
+        if ((_m = options === null || options === void 0 ? void 0 : options.performance) === null || _m === void 0 ? void 0 : _m.enableCaching) {
+            const cacheSize = options.performance.cacheSize || 1000;
+            this.resultCache = new Map();
+            this.logger.info(`Result caching enabled with size limit: ${cacheSize}`);
+        }
+    }
+    /**
+     * Normalize leet speak to regular characters.
+     * @param text - The input text.
+     * @returns Normalized text.
      */
     normalizeLeetSpeak(text) {
         if (!this.enableLeetSpeak)
@@ -284,13 +360,19 @@ export class AllProfanity {
         return normalized;
     }
     /**
-     * Properly escape regex special characters
+     * Escape regex special characters in a string.
+     * @param str - The string to escape.
+     * @returns The escaped string.
      */
     escapeRegex(str) {
         return str.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
     }
     /**
-     * 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.
      */
     hasWordBoundaries(text, start, end) {
         if (!this.strictMode)
@@ -301,27 +383,24 @@ export class AllProfanity {
         return (wordBoundaryRegex.test(beforeChar) && wordBoundaryRegex.test(afterChar));
     }
     /**
-     * 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.
      */
     isWholeWord(text, start, end) {
-        // Check left boundary
-        if (start === 0) {
-            // ok
-        }
-        else if (/\w/.test(text[start - 1])) {
+        if (start !== 0 && /\w/.test(text[start - 1]))
             return false;
-        }
-        // Check right boundary
-        if (end === text.length) {
-            // ok
-        }
-        else if (/\w/.test(text[end])) {
+        if (end !== text.length && /\w/.test(text[end]))
             return false;
-        }
         return true;
     }
     /**
-     * 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.
      */
     isWhitelistedMatch(word, matchedText) {
         if (this.caseSensitive) {
@@ -333,7 +412,9 @@ export class AllProfanity {
         }
     }
     /**
-     * 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.
      */
     deduplicateMatches(matches) {
         const sorted = [...matches].sort((a, b) => {
@@ -352,9 +433,76 @@ export class AllProfanity {
         return result;
     }
     /**
-     * Advanced profanity detection using efficient trie-based algorithm
+     * Use Aho-Corasick algorithm for pattern matching
+     */
+    findMatchesWithAhoCorasick(searchText, originalText) {
+        if (!this.ahoCorasickAutomaton) {
+            return [];
+        }
+        const ahoMatches = this.ahoCorasickAutomaton.findAll(searchText);
+        const results = [];
+        for (const match of ahoMatches) {
+            if (!this.detectPartialWords &&
+                !this.isWholeWord(originalText, match.start, match.end)) {
+                continue;
+            }
+            const matchedText = originalText.substring(match.start, match.end);
+            if (this.isWhitelistedMatch(match.pattern, matchedText)) {
+                continue;
+            }
+            if (this.hasWordBoundaries(originalText, match.start, match.end)) {
+                results.push({
+                    word: match.pattern,
+                    start: match.start,
+                    end: match.end,
+                    originalWord: matchedText,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Hybrid approach: Aho-Corasick for fast matching, Bloom Filter for validation
+     */
+    findMatchesHybrid(searchText, originalText) {
+        // Use Aho-Corasick for primary matching if available
+        if (this.ahoCorasickAutomaton) {
+            const matches = this.findMatchesWithAhoCorasick(searchText, originalText);
+            // If Bloom Filter is enabled, validate matches
+            if (this.bloomFilter) {
+                return matches.filter((match) => this.bloomFilter.mightContain(match.word));
+            }
+            return matches;
+        }
+        // Fallback to Trie if Aho-Corasick not available
+        const matches = [];
+        this.findMatches(searchText, originalText, matches);
+        // Validate with Bloom Filter if enabled
+        if (this.bloomFilter) {
+            return matches.filter((match) => this.bloomFilter.mightContain(match.word));
+        }
+        return matches;
+    }
+    /**
+     * Apply context analysis to filter false positives
+     */
+    applyContextAnalysis(text, matches, scoreThreshold = 0.5) {
+        if (!this.contextAnalyzer) {
+            return matches;
+        }
+        return matches.filter((match) => {
+            const analysis = this.contextAnalyzer.analyzeContext(text, match.start, match.end, match.word);
+            // If score is above threshold, it's likely profanity
+            return analysis.score >= scoreThreshold;
+        });
+    }
+    /**
+     * Detect profanity in a given text.
+     * @param text - The text to check.
+     * @returns Profanity detection result.
      */
     detect(text) {
+        var _a;
         const validatedText = validateString(text, "text");
         if (validatedText.length === 0) {
             return {
@@ -365,23 +513,56 @@ export class AllProfanity {
                 positions: [],
             };
         }
-        const matches = [];
+        // Check cache first if enabled
+        if ((_a = this.resultCache) === null || _a === void 0 ? void 0 : _a.has(validatedText)) {
+            return this.resultCache.get(validatedText);
+        }
+        let matches = [];
         const normalizedText = this.caseSensitive
             ? validatedText
             : validatedText.toLowerCase();
-        this.findMatches(normalizedText, validatedText, matches);
-        // Leet speak detection (normalize and search, map back to original)
-        if (this.enableLeetSpeak) {
-            const leetNormalized = this.normalizeLeetSpeak(normalizedText);
-            if (leetNormalized !== normalizedText) {
-                this.findMatches(leetNormalized, validatedText, matches);
-            }
+        // Choose matching algorithm based on configuration
+        switch (this.matchingAlgorithm) {
+            case "aho-corasick":
+                matches = this.findMatchesWithAhoCorasick(normalizedText, validatedText);
+                if (this.enableLeetSpeak) {
+                    const leetNormalized = this.normalizeLeetSpeak(normalizedText);
+                    if (leetNormalized !== normalizedText) {
+                        const leetMatches = this.findMatchesWithAhoCorasick(leetNormalized, validatedText);
+                        matches.push(...leetMatches);
+                    }
+                }
+                break;
+            case "hybrid":
+                matches = this.findMatchesHybrid(normalizedText, validatedText);
+                if (this.enableLeetSpeak) {
+                    const leetNormalized = this.normalizeLeetSpeak(normalizedText);
+                    if (leetNormalized !== normalizedText) {
+                        const leetMatches = this.findMatchesHybrid(leetNormalized, validatedText);
+                        matches.push(...leetMatches);
+                    }
+                }
+                break;
+            case "trie":
+            default:
+                this.findMatches(normalizedText, validatedText, matches);
+                if (this.enableLeetSpeak) {
+                    const leetNormalized = this.normalizeLeetSpeak(normalizedText);
+                    if (leetNormalized !== normalizedText) {
+                        this.findMatches(leetNormalized, validatedText, matches);
+                    }
+                }
+                break;
+        }
+        // Apply context analysis if enabled
+        if (this.contextAnalyzer) {
+            matches = this.applyContextAnalysis(validatedText, matches);
         }
         const uniqueMatches = this.deduplicateMatches(matches);
         const detectedWords = uniqueMatches.map((m) => m.originalWord);
         const severity = this.calculateSeverity(uniqueMatches);
         const cleanedText = this.generateCleanedText(validatedText, uniqueMatches);
-        return {
+        const result = {
             hasProfanity: uniqueMatches.length > 0,
             detectedWords,
             cleanedText,
@@ -392,9 +573,22 @@ export class AllProfanity {
                 end: m.end,
             })),
         };
+        // Cache result if caching is enabled
+        if (this.resultCache) {
+            this.resultCache.set(validatedText, result);
+            // Implement simple LRU by clearing cache when it gets too large
+            if (this.resultCache.size > 1000) {
+                const firstKey = this.resultCache.keys().next().value;
+                this.resultCache.delete(firstKey);
+            }
+        }
+        return result;
     }
     /**
      * 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.
      */
     findMatches(searchText, originalText, matches) {
         for (let i = 0; i < searchText.length; i++) {
@@ -402,12 +596,10 @@ export class AllProfanity {
             for (const match of matchResults) {
                 const start = i + match.start;
                 const end = i + match.end;
-                // Only match whole words if !detectPartialWords
                 if (!this.detectPartialWords &&
                     !this.isWholeWord(originalText, start, end)) {
                     continue;
                 }
-                // Use actual matched text for whitelist check
                 const matchedText = originalText.substring(start, end);
                 if (this.isWhitelistedMatch(match.word, matchedText)) {
                     continue;
@@ -424,13 +616,15 @@ export class AllProfanity {
         }
     }
     /**
-     * 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.
      */
     generateCleanedText(originalText, matches) {
         if (matches.length === 0)
             return originalText;
         let result = originalText;
-        // Process matches in reverse order to maintain indices and avoid overlap
         const sortedMatches = [...this.deduplicateMatches(matches)].sort((a, b) => b.start - a.start);
         for (const match of sortedMatches) {
             const replacement = this.defaultPlaceholder.repeat(match.originalWord.length);
@@ -442,20 +636,24 @@ export class AllProfanity {
         return result;
     }
     /**
-     * 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) {
         return this.detect(text).hasProfanity;
     }
     /**
-     * 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, placeholder) {
         const detection = this.detect(text);
         if (!placeholder || placeholder === this.defaultPlaceholder) {
             return detection.cleanedText;
         }
-        // Use custom placeholder
         let result = text;
         const sortedPositions = [
             ...this.deduplicateMatches(detection.positions.map((p) => ({
@@ -476,14 +674,16 @@ export class AllProfanity {
         return result;
     }
     /**
-     * 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, placeholder = "***") {
         const detection = this.detect(text);
         if (detection.positions.length === 0)
             return text;
         let result = text;
-        // Sort matches so later matches don't affect earlier ones
         const sortedPositions = [
             ...this.deduplicateMatches(detection.positions.map((p) => ({
                 word: p.word,
@@ -493,7 +693,6 @@ export class AllProfanity {
             }))),
         ].sort((a, b) => b.start - a.start);
         for (const pos of sortedPositions) {
-            // Only replace whole words!
             if (!this.isWholeWord(result, pos.start, pos.end))
                 continue;
             result =
@@ -504,7 +703,8 @@ export class AllProfanity {
         return result;
     }
     /**
-     * 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) {
         const words = Array.isArray(word) ? word : [word];
@@ -515,7 +715,8 @@ export class AllProfanity {
         }
     }
     /**
-     * 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) {
         const words = Array.isArray(word) ? word : [word];
@@ -527,7 +728,8 @@ export class AllProfanity {
         }
     }
     /**
-     * Add words to whitelist
+     * Add words to the whitelist.
+     * @param words - Words to whitelist.
      */
     addToWhitelist(words) {
         const validatedWords = validateStringArray(words, "whitelist words");
@@ -537,7 +739,8 @@ export class AllProfanity {
         }
     }
     /**
-     * Remove words from whitelist
+     * Remove words from the whitelist.
+     * @param words - Words to remove from whitelist.
      */
     removeFromWhitelist(words) {
         const validatedWords = validateStringArray(words, "whitelist words");
@@ -547,14 +750,18 @@ export class AllProfanity {
         }
     }
     /**
-     * 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.
      */
     isWhitelisted(word) {
         const normalizedWord = this.caseSensitive ? word : word.toLowerCase();
         return this.whitelistSet.has(normalizedWord);
     }
     /**
-     * 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) {
         if (!language || typeof language !== "string") {
@@ -587,7 +794,9 @@ export class AllProfanity {
         }
     }
     /**
-     * Load multiple languages at once
+     * Load multiple language dictionaries.
+     * @param languages - Array of languages to load.
+     * @returns Number of successfully loaded languages.
      */
     loadLanguages(languages) {
         const validatedLanguages = validateStringArray(languages, "languages");
@@ -596,14 +805,17 @@ export class AllProfanity {
         }, 0);
     }
     /**
-     * Load all Indian languages
+     * Load all supported Indian languages.
+     * @returns Number of loaded Indian languages.
      */
     loadIndianLanguages() {
         const indianLanguages = ["hindi", "bengali", "tamil", "telugu"];
         return this.loadLanguages(indianLanguages);
     }
     /**
-     * Load a custom dictionary
+     * Load a custom dictionary.
+     * @param name - Name of the dictionary.
+     * @param words - Words to add.
      */
     loadCustomDictionary(name, words) {
         validateString(name, "dictionary name");
@@ -619,7 +831,6 @@ export class AllProfanity {
                     addedCount++;
                 }
             }
-            // Store for future reference
             this.availableLanguages[name.toLowerCase()] = validatedWords;
             this.loadedLanguages.add(name.toLowerCase());
             this.logger.info(`Loaded ${addedCount} words from custom dictionary '${name}'`);
@@ -629,7 +840,9 @@ export class AllProfanity {
         }
     }
     /**
-     * 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.
      */
     addWordToTrie(word) {
         if (!word || typeof word !== "string" || word.trim().length === 0) {
@@ -638,16 +851,25 @@ export class AllProfanity {
         const normalizedWord = this.caseSensitive
             ? word.trim()
             : word.trim().toLowerCase();
-        // Skip if whitelisted
         if (this.isWhitelisted(normalizedWord)) {
             return false;
         }
-        // Add to trie
+        // Add to Trie (always used as fallback)
         this.profanityTrie.addWord(normalizedWord);
+        // Add to Bloom Filter if enabled
+        if (this.bloomFilter) {
+            this.bloomFilter.add(normalizedWord);
+        }
+        // Add to Aho-Corasick automaton if enabled
+        if (this.ahoCorasickAutomaton) {
+            this.ahoCorasickAutomaton.addPattern(normalizedWord);
+        }
         return true;
     }
     /**
-     * Remove overlapping matches, keep only the longest at each start position
+     * Calculate severity from matches.
+     * @param matches - Array of matches.
+     * @returns Severity level.
      */
     calculateSeverity(matches) {
         if (matches.length === 0)
@@ -663,7 +885,7 @@ export class AllProfanity {
         return ProfanitySeverity.MILD;
     }
     /**
-     * Clear all loaded dictionaries
+     * Clear all loaded dictionaries and dynamic words.
      */
     clearList() {
         this.profanityTrie.clear();
@@ -671,7 +893,8 @@ export class AllProfanity {
         this.dynamicWords.clear();
     }
     /**
-     * Set placeholder character
+     * Set the placeholder character for filtered words.
+     * @param placeholder - The placeholder character.
      */
     setPlaceholder(placeholder) {
         validateString(placeholder, "placeholder");
@@ -681,19 +904,22 @@ export class AllProfanity {
         this.defaultPlaceholder = placeholder.charAt(0);
     }
     /**
-     * Get loaded languages
+     * Get the list of loaded languages.
+     * @returns Array of loaded language keys.
      */
     getLoadedLanguages() {
         return Array.from(this.loadedLanguages);
     }
     /**
-     * Get available languages
+     * Get the list of available built-in languages.
+     * @returns Array of available language keys.
      */
     getAvailableLanguages() {
         return Object.keys(this.availableLanguages);
     }
     /**
-     * Get current configuration
+     * Get the current configuration of the profanity filter.
+     * @returns Partial configuration object.
      */
     getConfig() {
         return {
@@ -707,24 +933,23 @@ export class AllProfanity {
         };
     }
     /**
-     * Rebuilds the profanity trie from loaded language dictionaries and dynamic words.
+     * Rebuild the profanity trie from loaded dictionaries and dynamic words.
      */
     rebuildTrie() {
         this.profanityTrie.clear();
-        // Re-add all loaded language words
         for (const lang of this.loadedLanguages) {
             const words = this.availableLanguages[lang] || [];
             for (const word of words) {
                 this.addWordToTrie(word);
             }
         }
-        // Re-add dynamic words
         for (const word of this.dynamicWords) {
             this.addWordToTrie(word);
         }
     }
     /**
-     * Update configuration. Rebuild trie if needed.
+     * Update configuration options for the profanity filter.
+     * @param options - Partial configuration object.
      */
     updateConfig(options) {
         let rebuildNeeded = false;
@@ -752,8 +977,54 @@ export class AllProfanity {
             this.rebuildTrie();
         }
     }
+    /**
+     * Create an AllProfanity instance from a configuration object.
+     * @param config - Configuration object
+     * @returns A new AllProfanity instance
+     */
+    static fromConfig(config) {
+        const options = {};
+        if (config.algorithm)
+            options.algorithm = config.algorithm;
+        if (config.bloomFilter)
+            options.bloomFilter = config.bloomFilter;
+        if (config.ahoCorasick)
+            options.ahoCorasick = config.ahoCorasick;
+        if (config.contextAnalysis)
+            options.contextAnalysis = config.contextAnalysis;
+        if (config.performance)
+            options.performance = config.performance;
+        if (config.profanityDetection) {
+            options.enableLeetSpeak = config.profanityDetection.enableLeetSpeak;
+            options.caseSensitive = config.profanityDetection.caseSensitive;
+            options.strictMode = config.profanityDetection.strictMode;
+            options.detectPartialWords = config.profanityDetection.detectPartialWords;
+            options.defaultPlaceholder = config.profanityDetection.defaultPlaceholder;
+        }
+        if (config.enableLeetSpeak !== undefined)
+            options.enableLeetSpeak = config.enableLeetSpeak;
+        if (config.caseSensitive !== undefined)
+            options.caseSensitive = config.caseSensitive;
+        if (config.strictMode !== undefined)
+            options.strictMode = config.strictMode;
+        if (config.detectPartialWords !== undefined)
+            options.detectPartialWords = config.detectPartialWords;
+        if (config.defaultPlaceholder !== undefined)
+            options.defaultPlaceholder = config.defaultPlaceholder;
+        if (config.languages)
+            options.languages = config.languages;
+        if (config.whitelistWords)
+            options.whitelistWords = config.whitelistWords;
+        if (config.customDictionaries)
+            options.customDictionaries = config.customDictionaries;
+        if (config.logger)
+            options.logger = config.logger;
+        return new AllProfanity(options);
+    }
 }
-// Create and export a singleton instance
+/**
+ * Singleton instance of AllProfanity with default configuration.
+ */
 const allProfanity = new AllProfanity();
 export default allProfanity;
 //# sourceMappingURL=index.js.map