allprofanity 2.2.0 → 2.3.0

package/dist/index.js

@@ -23,35 +23,221 @@ 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 for AllProfanity.
+ *
+ * @class ConsoleLogger
+ * @implements {Logger}
+ * @description Logs messages to the browser or Node.js console with an "[AllProfanity]" prefix.
+ * This is the default logger used when no custom logger is provided.
+ *
+ * @internal
  */
 class ConsoleLogger {
+    /**
+     * Log informational messages to console.log with [AllProfanity] prefix.
+     *
+     * @param message - The message to log
+     * @returns void
+     */
     info(message) {
         console.log(`[AllProfanity] ${message}`);
     }
+    /**
+     * Log warning messages to console.warn with [AllProfanity] prefix.
+     *
+     * @param message - The warning message to log
+     * @returns void
+     */
     warn(message) {
         console.warn(`[AllProfanity] ${message}`);
     }
+    /**
+     * Log error messages to console.error with [AllProfanity] prefix.
+     *
+     * @param message - The error message to log
+     * @returns void
+     */
     error(message) {
         console.error(`[AllProfanity] ${message}`);
     }
 }
 /**
- * Severity levels for profanity detection.
+ * Silent logger implementation that suppresses all log output.
+ *
+ * @class SilentLogger
+ * @implements {Logger}
+ * @description A no-op logger that discards all log messages. Used when `silent: true` is set
+ * in AllProfanityOptions, or when you want to completely disable logging.
+ *
+ * @internal
+ */
+class SilentLogger {
+    /**
+     * No-op implementation - messages are discarded.
+     *
+     * @param _message - The message (unused)
+     * @returns void
+     */
+    info(_message) {
+        // Silent mode - no logging
+    }
+    /**
+     * No-op implementation - warnings are discarded.
+     *
+     * @param _message - The warning message (unused)
+     * @returns void
+     */
+    warn(_message) {
+        // Silent mode - no logging
+    }
+    /**
+     * No-op implementation - errors are discarded.
+     *
+     * @param _message - The error message (unused)
+     * @returns void
+     */
+    error(_message) {
+        // Silent mode - no logging
+    }
+}
+/**
+ * Severity levels for profanity detection results.
+ *
+ * @enum {number}
+ * @description Categorizes the severity of detected profanity based on the number
+ * of unique words and total matches found in the text.
+ *
+ * @readonly
+ * @example
+ * ```typescript
+ * const result = filter.detect("some text");
+ * if (result.severity === ProfanitySeverity.EXTREME) {
+ *   // Handle extreme profanity
+ * }
+ * ```
  */
 export var ProfanitySeverity;
 (function (ProfanitySeverity) {
+    /** No profanity detected */
+    ProfanitySeverity[ProfanitySeverity["NONE"] = 0] = "NONE";
+    /** Mild profanity: 1 unique word or 1 total match */
     ProfanitySeverity[ProfanitySeverity["MILD"] = 1] = "MILD";
+    /** Moderate profanity: 2 unique words or 2 total matches */
     ProfanitySeverity[ProfanitySeverity["MODERATE"] = 2] = "MODERATE";
+    /** Severe profanity: 3 unique words or 3 total matches */
     ProfanitySeverity[ProfanitySeverity["SEVERE"] = 3] = "SEVERE";
+    /** Extreme profanity: 4+ unique words or 5+ total matches */
     ProfanitySeverity[ProfanitySeverity["EXTREME"] = 4] = "EXTREME";
 })(ProfanitySeverity = ProfanitySeverity || (ProfanitySeverity = {}));
 /**
- * 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.
+ * Compose two position maps: `inner` maps its normalized text back to the
+ * text that `outer` normalized, and the result maps `inner.normalized`
+ * directly back to the original input.
+ *
+ * @internal
+ */
+function composeMaps(outer, inner) {
+    const starts = new Array(inner.starts.length);
+    const ends = new Array(inner.ends.length);
+    for (let i = 0; i < inner.starts.length; i++) {
+        starts[i] = outer.starts[inner.starts[i]];
+        ends[i] = outer.ends[inner.ends[i] - 1];
+    }
+    return { normalized: inner.normalized, starts, ends };
+}
+/**
+ * Common homoglyphs (visually identical/near-identical non-Latin characters)
+ * folded to their ASCII look-alikes for evasion-resistant matching.
+ *
+ * @internal
+ */
+const CONFUSABLES = new Map([
+    // Cyrillic
+    ["а", "a"], ["в", "b"], ["е", "e"], ["к", "k"], ["м", "m"], ["н", "h"],
+    ["о", "o"], ["р", "p"], ["с", "c"], ["т", "t"], ["у", "y"], ["х", "x"],
+    ["і", "i"], ["ј", "j"], ["ѕ", "s"], ["ԁ", "d"], ["ԛ", "q"], ["ԝ", "w"],
+    // Greek
+    ["α", "a"], ["β", "b"], ["γ", "y"], ["ε", "e"], ["η", "n"], ["ι", "i"],
+    ["κ", "k"], ["μ", "m"], ["ν", "v"], ["ο", "o"], ["ρ", "p"], ["σ", "s"],
+    ["τ", "t"], ["υ", "u"], ["χ", "x"], ["ω", "w"],
+]);
+/**
+ * Invisible characters commonly injected to break up profane words.
+ *
+ * @internal
+ */
+const INVISIBLE_CHARS = new Set([
+    "\u200B",
+    "\u200C",
+    "\u200D",
+    "\uFEFF",
+    "\u00AD",
+    "\u2060",
+    "\u180E", // Mongolian vowel separator
+]);
+/** Symbols treated as single-character wildcards in masked words like "f*ck". @internal */
+const MASK_CHARS = new Set(["*", "#", "@", "$", "%"]);
+/**
+ * Unambiguous profanity stems that are flagged even when embedded inside a
+ * larger token ("sisfuck", "totalshitshow"). Only words that essentially
+ * never occur inside legitimate vocabulary belong here — ambiguous stems
+ * like "ass" or "cock" (class, bass, Hitchcock, peacock) must stay
+ * whole-word matched.
+ *
+ * @internal
+ */
+const EMBEDDED_STRONG_STEMS = [
+    "fuck",
+    "shit",
+    "bitch",
+    "cunt",
+    "whore",
+    "nigger",
+    "nigga",
+    "faggot",
+    "wanker",
+    "chutiya",
+    "bhenchod",
+    "behenchod",
+    "madarchod",
+    "bhosdi",
+];
+/**
+ * Legitimate words that contain a strong stem and must never be flagged by
+ * the embedded pass (the user whitelist extends this set).
+ *
+ * @internal
+ */
+const EMBEDDED_SAFE_WORDS = new Set([
+    "scunthorpe",
+    "mishit",
+    "mishits",
+    "mishitting",
+    "shitake",
+    "shitakes",
+    "matsushita",
+    "takeshita",
+    "snigger",
+    "sniggers",
+    "sniggered",
+    "sniggering",
+]);
+/**
+ * Validates that an input is a non-empty string.
+ *
+ * @function validateString
+ * @param {unknown} input - The value to validate
+ * @param {string} paramName - Name of the parameter being validated (used in error messages)
+ * @returns {string} The validated string
+ * @throws {TypeError} If input is not a string
+ *
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * const text = validateString(userInput, 'text');
+ * // Returns userInput if it's a string, throws TypeError otherwise
+ * ```
  */
 function validateString(input, paramName) {
     if (typeof input !== "string") {
@@ -60,36 +246,86 @@ 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.
+ * Validates and filters a string array, removing non-string and empty items.
+ *
+ * @function validateStringArray
+ * @param {unknown} input - The value to validate (expected to be an array)
+ * @param {string} paramName - Name of the parameter being validated (used in error/warning messages)
+ * @returns {string[]} Array of valid, non-empty strings
+ * @throws {TypeError} If input is not an array
+ *
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * const words = validateStringArray(['word1', '', 123, 'word2'], 'words');
+ * // Returns: ['word1', 'word2']
+ * // Logs warning: "Skipping non-string item in words: 123"
+ * ```
  */
-function validateStringArray(input, paramName) {
+function validateStringArray(input, paramName, logger) {
     if (!Array.isArray(input)) {
         throw new TypeError(`${paramName} must be an array`);
     }
     return input.filter((item) => {
         if (typeof item !== "string") {
-            console.warn(`Skipping non-string item in ${paramName}: ${item}`);
+            const message = `Skipping non-string item in ${paramName}: ${item}`;
+            if (logger) {
+                logger.warn(message);
+            }
+            else {
+                console.warn(message);
+            }
             return false;
         }
         return item.trim().length > 0;
     });
 }
 /**
- * Trie node for efficient string matching.
+ * Trie (prefix tree) node for efficient pattern matching and word storage.
+ *
+ * @class TrieNode
+ * @description Implements a trie data structure for O(m) time complexity word matching,
+ * where m is the length of the word being searched. Each node represents a character
+ * in the word, and paths from root to nodes with isEndOfWord=true represent complete words.
+ *
+ * @internal
+ *
+ * @example
+ * ```typescript
+ * const trie = new TrieNode();
+ * trie.addWord('bad');
+ * trie.addWord('badword');
+ * const matches = trie.findMatches('badwords here', 0, false);
+ * // Returns matches for 'bad' and 'badword'
+ * ```
  */
 class TrieNode {
     constructor() {
+        /** Map of characters to child nodes for fast lookups */
         this.children = new Map();
+        /** Flag indicating if this node represents the end of a complete word */
         this.isEndOfWord = false;
+        /** The complete word ending at this node (only set when isEndOfWord is true) */
         this.word = "";
     }
     /**
-     * Add a word to the trie.
-     * @param word - The word to add.
+     * Adds a word to the trie structure.
+     *
+     * @param {string} word - The word to add to the trie
+     * @returns {void}
+     *
+     * @remarks
+     * - Time Complexity: O(m) where m is the length of the word
+     * - Space Complexity: O(m) in worst case when all characters are new
+     * - Supports any Unicode characters
+     *
+     * @example
+     * ```typescript
+     * const trie = new TrieNode();
+     * trie.addWord('hello');
+     * trie.addWord('world');
+     * ```
      */
     addWord(word) {
         let current = this;
@@ -106,13 +342,36 @@ class TrieNode {
         current.word = word;
     }
     /**
-     * Remove a word from the trie.
-     * @param word - The word to remove.
-     * @returns True if the word was removed, false otherwise.
+     * Removes a word from the trie structure.
+     *
+     * @param {string} word - The word to remove from the trie
+     * @returns {boolean} True if the word existed and was removed, false if word was not found
+     *
+     * @remarks
+     * - Time Complexity: O(m) where m is the length of the word
+     * - Also removes unnecessary nodes to keep the trie optimized
+     * - Only removes the word marking; shared prefixes with other words are preserved
+     *
+     * @example
+     * ```typescript
+     * const trie = new TrieNode();
+     * trie.addWord('hello');
+     * trie.removeWord('hello'); // Returns: true
+     * trie.removeWord('world'); // Returns: false (word not in trie)
+     * ```
      */
     removeWord(word) {
         return this.removeHelper(word, 0);
     }
+    /**
+     * Recursive helper method for removing a word from the trie.
+     *
+     * @param {string} word - The word being removed
+     * @param {number} index - Current character index in the word
+     * @returns {boolean} True if this node should be deleted (has no children and is not end of another word)
+     *
+     * @internal
+     */
     removeHelper(word, index) {
         if (index === word.length) {
             if (!this.isEndOfWord)
@@ -132,11 +391,25 @@ class TrieNode {
         return false;
     }
     /**
-     * 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.
+     * Finds all word matches in text starting at a specific position.
+     *
+     * @param {string} text - The text to search for profanity
+     * @param {number} startPos - The starting position (0-based index) in the text
+     * @param {boolean} allowPartial - If true, finds partial matches within larger words
+     * @returns {Array<{ word: string; start: number; end: number }>} Array of match objects with word and position info
+     *
+     * @remarks
+     * - Time Complexity: O(k) where k is the length of the longest match from startPos
+     * - Returns all valid words that can be formed starting from startPos
+     * - When allowPartial is false, respects word boundaries
+     *
+     * @example
+     * ```typescript
+     * const trie = new TrieNode();
+     * trie.addWord('bad');
+     * const matches = trie.findMatches('badword', 0, false);
+     * // Returns: [{ word: 'bad', start: 0, end: 3 }]
+     * ```
      */
     findMatches(text, startPos, allowPartial) {
         const matches = [];
@@ -149,28 +422,59 @@ class TrieNode {
             current = nextNode;
             pos++;
             if (current.isEndOfWord) {
-                if (!allowPartial) {
-                    const wordStart = startPos;
-                    const wordEnd = pos;
-                    matches.push({
-                        word: current.word,
-                        start: wordStart - startPos,
-                        end: wordEnd - startPos,
-                    });
-                }
-                else {
-                    matches.push({
-                        word: current.word,
-                        start: 0,
-                        end: pos - startPos,
-                    });
-                }
+                matches.push({
+                    word: current.word,
+                    start: 0,
+                    end: pos - startPos,
+                });
             }
         }
         return matches;
     }
     /**
-     * Clear all words from the trie.
+     * Find a stored word matching the token, where mask characters match any
+     * single character. The token must align with a complete word exactly.
+     *
+     * @param token - The token to resolve (e.g. "f*ck")
+     * @param maskChars - Characters that act as single-character wildcards
+     * @returns The first matching dictionary word, or null
+     */
+    findWildcardMatch(token, maskChars) {
+        return this.wildcardHelper(token, 0, maskChars);
+    }
+    wildcardHelper(token, index, maskChars) {
+        if (index === token.length) {
+            return this.isEndOfWord ? this.word : null;
+        }
+        const char = token[index];
+        if (maskChars.has(char)) {
+            for (const child of this.children.values()) {
+                const result = child.wildcardHelper(token, index + 1, maskChars);
+                if (result)
+                    return result;
+            }
+            return null;
+        }
+        const child = this.children.get(char);
+        return child ? child.wildcardHelper(token, index + 1, maskChars) : null;
+    }
+    /**
+     * Clears all words from the trie, resetting it to empty state.
+     *
+     * @returns {void}
+     *
+     * @remarks
+     * - Time Complexity: O(1) - clears the root node only (JavaScript GC handles children)
+     * - Removes all stored words and resets the trie to initial state
+     *
+     * @example
+     * ```typescript
+     * const trie = new TrieNode();
+     * trie.addWord('hello');
+     * trie.addWord('world');
+     * trie.clear();
+     * // Trie is now empty
+     * ```
      */
     clear() {
         this.children.clear();
@@ -179,15 +483,142 @@ class TrieNode {
     }
 }
 /**
- * Main class for profanity detection and filtering.
+ * AllProfanity - Professional-grade multilingual profanity detection and filtering library.
+ *
+ * @class AllProfanity
+ * @description A comprehensive, high-performance profanity filtering system supporting 9+ languages
+ * with advanced features including leet speak detection, context analysis, multiple matching algorithms,
+ * and customizable filtering options.
+ *
+ * @remarks
+ * ### Features:
+ * - **Multi-language Support**: English, Hindi, French, German, Spanish, Bengali, Tamil, Telugu, Brazilian Portuguese
+ * - **Advanced Algorithms**: Trie, Aho-Corasick, Bloom Filter, and hybrid approaches
+ * - **Leet Speak Detection**: Automatically normalizes and detects variations like "h3ll0"
+ * - **Context Analysis**: Reduces false positives using surrounding word context
+ * - **Performance**: Built-in caching and optimized data structures
+ * - **Flexible**: Custom dictionaries, whitelisting, severity levels
+ *
+ * ### Default Behavior:
+ * - Loads English and Hindi dictionaries by default
+ * - Case-insensitive matching
+ * - Leet speak detection enabled
+ * - Uses Trie algorithm (fastest for most cases)
+ *
+ * @example
+ * ```typescript
+ * // Basic usage with default instance
+ * import allProfanity from 'allprofanity';
+ *
+ * const result = allProfanity.detect("This is some bad text");
+ * console.log(result.hasProfanity); // true
+ * console.log(result.cleanedText); // "This is some *** text"
+ * console.log(result.severity); // ProfanitySeverity.MILD
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Advanced usage with custom configuration
+ * import { AllProfanity, ProfanitySeverity } from 'allprofanity';
+ *
+ * const filter = new AllProfanity({
+ *   languages: ['english', 'french', 'spanish'],
+ *   enableLeetSpeak: true,
+ *   strictMode: true,
+ *   algorithm: {
+ *     matching: 'hybrid',
+ *     useBloomFilter: true
+ *   },
+ *   performance: {
+ *     enableCaching: true,
+ *     cacheSize: 500
+ *   },
+ *   whitelistWords: ['class', 'assignment']
+ * });
+ *
+ * const text = "This text has some b@d w0rds";
+ * const result = filter.detect(text);
+ *
+ * if (result.hasProfanity) {
+ *   console.log(`Found ${result.detectedWords.length} profane words`);
+ *   console.log(`Severity: ${ProfanitySeverity[result.severity]}`);
+ *   console.log(`Cleaned: ${result.cleanedText}`);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using individual methods
+ * const filter = new AllProfanity();
+ *
+ * // Simple check
+ * if (filter.check("some text")) {
+ *   console.log("Contains profanity!");
+ * }
+ *
+ * // Clean with custom placeholder
+ * const cleaned = filter.clean("bad words here", "#");
+ *
+ * // Load additional languages
+ * filter.loadLanguage('german');
+ * filter.loadIndianLanguages(); // Loads hindi, bengali, tamil, telugu
+ *
+ * // Add custom words
+ * filter.add(['customword1', 'customword2']);
+ *
+ * // Remove words
+ * filter.remove(['someword']);
+ *
+ * // Whitelist words
+ * filter.addToWhitelist(['class', 'assignment']);
+ * ```
+ *
+ * @see {@link AllProfanityOptions} for all configuration options
+ * @see {@link ProfanityDetectionResult} for detection result format
+ * @see {@link ProfanitySeverity} for severity levels
  */
 export class AllProfanity {
     /**
-     * Create an AllProfanity instance.
-     * @param options - Profanity filter configuration options.
+     * Creates a new AllProfanity instance with the specified configuration.
+     *
+     * @constructor
+     * @param {AllProfanityOptions} [options] - Configuration options for profanity detection behavior
+     *
+     * @remarks
+     * ### Default Initialization:
+     * - Loads English and Hindi dictionaries automatically
+     * - Enables leet speak detection
+     * - Case-insensitive matching
+     * - Uses Trie algorithm for pattern matching
+     *
+     * ### Performance Considerations:
+     * - Initial load time depends on number of languages loaded
+     * - Aho-Corasick automaton (if enabled) is built during construction
+     * - Bloom Filter (if enabled) is populated during construction
+     *
+     * @throws {TypeError} If invalid options are provided
+     *
+     * @example
+     * ```typescript
+     * // Default instance
+     * const filter = new AllProfanity();
+     *
+     * // Custom configuration
+     * const filter = new AllProfanity({
+     *   languages: ['english', 'french'],
+     *   strictMode: true,
+     *   defaultPlaceholder: '#',
+     *   algorithm: { matching: 'hybrid' }
+     * });
+     *
+     * // Silent mode (no logging)
+     * const filter = new AllProfanity({ silent: true });
+     * ```
+     *
+     * @see {@link AllProfanityOptions} for all available configuration options
      */
     constructor(options) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
         this.profanityTrie = new TrieNode();
         this.whitelistSet = new Set();
         this.loadedLanguages = new Set();
@@ -196,6 +627,11 @@ export class AllProfanity {
         this.caseSensitive = false;
         this.strictMode = false;
         this.detectPartialWords = false;
+        this.evasionUnicode = true;
+        this.evasionRepeatedChars = true;
+        this.evasionMaskedChars = true;
+        this.evasionSeparatedLetters = true;
+        this.evasionEmbeddedWords = true;
         this.availableLanguages = {
             english: englishBadWords || [],
             hindi: hindiBadWords || [],
@@ -233,7 +669,6 @@ export class AllProfanity {
             ["¿", "j"],
             ["|<", "k"],
             ["1<", "k"],
-            ["7", "l"],
             ["|\\/|", "m"],
             ["/\\/\\", "m"],
             ["|\\|", "n"],
@@ -247,13 +682,11 @@ export class AllProfanity {
             ["12", "r"],
             ["5", "s"],
             ["$", "s"],
-            ["z", "s"],
             ["7", "t"],
             ["+", "t"],
             ["†", "t"],
             ["|_|", "u"],
             ["(_)", "u"],
-            ["v", "u"],
             ["\\/", "v"],
             ["|/", "v"],
             ["\\/\\/", "w"],
@@ -261,7 +694,6 @@ export class AllProfanity {
             ["><", "x"],
             ["}{", "x"],
             ["`/", "y"],
-            ["j", "y"],
             ["2", "z"],
             ["7_", "z"],
         ]);
@@ -270,9 +702,13 @@ export class AllProfanity {
         this.ahoCorasickAutomaton = null;
         this.bloomFilter = null;
         this.contextAnalyzer = null;
+        this.contextScoreThreshold = 0.5;
         this.matchingAlgorithm = "trie";
         this.resultCache = null;
-        this.logger = (options === null || options === void 0 ? void 0 : options.logger) || new ConsoleLogger();
+        this.cacheMaxSize = 1000;
+        this.leetTokensByFirstChar = null;
+        // Use silent logger if silent mode is enabled, otherwise use provided logger or console logger
+        this.logger = (options === null || options === void 0 ? void 0 : options.logger) || ((options === null || options === void 0 ? void 0 : options.silent) ? new SilentLogger() : new ConsoleLogger());
         if ((options === null || options === void 0 ? void 0 : options.defaultPlaceholder) !== undefined) {
             this.setPlaceholder(options.defaultPlaceholder);
         }
@@ -280,6 +716,15 @@ 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;
+        this.evasionUnicode = (_f = (_e = options === null || options === void 0 ? void 0 : options.evasionProtection) === null || _e === void 0 ? void 0 : _e.unicode) !== null && _f !== void 0 ? _f : true;
+        this.evasionRepeatedChars =
+            (_h = (_g = options === null || options === void 0 ? void 0 : options.evasionProtection) === null || _g === void 0 ? void 0 : _g.repeatedCharacters) !== null && _h !== void 0 ? _h : true;
+        this.evasionMaskedChars =
+            (_k = (_j = options === null || options === void 0 ? void 0 : options.evasionProtection) === null || _j === void 0 ? void 0 : _j.maskedCharacters) !== null && _k !== void 0 ? _k : true;
+        this.evasionSeparatedLetters =
+            (_m = (_l = options === null || options === void 0 ? void 0 : options.evasionProtection) === null || _l === void 0 ? void 0 : _l.separatedLetters) !== null && _m !== void 0 ? _m : true;
+        this.evasionEmbeddedWords =
+            (_p = (_o = options === null || options === void 0 ? void 0 : options.evasionProtection) === null || _o === void 0 ? void 0 : _o.embeddedWords) !== null && _p !== void 0 ? _p : true;
         if (options === null || options === void 0 ? void 0 : options.whitelistWords) {
             this.addToWhitelist(options.whitelistWords);
         }
@@ -288,7 +733,7 @@ export class AllProfanity {
         this.initializeAdvancedAlgorithms(options);
         this.loadLanguage("english");
         this.loadLanguage("hindi");
-        if ((_e = options === null || options === void 0 ? void 0 : options.languages) === null || _e === void 0 ? void 0 : _e.length) {
+        if ((_q = options === null || options === void 0 ? void 0 : options.languages) === null || _q === void 0 ? void 0 : _q.length) {
             options.languages.forEach((lang) => this.loadLanguage(lang));
         }
         if (options === null || options === void 0 ? void 0 : options.customDictionaries) {
@@ -296,12 +741,15 @@ export class AllProfanity {
                 this.loadCustomDictionary(name, words);
             });
         }
+        if (((_r = options === null || options === void 0 ? void 0 : options.ahoCorasick) === null || _r === void 0 ? void 0 : _r.prebuild) && this.ahoCorasickAutomaton) {
+            this.ahoCorasickAutomaton.build();
+        }
     }
     /**
      * Initialize advanced algorithms based on configuration
      */
     initializeAdvancedAlgorithms(options) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
         // 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;
@@ -334,38 +782,362 @@ export class AllProfanity {
             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);
             }
+            if (((_m = options === null || options === void 0 ? void 0 : options.contextAnalysis) === null || _m === void 0 ? void 0 : _m.scoreThreshold) !== undefined) {
+                this.contextScoreThreshold = options.contextAnalysis.scoreThreshold;
+            }
             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;
+        if ((_o = options === null || options === void 0 ? void 0 : options.performance) === null || _o === void 0 ? void 0 : _o.enableCaching) {
+            this.cacheMaxSize = options.performance.cacheSize || 1000;
             this.resultCache = new Map();
-            this.logger.info(`Result caching enabled with size limit: ${cacheSize}`);
+            this.logger.info(`Result caching enabled with size limit: ${this.cacheMaxSize}`);
         }
     }
     /**
-     * Normalize leet speak to regular characters.
-     * @param text - The input text.
-     * @returns Normalized text.
+     * Normalize leet speak to regular characters, keeping a map from each
+     * normalized character back to its source range in the input text.
+     *
+     * For normalized index i, starts[i]/ends[i] give the [start, end) range in
+     * the input that produced that character. A match [s, e) in the normalized
+     * string therefore spans [starts[s], ends[e - 1]) in the input. This is what
+     * keeps positions correct when length-changing mappings like "ph" -> "f"
+     * apply.
      */
