allprofanity 1.1.0 → 2.1.0

package/dist/index.js

@@ -1,4 +1,5 @@
-import leoProfanity from "leo-profanity";
+// 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";
 import germanBadWords from "./languages/german-words.js";
@@ -7,6 +8,7 @@ import bengaliBadWords from "./languages/bengali-words.js";
 import tamilBadWords from "./languages/tamil-words.js";
 import teluguBadWords from "./languages/telugu-words.js";
 // Export language dictionaries for direct access
+export { default as englishBadWords } from "./languages/english-words.js";
 export { default as hindiBadWords } from "./languages/hindi-words.js";
 export { default as frenchBadWords } from "./languages/french-words.js";
 export { default as germanBadWords } from "./languages/german-words.js";
@@ -15,239 +17,743 @@ 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";
 /**
- * AllProfanity - Extended profanity filter with multi-language support
- * Based on leo-profanity with additional language capabilities
+ * Default console logger implementation
  */
-export class AllProfanity {
+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
+ */
+export var ProfanitySeverity;
+(function (ProfanitySeverity) {
+    ProfanitySeverity[ProfanitySeverity["MILD"] = 1] = "MILD";
+    ProfanitySeverity[ProfanitySeverity["MODERATE"] = 2] = "MODERATE";
+    ProfanitySeverity[ProfanitySeverity["SEVERE"] = 3] = "SEVERE";
+    ProfanitySeverity[ProfanitySeverity["EXTREME"] = 4] = "EXTREME";
+})(ProfanitySeverity = ProfanitySeverity || (ProfanitySeverity = {}));
+/**
+ * Validates input parameters
+ */
+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) {
-        this.defaultPlaceholder = "*";
+        var _a, _b, _c, _d, _e;
+        this.profanityTrie = new TrieNode();
+        this.whitelistSet = new Set();
         this.loadedLanguages = new Set();
+        // Configuration
+        this.defaultPlaceholder = "*";
+        this.enableLeetSpeak = true;
+        this.caseSensitive = false;
+        this.strictMode = false;
+        this.detectPartialWords = false;
+        // Available language dictionaries
         this.availableLanguages = {
-            hindi: hindiBadWords,
-            french: frenchBadWords,
-            german: germanBadWords,
-            spanish: spanishBadWords,
-            bengali: bengaliBadWords,
-            tamil: tamilBadWords,
-            telugu: teluguBadWords,
-            // Add more built-in languages here in the future
+            english: englishBadWords || [],
+            hindi: hindiBadWords || [],
+            french: frenchBadWords || [],
+            german: germanBadWords || [],
+            spanish: spanishBadWords || [],
+            bengali: bengaliBadWords || [],
+            tamil: tamilBadWords || [],
+            telugu: teluguBadWords || [],
         };
-        this.filter = leoProfanity;
-        // Set custom placeholder if provided
-        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);
         }
-        // Load the default English dictionary from leo-profanity
-        this.loadedLanguages.add("english");
-        // Load Hindi by default for backward compatibility
+        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 : false;
+        // Load whitelist
+        if (options === null || options === void 0 ? void 0 : options.whitelistWords) {
+            this.addToWhitelist(options.whitelistWords);
+        }
+        // Load default languages
+        this.loadLanguage("english");
         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.
