text-sanctifier 1.3.9 → 1.3.11

package/dist/types/sanctifyText.d.ts

@@ -68,7 +68,7 @@ export function sanctifyPasted(text: string): string;
  * @param {number} [maxLength=Infinity] - Hard input length cap (UTF-16 code units via `text.length`).
  * @param {'throw'|'truncate'|'noop'} [onMaxLength='throw'] - Behavior when `text.length` exceeds `maxLength`:
  *   - `'throw'`: throw a `RangeError`
- *   - `'truncate'`: slice to `maxLength` before processing
+ *   - `'truncate'`: slice to at most `maxLength` before processing, never through a surrogate pair
  *   - `'noop'`: return the original input unchanged (skips processing)
  * @param {boolean} [normalizeSpaces=false] - Replace look-alike spaces with an ordinary space. Runs first,
  *   so `purgeInvisibleChars` no longer joins the words around them.

package/dist/types/version.generated.d.ts

@@ -1,2 +1,2 @@
 /** The installed version of text-sanctifier, as in its package.json. */
-export const VERSION: "1.3.9";
+export const VERSION: "1.3.11";

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "text-sanctifier",
-  "version": "1.3.9",
+  "version": "1.3.11",
   "type": "module",
-  "description": "A brutal text normalizer and invisible trash scrubber for modern web projects.",
+  "description": "Find and remove invisible Unicode in web input, model-bound text and repositories.",
   "engines": {
     "node": ">=18"
   },
@@ -48,15 +48,17 @@
     "build": "node scripts/build.js",
     "build:types": "tsc -p tsconfig.types.json",
     "test:types": "tsc -p tests/types/tsconfig.json",
-    "test": "node tests/sanctifyText.test.js && node tests/inspectTextDetailed.test.js && node --expose-gc tests/hiddenText.test.js && node --expose-gc tests/context.test.js && node tests/cli.test.js && node tests/release.test.js",
+    "test": "node tests/sanctifyText.test.js && node tests/inspectTextDetailed.test.js && node --expose-gc tests/hiddenText.test.js && node --expose-gc tests/context.test.js && node tests/cli.test.js && node tests/release.test.js && node tests/names.test.js && node tests/docs.test.js && node tests/repo.test.js",
     "test-min": "node tests/sanctifyText.test.min.js",
     "check:self": "node bin/text-sanctifier.js check .",
     "check:names": "node scripts/check-names.js",
-    "ci": "npm run gen:check && npm run check:names && npm run check:self && npm run test && npm run build && npm run size && npm run build:types && npm run test:types && npm run test-min",
+    "check:repo": "node scripts/check-repo.js",
+    "ci": "npm run gen:check && npm run check:names && npm run check:repo && npm run check:self && npm run test && npm run build && npm run size && npm run build:types && npm run test:types && npm run test-min",
     "size": "node scripts/check-size.js",
     "bench": "node --expose-gc scripts/bench.js",
     "release:prep": "node scripts/release.js prep",
     "release:verify": "node scripts/release.js verify",
+    "prepublishOnly": "node scripts/release.js check-publish",
     "hooks:install": "git config core.hooksPath scripts/hooks"
   },
   "keywords": [
@@ -83,7 +85,7 @@
     "test": "tests"
   },
   "devDependencies": {
-    "esbuild": "^0.25.3",
-    "typescript": "^5.9.3"
+    "esbuild": "0.25.12",
+    "typescript": "5.9.3"
   }
 }

package/src/hiddenScan.js

