text-sanctifier 1.0.13 → 1.0.15

package/README.md

@@ -5,22 +5,21 @@
 [![downloads](https://img.shields.io/npm/dw/text-sanctifier)](https://www.npmjs.com/package/text-sanctifier)
 [![GitHub stars](https://img.shields.io/github/stars/iWhatty/text-sanctifier?style=social)](https://github.com/iWhatty/text-sanctifier)
 
-
 Brutal text normalizer and invisible trash scrubber for modern web projects.
 
-* Minified: (2.45 KB)
-* Gzipped (GCC) : (1.18 KB)
+* Minified: (3.09 KB)
+* Gzipped (GCC): (1.36 KB)
 
 ## Features
 
 * Purges zero-width Unicode garbage
-* Normalizes line endings
+* Normalizes line endings (CRLF, CR, LF) → LF
 * Collapses unwanted spaces and paragraphs
 * Nukes control characters (if enabled)
-* Configurable via options or presets
-* Includes strict and loose sanitization modes
-* **NEW:** Keyboard-only filtering — retains only printable ASCII + emojis
-* **NEW:** Smart normalization of typographic junk (smart quotes, em dashes, full-width punctuation)
+* Smart normalization of typographic junk (quotes, dashes, bullets, full-width punctuation)
+* Keyboard-only filtering (retain printable ASCII + emoji, or restrict)
+* Configurable via fine-grained flags or ready-made presets
+* Includes strict, loose, and keyboard-only modes
 
 ## Install
 
@@ -30,98 +29,65 @@ 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 (`src/`)**: ES2020+ ESM modules with JSDoc
+* **Browser Build (`dist/`)**: Minified ESM bundle for `<script type="module">`
+* **Tree-shaking Friendly**: Fully optimized with `sideEffects: false`
+* **Zero Transpilation**: No built-in polyfills or runtime overhead
+* **Bundler Ready**: Works great with Vite, Rollup, Webpack, Parcel, etc.
 
-  * Source-first design for flexibility, debuggability, and modern bundling pipelines.
-  * Minified bundle included separately for raw browser consumption without a build step.
+---
 
-## Quick Usage
+## 🔧 Quick Usage
 
-### Basic (via `summonSanctifier`)
+### Custom Config
 
-```javascript
+```js
 import { summonSanctifier } from 'text-sanctifier';
 
-const customSanitizer = summonSanctifier({
-  preserveParagraphs: true,
-  collapseSpaces: true,
-  nukeControls: true,
+const clean = summonSanctifier({
+  purgeInvisibleChars: true,
   purgeEmojis: true,
+  collapseSpaces: true,
+  collapseNewLines: true,
+  preserveParagraphs: true,
+  finalTrim: true,
 });
 
-const cleaned = customSanitizer(rawText);
+const output = clean(rawText);
 ```
 
-### Strict Mode (aggressive cleanup)
-
-```javascript
-import { summonSanctifier } from 'text-sanctifier';
+### Strict Preset
 
-const strictSanitizer = summonSanctifier.strict;
-const cleanText = strictSanitizer(rawText);
+```js
+const output = summonSanctifier.strict(rawText);
 ```
 
-### Loose Mode (preserve paragraphs)
-
-```javascript
-import { summonSanctifier } from 'text-sanctifier';
+### Loose Preset
 
-const looseSanitizer = summonSanctifier.loose;
-const cleanBodyText = looseSanitizer(rawInput);
+```js
+const output = summonSanctifier.loose(rawText);
 ```
 
-### Keyboard-only Mode (keep only printable ASCII)
+### Keyboard-Only (No Emojis)
 
-```javascript
-const keyboardOnly = summonSanctifier.keyboardOnly;
-const asciiOnlyText = keyboardOnly(userInput);
+```js
+const output = summonSanctifier.keyboardOnly(userInput);
 ```
 
-### Keyboard-only with Emoji Support
+### Keyboard-Only (With Emojis)
 
-```javascript
-const keyboardWithEmoji = summonSanctifier.keyboardOnlyEmoji;
-const cleanAndFun = keyboardWithEmoji(commentBox);
+```js
+const output = summonSanctifier.keyboardOnlyEmoji(commentText);
 ```
 
-## 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).
-
-#### `summonSanctifier.keyboardOnly: (text: string) => string`
-
-Removes everything except printable ASCII. Emojis are removed. Spaces are collapsed.
-
-#### `summonSanctifier.keyboardOnlyEmoji: (text: string) => string`
-
-Keeps printable ASCII and emoji characters. Typographic normalization included.
-
 ---
 
+## 🔍 Unicode Trash Detection
 
-### Unicode Trash Detection
-
-```javascript
+```js
 import { inspectText } from 'text-sanctifier';
 
-const report = inspectText(rawInput);
+const report = inspectText(input);
 
 /*
 {
@@ -141,8 +107,37 @@ const report = inspectText(rawInput);
 */
 ```
 
-Use this to preflight inputs and flag unwanted characters (like control codes, zero-width spaces, or mixed newline styles) before sanitization or storage.
+Use `inspectText` to preflight text content before rendering, storing, or linting. It's a diagnostic tool to help inform sanitization needs.
+
+Pass the report to getRecommendedSanctifierOptions(report) to auto-generate config flags for summonSanctifier().
+
+---
+
+## API
+
+### `summonSanctifier(options?: SanctifyOptions): (text: string) => string`
+
+Creates a reusable sanitizer from an option object.
+
+### `summonSanctifier.strict`
+
+Aggressively purges: emojis, control characters, extra spacing, and newlines.
+
+### `summonSanctifier.loose`
+
+Gently normalizes spacing and newlines while preserving emojis and paragraphs.
+
+### `summonSanctifier.keyboardOnly`
+
+Restricts to printable ASCII only (removes emojis).
+
+### `summonSanctifier.keyboardOnlyEmoji`
+
+Restricts to keyboard-safe ASCII + emojis. Preserves fun, removes weird.
+
+### `inspectText(text: string): UnicodeTrashReport`
 
+Returns a structural report of control codes, invisible chars, newline styles, and more.
 
 ---
 

package/dist/text-sanctifier.min.js

@@ -1,7 +1,8 @@
-function f(a={}){const b=!!a.preserveParagraphs,c=!!a.collapseSpaces,d=!!a.nukeControls,e=!!a.purgeEmojis,h=!!a.keyboardOnlyFilter;return k=>g(k,b,c,d,e,h)}f.strict=a=>g(a,!1,!0,!0,!0);f.loose=a=>g(a,!0,!0);f.keyboardOnlyEmoji=a=>g(a,!1,!1,!0,!1,!0);f.keyboardOnly=a=>g(a,!1,!0,!0,!0,!0);
-function g(a,b=!1,c=!1,d=!1,e=!1,h=!1){if("string"!==typeof a)throw new TypeError("sanctifyText expects a string input.");a=a.replace(l,"");e&&(a=a.replace(m,""));d&&(a=a.replace(n,""));h&&(a=p(a,e));a=a.replace(q,"\n");d=a=a.replace(r,"$1");a=b?d.replace(t,"\n\n"):d.replace(u,"\n");c&&(a=a.replace(v," "));return a.trim()}var l=/[\u00A0\u2000-\u200D\u202F\u2060\u3000\uFEFF\u200E\u200F\u202A-\u202E]+/g,w=/[^\x20-\x7E\r\n]+/gu;
-function p(a,b=!1){a=x(a);return b?a.replace(w,""):a.replace(w,c=>c.match(m)?c:"")}var y=/[\u2018\u2019\u201A\u201B\u2032\u2035]/g,z=/[\u201C\u201D\u201E\u201F\u2033\u2036\u00AB\u00BB]/g,A=/[\u2012\u2013\u2014\u2015\u2212]/g,B=/\u2026/g,C=/[\u2022\u00B7]/g,D=/[\uFF01-\uFF5E]/g;function x(a){return a.replace(y,"'").replace(z,'"').replace(A,"-").replace(B,"...").replace(C,"*").replace(D,b=>String.fromCharCode(b.charCodeAt(0)-65248))}var m;
-try{m=RegExp("(?:\\p{Extended_Pictographic}(?:\\uFE0F|\\uFE0E)?(?:\\u200D(?:\\p{Extended_Pictographic}|\\w)+)*)","gu")}catch{m=/[\u{1F300}-\u{1FAFF}]/gu}var q=/\r\n|\r|\n/g,r=/[ \t]*(\n+)[ \t]*/g,u=/\n{2,}/g,t=/\n{3,}/g,v=/ {2,}/g,n=/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\u0080-\u009F\u200E\u200F\u202A-\u202E]+/g;
-function E(a){if("string"!==typeof a)throw new TypeError("inspectText expects a string input.");const b=[],c={o:!1,u:!1,j:!1,g:null,s:!1,v:!1,summary:b},d=(k,F,G)=>{k&&(c[F]=!0,b.push(G))};d(n.test(a),"hasControlChars","Control characters detected.");d(l.test(a),"hasInvisibleChars","Invisible Unicode characters detected.");d(m.test(a),"hasEmojis","Emojis detected.");const {m:e,types:h}=H(a);c.j=e;c.g=e?"Mixed":h[0]||null;c.g&&b.push(e?"Mixed newline styles detected.":`Consistent newline style: ${c.g}`);
-a=x(a).replace(w,k=>k.match(m)?"":"\u2612");d(/[\u2612]/.test(a),"hasNonKeyboardChars","Non-keyboard characters detected.");return c}function H(a){if("string"!==typeof a)throw new TypeError("getNewlineStats expects a string input.");var b=a.replace(/\r\n/g,"");a={i:(a.match(/\r\n/g)||[]).length,h:(b.match(/\r/g)||[]).length,l:(b.match(/\n/g)||[]).length};b=[];0<a.i&&b.push("CRLF");0<a.h&&b.push("CR");0<a.l&&b.push("LF");return{...a,types:b,m:1<b.length}}
-export { f as summonSanctifier, E as inspectText };
+function g(a={}){const b=!!a.purgeInvisibleChars,c=!!a.purgeEmojis,d=!!a.nukeControls,e=!!a.keyboardOnlyFilter,k=!!a.normalizeNewlines,f=!!a.trimSpacesAroundNewlines,l=!!a.collapseNewLines,m=!!a.preserveParagraphs,p=!!a.collapseSpaces,q=!!a.finalTrim;return w=>h(w,b,c,d,e,k,f,l,m,p,q)}g.strict=a=>h(a,!0,!0,!0,!1,!0,!0,!0,!1,!0,!0);g.loose=a=>h(a,!1,!1,!1,!1,!0,!0,!0,!0,!0,!0);g.keyboardOnlyEmoji=a=>h(a,!1,!1,!1,!0,!0,!0,!1,!1,!1,!0);g.keyboardOnly=a=>h(a,!0,!0,!0,!0,!0,!0,!0,!1,!0,!0);
+function h(a,b=!1,c=!1,d=!1,e=!1,k=!1,f=!1,l=!1,m=!1,p=!1,q=!1){if("string"!==typeof a)throw new TypeError("sanctifyText expects a string input.");b&&(a=a.replace(n,""));c&&(a=a.replace(r,""));d&&(a=a.replace(t,""));e&&(a=u(a,c));k&&(a=a.replace(v,"\n"));f&&(a=a.replace(x,"$1"));l&&(b=a,a=m?b.replace(y,"\n\n"):b.replace(z,"\n"));p&&(a=a.replace(A," "));return q?a.trim():a}var n=/[\u00A0\u2000-\u200D\u202F\u2060\u3000\uFEFF\u200E\u200F\u202A-\u202E]+/g,B=/[^\x20-\x7E\r\n]+/gu;
+function u(a,b=!1){a=C(a);return b?a.replace(B,""):a.replace(B,c=>c.match(r)?c:"")}var D=/[\u2018\u2019\u201A\u201B\u2032\u2035]/g,E=/[\u201C\u201D\u201E\u201F\u2033\u2036\u00AB\u00BB]/g,F=/[\u2012\u2013\u2014\u2015\u2212]/g,G=/\u2026/g,H=/[\u2022\u00B7]/g,I=/[\uFF01-\uFF5E]/g;function C(a){return a.replace(D,"'").replace(E,'"').replace(F,"-").replace(G,"...").replace(H,"*").replace(I,b=>String.fromCharCode(b.charCodeAt(0)-65248))}var r;
+try{r=RegExp("(?:\\p{Extended_Pictographic}(?:\\uFE0F|\\uFE0E)?(?:\\u200D(?:\\p{Extended_Pictographic}|\\w)+)*)","gu")}catch{r=/[\u{1F300}-\u{1FAFF}]/gu}var v=/\r\n|\r|\n/g,x=/[ \t]*(\n+)[ \t]*/g,z=/\n{2,}/g,y=/\n{3,}/g,A=/ {2,}/g,t=/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F\u0080-\u009F\u200E\u200F\u202A-\u202E]+/g;
+function J(a){if("string"!==typeof a)throw new TypeError("inspectText expects a string input.");const b=[],c={hasControlChars:!1,hasInvisibleChars:!1,hasMixedNewlines:!1,newlineStyle:null,hasEmojis:!1,hasNonKeyboardChars:!1,summary:b},d=(f,l,m)=>{f&&(c[l]=!0,b.push(m))};d(t.test(a),"hasControlChars","Control characters detected.");d(n.test(a),"hasInvisibleChars","Invisible Unicode characters detected.");d(r.test(a),"hasEmojis","Emojis detected.");const {j:e,types:k}=K(a);c.hasMixedNewlines=e;c.newlineStyle=
+e?"Mixed":k[0]||null;c.newlineStyle&&b.push(e?"Mixed newline styles detected.":`Consistent newline style: ${c.newlineStyle}`);a=C(a).replace(B,f=>f.match(r)?"":"\u2612");d(/[\u2612]/.test(a),"hasNonKeyboardChars","Non-keyboard characters detected.");return c}
+function K(a){if("string"!==typeof a)throw new TypeError("getNewlineStats expects a string input.");var b=a.replace(/\r\n/g,"");a={h:(a.match(/\r\n/g)||[]).length,g:(b.match(/\r/g)||[]).length,i:(b.match(/\n/g)||[]).length};b=[];0<a.h&&b.push("CRLF");0<a.g&&b.push("CR");0<a.i&&b.push("LF");return{...a,types:b,j:1<b.length}}
+function L(a){return{purgeInvisibleChars:a.hasInvisibleChars,purgeEmojis:a.hasEmojis,nukeControls:a.hasControlChars,keyboardOnlyFilter:a.hasNonKeyboardChars,normalizeNewlines:a.hasMixedNewlines||"CRLF"===a.newlineStyle||"CR"===a.newlineStyle}}export { g as summonSanctifier, J as inspectText, L as getRecommendedSanctifierOptions };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "text-sanctifier",
-    "version": "1.0.13",
+    "version": "1.0.15",
     "type": "module",
     "description": "A brutal text normalizer and invisible trash scrubber for modern web projects.",
     "main": "./src/index.js",

package/src/index.d.ts

@@ -1,20 +1,35 @@
 // src/index.d.ts
 
 export interface SanctifyOptions {
-  /** Preserve paragraph breaks by collapsing 3+ newlines into 2 */
-  preserveParagraphs?: boolean;
+  /** Remove ZWSP, NBSP, bidi, and other invisible Unicode trash */
+  purgeInvisibleChars?: boolean;
 
-  /** Collapse multiple spaces into a single space */
-  collapseSpaces?: boolean;
+  /** Remove emoji characters */
+  purgeEmojis?: boolean;
 
   /** Nuke hidden control characters (excluding whitespace like \n and \t) */
   nukeControls?: boolean;
 
-  /** Remove emoji characters */
-  purgeEmojis?: boolean;
-
   /** Restrict to printable ASCII (+ emoji if `purgeEmojis` is false) */
   keyboardOnlyFilter?: boolean;
+
+  /** Normalize all newline sequences to LF (`\n`) */
+  normalizeNewlines?: boolean;
+
+  /** Remove tabs and spaces before/after newline characters */
+  trimSpacesAroundNewlines?: boolean;
+
+  /** Collapse multiple consecutive newlines */
+  collapseNewLines?: boolean;
+
+  /** When collapsing newlines, preserve paragraph breaks as double `\n\n` */
+  preserveParagraphs?: boolean;
+
+  /** Collapse multiple spaces into a single space */
+  collapseSpaces?: boolean;
+
+  /** Trim leading and trailing whitespace from final result */
+  finalTrim?: boolean;
 }
 
 /** Preconfigured sanitizer function */
@@ -56,11 +71,16 @@ export namespace summonSanctifier {
  */
 export function sanctifyText(
   text: string,
+  purgeInvisibleChars?: boolean,
+  purgeEmojis?: boolean,
+  nukeControls?: boolean,
+  keyboardOnlyFilter?: boolean,
+  normalizeNewlines?: boolean,
+  trimSpacesAroundNewlines?: boolean,
+  collapseNewLines?: boolean,
   preserveParagraphs?: boolean,
   collapseSpaces?: boolean,
-  nukeControls?: boolean,
-  purgeEmojis?: boolean,
-  keyboardOnlyFilter?: boolean
+  finalTrim?: boolean,
 ): string;
 
 /** Style of newline characters detected in a string */
@@ -84,3 +104,13 @@ export interface UnicodeTrashReport {
  * invisible characters, newline styles, emojis, and more.
  */
 export function inspectText(text: string): UnicodeTrashReport;
+
+
+/**
+ * Creates a recommended set of `summonSanctifier` options based on the findings
+ * of `inspectText()`. This maps only what can be inferred automatically —
+ * user-preference settings like whitespace collapsing are left unset.
+ */
+export function getRecommendedSanctifierOptions(
+  report: UnicodeTrashReport
+): SanctifyOptions;

package/src/index.js

@@ -1,8 +1,8 @@
 // src/index.js
 
 
-import { inspectText } from './inspectText.js';
-export { inspectText };
+import { inspectText, getRecommendedSanctifierOptions } from './inspectText.js';
+export { inspectText, getRecommendedSanctifierOptions };
 
 import { summonSanctifier } from './sanctifyText.js';
 export { summonSanctifier };

package/src/inspectText.js

@@ -1,4 +1,5 @@
 
+// ./src/inspectText.js
 
 
 import {
@@ -7,9 +8,10 @@ import {
     EMOJI_REGEX,
     ASCII_KEYBOARD_SAFE_REGEX,
     normalizeTypographicJank
-  } from './sanctifyText.js';
+} from './sanctifyText.js';
+
+
 
-  
 /**
  * Detects textual "trash" or anomalies in a given string.
  * @param {string} text
@@ -24,53 +26,53 @@ import {
 * }}
 */
 export function inspectText(text) {
- if (typeof text !== 'string') {
-   throw new TypeError('inspectText expects a string input.');
- }
-
- const summary = [];
- const report = {
-   hasControlChars: false,
-   hasInvisibleChars: false,
-   hasMixedNewlines: false,
-   newlineStyle: null,
-   hasEmojis: false,
-   hasNonKeyboardChars: false,
-   summary
- };
-
- const flag = (condition, key, message) => {
-   if (condition) {
-     report[key] = true;
-     summary.push(message);
-   }
- };
-
- // === Pattern Checks ===
- flag(CONTROL_CHARS_REGEX.test(text), 'hasControlChars', 'Control characters detected.');
- flag(INVISIBLE_TRASH_REGEX.test(text), 'hasInvisibleChars', 'Invisible Unicode characters detected.');
- flag(EMOJI_REGEX.test(text), 'hasEmojis', 'Emojis detected.');
-
- // === Newline Analysis ===
- const { mixed, types } = getNewlineStats(text);
- report.hasMixedNewlines = mixed;
- report.newlineStyle = mixed ? 'Mixed' : types[0] || null;
-
- if (report.newlineStyle) {
-   summary.push(
-     mixed
-       ? 'Mixed newline styles detected.'
-       : `Consistent newline style: ${report.newlineStyle}`
-   );
- }
-
- // === Non-keyboard characters (excluding emojis) ===
- const filtered = normalizeTypographicJank(text).replace(ASCII_KEYBOARD_SAFE_REGEX, m =>
-    m.match(EMOJI_REGEX) ? '' : '☒'
-  );
- flag(/[☒]/.test(filtered), 'hasNonKeyboardChars', 'Non-keyboard characters detected.');
-
- return report;
+    if (typeof text !== 'string') {
+        throw new TypeError('inspectText expects a string input.');
+    }
+
+    const summary = [];
+    const report = {
+        hasControlChars: false,
+        hasInvisibleChars: false,
+        hasMixedNewlines: false,
+        newlineStyle: null,
+        hasEmojis: false,
+        hasNonKeyboardChars: false,
+        summary
+    };
+
+    const flag = (condition, key, message) => {
+        if (condition) {
+            report[key] = true;
+            summary.push(message);
+        }
+    };
+
+    // === Pattern Checks ===
+    flag(CONTROL_CHARS_REGEX.test(text), 'hasControlChars', 'Control characters detected.');
+    flag(INVISIBLE_TRASH_REGEX.test(text), 'hasInvisibleChars', 'Invisible Unicode characters detected.');
+    flag(EMOJI_REGEX.test(text), 'hasEmojis', 'Emojis detected.');
+
+    // === Newline Analysis ===
+    const { mixed, types } = getNewlineStats(text);
+    report.hasMixedNewlines = mixed;
+    report.newlineStyle = mixed ? 'Mixed' : types[0] || null;
+
+    if (report.newlineStyle) {
+        summary.push(
+            mixed
+                ? 'Mixed newline styles detected.'
+                : `Consistent newline style: ${report.newlineStyle}`
+        );
+    }
+
+    // === Non-keyboard characters (excluding emojis) ===
+    const filtered = normalizeTypographicJank(text).replace(ASCII_KEYBOARD_SAFE_REGEX, m =>
+        m.match(EMOJI_REGEX) ? '' : '☒'
+    );
+    flag(/[☒]/.test(filtered), 'hasNonKeyboardChars', 'Non-keyboard characters detected.');
+
+    return report;
 }
 
 
@@ -86,30 +88,52 @@ export function inspectText(text) {
 * }}
 */
 export function getNewlineStats(text) {
- if (typeof text !== 'string') {
-   throw new TypeError('getNewlineStats expects a string input.');
- }
-
- const crlfMatches = text.match(/\r\n/g) || [];
- const textWithoutCRLF = text.replace(/\r\n/g, '');
-
- const crMatches = textWithoutCRLF.match(/\r/g) || [];
- const lfMatches = textWithoutCRLF.match(/\n/g) || [];
-
- const count = {
-   crlf: crlfMatches.length,
-   cr: crMatches.length,
-   lf: lfMatches.length
- };
-
- const types = [];
- if (count.crlf > 0) types.push('CRLF');
- if (count.cr > 0) types.push('CR');
- if (count.lf > 0) types.push('LF');
-
- return {
-   ...count,
-   types,
-   mixed: types.length > 1
- };
+    if (typeof text !== 'string') {
+        throw new TypeError('getNewlineStats expects a string input.');
+    }
+
+    const crlfMatches = text.match(/\r\n/g) || [];
+    const textWithoutCRLF = text.replace(/\r\n/g, '');
+
+    const crMatches = textWithoutCRLF.match(/\r/g) || [];
+    const lfMatches = textWithoutCRLF.match(/\n/g) || [];
+
+    const count = {
+        crlf: crlfMatches.length,
+        cr: crMatches.length,
+        lf: lfMatches.length
+    };
+
+    const types = [];
+    if (count.crlf > 0) types.push('CRLF');
+    if (count.cr > 0) types.push('CR');
+    if (count.lf > 0) types.push('LF');
+
+    return {
+        ...count,
+        types,
+        mixed: types.length > 1
+    };
+}
+
+
+
+/**
+ * Creates defaultOptions for summonSanctifier based on inspectText result
+ * @param {!UnicodeTrashReport} report
+ * @return {!SanctifyOptions}
+ */
+export function getRecommendedSanctifierOptions(report) {
+    return {
+        purgeInvisibleChars: report.hasInvisibleChars,
+        purgeEmojis: report.hasEmojis,
+        nukeControls: report.hasControlChars,
+        keyboardOnlyFilter: report.hasNonKeyboardChars,
+        normalizeNewlines: report.hasMixedNewlines || report.newlineStyle === 'CRLF' || report.newlineStyle === 'CR',
+        // trimSpacesAroundNewlines: true,
+        // collapseNewLines: false,
+        // preserveParagraphs: true,
+        // collapseSpaces: true,
+        // finalTrim: true,
+    };
 }

package/src/sanctifyText.js

@@ -3,77 +3,149 @@
 
 /**
  * @typedef {Object} SanctifyOptions
- * @property {boolean} [preserveParagraphs=false]
- * @property {boolean} [collapseSpaces=false]
- * @property {boolean} [nukeControls=false]
-*  @property {boolean} [purgeEmojis=false]
- * @property {boolean} [keyboardOnlyFilter=false]
+ * @property {boolean} [purgeInvisibleChars]
+ * @property {boolean} [purgeEmojis]
+ * @property {boolean} [nukeControls]
+ * @property {boolean} [keyboardOnlyFilter]
+ * @property {boolean} [normalizeNewlines]
+ * @property {boolean} [trimSpacesAroundNewlines]
+ * @property {boolean} [collapseNewLines]
+ * @property {boolean} [preserveParagraphs]
+ * @property {boolean} [collapseSpaces]
+ * @property {boolean} [finalTrim]
  */
 
 
 /**
  * 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]
- * @param {boolean} [o.keyboardOnlyFilter=false]
+ *
+ * Accepts full flag names and returns a text-cleaning function.
+ *
+ * @param {Object} [defaultOptions={}]
+ * @param {boolean} [defaultOptions.purgeInvisibleChars]
+ * @param {boolean} [defaultOptions.purgeEmojis]
+ * @param {boolean} [defaultOptions.nukeControls]
+ * @param {boolean} [defaultOptions.keyboardOnlyFilter]
+ * @param {boolean} [defaultOptions.normalizeNewlines]
+ * @param {boolean} [defaultOptions.trimSpacesAroundNewlines]
+ * @param {boolean} [defaultOptions.collapseNewLines]
+ * @param {boolean} [defaultOptions.preserveParagraphs]
+ * @param {boolean} [defaultOptions.collapseSpaces]
+ * @param {boolean} [defaultOptions.finalTrim]
  * @returns {(text: string) => string}
  */
 export function summonSanctifier(defaultOptions = {}) {
-    const p = !!defaultOptions.preserveParagraphs;
-    const c = !!defaultOptions.collapseSpaces;
-    const n = !!defaultOptions.nukeControls;
-    const e = !!defaultOptions.purgeEmojis;
-    const k = !!defaultOptions.keyboardOnlyFilter;
-
-    return text => sanctifyText(text, p, c, n, e, k);
+    const purgeInvisibleChars = !!defaultOptions.purgeInvisibleChars;
+    const purgeEmojis = !!defaultOptions.purgeEmojis;
+    const nukeControls = !!defaultOptions.nukeControls;
+    const keyboardOnlyFilter = !!defaultOptions.keyboardOnlyFilter;
+    const normalizeNewlines = !!defaultOptions.normalizeNewlines;
+    const trimSpacesAroundNewlines = !!defaultOptions.trimSpacesAroundNewlines;
+    const collapseNewLines = !!defaultOptions.collapseNewLines;
+    const preserveParagraphs = !!defaultOptions.preserveParagraphs;
+    const collapseSpaces = !!defaultOptions.collapseSpaces;
+    const finalTrim = !!defaultOptions.finalTrim;
+
+    return text => sanctifyText(
+        text,
+        purgeInvisibleChars,
+        purgeEmojis,
+        nukeControls,
+        keyboardOnlyFilter,
+        normalizeNewlines,
+        trimSpacesAroundNewlines,
+        collapseNewLines,
+        preserveParagraphs,
+        collapseSpaces,
+        finalTrim
+    );
 }
 
-
 // --- Added Presets ---
 
 /**
  * Strict sanitizer:
- * - Collapse spaces
+ * - Purge emojis
  * - Collapse all newlines
+ * - Collapse spaces
  * - Nuke control characters
  */
-summonSanctifier.strict = text => sanctifyText(text, false, true, true, true);
+summonSanctifier.strict = text => sanctifyText(
+    text,
+    true,   // purgeInvisibleChars
+    true,   // purgeEmojis
+    true,   // nukeControls
+    false,  // keyboardOnlyFilter
+    true,   // normalizeNewlines
+    true,   // trimSpacesAroundNewlines
+    true,   // collapseNewLines
+    false,  // preserveParagraphs
+    true,   // collapseSpaces
+    true    // finalTrim
+);
 
 
 /**
  * Loose sanitizer:
  * - Collapse spaces
  * - Preserve paragraphs
- * - Skip nuking control characters
+ * - Normalize newlines
  */
-summonSanctifier.loose = text => sanctifyText(text, true, true);
+summonSanctifier.loose = text => sanctifyText(
+    text,
+    false,  // purgeInvisibleChars
+    false,  // purgeEmojis
+    false,  // nukeControls
+    false,  // keyboardOnlyFilter
+    true,   // normalizeNewlines
+    true,   // trimSpacesAroundNewlines
+    true,   // collapseNewLines
+    true,   // preserveParagraphs
+    true,   // collapseSpaces
+    true    // finalTrim
+);
 
 
 /**
  * Keyboard-only (with emojis):
- * - Keeps emojis and printable ASCII.
- * - Normalizes typographic trash (quotes, dashes, etc.)
- * - Strips non-standard characters.
- * - Keeps spacing soft (spaces not collapsed).
+ * - Keeps emojis and printable ASCII
+ * - Strips non-standard characters
+ * - Normalizes typographic trash
  */
-summonSanctifier.keyboardOnlyEmoji = text =>
-    sanctifyText(text, false, false, true, false, true);
+summonSanctifier.keyboardOnlyEmoji = text => sanctifyText(
+    text,
+    false,  // purgeInvisibleChars
+    false,  // purgeEmojis
+    false,  // nukeControls
+    true,   // keyboardOnlyFilter
+    true,   // normalizeNewlines
+    true,   // trimSpacesAroundNewlines
+    false,  // collapseNewLines
+    false,  // preserveParagraphs
+    false,  // collapseSpaces
+    true    // finalTrim
+);
 
 
 /**
-* Keyboard-only (strict):
-* - No emojis.
-* - Collapses whitespace.
-* - Keeps only printable ASCII.
-*/
-summonSanctifier.keyboardOnly = text =>
-    sanctifyText(text, false, true, true, true, true);
-
-
+ * Keyboard-only (strict):
+ * - Removes emojis
+ * - Collapses all whitespace
+ * - Restricts to printable ASCII only
+ */
+summonSanctifier.keyboardOnly = text => sanctifyText(
+    text,
+    true,  // purgeInvisibleChars
+    true,   // purgeEmojis
+    true,   // nukeControls
+    true,   // keyboardOnlyFilter
+    true,   // normalizeNewlines
+    true,   // trimSpacesAroundNewlines
+    true,   // collapseNewLines
+    false,  // preserveParagraphs
+    true,   // collapseSpaces
+    true    // finalTrim
+);
 
 
 /**
@@ -82,70 +154,64 @@ summonSanctifier.keyboardOnly = text =>
  * 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.
- * @param {boolean} [keyboardOnlyFilter=false] - Keep only printable ASCII and emoji characters.
+ * @param {boolean} [purgeInvisibleChars=false] - Remove ZWSP, NBSP, bidi, etc.
+ * @param {boolean} [purgeEmojis=false] - Remove emoji characters entirely.
+ * @param {boolean} [nukeControls=false] - Remove non-whitespace control characters.
+ * @param {boolean} [keyboardOnlyFilter=false] - Keep printable ASCII and emojis only.
+ * @param {boolean} [normalizeNewlines=false] - Convert all newlines to `\n`.
+ * @param {boolean} [trimSpacesAroundNewlines=false] - Remove spaces/tabs around newlines.
+ * @param {boolean} [collapseNewLines=false] - Collapse `\n` runs (optionally preserve paragraphs).
+ * @param {boolean} [preserveParagraphs=false] - Preserve paragraph breaks when collapsing newlines.
+ * @param {boolean} [collapseSpaces=false] - Collapse multiple spaces into one.
+ * @param {boolean} [finalTrim=false] - `.trim()` the final output (head/tail).
  * @returns {string}
  */
 export function sanctifyText(
     text,
+    purgeInvisibleChars = false,
+    purgeEmojis = false,
+    nukeControls = false,
+    keyboardOnlyFilter = false,
+    normalizeNewlines = false,
+    trimSpacesAroundNewlines = false,
+    collapseNewLines = false,
     preserveParagraphs = false,
     collapseSpaces = false,
-    nukeControls = false,
-    purgeEmojis = false,
-    keyboardOnlyFilter = false
+    finalTrim = 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);
+    //  Purge invisible Unicode trash (zero-width, non-breaking, bidi junk, etc.)
+    if (purgeInvisibleChars) cleaned = purgeInvisibleTrash(cleaned);
 
-    // Optionally, remove emojis
-    if (purgeEmojis) {
-        cleaned = purgeEmojisCharacters(cleaned);
-    }
+    // Remove emojis
+    if (purgeEmojis) cleaned = purgeEmojisCharacters(cleaned);
 
-    // Optionally, nuke control characters (excluding whitespace)
-    if (nukeControls) {
-        cleaned = purgeControlCharacters(cleaned);
-    }
-
-
-    if (keyboardOnlyFilter) {
-        cleaned = purgeNonKeyboardChars(cleaned, purgeEmojis);
-    }
+    // Nuke control characters (excluding whitespace)
+    if (nukeControls) cleaned = purgeControlCharacters(cleaned);
 
+    // Keep only ASCII/emojis
+    if (keyboardOnlyFilter) cleaned = purgeNonKeyboardChars(cleaned, purgeEmojis);
 
     // Normalize line endings to Unix style (\n)
-    cleaned = normalizeNewlines(cleaned);
+    if (normalizeNewlines) cleaned = normalizeNewlineChars(cleaned);
 
     // Remove spaces/tabs around newlines
-    cleaned = trimSpacesAroundNewlines(cleaned);
+    if (trimSpacesAroundNewlines) cleaned = trimSpacesAroundNewlineChars(cleaned);
 
     // Collapse excessive newlines, Optionally preserve Paragraphs
-    cleaned = collapseParagraphs(cleaned, preserveParagraphs);
+    if (collapseNewLines) cleaned = collapseMultipleNewLines(cleaned, preserveParagraphs);
 
-    // Optionally, Collapse multiple spaces into a single space
-    if (collapseSpaces) {
-        cleaned = collapseExtraSpaces(cleaned);
-    }
+    // Collapse multiple spaces into a single space
+    if (collapseSpaces) cleaned = collapseExtraSpaces(cleaned);
 
-    // Final trim
-    return cleaned.trim();
+    // Final trim, return Sanctified Text
+    return finalTrim ? cleaned.trim() : cleaned;
 }
 
 
@@ -268,7 +334,7 @@ function purgeEmojisCharacters(text) {
  * @returns {string}
  */
 const NORMALIZE_NEWLINES_REGEX = /\r\n|\r|\n/g;
-function normalizeNewlines(text, normalized = '\n') {
+function normalizeNewlineChars(text, normalized = '\n') {
     return text.replace(NORMALIZE_NEWLINES_REGEX, normalized);
 }
 
@@ -284,7 +350,7 @@ function normalizeNewlines(text, normalized = '\n') {
  * @returns {string}
  */
 const TRIM_SPACES_AROUND_NEWLINES_REGEX = /[ \t]*(\n+)[ \t]*/g;
-function trimSpacesAroundNewlines(text) {
+function trimSpacesAroundNewlineChars(text) {
     return text.replace(TRIM_SPACES_AROUND_NEWLINES_REGEX, '$1');
 }
 
@@ -307,7 +373,7 @@ function trimSpacesAroundNewlines(text) {
 const MULTIPLE_NEWLINES_REGEX = /\n{2,}/g;
 const TRIPLE_NEWLINES_REGEX = /\n{3,}/g;
 
-function collapseParagraphs(text, preserveParagraphs) {
+function collapseMultipleNewLines(text, preserveParagraphs) {
     return preserveParagraphs
         ? text.replace(TRIPLE_NEWLINES_REGEX, '\n\n')
         : text.replace(MULTIPLE_NEWLINES_REGEX, '\n');