+     */
+    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);
+        }
+        return normalized;
+    }
+    /**
+     * Properly escape regex special characters
+     */
+    escapeRegex(str) {
+        return str.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+    }
+    /**
+     * 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] : " ";
+        const wordBoundaryRegex = /[\s\p{P}\p{S}]/u;
+        return (wordBoundaryRegex.test(beforeChar) && wordBoundaryRegex.test(afterChar));
+    }
+    /**
+     * Helper method to verify whole-word matching.
+     */
+    isWholeWord(text, start, end) {
+        // Check left boundary
+        if (start === 0) {
+            // ok
+        }
+        else if (/\w/.test(text[start - 1])) {
+            return false;
+        }
+        // Check right boundary
+        if (end === text.length) {
+            // ok
+        }
+        else if (/\w/.test(text[end])) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Check if a match is whitelisted (by actual matched substring and dictionary word)
+     */
+    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 overlapping matches, keep only the longest at each start position
+     */
+    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 using efficient trie-based algorithm
+     */
+    detect(text) {
+        const validatedText = validateString(text, "text");
+        if (validatedText.length === 0) {
+            return {
+                hasProfanity: false,
+                detectedWords: [],
+                cleanedText: validatedText,
+                severity: ProfanitySeverity.MILD,
+                positions: [],
+            };
+        }
+        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);
+            }
+        }
+        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;
+                }
+                // Use actual matched text for whitelist check
+                const matchedText = originalText.substring(start, end);
+                if (this.isWhitelistedMatch(match.word, matchedText)) {
+                    continue;
+                }
+                if (this.hasWordBoundaries(originalText, start, end)) {
+                    matches.push({
+                        word: match.word,
+                        start,
+                        end,
+                        originalWord: matchedText,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * 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);
+        }
+        return result;
+    }
+    /**
+     * Simple boolean check for profanity
+     */
+    check(text) {
+        return this.detect(text).hasProfanity;
+    }
+    /**
+     * Clean text with custom placeholder
+     */
+    clean(text, placeholder) {
+        const detection = this.detect(text);
+        if (!placeholder || placeholder === this.defaultPlaceholder) {
+            return detection.cleanedText;
+        }
+        // Use custom placeholder
+        let result = text;
+        const sortedPositions = [
+            ...this.deduplicateMatches(detection.positions.map((p) => ({
+                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 = text.substring(pos.start, pos.end);
+            const replacement = placeholder.repeat(originalWord.length);
+            result =
+                result.substring(0, pos.start) +
+                    replacement +
+                    result.substring(pos.end);
+        }
+        return result;
+    }
+    /**
+     * Clean text by replacing each profane word with a single placeholder (word-level)
+     */
+    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
+     */
+    add(word) {
+        const words = Array.isArray(word) ? word : [word];
+        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
+     */
+    remove(word) {
+        const words = Array.isArray(word) ? word : [word];
+        const validatedWords = validateStringArray(words, "words to remove");
+        for (const w of validatedWords) {
+            const normalizedWord = this.caseSensitive ? w : w.toLowerCase();
+            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
-     * @param language - The language to load
-     * @returns boolean - True if loaded successfully, false otherwise
      */
     loadLanguage(language) {
-        // Skip if already loaded
-        if (this.loadedLanguages.has(language.toLowerCase())) {
+        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 langKey = language.toLowerCase();
-        if (this.availableLanguages[langKey]) {
-            this.filter.add(this.availableLanguages[langKey]);
+        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);
-            console.log(`AllProfanity: Added ${this.availableLanguages[langKey].length} ${language} words to the profanity list.`);
+            this.logger.info(`Loaded ${addedCount} words from ${language} dictionary`);
             return true;
         }
-        else {
-            console.warn(`AllProfanity: Language '${language}' not found in available dictionaries.`);
+        catch (error) {
+            this.logger.error(`Failed to load language ${language}: ${error}`);
             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;
+        const validatedLanguages = validateStringArray(languages, "languages");
+        return validatedLanguages.reduce((count, lang) => {
+            return this.loadLanguage(lang) ? count + 1 : count;
+        }, 0);
     }
     /**
-     * Load all Indian languages at once
-     * @returns number - Number of Indian languages loaded
+     * Load all Indian languages
      */
     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
+     * Load a custom dictionary
      */
     loadCustomDictionary(name, words) {
-        if (!words || words.length === 0) {
-            console.warn(`AllProfanity: Custom dictionary '${name}' has no 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;
         }
-        // Add to available languages for future reference
-        this.availableLanguages[name.toLowerCase()] = words;
-        // Add to filter
-        this.filter.add(words);
-        this.loadedLanguages.add(name.toLowerCase());
-        console.log(`AllProfanity: Added ${words.length} words from custom '${name}' dictionary.`);
+        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}`);
+        }
     }
     /**
-     * Get the list of currently loaded languages
-     * @returns string[] - Array of loaded language names
+     * Add a single word to the trie structure
      */
-    getLoadedLanguages() {
-        return Array.from(this.loadedLanguages);
+    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;
     }
     /**
-     * Get the list of available language dictionaries
-     * @returns string[] - Array of available language names
+     * Remove overlapping matches, keep only the longest at each start position
      */
-    getAvailableLanguages() {
-        return Object.keys(this.availableLanguages);
+    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;
     }
     /**
-     * Check if a string contains profanity
-     * @param string - The string to check
-     * @returns boolean - True if profanity found, false otherwise
-     */
-    check(string) {
-        return this.filter.check(string);
-    }
-    /**
-     * Clean a string by replacing profanities with placeholders
-     * @param string - The string to clean
-     * @param placeholder - Optional custom placeholder (defaults to '*')
-     * @returns string - The cleaned string
-     */
-    clean(string, placeholder) {
-        // More general solution for handling variations like "fucking"
-        const badWords = this.list();
-        let result = string;
-        for (const word of badWords) {
-            // Check for variations with "ing", "ed", etc.
-            const variations = [
-                `${word}ing`,
-                `${word}ed`,
-                `${word}s`,
-                `${word}er`,
-                `${word}ers`,
-            ];
-            for (const variation of variations) {
-                if (result.toLowerCase().includes(variation.toLowerCase())) {
-                    const prefix = word;
-                    const suffix = variation.slice(word.length);
-                    const replacement = (placeholder || this.defaultPlaceholder).repeat(prefix.length) +
-                        suffix;
-                    // Use regex to replace while preserving case (though this simplifies it)
-                    const regex = new RegExp(variation, "gi");
-                    result = result.replace(regex, replacement);
-                }
-            }
+     * Clear all loaded dictionaries
+     */
+    clearList() {
+        this.profanityTrie.clear();
+        this.loadedLanguages.clear();
+        this.dynamicWords.clear();
+    }
+    /**
+     * Set placeholder character
+     */
+    setPlaceholder(placeholder) {
+        validateString(placeholder, "placeholder");
+        if (placeholder.length === 0) {
+            throw new Error("Placeholder cannot be empty");
         }
-        // Fall back to default leo-profanity implementation
-        return this.filter.clean(result, placeholder || this.defaultPlaceholder);
-    }
-    /**
-     * 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 = "***") {
-        // Split by spaces but preserve punctuation
-        const regex = /([^\w\s])/g;
-        let tempString = string.replace(regex, " $1 ");
-        const words = tempString.split(" ").filter((w) => w !== "");
-        const result = words.map((word) => {
-            // Check if this word contains profanity, ignoring punctuation for the check
-            const wordWithoutPunctuation = word.replace(/[^\w\s]/g, "");
-            if (wordWithoutPunctuation && this.check(wordWithoutPunctuation)) {
-                return placeholder;
-            }
-            return word;
-        });
-        // Join and fix spaces before punctuation
-        let cleaned = result.join(" ");
-        cleaned = cleaned.replace(/ ([^\w\s]) /g, "$1 "); // Fix space before punctuation
-        cleaned = cleaned.replace(/ ([^\w\s])$/g, "$1"); // Fix trailing punctuation
-        return cleaned;
+        this.defaultPlaceholder = placeholder.charAt(0);
     }
     /**
-     * Get the current list of profanity words
-     * @returns string[] - Array of all profanity words
+     * Get loaded languages
      */
-    list() {
-        return this.filter.list();
+    getLoadedLanguages() {
+        return Array.from(this.loadedLanguages);
     }
     /**
-     * Add word(s) to the profanity list
-     * @param word - String or array of strings to add
+     * Get available languages
      */
-    add(word) {
-        this.filter.add(word);
+    getAvailableLanguages() {
+        return Object.keys(this.availableLanguages);
     }
     /**
-     * Remove word(s) from the profanity list
-     * @param word - String or array of strings to remove
+     * Get current configuration
      */
-    remove(word) {
-        this.filter.remove(word);
+    getConfig() {
+        return {
+            defaultPlaceholder: this.defaultPlaceholder,
+            enableLeetSpeak: this.enableLeetSpeak,
+            caseSensitive: this.caseSensitive,
+            strictMode: this.strictMode,
+            detectPartialWords: this.detectPartialWords,
+            languages: this.getLoadedLanguages(),
+            whitelistWords: Array.from(this.whitelistSet),
+        };
     }
     /**
-     * Clear the filter list and reset to default
+     * Rebuilds the profanity trie from loaded language dictionaries and dynamic words.
      */
-    clearList() {
-        // Get all current words
-        const currentWords = this.filter.list();
-        // Remove all words
-        if (currentWords.length > 0) {
-            this.filter.remove(currentWords);
+    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);
         }
-        // Reset loaded languages tracking
-        this.loadedLanguages.clear();
-        this.loadedLanguages.add("english"); // Default language remains
     }
     /**
-     * Change the character used as placeholder
-     * @param placeholder - Single character to use as placeholder
+     * Update configuration. Rebuild trie if needed.
      */
-    setPlaceholder(placeholder) {
-        if (placeholder.length !== 1) {
-            console.warn("AllProfanity: Placeholder should be a single character. Using first character.");
-            this.defaultPlaceholder = placeholder.charAt(0);
+    updateConfig(options) {
+        let rebuildNeeded = false;
+        if (options.defaultPlaceholder !== undefined) {
+            this.setPlaceholder(options.defaultPlaceholder);
         }
-        else {
-            this.defaultPlaceholder = placeholder;
+        if (options.enableLeetSpeak !== undefined) {
+            this.enableLeetSpeak = options.enableLeetSpeak;
+        }
+        if (options.caseSensitive !== undefined &&
+            options.caseSensitive !== this.caseSensitive) {
+            this.caseSensitive = options.caseSensitive;
+            rebuildNeeded = true;
+        }
+        if (options.strictMode !== undefined) {
+            this.strictMode = options.strictMode;
+        }
+        if (options.detectPartialWords !== undefined) {
+            this.detectPartialWords = options.detectPartialWords;
+        }
+        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