@@ -0,0 +1,171 @@
+// Internal hidden-span scanner; not a package entry point.
+
+/**
+ * @typedef {import('./hiddenText.js').HiddenRunKind} HiddenRunKind
+ * @typedef {import('./hiddenText.js').HiddenRun} HiddenRun
+ * @typedef {import('./hiddenText.js').HiddenRunCounts} HiddenRunCounts
+ * @typedef {import('./hiddenText.js').HiddenTextScan} HiddenTextScan
+ * @typedef {import('./hiddenText.js').HiddenScanOptions} HiddenScanOptions
+ */
+
+const TAG_FIRST = 0xE0000;
+const TAG_LAST = 0xE007F;
+const CANCEL_TAG = 0xE007F;
+const BLACK_FLAG = 0x1F3F4;
+
+// RGI subdivision flags: U+1F3F4, the tag letters, U+E007F
+const SUBDIVISION_FLAGS = new Set(['gbeng', 'gbsct', 'gbwls']);
+
+/**
+ * @param {number} cp
+ * @returns {HiddenRunKind | null}
+ */
+function kindOf(cp) {
+    if (cp >= TAG_FIRST && cp <= TAG_LAST) return 'tag';
+    if ((cp >= 0xFE00 && cp <= 0xFE0F) || (cp >= 0xE0100 && cp <= 0xE01EF) ||
+        (cp >= 0x180B && cp <= 0x180D) || cp === 0x180F) return 'variation_selector';
+    if (cp >= 0x2061 && cp <= 0x2064) return 'invisible_operator';
+    // Unassigned and default ignorable: U+E0080-U+E00FF and U+E01F0-U+E0FFF
+    if (cp >= 0xE0080 && cp <= 0xE0FFF) return 'reserved_tag_plane';
+    return null;
+}
+
+/** @param {number} cp */
+const hex = (cp) => 'U+' + cp.toString(16).toUpperCase().padStart(4, '0');
+
+/**
+ * Decodes text[start, end) as decodeTagText does, stopping before the output would
+ * pass `limit` UTF-16 units. A `<U+XXXX>` marker is written whole or not at all.
+ * @param {string} text
+ * @param {number} start
+ * @param {number} end
+ * @param {number} limit
+ * @returns {{ decoded: string, truncated: boolean }}
+ */
+export function decodeRange(text, start, end, limit) {
+    let out = '';
+    let i = start;
+    while (i < end) {
+        const cp = /** @type {number} */ (text.codePointAt(i));
+        const piece = cp >= 0xE0020 && cp <= 0xE007E ? String.fromCharCode(cp - TAG_FIRST) : `<${hex(cp)}>`;
+        if (out.length + piece.length > limit) return { decoded: out, truncated: true };
+        out += piece;
+        i += cp > 0xFFFF ? 2 : 1;
+    }
+    return { decoded: out, truncated: false };
+}
+
+// Tested at an index of the text itself, so the check allocates nothing.
+const PICTOGRAPHIC_AT = /\p{Extended_Pictographic}/yu;
+
+/**
+ * True when a presentation selector at `index` follows an emoji-capable character:
+ * an Extended_Pictographic code point, or a keycap base (#, * or a digit) with U+20E3 after.
+ * @param {string} text
+ * @param {number} index
+ * @returns {boolean}
+ */
+function isPresentationBase(text, index) {
+    if (index === 0) return false;
+    const low = text.charCodeAt(index - 1);
+    const p = low >= 0xDC00 && low <= 0xDFFF && index >= 2 &&
+        (text.charCodeAt(index - 2) & 0xFC00) === 0xD800 ? index - 2 : index - 1;
+    const before = text.charCodeAt(p);
+    if ((before === 0x23 || before === 0x2A || (before >= 0x30 && before <= 0x39)) && text.charCodeAt(index + 1) === 0x20E3) return true;
+    PICTOGRAPHIC_AT.lastIndex = p;
+    return PICTOGRAPHIC_AT.test(text);
+}
+
+/**
+ * A cap option: a non-negative integer or Infinity; anything else means no cap.
+ * @param {unknown} value
+ * @returns {number}
+ */
+function cap(value) {
+    return typeof value === 'number' && (value === Infinity || (Number.isInteger(value) && value >= 0))
+        ? value
+        : Infinity;
+}
+
+/**
+ * @param {string} text
+ * @param {HiddenScanOptions} [options]
+ * @param {(span: {offset: number, end: number, benign: boolean, kind: HiddenRunKind}) => void} [onSpan] - internal streaming visitor
+ * @returns {HiddenTextScan}
+ */
+export function scanHiddenSpans(text, options = {}, onSpan) {
+    if (typeof text !== 'string') throw new TypeError('findHiddenRuns expects a string input.');
+    const maxRuns = cap(options && options.maxRuns);
+    const maxDecodedLength = cap(options && options.maxDecodedLength);
+
+    /** @type {HiddenRun[]} */
+    const runs = [];
+    /** @type {Array<[number, number]>} */
+    const benign = [];
+    /** @type {HiddenRunCounts} */
+    const counts = { tag: 0, variation_selector: 0, invisible_operator: 0, reserved_tag_plane: 0 };
+    /** @type {HiddenRunCounts} */
+    const codePointCounts = { tag: 0, variation_selector: 0, invisible_operator: 0, reserved_tag_plane: 0 };
+    let supplementarySelectorCount = 0;
+    let total = 0;
+    let benignTotal = 0;
+    let line = 1;
+    let lineStart = 0;
+
+    let i = 0;
+    while (i < text.length) {
+        const cp = /** @type {number} */ (text.codePointAt(i));
+        const kind = kindOf(cp);
+        if (kind === null) {
+            if (cp === 0x0A || (cp === 0x0D && text.charCodeAt(i + 1) !== 0x0A)) { // CRLF ends at its LF
+                line++;
+                lineStart = i + 1;
+            }
+            i += cp > 0xFFFF ? 2 : 1;
+            continue;
+        }
+
+        const offset = i;
+        let count = 0;
+        let supplementary = 0;
+        let last = cp;
+        while (i < text.length) {
+            const c = /** @type {number} */ (text.codePointAt(i));
+            if (kindOf(c) !== kind) break;
+            last = c;
+            count++;
+            if (c >= 0xE0100 && c <= 0xE01EF) supplementary++;
+            i += c > 0xFFFF ? 2 : 1;
+        }
+        const end = i;
+
+        // A subdivision flag is exactly five tag letters and CANCEL TAG after U+1F3F4.
+        const isBenign = kind === 'tag'
+            ? count === 6 && last === CANCEL_TAG && offset >= 2 && text.codePointAt(offset - 2) === BLACK_FLAG &&
+              SUBDIVISION_FLAGS.has(decodeRange(text, offset, end - 2, Infinity).decoded)
+            : kind === 'variation_selector' && count === 1 && (cp === 0xFE0E || cp === 0xFE0F) &&
+              isPresentationBase(text, offset);
+        if (onSpan) onSpan({ offset, end, benign: isBenign, kind });
+        if (isBenign) {
+            benignTotal++;
+            if (benign.length < maxRuns) benign.push([offset, end]);
+            continue;
+        }
+
+        counts[kind]++;
+        codePointCounts[kind] += count;
+        supplementarySelectorCount += supplementary;
+        total++;
+        if (runs.length < maxRuns) {
+            /** @type {HiddenRun} */
+            const run = { kind, offset, end, line, column: offset - lineStart + 1, count };
+            if (kind === 'tag') {
+                const { decoded, truncated } = decodeRange(text, offset, end, maxDecodedLength);
+                run.decoded = decoded;
+                run.decodedTruncated = truncated;
+            }
+            runs.push(run);
+        }
+    }
+    return { runs, benign, counts, codePointCounts, supplementarySelectorCount, total, benignTotal, truncated: total > runs.length || benignTotal > benign.length };
+}

