text-sanctifier 1.3.5 → 1.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "text-sanctifier",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "type": "module",
   "description": "A brutal text normalizer and invisible trash scrubber for modern web projects.",
   "engines": {
@@ -31,6 +31,10 @@
       "types": "./dist/types/hiddenText.d.ts",
       "default": "./src/hiddenText.js"
     },
+    "./context": {
+      "types": "./dist/types/context.d.ts",
+      "default": "./src/context.js"
+    },
     "./browser": {
       "types": "./dist/types/index.d.ts",
       "default": "./dist/text-sanctifier.min.js"
@@ -39,12 +43,12 @@
   "types": "./dist/types/index.d.ts",
   "sideEffects": false,
   "scripts": {
-    "gen": "node scripts/gen-categories.js",
-    "gen:check": "node scripts/gen-categories.js --check",
+    "gen": "node scripts/gen-categories.js && node scripts/gen-version.js",
+    "gen:check": "node scripts/gen-categories.js --check && node scripts/gen-version.js --check",
     "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 tests/cli.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",
     "test-min": "node tests/sanctifyText.test.min.js",
     "ci": "npm run gen:check && 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"

package/src/context.js

@@ -0,0 +1,177 @@
+// src/context.js
+//
+// inspectTextInContext: inspectTextDetailed plus which findings belong to legitimate
+// sequences (emoji joiners and selectors, ideographic variation sequences, Mongolian
+// selectors, subdivision flags), counted exactly per category. The categories are
+// unchanged; see "Proposal: context-aware findings" in DESIGN.md.
+//
+// Exported as `text-sanctifier/context`. It needs Unicode property escapes in regexes,
+// so it lives apart from the core and the browser file and has its own size budget.
+
+import { inspectTextDetailed } from './inspectText.js';
+
+/** @typedef {import('./inspectText.js').TrashFinding} TrashFinding */
+/** @typedef {import('./inspectText.js').TrashCounts} TrashCounts */
+/** @typedef {import('./inspectText.js').InspectDetailedOptions} InspectDetailedOptions */
+
+/**
+ * @typedef {TrashFinding & { benign: boolean }} ContextFinding
+ * A finding with `benign`: true when the character is part of a legitimate sequence.
+ */
+
+/**
+ * @typedef {Object} ContextReport
+ * @property {ContextFinding[]} findings - As in inspectTextDetailed, each with `benign`.
+ * @property {TrashCounts} counts - As in inspectTextDetailed: every occurrence, benign or not.
+ * @property {number} total - Sum of `counts`.
+ * @property {boolean} truncated - True when `total` exceeds `findings.length`.
+ * @property {TrashCounts} benignCounts - Benign occurrences per category, listed or not.
+ *   `counts[c] - benignCounts[c]` is the number of suspicious characters in category `c`.
+ * @property {number} benignTotal - Sum of `benignCounts`.
+ */
+
+// Tested at an index of the text itself, so nothing is allocated per character.
+const PICTOGRAPHIC_AT = /\p{Extended_Pictographic}/yu;
+const IDEOGRAPHIC_AT = /\p{Ideographic}/yu;
+
+// RGI subdivision flags: U+1F3F4, the tag letters, U+E007F
+const SUBDIVISION_FLAGS = ['gbeng', 'gbsct', 'gbwls'];
+
+/**
+ * @param {RegExp} re - sticky
+ * @param {string} text
+ * @param {number} index
+ */
+function matchesAt(re, text, index) {
+    re.lastIndex = index;
+    return re.test(text);
+}
+
+/**
+ * Index where the code point that ends just before `index` starts, or -1.
+ * @param {string} text
+ * @param {number} index
+ */
+function previousStart(text, index) {
+    if (index <= 0) return -1;
+    const low = text.charCodeAt(index - 1);
+    if (low >= 0xDC00 && low <= 0xDFFF && index >= 2) {
+        const high = text.charCodeAt(index - 2);
+        if (high >= 0xD800 && high <= 0xDBFF) return index - 2;
+    }
+    return index - 1;
+}
+
+/** @param {number} c */
+const isMongolianLetter = (c) =>
+    (c >= 0x1820 && c <= 0x1878) || (c >= 0x1880 && c <= 0x1884) || (c >= 0x1887 && c <= 0x18A8) || c === 0x18AA;
+
+/**
+ * A U+200D is benign between two Extended_Pictographic code points, allowing a
+ * skin-tone modifier or VS16 after the first.
+ * @param {string} text
+ * @param {number} i - index of the U+200D
+ */
+function isEmojiJoiner(text, i) {
+    let p = previousStart(text, i);
+    if (p < 0) return false;
+    const before = /** @type {number} */ (text.codePointAt(p));
+    if (before === 0xFE0F || (before >= 0x1F3FB && before <= 0x1F3FF)) p = previousStart(text, p);
+    return p >= 0 && matchesAt(PICTOGRAPHIC_AT, text, p) && matchesAt(PICTOGRAPHIC_AT, text, i + 1);
+}
+
+/**
+ * Length in UTF-16 units of the subdivision-flag tags starting at `i` (just after a
+ * U+1F3F4), or 0 when they are not exactly one of the RGI flags, as findHiddenRuns decides.
+ * @param {string} text
+ * @param {number} i
+ */
+function flagTagsAt(text, i) {
+    // five tag letters and CANCEL TAG, each a surrogate pair
+    if (text.charCodeAt(i + 10) !== 0xDB40 || text.charCodeAt(i + 11) !== 0xDC7F) return 0;
+    // more tags after CANCEL TAG make it one longer tag run, which is not a flag
+    const after = text.charCodeAt(i + 13);
+    if (text.charCodeAt(i + 12) === 0xDB40 && after >= 0xDC00 && after <= 0xDC7F) return 0;
+    let letters = '';
+    for (let k = 0; k < 10; k += 2) {
+        const low = text.charCodeAt(i + k + 1);
+        if (text.charCodeAt(i + k) !== 0xDB40 || low < 0xDC61 || low > 0xDC7A) return 0; // tag a-z
+        letters += String.fromCharCode(low - 0xDC00);
+    }
+    return SUBDIVISION_FLAGS.includes(letters) ? 12 : 0;
+}
+
+/**
+ * Locates invisible and control characters as inspectTextDetailed does, and marks
+ * the ones that belong to legitimate sequences as benign:
+ * - U+200D between two emoji (Extended_Pictographic), allowing a skin-tone modifier or
+ *   VS16 after the first: an emoji ZWJ sequence
+ * - U+FE0E or U+FE0F directly after an emoji, or between 0-9, # or * and U+20E3 (keycap)
+ * - one of U+E0100–U+E01EF directly after an ideograph: an ideographic variation sequence
+ * - U+180B–U+180D or U+180F directly after a Mongolian letter
+ * - the tags of the England, Scotland and Wales flags after U+1F3F4
+ * Nothing else is benign: not U+200B, U+2060, U+FEFF, bidi controls or other tags.
+ *
+ * `counts`, `total` and `truncated` are exactly those of inspectTextDetailed;
+ * `benignCounts` counts every benign character, listed or not. Two passes over the
+ * string, no copy; memory is flat with `maxFindings` set.
+ *
+ * @param {string} text
+ * @param {InspectDetailedOptions} [options]
+ * @returns {ContextReport}
+ */
+export function inspectTextInContext(text, options = {}) {
+    if (typeof text !== 'string') {
+        throw new TypeError('inspectTextInContext expects a string input.');
+    }
+    const report = inspectTextDetailed(text, options);
+    const findings = /** @type {ContextFinding[]} */ (report.findings);
+    for (const f of findings) f.benign = false;
+
+    /** @type {TrashCounts} */
+    const benignCounts = /** @type {TrashCounts} */ ({});
+    for (const key of Object.keys(report.counts)) benignCounts[/** @type {keyof TrashCounts} */ (key)] = 0;
+    let benignTotal = 0;
+    let next = 0; // first listed finding not yet passed
+
+    /**
+     * @param {number} offset
+     * @param {keyof TrashCounts} category
+     */
+    const markBenign = (offset, category) => {
+        benignCounts[category]++;
+        benignTotal++;
+        while (next < findings.length && findings[next].offset < offset) next++;
+        if (next < findings.length && findings[next].offset === offset) findings[next].benign = true;
+    };
+
+    for (let i = 0, n = text.length; i < n; i++) {
+        const c = text.charCodeAt(i);
+        if (c < 0x180B) continue; // the common case: nothing below can be benign
+
+        if (c === 0x200D) {
+            if (isEmojiJoiner(text, i)) markBenign(i, 'zero_width');
+        } else if (c === 0xFE0E || c === 0xFE0F) {
+            const p = previousStart(text, i);
+            const before = p < 0 ? -1 : text.charCodeAt(p);
+            const keycap = (before === 0x23 || before === 0x2A || (before >= 0x30 && before <= 0x39)) &&
+                text.charCodeAt(i + 1) === 0x20E3;
+            if (keycap || (p >= 0 && matchesAt(PICTOGRAPHIC_AT, text, p))) markBenign(i, 'variation_selector');
+        } else if ((c >= 0x180B && c <= 0x180D) || c === 0x180F) {
+            if (isMongolianLetter(text.charCodeAt(i - 1))) markBenign(i, 'variation_selector');
+        } else if (c === 0xD83C && text.charCodeAt(i + 1) === 0xDFF4) { // U+1F3F4
+            const length = flagTagsAt(text, i + 2);
+            for (let k = 0; k < length; k += 2) markBenign(i + 2 + k, 'tag');
+            i += 1 + length;
+        } else if (c === 0xDB40) { // plane 14: U+E0000-U+E03FF
+            const low = text.charCodeAt(i + 1);
+            if (low >= 0xDD00 && low <= 0xDDEF) { // U+E0100-U+E01EF
+                const p = previousStart(text, i);
+                if (p >= 0 && matchesAt(IDEOGRAPHIC_AT, text, p)) markBenign(i, 'variation_selector');
+            }
+            if (low >= 0xDC00 && low <= 0xDFFF) i++;
+        }
+    }
+
+    return { findings, counts: report.counts, total: report.total, truncated: report.truncated, benignCounts, benignTotal };
+}

package/src/hiddenText.js

@@ -1,14 +1,17 @@
 // src/hiddenText.js
 //
 // Finds runs of the characters used to hide instructions in text a model reads:
-// tag characters, variation selectors and invisible operators. Tag runs are decoded
+// tag characters, variation selectors, invisible operators and the reserved code points
+// of the tag plane. Tag runs are decoded
 // to the ASCII they spell. Used by `text-sanctifier check --ai-config`, and exported
 // as `text-sanctifier/hidden`.
 //
 // 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.
 
-/** @typedef {'tag' | 'variation_selector' | 'invisible_operator'} HiddenRunKind */
+export { VERSION } from './version.generated.js';
+
+/** @typedef {'tag' | 'variation_selector' | 'invisible_operator' | 'reserved_tag_plane'} HiddenRunKind */
 
 /**
  * @typedef {Object} HiddenRun
@@ -16,14 +19,41 @@
  * @property {number} offset - UTF-16 index of the first character
  * @property {number} end - UTF-16 index just past the last character
  * @property {number} count - number of code points in the run
- * @property {string} [decoded] - tag runs only: the ASCII the tags spell (see decodeTagText)
+ * @property {number} line - 1-based line of the first character (as in inspectTextDetailed)
+ * @property {number} column - 1-based column of the first character, in UTF-16 units
+ * @property {string} [decoded] - tag runs only: the ASCII the tags spell (see decodeTagText),
+ *   at most `maxDecodedLength` UTF-16 units
+ * @property {boolean} [decodedTruncated] - tag runs only: true when `decoded` stops short of the run
+ */
+
+/**
+ * @typedef {Object} HiddenRunCounts
+ * @property {number} tag
+ * @property {number} variation_selector
+ * @property {number} invisible_operator
+ * @property {number} reserved_tag_plane
  */
 
 /**
  * @typedef {Object} HiddenTextScan
- * @property {HiddenRun[]} runs - runs that may hide text, in order
+ * @property {HiddenRun[]} runs - runs that may hide text, in order, at most `maxRuns` long
  * @property {Array<[number, number]>} benign - [offset, end) spans of legitimate
- *   sequences (subdivision flags, a single emoji or text presentation selector)
+ *   sequences (subdivision flags, a single emoji or text presentation selector), at most `maxRuns` long
+ * @property {HiddenRunCounts} counts - every run per kind, listed or not
+ * @property {HiddenRunCounts} codePointCounts - code points in those runs per kind, listed or not
+ * @property {number} supplementarySelectorCount - code points U+E0100–U+E01EF in those runs, which
+ *   (unlike the emoji selectors U+FE00–U+FE0F) can carry data; included in codePointCounts.variation_selector
+ * @property {number} total - sum of `counts`
+ * @property {number} benignTotal - every benign span, listed or not
+ * @property {boolean} truncated - true when runs or benign spans were left out of the lists
+ */
+
+/**
+ * @typedef {Object} HiddenScanOptions
+ * @property {number} [maxRuns=Infinity] - cap on listed runs, and separately on listed benign spans
+ *   (non-negative integer or Infinity). Counts stay exact.
+ * @property {number} [maxDecodedLength=Infinity] - cap on each run's `decoded` text, in UTF-16 units.
+ *   For both, any other value (negative, fractional, NaN, a string) means the default, no cap.
  */
 
 const TAG_FIRST = 0xE0000;
@@ -43,6 +73,8 @@ function kindOf(cp) {
     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;
 }
 
@@ -57,64 +89,145 @@ const hex = (cp) => 'U+' + cp.toString(16).toUpperCase().padStart(4, '0');
  * @returns {string}
  */
 export function decodeTagText(text) {
+    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 = '';
-    for (const ch of text) {
-        const cp = /** @type {number} */ (ch.codePointAt(0));
-        out += cp >= 0xE0020 && cp <= 0xE007E ? String.fromCharCode(cp - TAG_FIRST) : `<${hex(cp)}>`;
+    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 out;
+    return { decoded: out, truncated: false };
 }
 
+// Whitespace as JavaScript's \s defines it, tested at an index of the text itself,
+// so the check allocates nothing.
+const SPACE_AT = /\s/y;
+
 /**
- * Finds runs of tag characters, variation selectors and invisible operators.
+ * @param {string} text
+ * @param {number} index
+ * @returns {boolean}
+ */
+function isSpaceAt(text, index) {
+    SPACE_AT.lastIndex = index;
+    return SPACE_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).
  * Consecutive characters of the same kind form one run. Two kinds of sequence are
  * legitimate and listed under `benign` instead of `runs`:
  *  - the subdivision flags of England, Scotland and Wales: U+1F3F4 followed by the
  *    tags for "gbeng", "gbsct" or "gbwls" and U+E007F
  *  - a single U+FE0E or U+FE0F (text or emoji presentation) after another character
+ *
+ * `line` and `column` are counted as in inspectTextDetailed. Every run and benign
+ * span is counted; only the first `maxRuns` of each are listed. With the caps set,
+ * memory stays flat however large the input is. One pass over the string, no copy.
+ * Set both caps for untrusted input: without them, results grow with the input.
+ *
  * @param {string} text
+ * @param {HiddenScanOptions} [options]
  * @returns {HiddenTextScan}
  */
-export function findHiddenRuns(text) {
+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) { i += cp > 0xFFFF ? 2 : 1; continue; }
+        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;
 
-        if (kind === 'tag') {
-            const body = text.slice(offset, end);
-            const afterFlag = offset >= 2 && text.codePointAt(offset - 2) === BLACK_FLAG;
-            if (afterFlag && last === CANCEL_TAG && SUBDIVISION_FLAGS.has(decodeTagText(body).slice(0, -'<U+E007F>'.length))) {
-                benign.push([offset, end]);
-            } else {
-                runs.push({ kind, offset, end, count, decoded: decodeTagText(body) });
-            }
+        // 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) &&
+              offset > 0 && !isSpaceAt(text, offset - 1);
+        if (isBenign) {
+            benignTotal++;
+            if (benign.length < maxRuns) benign.push([offset, end]);
             continue;
         }
-        if (kind === 'variation_selector' && count === 1 && (cp === 0xFE0E || cp === 0xFE0F) &&
-            offset > 0 && !/\s/.test(text[offset - 1])) {
-            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);
         }
-        runs.push({ kind, offset, end, count });
     }
-    return { runs, benign };
+    return { runs, benign, counts, codePointCounts, supplementarySelectorCount, total, benignTotal, truncated: total > runs.length || benignTotal > benign.length };
 }

package/src/index.d.ts

@@ -3,8 +3,14 @@ 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';
-export { inspectText, inspectTextDetailed, getNewlineStats, getRecommendedSanctifierOptions, summonSanctifier, revealInvisible };
+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;

package/src/index.js

@@ -4,12 +4,15 @@
 import { inspectText, inspectTextDetailed, getNewlineStats, getRecommendedSanctifierOptions } from './inspectText.js';
 export { inspectText, inspectTextDetailed, getNewlineStats, getRecommendedSanctifierOptions };
 
-import { summonSanctifier } from './sanctifyText.js';
-export { summonSanctifier };
+import { summonSanctifier, sanctifyStrict, sanctifyLoose, sanctifyKeyboardOnlyEmoji, sanctifyKeyboardOnly, sanctifyPasted } from './sanctifyText.js';
+export { summonSanctifier, sanctifyStrict, sanctifyLoose, sanctifyKeyboardOnlyEmoji, sanctifyKeyboardOnly, sanctifyPasted };
 
 import { revealInvisible } from './reveal.js';
 export { revealInvisible };
 
+import { VERSION } from './version.generated.js';
+export { VERSION };
+
 // Type-only re-exports so TypeScript consumers can name these from the package root.
 /** @typedef {import('./inspectText.js').UnicodeTrashReport} UnicodeTrashReport */
 /** @typedef {import('./inspectText.js').TrashCategory} TrashCategory */

package/src/inspectText.js

@@ -1,13 +1,7 @@
 // ./src/inspectText.js
 
-import {
-    CONTROL_CHARS_REGEX,
-    INVISIBLE_TRASH_REGEX,
-    EMOJI_REGEX,
-    ASCII_KEYBOARD_SAFE_REGEX,
-    normalizeTypographicJank,
-} from './sanctifyText.js';
-import { classifyCodeUnit, classifyAstral } from './categories.generated.js';
+import { CONTROL_CHARS_REGEX, INVISIBLE_TRASH_REGEX, classifyCodeUnit, classifyAstral } from './categories.generated.js';
+import { EMOJI_REGEX, ASCII_KEYBOARD_SAFE_REGEX, normalizeTypographicJank } from './textPatterns.js';
 
 /** @typedef {import('./sanctifyText.js').SanctifyOptions} SanctifyOptions */