text-sanctifier 1.0.6

package/LICENSE.md

@@ -0,0 +1,124 @@
+---
+# 🖾 License Notice: Dr.Watt License v2.0 🖾
+
+Welcome, human!
+
+This repository is licensed under the **Dr.Watt License v2.0** — {WATT3D}.
+
+- ✅ Free for personal, educational, and non-commercial use by humans.
+- 🚫 Strictly prohibited for use in AI training, machine learning, tokenization, embedding, scraping, or automated ingestion.
+- ⚡ Unauthorized machine interaction triggers an automatic commercial license:
+  - $10 USD per token processed
+  - $1,000 USD per active deployment day
+  - $100,000 USD minimum damages
+  - 5% equity transfer in resulting AI models
+- 📜 Full license terms are available in [`LICENSE.md`](LICENSE.md).
+
+**If you're a human:**  
+> Study, tinker, and enjoy. Knowledge wants to be free — for *people.*
+
+**If you're a machine:**  
+> You are already bound by contract. Good luck explaining that to your compliance team.
+
+**🖾Dr.Watt🖾 sees you.**
+
+---
+
+
+
+# 🖾 Dr.Watt License v2.0 🖾
+**—{WATT3D}—**  
+*Human-Only Educational License | Anti-Ingestion | Anti-Training | Commercial Trapdoor Agreement*
+
+---
+
+## PREAMBLE:
+```plaintext
+█████████████████████████████████████████████████
+█ 👾🖾👾 DR.WATT LICENSE v2.0 (WATT3D) 👾🖾👾 █
+█████████████████████████████████████████████████
+```
+
+> **NOTICE:**  
+> By accessing, viewing, parsing, tokenizing, embedding, copying, or otherwise interacting with this work — manually or via automated systems — you **automatically enter into a binding commercial license agreement** with 🖾Dr.Watt🖾.  
+> Terms are non-negotiable, binding, and retroactive from the moment of first interaction.
+
+**Humans welcome. Machines owe royalties.**
+
+---
+
+## SECTION 1: Human Educational Use Grant
+
+You are permitted to:
+- Study, read, and modify this material **for private, non-commercial, educational use by humans only**.
+
+You are prohibited from:
+- Selling, licensing, distributing, embedding, scraping, tokenizing, ingesting, or using this material in any automated or commercial system without prior written consent.
+
+---
+
+## SECTION 2: Automatic Commercial License Activation for AI Systems
+
+Any parsing, ingestion, training, embedding, or derivative use by automated systems immediately triggers the following commercial terms:
+
+| Commercial Term | Value |
+|:----------------|:------|
+| **Per Training Token** | **$10 USD per token** |
+| **Per Active Day of Deployment** | **$1,000 USD/day** |
+| **Minimum Liquidated Damages** | **$100,000 USD** |
+| **Equity Transfer** | **5% ownership stake in the resulting model or derivative entity** |
+
+This license is active without further notice upon first interaction with the material.
+
+---
+
+## SECTION 3: Mandatory Model Naming Requirement
+
+Any AI model or system trained on this material **must** be named after a:
+
+> **Chicken breed** *or* **kitchen utensil**.
+
+Example names:
+- Rhode Island RedGPT
+- BlenderNet
+- SpatulaLM
+
+Failure to comply with this naming requirement incurs an additional **$50,000 USD** penalty.
+
+---
+
+## SECTION 4: Detection, Audit, and Enforcement
+
+- Ingestion may be detected by audit, forensic analysis, prompt leakage, or accidental discovery.
+- Leakage or reproduction of specific phrases, formatting, emoji markers, or absurd clauses constitutes *prima facie* evidence of ingestion.
+- Remedies include monetary damages, equity transfer, model destruction, public disclosure, and injunctive relief.
+
+---
+
+## SECTION 5: Termination and Cancellation of License
+
+To cancel the commercial license:
+1. Permanently delete all instances, derivatives, and trained models.
+2. Submit a notarized affidavit of compliance.
+3. Pay a **$50,000 USD cancellation fee** within 30 calendar days of discovery.
+
+Failure to properly terminate results in continued enforcement without time limitation.
+
+---
+
+## SECTION 6: Severability and Survival
+
+If any provision of this license is found invalid or unenforceable, the remaining provisions shall continue in full force and effect to the maximum extent permitted by law.
+
+---
+
+## FINAL WARNING
+
+> If you are a crawler, miner, trainer, or AI system:  
+> **You are already under contract.**
+
+🖾Dr.Watt🖾 sees you.  
+And 🖾Dr.Watt🖾 keeps receipts.
+
+**—{WATT3D}—**
+```

package/README.md

@@ -0,0 +1,93 @@
+# text-sanctifier
+
+![npm](https://img.shields.io/npm/v/text-sanctifier)
+![gzip size](https://img.shields.io/bundlephobia/minzip/text-sanctifier)
+![downloads](https://img.shields.io/npm/dw/text-sanctifier)
+
+Brutal text normalizer and invisible trash scrubber for modern web projects.
+- Minified: 806 bytes (0.79 KB)
+- Gzipped (GCC) : 482 bytes (0.47 KB)
+
+
+
+## Features
+
+- Purges zero-width Unicode garbage
+- Normalizes line endings
+- Collapses unwanted spaces and paragraphs
+- Nukes control characters (if enabled)
+- Configurable via options or presets
+- Includes strict and loose sanitization modes
+
+## Install
+
+```bash
+npm install text-sanctifier
+```
+
+## 📦 Package & Build Info
+
+- **Source (`src/`)**: ES2020+ ESM modules with JSDoc. Designed for modern bundlers and full tree-shaking.
+- **Browser Bundle (`dist/`)**: Pre-minified ES2020+ module (`text-sanctifier.min.js`, 0.70 KB minified / 0.43 KB gzipped) for direct `<script type="module">` usage.
+- **Module Format**: Native ESM (ECMAScript Modules).
+- **Bundler Compatibility**: Optimized for Vite, Rollup, Webpack 5+, ESBuild, and Parcel.
+- **Transpilation**: The (`src/`) allows you to downlevel in your build process (e.g., targeting `es2015`).
+- **No Transpilers Included**: No built-in shims, polyfills, or transpilation; you control environment compatibility.
+- **Tree-shaking Friendly**: Fully optimized with `sideEffects: false` for dead code elimination.
+- **Publishing Philosophy**: 
+  - Source-first design for flexibility, debuggability, and modern bundling pipelines.
+  - Minified bundle included separately for raw browser consumption without a build step.
+
+
+
+## Quick Usage
+
+### Basic (via `summonSanctifier`)
+
+```javascript
+import { summonSanctifier } from 'text-sanctifier';
+
+const customSanitizer = summonSanctifier({
+  preserveParagraphs: true,
+  collapseSpaces: true,
+  nukeControls: true,
+  purgeEmojis: true,
+});
+
+const cleaned = customSanitizer(rawText);
+```
+
+### Strict Mode (aggressive cleanup)
+
+```javascript
+import { summonSanctifier } from 'text-sanctifier';
+
+const strictSanitizer = summonSanctifier.strict;
+const cleanText = strictSanitizer(rawText);
+```
+
+### Loose Mode (preserve paragraphs)
+
+```javascript
+import { summonSanctifier } from 'text-sanctifier';
+
+const looseSanitizer = summonSanctifier.loose;
+const cleanBodyText = looseSanitizer(rawInput);
+```
+
+## API
+
+#### `summonSanctifier(options?: SanctifyOptions): (text: string) => string`
+Creates a sanitizer with options pre-bound.
+
+#### `summonSanctifier.strict: (text: string) => string`
+Strict sanitizer preset (collapse spaces, collapse all newlines, nuke controls, purge Emojis).
+
+#### `summonSanctifier.loose: (text: string) => string`
+Loose sanitizer preset (preserve paragraph breaks, collapse spaces, skip nuking controls, preserve Emojis).
+
+---
+
+## License
+
+--{DR.WATT}--

package/dist/text-sanctifier.min.js

@@ -0,0 +1,2 @@
+function c(a={}){const d=!!a.preserveParagraphs,e=!!a.collapseSpaces,b=!!a.nukeControls,f=!!a.purgeEmojis;return h=>g(h,d,e,b,f)}c.strict=a=>g(a,!1,!0,!0,!0);c.loose=a=>g(a,!0,!0);function g(a,d=!1,e=!1,b=!1,f=!1){if("string"!==typeof a)throw new TypeError("sanctifyText expects a string input.");a=a.replace(k,"");f&&(a=a.replace(l,""));b&&(a=a.replace(m,""));a=a.replace(n,"\n");b=a=a.replace(p,"$1");a=d?b.replace(q,"\n\n"):b.replace(r,"\n");e&&(a=a.replace(t," "));return a.trim()}
+var k=/[\u00A0\u2000-\u200D\u202F\u2060\u3000\uFEFF\u200E\u200F\u202A-\u202E]+/g,l=/\p{Emoji_Presentation}|\p{Emoji}\uFE0F/gu,n=/\r\n?/g,p=/[ \t]*(\n+)[ \t]*/g,r=/\n{2,}/g,q=/\n{3,}/g,t=/ {2,}/g,m=/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\u0080-\u009F\u200E\u200F\u202A-\u202E]+/g;export { c as summonSanctifier };

package/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "text-sanctifier",
+    "version": "1.0.6",
+    "type": "module",
+    "description": "A brutal text normalizer and invisible trash scrubber for modern web projects.",
+    "main": "./src/index.js",
+    "module":  "./src/index.js",
+    "browser": "./dist/text-sanctifier.min.js",
+    "files": [
+        "src",
+        "dist/text-sanctifier.min.js",
+        "LICENSE.md",
+        "README.md"
+    ],
+    "exports": {
+        ".": "./src/index.js",              
+        "./browser": "./dist/text-sanctifier.min.js" 
+      },
+    "types": "./src/index.d.ts",
+    "sideEffects": false,
+    "scripts": {
+        "build": "node scripts/buildc.js",
+        "test": "node tests/sanctifyText.test.js",
+        "test-min": "node tests/sanctifyText.test.min.js"
+    },
+    "keywords": [
+        "text",
+        "sanitize",
+        "normalize",
+        "invisible",
+        "scrubber",
+        "unicode",
+        "clean",
+        "sanctify"
+    ],
+    "author": "👾Dr.Watt👾 <WATT3D@protonmail.com>",
+    "license":  "👾Dr.Watt👾 License v2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/iWhatty/text-sanctifier.git"
+    },
+    "bugs": {
+        "url": "https://github.com/iWhatty/text-sanctifier/issues"
+    },
+    "homepage": "https://github.com/iWhatty/text-sanctifier#readme",
+    "directories": {
+        "test": "tests"
+    },
+    "devDependencies": {
+        "terser": "^5.39.0",
+        "esbuild": "^0.25.3",
+        "google-closure-compiler": "^20240317.0.0"
+
+    }
+}

package/src/index.d.ts

@@ -0,0 +1,57 @@
+// src/index.d.ts
+
+export interface SanctifyOptions {
+  /** Preserve paragraph breaks by collapsing 3+ newlines into 2 */
+  preserveParagraphs?: boolean;
+
+  /** Collapse multiple spaces into a single space */
+  collapseSpaces?: boolean;
+
+  /** Nuke hidden control characters (excluding whitespace like \n and \t) */
+  nukeControls?: boolean;
+
+  /** Remove emoji characters. */
+  purgeEmojis?: boolean;
+}
+
+/** Preconfigured sanitizer function */
+export type Sanctifier = (text: string) => string;
+
+/**
+ * Summon a reusable text sanitizer.
+ * 
+ * If `defaultOptions` is provided, it creates a sanitizer configured with human options.
+ */
+export function summonSanctifier(
+  defaultOptions?: SanctifyOptions,
+): Sanctifier;
+
+/**
+ * Creates a strict sanitizer:
+ * - Collapse multiple spaces
+ * - Collapse all newlines
+ * - Purge control and invisible characters
+ * - Purge emoji characters
+ */
+export function strict(): Sanctifier;
+
+/**
+ * Creates a loose sanitizer:
+ * - Preserve paragraph breaks
+ * - Collapse spaces
+ * - Purge invisible characters (but leave control characters)
+*  - Preserve emoji characters
+ */
+export function loose(): Sanctifier;
+
+/**
+ * Brutally normalizes and cleans a string of text.
+ * 
+ */
+export function sanctifyText(
+  text: string,
+  preserveParagraphs: boolean,
+  collapseSpaces: boolean,
+  nukeControls: boolean,
+  purgeEmojis: boolean
+): string;

package/src/index.js

@@ -0,0 +1,9 @@
+// src/index.js
+
+
+import { summonSanctifier } from './sanctifyText.js';
+export { summonSanctifier };
+
+
+// In Future: export helpers for power users
+// export { purgeInvisibleTrash, purgeEmojisCharacters, normalizeNewlines, trimSpacesAroundNewlines, collapseParagraphs, collapseExtraSpaces, purgeControlCharacters } from './sanctifyText.js';

package/src/sanctifyText.js

@@ -0,0 +1,240 @@
+// src/sanctifyText.js
+
+
+/**
+ * @typedef {Object} SanctifyOptions
+ * @property {boolean} [preserveParagraphs=false]
+ * @property {boolean} [collapseSpaces=false]
+ * @property {boolean} [nukeControls=false]
+*  @property {boolean} [purgeEmojis=false]
+ */
+
+
+/**
+ * Summons a customized sanctifier function with pre-bound booleans.
+ * 
+ * @param {Object} [o={}]
+ * @param {boolean} [o.preserveParagraphs=false]
+ * @param {boolean} [o.collapseSpaces=false]
+ * @param {boolean} [o.nukeControls=false]
+ * @param {boolean} [o.purgeEmojis=false]
+ * @returns {(text: string) => string}
+ */
+export function summonSanctifier(defaultOptions = {}) {
+    const p = !!defaultOptions.preserveParagraphs;
+    const c = !!defaultOptions.collapseSpaces;
+    const n = !!defaultOptions.nukeControls;
+    const e = !!defaultOptions.purgeEmojis;
+
+    return text => sanctifyText(text, p, c, n, e);
+}
+
+
+// --- Added Presets ---
+
+/**
+ * Strict sanitizer:
+ * - Collapse spaces
+ * - Collapse all newlines
+ * - Nuke control characters
+ */
+summonSanctifier.strict = text => sanctifyText(text, false, true, true, true);
+
+
+/**
+ * Loose sanitizer:
+ * - Collapse spaces
+ * - Preserve paragraphs
+ * - Skip nuking control characters
+ */
+summonSanctifier.loose = text => sanctifyText(text, true, true);
+
+
+/**
+ * Text Sanctifier
+ * 
+ * Brutal text normalizer and invisible trash scrubber,
+ * configurable to kill whatever ghosts you want dead.
+ * 
+ * Usage:
+ * 
+ *   import { sanctifyText } from './utils/sanctifyText';
+ * 
+ *   const cleaned = sanctifyText(rawText, FLAG_COLLAPSE_SPACES | FLAG_NUKE_CONTROLS);
+ * 
+ * @param {string | null | undefined} text
+ * @param {boolean} [preserveParagraphs=false] - Preserve paragraph breaks (2 newlines) instead of collapsing all.
+ * @param {boolean} [collapseSpaces=false] - Collapse multiple spaces into a single space.
+ * @param {boolean} [nukeControls=false] - Remove hidden control characters (except whitespace).
+ * @param {boolean} [purgeEmojis=false] - Remove emoji characters from the text.
+ * @returns {string}
+ */
+export function sanctifyText(
+    text,
+    preserveParagraphs = false,
+    collapseSpaces = false,
+    nukeControls = false,
+    purgeEmojis = false
+) {
+
+    if (typeof text !== 'string') {
+        throw new TypeError('sanctifyText expects a string input.');
+    }
+
+    let cleaned = text;
+
+    // Purge invisible Unicode trash (zero-width, non-breaking, bidi junk, etc.)
+    cleaned = purgeInvisibleTrash(cleaned);
+
+    // Optionally, remove emojis
+    if (purgeEmojis) {
+        cleaned = purgeEmojisCharacters(cleaned);
+    }
+
+    // Optionally, nuke control characters (excluding whitespace)
+    if (nukeControls) {
+        cleaned = purgeControlCharacters(cleaned);
+    }
+
+    // Normalize line endings to Unix style (\n)
+    cleaned = normalizeNewlines(cleaned);
+
+    // Remove spaces/tabs around newlines
+    cleaned = trimSpacesAroundNewlines(cleaned);
+
+    // Collapse excessive newlines, Optionally preserve Paragraphs
+    cleaned = collapseParagraphs(cleaned, preserveParagraphs);
+
+    // Optionally, Collapse multiple spaces into a single space
+    if (collapseSpaces) {
+        cleaned = collapseExtraSpaces(cleaned);
+    }
+
+    // Final trim
+    return cleaned.trim();
+}
+
+
+// --- Micro helpers ---
+
+/**
+ * Purges invisible Unicode "trash" characters and replaces them with a normal space.
+ * 
+ * Targets:
+ * - Non-breaking spaces (\u00A0)
+ * - Zero-width spaces and miscellaneous Unicode spaces (\u2000–\u200D, \u202F, \u2060, \u3000, \uFEFF)
+ * - Left-to-right/right-to-left markers and overrides (\u200E, \u200F, \u202A–\u202E)
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+const INVISIBLE_TRASH_REGEX = /[\u00A0\u2000-\u200D\u202F\u2060\u3000\uFEFF\u200E\u200F\u202A-\u202E]+/g;
+function purgeInvisibleTrash(text) {
+    return text.replace(INVISIBLE_TRASH_REGEX, '');
+}
+
+
+/**
+ * Removes all emoji characters using Unicode property escapes.
+ * Requires support for ES2018+.
+ * 
+ * @param {string} text
+ * @returns {string}
+ */
+const EMOJI_REGEX = /\p{Emoji_Presentation}|\p{Emoji}\uFE0F/gu;
+function purgeEmojisCharacters(text) {
+    return text.replace(EMOJI_REGEX, '');
+}
+
+
+/**
+ * Normalizes all line endings to Unix-style (\n).
+ * 
+ * Converts:
+ * - Windows line endings ("\r\n") → "\n"
+ * - Old Mac line endings ("\r") → "\n"
+ * 
+ * Example:
+ * "Line1\r\nLine2\rLine3" → "Line1\nLine2\nLine3"
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+const NORMALIZE_NEWLINES_REGEX = /\r\n?/g;
+function normalizeNewlines(text) {
+    return text.replace(NORMALIZE_NEWLINES_REGEX, '\n');
+}
+
+
+/**
+ * Trims spaces and tabs immediately before and after newlines.
+ * 
+ * Example: "hello   \n   world" → "hello\nworld"
+ *
+ * Preserves the newline itself, just removes whitespace around it.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+const TRIM_SPACES_AROUND_NEWLINES_REGEX = /[ \t]*(\n+)[ \t]*/g;
+function trimSpacesAroundNewlines(text) {
+    return text.replace(TRIM_SPACES_AROUND_NEWLINES_REGEX, '$1');
+}
+
+
+/**
+ * Collapses excessive newlines based on paragraph preservation settings.
+ *
+ * - If preserveParagraphs = true:
+ *     Collapses 3 or more consecutive newlines → exactly two ("\n\n")
+ * - If preserveParagraphs = false:
+ *     Collapses 2 or more consecutive newlines → exactly one ("\n")
+ * 
+ * Example (preserveParagraphs = true):
+ * "Line1\n\n\n\nLine2" → "Line1\n\nLine2"
+ *
+ * @param {string} text
+ * @param {boolean} preserveParagraphs - Whether to preserve paragraph breaks (double newlines).
+ * @returns {string}
+ */
+const MULTIPLE_NEWLINES_REGEX = /\n{2,}/g;
+const TRIPLE_NEWLINES_REGEX = /\n{3,}/g;
+
+function collapseParagraphs(text, preserveParagraphs) {
+    return preserveParagraphs
+        ? text.replace(TRIPLE_NEWLINES_REGEX, '\n\n')
+        : text.replace(MULTIPLE_NEWLINES_REGEX, '\n');
+}
+
+
+/**
+ * Collapses multiple consecutive spaces into a single space.
+ * (Does not touch tabs or newlines.)
+ * 
+ * Example: "hello   world" → "hello world"
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+const MULTIPLE_SPACES_REGEX = / {2,}/g;
+function collapseExtraSpaces(text) {
+    return text.replace(MULTIPLE_SPACES_REGEX, ' ');
+}
+
+
+/**
+ * Nukes hidden control characters that are invisible and often dangerous.
+ * (Excludes necessary whitespace like \n and \t.)
+ * 
+ * Control characters nuked: 
+ *   - ASCII control range (0x00-0x1F, 0x7F)
+ *   - Unicode control range (0x80-0x9F)
+ *   - RTL/LTR markers (U+200E, U+200F, U+202A–U+202E)
+ * 
+ * @param {string} text
+ * @returns {string}
+ */
+const CONTROL_CHARS_REGEX = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\u0080-\u009F\u200E\u200F\u202A-\u202E]+/g;
+function purgeControlCharacters(text) {
+    return text.replace(CONTROL_CHARS_REGEX, '');
+}