package/src/hiddenText.js

@@ -9,6 +9,8 @@
 // Plain JavaScript with no Node APIs, so it also runs in a browser. src/index.js does
 // not import this file, so it stays out of the browser bundle and its size budget.
 
+import { scanHiddenSpans, decodeRange } from './hiddenScan.js';
+
 export { VERSION } from './version.generated.js';
 
 /** @typedef {'tag' | 'variation_selector' | 'invisible_operator' | 'reserved_tag_plane'} HiddenRunKind */
@@ -56,31 +58,6 @@ export { VERSION } from './version.generated.js';
  *   For both, any other value (negative, fractional, NaN, a string) means the default, no cap.
  */
 
-const TAG_FIRST = 0xE0000;
-const TAG_LAST = 0xE007F;
-const CANCEL_TAG = 0xE007F;
-const BLACK_FLAG = 0x1F3F4;
-
-// RGI subdivision flags: U+1F3F4, the tag letters, U+E007F
-const SUBDIVISION_FLAGS = new Set(['gbeng', 'gbsct', 'gbwls']);
-
-/**
- * @param {number} cp
- * @returns {HiddenRunKind | null}
- */
-function kindOf(cp) {
-    if (cp >= TAG_FIRST && cp <= TAG_LAST) return 'tag';
-    if ((cp >= 0xFE00 && cp <= 0xFE0F) || (cp >= 0xE0100 && cp <= 0xE01EF) ||
-        (cp >= 0x180B && cp <= 0x180D) || cp === 0x180F) return 'variation_selector';
-    if (cp >= 0x2061 && cp <= 0x2064) return 'invisible_operator';
-    // Unassigned and default ignorable: U+E0080-U+E00FF and U+E01F0-U+E0FFF
-    if (cp >= 0xE0080 && cp <= 0xE0FFF) return 'reserved_tag_plane';
-    return null;
-}
-
-/** @param {number} cp */
-const hex = (cp) => 'U+' + cp.toString(16).toUpperCase().padStart(4, '0');
-
 /**
  * Decodes tag characters to the ASCII they shadow: U+E0020–U+E007E become
  * U+0020–U+007E. Anything else (U+E0001 LANGUAGE TAG, U+E007F CANCEL TAG, unassigned
@@ -89,63 +66,10 @@ const hex = (cp) => 'U+' + cp.toString(16).toUpperCase().padStart(4, '0');
  * @returns {string}
  */
 export function decodeTagText(text) {
+    if (typeof text !== 'string') throw new TypeError('decodeTagText expects a string input.');
     return decodeRange(text, 0, text.length, Infinity).decoded;
 }
 