-    normalizeLeetSpeak(text) {
-        if (!this.enableLeetSpeak)
-            return text;
-        let normalized = text.toLowerCase();
-        const sortedMappings = Array.from(this.leetMappings.entries()).sort(([leetA], [leetB]) => leetB.length - leetA.length);
-        for (const [leet, normal] of sortedMappings) {
-            const regex = new RegExp(this.escapeRegex(leet), "g");
-            normalized = normalized.replace(regex, normal);
+    normalizeLeetSpeakWithMap(text) {
+        // Bucket tokens by first character so each position costs one Map lookup
+        // instead of a scan over every mapping (longest token first per bucket).
+        if (!this.leetTokensByFirstChar) {
+            this.leetTokensByFirstChar = new Map();
+            for (const entry of this.leetMappings.entries()) {
+                const bucket = this.leetTokensByFirstChar.get(entry[0][0]);
+                if (bucket) {
+                    bucket.push(entry);
+                }
+                else {
+                    this.leetTokensByFirstChar.set(entry[0][0], [entry]);
+                }
+            }
+            for (const bucket of this.leetTokensByFirstChar.values()) {
+                bucket.sort(([leetA], [leetB]) => leetB.length - leetA.length);
+            }
+        }
+        // Fast path: most text contains no leet characters at all. Scan for the
+        // first applicable mapping before allocating the position-map arrays.
+        let hasLeet = false;
+        for (let j = 0; j < text.length && !hasLeet; j++) {
+            const bucket = this.leetTokensByFirstChar.get(text[j]);
+            if (bucket) {
+                for (const [leet] of bucket) {
+                    if (leet.length === 1 || text.startsWith(leet, j)) {
+                        hasLeet = true;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!hasLeet) {
+            return { normalized: text, starts: [], ends: [] };
+        }
+        const parts = [];
+        const starts = [];
+        const ends = [];
+        let i = 0;
+        while (i < text.length) {
+            let consumed = 0;
+            let replacement = "";
+            const bucket = this.leetTokensByFirstChar.get(text[i]);
+            if (bucket) {
+                for (const [leet, normal] of bucket) {
+                    if (leet.length === 1 || text.startsWith(leet, i)) {
+                        consumed = leet.length;
+                        replacement = normal;
+                        break;
+                    }
+                }
+            }
+            if (consumed === 0) {
+                consumed = 1;
+                replacement = text[i];
+            }
+            for (const char of replacement) {
+                parts.push(char);
+                starts.push(i);
+                ends.push(i + consumed);
+            }
+            i += consumed;
+        }
+        return { normalized: parts.join(""), starts, ends };
+    }
+    /**
+     * Fold unicode evasion tactics into ASCII with a position map: fullwidth
+     * forms, Cyrillic/Greek homoglyphs, Latin diacritics, and invisible
+     * characters injected inside words. Non-Latin scripts (Devanagari, Tamil,
+     * etc.) pass through untouched. Returns null when nothing changed.
+     */
+    unicodeNormalizeWithMap(text) {
+        // Fast path: pure ASCII text needs no folding
+        let needsScan = false;
+        for (let j = 0; j < text.length; j++) {
+            if (text.charCodeAt(j) > 127) {
+                needsScan = true;
+                break;
+            }
+        }
+        if (!needsScan)
+            return null;
+        const parts = [];
+        const starts = [];
+        const ends = [];
+        let changed = false;
+        for (let i = 0; i < text.length; i++) {
+            const char = text[i];
+            const code = text.charCodeAt(i);
+            if (code < 128) {
+                parts.push(char);
+                starts.push(i);
+                ends.push(i + 1);
+                continue;
+            }
+            if (INVISIBLE_CHARS.has(char)) {
+                changed = true;
+                continue;
+            }
+            // Fullwidth ASCII block (！ U+FF01 .. ～ U+FF5E)
+            if (code >= 0xff01 && code <= 0xff5e) {
+                parts.push(String.fromCharCode(code - 0xfee0));
+                starts.push(i);
+                ends.push(i + 1);
+                changed = true;
+                continue;
+            }
+            const confusable = CONFUSABLES.get(char);
+            if (confusable) {
+                parts.push(confusable);
+                starts.push(i);
+                ends.push(i + 1);
+                changed = true;
+                continue;
+            }
+            // Bare combining marks (covers decomposed input like "u" + U+0308)
+            if (code >= 0x0300 && code <= 0x036f) {
+                changed = true;
+                continue;
+            }
+            // Latin letters with diacritics: decompose and strip the marks.
+            // Limited to the Latin blocks so other scripts keep their composed forms.
+            if (code >= 0x00c0 && code < 0x0250) {
+                for (const piece of char.normalize("NFD")) {
+                    const pieceCode = piece.charCodeAt(0);
+                    if (pieceCode >= 0x0300 && pieceCode <= 0x036f) {
+                        changed = true;
+                        continue;
+                    }
+                    const folded = this.caseSensitive ? piece : piece.toLowerCase();
+                    parts.push(folded);
+                    starts.push(i);
+                    ends.push(i + 1);
+                    if (folded !== char)
+                        changed = true;
+                }
+                continue;
+            }
+            parts.push(char);
+            starts.push(i);
+            ends.push(i + 1);
+        }
+        if (!changed)
+            return null;
+        return { normalized: parts.join(""), starts, ends };
+    }
+    /**
+     * Collapse runs of repeated characters ("fuuuuck" -> "fuck") with a
+     * position map. Only triggers when a run of 3+ identical characters
+     * exists, so ordinary doubled letters never pay for this pass.
+     * Returns null when not triggered.
+     */
+    collapseRepeatsWithMap(text) {
+        let triggered = false;
+        for (let j = 2; j < text.length; j++) {
+            if (text[j] === text[j - 1] && text[j] === text[j - 2]) {
+                triggered = true;
+                break;
+            }
+        }
+        if (!triggered)
+            return null;
+        const parts = [];
+        const starts = [];
+        const ends = [];
+        let i = 0;
+        while (i < text.length) {
+            let runEnd = i + 1;
+            while (runEnd < text.length && text[runEnd] === text[i]) {
+                runEnd++;
+            }
+            parts.push(text[i]);
+            starts.push(i);
+            ends.push(runEnd);
+            i = runEnd;
+        }
+        return { normalized: parts.join(""), starts, ends };
+    }
+    /**
+     * Build the list of (text, position-map) variants to scan: the base text
+     * plus unicode-folded, leet-normalized and repeat-collapsed variants, each
+     * included only when its normalization actually changed something.
+     */
+    buildScanPasses(normalizedText) {
+        const passes = [
+            { text: normalizedText },
+        ];
+        let workText = normalizedText;
+        let workMap;
+        if (this.evasionUnicode) {
+            const uni = this.unicodeNormalizeWithMap(normalizedText);
+            if (uni) {
+                passes.push({ text: uni.normalized, posMap: uni });
+                workText = uni.normalized;
+                workMap = uni;
+            }
+        }
+        if (this.enableLeetSpeak) {
+            const leet = this.normalizeLeetSpeakWithMap(workText);
+            if (leet.normalized !== workText) {
+                passes.push({
+                    text: leet.normalized,
+                    posMap: workMap ? composeMaps(workMap, leet) : leet,
+                });
+            }
+        }
+        if (this.evasionRepeatedChars) {
+            const collapsed = this.collapseRepeatsWithMap(workText);
+            if (collapsed) {
+                passes.push({
+                    text: collapsed.normalized,
+                    posMap: workMap ? composeMaps(workMap, collapsed) : collapsed,
+                });
+            }
+        }
+        return passes;
+    }
+    /**
+     * Find dictionary words hidden behind masked characters ("f*ck", "f#ck").
+     * Each mask matches exactly one character and the token's visible letters
+     * must align with a dictionary word, so "c#" or "5% off" never flag.
+     */
+    findMaskedMatches(searchText, originalText) {
+        const results = [];
+        if (!/[*#@$%]/.test(searchText))
+            return results;
+        const tokenRegex = /[\p{L}*#@$%]+/gu;
+        let tokenMatch;
+        while ((tokenMatch = tokenRegex.exec(searchText)) !== null) {
+            const token = tokenMatch[0];
+            let maskCount = 0;
+            for (const char of token) {
+                if (MASK_CHARS.has(char))
+                    maskCount++;
+            }
+            if (maskCount === 0 || maskCount > 2)
+                continue;
+            if (MASK_CHARS.has(token[0]) ||
+                MASK_CHARS.has(token[token.length - 1])) {
+                continue;
+            }
+            const word = this.profanityTrie.findWildcardMatch(token, MASK_CHARS);
+            if (!word)
+                continue;
+            const start = tokenMatch.index;
+            const end = start + token.length;
+            if (!this.detectPartialWords &&
+                !this.isWholeWord(originalText, start, end)) {
+                continue;
+            }
+            const matchedText = originalText.substring(start, end);
+            if (this.isWhitelistedMatch(word, matchedText))
+                continue;
+            if (!this.hasWordBoundaries(originalText, start, end))
+                continue;
+            results.push({ word, start, end, originalWord: matchedText });
         }
-        return normalized;
+        return results;
+    }
+    /**
+     * Find words spelled out with a uniform single separator ("f u c k",
+     * "f.u.c.k"). The joined letters must equal a dictionary word exactly:
+     * runs like "U S A" or letters inside spelled-out sentences never flag.
+     */
+    findSeparatedMatches(searchText, originalText) {
+        const results = [];
+        // Single letters joined by one consistent separator, at least 3 letters,
+        // not touching letters/digits on either side.
+        const runRegex = /(?<![\p{L}\p{N}])\p{L}(?:([ ._\-/])\p{L})(?:\1\p{L})+(?![\p{L}\p{N}])/gu;
+        let runMatch;
+        while ((runMatch = runRegex.exec(searchText)) !== null) {
+            const run = runMatch[0];
+            const separator = runMatch[1];
+            const joined = run.split(separator).join("");
+            const trieMatches = this.profanityTrie.findMatches(joined, 0, false);
+            const exact = trieMatches.find((m) => m.end === joined.length);
+            if (!exact)
+                continue;
+            const start = runMatch.index;
+            const end = start + run.length;
+            const matchedText = originalText.substring(start, end);
+            if (this.isWhitelistedMatch(exact.word, joined) ||
+                this.isWhitelistedMatch(exact.word, matchedText)) {
+                continue;
+            }
+            results.push({ word: exact.word, start, end, originalWord: matchedText });
+        }
+        return results;
     }
     /**
-     * Escape regex special characters in a string.
-     * @param str - The string to escape.
-     * @returns The escaped string.
+     * Find unambiguous profanity stems embedded inside larger tokens
+     * ("sisfuck", "totalshitshow"). Only stems from EMBEDDED_STRONG_STEMS that
+     * are currently in the dictionary are considered, and tokens listed in
+     * EMBEDDED_SAFE_WORDS or the whitelist never flag. The whole containing
+     * token is reported so cleaning masks all of it.
      */
-    escapeRegex(str) {
-        return str.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+    findEmbeddedMatches(searchText, originalText) {
+        const results = [];
+        for (const stem of EMBEDDED_STRONG_STEMS) {
+            // Respect remove()/clearList(): only flag stems still in the dictionary
+            const exact = this.profanityTrie
+                .findMatches(stem, 0, false)
+                .some((m) => m.end === stem.length);
+            if (!exact)
+                continue;
+            let index = searchText.indexOf(stem);
+            while (index !== -1) {
+                // Expand to the containing token
+                let tokenStart = index;
+                let tokenEnd = index + stem.length;
+                while (tokenStart > 0 && /\w/.test(searchText[tokenStart - 1])) {
+                    tokenStart--;
+                }
+                while (tokenEnd < searchText.length &&
+                    /\w/.test(searchText[tokenEnd])) {
+                    tokenEnd++;
+                }
+                const token = searchText.substring(tokenStart, tokenEnd);
+                const isEmbedded = token !== stem; // exact tokens are the base pass's job
+                if (isEmbedded &&
+                    !EMBEDDED_SAFE_WORDS.has(token.toLowerCase()) &&
+                    !this.isWhitelisted(token) &&
+                    !this.isWhitelistedMatch(stem, token)) {
+                    results.push({
+                        word: stem,
+                        start: tokenStart,
+                        end: tokenEnd,
+                        originalWord: originalText.substring(tokenStart, tokenEnd),
+                    });
+                }
+                index = searchText.indexOf(stem, tokenEnd);
+            }
+        }
+        return results;
     }
     /**
      * Check if a match is bounded by word boundaries (strict mode).
@@ -411,6 +1183,27 @@ export class AllProfanity {
                 this.whitelistSet.has(matchedText.toLowerCase()));
         }
     }
+    /**
+     * In partial-word mode, check whether the word CONTAINING the match is
+     * whitelisted: with "classic" whitelisted, the embedded "ass" must not flag.
+     */
+    isWhitelistedContainingWord(originalText, start, end) {
+        if (!this.detectPartialWords || this.whitelistSet.size === 0) {
+            return false;
+        }
+        let tokenStart = start;
+        let tokenEnd = end;
+        while (tokenStart > 0 && /\w/.test(originalText[tokenStart - 1])) {
+            tokenStart--;
+        }
+        while (tokenEnd < originalText.length && /\w/.test(originalText[tokenEnd])) {
+            tokenEnd++;
+        }
+        if (tokenStart === start && tokenEnd === end) {
+            return false; // match is the whole token; already covered by isWhitelistedMatch
+        }
+        return this.isWhitelisted(originalText.substring(tokenStart, tokenEnd));
+    }
     /**
      * Remove overlapping matches, keeping only the longest at each start position.
      * @param matches - Array of match results.
@@ -435,26 +1228,31 @@ export class AllProfanity {
     /**
      * Use Aho-Corasick algorithm for pattern matching
      */
-    findMatchesWithAhoCorasick(searchText, originalText) {
+    findMatchesWithAhoCorasick(searchText, originalText, posMap) {
         if (!this.ahoCorasickAutomaton) {
             return [];
         }
         const ahoMatches = this.ahoCorasickAutomaton.findAll(searchText);
         const results = [];
         for (const match of ahoMatches) {
+            const start = posMap ? posMap.starts[match.start] : match.start;
+            const end = posMap ? posMap.ends[match.end - 1] : match.end;
             if (!this.detectPartialWords &&
-                !this.isWholeWord(originalText, match.start, match.end)) {
+                !this.isWholeWord(originalText, start, end)) {
                 continue;
             }
-            const matchedText = originalText.substring(match.start, match.end);
+            const matchedText = originalText.substring(start, end);
             if (this.isWhitelistedMatch(match.pattern, matchedText)) {
                 continue;
             }
-            if (this.hasWordBoundaries(originalText, match.start, match.end)) {
+            if (this.isWhitelistedContainingWord(originalText, start, end)) {
+                continue;
+            }
+            if (this.hasWordBoundaries(originalText, start, end)) {
                 results.push({
                     word: match.pattern,
-                    start: match.start,
-                    end: match.end,
+                    start,
+                    end,
                     originalWord: matchedText,
                 });
             }
@@ -462,25 +1260,38 @@ export class AllProfanity {
         return results;
     }
     /**
-     * Hybrid approach: Aho-Corasick for fast matching, Bloom Filter for validation
+     * Check whether the Bloom Filter can quickly rule out any profanity in the
+     * text. Only safe for ASCII whole-word matching: partial matches and
+     * non-ASCII scripts can match inside tokens, so they bypass the prefilter.
      */
-    findMatchesHybrid(searchText, originalText) {
+    bloomQuickReject(searchText) {
+        if (!this.bloomFilter || this.detectPartialWords)
+            return false;
+        // eslint-disable-next-line no-control-regex
+        if (!/^[\x00-\x7F]*$/.test(searchText))
+            return false;
+        const tokens = searchText.split(/[^\p{L}\p{N}]+/u);
+        for (const token of tokens) {
+            if (token.length > 0 && this.bloomFilter.mightContain(token)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Hybrid approach: Bloom Filter for quick rejection, Aho-Corasick for matching
+     */
+    findMatchesHybrid(searchText, originalText, posMap) {
+        if (this.bloomQuickReject(searchText)) {
+            return [];
+        }
         // 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;
+            return this.findMatchesWithAhoCorasick(searchText, originalText, posMap);
         }
         // 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));
-        }
+        this.findMatches(searchText, originalText, matches, posMap);
         return matches;
     }
     /**
@@ -497,66 +1308,117 @@ export class AllProfanity {
         });
     }
     /**
-     * Detect profanity in a given text.
-     * @param text - The text to check.
-     * @returns Profanity detection result.
+     * Drop all cached detection results. Must be called whenever the word lists
+     * or any option that affects detection output changes.
      */
-    detect(text) {
+    invalidateCache() {
         var _a;
+        (_a = this.resultCache) === null || _a === void 0 ? void 0 : _a.clear();
+    }
+    /**
+     * Detects profanity in the provided text and returns comprehensive analysis.
+     *
+     * @param {string} text - The text to analyze for profanity
+     * @returns {ProfanityDetectionResult} Detailed detection result including matches, positions, severity, and cleaned text
+     *
+     * @throws {TypeError} If text is not a string
+     *
+     * @remarks
+     * ### Performance:
+     * - Time Complexity: O(n*m) where n is text length, m is average word length in dictionary
+     * - With Bloom Filter: O(n) average case (faster early rejection)
+     * - With Caching: O(1) for repeated identical text
+     *
+     * ### Features:
+     * - Detects leet speak variations (if enabled): "h3ll0" → "hello"
+     * - Respects word boundaries (strict mode) or detects partial matches
+     * - Returns exact positions for highlighting/masking
+     * - Calculates severity based on match count and uniqueness
+     *
+     * ### Caching:
+     * - Results are cached if `performance.enableCaching` is true
+     * - Cache uses LRU eviction when size limit is reached
+     *
+     * @example
+     * ```typescript
+     * const filter = new AllProfanity();
+     * const result = filter.detect("This has bad words");
+     *
+     * console.log(result.hasProfanity); // true
+     * console.log(result.detectedWords); // ['bad']
+     * console.log(result.cleanedText); // 'This has *** words'
+     * console.log(result.severity); // ProfanitySeverity.MILD
+     * console.log(result.positions); // [{ word: 'bad', start: 9, end: 12 }]
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // With leet speak detection
+     * const filter = new AllProfanity({ enableLeetSpeak: true });
+     * const result = filter.detect("st0p b3ing b@d");
+     *
+     * if (result.hasProfanity) {
+     *   result.positions.forEach(pos => {
+     *     console.log(`Found "${pos.word}" at position ${pos.start}-${pos.end}`);
+     *   });
+     * }
+     * ```
+     *
+     * @see {@link ProfanityDetectionResult} for result structure
+     * @see {@link ProfanitySeverity} for severity levels
+     */
+    detect(text) {
         const validatedText = validateString(text, "text");
         if (validatedText.length === 0) {
             return {
                 hasProfanity: false,
                 detectedWords: [],
                 cleanedText: validatedText,
-                severity: ProfanitySeverity.MILD,
+                severity: ProfanitySeverity.NONE,
                 positions: [],
             };
         }
-        // Check cache first if enabled
-        if ((_a = this.resultCache) === null || _a === void 0 ? void 0 : _a.has(validatedText)) {
-            return this.resultCache.get(validatedText);
+        // Check cache first if enabled (refresh recency for LRU eviction)
+        if (this.resultCache) {
+            const cached = this.resultCache.get(validatedText);
+            if (cached) {
+                this.resultCache.delete(validatedText);
+                this.resultCache.set(validatedText, cached);
+                return cached;
+            }
         }
         let matches = [];
         const normalizedText = this.caseSensitive
             ? validatedText
             : validatedText.toLowerCase();
-        // 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;
+        // Scan the base text plus every triggered normalization variant
+        // (unicode folding, leet speak, repeated-character collapse)
+        for (const pass of this.buildScanPasses(normalizedText)) {
+            switch (this.matchingAlgorithm) {
+                case "aho-corasick":
+                    matches.push(...this.findMatchesWithAhoCorasick(pass.text, validatedText, pass.posMap));
+                    break;
+                case "hybrid":
+                    matches.push(...this.findMatchesHybrid(pass.text, validatedText, pass.posMap));
+                    break;
+                case "trie":
+                default:
+                    this.findMatches(pass.text, validatedText, matches, pass.posMap);
+                    break;
+            }
+        }
+        if (this.evasionMaskedChars) {
+            matches.push(...this.findMaskedMatches(normalizedText, validatedText));
+        }
+        if (this.evasionSeparatedLetters) {
+            matches.push(...this.findSeparatedMatches(normalizedText, validatedText));
+        }
+        if (this.evasionEmbeddedWords) {
+            matches.push(...this.findEmbeddedMatches(normalizedText, validatedText));
         }
         // Apply context analysis if enabled
         if (this.contextAnalyzer) {
-            matches = this.applyContextAnalysis(validatedText, matches);
+            matches = this.applyContextAnalysis(validatedText, matches, this.contextScoreThreshold);
         }
         const uniqueMatches = this.deduplicateMatches(matches);
         const detectedWords = uniqueMatches.map((m) => m.originalWord);
@@ -573,14 +1435,15 @@ export class AllProfanity {
                 end: m.end,
             })),
         };
-        // Cache result if caching is enabled
+        // Cache result if caching is enabled (evict least recently used entry)
         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);
+            if (this.resultCache.size >= this.cacheMaxSize) {
+                const oldestKey = this.resultCache.keys().next().value;
+                if (oldestKey !== undefined) {
+                    this.resultCache.delete(oldestKey);
+                }
             }
+            this.resultCache.set(validatedText, result);
         }
         return result;
     }
@@ -590,12 +1453,14 @@ export class AllProfanity {
      * @param originalText - The original text.
      * @param matches - Array to collect matches.
      */
-    findMatches(searchText, originalText, matches) {
+    findMatches(searchText, originalText, matches, posMap) {
         for (let i = 0; i < searchText.length; i++) {
             const matchResults = this.profanityTrie.findMatches(searchText, i, this.detectPartialWords);
             for (const match of matchResults) {
-                const start = i + match.start;
-                const end = i + match.end;
+                const searchStart = i + match.start;
+                const searchEnd = i + match.end;
+                const start = posMap ? posMap.starts[searchStart] : searchStart;
+                const end = posMap ? posMap.ends[searchEnd - 1] : searchEnd;
                 if (!this.detectPartialWords &&
                     !this.isWholeWord(originalText, start, end)) {
                     continue;
@@ -604,6 +1469,9 @@ export class AllProfanity {
                 if (this.isWhitelistedMatch(match.word, matchedText)) {
                     continue;
                 }
+                if (this.isWhitelistedContainingWord(originalText, start, end)) {
+                    continue;
+                }
                 if (this.hasWordBoundaries(originalText, start, end)) {
                     matches.push({
                         word: match.word,
@@ -636,18 +1504,149 @@ export class AllProfanity {
         return result;
     }
     /**
-     * Check if a string contains profanity.
-     * @param text - The text to check.
-     * @returns True if profanity is found, false otherwise.
+     * Quick boolean check for profanity presence in text.
+     *
+     * @param {string} text - The text to check for profanity
+     * @returns {boolean} True if profanity is detected, false otherwise
+     *
+     * @throws {TypeError} If text is not a string
+     *
+     * @remarks
+     * - Convenience method that internally calls `detect()` and returns only the boolean result
+     * - For detailed information about matches, use `detect()` instead
+     * - Results are cached if caching is enabled (same cache as `detect()`)
+     *
+     * @example
+     * ```typescript
+     * const filter = new AllProfanity();
+     *
+     * if (filter.check("This has bad words")) {
+     *   console.log("Profanity detected!");
+     * }
+     *
+     * // Quick validation
+     * const isClean = !filter.check(userInput);
+     * ```
+     *
+     * @see {@link detect} for detailed profanity analysis
      */
     check(text) {
-        return this.detect(text).hasProfanity;
+        const validatedText = validateString(text, "text");
+        if (validatedText.length === 0)
+            return false;
+        // Reuse a cached full result when available
+        if (this.resultCache) {
+            const cached = this.resultCache.get(validatedText);
+            if (cached)
+                return cached.hasProfanity;
+        }
+        // Context analysis scores matches against their surroundings; reuse the
+        // full pipeline so check() and detect() can never disagree.
+        if (this.contextAnalyzer) {
+            return this.detect(validatedText).hasProfanity;
+        }
+        const normalizedText = this.caseSensitive
+            ? validatedText
+            : validatedText.toLowerCase();
+        // Early exit on the first accepted match — unlike detect(), no positions,
+        // severity or cleaned text are computed. The base text is scanned before
+        // any normalization variants are built, so plainly profane text returns
+        // without paying for normalization at all.
+        if (this.hasMatchInPass(normalizedText, validatedText)) {
+            return true;
+        }
+        const passes = this.buildScanPasses(normalizedText);
+        for (let p = 1; p < passes.length; p++) {
+            if (this.hasMatchInPass(passes[p].text, validatedText, passes[p].posMap)) {
+                return true;
+            }
+        }
+        if (this.evasionMaskedChars &&
+            this.findMaskedMatches(normalizedText, validatedText).length > 0) {
+            return true;
+        }
+        if (this.evasionSeparatedLetters &&
+            this.findSeparatedMatches(normalizedText, validatedText).length > 0) {
+            return true;
+        }
+        if (this.evasionEmbeddedWords &&
+            this.findEmbeddedMatches(normalizedText, validatedText).length > 0) {
+            return true;
+        }
+        return false;
     }
     /**
-     * Clean text with a custom placeholder.
-     * @param text - The text to clean.
-     * @param placeholder - The placeholder to use.
-     * @returns Cleaned text.
+     * Trie scan that stops at the first match surviving the whole-word,
+     * whitelist and boundary checks. Powers the fast path in check().
+     */
+    hasMatchInPass(searchText, originalText, posMap) {
+        for (let i = 0; i < searchText.length; i++) {
+            const matchResults = this.profanityTrie.findMatches(searchText, i, this.detectPartialWords);
+            for (const match of matchResults) {
+                const searchEnd = i + match.end;
+                const start = posMap ? posMap.starts[i] : i;
+                const end = posMap ? posMap.ends[searchEnd - 1] : searchEnd;
+                if (!this.detectPartialWords &&
+                    !this.isWholeWord(originalText, start, end)) {
+                    continue;
+                }
+                const matchedText = originalText.substring(start, end);
+                if (this.isWhitelistedMatch(match.word, matchedText)) {
+                    continue;
+                }
+                if (this.isWhitelistedContainingWord(originalText, start, end)) {
+                    continue;
+                }
+                if (this.hasWordBoundaries(originalText, start, end)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Cleans text by replacing profanity with a placeholder character.
+     *
+     * @param {string} text - The text to clean
+     * @param {string} [placeholder] - Optional custom placeholder character (uses default if not provided)
+     * @returns {string} The cleaned text with profanity replaced
+     *
+     * @throws {TypeError} If text is not a string
+     *
+     * @remarks
+     * ### Character-level Replacement:
+     * - Each profane character is replaced individually
+     * - "bad" with placeholder "*" becomes "***"
+     * - Preserves text length and structure
+     *
+     * ### Placeholder Behavior:
+     * - If no placeholder provided, uses the instance's default placeholder
+     * - If placeholder provided, uses only the first character
+     * - Empty placeholder throws error
+     *
+     * @example
+     * ```typescript
+     * const filter = new AllProfanity();
+     *
+     * // Using default placeholder (*)
+     * const cleaned = filter.clean("This has bad words");
+     * console.log(cleaned); // "This has *** *****"
+     *
+     * // Using custom placeholder
+     * const cleaned = filter.clean("This has bad words", "#");
+     * console.log(cleaned); // "This has ### #####"
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Clean user-generated content for display
+     * const userComment = "Some inappropriate words here";
+     * const safeComment = filter.clean(userComment);
+     * displayComment(safeComment);
+     * ```
+     *
+     * @see {@link cleanWithPlaceholder} for word-level replacement
+     * @see {@link setPlaceholder} to change default placeholder
      */
     clean(text, placeholder) {
         const detection = this.detect(text);
@@ -663,9 +1662,10 @@ export class AllProfanity {
                 originalWord: text.substring(p.start, p.end),
             }))),
         ].sort((a, b) => b.start - a.start);
+        const placeholderChar = placeholder.charAt(0);
         for (const pos of sortedPositions) {
             const originalWord = text.substring(pos.start, pos.end);
-            const replacement = placeholder.repeat(originalWord.length);
+            const replacement = placeholderChar.repeat(originalWord.length);
             result =
                 result.substring(0, pos.start) +
                     replacement +
@@ -674,10 +1674,46 @@ export class AllProfanity {
         return result;
     }
     /**
-     * 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.
+     * Cleans text by replacing each profane word with a single placeholder string (word-level replacement).
+     *
+     * @param {string} text - The text to clean
+     * @param {string} [placeholder="***"] - The placeholder string to use for each profane word
+     * @returns {string} The cleaned text with each profane word replaced by the placeholder
+     *
+     * @throws {TypeError} If text is not a string
+     *
+     * @remarks
+     * ### Word-level Replacement:
+     * - Each profane word is replaced with the entire placeholder string (not character-by-character)
+     * - "bad words" with placeholder "***" becomes "*** ***"
+     * - Does NOT preserve original text length
+     *
+     * ### Difference from `clean()`:
+     * - `clean()`: Character-level replacement - "bad" becomes "***" (preserves length)
+     * - `cleanWithPlaceholder()`: Word-level replacement - "bad" becomes "***" (fixed placeholder)
+     *
+     * @example
+     * ```typescript
+     * const filter = new AllProfanity();
+     *
+     * // Default placeholder (***) const text = "This has bad words";
+     * const cleaned = filter.cleanWithPlaceholder(text);
+     * console.log(cleaned); // "This has *** ***"
+     *
+     * // Custom placeholder
+     * const cleaned2 = filter.cleanWithPlaceholder(text, "[CENSORED]");
+     * console.log(cleaned2); // "This has [CENSORED] [CENSORED]"
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Censoring chat messages
+     * const message = "You are a badword and stupid";
+     * const censored = filter.cleanWithPlaceholder(message, "[***]");
+     * // Result: "You are a [***] and [***]"
+     * ```
+     *
+     * @see {@link clean} for character-level replacement
      */
     cleanWithPlaceholder(text, placeholder = "***") {
         const detection = this.detect(text);
@@ -703,51 +1739,144 @@ export class AllProfanity {
         return result;
     }
     /**
-     * Add word(s) to the profanity filter.
-     * @param word - Word or array of words to add.
+     * Dynamically adds one or more words to the profanity filter at runtime.
+     *
+     * @param {string | string[]} word - A single word or array of words to add to the filter
+     * @returns {void}
+     *
+     * @remarks
+     * ### Behavior:
+     * - Words are added to all active data structures (Trie, Aho-Corasick, Bloom Filter)
+     * - Automatically normalizes words based on caseSensitive setting
+     * - Skips whitelisted words
+     * - Validates and filters out non-string or empty values
+     * - Changes take effect immediately for subsequent detect/check/clean calls
+     *
+     * ### Use Cases:
+     * - Adding context-specific profanity
+     * - Building dynamic word lists from user reports
+     * - Customizing filters for specific communities/applications
+     *
+     * @example
+     * ```typescript
+     * const filter = new AllProfanity();
+     *
+     * // Add single word
+     * filter.add('newbadword');
+     *
+     * // Add multiple words
+     * filter.add(['word1', 'word2', 'word3']);
+     *
+     * // Now these words will be detected
+     * filter.check('newbadword'); // true
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Add game-specific slang dynamically
+     * const filter = new AllProfanity();
+     * const gamingSlang = ['noob', 'trash', 'tryhard'];
+     * filter.add(gamingSlang);
+     *
+     * const message = "You're such a noob";
+     * console.log(filter.check(message)); // true
+     * ```
+     *
+     * @see {@link remove} to remove words
+     * @see {@link loadCustomDictionary} for loading named dictionaries
      */
     add(word) {
         const words = Array.isArray(word) ? word : [word];
-        const validatedWords = validateStringArray(words, "words to add");
+        const validatedWords = validateStringArray(words, "words to add", this.logger);
         for (const w of validatedWords) {
             this.dynamicWords.add(w);
             this.addWordToTrie(w);
         }
+        this.invalidateCache();
     }
     /**
-     * Remove word(s) from the profanity filter.
-     * @param word - Word or array of words to remove.
+     * Dynamically removes one or more words from the profanity filter at runtime.
+     *
+     * @param {string | string[]} word - A single word or array of words to remove from the filter
+     * @returns {void}
+     *
+     * @remarks
+     * ### Behavior:
+     * - Removes words from all active data structures (Trie, dynamic words set)
+     * - Normalizes words based on caseSensitive setting before removal
+     * - Only removes dynamically added words, not words from loaded language dictionaries
+     * - Changes take effect immediately for subsequent detect/check/clean calls
+     *
+     * ### Important Notes:
+     * - Cannot remove words from built-in language dictionaries
+     * - To exclude dictionary words, use `addToWhitelist()` instead
+     * - Validates and filters out non-string or empty values
+     *
+     * @example
+     * ```typescript
+     * const filter = new AllProfanity();
+     *
+     * // Add then remove a word
+     * filter.add('tempword');
+     * filter.check('tempword'); // true
+     *
+     * filter.remove('tempword');
+     * filter.check('tempword'); // false
+     *
+     * // Remove multiple words
+     * filter.remove(['word1', 'word2']);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Managing custom word list
+     * const filter = new AllProfanity();
+     * filter.add(['custom1', 'custom2', 'custom3']);
+     *
+     * // Later, remove one that's no longer needed
+     * filter.remove('custom2');
+     * ```
+     *
+     * @see {@link add} to add words
+     * @see {@link addToWhitelist} to exclude dictionary words without removing them
      */
     remove(word) {
+        var _a;
         const words = Array.isArray(word) ? word : [word];
-        const validatedWords = validateStringArray(words, "words to remove");
+        const validatedWords = validateStringArray(words, "words to remove", this.logger);
         for (const w of validatedWords) {
             const normalizedWord = this.caseSensitive ? w : w.toLowerCase();
             this.profanityTrie.removeWord(normalizedWord);
             this.dynamicWords.delete(w);
+            // Bloom filter entries cannot be deleted, but stale entries only cost a
+            // skipped quick-rejection — they can never produce a match by themselves.
+            (_a = this.ahoCorasickAutomaton) === null || _a === void 0 ? void 0 : _a.removePattern(normalizedWord);
         }
+        this.invalidateCache();
     }
     /**
      * Add words to the whitelist.
      * @param words - Words to whitelist.
      */
     addToWhitelist(words) {
-        const validatedWords = validateStringArray(words, "whitelist words");
+        const validatedWords = validateStringArray(words, "whitelist words", this.logger);
         for (const word of validatedWords) {
             const normalizedWord = this.caseSensitive ? word : word.toLowerCase();
             this.whitelistSet.add(normalizedWord);
         }
+        this.invalidateCache();
     }
     /**
      * Remove words from the whitelist.
      * @param words - Words to remove from whitelist.
      */
     removeFromWhitelist(words) {
-        const validatedWords = validateStringArray(words, "whitelist words");
+        const validatedWords = validateStringArray(words, "whitelist words", this.logger);
         for (const word of validatedWords) {
             const normalizedWord = this.caseSensitive ? word : word.toLowerCase();
             this.whitelistSet.delete(normalizedWord);
         }
+        this.invalidateCache();
     }
     /**
      * Check if a word is whitelisted.
@@ -759,9 +1888,60 @@ export class AllProfanity {
         return this.whitelistSet.has(normalizedWord);
     }
     /**
-     * Load a built-in language dictionary.
-     * @param language - The language key.
-     * @returns True if loaded, false otherwise.
+     * Loads a built-in language dictionary into the profanity filter.
+     *
+     * @param {string} language - The language key to load (case-insensitive)
+     * @returns {boolean} True if language was loaded successfully, false if not found or already loaded
+     *
+     * @remarks
+     * ### Available Languages:
+     * - `'english'` - English profanity words
+     * - `'hindi'` - Hindi profanity words
+     * - `'french'` - French profanity words
+     * - `'german'` - German profanity words
+     * - `'spanish'` - Spanish profanity words
+     * - `'bengali'` - Bengali profanity words
+     * - `'tamil'` - Tamil profanity words
+     * - `'telugu'` - Telugu profanity words
+     * - `'brazilian'` - Brazilian Portuguese profanity words
+     *
+     * ### Behavior:
+     * - Language keys are case-insensitive
+     * - Loading is idempotent - calling multiple times for same language is safe
+     * - Returns true if language loaded successfully or was already loaded
+     * - Returns false if language not found
+     * - Logs success/failure messages (unless silent mode enabled)
+     * - Words are added to all active data structures
+     *
+     * ### Default Languages:
+     * English and Hindi are loaded automatically in the constructor
+     *
+     * @example
+     * ```typescript
+     * const filter = new AllProfanity();
+     *
+     * // Load additional languages
+     * filter.loadLanguage('french');
+     * filter.loadLanguage('spanish');
+     *
+     * // Case-insensitive
+     * filter.loadLanguage('GERMAN'); // Works
+     *
+     * // Check if loaded
+     * console.log(filter.getLoadedLanguages()); // ['english', 'hindi', 'french', 'spanish', 'german']
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Load all Indian languages at once
+     * const filter = new AllProfanity();
+     * filter.loadIndianLanguages();
+     * ```
+     *
+     * @see {@link loadLanguages} to load multiple languages at once
+     * @see {@link loadIndianLanguages} for convenience method
+     * @see {@link getAvailableLanguages} to see all available languages
+     * @see {@link getLoadedLanguages} to see currently loaded languages
      */
     loadLanguage(language) {
         if (!language || typeof language !== "string") {
@@ -785,6 +1965,7 @@ export class AllProfanity {
                 }
             }
             this.loadedLanguages.add(langKey);
+            this.invalidateCache();
             this.logger.info(`Loaded ${addedCount} words from ${language} dictionary`);
             return true;
         }
@@ -799,7 +1980,7 @@ export class AllProfanity {
      * @returns Number of successfully loaded languages.
      */
     loadLanguages(languages) {
-        const validatedLanguages = validateStringArray(languages, "languages");
+        const validatedLanguages = validateStringArray(languages, "languages", this.logger);
         return validatedLanguages.reduce((count, lang) => {
             return this.loadLanguage(lang) ? count + 1 : count;
         }, 0);
@@ -813,13 +1994,68 @@ export class AllProfanity {
         return this.loadLanguages(indianLanguages);
     }
     /**
-     * Load a custom dictionary.
-     * @param name - Name of the dictionary.
-     * @param words - Words to add.
+     * Loads a custom dictionary of profane words with a specific name.
+     *
+     * @param {string} name - Unique name/identifier for this custom dictionary
+     * @param {string[]} words - Array of profane words to add to the dictionary
+     * @returns {void}
+     *
+     * @throws {TypeError} If name is not a string or words is not an array
+     *
+     * @remarks
+     * ### Behavior:
+     * - Creates a new named dictionary or overwrites existing one with same name
+     * - Validates and filters out non-string and empty values from words array
+     * - Words are added to all active data structures (Trie, Aho-Corasick, Bloom Filter)
+     * - Dictionary name is converted to lowercase for storage
+     * - Logs count of loaded words (unless silent mode enabled)
+     *
+     * ### Use Cases:
+     * - Domain-specific profanity (gaming, medical, legal, etc.)
+     * - Organization-specific word lists
+     * - Temporary or context-dependent filters
+     * - Testing and development
+     *
+     * @example
+     * ```typescript
+     * const filter = new AllProfanity();
+     *
+     * // Load gaming-specific slang
+     * filter.loadCustomDictionary('gaming', [
+     *   'noob',
+     *   'scrub',
+     *   'tryhard',
+     *   'trash'
+     * ]);
+     *
+     * // Load company-specific terms
+     * filter.loadCustomDictionary('company', [
+     *   'competitor1',
+     *   'bannedTerm1',
+     *   'inappropriateJargon'
+     * ]);
+     *
+     * console.log(filter.check('You are such a noob')); // true
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Load from external source
+     * const filter = new AllProfanity();
+     *
+     * async function loadExternalDictionary() {
+     *   const response = await fetch('https://example.com/custom-words.json');
+     *   const customWords = await response.json();
+     *   filter.loadCustomDictionary('external', customWords);
+     * }
+     * ```
+     *
+     * @see {@link add} for adding individual words dynamically
+     * @see {@link loadLanguage} for loading built-in language dictionaries
      */
     loadCustomDictionary(name, words) {
         validateString(name, "dictionary name");
-        const validatedWords = validateStringArray(words, "custom dictionary words");
+        const validatedWords = validateStringArray(words, "custom dictionary words", this.logger);
         if (validatedWords.length === 0) {
             this.logger.warn(`Custom dictionary '${name}' contains no valid words`);
             return;
@@ -833,6 +2069,7 @@ export class AllProfanity {
             }
             this.availableLanguages[name.toLowerCase()] = validatedWords;
             this.loadedLanguages.add(name.toLowerCase());
+            this.invalidateCache();
             this.logger.info(`Loaded ${addedCount} words from custom dictionary '${name}'`);
         }
         catch (error) {
@@ -856,9 +2093,17 @@ export class AllProfanity {
         }
         // Add to Trie (always used as fallback)
         this.profanityTrie.addWord(normalizedWord);
-        // Add to Bloom Filter if enabled
+        // Add to Bloom Filter if enabled. Constituent tokens of multi-word or
+        // symbol-containing entries are added too, so the token-level quick
+        // rejection in bloomQuickReject() can never miss a phrase.
         if (this.bloomFilter) {
             this.bloomFilter.add(normalizedWord);
+            const tokens = normalizedWord.split(/[^\p{L}\p{N}]+/u);
+            for (const token of tokens) {
+                if (token.length > 0 && token !== normalizedWord) {
+                    this.bloomFilter.add(token);
+                }
+            }
         }
         // Add to Aho-Corasick automaton if enabled
         if (this.ahoCorasickAutomaton) {
@@ -873,7 +2118,7 @@ export class AllProfanity {
      */
     calculateSeverity(matches) {
         if (matches.length === 0)
-            return ProfanitySeverity.MILD;
+            return ProfanitySeverity.NONE;
         const uniqueWords = new Set(matches.map((m) => m.word)).size;
         const totalMatches = matches.length;
         if (totalMatches >= 5 || uniqueWords >= 4)
@@ -888,9 +2133,13 @@ export class AllProfanity {
      * Clear all loaded dictionaries and dynamic words.
      */
     clearList() {
+        var _a, _b;
         this.profanityTrie.clear();
         this.loadedLanguages.clear();
         this.dynamicWords.clear();
+        (_a = this.ahoCorasickAutomaton) === null || _a === void 0 ? void 0 : _a.clear();
+        (_b = this.bloomFilter) === null || _b === void 0 ? void 0 : _b.clear();
+        this.invalidateCache();
     }
     /**
      * Set the placeholder character for filtered words.
@@ -902,6 +2151,7 @@ export class AllProfanity {
             throw new Error("Placeholder cannot be empty");
         }
         this.defaultPlaceholder = placeholder.charAt(0);
+        this.invalidateCache();
     }
     /**
      * Get the list of loaded languages.
@@ -933,10 +2183,14 @@ export class AllProfanity {
         };
     }
     /**
-     * Rebuild the profanity trie from loaded dictionaries and dynamic words.
+     * Rebuild all matching structures (trie, Aho-Corasick automaton, Bloom
+     * Filter) from loaded dictionaries and dynamic words.
      */
-    rebuildTrie() {
+    rebuildIndexes() {
+        var _a, _b;
         this.profanityTrie.clear();
+        (_a = this.ahoCorasickAutomaton) === null || _a === void 0 ? void 0 : _a.clear();
+        (_b = this.bloomFilter) === null || _b === void 0 ? void 0 : _b.clear();
         for (const lang of this.loadedLanguages) {
             const words = this.availableLanguages[lang] || [];
             for (const word of words) {
@@ -946,6 +2200,7 @@ export class AllProfanity {
         for (const word of this.dynamicWords) {
             this.addWordToTrie(word);
         }
+        this.invalidateCache();
     }
     /**
      * Update configuration options for the profanity filter.
@@ -974,8 +2229,9 @@ export class AllProfanity {
             this.addToWhitelist(options.whitelistWords);
         }
         if (rebuildNeeded) {
-            this.rebuildTrie();
+            this.rebuildIndexes();
         }
+        this.invalidateCache();
     }
     /**
      * Create an AllProfanity instance from a configuration object.
@@ -992,8 +2248,12 @@ export class AllProfanity {
             options.ahoCorasick = config.ahoCorasick;
         if (config.contextAnalysis)
             options.contextAnalysis = config.contextAnalysis;
+        if (config.evasionProtection)
+            options.evasionProtection = config.evasionProtection;
         if (config.performance)
             options.performance = config.performance;
+        if (config.silent !== undefined)
+            options.silent = config.silent;
         if (config.profanityDetection) {
             options.enableLeetSpeak = config.profanityDetection.enableLeetSpeak;
             options.caseSensitive = config.profanityDetection.caseSensitive;
@@ -1024,7 +2284,8 @@ export class AllProfanity {
 }
 /**
  * Singleton instance of AllProfanity with default configuration.
+ * Silent so that importing the library never writes to the console.
  */
-const allProfanity = new AllProfanity();
+const allProfanity = new AllProfanity({ silent: true });
 export default allProfanity;
 //# sourceMappingURL=index.js.map