allprofanity 2.0.0 → 2.1.0

package/dist/index.js

@@ -1,3 +1,4 @@
+// Import language dictionaries (assuming these exist)
 import englishBadWords from "./languages/english-words.js";
 import hindiBadWords from "./languages/hindi-words.js";
 import frenchBadWords from "./languages/french-words.js";
@@ -15,6 +16,20 @@ 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";
+/**
+ * Default console logger implementation
+ */
+class ConsoleLogger {
+    info(message) {
+        console.log(`[AllProfanity] ${message}`);
+    }
+    warn(message) {
+        console.warn(`[AllProfanity] ${message}`);
+    }
+    error(message) {
+        console.error(`[AllProfanity] ${message}`);
+    }
+}
 /**
  * Severity levels for profanity detection
  */
@@ -26,77 +41,136 @@ export var ProfanitySeverity;
     ProfanitySeverity[ProfanitySeverity["EXTREME"] = 4] = "EXTREME";
 })(ProfanitySeverity = ProfanitySeverity || (ProfanitySeverity = {}));
 /**
- * Advanced AllProfanity - Custom profanity filter with multi-language support and leet speak detection
- * No external dependencies - built from scratch for maximum performance and control
+ * Validates input parameters
  */
-export class AllProfanity {
+function validateString(input, paramName) {
+    if (typeof input !== "string") {
+        throw new TypeError(`${paramName} must be a string, got ${typeof input}`);
+    }
+    return input;
+}
+function validateStringArray(input, paramName) {
+    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}`);
+            return false;
+        }
+        return item.trim().length > 0;
+    });
+}
+/**
+ * Efficient Trie data structure for fast string matching
+ */
+class TrieNode {
+    constructor() {
+        this.children = new Map();
+        this.isEndOfWord = false;
+        this.word = "";
+    }
+    /**
+     * Add a word to the trie
+     */
+    addWord(word) {
+        let current = this;
+        for (const char of word) {
+            if (!current.children.has(char)) {
+                current.children.set(char, new TrieNode());
+            }
+            const nextNode = current.children.get(char);
+            if (nextNode) {
+                current = nextNode;
+            }
+        }
+        current.isEndOfWord = true;
+        current.word = word;
+    }
     /**
-     * Create a new AllProfanity instance
-     * @param options - Configuration options
+     * Remove a word from the trie
      */
+    removeWord(word) {
+        return this.removeHelper(word, 0);
+    }
+    removeHelper(word, index) {
+        if (index === word.length) {
+            if (!this.isEndOfWord)
+                return false;
+            this.isEndOfWord = false;
+            return this.children.size === 0;
+        }
+        const char = word[index];
+        const node = this.children.get(char);
+        if (!node)
+            return false;
+        const shouldDeleteChild = node.removeHelper(word, index + 1);
+        if (shouldDeleteChild) {
+            this.children.delete(char);
+            return this.children.size === 0 && !this.isEndOfWord;
+        }
+        return false;
+    }
+    /**
+     * Find all matches starting at a given position
+     */
+    findMatches(text, startPos, allowPartial) {
+        const matches = [];
+        let current = this;
+        let pos = startPos;
+        while (pos < text.length) {
+            const nextNode = current.children.get(text[pos]);
+            if (!nextNode)
+                break;
+            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,
+                    });
+                }
+            }
+        }
+        return matches;
+    }
+    /**
+     * Clear all words from the trie
+     */
+    clear() {
+        this.children.clear();
+        this.isEndOfWord = false;
+        this.word = "";
+    }
+}
+/**
+ * Advanced AllProfanity - Fixed profanity filter with multi-language support
+ * Addresses all critical issues from the original implementation
+ */
+export class AllProfanity {
     constructor(options) {
-        var _a, _b, _c, _d;
-        this.profanitySet = new Set();
-        this.normalizedProfanityMap = new Map();
-        this.defaultPlaceholder = "*";
-        this.loadedLanguages = new Set();
+        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 = true;
-        // Comprehensive leet speak mapping
-        this.leetMap = {
-            a: ["4", "@", "^", "aye", "λ", "ª"],
-            b: ["8", "6", "|3", "ß", "β", "13"],
-            c: ["(", "<", "©", "¢", "see", "sea"],
-            d: ["|)", "|]", "0", "ð"],
-            e: ["3", "€", "£", "ë", "é", "è"],
-            f: ["|=", "ph", "|#", "ƒ"],
-            g: ["9", "6", "&", "gee"],
-            h: ["#", "|-|", "[-]", "}{", "ħ"],
-            i: ["1", "!", "|", "eye", "ï", "í", "ì"],
-            j: ["_|", "_/", "¿", "ĵ"],
-            k: ["|<", "1<", "l<", "|{", "ķ"],
-            l: ["1", "|", "7", "£", "ł", "ĺ"],
-            m: ["|/|", "//\\", "em", "ɱ"],
-            n: ["||", "//", "and", "ñ", "ń"],
-            o: ["0", "()", "oh", "ø", "ó", "ò", "ô"],
-            p: ["|*", "|o", "|^", "|>", "9", "þ"],
-            q: ["(_,)", "()_", "kw", "ĸ"],
-            r: ["|2", "12", ".-", "are", "ř", "ŕ"],
-            s: ["5", "$", "z", "ş", "ś", "š"],
-            t: ["7", "+", "-|-", "†", "ť", "ţ"],
-            u: ["(_)", "|_|", "v", "you", "ü", "ú", "ù"],
-            v: ["\\/", "|/", "|", "vee"],
-            w: ["\\/\\/", "vv", "dubya", "ŵ"],
-            x: ["><", "}{", "ecks", "χ"],
-            y: ["`/", "j", "why", "ÿ", "ý"],
-            z: ["2", "7_", "-/_", "zee", "ž", "ź", "ż"],
-        };
-        // Word boundary patterns
-        this.wordBoundaryChars = /[\s\.,;:!?\-_+=\[\]{}()"'\/\\]/;
-        // Common word variations and suffixes
-        this.commonSuffixes = [
-            "ing",
-            "ed",
-            "s",
-            "er",
-            "ers",
-            "est",
-            "ly",
-            "tion",
-            "ness",
-        ];
-        this.commonPrefixes = [
-            "un",
-            "re",
-            "pre",
-            "dis",
-            "over",
-            "under",
-            "out",
-        ];
+        this.detectPartialWords = false;
+        // Available language dictionaries
         this.availableLanguages = {
             english: englishBadWords || [],
             hindi: hindiBadWords || [],
@@ -107,442 +181,293 @@ export class AllProfanity {
             tamil: tamilBadWords || [],
             telugu: teluguBadWords || [],
         };
-        // Set configuration options
-        if (options === null || options === void 0 ? void 0 : options.defaultPlaceholder) {
+        // Fixed leet speak mappings
+        this.leetMappings = new Map([
+            ["@", "a"],
+            ["^", "a"],
+            ["4", "a"],
+            ["8", "b"],
+            ["6", "b"],
+            ["|3", "b"],
+            ["(", "c"],
+            ["<", "c"],
+            ["©", "c"],
+            ["|)", "d"],
+            ["0", "o"],
+            ["3", "e"],
+            ["€", "e"],
+            ["|=", "f"],
+            ["ph", "f"],
+            ["9", "g"],
+            ["#", "h"],
+            ["|-|", "h"],
+            ["1", "i"],
+            ["!", "i"],
+            ["|", "i"],
+            ["_|", "j"],
+            ["¿", "j"],
+            ["|<", "k"],
+            ["1<", "k"],
+            ["7", "l"],
+            ["|\\/|", "m"],
+            ["/\\/\\", "m"],
+            ["|\\|", "n"],
+            ["//", "n"],
+            ["()", "o"],
+            ["|*", "p"],
+            ["|o", "p"],
+            ["(_,)", "q"],
+            ["()_", "q"],
+            ["|2", "r"],
+            ["12", "r"],
+            ["5", "s"],
+            ["$", "s"],
+            ["z", "s"],
+            ["7", "t"],
+            ["+", "t"],
+            ["†", "t"],
+            ["|_|", "u"],
+            ["(_)", "u"],
+            ["v", "u"],
+            ["\\/", "v"],
+            ["|/", "v"],
+            ["\\/\\/", "w"],
+            ["vv", "w"],
+            ["><", "x"],
+            ["}{", "x"],
+            ["`/", "y"],
+            ["j", "y"],
+            ["2", "z"],
+            ["7_", "z"],
+        ]);
+        // Dynamic words added at runtime
+        this.dynamicWords = new Set();
+        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);
         }
         this.enableLeetSpeak = (_a = options === null || options === void 0 ? void 0 : options.enableLeetSpeak) !== null && _a !== void 0 ? _a : true;
         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 : true;
-        // Load whitelist if provided
+        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 the default English dictionary
+        // Load default languages
         this.loadLanguage("english");
-        // Load Hindi by default for backward compatibility
         this.loadLanguage("hindi");
-        // Load any additional languages specified in options
-        if (options === null || options === void 0 ? void 0 : options.languages) {
+        // 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 any custom dictionaries
+        // Load custom dictionaries
         if (options === null || options === void 0 ? void 0 : options.customDictionaries) {
-            Object.entries(options.customDictionaries).forEach(([langName, words]) => {
-                this.loadCustomDictionary(langName, words);
+            Object.entries(options.customDictionaries).forEach(([name, words]) => {
+                this.loadCustomDictionary(name, words);
             });
         }
     }
     /**
-     * Normalize text by converting leet speak to regular characters
-     * @param text - Text to normalize
-     * @returns Normalized text
+     * Normalize text by converting leet speak to regular characters.
      */
     normalizeLeetSpeak(text) {
         if (!this.enableLeetSpeak)
             return text;
         let normalized = text.toLowerCase();
-        // Define comprehensive leet mappings
-        const leetMappings = [
-            // Multi-character first
-            { pattern: /\|-\|/g, replacement: "h" },
-            { pattern: /\[-\]/g, replacement: "h" },
-            { pattern: /\}{\s*/g, replacement: "h" },
-            { pattern: /\|\/\|/g, replacement: "m" },
-            { pattern: /\/\/\\/g, replacement: "m" },
-            { pattern: /\|\|/g, replacement: "n" },
-            { pattern: /\/\//g, replacement: "n" },
-            { pattern: /\|2/g, replacement: "r" },
-            { pattern: /12/g, replacement: "r" },
-            { pattern: /\\\/\\\//g, replacement: "w" },
-            { pattern: /vv/g, replacement: "w" },
-            { pattern: /><\s*/g, replacement: "x" },
-            { pattern: /\(_\)/g, replacement: "u" },
-            { pattern: /\|_\|/g, replacement: "u" },
-            { pattern: /\\\//g, replacement: "v" },
-            { pattern: /\|\//g, replacement: "v" },
-            // Single character mappings
-            { pattern: /@/g, replacement: "a" },
-            { pattern: /4/g, replacement: "u" },
-            { pattern: /\^/g, replacement: "a" },
-            { pattern: /8/g, replacement: "b" },
-            { pattern: /6/g, replacement: "b" },
-            { pattern: /\(/g, replacement: "c" },
-            { pattern: /</g, replacement: "c" },
-            { pattern: /©/g, replacement: "c" },
-            { pattern: /¢/g, replacement: "c" },
-            { pattern: /0/g, replacement: "o" },
-            { pattern: /3/g, replacement: "e" },
-            { pattern: /€/g, replacement: "e" },
-            { pattern: /£/g, replacement: "e" },
-            { pattern: /9/g, replacement: "g" },
-            { pattern: /&/g, replacement: "g" },
-            { pattern: /#/g, replacement: "h" },
-            { pattern: /1/g, replacement: "i" },
-            { pattern: /!/g, replacement: "i" },
-            { pattern: /\|/g, replacement: "i" },
-            { pattern: /7/g, replacement: "t" },
-            { pattern: /5/g, replacement: "s" },
-            { pattern: /\$/g, replacement: "s" },
-            { pattern: /\+/g, replacement: "t" },
-            { pattern: /2/g, replacement: "z" },
-        ];
-        // Apply all mappings
-        for (const mapping of leetMappings) {
-            normalized = normalized.replace(mapping.pattern, mapping.replacement);
+        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);
         }
         return normalized;
     }
-    escapeRegex(str) {
-        if (!str || typeof str !== "string") {
-            return "";
-        }
-        return str.replace(/[\\^$.*+?()[\]{}|\-]/g, function (match) {
-            return "\\" + match;
-        });
-    }
     /**
-     * Generate word variations with common prefixes and suffixes
+     * Properly escape regex special characters
      */
-    generateWordVariations(word) {
-        const variations = new Set([word]);
-        // Add suffix variations
-        for (const suffix of this.commonSuffixes) {
-            variations.add(word + suffix);
-            // Handle words ending in 'e'
-            if (word.endsWith("e") && !suffix.startsWith("e")) {
-                variations.add(word.slice(0, -1) + suffix);
-            }
-            // Handle consonant doubling
-            if (word.length > 2 && /[bcdfghjklmnpqrstvwxyz]/.test(word.slice(-1))) {
-                variations.add(word + word.slice(-1) + suffix);
-            }
-        }
-        // Add prefix variations
-        for (const prefix of this.commonPrefixes) {
-            variations.add(prefix + word);
-        }
-        return Array.from(variations);
+    escapeRegex(str) {
+        return str.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
     }
     /**
-     * Check if text contains word boundaries around a match
+     * Check if a position has word boundaries (for strict mode)
      */
     hasWordBoundaries(text, start, end) {
         if (!this.strictMode)
             return true;
         const beforeChar = start > 0 ? text[start - 1] : " ";
         const afterChar = end < text.length ? text[end] : " ";
-        return (this.wordBoundaryChars.test(beforeChar) &&
-            this.wordBoundaryChars.test(afterChar));
+        const wordBoundaryRegex = /[\s\p{P}\p{S}]/u;
+        return (wordBoundaryRegex.test(beforeChar) && wordBoundaryRegex.test(afterChar));
     }
     /**
-     * Calculate severity based on detected words
+     * Helper method to verify whole-word matching.
      */
-    calculateSeverity(detectedWords) {
-        if (detectedWords.length === 0)
-            return ProfanitySeverity.MILD;
-        // This is a simplified severity calculation
-        // You can enhance this based on your specific word categorization
-        const totalWords = detectedWords.length;
-        const uniqueWords = new Set(detectedWords).size;
-        if (totalWords >= 5 || uniqueWords >= 3)
-            return ProfanitySeverity.EXTREME;
-        if (totalWords >= 3 || uniqueWords >= 2)
-            return ProfanitySeverity.SEVERE;
-        if (totalWords >= 2)
-            return ProfanitySeverity.MODERATE;
-        return ProfanitySeverity.MILD;
-    }
-    /**
-     * Load a built-in language dictionary
-     * @param language - The language to load
-     * @returns boolean - True if loaded successfully, false otherwise
-     */
-    loadLanguage(language) {
-        if (this.loadedLanguages.has(language.toLowerCase())) {
-            return true;
+    isWholeWord(text, start, end) {
+        // Check left boundary
+        if (start === 0) {
+            // ok
         }
-        const langKey = language.toLowerCase();
-        if (this.availableLanguages[langKey] &&
-            this.availableLanguages[langKey].length > 0) {
-            const words = this.availableLanguages[langKey];
-            // Add words and their variations to the profanity set
-            for (const word of words) {
-                if (!word || typeof word !== "string")
-                    continue;
-                const normalizedWord = this.caseSensitive ? word : word.toLowerCase();
-                this.profanitySet.add(normalizedWord);
-                // Store normalized leet version mapping
-                const leetNormalized = this.normalizeLeetSpeak(normalizedWord);
-                if (leetNormalized !== normalizedWord) {
-                    this.normalizedProfanityMap.set(leetNormalized, normalizedWord);
-                }
-                // Generate and add variations
-                const variations = this.generateWordVariations(normalizedWord);
-                for (const variation of variations) {
-                    this.profanitySet.add(variation);
-                    const leetVariation = this.normalizeLeetSpeak(variation);
-                    if (leetVariation !== variation) {
-                        this.normalizedProfanityMap.set(leetVariation, variation);
-                    }
-                }
-            }
-            this.loadedLanguages.add(langKey);
-            console.log(`AllProfanity: Added ${words.length} ${language} words to the profanity list.`);
-            return true;
-        }
-        else {
-            console.warn(`AllProfanity: Language '${language}' not found or empty in available dictionaries.`);
+        else if (/\w/.test(text[start - 1])) {
             return false;
         }
-    }
-    /**
-     * Load multiple languages at once
-     * @param languages - Array of language names to load
-     * @returns number - Number of successfully loaded languages
-     */
-    loadLanguages(languages) {
-        let successCount = 0;
-        languages.forEach((lang) => {
-            if (this.loadLanguage(lang)) {
-                successCount++;
-            }
-        });
-        return successCount;
-    }
-    /**
-     * Load all Indian languages at once
-     * @returns number - Number of Indian languages loaded
-     */
-    loadIndianLanguages() {
-        const indianLanguages = ["hindi", "bengali", "tamil", "telugu"];
-        return this.loadLanguages(indianLanguages);
-    }
-    /**
-     * Load a custom dictionary with a given name
-     * @param name - Name to identify this dictionary
-     * @param words - Array of profanity words
-     */
-    loadCustomDictionary(name, words) {
-        if (!words || words.length === 0) {
-            console.warn(`AllProfanity: Custom dictionary '${name}' has no words.`);
-            return;
+        // Check right boundary
+        if (end === text.length) {
+            // ok
         }
-        // Add to available languages for future reference
-        this.availableLanguages[name.toLowerCase()] = words;
-        // Process and add words
-        for (const word of words) {
-            if (!word || typeof word !== "string")
-                continue;
-            const normalizedWord = this.caseSensitive ? word : word.toLowerCase();
-            this.profanitySet.add(normalizedWord);
-            // Store normalized leet version mapping
-            const leetNormalized = this.normalizeLeetSpeak(normalizedWord);
-            if (leetNormalized !== normalizedWord) {
-                this.normalizedProfanityMap.set(leetNormalized, normalizedWord);
-            }
-            // Generate and add variations
-            const variations = this.generateWordVariations(normalizedWord);
-            for (const variation of variations) {
-                this.profanitySet.add(variation);
-                const leetVariation = this.normalizeLeetSpeak(variation);
-                if (leetVariation !== variation) {
-                    this.normalizedProfanityMap.set(leetVariation, variation);
-                }
-            }
+        else if (/\w/.test(text[end])) {
+            return false;
         }
-        this.loadedLanguages.add(name.toLowerCase());
-        console.log(`AllProfanity: Added ${words.length} words from custom '${name}' dictionary.`);
+        return true;
     }
     /**
-     * Add words to whitelist (words that should never be flagged as profanity)
-     * @param words - Array of words to whitelist
+     * Check if a match is whitelisted (by actual matched substring and dictionary word)
      */
-    addToWhitelist(words) {
-        for (const word of words) {
-            if (word && typeof word === "string") {
-                this.whitelistSet.add(this.caseSensitive ? word : word.toLowerCase());
-            }
+    isWhitelistedMatch(word, matchedText) {
+        if (this.caseSensitive) {
+            return this.whitelistSet.has(word) || this.whitelistSet.has(matchedText);
+        }
+        else {
+            return (this.whitelistSet.has(word.toLowerCase()) ||
+                this.whitelistSet.has(matchedText.toLowerCase()));
         }
     }
     /**
-     * Remove words from whitelist
-     * @param words - Array of words to remove from whitelist
+     * Remove overlapping matches, keep only the longest at each start position
      */
-    removeFromWhitelist(words) {
-        for (const word of words) {
-            if (word && typeof word === "string") {
-                this.whitelistSet.delete(this.caseSensitive ? word : word.toLowerCase());
+    deduplicateMatches(matches) {
+        const sorted = [...matches].sort((a, b) => {
+            if (a.start !== b.start)
+                return a.start - b.start;
+            return b.end - a.end;
+        });
+        const result = [];
+        let lastEnd = -1;
+        for (const match of sorted) {
+            if (match.start >= lastEnd) {
+                result.push(match);
+                lastEnd = match.end;
             }
         }
+        return result;
     }
     /**
-     * Advanced profanity detection with detailed results
-     * @param text - The text to analyze
-     * @returns ProfanityDetectionResult - Detailed detection results
+     * Advanced profanity detection using efficient trie-based algorithm
      */
     detect(text) {
-        if (!text || typeof text !== "string") {
+        const validatedText = validateString(text, "text");
+        if (validatedText.length === 0) {
             return {
                 hasProfanity: false,
                 detectedWords: [],
-                cleanedText: text || "",
+                cleanedText: validatedText,
                 severity: ProfanitySeverity.MILD,
                 positions: [],
             };
         }
-        const normalizedText = this.caseSensitive ? text : text.toLowerCase();
-        const leetNormalizedText = this.normalizeLeetSpeak(normalizedText);
-        const detectedWords = [];
-        const positions = [];
-        // Check for whole word matches first
-        for (const profanity of this.profanitySet) {
-            if (this.whitelistSet.has(profanity))
-                continue;
-            try {
-                // Create regex for word boundary detection
-                const escapedWord = this.escapeRegex(profanity);
-                const wordRegex = new RegExp(`\\b${escapedWord}\\b`, this.caseSensitive ? "g" : "gi");
-                let match;
-                while ((match = wordRegex.exec(normalizedText)) !== null) {
-                    if (this.hasWordBoundaries(normalizedText, match.index, match.index + match[0].length)) {
-                        detectedWords.push(match[0]);
-                        positions.push({
-                            word: match[0],
-                            start: match.index,
-                            end: match.index + match[0].length,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                // Fallback to simple string search if regex fails
-                const index = normalizedText.indexOf(profanity);
-                if (index !== -1) {
-                    detectedWords.push(profanity);
-                    positions.push({
-                        word: profanity,
-                        start: index,
-                        end: index + profanity.length,
-                    });
-                }
+        const 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);
             }
         }
-        // Check leet speak normalized text
-        if (this.enableLeetSpeak && leetNormalizedText !== normalizedText) {
-            for (const profanity of this.profanitySet) {
-                if (this.whitelistSet.has(profanity))
+        const uniqueMatches = this.deduplicateMatches(matches);
+        const detectedWords = uniqueMatches.map((m) => m.originalWord);
+        const severity = this.calculateSeverity(uniqueMatches);
+        const cleanedText = this.generateCleanedText(validatedText, uniqueMatches);
+        return {
+            hasProfanity: uniqueMatches.length > 0,
+            detectedWords,
+            cleanedText,
+            severity,
+            positions: uniqueMatches.map((m) => ({
+                word: m.originalWord,
+                start: m.start,
+                end: m.end,
+            })),
+        };
+    }
+    /**
+     * Main matching function, with whole-word logic.
+     */
+    findMatches(searchText, originalText, matches) {
+        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;
+                // Only match whole words if !detectPartialWords
+                if (!this.detectPartialWords &&
+                    !this.isWholeWord(originalText, start, end)) {
                     continue;
-                try {
-                    const escapedWord = this.escapeRegex(profanity);
-                    const wordRegex = new RegExp(`\\b${escapedWord}\\b`, this.caseSensitive ? "g" : "gi");
-                    let match;
-                    while ((match = wordRegex.exec(leetNormalizedText)) !== null) {
-                        if (this.hasWordBoundaries(leetNormalizedText, match.index, match.index + match[0].length)) {
-                            // Find the original text that corresponds to this match
-                            const originalMatch = normalizedText.substring(match.index, match.index + match[0].length);
-                            if (!detectedWords.includes(originalMatch)) {
-                                detectedWords.push(originalMatch);
-                                positions.push({
-                                    word: originalMatch,
-                                    start: match.index,
-                                    end: match.index + match[0].length,
-                                });
-                            }
-                        }
-                    }
                 }
-                catch (error) {
-                    // Fallback to simple string search
-                    if (leetNormalizedText.includes(profanity)) {
-                        const index = leetNormalizedText.indexOf(profanity);
-                        const originalMatch = normalizedText.substring(index, index + profanity.length);
-                        if (!detectedWords.includes(originalMatch)) {
-                            detectedWords.push(originalMatch);
-                            positions.push({
-                                word: originalMatch,
-                                start: index,
-                                end: index + profanity.length,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        // Partial word detection (if enabled)
-        if (this.detectPartialWords) {
-            for (const profanity of this.profanitySet) {
-                if (this.whitelistSet.has(profanity) || profanity.length < 4)
+                // Use actual matched text for whitelist check
+                const matchedText = originalText.substring(start, end);
+                if (this.isWhitelistedMatch(match.word, matchedText)) {
                     continue;
-                if (normalizedText.includes(profanity) ||
-                    leetNormalizedText.includes(profanity)) {
-                    const index = normalizedText.indexOf(profanity);
-                    if (index !== -1 &&
-                        !detectedWords.some((w) => normalizedText.indexOf(w) === index)) {
-                        detectedWords.push(profanity);
-                        positions.push({
-                            word: profanity,
-                            start: index,
-                            end: index + profanity.length,
-                        });
-                    }
+                }
+                if (this.hasWordBoundaries(originalText, start, end)) {
+                    matches.push({
+                        word: match.word,
+                        start,
+                        end,
+                        originalWord: matchedText,
+                    });
                 }
             }
         }
-        // REMOVED: cleanedText = this.clean(text) - this was causing circular dependency
-        // We'll generate the cleaned text directly here instead
-        let cleanedText = text;
-        if (detectedWords.length > 0) {
-            // Sort positions by start index in descending order to avoid index shifting
-            const sortedPositions = positions.sort((a, b) => b.start - a.start);
-            for (const pos of sortedPositions) {
-                const originalWord = text.substring(pos.start, pos.end);
-                const replacement = this.defaultPlaceholder.repeat(originalWord.length);
-                cleanedText =
-                    cleanedText.substring(0, pos.start) +
-                        replacement +
-                        cleanedText.substring(pos.end);
-            }
+    }
+    /**
+     * Generate cleaned text by replacing profane words (non-overlapping only)
+     */
+    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);
+            result =
+                result.substring(0, match.start) +
+                    replacement +
+                    result.substring(match.end);
         }
-        const severity = this.calculateSeverity(detectedWords);
-        return {
-            hasProfanity: detectedWords.length > 0,
-            detectedWords: [...new Set(detectedWords)],
-            cleanedText,
-            severity,
-            positions,
-        };
+        return result;
     }
     /**
-     * Check if a string contains profanity (simple boolean check)
-     * @param string - The string to check
-     * @returns boolean - True if profanity found, false otherwise
+     * Simple boolean check for profanity
      */
-    check(string) {
-        return this.detect(string).hasProfanity;
+    check(text) {
+        return this.detect(text).hasProfanity;
     }
     /**
-     * Clean a string by replacing profanities with placeholders
-     * @param string - The string to clean
-     * @param placeholder - Optional custom placeholder
-     * @returns string - The cleaned string
+     * Clean text with custom placeholder
      */
-    clean(string, placeholder) {
-        if (!string || typeof string !== "string")
-            return string || "";
-        const placeholderChar = placeholder || this.defaultPlaceholder;
-        const detection = this.detect(string);
-        // If detect() already provided cleanedText and no custom placeholder, use it
-        if (!placeholder && detection.cleanedText !== string) {
+    clean(text, placeholder) {
+        const detection = this.detect(text);
+        if (!placeholder || placeholder === this.defaultPlaceholder) {
             return detection.cleanedText;
         }
-        // Otherwise, build cleaned text with custom placeholder
-        let result = string;
-        const sortedPositions = detection.positions.sort((a, b) => b.start - a.start);
+        // Use custom placeholder
+        let result = text;
+        const sortedPositions = [
+            ...this.deduplicateMatches(detection.positions.map((p) => ({
+                word: p.word,
+                start: p.start,
+                end: p.end,
+                originalWord: text.substring(p.start, p.end),
+            }))),
+        ].sort((a, b) => b.start - a.start);
         for (const pos of sortedPositions) {
-            const originalWord = string.substring(pos.start, pos.end);
-            const replacement = placeholderChar.repeat(originalWord.length);
+            const originalWord = text.substring(pos.start, pos.end);
+            const replacement = placeholder.repeat(originalWord.length);
             result =
                 result.substring(0, pos.start) +
                     replacement +
@@ -551,107 +476,218 @@ export class AllProfanity {
         return result;
     }
     /**
-     * Clean a string by replacing each profane word with a single placeholder
-     * @param string - The string to clean
-     * @param placeholder - The placeholder to use (defaults to '***')
-     * @returns string - The cleaned string
-     */
-    cleanWithWord(string, placeholder = "***") {
-        if (!string || typeof string !== "string")
-            return string || "";
-        // Build a regex that matches any profane word with word boundaries, unicode-aware
-        const words = Array.from(this.profanitySet)
-            .map((w) => w.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")) // escape regex
-            .sort((a, b) => b.length - a.length); // longer words first to avoid partial matches
-        if (words.length === 0)
-            return string;
-        // Unicode safe word boundary: (?<=^|[^\p{L}\p{N}_])WORD(?=[^\p{L}\p{N}_]|$)
-        // This ensures we only match whole words, not inside other words.
-        const regex = new RegExp(`(?<=^|[\\s\\.,;:!\\?\\-_+=\\[\\]{}()"'\\/\\\\])(` +
-            words.join("|") +
-            `)(?=[\\s\\.,;:!\\?\\-_+=\\[\\]{}()"'\\/\\\\]|$)`, this.caseSensitive ? "gu" : "giu");
-        // Replace all matches with the placeholder.
-        return string.replace(regex, placeholder);
-    }
-    /**
-     * Get the current list of profanity words
-     * @returns string[] - Array of all profanity words
+     * Clean text by replacing each profane word with a single placeholder (word-level)
      */
-    list() {
-        return Array.from(this.profanitySet);
+    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,
+                start: p.start,
+                end: p.end,
+                originalWord: text.substring(p.start, p.end),
+            }))),
+        ].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 =
+                result.substring(0, pos.start) +
+                    placeholder +
+                    result.substring(pos.end);
+        }
+        return result;
     }
     /**
      * Add word(s) to the profanity list
-     * @param word - String or array of strings to add
      */
     add(word) {
         const words = Array.isArray(word) ? word : [word];
-        for (const w of words) {
-            if (!w || typeof w !== "string")
-                continue;
-            const normalizedWord = this.caseSensitive ? w : w.toLowerCase();
-            this.profanitySet.add(normalizedWord);
-            // Add leet speak mapping
-            const leetNormalized = this.normalizeLeetSpeak(normalizedWord);
-            if (leetNormalized !== normalizedWord) {
-                this.normalizedProfanityMap.set(leetNormalized, normalizedWord);
-            }
-            // Add variations
-            const variations = this.generateWordVariations(normalizedWord);
-            for (const variation of variations) {
-                this.profanitySet.add(variation);
-            }
+        const validatedWords = validateStringArray(words, "words to add");
+        for (const w of validatedWords) {
+            this.dynamicWords.add(w);
+            this.addWordToTrie(w);
         }
     }
     /**
      * Remove word(s) from the profanity list
-     * @param word - String or array of strings to remove
      */
     remove(word) {
         const words = Array.isArray(word) ? word : [word];
-        for (const w of words) {
-            if (!w || typeof w !== "string")
-                continue;
+        const validatedWords = validateStringArray(words, "words to remove");
+        for (const w of validatedWords) {
             const normalizedWord = this.caseSensitive ? w : w.toLowerCase();
-            this.profanitySet.delete(normalizedWord);
-            // Remove variations
-            const variations = this.generateWordVariations(normalizedWord);
-            for (const variation of variations) {
-                this.profanitySet.delete(variation);
+            this.profanityTrie.removeWord(normalizedWord);
+            this.dynamicWords.delete(w);
+        }
+    }
+    /**
+     * Add words to whitelist
+     */
+    addToWhitelist(words) {
+        const validatedWords = validateStringArray(words, "whitelist words");
+        for (const word of validatedWords) {
+            const normalizedWord = this.caseSensitive ? word : word.toLowerCase();
+            this.whitelistSet.add(normalizedWord);
+        }
+    }
+    /**
+     * Remove words from whitelist
+     */
+    removeFromWhitelist(words) {
+        const validatedWords = validateStringArray(words, "whitelist words");
+        for (const word of validatedWords) {
+            const normalizedWord = this.caseSensitive ? word : word.toLowerCase();
+            this.whitelistSet.delete(normalizedWord);
+        }
+    }
+    /**
+     * Helper for whitelist checking with correct normalization
+     */
+    isWhitelisted(word) {
+        const normalizedWord = this.caseSensitive ? word : word.toLowerCase();
+        return this.whitelistSet.has(normalizedWord);
+    }
+    /**
+     * Load a built-in language dictionary
+     */
+    loadLanguage(language) {
+        if (!language || typeof language !== "string") {
+            this.logger.warn(`Invalid language parameter: ${language}`);
+            return false;
+        }
+        const langKey = language.toLowerCase().trim();
+        if (this.loadedLanguages.has(langKey)) {
+            return true;
+        }
+        const words = this.availableLanguages[langKey];
+        if (!words || words.length === 0) {
+            this.logger.warn(`Language '${language}' not found or empty`);
+            return false;
+        }
+        try {
+            let addedCount = 0;
+            for (const word of words) {
+                if (this.addWordToTrie(word)) {
+                    addedCount++;
+                }
+            }
+            this.loadedLanguages.add(langKey);
+            this.logger.info(`Loaded ${addedCount} words from ${language} dictionary`);
+            return true;
+        }
+        catch (error) {
+            this.logger.error(`Failed to load language ${language}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Load multiple languages at once
+     */
+    loadLanguages(languages) {
+        const validatedLanguages = validateStringArray(languages, "languages");
+        return validatedLanguages.reduce((count, lang) => {
+            return this.loadLanguage(lang) ? count + 1 : count;
+        }, 0);
+    }
+    /**
+     * Load all Indian languages
+     */
+    loadIndianLanguages() {
+        const indianLanguages = ["hindi", "bengali", "tamil", "telugu"];
+        return this.loadLanguages(indianLanguages);
+    }
+    /**
+     * Load a custom dictionary
+     */
+    loadCustomDictionary(name, words) {
+        validateString(name, "dictionary name");
+        const validatedWords = validateStringArray(words, "custom dictionary words");
+        if (validatedWords.length === 0) {
+            this.logger.warn(`Custom dictionary '${name}' contains no valid words`);
+            return;
+        }
+        try {
+            let addedCount = 0;
+            for (const word of validatedWords) {
+                if (this.addWordToTrie(word)) {
+                    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}'`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to load custom dictionary ${name}: ${error}`);
         }
     }
     /**
-     * Clear the filter list and reset to default
+     * Add a single word to the trie structure
+     */
+    addWordToTrie(word) {
+        if (!word || typeof word !== "string" || word.trim().length === 0) {
+            return false;
+        }
+        const normalizedWord = this.caseSensitive
+            ? word.trim()
+            : word.trim().toLowerCase();
+        // Skip if whitelisted
+        if (this.isWhitelisted(normalizedWord)) {
+            return false;
+        }
+        // Add to trie
+        this.profanityTrie.addWord(normalizedWord);
+        return true;
+    }
+    /**
+     * Remove overlapping matches, keep only the longest at each start position
+     */
+    calculateSeverity(matches) {
+        if (matches.length === 0)
+            return ProfanitySeverity.MILD;
+        const uniqueWords = new Set(matches.map((m) => m.word)).size;
+        const totalMatches = matches.length;
+        if (totalMatches >= 5 || uniqueWords >= 4)
+            return ProfanitySeverity.EXTREME;
+        if (totalMatches >= 3 || uniqueWords >= 3)
+            return ProfanitySeverity.SEVERE;
+        if (totalMatches >= 2 || uniqueWords >= 2)
+            return ProfanitySeverity.MODERATE;
+        return ProfanitySeverity.MILD;
+    }
+    /**
+     * Clear all loaded dictionaries
      */
     clearList() {
-        this.profanitySet.clear();
-        this.normalizedProfanityMap.clear();
+        this.profanityTrie.clear();
         this.loadedLanguages.clear();
+        this.dynamicWords.clear();
     }
     /**
-     * Change the character used as placeholder
-     * @param placeholder - Single character to use as placeholder
+     * Set placeholder character
      */
     setPlaceholder(placeholder) {
-        if (placeholder.length !== 1) {
-            console.warn("AllProfanity: Placeholder should be a single character. Using first character.");
-            this.defaultPlaceholder = placeholder.charAt(0);
-        }
-        else {
-            this.defaultPlaceholder = placeholder;
+        validateString(placeholder, "placeholder");
+        if (placeholder.length === 0) {
+            throw new Error("Placeholder cannot be empty");
         }
+        this.defaultPlaceholder = placeholder.charAt(0);
     }
     /**
-     * Get the list of currently loaded languages
-     * @returns string[] - Array of loaded language names
+     * Get loaded languages
      */
     getLoadedLanguages() {
         return Array.from(this.loadedLanguages);
     }
     /**
-     * Get the list of available language dictionaries
-     * @returns string[] - Array of available language names
+     * Get available languages
      */
     getAvailableLanguages() {
         return Object.keys(this.availableLanguages);
@@ -671,17 +707,37 @@ export class AllProfanity {
         };
     }
     /**
-     * Update configuration
+     * Rebuilds the profanity trie from loaded language 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.
      */
     updateConfig(options) {
+        let rebuildNeeded = false;
         if (options.defaultPlaceholder !== undefined) {
             this.setPlaceholder(options.defaultPlaceholder);
         }
         if (options.enableLeetSpeak !== undefined) {
             this.enableLeetSpeak = options.enableLeetSpeak;
         }
-        if (options.caseSensitive !== undefined) {
+        if (options.caseSensitive !== undefined &&
+            options.caseSensitive !== this.caseSensitive) {
             this.caseSensitive = options.caseSensitive;
+            rebuildNeeded = true;
         }
         if (options.strictMode !== undefined) {
             this.strictMode = options.strictMode;
@@ -692,9 +748,12 @@ export class AllProfanity {
         if (options.whitelistWords) {
             this.addToWhitelist(options.whitelistWords);
         }
+        if (rebuildNeeded) {
+            this.rebuildTrie();
+        }
     }
 }
-// Create and export a singleton instance with default settings
+// Create and export a singleton instance
 const allProfanity = new AllProfanity();
 export default allProfanity;
 //# sourceMappingURL=index.js.map