better-profane-words 1.0.0

package/LICENSE.md

@@ -0,0 +1,13 @@
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                    Version 2, December 2004
+
+ Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+ Everyone is permitted to copy and distribute verbatim or modified
+ copies of this license document, and changing it is allowed as long
+ as the name is changed.
+
+            DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. You just DO WHAT THE FUCK YOU WANT TO.

package/README.md

@@ -0,0 +1,105 @@
+# profane-words-classified
+
+A comprehensive list of 2700+ profane words with **category** and **intensity** classifications, ready for content moderation and filtering.
+
+Built on top of [profane-words](https://github.com/zautumnz/profane-words).
+
+## Install
+
+```bash
+npm install profane-words-classified
+```
+
+## Usage
+
+```js
+const profanity = require('profane-words-classified');
+```
+
+### Check if a word is profane
+
+```js
+profanity.isProfane('fuck');        // true
+profanity.isProfane('hello');       // false
+```
+
+### Look up a word
+
+```js
+profanity.lookup('shit');
+// { word: 'shit', categories: ['bodily'], intensity: 3 }
+
+profanity.lookup('ni**er');
+// { word: 'ni**er', categories: ['slur_racial'], intensity: 5 }
+// i censored this to avoid getting cancelled
+```
+
+### Filter text
+
+```js
+profanity.filterText('what the fuck is this shit');
+// { clean: 'what the *** is this ***', matched: [...] }
+
+profanity.filterText('holy damn', { replacement: '[censored]', minIntensity: 2 });
+// { clean: 'holy [censored]', matched: [...] }
+```
+
+### Check if text contains profanity
+
+```js
+profanity.containsProfanity('this is fine');         // false
+profanity.containsProfanity('what the hell');        // true
+
+profanity.containsProfanity('damn it', { minIntensity: 3 });  // false (damn = intensity 1)
+```
+
+### Get words by category
+
+```js
+profanity.getByCategory('slur_racial');   // all racial slurs
+profanity.getByCategory('drug');          // all drug references
+```
+
+### Get words by intensity
+
+```js
+profanity.getByIntensity(5);       // intensity exactly 5
+profanity.getByIntensity(3, 5);    // intensity 3 through 5
+```
+
+### Get all categories
+
+```js
+profanity.getCategories();
+// ['bodily', 'drug', 'hateful_ideology', 'insult', 'religious', 'sexual', 'slur_gender', 'slur_racial', 'violence']
+```
+
+## Categories
+
+| Category | Description |
+|---|---|
+| `sexual` | Sex acts, sexual anatomy, pornography |
+| `bodily` | Bodily functions and anatomy |
+| `insult` | General insults and name-calling |
+| `slur_racial` | Racial and ethnic slurs |
+| `slur_gender` | Homophobic, transphobic, and sexist slurs |
+| `religious` | Religious profanity |
+| `hateful_ideology` | Nazi, KKK, white supremacy references |
+| `drug` | Drug references |
+| `violence` | Violence and harm references |
+
+Words can belong to multiple categories.
+
+## Intensity Scale
+
+| Level | Description | Examples |
+|---|---|---|
+| 1 | Mild | crap, damn, ass |
+| 2 | Moderate | bastard, piss, douche |
+| 3 | Strong | fuck, shit, bitch, cock |
+| 4 | Very strong | cunt, motherfucker, rape |
+| 5 | Extremely offensive | Slurs, CSAM references |
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,40 @@
+export interface WordEntry {
+  word: string;
+  categories: Category[];
+  intensity: Intensity;
+}
+
+export type Category =
+  | 'sexual'
+  | 'bodily'
+  | 'insult'
+  | 'slur_racial'
+  | 'slur_gender'
+  | 'religious'
+  | 'hateful_ideology'
+  | 'drug'
+  | 'violence';
+
+export type Intensity = 1 | 2 | 3 | 4 | 5;
+
+export interface FilterOptions {
+  replacement?: string;
+  minIntensity?: Intensity;
+  categories?: Category[];
+}
+
+export interface FilterResult {
+  clean: string;
+  matched: WordEntry[];
+}
+
+export declare function isProfane(word: string): boolean;
+export declare function lookup(word: string): WordEntry | null;
+export declare function getByCategory(category: Category): WordEntry[];
+export declare function getByIntensity(min: Intensity, max?: Intensity): WordEntry[];
+export declare function getByIntensityAndCategory(intensity: Intensity, category: Category): WordEntry[];
+export declare function filterText(text: string, options?: FilterOptions): FilterResult;
+export declare function containsProfanity(text: string, options?: FilterOptions): boolean;
+export declare function getCategories(): Category[];
+export declare function getAll(): WordEntry[];
+export declare const words: WordEntry[];

package/index.js

@@ -0,0 +1,84 @@
+'use strict';
+
+const words = require('./words.json');
+
+const _byWord = new Map(words.map(e => [e.word, e]));
+
+function isProfane(word) {
+  return _byWord.has(word.toLowerCase());
+}
+
+function lookup(word) {
+  return _byWord.get(word.toLowerCase()) || null;
+}
+
+function getByCategory(category) {
+  return words.filter(e => e.categories.includes(category));
+}
+
+function getByIntensity(min, max) {
+  if (max === undefined) max = min;
+  return words.filter(e => e.intensity >= min && e.intensity <= max);
+}
+
+function getByIntensityAndCategory(intensity, category) {
+  return words.filter(e => e.intensity === intensity && e.categories.includes(category));
+}
+
+function filterText(text, options = {}) {
+  const { replacement = '***', minIntensity = 1, categories = null } = options;
+  let result = text;
+  const matched = [];
+
+  const sorted = [...words].sort((a, b) => b.word.length - a.word.length);
+
+  for (const entry of sorted) {
+    if (entry.intensity < minIntensity) continue;
+    if (categories && !categories.some(c => entry.categories.includes(c))) continue;
+
+    const escaped = entry.word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`\\b${escaped}\\b`, 'gi');
+    if (regex.test(result)) {
+      matched.push(entry);
+      result = result.replace(regex, replacement);
+    }
+  }
+
+  return { clean: result, matched };
+}
+
+function containsProfanity(text, options = {}) {
+  const { minIntensity = 1, categories = null } = options;
+  const lower = text.toLowerCase();
+  return words.some(entry => {
+    if (entry.intensity < minIntensity) return false;
+    if (categories && !categories.some(c => entry.categories.includes(c))) return false;
+    const escaped = entry.word.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`\\b${escaped}\\b`, 'i').test(lower);
+  });
+}
+
+function getCategories() {
+  const cats = new Set();
+  for (const entry of words) {
+    for (const c of entry.categories) cats.add(c);
+  }
+  return [...cats].sort();
+}
+
+function getAll() {
+  return words;
+}
+
+module.exports = {
+  isProfane,
+  lookup,
+  getByCategory,
+  getByIntensity,
+  getByIntensityAndCategory,
+  filterText,
+  containsProfanity,
+  getCategories,
+  getAll,
+  words,
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "better-profane-words",
+  "version": "1.0.0",
+  "description": "A comprehensive list of profane words with category and intensity classifications",
+  "main": "index.js",
+  "type": "module",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "words.json",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "keywords": [
+    "profanity",
+    "profane",
+    "filter",
+    "words",
+    "classification",
+    "moderation",
+    "content-filter"
+  ],
+  "author": "awdev1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/awdev1/better-profane-words"
+  },
+  "dependencies": {
+    "better-profane-words": "^1.0.0"
+  }
+}