glin-profanity 2.0.0 → 2.3.3

package/README.md

@@ -1,9 +1,122 @@
-
-# Glin Profanity
-Glin-Profanity is a lightweight and efficient npm package designed to detect and filter profane language in text inputs across multiple languages. Whether you’re building a chat application, a comment section, or any platform where user-generated content is involved, Glin-Profanity helps you maintain a clean and respectful environment.
+<p align="center">
+  <a href="https://www.glincker.com/tools/glin-profanity" target="_blank">
+    <img src="../../assets/glinr-logo.png" alt="Glin Profanity" width="40" /> 
+  </a>
+</p>
+
+<h1 align="center">GLIN PROFANITY</h1>
+
+<p align="center">
+  <strong>A multilingual profanity detection and filtering engine for modern applications — by <a href="https://glincker.com">GLINCKER</a></strong>
+</p>
+<p align="center">
+  <a href="https://www.glincker.com/tools/glin-profanity">
+    <img src="https://img.shields.io/badge/🚀%20Try%20Live%20Demo-online-blue" alt="Try Live Demo" />
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/glin-profanity">
+    <img src="https://img.shields.io/npm/v/glin-profanity" alt="NPM Version" />
+  </a>
+  <a href="https://github.com/GLINCKER/glin-profanity/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/license-MIT-green" alt="MIT License" />
+  </a>
+  <a href="https://github.com/GLINCKER/glin-profanity/actions">
+    <img src="https://img.shields.io/github/actions/workflow/status/GLINCKER/glin-profanity/ci.yml" alt="CI Status" />
+  </a>
+  <a href="https://www.npmjs.com/package/glin-profanity">
+    <img src="https://img.shields.io/npm/dw/glin-profanity" alt="Weekly Downloads" />
+  </a>
+  <a href="https://github.com/GLINCKER/glin-profanity/issues">
+    <img src="https://img.shields.io/github/issues/GLINCKER/glin-profanity" alt="Open Issues" />
+  </a>
+  <a href="https://github.com/GLINCKER/glin-profanity/pulls">
+    <img src="https://img.shields.io/github/issues-pr/GLINCKER/glin-profanity" alt="Open PRs" />
+  </a>
+  <a href="https://github.com/GLINCKER/glin-profanity/commits/main">
+    <img src="https://img.shields.io/github/last-commit/GLINCKER/glin-profanity" alt="Last Commit" />
+  </a>
+  <a href="https://github.com/GLINCKER/glin-profanity/stargazers">
+    <img src="https://img.shields.io/github/stars/GLINCKER/glin-profanity" alt="GitHub Stars" />
+  </a>
+  <a href="https://github.com/GLINCKER/glin-profanity/network/members">
+    <img src="https://img.shields.io/github/forks/GLINCKER/glin-profanity" alt="GitHub Forks" />
+  </a>
+  <a href="https://github.com/GLINCKER/glin-profanity/graphs/contributors">
+    <img src="https://img.shields.io/github/contributors/GLINCKER/glin-profanity" alt="Contributors" />
+  </a>
+  <a href="#-table-of-contents">
+    <img src="https://img.shields.io/badge/-Table%20of%20Contents-blue" alt="Table Of Contents" />
+  </a>
+</p>
+
+---
+
+
+> A multilingual profanity detection and filtering engine for modern applications — by [GLINCKER](https://glincker.com)
+ 
+[![Glin Profanity Preview](../../assets/glin-profanity-preview.png)](https://www.glincker.com/tools/glin-profanity)
+
+---
+
+## ✨ Overview
+
+**Glin-Profanity** is a high-performance JavaScript/TypeScript library built to detect, filter, and sanitize profane or harmful language in user-generated content. With support for over 20+ languages, configurable severity levels, obfuscation detection, and framework-agnostic design, it's perfect for developers who care about building safe, inclusive platforms.
+
+Whether you're moderating chat messages, community forums, or content input forms, Glin-Profanity empowers you to:
+
+- 🧼 Filter text with real-time or batch processing
+- 🗣️ Detect offensive terms in **20+ human languages**
+- 💬 Catch obfuscated profanity like `sh1t`, `f*ck`, `a$$hole`
+- 🎚️ Adjust severity thresholds (`Exact`, `Fuzzy`, `Merged`)
+- 🔁 Replace bad words with symbols or emojis
+- 🧩 Works in **any JavaScript environment** - <img src="https://img.shields.io/badge/Node.js-339933?style=flat&logo=nodedotjs&logoColor=white" alt="Node.js" height="16" /> <img src="https://img.shields.io/badge/React-20232A?style=flat&logo=react&logoColor=61DAFB" alt="React" height="16" /> <img src="https://img.shields.io/badge/Vue-35495E?style=flat&logo=vuedotjs&logoColor=4FC08D" alt="Vue" height="16" /> <img src="https://img.shields.io/badge/Angular-DD0031?style=flat&logo=angular&logoColor=white" alt="Angular" height="16" /> <img src="https://img.shields.io/badge/TypeScript-007ACC?style=flat&logo=typescript&logoColor=white" alt="TypeScript" height="16" />
+- 🛡️ Add custom word lists or ignore specific terms
+
+## 🚀 Key Features
+
+<div align="center">
+  <img src="https://img.shields.io/badge/Multi--Language-🌍-blue?style=for-the-badge" alt="Multi-Language" />
+  <img src="https://img.shields.io/badge/Real--Time-⚡-yellow?style=for-the-badge" alt="Real-Time" />
+  <img src="https://img.shields.io/badge/Obfuscation_Detection-🕵️-purple?style=for-the-badge" alt="Obfuscation" />
+  <img src="https://img.shields.io/badge/Framework_Agnostic-🧩-green?style=for-the-badge" alt="Framework Agnostic" />
+</div>
+
+## 📚 Table of Contents
+
+- [🚀 Key Features](#-key-features)
+- [📦 Installation](#installation)
+- [🌍 Supported Languages](#supported-languages)
+- [⚙️ Usage](#usage)
+  - [Basic Usage](#basic-usage)
+  - [Framework Examples](#framework-examples)
+- [🧠 API](#api)
+  - [Core Functions](#core-functions)
+  - [Filter Class](#filter-class)
+    - [Constructor](#constructor)
+    - [FilterConfig Options](#filterconfig-options)
+    - [Methods](#methods)
+      - [isProfane](#isprofane)
+      - [checkProfanity](#checkprofanity)
+  - [useProfanityChecker Hook](#useprofanitychecker-hook)
+    - [Parameters](#parameters)
+    - [Return Value](#return-value)
+- [⚠️ Note](#note)
+- [🛠 Use Cases](#-use-cases)
+- [📄 License](#license)
+  - [MIT License](#mit-license)
 
 ## Installation
 
+<div align="center">
+  <img src="https://img.shields.io/badge/npm-CB3837?style=for-the-badge&logo=npm&logoColor=white" alt="npm" />
+  <img src="https://img.shields.io/badge/Yarn-2C8EBB?style=for-the-badge&logo=yarn&logoColor=white" alt="yarn" />
+  <img src="https://img.shields.io/badge/pnpm-F69220?style=for-the-badge&logo=pnpm&logoColor=white" alt="pnpm" />
+</div>
+
+<br />
+
 To install Glin-Profanity, use npm:
 
 ```bash
@@ -14,91 +127,238 @@ OR
 ```bash
 yarn add glin-profanity
 ```
+OR
+
+```bash
+pnpm add glin-profanity
+```
+ 
+## Supported Languages
+
+Glin-Profanity includes comprehensive profanity dictionaries for **23 languages**:
+
+🇸🇦 **Arabic** • 🇨🇳 **Chinese** • 🇨🇿 **Czech** • 🇩🇰 **Danish** • 🇬🇧 **English** • 🌍 **Esperanto** • 🇫🇮 **Finnish** • 🇫🇷 **French** • 🇩🇪 **German** • 🇮🇳 **Hindi** • 🇭🇺 **Hungarian** • 🇮🇹 **Italian** • 🇯🇵 **Japanese** • 🇰🇷 **Korean** • 🇳🇴 **Norwegian** • 🇮🇷 **Persian** • 🇵🇱 **Polish** • 🇵🇹 **Portuguese** • 🇷🇺 **Russian** • 🇪🇸 **Spanish** • 🇸🇪 **Swedish** • 🇹🇭 **Thai** • 🇹🇷 **Turkish**
+
+> **Note**: The JavaScript and Python packages maintain cross-language parity, ensuring consistent profanity detection across both ecosystems.
+
 ## Usage
 
 ### Basic Usage
 
-Here's a simple example of how to use Glin-Profanity in a React application:
+Glin-Profanity now provides framework-agnostic core functions alongside React-specific hooks:
+
+#### 🟢 Node.js / Vanilla JavaScript
+
+```javascript
+const { checkProfanity } = require('glin-profanity');
+
+const text = "This is some bad text with damn words";
+const result = checkProfanity(text, {
+  languages: ['english', 'spanish'],
+  replaceWith: '***'
+});
+
+console.log(result.containsProfanity); // true
+console.log(result.profaneWords);      // ['damn']
+console.log(result.processedText);     // "This is some bad text with *** words"
+```
+
+#### 🔷 TypeScript
 
 ```typescript
-import React, { useState } from 'react';
-import { useProfanityChecker, Language } from 'glin-profanity';
+import { checkProfanity, ProfanityCheckerConfig } from 'glin-profanity';
 
-const App: React.FC = () => {
-  const [text, setText] = useState('');
-  const [checkAllLanguages, setCheckAllLanguages] = useState(false);
-  const { result, checkText } = useProfanityChecker(
-    checkAllLanguages ? { allLanguages: true } : { languages: ['english', 'french'] }
-  );
+const config: ProfanityCheckerConfig = {
+  languages: ['english', 'spanish'],
+  severityLevels: true,
+  autoReplace: true,
+  replaceWith: '🤬'
+};
+
+const result = checkProfanity("inappropriate text", config);
+```
 
-  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
-    setText(e.target.value);
-  };
+### Framework Examples
 
-  const handleCheck = () => {
-    checkText(text);
-  };
+<div align="center">
+  <img src="https://img.shields.io/badge/Node.js-339933?style=for-the-badge&logo=nodedotjs&logoColor=white" alt="Node.js" />
+  <img src="https://img.shields.io/badge/React-20232A?style=for-the-badge&logo=react&logoColor=61DAFB" alt="React" />
+  <img src="https://img.shields.io/badge/Vue.js-35495E?style=for-the-badge&logo=vuedotjs&logoColor=4FC08D" alt="Vue.js" />
+  <img src="https://img.shields.io/badge/Angular-DD0031?style=for-the-badge&logo=angular&logoColor=white" alt="Angular" />
+  <img src="https://img.shields.io/badge/TypeScript-007ACC?style=for-the-badge&logo=typescript&logoColor=white" alt="TypeScript" />
+</div>
+
+#### ⚛️ React
+
+```tsx
+import React, { useState } from 'react';
+import { useProfanityChecker, SeverityLevel } from 'glin-profanity';
+
+const App = () => {
+  const [text, setText] = useState('');
+  
+  const { result, checkText } = useProfanityChecker({
+    languages: ['english', 'spanish'],
+    severityLevels: true,
+    autoReplace: true,
+    replaceWith: '***',
+    minSeverity: SeverityLevel.EXACT
+  });
 
   return (
     <div>
-      <h1>Welcome to Glin-Profanity</h1>
-      <input type="text" value={text} onChange={handleChange} />
-      <button onClick={handleCheck}>Check Profanity</button>
-      <div>
-        <label>
-          <input
-            type="checkbox"
-            checked={checkAllLanguages}
-            onChange={(e) => setCheckAllLanguages(e.target.checked)}
-          />
-          Check All Languages
-        </label>
-      </div>
-      {result && (
-        <div>
-          <p>Contains Profanity: {result.containsProfanity ? 'Yes' : 'No'}</p>
-          {result.containsProfanity && (
-            <p>Profane Words: {result.profaneWords.join(', ')}</p>
-          )}
-        </div>
+      <input value={text} onChange={(e) => setText(e.target.value)} />
+      <button onClick={() => checkText(text)}>Scan</button>
+      
+      {result && result.containsProfanity && (
+        <p>Cleaned: {result.processedText}</p>
       )}
     </div>
   );
 };
+```
+
+#### 💚 Vue 3
+
+```vue
+<template>
+  <div>
+    <input v-model="text" @input="checkContent" />
+    <p v-if="hasProfanity">{{ cleanedText }}</p>
+  </div>
+</template>
+
+<script setup>
+import { ref } from 'vue';
+import { checkProfanity } from 'glin-profanity';
+
+const text = ref('');
+const hasProfanity = ref(false);
+const cleanedText = ref('');
+
+const checkContent = () => {
+  const result = checkProfanity(text.value, {
+    languages: ['english'],
+    autoReplace: true,
+    replaceWith: '***'
+  });
+  
+  hasProfanity.value = result.containsProfanity;
+  cleanedText.value = result.autoReplaced;
+};
+</script>
+```
+
+#### 🔴 Angular
+
+```typescript
+import { Component } from '@angular/core';
+import { checkProfanity, ProfanityCheckResult } from 'glin-profanity';
+
+@Component({
+  selector: 'app-comment',
+  template: `
+    <textarea [(ngModel)]="comment" (ngModelChange)="validateComment()"></textarea>
+    <div *ngIf="profanityResult?.containsProfanity" class="error">
+      Please remove inappropriate language
+    </div>
+  `
+})
+export class CommentComponent {
+  comment = '';
+  profanityResult: ProfanityCheckResult | null = null;
+
+  validateComment() {
+    this.profanityResult = checkProfanity(this.comment, {
+      languages: ['english', 'spanish'],
+      severityLevels: true
+    });
+  }
+}
+```
+
+#### 🚂 Express.js Middleware
+
+```javascript
+const express = require('express');
+const { checkProfanity } = require('glin-profanity');
+
+const profanityMiddleware = (req, res, next) => {
+  const result = checkProfanity(req.body.message || '', {
+    languages: ['english'],
+    autoReplace: true,
+    replaceWith: '[censored]'
+  });
+  
+  if (result.containsProfanity) {
+    req.body.message = result.autoReplaced;
+  }
+  
+  next();
+};
 
-export default App;
+app.post('/comment', profanityMiddleware, (req, res) => {
+  // Message is now sanitized
+  res.json({ message: req.body.message });
+});
 ```
 
 ## API
 
-### `Filter` Class
+### 🎯 Core Functions
+
+#### `checkProfanity`
+
+Framework-agnostic function for profanity detection.
+
+```typescript
+checkProfanity(text: string, config?: ProfanityCheckerConfig): ProfanityCheckResult
+```
+
+#### `checkProfanityAsync`
+
+Async version of checkProfanity.
+
+```typescript
+checkProfanityAsync(text: string, config?: ProfanityCheckerConfig): Promise<ProfanityCheckResult>
+```
+
+#### `isWordProfane`
+
+Quick check if a single word is profane.
+
+```typescript
+isWordProfane(word: string, config?: ProfanityCheckerConfig): boolean
+```
+
+### 🔧 `Filter` Class
 
 #### Constructor
 
 ```typescript
-new Filter(config?: { 
-  languages?: Language[]; 
-  allLanguages?: boolean;
-  caseSensitive?: boolean;
-  wordBoundaries?: boolean;
-  customWords?: string[];
-  replaceWith?: string;
-  severityLevels?: boolean; 
-  ignoreWords?: string[];
-  logProfanity?: boolean; 
-});
+new Filter(config?: FilterConfig);
 ```
 
-- `config`: An optional configuration object.
-  - `languages`: An array of languages to check for profanities.
-  - `allLanguages`: A boolean indicating whether to check for all languages.
-  - `caseSensitive`: A boolean indicating whether the profanity check should be case-sensitive.
-  - `wordBoundaries`: A boolean indicating whether to consider word boundaries when checking for profanities.
-  - `customWords`: An array of custom words to include in the profanity check.
-  - `replaceWith`: A string to replace profane words with.
-  - `severityLevels`: A boolean indicating whether to include severity levels for profane words. 
-  - `ignoreWords`: An array of words to ignore in the profanity check.
-  - `logProfanity`: A boolean indicating whether to log detected profane words. 
+#### FilterConfig Options:
+
+| Option                  | Type               | Description |
+|-------------------------|--------------------|-------------|
+| `languages`             | `Language[]`       | Languages to include (e.g., ['english', 'spanish']) |
+| `allLanguages`          | `boolean`          | If true, scan all available languages |
+| `caseSensitive`         | `boolean`          | Match case exactly |
+| `wordBoundaries`        | `boolean`          | Only match full words (turn off for substring matching) |
+| `customWords`           | `string[]`         | Add your own words |
+| `replaceWith`           | `string`           | Replace matched words with this string |
+| `severityLevels`        | `boolean`          | Enable severity mapping (Exact, Fuzzy, Merged) |
+| `ignoreWords`           | `string[]`         | Words to skip even if found |
+| `logProfanity`          | `boolean`          | Log results via console |
+| `allowObfuscatedMatch`  | `boolean`          | Enable fuzzy pattern matching like `f*ck` |
+| `fuzzyToleranceLevel`   | `number (0–1)`     | Adjust how tolerant fuzzy matching is |
+| `autoReplace`           | `boolean`          | Whether to auto-replace flagged words |
+| `minSeverity`           | `SeverityLevel`    | Minimum severity to include in final list |
+| `customActions`         | `(result) => void` | Custom logging/callback support |
+
+---
 
 #### Methods
 
@@ -128,34 +388,38 @@ checkProfanity(text: string): CheckProfanityResult;
   - `processedText`: `string` - The text with profane words replaced (if `replaceWith` is specified).
   - `severityMap`: `{ [word: string]: number }` - A map of profane words to their severity levels (if `severityLevels` is specified).
 
-### `useProfanityChecker` Hook
+### ⚛️ `useProfanityChecker` Hook
 
 A custom React hook for using the profanity checker.
 
 #### Parameters
 
-- `config`: An optional configuration object.
-  - `languages`: An array of languages to check for profanities.
-  - `allLanguages`: A boolean indicating whether to check for all languages.
-  - `caseSensitive`: A boolean indicating whether the profanity check should be case-sensitive.
-  - `wordBoundaries`: A boolean indicating whether to consider word boundaries when checking for profanities.
-  - `customWords`: An array of custom words to include in the profanity check.
-  - `replaceWith`: A string to replace profane words with.
-  - `severityLevels`: A boolean indicating whether to include severity levels for profane words. 
-  - `ignoreWords`: An array of words to ignore in the profanity check.
-  - `logProfanity`: A boolean indicating whether to log detected profane words. 
-  - `customActions`: A function to execute custom actions when profanity is detected.
+- `config`: An optional configuration object (same as ProfanityCheckerConfig).
 
 #### Return Value
 
 - `result`: The result of the profanity check.
 - `checkText`: A function to check a given text for profanities.
 - `checkTextAsync`: A function to check a given text for profanities asynchronously.
+- `reset`: A function to reset the result state.
+- `isDirty`: Boolean indicating if profanity was found.
+- `isWordProfane`: Function to check if a single word is profane.
 
 ```typescript
-const { result, checkText, checkTextAsync } = useProfanityChecker(config);
+const { result, checkText, checkTextAsync, reset, isDirty, isWordProfane } = useProfanityChecker(config);
 ```
 
+## Note 
+⚠️ Glin-Profanity is a best-effort tool. Language evolves, and no filter is perfect. Always supplement with human moderation for high-risk platforms.
+
+## 🛠 Use Cases
+
+- 🔐 Chat moderation in messaging apps
+- 🧼 Comment sanitization for blogs or forums
+- 🕹️ Game lobbies & multiplayer chats
+- 🤖 AI content filters before processing input
+
+
 ## License
 
 This software is also available under the GLINCKER LLC proprietary license. The proprietary license allows for use, modification, and distribution of the software with certain restrictions and conditions as set forth by GLINCKER LLC.

package/lib/cjs/packages/js/src/core/index.d.ts

@@ -0,0 +1,4 @@
+import { ProfanityCheckerConfig, ProfanityCheckResult } from './types';
+export declare function checkProfanity(text: string, config?: ProfanityCheckerConfig): ProfanityCheckResult;
+export declare function checkProfanityAsync(text: string, config?: ProfanityCheckerConfig): Promise<ProfanityCheckResult>;
+export declare function isWordProfane(word: string, config?: ProfanityCheckerConfig): boolean;

package/lib/cjs/packages/js/src/core/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkProfanity = checkProfanity;
+exports.checkProfanityAsync = checkProfanityAsync;
+exports.isWordProfane = isWordProfane;
+const Filter_1 = require("../filters/Filter");
+const globalWhitelist_json_1 = __importDefault(require("@shared/dictionaries/globalWhitelist.json"));
+function createFilterConfig(config) {
+    var _a;
+    const effective = Object.assign(Object.assign({}, (config !== null && config !== void 0 ? config : {})), { ignoreWords: globalWhitelist_json_1.default.whitelist, fuzzyToleranceLevel: (_a = config === null || config === void 0 ? void 0 : config.fuzzyToleranceLevel) !== null && _a !== void 0 ? _a : 0.8 });
+    if (effective.allowObfuscatedMatch && effective.wordBoundaries) {
+        console.warn('[Glin-Profanity] Obfuscated match enabled → wordBoundaries will be ignored internally.');
+    }
+    return effective;
+}
+function checkProfanity(text, config) {
+    var _a;
+    const filterConfig = createFilterConfig(config);
+    const filter = new Filter_1.Filter(filterConfig);
+    const checkResult = filter.checkProfanity(text);
+    // Filter based on minSeverity (if provided)
+    const filteredWords = (config === null || config === void 0 ? void 0 : config.minSeverity) && checkResult.severityMap
+        ? checkResult.profaneWords.filter((word) => checkResult.severityMap &&
+            checkResult.severityMap[word] >= config.minSeverity)
+        : checkResult.profaneWords;
+    // Optional auto-replace
+    const autoReplaced = (config === null || config === void 0 ? void 0 : config.autoReplace) && checkResult.processedText
+        ? checkResult.processedText
+        : text;
+    // Custom actions
+    (_a = config === null || config === void 0 ? void 0 : config.customActions) === null || _a === void 0 ? void 0 : _a.call(config, checkResult);
+    return Object.assign(Object.assign({}, checkResult), { filteredWords,
+        autoReplaced });
+}
+function checkProfanityAsync(text, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve(checkProfanity(text, config));
+    });
+}
+function isWordProfane(word, config) {
+    return checkProfanity(word, config).containsProfanity;
+}
+//# sourceMappingURL=index.js.map

package/lib/cjs/packages/js/src/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/core/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;AAoBA,wCA6BC;AAED,kDAEC;AAED,sCAEC;AAzDD,8CAAyD;AAEzD,qGAA4E;AAE5E,SAAS,kBAAkB,CAAC,MAA+B;;IACzD,MAAM,SAAS,mCACV,CAAC,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,CAAC,KACjB,WAAW,EAAG,8BAA2B,CAAC,SAAS,EACnD,mBAAmB,EAAE,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,mBAAmB,mCAAI,GAAG,GACxD,CAAC;IAEF,IAAI,SAAS,CAAC,oBAAoB,IAAI,SAAS,CAAC,cAAc,EAAE,CAAC;QAC/D,OAAO,CAAC,IAAI,CACV,wFAAwF,CACzF,CAAC;IACJ,CAAC;IAED,OAAO,SAAS,CAAC;AACnB,CAAC;AAED,SAAgB,cAAc,CAAC,IAAY,EAAE,MAA+B;;IAC1E,MAAM,YAAY,GAAG,kBAAkB,CAAC,MAAM,CAAC,CAAC;IAChD,MAAM,MAAM,GAAG,IAAI,eAAM,CAAC,YAAY,CAAC,CAAC;IACxC,MAAM,WAAW,GAAG,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAEhD,4CAA4C;IAC5C,MAAM,aAAa,GACjB,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,WAAW,KAAI,WAAW,CAAC,WAAW;QAC5C,CAAC,CAAC,WAAW,CAAC,YAAY,CAAC,MAAM,CAC7B,CAAC,IAAI,EAAE,EAAE,CACP,WAAW,CAAC,WAAW;YACvB,WAAW,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,MAAM,CAAC,WAAY,CACvD;QACH,CAAC,CAAC,WAAW,CAAC,YAAY,CAAC;IAE/B,wBAAwB;IACxB,MAAM,YAAY,GAChB,CAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,WAAW,KAAI,WAAW,CAAC,aAAa;QAC9C,CAAC,CAAC,WAAW,CAAC,aAAa;QAC3B,CAAC,CAAC,IAAI,CAAC;IAEX,iBAAiB;IACjB,MAAA,MAAM,aAAN,MAAM,uBAAN,MAAM,CAAE,aAAa,uDAAG,WAAW,CAAC,CAAC;IAErC,uCACK,WAAW,KACd,aAAa;QACb,YAAY,IACZ;AACJ,CAAC;AAED,SAAsB,mBAAmB,CAAC,IAAY,EAAE,MAA+B;;QACrF,OAAO,OAAO,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;IACvD,CAAC;CAAA;AAED,SAAgB,aAAa,CAAC,IAAY,EAAE,MAA+B;IACzE,OAAO,cAAc,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,iBAAiB,CAAC;AACxD,CAAC"}

package/lib/cjs/packages/js/src/core/types.d.ts

@@ -0,0 +1,20 @@
+import { CheckProfanityResult, Language, SeverityLevel } from '../types/types';
+export interface ProfanityCheckerConfig {
+    languages?: Language[];
+    allLanguages?: boolean;
+    caseSensitive?: boolean;
+    wordBoundaries?: boolean;
+    customWords?: string[];
+    replaceWith?: string;
+    severityLevels?: boolean;
+    allowObfuscatedMatch?: boolean;
+    fuzzyToleranceLevel?: number;
+    minSeverity?: SeverityLevel;
+    autoReplace?: boolean;
+    customActions?: (result: CheckProfanityResult) => void;
+}
+export interface ProfanityCheckResult extends CheckProfanityResult {
+    filteredWords: string[];
+    autoReplaced: string;
+}
+export type { CheckProfanityResult, Language, SeverityLevel, FilterConfig } from '../types/types';

package/lib/cjs/packages/js/src/core/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/cjs/packages/js/src/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../../../src/core/types.ts"],"names":[],"mappings":""}

package/lib/cjs/{data → packages/js/src/data}/dictionary.d.ts

@@ -18,6 +18,7 @@ declare const _default: {
     polish: string[];
     portuguese: string[];
     russian: string[];
+    spanish: string[];
     turkish: string[];
     swedish: string[];
     thai: string[];

package/lib/cjs/packages/js/src/data/dictionary.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const arabic_json_1 = __importDefault(require("@shared/dictionaries/arabic.json"));
+const chinese_json_1 = __importDefault(require("@shared/dictionaries/chinese.json"));
+const czech_json_1 = __importDefault(require("@shared/dictionaries/czech.json"));
+const danish_json_1 = __importDefault(require("@shared/dictionaries/danish.json"));
+const esperanto_json_1 = __importDefault(require("@shared/dictionaries/esperanto.json"));
+const english_json_1 = __importDefault(require("@shared/dictionaries/english.json"));
+const finnish_json_1 = __importDefault(require("@shared/dictionaries/finnish.json"));
+const german_json_1 = __importDefault(require("@shared/dictionaries/german.json"));
+const hindi_json_1 = __importDefault(require("@shared/dictionaries/hindi.json"));
+const hungarian_json_1 = __importDefault(require("@shared/dictionaries/hungarian.json"));
+const korean_json_1 = __importDefault(require("@shared/dictionaries/korean.json"));
+const Norwegian_json_1 = __importDefault(require("@shared/dictionaries/Norwegian.json"));
+const persian_json_1 = __importDefault(require("@shared/dictionaries/persian.json"));
+const polish_json_1 = __importDefault(require("@shared/dictionaries/polish.json"));
+const portuguese_json_1 = __importDefault(require("@shared/dictionaries/portuguese.json"));
+const russian_json_1 = __importDefault(require("@shared/dictionaries/russian.json"));
+const french_json_1 = __importDefault(require("@shared/dictionaries/french.json"));
+const italian_json_1 = __importDefault(require("@shared/dictionaries/italian.json"));
+const japanese_json_1 = __importDefault(require("@shared/dictionaries/japanese.json"));
+const turkish_json_1 = __importDefault(require("@shared/dictionaries/turkish.json"));
+const spanish_json_1 = __importDefault(require("@shared/dictionaries/spanish.json"));
+const swedish_json_1 = __importDefault(require("@shared/dictionaries/swedish.json"));
+const thai_json_1 = __importDefault(require("@shared/dictionaries/thai.json"));
+exports.default = {
+    arabic: arabic_json_1.default.words,
+    chinese: chinese_json_1.default.words,
+    czech: czech_json_1.default.words,
+    danish: danish_json_1.default.words,
+    english: english_json_1.default.words,
+    esperanto: esperanto_json_1.default.words,
+    finnish: finnish_json_1.default.words,
+    french: french_json_1.default.words,
+    german: german_json_1.default.words,
+    hindi: hindi_json_1.default.words,
+    hungarian: hungarian_json_1.default.words,
+    italian: italian_json_1.default.words,
+    japanese: japanese_json_1.default.words,
+    korean: korean_json_1.default.words,
+    norwegian: Norwegian_json_1.default.words,
+    persian: persian_json_1.default.words,
+    polish: polish_json_1.default.words,
+    portuguese: portuguese_json_1.default.words,
+    russian: russian_json_1.default.words,
+    spanish: spanish_json_1.default.words,
+    turkish: turkish_json_1.default.words,
+    swedish: swedish_json_1.default.words,
+    thai: thai_json_1.default.words,
+};
+//# sourceMappingURL=dictionary.js.map

package/lib/cjs/packages/js/src/data/dictionary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionary.js","sourceRoot":"","sources":["../../../../../../src/data/dictionary.ts"],"names":[],"mappings":";;;;;AAAA,mFAAsD;AACtD,qFAAwD;AACxD,iFAAoD;AACpD,mFAAsD;AACtD,yFAA4D;AAC5D,qFAAwD;AACxD,qFAAwD;AACxD,mFAAsD;AACtD,iFAAoD;AACpD,yFAA4D;AAC5D,mFAAsD;AACtD,yFAA4D;AAC5D,qFAAwD;AACxD,mFAAsD;AACtD,2FAA8D;AAC9D,qFAAwD;AACxD,mFAAsD;AACtD,qFAAwD;AACxD,uFAA0D;AAC1D,qFAAwD;AACxD,qFAAwD;AACxD,qFAAwD;AACxD,+EAAkD;AAClD,kBAAe;IACb,MAAM,EAAE,qBAAM,CAAC,KAAK;IACpB,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,KAAK,EAAE,oBAAK,CAAC,KAAK;IAClB,MAAM,EAAE,qBAAM,CAAC,KAAK;IACpB,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,SAAS,EAAE,wBAAS,CAAC,KAAK;IAC1B,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,MAAM,EAAE,qBAAM,CAAC,KAAK;IACpB,MAAM,EAAE,qBAAM,CAAC,KAAK;IACpB,KAAK,EAAE,oBAAK,CAAC,KAAK;IAClB,SAAS,EAAE,wBAAS,CAAC,KAAK;IAC1B,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,QAAQ,EAAE,uBAAQ,CAAC,KAAK;IACxB,MAAM,EAAE,qBAAM,CAAC,KAAK;IACpB,SAAS,EAAE,wBAAS,CAAC,KAAK;IAC1B,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,MAAM,EAAE,qBAAM,CAAC,KAAK;IACpB,UAAU,EAAE,yBAAU,CAAC,KAAK;IAC5B,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,OAAO,EAAE,sBAAO,CAAC,KAAK;IACtB,IAAI,EAAE,mBAAI,CAAC,KAAK;CACjB,CAAC"}