glin-profanity

GLIN PROFANITY

A multilingual profanity detection and filtering engine for modern applications — by GLINCKER

A multilingual profanity detection and filtering engine for modern applications — by GLINCKER

✨ 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 real-time React integration, it’s designed 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
• 🧩 Seamlessly integrate into React apps via useProfanityChecker
• 🛡️ Add custom word lists or ignore specific terms

📚 Table of Contents

• 🚀 Features
• 📦 Installation
• 🌍 Supported Languages
• ⚙️ Usage
  • Basic Usage
• 🧠 API
  • Filter Class
    • Constructor
    • FilterConfig Options
    • Methods
      • isProfane
      • checkProfanity
  • useProfanityChecker Hook
    • Parameters
    • Return Value
• ⚠️ Note
• 🛠 Use Cases
• 📄 License
  • MIT License

Installation

To install Glin-Profanity, use npm:

npm install glin-profanity

OR

yarn add glin-profanity

Supported Languages

Arabic, Chinese, Czech, Danish, English, Esperanto, Finnish, French, German, Hindi, Hungarian, Italian, Japanese, Korean, Norwegian, Persian, Polish, Portuguese, Russian, Turkish, Swedish, Thai

Usage

Basic Usage

Here's a simple example of how to use Glin-Profanity in a React application:

import React, { useState } from 'react';
import { useProfanityChecker, SeverityLevel, Language } from 'glin-profanity';

const App = () => {
  const [text, setText] = useState('');
  const [autoReplace, setAutoReplace] = useState(true);
  const [replaceWith, setReplaceWith] = useState('***');
  const [minSeverity, setMinSeverity] = useState(SeverityLevel.Exact);

  const { result, checkText } = useProfanityChecker({
    allLanguages: true,
    severityLevels: true,
    autoReplace,
    replaceWith,
    minSeverity,
    customActions: (res) => {
      console.log('[Detected]', res.profaneWords);
    },
  });

  return (
    <div>
      <input value={text} onChange={(e) => setText(e.target.value)} />
      <button onClick={() => checkText(text)}>Scan</button>

      {result && (
        <>
          <p>Contains Profanity: {result.containsProfanity ? 'Yes' : 'No'}</p>
          {result.containsProfanity && (
            <>
              <p>Detected: {result.profaneWords.join(', ')}</p>
              <p>Replaced: {result.processedText}</p>
            </>
          )}
        </>
      )}
    </div>
  );
};

API

Filter Class

Constructor

new Filter(config?: { 
  languages?: Language[]; 
  allLanguages?: boolean;
  caseSensitive?: boolean;
  wordBoundaries?: boolean;
  customWords?: string[];
  replaceWith?: string;
  severityLevels?: boolean; 
  ignoreWords?: string[];
  logProfanity?: boolean; 
});

FilterConfig Options:

Option	Type	Description
languages	Language[]	Languages to include
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

isProfane

Checks if a given text contains profanities.

isProfane(value: string): boolean;

• value: The text to check.
• Returns: boolean - true if the text contains profanities, false otherwise.

checkProfanity

Returns details about profanities found in the text.

checkProfanity(text: string): CheckProfanityResult;

• text: The text to check.
• Returns: CheckProfanityResult
  • containsProfanity: boolean - true if the text contains profanities, false otherwise.
  • profaneWords: string[] - An array of profane words found in the text.
  • 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

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.

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.

const { result, checkText, checkTextAsync } = 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.

You are free to use this software for reference and educational purposes. However, any commercial use, distribution, or modification outside the terms of the MIT License requires explicit permission from GLINCKER LLC.

By using the software in any form, you agree to adhere to the terms of both the MIT License and the GLINCKER LLC proprietary license, where applicable. If there is any conflict between the terms of the MIT License and the GLINCKER LLC proprietary license, the terms of the GLINCKER LLC proprietary license shall prevail.

MIT License

GLIN PROFANITY is MIT licensed.