-/**
- * Decodes text[start, end) as decodeTagText does, stopping before the output would
- * pass `limit` UTF-16 units. A `<U+XXXX>` marker is written whole or not at all.
- * @param {string} text
- * @param {number} start
- * @param {number} end
- * @param {number} limit
- * @returns {{ decoded: string, truncated: boolean }}
- */
-function decodeRange(text, start, end, limit) {
-    let out = '';
-    let i = start;
-    while (i < end) {
-        const cp = /** @type {number} */ (text.codePointAt(i));
-        const piece = cp >= 0xE0020 && cp <= 0xE007E ? String.fromCharCode(cp - TAG_FIRST) : `<${hex(cp)}>`;
-        if (out.length + piece.length > limit) return { decoded: out, truncated: true };
-        out += piece;
-        i += cp > 0xFFFF ? 2 : 1;
-    }
-    return { decoded: out, truncated: false };
-}
-
-// Tested at an index of the text itself, so the check allocates nothing.
-const PICTOGRAPHIC_AT = /\p{Extended_Pictographic}/yu;
-
-/**
- * True when a presentation selector at `index` follows an emoji-capable character:
- * an Extended_Pictographic code point, or a keycap base (#, * or a digit) with U+20E3 after.
- * @param {string} text
- * @param {number} index
- * @returns {boolean}
- */
-function isPresentationBase(text, index) {
-    if (index === 0) return false;
-    const low = text.charCodeAt(index - 1);
-    const p = low >= 0xDC00 && low <= 0xDFFF && index >= 2 &&
-        (text.charCodeAt(index - 2) & 0xFC00) === 0xD800 ? index - 2 : index - 1;
-    const before = text.charCodeAt(p);
-    if ((before === 0x23 || before === 0x2A || (before >= 0x30 && before <= 0x39)) && text.charCodeAt(index + 1) === 0x20E3) return true;
-    PICTOGRAPHIC_AT.lastIndex = p;
-    return PICTOGRAPHIC_AT.test(text);
-}
-
-/**
- * A cap option: a non-negative integer or Infinity; anything else means no cap.
- * @param {unknown} value
- * @returns {number}
- */
-function cap(value) {
-    return typeof value === 'number' && (value === Infinity || (Number.isInteger(value) && value >= 0))
-        ? value
-        : Infinity;
-}
-
 /**
  * Finds runs of tag characters, variation selectors, invisible operators and reserved
  * tag-plane code points (U+E0080–U+E00FF, U+E01F0–U+E0FFF).
@@ -168,76 +92,5 @@ function cap(value) {
  * @returns {HiddenTextScan}
  */
 export function findHiddenRuns(text, options = {}) {
-    const maxRuns = cap(options && options.maxRuns);
-    const maxDecodedLength = cap(options && options.maxDecodedLength);
-
-    /** @type {HiddenRun[]} */
-    const runs = [];
-    /** @type {Array<[number, number]>} */
-    const benign = [];
-    /** @type {HiddenRunCounts} */
-    const counts = { tag: 0, variation_selector: 0, invisible_operator: 0, reserved_tag_plane: 0 };
-    /** @type {HiddenRunCounts} */
-    const codePointCounts = { tag: 0, variation_selector: 0, invisible_operator: 0, reserved_tag_plane: 0 };
-    let supplementarySelectorCount = 0;
-    let total = 0;
-    let benignTotal = 0;
-    let line = 1;
-    let lineStart = 0;
-
-    let i = 0;
-    while (i < text.length) {
-        const cp = /** @type {number} */ (text.codePointAt(i));
-        const kind = kindOf(cp);
-        if (kind === null) {
-            if (cp === 0x0A || (cp === 0x0D && text.charCodeAt(i + 1) !== 0x0A)) { // CRLF ends at its LF
-                line++;
-                lineStart = i + 1;
-            }
-            i += cp > 0xFFFF ? 2 : 1;
-            continue;
-        }
-
-        const offset = i;
-        let count = 0;
-        let supplementary = 0;
-        let last = cp;
-        while (i < text.length) {
-            const c = /** @type {number} */ (text.codePointAt(i));
-            if (kindOf(c) !== kind) break;
-            last = c;
-            count++;
-            if (c >= 0xE0100 && c <= 0xE01EF) supplementary++;
-            i += c > 0xFFFF ? 2 : 1;
-        }
-        const end = i;
-
-        // A subdivision flag is exactly five tag letters and CANCEL TAG after U+1F3F4.
-        const isBenign = kind === 'tag'
-            ? count === 6 && last === CANCEL_TAG && offset >= 2 && text.codePointAt(offset - 2) === BLACK_FLAG &&
-              SUBDIVISION_FLAGS.has(decodeRange(text, offset, end - 2, Infinity).decoded)
-            : kind === 'variation_selector' && count === 1 && (cp === 0xFE0E || cp === 0xFE0F) &&
-              isPresentationBase(text, offset);
-        if (isBenign) {
-            benignTotal++;
-            if (benign.length < maxRuns) benign.push([offset, end]);
-            continue;
-        }
-
-        counts[kind]++;
-        codePointCounts[kind] += count;
-        supplementarySelectorCount += supplementary;
-        total++;
-        if (runs.length < maxRuns) {
-            /** @type {HiddenRun} */
-            const run = { kind, offset, end, line, column: offset - lineStart + 1, count };
-            if (kind === 'tag') {
-                const { decoded, truncated } = decodeRange(text, offset, end, maxDecodedLength);
-                run.decoded = decoded;
-                run.decodedTruncated = truncated;
-            }
-            runs.push(run);
-        }
-    }
-    return { runs, benign, counts, codePointCounts, supplementarySelectorCount, total, benignTotal, truncated: total > runs.length || benignTotal > benign.length };
+    return scanHiddenSpans(text, options);
 }

