euredact 0.3.6 → 0.3.8

package/dist/cjs/rules/suppressors.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SuppressionScratch = void 0;
 exports.shouldSuppress = shouldSuppress;
 const types_js_1 = require("../types.js");
 const bicRegistry_js_1 = require("./bicRegistry.js");
@@ -43,11 +44,16 @@ const MATH_AFTER = /^\s*[=+\-×÷*/]/;
 const COUNTRY_PREFIX_HYPHEN = /(?:^|[^A-Za-z0-9])[A-Z]{1,2}-\s*$/;
 const SEQUENTIAL_PATTERNS = /^(?:0{6,}|1234567890?|0123456789|9876543210?|1111111111?|000000000|123456789)$/;
 // YEAR_PATTERN kept for reference but replaced by RECENT_YEAR in suppressYearAsPostal
-// The leading \b is load-bearing. Without it the short alternatives match the
-// *tail* of an ordinary word: "NIS" matched "tālru**nis** ", the Latvian for
-// "telephone", so every Latvian phone number was suppressed as though it sat
-// behind a Belgian national-ID label. 653 misses from a missing word boundary.
-const ID_LABEL_BEFORE = /\b(?:BSN|RR|NN|NIR|INSZ|NISS|NIS|Steuer-?ID|TIN|NIF|NIE|SSN|rijksregisternummer|numéro\s*national|national\s*number|matricule|Ausweisnummer|Personalausweis|Versichertennummer|KVNR|KV-Nr|Steuernummer|St\.\-Nr|StNr|Finanzamt\s+ist|Ondernemingen\s+onder\s+nummer|ondernemingsnummer|numéro\s*d'entreprise|enterprise\s*number|Kruispuntbank)\s*[:.]?\s*$/i;
+// `ID_LABEL_BEFORE` and `suppressPhoneAfterIdLabel` lived here. Their labels are
+// now typed entries in `cues.ts`, and a phone-shaped span behind one is
+// *relabelled* rather than dropped.
+//
+// Dropping was the wrong verb. The span is found either way, so removing the
+// claim decided only whether the value was masked — and the answer was "no":
+// "Rijksregisternummer: 85.03.19-284.73" produced no detection at all, a
+// redaction library printing in full an identifier it had recognised and
+// rejected. The 653-miss word-boundary lesson recorded here moved with the
+// labels; see the module comment in `cues.ts`.
 const SERVICE_NUMBER = /^0800[\-\s]/;
 const DATE_PATTERN_FULL = /^\d{2}[-/.]\d{2}[-/.]\d{4}$|^\d{4}[-/.]\d{2}[-/.]\d{2}$/;
 const PASSPORT_CONTEXT_BEFORE = /(?:Reisepass|passport|passeport|paspoort|Bisheriger\s+Reisepass)\s*(?:Nr\.?|Nummer|nummer|number|n[°o])?\s*[:.]?\s*$/i;
@@ -271,8 +277,12 @@ function suppressUnits(text, match) {
  * keyword window. That window is what made the postal rule claim years in
  * dates; widening its reach to fix a different symptom would repeat the error.
  */
+// Hoisted out of the suppressor bodies: rebuilding these per candidate cost
+// ~260k Set allocations per 1 MB document, and GC was 10.7% of the profile.
+const REFERENCE_TYPES = new Set([types_js_1.EntityType.PHONE, types_js_1.EntityType.NATIONAL_ID, types_js_1.EntityType.SSN, types_js_1.EntityType.TAX_ID, types_js_1.EntityType.IBAN, types_js_1.EntityType.CHAMBER_OF_COMMERCE, types_js_1.EntityType.POSTAL_CODE]);
+const LEGAL_TYPES = new Set([types_js_1.EntityType.PHONE, types_js_1.EntityType.NATIONAL_ID, types_js_1.EntityType.POSTAL_CODE]);
 function suppressReference(text, match) {
-    const applicable = new Set([types_js_1.EntityType.PHONE, types_js_1.EntityType.NATIONAL_ID, types_js_1.EntityType.SSN, types_js_1.EntityType.TAX_ID, types_js_1.EntityType.IBAN, types_js_1.EntityType.CHAMBER_OF_COMMERCE, types_js_1.EntityType.POSTAL_CODE]);
+    const applicable = REFERENCE_TYPES;
     if (!applicable.has(match.patternDef.entityType))
         return false;
     const [before] = getContext(text, match.start, match.end);
@@ -282,7 +292,7 @@ function suppressReference(text, match) {
     return HASH_BEFORE.test(adjacent) || REF_PREFIX_BEFORE.test(adjacent);
 }
 function suppressLegal(text, match) {
-    const applicable = new Set([types_js_1.EntityType.PHONE, types_js_1.EntityType.NATIONAL_ID, types_js_1.EntityType.POSTAL_CODE]);
+    const applicable = LEGAL_TYPES;
     if (!applicable.has(match.patternDef.entityType))
         return false;
     const [before] = getContext(text, match.start, match.end);
@@ -337,12 +347,6 @@ function suppressYearAsPostal(text, match) {
     // Suppress: recent years without postal context are almost never postal codes
     return true;
 }
-function suppressPhoneAfterIdLabel(text, match) {
-    if (match.patternDef.entityType !== types_js_1.EntityType.PHONE)
-        return false;
-    const [before] = getContext(text, match.start, match.end);
-    return ID_LABEL_BEFORE.test(before);
-}
 function suppressPhoneServiceNumber(_text, match) {
     if (match.patternDef.entityType !== types_js_1.EntityType.PHONE)
         return false;
@@ -505,8 +509,15 @@ function enclosingLine(text, start, end) {
  */
 function structuralUnit(text, start, end) {
     const [lineStart, lineEnd] = enclosingLine(text, start, end);
+    // Both walks stop as soon as the paragraph is too wide to be used, because
+    // everything past that point is discarded by the cap below anyway. Applying
+    // the cap only to the *result* meant that on a document with no blank lines
+    // each walk ran to the top and bottom of the whole text — O(document) per
+    // candidate, O(n^2) overall.
     let paraStart = lineStart;
     while (paraStart > 0) {
+        if (lineEnd - paraStart > MAX_UNIT_CHARS)
+            return text.slice(lineStart, lineEnd);
         const prevEnd = paraStart - 1;
         const prevStart = text.lastIndexOf("\n", prevEnd - 1) + 1;
         if (text.slice(prevStart, prevEnd).trim() === "")
@@ -515,6 +526,8 @@ function structuralUnit(text, start, end) {
     }
     let paraEnd = lineEnd;
     while (paraEnd < text.length) {
+        if (paraEnd - paraStart > MAX_UNIT_CHARS)
+            return text.slice(lineStart, lineEnd);
         const nextStart = paraEnd + 1;
         let nextEnd = text.indexOf("\n", nextStart);
         if (nextEnd === -1)
@@ -551,28 +564,74 @@ function escapeRe(s) {
  * heading. Measured on the corpus this alone identifies ~78% of the BIC false
  * positives with no dictionaries and no labelled data.
  */
-function occursAsLowercaseWord(text, token) {
+/**
+ * Every all-letter word in the document that is not part of an email address
+ * or a domain name.
+ *
+ * `\b<word>\b` can only match a maximal run of word characters, so collecting
+ * the runs once answers the question for every candidate. Re-scanning the whole
+ * document per candidate made this quadratic: 1.58 s on a 400 KB document
+ * dense in bank codes, against ~1 ms to build this set.
+ */
+function buildDocumentWords(text) {
+    const words = new Set();
+    const re = /[A-Za-z0-9_]+/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        const word = m[0];
+        if (!/^[A-Za-z]+$/.test(word))
+            continue;
+        const i = m.index;
+        const before = i > 0 ? text[i - 1] : "";
+        if (before === "@")
+            continue;
+        if (before === "." && i >= 2 && /[A-Za-z0-9]/.test(text[i - 2]))
+            continue;
+        const after = text.slice(i + word.length, i + word.length + 8);
+        if (after.startsWith("@"))
+            continue;
+        if (/^\.[a-zA-Z]{2,6}\b/.test(after))
+            continue;
+        words.add(word);
+    }
+    return words;
+}
+/**
+ * Per-document scratch space for suppressors that would otherwise re-derive the
+ * same whole-document facts for every candidate.
+ *
+ * Built lazily and held only for the duration of one `detect()` call, so no
+ * document text outlives the call that supplied it.
+ */
+class SuppressionScratch {
+    text;
+    words = null;
+    constructor(text) {
+        this.text = text;
+    }
+    documentWords() {
+        if (this.words === null)
+            this.words = buildDocumentWords(this.text);
+        return this.words;
+    }
+}
+exports.SuppressionScratch = SuppressionScratch;
+/**
+ * Does `token` also occur as an ordinary lowercase word in this document?
+ *
+ * `hospital`/`HOSPITAL`, `gegevens`/`GEGEVENS` — a token that appears in
+ * ordinary case elsewhere in the same document is a word, not a bank code.
+ * Email and domain contexts are excluded, so `ing.nl` does not vouch for a
+ * heading. Measured on the corpus this alone identifies ~78% of the BIC false
+ * positives with no dictionaries and no labelled data.
+ */
+function occursAsLowercaseWord(text, token, scratch) {
     if (!/^[A-Za-z]+$/.test(token))
         return false;
     const lower = token.toLowerCase();
     const capitalised = lower[0].toUpperCase() + lower.slice(1);
-    for (const form of [lower, capitalised]) {
-        // Cheap pre-check: a plain substring test almost always answers "no".
-        if (!text.includes(form))
-            continue;
-        const re = new RegExp(`\\b${escapeRe(form)}\\b`, "g");
-        let m;
-        while ((m = re.exec(text)) !== null) {
-            const before = m.index > 0 ? text[m.index - 1] : "";
-            const after = text.slice(m.index + form.length, m.index + form.length + 8);
-            if (before === "@" || (before === "." && m.index >= 2 && /[A-Za-z0-9]/.test(text[m.index - 2])))
-                continue;
-            if (after.startsWith("@") || /^\.[a-zA-Z]{2,6}\b/.test(after))
-                continue;
-            return true;
-        }
-    }
-    return false;
+    const words = scratch ? scratch.documentWords() : buildDocumentWords(text);
+    return words.has(lower) || words.has(capitalised);
 }
 /**
  * Is the candidate positioned as a section heading rather than a value?
@@ -610,25 +669,29 @@ function isHeadingShape(text, start, end, token) {
  * ordinary lowercase word — so it is applied on both emitting paths. It scans
  * the whole document, so it runs only on the paths that would otherwise emit.
  */
-function suppressBicWithoutEvidence(text, match) {
+function suppressBicWithoutEvidence(text, match, scratch) {
     if (match.patternDef.entityType !== types_js_1.EntityType.BIC)
         return false;
     const token = match.text.trim();
     if ((0, bicRegistry_js_1.isRegisteredBic)(token))
-        return occursAsLowercaseWord(text, token);
+        return occursAsLowercaseWord(text, token, scratch);
     if (isHeadingShape(text, match.start, match.end, token))
         return true;
     // The token itself is blanked out so it cannot vouch for itself.
     const unit = structuralUnit(text, match.start, match.end).split(token).join(" ".repeat(token.length));
     if (BIC_KEYWORD.test(unit) || IBAN_SHAPE.test(unit) || BANK_BLOCK.test(unit)) {
-        return occursAsLowercaseWord(text, token);
+        return occursAsLowercaseWord(text, token, scratch);
     }
     return true;
 }
 // ── Postal code: digits belonging to a longer identifier ────────────────
 // An identifier label immediately before the digits. A postal code is never
 // introduced this way; an SVNr, policy number or service number always is.
-const ID_CUE_BEFORE = /(?:[\w\-]*Nr|[\w\-]*N[°ºo]|[\w\-]*Nummer|[\w\-]*Numero|[\w\-]*Numéro|No|number|num|Kennzahl|Aktenzeichen|Az|e-?card|Polizze|Police|Policen)\.?\s*:?\s*$/i;
+// The `[\w\-]*` prefix is factored out of the five alternatives that share it.
+// Repeated per alternative, the engine retried the same unbounded prefix five
+// times per starting position — the most expensive single regex in the engine
+// at 197 ms per 1 MB document. Same language, 8x faster on the worst case.
+const ID_CUE_BEFORE = /(?:[\w\-]*(?:Nr|N[°ºo]|Nummer|Numero|Numéro)|No|number|num|Kennzahl|Aktenzeichen|Az|e-?card|Polizze|Police|Policen)\.?\s*:?\s*$/i;
 // An international dialling prefix earlier on the same line, with nothing but
 // number punctuation in between: these digits belong to the phone detector.
 const DIALLING_PREFIX_BEFORE = /\+\d{1,3}[\d\s\-().]*$/;
@@ -729,7 +792,7 @@ function suppressRequiresContext(text, match) {
     return !match.patternDef.contextKeywords.some(kw => context.includes(kw.toLowerCase()));
 }
 const TYPE_SUPPRESSORS = {
-    [types_js_1.EntityType.PHONE]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressPhoneAfterIdLabel, suppressPhoneServiceNumber, suppressPhoneDateOverlap, suppressPhoneAsNumberRange],
+    [types_js_1.EntityType.PHONE]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressPhoneServiceNumber, suppressPhoneDateOverlap, suppressPhoneAsNumberRange],
     [types_js_1.EntityType.NATIONAL_ID]: [suppressCurrency, suppressUnits, suppressReference, suppressLegal, suppressMath, suppressNatidAsPassport, suppressSeNatidAsOrg],
     [types_js_1.EntityType.SSN]: [suppressCurrency, suppressUnits, suppressReference, suppressMath],
     [types_js_1.EntityType.TAX_ID]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressTaxidAsIpAddress],
@@ -740,13 +803,13 @@ const TYPE_SUPPRESSORS = {
     [types_js_1.EntityType.SECRET]: [suppressSecretOverStructured, suppressSecretNotASecret],
     [types_js_1.EntityType.CHAMBER_OF_COMMERCE]: [suppressReference],
 };
-function shouldSuppress(text, match) {
+function shouldSuppress(text, match, scratch) {
     if (suppressSequential(text, match))
         return true;
     const typeSups = TYPE_SUPPRESSORS[match.patternDef.entityType];
     if (typeSups) {
         for (const s of typeSups) {
-            if (s(text, match))
+            if (s(text, match, scratch))
                 return true;
         }
     }

package/dist/cjs/rules/validators.js

@@ -225,6 +225,18 @@ function validateFrenchNir(candidate) {
     const check = parseInt(numeric.slice(13, 15));
     return (97 - (first13 % 97)) === check;
 }
+/**
+ * ISO 3779 VIN validation: 17 characters, no I/O/Q. **Shape only.**
+ *
+ * The position-9 check digit is mandatory for North American VINs (WMI 1-5)
+ * and unused elsewhere, and it is deliberately **not** enforced. Measured over
+ * the 152,300-document corpus, enforcing it turned 1,502 labelled VINs into
+ * misses — every North American VIN whose check digit does not survive being
+ * written down. A VIN that fails its checksum is still a VIN sitting in the
+ * text; dropping it leaves it unredacted, which is a leak, while keeping it
+ * costs at worst an over-masked 17-character token. Matches the Python SDK's
+ * `validate_vin`, which carries the full reasoning.
+ */
 function validateVin(candidate) {
     const c = candidate.replace(/[\s\-]/g, "").toUpperCase();
     if (c.length !== 17)

package/dist/cjs/sdk.js

@@ -7,20 +7,44 @@ const engine_js_1 = require("./rules/engine.js");
 const evidence_js_1 = require("./rules/evidence.js");
 const types_js_1 = require("./types.js");
 const DATE_TYPES = new Set([types_js_1.EntityType.DOB, types_js_1.EntityType.DATE_OF_DEATH]);
+/** Entry count at which a one-time warning is emitted. */
+const MAPPING_WARN_THRESHOLD = 100_000;
+/**
+ * Maps real PII values to consistent labels within a session.
+ *
+ * The mapping is keyed on the **raw PII value** and is never evicted — evicting
+ * would hand a previously seen value a second label and quietly break
+ * referential integrity. Two consequences worth designing around:
+ *
+ * - It grows for as long as the process runs. Call `clear()` between workloads;
+ *   a warning is emitted once the mapping passes `MAPPING_WARN_THRESHOLD`.
+ * - Labels are shared by every caller of the same instance, including every
+ *   caller of the module-level `redact()`. A label repeated across two
+ *   documents reveals that they contain the same underlying value, so give each
+ *   tenant its own `EuRedact` instance rather than sharing the module-level one.
+ */
 class ReferentialMapper {
     counters = new Map();
     mapping = new Map();
+    warned = false;
     getLabel(text, entityType) {
         if (!this.mapping.has(text)) {
             const count = (this.counters.get(entityType) ?? 0) + 1;
             this.counters.set(entityType, count);
             this.mapping.set(text, `${entityType}_${count}`);
+            if (!this.warned && this.mapping.size > MAPPING_WARN_THRESHOLD) {
+                this.warned = true;
+                console.warn(`[euredact] Referential integrity mapping holds ${this.mapping.size} ` +
+                    `raw PII values and is never evicted. Call clear() between workloads ` +
+                    `to release them.`);
+            }
         }
         return this.mapping.get(text);
     }
     clear() {
         this.counters.clear();
         this.mapping.clear();
+        this.warned = false;
     }
 }
 const DEFAULT_MAX_INPUT_LENGTH = 10_485_760; // ~10 MB of text
@@ -110,14 +134,32 @@ class EuRedact {
             detections = detections.filter(d => !DATE_TYPES.has(d.entityType));
         }
         detections.sort((a, b) => a.start - b.start || b.end - a.end);
-        let redacted = text;
+        // Labels are resolved right-to-left because the referential mapper numbers
+        // each entity type in call order, and that order is part of the output
+        // contract. The string itself is then assembled in a single forward pass:
+        // rebuilding it per detection copied the whole document each time, which is
+        // O(document x detections) — 1.68 s of pure copying on a 1 MB document with
+        // 15,000 detections, versus 2 ms here.
+        const replacements = new Array(detections.length);
         for (let i = detections.length - 1; i >= 0; i--) {
             const det = detections[i];
-            const replacement = referentialIntegrity
+            replacements[i] = referentialIntegrity
                 ? this.referentialMapper.getLabel(det.text, det.entityType)
                 : `[${det.entityType}]`;
-            redacted = redacted.slice(0, det.start) + replacement + redacted.slice(det.end);
         }
+        const parts = [];
+        let pos = 0;
+        for (let i = 0; i < detections.length; i++) {
+            const det = detections[i];
+            // Spans reach here deduplicated and non-overlapping; one starting behind
+            // the cursor would splice into the middle of a label, so drop it.
+            if (det.start < pos)
+                continue;
+            parts.push(text.slice(pos, det.start), replacements[i]);
+            pos = det.end;
+        }
+        parts.push(text.slice(pos));
+        const redacted = parts.join("");
         // Report the inference so it can be audited. Spans in `evidence` are
         // offsets into the normalised text, matching `detections`.
         const inferredCountries = [...(0, evidence_js_1.weightsToRanking)(scores).entries()]

package/dist/cjs/types.js

@@ -36,6 +36,16 @@ var EntityType;
     EntityType["HEALTH_INSURANCE"] = "HEALTH_INSURANCE";
     EntityType["HEALTHCARE_PROVIDER"] = "HEALTHCARE_PROVIDER";
     EntityType["CHAMBER_OF_COMMERCE"] = "CHAMBER_OF_COMMERCE";
+    /**
+     * Employee, badge or customer number tied to a person.
+     *
+     * Emitted **only** when an explicit label names it — see `rules/cues.ts`.
+     * There is no pattern for an internal identifier because there is no shape
+     * for one; without the label, a digit run is not distinguishable from any
+     * other. The type exists so that a labelled employee number is filed
+     * correctly instead of being claimed by the phone pattern.
+     */
+    EntityType["INTERNAL_ID"] = "INTERNAL_ID";
     EntityType["IMEI"] = "IMEI";
     EntityType["GPS_COORDINATES"] = "GPS_COORDINATES";
     EntityType["UUID"] = "UUID";

package/dist/esm/cache.d.ts

@@ -1,11 +1,15 @@
 import type { RedactResult } from "./types.js";
 export declare class ResultCache {
     private maxsize;
+    private maxChars;
     private enabled;
     private store;
-    constructor(maxsize?: number, enabled?: boolean);
+    private sizes;
+    private chars;
+    constructor(maxsize?: number, enabled?: boolean, maxChars?: number);
     key(text: string, countries: string[], mode: string): string;
     get(key: string): RedactResult | null;
     put(key: string, result: RedactResult): void;
+    private evict;
     clear(): void;
 }

package/dist/esm/cache.js

@@ -1,27 +1,41 @@
-// Simple hash function (FNV-1a) - no crypto dependency needed for cache keys
-function fnv1aHash(str) {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < str.length; i++) {
-        hash ^= str.charCodeAt(i);
-        hash = (hash * 0x01000193) >>> 0;
-    }
-    return hash.toString(16).padStart(8, "0");
+import { createHash } from "node:crypto";
+// Default ceiling on retained characters, not entries. A count-only cap of
+// 1024 entries says nothing about memory: 1024 cached 1 MB documents is a
+// gigabyte of PII-bearing text held live. ~16M characters is a few tens of MB.
+const DEFAULT_MAX_CHARS = 16_000_000;
+/** Approximate retained size of a cached result, in characters. */
+function resultChars(result) {
+    let chars = result.redactedText.length;
+    for (const d of result.detections)
+        chars += d.text.length;
+    return chars;
 }
 export class ResultCache {
     maxsize;
+    maxChars;
     enabled;
     store = new Map();
-    constructor(maxsize = 1024, enabled = true) {
+    sizes = new Map();
+    chars = 0;
+    constructor(maxsize = 1024, enabled = true, maxChars = DEFAULT_MAX_CHARS) {
         this.maxsize = maxsize;
+        this.maxChars = maxChars;
         this.enabled = enabled;
     }
     key(text, countries, mode) {
         const sorted = [...countries].sort();
-        const raw = `${text}|${sorted.join("|")}|${mode}`;
-        // Include raw length to reduce collision risk alongside dual FNV-1a hashes
-        const h1 = fnv1aHash(raw);
-        const h2 = fnv1aHash(raw.slice(Math.floor(raw.length / 2)) + raw.slice(0, Math.floor(raw.length / 2)));
-        return `${raw.length}:${h1}${h2}`;
+        // SHA-256, matching the Python implementation. The previous dual FNV-1a
+        // was non-cryptographic and collidable by construction: in a shared-process
+        // deployment an attacker who can guess a victim's document could submit a
+        // same-length colliding one and be served the victim's cached result,
+        // detections and raw matched PII included.
+        return createHash("sha256")
+            .update(text)
+            .update("|")
+            .update(sorted.join("|"))
+            .update("|")
+            .update(mode)
+            .digest("hex");
     }
     get(key) {
         if (!this.enabled)
@@ -38,15 +52,35 @@ export class ResultCache {
     put(key, result) {
         if (!this.enabled)
             return;
-        this.store.delete(key);
+        const size = resultChars(result);
+        // A single result bigger than the whole budget would evict everything else
+        // and still not fit; skip it rather than empty the cache for one document.
+        if (size > this.maxChars) {
+            this.evict(key);
+            return;
+        }
+        this.evict(key);
         this.store.set(key, result);
-        while (this.store.size > this.maxsize) {
+        this.sizes.set(key, size);
+        this.chars += size;
+        while (this.store.size > this.maxsize || this.chars > this.maxChars) {
             const first = this.store.keys().next().value;
-            if (first !== undefined)
-                this.store.delete(first);
+            if (first === undefined)
+                break;
+            this.evict(first);
         }
     }
+    evict(key) {
+        const size = this.sizes.get(key);
+        if (size !== undefined) {
+            this.chars -= size;
+            this.sizes.delete(key);
+        }
+        this.store.delete(key);
+    }
     clear() {
         this.store.clear();
+        this.sizes.clear();
+        this.chars = 0;
     }
 }

package/dist/esm/rules/context.d.ts

@@ -6,7 +6,7 @@
  * contain no IBAN, no `+CC` number and no ccTLD infers nothing at all, even
  * when the first page identified the document beyond doubt:
  *
- *     page 1   "Factuur — IBAN NL91ABNA0417164300, info@jansen.nl"
+ *     page 1   "Factuur — IBAN NL91ABNA0417164300, info@example.nl"
  *     page 7   "Telefoon 0612345678"        <- Dutch mobile, or Danish CPR?
  *
  * Scanned alone, page 7 has nothing to go on. Sharing a context across the two

package/dist/esm/rules/context.js

@@ -6,7 +6,7 @@
  * contain no IBAN, no `+CC` number and no ccTLD infers nothing at all, even
  * when the first page identified the document beyond doubt:
  *
- *     page 1   "Factuur — IBAN NL91ABNA0417164300, info@jansen.nl"
+ *     page 1   "Factuur — IBAN NL91ABNA0417164300, info@example.nl"
  *     page 7   "Telefoon 0612345678"        <- Dutch mobile, or Danish CPR?
  *
  * Scanned alone, page 7 has nothing to go on. Sharing a context across the two

package/dist/esm/rules/countries/index.js

@@ -157,7 +157,20 @@ const SHARED = {
         // --- Secret / API Key (assignment-based: KEY=value or KEY: value) ---
         p(EntityType.SECRET, String.raw `(?<=[:=] )\S{8,}|(?<=[:=])\S{8,}`, "high_entropy", "Assigned secret value", SECRET_CONTEXT, true),
         // --- Secret / API Key (entropy-based fallback for longer tokens) ---
-        p(EntityType.SECRET, String.raw `\b[A-Za-z0-9_\-+/]{24,}[A-Za-z0-9_\-+/=]*\b`, "high_entropy", "High-entropy token", SECRET_CONTEXT, true),
+        // Only the *trailing* \b is replaced. It could not match when the token run
+        // ended on "-", "+" or "/", so the engine backtracked across two
+        // overlapping quantified classes: an ordinary dashed rule line ("x-----...")
+        // cost O(n^2), 8.3 s for 80 KB. The lookahead simply asserts the run is
+        // over, which is what \b was there to express, and it cannot fail after a
+        // maximal run — so there is nothing to backtrack into.
+        //
+        // The leading \b stays. A class lookbehind there widened the span leftwards
+        // over any "/" in front, so an authorized_keys entry started "//...",
+        // matched the protocol-relative URL shape in the endpoint suppressor, and
+        // was dropped — leaving SSH key material in the clear. Base64 padding is
+        // now inside the span instead of trailing outside it; that is the only
+        // intended difference.
+        p(EntityType.SECRET, String.raw `\b[A-Za-z0-9_\-+/]{24,}[A-Za-z0-9_\-+/=]*(?![A-Za-z0-9_\-+/=])`, "high_entropy", "High-entropy token", SECRET_CONTEXT, true),
         p(EntityType.DOB, String.raw `\b(?:0[1-9]|[12][0-9]|3[01])[/.\-](?:0[1-9]|1[0-2])[/.\-](?:19|20)\d{2}\b`, null, "DD/MM/YYYY", DOB_CONTEXT, true),
         p(EntityType.DATE_OF_DEATH, String.raw `\b(?:0[1-9]|[12][0-9]|3[01])[/.\-](?:0[1-9]|1[0-2])[/.\-](?:19|20)\d{2}\b`, null, "", DATE_OF_DEATH_CONTEXT, true),
         p(EntityType.DOB, String.raw `\b(?:19|20)\d{2}[/.\-](?:0[1-9]|1[0-2])[/.\-](?:0[1-9]|[12][0-9]|3[01])\b`, null, "ISO YYYY-MM-DD", DOB_ISO_CONTEXT, true),

package/dist/esm/rules/cues.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Local cues: what the document calls the value sitting next to it.
+ *
+ * A label touching the left edge of a span is the strongest statement a
+ * document makes about what that value *is*. "Phone: 0705237535" is a phone
+ * number even though those digits pass the Swedish personnummer checksum, and
+ * "Αρ. Ταυτότητας: 00892341" is an identity-card number even though nothing in
+ * the engine can checksum it.
+ *
+ * This table is the single source of that knowledge. Three callers read it, and
+ * none of them may move a span:
+ *
+ * 1. `localCueBonus` — ranks a candidate above its rivals on the *same span*
+ *    when the cue names its type. The oldest use, and why the table exists.
+ * 2. `detectWithEvidence` — re-admits a candidate whose checksum failed when the
+ *    cue names that same type. A declined identifier with its own label in front
+ *    of it is still that identifier, mistyped or truncated.
+ * 3. `retypedBy` — relabels a winning generic candidate whose type the cue
+ *    contradicts, when nothing of the cued type claimed the span.
+ *
+ * Consolidated here from two places that had drifted apart: `LOCAL_CUES` in
+ * `engine.ts` (typed, but missing most of Europe) and `ID_LABEL_BEFORE` in
+ * `suppressors.ts` (broader, but untyped — it could only *delete* a phone
+ * candidate, which left the value unmasked).
+ *
+ * Kept character-for-character in step with `euredact/rules/cues.py`. Two
+ * constructs are written the way they are so that both engines agree:
+ *
+ * * Boundaries are `(?<![A-Za-z0-9_])`, not `\b`. JavaScript's `\b` is
+ *   ASCII-only, so `\bΑΦΜ` never matches — a Greek letter is not a word
+ *   character there, and a space before it is not a transition. A boundary of
+ *   some kind is required regardless: without one the short alternatives match
+ *   the *tail* of an ordinary word. "NIS" matched "tālru**nis**", the Latvian
+ *   for telephone, and suppressed 653 real phone numbers; "iva" matched
+ *   "Pr**iva**t:" and read a personal e-mail address as a VAT number.
+ * * The qualifier class is spelled out rather than written `[^\W\d_]`, which
+ *   would reject "εταιρειας" here for the same ASCII reason.
+ *
+ * Every label ends in `(?:\w*|\s+<one word>)`: the label either runs on into a
+ * longer word ("telefoon" → "telefoonnummer") **or** takes one qualifier word
+ * naming whose identifier it is ("ΑΦΜ εταιρειας:", "Tel Nr:") — never both.
+ * Allowing both let "nie" grow into the surname "Nieminen" and then swallow the
+ * real label in "Matti Nieminen\nDOB: 08.05.1994", reading a date of birth as a
+ * Spanish NIE: 52 false positives across the corpus.
+ */
+import { EntityType } from "../types.js";
+/**
+ * How far back a cue may sit. Short on purpose: a cue is only evidence about
+ * the value it introduces, which is the lesson of the postal-code year defect,
+ * where a cue 150 characters away licensed every number in the window.
+ */
+export declare const CUE_WINDOW = 22;
+/**
+ * (entity type, label pattern). Ordered: the first match wins, so the narrower
+ * label comes first where two could read the same text.
+ */
+export declare const CUES: Array<[EntityType, RegExp]>;
+/**
+ * The entity type a label immediately before `start` names, or null.
+ *
+ * Reads at most `CUE_WINDOW` characters, and every pattern is anchored to the
+ * end of that window, so the cue must *touch* the span. A label further away is
+ * about some other value.
+ */
+export declare function cuedType(text: string, start: number): EntityType | null;
+/**
+ * Types a label can assert on its own. Also the types eligible for the rescue
+ * in `engine.ts`, for the same reason read the other way — a label may vouch
+ * for one of these, so it may also vouch for a malformed one.
+ *
+ * PHONE is absent on purpose: "Tel:" in front of something no phone pattern
+ * matched means the document is laid out oddly, not that the value is a phone
+ * number. So are EMAIL, SECRET, DOB, VIN and the rest — those carry their own
+ * structure, and a nearby word is not entitled to overrule it.
+ *
+ * BIC's absence is what keeps the rescue honest. Its validator is a *registry
+ * lookup*, not a checksum, so a failure means "no such bank", which no label can
+ * talk you out of. Rescuing it read 34 unlisted codes behind a "BIC:" label as
+ * real ones. The same reasoning keeps CREDIT_CARD and BANK_ACCOUNT out: Luhn and
+ * mod-97 are strong enough that a failure really does mean "not one of these".
+ */
+export declare const CUE_TARGETS: Set<string>;
+/**
+ * The type a cue overrules `entityType` with, or null to leave it alone.
+ *
+ * Both gates are load-bearing. Measured over 2,000 corpus documents, re-typing
+ * without them fired 52 times and got roughly 30 of those wrong — EMAIL read as
+ * VAT, a date of birth as a phone number, a VIN as VAT — against 20 real fixes.
+ * With them: 14 re-typings, every one of them PHONE to a structured identifier.
+ */
+export declare function retypedBy(text: string, start: number, entityType: EntityType | string): EntityType | null;