bekindprofanityfilter 0.0.5 → 0.0.6

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "bekindprofanityfilter",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "A multi-language profanity filter with romanization detection, language-aware innocence scoring, leet-speak detection, and cross-language collision handling. Forked from AllProfanity.",
   "main": "dist/cjs/index.js",
-  "module": "dist/esm/index.js",
+  "module": "dist/esm.min.js",
   "types": "dist/esm/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
       "import": {
         "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
+        "default": "./dist/esm.min.js"
       },
       "require": {
         "types": "./dist/esm/index.d.ts",
@@ -19,7 +19,7 @@
     }
   },
   "scripts": {
-    "build": "tsc && esbuild dist/esm/index.js --bundle --minify --platform=node --format=cjs --outfile=dist/cjs/index.js --packages=bundle && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
+    "build": "tsc && esbuild dist/esm/index.js --bundle --minify --platform=node --format=esm --outfile=dist/esm.min.js --packages=bundle && esbuild dist/esm/index.js --bundle --minify --platform=node --format=cjs --outfile=dist/cjs/index.js --packages=bundle && echo '{\"type\":\"commonjs\"}' > dist/cjs/package.json",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
@@ -75,9 +75,8 @@
     "typescript": "^4.0.0"
   },
   "files": [
-    "dist/esm/**/*.js",
+    "dist/esm.min.js",
     "dist/esm/**/*.d.ts",
-    "!dist/esm/languages/*-words.js",
     "!dist/esm/languages/*-words.d.ts",
     "dist/cjs/index.js",
     "dist/cjs/package.json",

package/dist/esm/algos/aho-corasick.js

@@ -1,238 +0,0 @@
-/**
- * Aho-Corasick algorithm implementation for efficient multi-pattern string matching
- */
-export class AhoCorasick {
-    constructor(patterns = []) {
-        this.compiled = false;
-        this.patterns = [...patterns];
-        this.root = this.createNode();
-        if (patterns.length > 0) {
-            this.buildAutomaton();
-        }
-    }
-    /**
-     * Create a new trie node
-     */
-    createNode() {
-        return {
-            children: new Map(),
-            output: [],
-            outputIndices: [],
-            failure: null,
-            isEndOfPattern: false,
-        };
-    }
-    /**
-     * Add patterns to the automaton
-     */
-    addPatterns(patterns) {
-        this.patterns.push(...patterns);
-        this.compiled = false;
-    }
-    /**
-     * Add a single pattern to the automaton
-     */
-    addPattern(pattern) {
-        if (pattern && pattern.length > 0) {
-            this.patterns.push(pattern);
-            this.compiled = false;
-        }
-    }
-    /**
-     * Build the Aho-Corasick automaton
-     */
-    buildAutomaton() {
-        this.buildTrie();
-        this.buildFailureLinks();
-        this.buildOutputLinks();
-        this.compiled = true;
-    }
-    /**
-     * Build the trie structure
-     */
-    buildTrie() {
-        this.root = this.createNode();
-        for (let i = 0; i < this.patterns.length; i++) {
-            const pattern = this.patterns[i];
-            let current = this.root;
-            for (const char of pattern) {
-                if (!current.children.has(char)) {
-                    current.children.set(char, this.createNode());
-                }
-                current = current.children.get(char);
-            }
-            current.isEndOfPattern = true;
-            current.output.push(pattern);
-            current.outputIndices.push(i);
-        }
-    }
-    /**
-     * Build failure links using BFS
-     */
-    buildFailureLinks() {
-        const queue = [];
-        // Initialize failure links for depth 1 nodes
-        for (const child of this.root.children.values()) {
-            child.failure = this.root;
-            queue.push(child);
-        }
-        // Build failure links for deeper nodes
-        while (queue.length > 0) {
-            const current = queue.shift();
-            for (const [char, child] of current.children) {
-                queue.push(child);
-                let failure = current.failure;
-                while (failure !== null && !failure.children.has(char)) {
-                    failure = failure.failure;
-                }
-                child.failure = failure ? failure.children.get(char) : this.root;
-            }
-        }
-    }
-    /**
-     * Build output links for failure transitions
-     */
-    buildOutputLinks() {
-        const queue = [];
-        for (const child of this.root.children.values()) {
-            queue.push(child);
-        }
-        while (queue.length > 0) {
-            const current = queue.shift();
-            // Add failure node outputs to current node
-            if (current.failure && current.failure.output.length > 0) {
-                current.output.push(...current.failure.output);
-                current.outputIndices.push(...current.failure.outputIndices);
-            }
-            for (const child of current.children.values()) {
-                queue.push(child);
-            }
-        }
-    }
-    /**
-     * Find all pattern matches in the given text
-     */
-    findAll(text) {
-        if (!this.compiled) {
-            this.buildAutomaton();
-        }
-        const matches = [];
-        let current = this.root;
-        for (let i = 0; i < text.length; i++) {
-            const char = text[i];
-            // Follow failure links until we find a transition or reach root
-            while (current !== this.root && !current.children.has(char)) {
-                current = current.failure;
-            }
-            // Transition to next state if possible
-            if (current.children.has(char)) {
-                current = current.children.get(char);
-            }
-            // Report all patterns that end at this position
-            for (let j = 0; j < current.output.length; j++) {
-                const pattern = current.output[j];
-                const patternIndex = current.outputIndices[j];
-                const start = i - pattern.length + 1;
-                matches.push({
-                    pattern,
-                    start,
-                    end: i + 1,
-                    patternIndex,
-                });
-            }
-        }
-        return matches;
-    }
-    /**
-     * Check if text contains any patterns
-     */
-    hasMatch(text) {
-        if (!this.compiled) {
-            this.buildAutomaton();
-        }
-        let current = this.root;
-        for (let i = 0; i < text.length; i++) {
-            const char = text[i];
-            while (current !== this.root && !current.children.has(char)) {
-                current = current.failure;
-            }
-            if (current.children.has(char)) {
-                current = current.children.get(char);
-            }
-            if (current.output.length > 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Find first match in text
-     */
-    findFirst(text) {
-        if (!this.compiled) {
-            this.buildAutomaton();
-        }
-        let current = this.root;
-        for (let i = 0; i < text.length; i++) {
-            const char = text[i];
-            while (current !== this.root && !current.children.has(char)) {
-                current = current.failure;
-            }
-            if (current.children.has(char)) {
-                current = current.children.get(char);
-            }
-            if (current.output.length > 0) {
-                const pattern = current.output[0];
-                const patternIndex = current.outputIndices[0];
-                const start = i - pattern.length + 1;
-                return {
-                    pattern,
-                    start,
-                    end: i + 1,
-                    patternIndex,
-                };
-            }
-        }
-        return null;
-    }
-    /**
-     * Get the patterns stored in this automaton
-     */
-    getPatterns() {
-        return [...this.patterns];
-    }
-    /**
-     * Clear all patterns and reset the automaton
-     */
-    clear() {
-        this.patterns = [];
-        this.root = this.createNode();
-        this.compiled = false;
-    }
-    /**
-     * Get statistics about the automaton
-     */
-    getStats() {
-        const nodeCount = this.countNodes(this.root);
-        const averagePatternLength = this.patterns.length > 0
-            ? this.patterns.reduce((sum, p) => sum + p.length, 0) /
-                this.patterns.length
-            : 0;
-        return {
-            patternCount: this.patterns.length,
-            nodeCount,
-            averagePatternLength,
-        };
-    }
-    /**
-     * Count total nodes in the trie
-     */
-    countNodes(node) {
-        let count = 1;
-        for (const child of node.children.values()) {
-            count += this.countNodes(child);
-        }
-        return count;
-    }
-}
-//# sourceMappingURL=aho-corasick.js.map

package/dist/esm/algos/bloom-filter.js

@@ -1,208 +0,0 @@
-/**
- * Bloom Filter implementation for efficient set membership testing
- */
-export class BloomFilter {
-    constructor(expectedItems, falsePositiveRate = 0.01) {
-        this.itemCount = 0;
-        // Calculate optimal size and hash count
-        this.size = this.calculateOptimalSize(expectedItems, falsePositiveRate);
-        this.hashCount = this.calculateOptimalHashCount(this.size, expectedItems);
-        this.bitArray = new Uint8Array(Math.ceil(this.size / 8));
-    }
-    /**
-     * Calculate optimal bit array size
-     */
-    calculateOptimalSize(n, p) {
-        return Math.ceil((-n * Math.log(p)) / Math.log(2) ** 2);
-    }
-    /**
-     * Calculate optimal number of hash functions
-     */
-    calculateOptimalHashCount(m, n) {
-        return Math.ceil((m / n) * Math.log(2));
-    }
-    /**
-     * Hash function 1 (FNV-1a variant)
-     */
-    hash1(item) {
-        let hash = 2166136261;
-        for (let i = 0; i < item.length; i++) {
-            hash ^= item.charCodeAt(i);
-            hash *= 16777619;
-        }
-        return Math.abs(hash) % this.size;
-    }
-    /**
-     * Hash function 2 (djb2 variant)
-     */
-    hash2(item) {
-        let hash = 5381;
-        for (let i = 0; i < item.length; i++) {
-            hash = (hash << 5) + hash + item.charCodeAt(i);
-        }
-        return Math.abs(hash) % this.size;
-    }
-    /**
-     * Generate k hash values for an item using double hashing
-     */
-    getHashes(item) {
-        const hash1 = this.hash1(item);
-        const hash2 = this.hash2(item);
-        const hashes = [];
-        for (let i = 0; i < this.hashCount; i++) {
-            const hash = (hash1 + i * hash2) % this.size;
-            hashes.push(Math.abs(hash));
-        }
-        return hashes;
-    }
-    /**
-     * Set a bit in the bit array
-     */
-    setBit(index) {
-        const byteIndex = Math.floor(index / 8);
-        const bitIndex = index % 8;
-        this.bitArray[byteIndex] |= 1 << bitIndex;
-    }
-    /**
-     * Get a bit from the bit array
-     */
-    getBit(index) {
-        const byteIndex = Math.floor(index / 8);
-        const bitIndex = index % 8;
-        return (this.bitArray[byteIndex] & (1 << bitIndex)) !== 0;
-    }
-    /**
-     * Add an item to the bloom filter
-     */
-    add(item) {
-        const hashes = this.getHashes(item);
-        for (const hash of hashes) {
-            this.setBit(hash);
-        }
-        this.itemCount++;
-    }
-    /**
-     * Add multiple items to the bloom filter
-     */
-    addAll(items) {
-        for (const item of items) {
-            this.add(item);
-        }
-    }
-    /**
-     * Test if an item might be in the set
-     */
-    mightContain(item) {
-        const hashes = this.getHashes(item);
-        for (const hash of hashes) {
-            if (!this.getBit(hash)) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Test multiple items at once
-     */
-    mightContainAny(items) {
-        return items.some((item) => this.mightContain(item));
-    }
-    /**
-     * Filter items that might be in the set
-     */
-    filter(items) {
-        return items.filter((item) => this.mightContain(item));
-    }
-    /**
-     * Clear the bloom filter
-     */
-    clear() {
-        this.bitArray.fill(0);
-        this.itemCount = 0;
-    }
-    /**
-     * Get current false positive probability
-     */
-    getCurrentFalsePositiveRate() {
-        const ratio = this.itemCount / this.size;
-        return Math.pow(1 - Math.exp(-this.hashCount * ratio), this.hashCount);
-    }
-    /**
-     * Get bloom filter statistics
-     */
-    getStats() {
-        let bitsSet = 0;
-        for (let i = 0; i < this.size; i++) {
-            if (this.getBit(i)) {
-                bitsSet++;
-            }
-        }
-        const loadFactor = bitsSet / this.size;
-        const estimatedFalsePositiveRate = Math.pow(loadFactor, this.hashCount);
-        return {
-            size: this.size,
-            hashCount: this.hashCount,
-            itemCount: this.itemCount,
-            bitsSet,
-            loadFactor,
-            estimatedFalsePositiveRate,
-        };
-    }
-    /**
-     * Serialize bloom filter to JSON
-     */
-    toJSON() {
-        return {
-            size: this.size,
-            hashCount: this.hashCount,
-            itemCount: this.itemCount,
-            bitArray: Array.from(this.bitArray),
-        };
-    }
-    /**
-     * Deserialize bloom filter from JSON
-     */
-    static fromJSON(data) {
-        const filter = Object.create(BloomFilter.prototype);
-        filter.size = data.size;
-        filter.hashCount = data.hashCount;
-        filter.itemCount = data.itemCount;
-        filter.bitArray = new Uint8Array(data.bitArray);
-        return filter;
-    }
-    /**
-     * Union operation with another bloom filter
-     */
-    union(other) {
-        if (this.size !== other.size || this.hashCount !== other.hashCount) {
-            throw new Error("Bloom filters must have same size and hash count for union operation");
-        }
-        const result = new BloomFilter(1, 0.01);
-        result.size = this.size;
-        result.hashCount = this.hashCount;
-        result.bitArray = new Uint8Array(this.bitArray.length);
-        result.itemCount = this.itemCount + other.itemCount;
-        for (let i = 0; i < this.bitArray.length; i++) {
-            result.bitArray[i] = this.bitArray[i] | other.bitArray[i];
-        }
-        return result;
-    }
-    /**
-     * Intersection operation with another bloom filter
-     */
-    intersect(other) {
-        if (this.size !== other.size || this.hashCount !== other.hashCount) {
-            throw new Error("Bloom filters must have same size and hash count for intersection operation");
-        }
-        const result = new BloomFilter(1, 0.01);
-        result.size = this.size;
-        result.hashCount = this.hashCount;
-        result.bitArray = new Uint8Array(this.bitArray.length);
-        result.itemCount = Math.min(this.itemCount, other.itemCount);
-        for (let i = 0; i < this.bitArray.length; i++) {
-            result.bitArray[i] = this.bitArray[i] & other.bitArray[i];
-        }
-        return result;
-    }
-}
-//# sourceMappingURL=bloom-filter.js.map