package/src/inspectText.js

@@ -322,16 +322,20 @@ export function getNewlineStats(text) {
 }
 
 /**
- * Creates defaultOptions for summonSanctifier based on inspectText result
+ * Creates defaultOptions for summonSanctifier based on inspectText result.
+ * Recommends only what removes trash without losing meaning: non-ASCII text and emoji are
+ * content, so `purgeEmojis` and `keyboardOnlyFilter` stay opt-in, and look-alike spaces
+ * become ordinary spaces so that words do not run together.
  * @param {!UnicodeTrashReport} report
  * @return {!SanctifyOptions}
  */
 export function getRecommendedSanctifierOptions(report) {
     return {
+        normalizeSpaces: report.hasInvisibleChars,
         purgeInvisibleChars: report.hasInvisibleChars,
-        purgeEmojis: report.hasEmojis,
+        purgeEmojis: false,
         nukeControls: report.hasControlChars,
-        keyboardOnlyFilter: report.hasNonKeyboardChars,
+        keyboardOnlyFilter: false,
         normalizeNewlines:
             report.hasMixedNewlines || report.newlineStyle === 'CRLF' || report.newlineStyle === 'CR',
     };

package/src/sanctifyText.js

@@ -294,7 +294,7 @@ export const summonSanctifier = /* @__PURE__ */ Object.assign(createSanctifier,
  * @param {number} [maxLength=Infinity] - Hard input length cap (UTF-16 code units via `text.length`).
  * @param {'throw'|'truncate'|'noop'} [onMaxLength='throw'] - Behavior when `text.length` exceeds `maxLength`:
  *   - `'throw'`: throw a `RangeError`
- *   - `'truncate'`: slice to `maxLength` before processing
+ *   - `'truncate'`: slice to at most `maxLength` before processing, never through a surrogate pair
  *   - `'noop'`: return the original input unchanged (skips processing)
  * @param {boolean} [normalizeSpaces=false] - Replace look-alike spaces with an ordinary space. Runs first,
  *   so `purgeInvisibleChars` no longer joins the words around them.
@@ -324,26 +324,27 @@ export function sanctifyText(
         throw new TypeError('sanctifyText expects a string input.');
     }
 
-    if (onMaxLength !== 'truncate' && onMaxLength !== 'noop' && onMaxLength !== 'throw') {
-        onMaxLength = 'throw';
-    }
-
     if (text.length > maxLength) {
         switch (onMaxLength) {
             case 'truncate':
-                text = text.slice(0, maxLength);
+                {
+                    // Cut before a surrogate pair, not through it
+                    const last = text.charCodeAt(maxLength - 1);
+                    text = text.slice(0, last >= 0xD800 && last <= 0xDBFF ? maxLength - 1 : maxLength);
+                }
                 break;
             case 'noop':
                 return text;
-            case 'throw':
-            default:
+            default: // 'throw', and any invalid value
                 throw new RangeError(
                     `sanctifyText input length ${text.length} exceeds maxLength ${maxLength}.`
                 );
         }
     }
 
-    let cleaned = text;
+    // Unpaired surrogates become U+FFFD first, so removing a character between two
+    // halves cannot join them into a new character, such as a hidden tag.
+    let cleaned = text.replace(LONE_SURROGATES_REGEX, '\uFFFD');
 
     // Look-alike spaces become ordinary spaces, before anything can delete them
     if (normalizeSpaces) cleaned = cleaned.replace(SPACE_LOOKALIKES_REGEX, ' ');
@@ -389,6 +390,9 @@ export function sanctifyText(
  */
 export const SPACE_LOOKALIKES_REGEX = /[\u00A0\u2000-\u200A\u202F\u205F]/g;
 
+/** With the `u` flag a surrogate pair is one character, so this matches only unpaired halves. */
+const LONE_SURROGATES_REGEX = /[\uD800-\uDFFF]/gu;
+
 /** Zero-width space, word joiner and BOM: invisible and never needed in plain text. */
 export const ZERO_WIDTH_SPACES_REGEX = /[\u200B\u2060\uFEFF]/g;
 
@@ -497,9 +501,11 @@ function normalizeNewlineChars(text, normalized = '\n') {
  * @param {string} text
  * @returns {string}
  */
-const TRIM_SPACES_AROUND_NEWLINES_REGEX = /[ \t]*(\n+)[ \t]*/g;
+// The second branch consumes a run with no newline after it, so matching resumes past the
+// run instead of retrying from each of its characters, which took quadratic time.
+const TRIM_SPACES_AROUND_NEWLINES_REGEX = /[ \t]*(\n+)[ \t]*|([ \t]+)/g;
 function trimSpacesAroundNewlineChars(text) {
-    return text.replace(TRIM_SPACES_AROUND_NEWLINES_REGEX, '$1');
+    return text.replace(TRIM_SPACES_AROUND_NEWLINES_REGEX, '$1$2');
 }
 
 

package/src/version.generated.js

@@ -2,4 +2,4 @@
 // Generated from package.json by scripts/gen-version.js (`npm run gen`); do not edit.
 
 /** The installed version of text-sanctifier, as in its package.json. */
-export const VERSION = '1.3.9';
+export const VERSION = '1.3.11';

package/src/index.d.ts

@@ -1,22 +0,0 @@
-import { inspectText } from './inspectText.js';
-import { inspectTextDetailed } from './inspectText.js';
-import { getNewlineStats } from './inspectText.js';
-import { getRecommendedSanctifierOptions } from './inspectText.js';
-import { summonSanctifier } from './sanctifyText.js';
-import { sanctifyStrict } from './sanctifyText.js';
-import { sanctifyLoose } from './sanctifyText.js';
-import { sanctifyKeyboardOnlyEmoji } from './sanctifyText.js';
-import { sanctifyKeyboardOnly } from './sanctifyText.js';
-import { sanctifyPasted } from './sanctifyText.js';
-import { revealInvisible } from './reveal.js';
-import { VERSION } from './version.generated.js';
-export { inspectText, inspectTextDetailed, getNewlineStats, getRecommendedSanctifierOptions, summonSanctifier, sanctifyStrict, sanctifyLoose, sanctifyKeyboardOnlyEmoji, sanctifyKeyboardOnly, sanctifyPasted, revealInvisible, VERSION };
-export type UnicodeTrashReport = import('./inspectText.js').UnicodeTrashReport;
-export type TrashCategory = import('./inspectText.js').TrashCategory;
-export type TrashFinding = import('./inspectText.js').TrashFinding;
-export type TrashCounts = import('./inspectText.js').TrashCounts;
-export type DetailedTrashReport = import('./inspectText.js').DetailedTrashReport;
-export type InspectDetailedOptions = import('./inspectText.js').InspectDetailedOptions;
-export type NewlineStats = import('./inspectText.js').NewlineStats;
-export type SanctifyOptions = import('./sanctifyText.js').SanctifyOptions;
-export type RevealOptions = import('./reveal.js').RevealOptions;