allprofanity 2.2.1 → 2.3.0

package/dist/index.js

@@ -118,6 +118,8 @@ class SilentLogger {
  */
 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 */
@@ -127,6 +129,99 @@ export var ProfanitySeverity;
     /** Extreme profanity: 4+ unique words or 5+ total matches */
     ProfanitySeverity[ProfanitySeverity["EXTREME"] = 4] = "EXTREME";
 })(ProfanitySeverity = ProfanitySeverity || (ProfanitySeverity = {}));
+/**
+ * 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.
  *
@@ -168,13 +263,19 @@ function validateString(input, paramName) {
  * // 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;
@@ -321,26 +422,42 @@ 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;
     }
+    /**
+     * 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.
      *
@@ -501,7 +618,7 @@ export class AllProfanity {
      * @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();
@@ -510,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 || [],
@@ -547,7 +669,6 @@ export class AllProfanity {
             ["¿", "j"],
             ["|<", "k"],
             ["1<", "k"],
-            ["7", "l"],
             ["|\\/|", "m"],
             ["/\\/\\", "m"],
             ["|\\|", "n"],
@@ -561,13 +682,11 @@ export class AllProfanity {
             ["12", "r"],
             ["5", "s"],
             ["$", "s"],
-            ["z", "s"],
             ["7", "t"],
             ["+", "t"],
             ["†", "t"],
             ["|_|", "u"],
             ["(_)", "u"],
-            ["v", "u"],
             ["\\/", "v"],
             ["|/", "v"],
             ["\\/\\/", "w"],
@@ -575,7 +694,6 @@ export class AllProfanity {
             ["><", "x"],
             ["}{", "x"],
             ["`/", "y"],
-            ["j", "y"],
             ["2", "z"],
             ["7_", "z"],
         ]);
@@ -584,8 +702,11 @@ export class AllProfanity {
         this.ahoCorasickAutomaton = null;
         this.bloomFilter = null;
         this.contextAnalyzer = null;
+        this.contextScoreThreshold = 0.5;
         this.matchingAlgorithm = "trie";
         this.resultCache = null;
+        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) {
@@ -595,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);
         }
@@ -603,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) {
@@ -611,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;
@@ -649,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;
     }
     /**
-     * Escape regex special characters in a string.
-     * @param str - The string to escape.
-     * @returns The escaped string.
+     * 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.
      */
-    escapeRegex(str) {
-        return str.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+    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;
+    }
+    /**
+     * 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.
+     */
+    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).
@@ -726,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.
@@ -750,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,
                 });
             }
@@ -777,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.
+     */
+    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) {
+    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;
     }
     /**
@@ -811,6 +1307,14 @@ export class AllProfanity {
             return analysis.score >= scoreThreshold;
         });
     }
+    /**
+     * Drop all cached detection results. Must be called whenever the word lists
+     * or any option that affects detection output changes.
+     */
+    invalidateCache() {
+        var _a;
+        (_a = this.resultCache) === null || _a === void 0 ? void 0 : _a.clear();
+    }
     /**
      * Detects profanity in the provided text and returns comprehensive analysis.
      *
@@ -864,61 +1368,57 @@ export class AllProfanity {
      * @see {@link ProfanitySeverity} for severity levels
      */
     detect(text) {
-        var _a;
         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);
@@ -935,16 +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;
-                if (firstKey !== undefined) {
-                    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;
     }
@@ -954,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;
@@ -968,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,
@@ -1027,7 +1531,78 @@ export class AllProfanity {
      * @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;
+    }
+    /**
+     * 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.
@@ -1087,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 +
@@ -1211,11 +1787,12 @@ export class AllProfanity {
      */
     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();
     }
     /**
      * Dynamically removes one or more words from the profanity filter at runtime.
@@ -1264,35 +1841,42 @@ export class AllProfanity {
      * @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.
@@ -1381,6 +1965,7 @@ export class AllProfanity {
                 }
             }
             this.loadedLanguages.add(langKey);
+            this.invalidateCache();
             this.logger.info(`Loaded ${addedCount} words from ${language} dictionary`);
             return true;
         }
@@ -1395,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);
@@ -1470,7 +2055,7 @@ export class AllProfanity {
      */
     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;
@@ -1484,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) {
@@ -1507,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) {
@@ -1524,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)
@@ -1539,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.
@@ -1553,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.
@@ -1584,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) {
@@ -1597,6 +2200,7 @@ export class AllProfanity {
         for (const word of this.dynamicWords) {
             this.addWordToTrie(word);
         }
+        this.invalidateCache();
     }
     /**
      * Update configuration options for the profanity filter.
@@ -1625,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.
@@ -1643,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;
@@ -1675,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