euredact 0.3.5 → 0.3.7

package/README.md

@@ -313,7 +313,7 @@ for (const page of pages) {
   offset += page.length;
 }
 
-// page 1: "Factuur — IBAN NL91ABNA0417164300, info@jansen.nl"
+// page 1: "Factuur — IBAN NL91ABNA0417164300, info@example.nl"
 // page 7: "Telefoon 0612345678"  -> PHONE (NL), not NATIONAL_ID (DK)
 ```
 

package/dist/cjs/cache.js

@@ -1,30 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResultCache = void 0;
-// 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");
+const node_crypto_1 = require("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;
 }
 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 (0, node_crypto_1.createHash)("sha256")
+            .update(text)
+            .update("|")
+            .update(sorted.join("|"))
+            .update("|")
+            .update(mode)
+            .digest("hex");
     }
     get(key) {
         if (!this.enabled)
@@ -41,16 +55,36 @@ 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;
     }
 }
 exports.ResultCache = ResultCache;

package/dist/cjs/rules/context.js

@@ -7,7 +7,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/cjs/rules/countries/index.js

@@ -160,7 +160,20 @@ const SHARED = {
         // --- Secret / API Key (assignment-based: KEY=value or KEY: value) ---
         p(types_js_1.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(types_js_1.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(types_js_1.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(types_js_1.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(types_js_1.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(types_js_1.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/cjs/rules/engine.js

@@ -310,6 +310,14 @@ class RuleEngine {
         const allFailed = failedSpans
             .map(f => [f.start, f.end])
             .sort((a, b) => a[0] - b[0] || a[1] - b[1]);
+        // Running maximum of the end offsets, so the fragment test below can ask
+        // "does any span starting at or before me reach past my end?" in O(1)
+        // instead of walking the prefix per candidate.
+        const failedStarts = allFailed.map(f => f[0]);
+        const failedPrefixMax = new Array(allFailed.length + 1).fill(0);
+        for (let i = 0; i < allFailed.length; i++) {
+            failedPrefixMax[i + 1] = Math.max(failedPrefixMax[i], allFailed[i][1]);
+        }
         const mergedZones = new Map();
         for (const [etype, spans] of zonesByType) {
             spans.sort((a, b) => a[0] - b[0] || a[1] - b[1]);
@@ -332,8 +340,11 @@ class RuleEngine {
             mergedZones.set(etype, { starts, ends });
         }
         const candidates = [];
+        // Whole-document facts a suppressor may need, derived at most once per call
+        // and discarded with it.
+        const scratch = new suppressors_js_1.SuppressionScratch(text);
         for (const { match, hasValidValidator } of validated) {
-            if ((0, suppressors_js_1.shouldSuppress)(text, match))
+            if ((0, suppressors_js_1.shouldSuppress)(text, match, scratch))
                 continue;
             // A validator-less match inside a failed-validation span of its own type
             // is demoted below every other candidate rather than deleted. Demotion
@@ -361,13 +372,31 @@ class RuleEngine {
             // default — the generic phone pattern kept claiming the tail of the
             // rejected national number.
             if (match.patternDef.validator === null && !demoted) {
+                // Upper bound of the spans starting at or before match.start.
+                let lo = 0, hi = failedStarts.length;
+                while (lo < hi) {
+                    const mid = (lo + hi) >>> 1;
+                    if (failedStarts[mid] <= match.start)
+                        lo = mid + 1;
+                    else
+                        hi = mid;
+                }
                 let fragment = false;
-                for (const [zs, ze] of allFailed) {
-                    if (zs > match.start)
-                        break;
-                    if (match.end <= ze && (match.start > zs || match.end < ze)) {
-                        fragment = true;
-                        break;
+                const reach = failedPrefixMax[lo];
+                if (reach > match.end) {
+                    // Something starting no later than us ends strictly later: we are a
+                    // proper subset of it.
+                    fragment = true;
+                }
+                else if (reach === match.end) {
+                    // Same end offset — a proper subset only if some span with that end
+                    // starts strictly earlier. Scanning backwards finds the enclosing
+                    // span first, and the equal case is rare.
+                    for (let i = lo - 1; i >= 0; i--) {
+                        if (allFailed[i][1] === match.end && allFailed[i][0] < match.start) {
+                            fragment = true;
+                            break;
+                        }
                     }
                 }
                 if (fragment)
@@ -418,6 +447,7 @@ class RuleEngine {
                 length: match.end - match.start,
                 countryScore: countryScores.get(match.countryCode) ?? 0,
                 inScope: declared === null || declared.has(match.countryCode) ? 1 : 0,
+                tier: 0,
                 det: {
                     entityType: match.patternDef.entityType,
                     start: match.start,
@@ -432,7 +462,7 @@ class RuleEngine {
         }
         for (const d of (0, structural_js_1.detectStructuralDob)(text)) {
             candidates.push({ blindPriority: 1, cue: 0, priority: 1, length: d.end - d.start,
-                countryScore: 0, inScope: 1, det: d });
+                countryScore: 0, inScope: 1, tier: 0, det: d });
         }
         const detections = this.deduplicate(candidates);
         detections.sort((a, b) => a.start - b.start || b.end - a.end);
@@ -466,7 +496,10 @@ class RuleEngine {
             if (seen === undefined || c.blindPriority > seen)
                 spanTier.set(key, c.blindPriority);
         }
-        const tierOf = (c) => spanTier.get(`${c.det.start}:${c.det.end}`);
+        // Resolved once per candidate rather than inside the comparator, which ran
+        // it O(n log n) times and rebuilt the key string on every comparison.
+        for (const c of candidates)
+            c.tier = spanTier.get(`${c.det.start}:${c.det.end}`);
         // Span length outranks *everything*, including validation.
         //
         // A shorter candidate winning re-cuts a longer one and leaves the
@@ -492,7 +525,7 @@ class RuleEngine {
         // country-blind up to and including `start`, and (length, start) already
         // identifies a span uniquely.
         const sorted = [...candidates].sort((a, b) => b.length - a.length || // longest first     } country-blind
-            tierOf(b) - tierOf(a) || // best tier here    } — decides
+            b.tier - a.tier || // best tier here    } — decides
             a.det.start - b.det.start || // leftmost          } WHICH span
             b.cue - a.cue || // local cue         } country-aware
             b.priority - a.priority || // country priority  } — decides the

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");
@@ -12,15 +13,29 @@ function getContext(text, start, end) {
 }
 // Unicode-safe word boundary: negative lookahead for any letter (including accented)
 const _UWB = "(?![a-zA-Z\\u00C0-\\u024F\\u0400-\\u04FF])";
-const CURRENCY_AFTER = new RegExp(`^\\s*(?:EUR|€|\\$|USD|GBP|£|CHF|ISK|SEK|NOK|DKK|euro|euros|dollar|dollars|pond|kronor|kroner|kr)${_UWB}`, "i");
-const CURRENCY_COMMA_AFTER = new RegExp(`^[.,]\\d{1,2}\\s*(?:EUR|€|\\$|USD|GBP|£|CHF|ISK|SEK|NOK|DKK|euro|euros|kr(?:onor|oner)?|pond)${_UWB}`, "i");
-const CURRENCY_BEFORE = /(?:EUR|€|\$|USD|GBP|£|CHF|ISK|SEK|NOK|DKK)\s*$/;
-const AMOUNT_LABEL_BEFORE = /(?:Montant|Beløb|Summa|Summe|Bedrag|Amount|Total|TTC|inkl|Upphæð)\s*:?\s*$/i;
+// Symbols are held apart from the alphabetic codes because a word boundary
+// after "€" is meaningless — the symbol is not a word character. Python used a
+// bare "\b" here and so could never match "1163 €," at all; this port used the
+// lookahead below and did not have that defect. Kept split so the difference
+// cannot come back.
+const CURRENCY_SYMBOL = "€|\\$|£|¥|₺|zł|Kč|лв|kn|Ft|₽";
+const CURRENCY_WORD = "EUR|USD|GBP|CHF|ISK|SEK|NOK|DKK|PLN|CZK|HUF|RON|BGN|HRK|" +
+    "euro|euros|dollar|dollars|pond|kronor|kroner|kronur|kr|" +
+    "złoty|korun|forint|lei|leva";
+const CURRENCY_AFTER = new RegExp(`^\\s*(?:(?:${CURRENCY_SYMBOL})|(?:${CURRENCY_WORD})${_UWB})`, "i");
+const CURRENCY_COMMA_AFTER = new RegExp(`^[.,]\\d{1,2}\\s*(?:(?:${CURRENCY_SYMBOL})|(?:${CURRENCY_WORD})${_UWB})`, "i");
+const CURRENCY_BEFORE = new RegExp(`(?:(?:${CURRENCY_SYMBOL})|\\b(?:${CURRENCY_WORD}))\\s*$`, "i");
+const AMOUNT_LABEL_BEFORE = /\b(?:Montant|Beløb|Summa|Summe|Bedrag|Amount|Total|TTC|inkl|Upphæð|Importe|Importo|Valore|Wartość|Kwota|Částka|Összeg|Sum|Beloop|Prix|Preis|Price|Loyer|Miete|Huur|Rent|Betrag)\s*(?:\w+\s*)?:?\s*$/i;
 // Use Unicode-aware word boundary via \p{L} negative lookahead instead of \b
 // because JS \b is ASCII-only and fails on Unicode letters (e.g. "München" → \bm\b matches M before ü)
 const UNIT_AFTER = /^\s*(?:kg|km|cm|mm|m[²³]|ml|mg|GB|MB|KB|TB|%|jaar|maanden|weken|dagen|uur|minuten|seconden|stuks|pcs|pieces|ans|mois|semaines|jours|heures|Jahre|Monate|Wochen|Tage|Stunden)(?![a-zA-Z\u00C0-\u024F\u0400-\u04FF])/i;
 // Same missing-boundary flaw: "ref" matched the tail of "kortref".
-const REFERENCE_BEFORE = /\b(?:dossier|ref\.?|referentie|reference|référence|factuurnummer|invoice\s*(?:nr|number|no)?|bestelnummer|order\s*(?:nr|number|no)?|kenmerk|ordernummer|Aktenzeichen|numéro\s*de\s*(?:dossier|facture|commande)|bestellnummer|Rechnungsnummer|artikelnr|article\s*no|contract\s*(?:nr|number|no)?|pagina|page|Seite|blz\.?|Facture\s*n[°o]?|Faktura\s*n[°or]\.?|Lasku\s*n[°or]o?\.?|Rechnung\s*(?:Nr|n[°o])?|faktura\s*(?:nr|n[°o])?|bestilling\s*(?:nr|n[°o])?|bestelling\s*n[°or]\.?|Reikningur\s*nr|Factuur\s*n[ro]?\.?|Nota\s*n[ro]?\.?)\s*[:.]?\s*$/i;
+const REFERENCE_BEFORE = /\b(?:dossier|ref\.?|referentie|reference|référence|factuurnummer|invoice\s*(?:nr|number|no)?|bestelnummer|order\s*(?:nr|number|no)?|kenmerk|ordernummer|Aktenzeichen|numéro\s*de\s*(?:dossier|facture|commande)|bestellnummer|Rechnungsnummer|artikelnr|article\s*no|contract\s*(?:nr|number|no)?|pagina|page|Seite|blz\.?|Facture\s*n[°o]?|Faktura\s*n[°or]\.?|Lasku\s*n[°or]o?\.?|Rechnung\s*(?:Nr|n[°o])?|faktura\s*(?:nr|n[°o])?|bestilling\s*(?:nr|n[°o])?|bestelling\s*n[°or]\.?|Reikningur\s*nr|ticket|incident\s*(?:report|nr|no)?|case\s*(?:nr|no|id)?|zaaknummer|meldingsnummer|Vorgangsnummer|Vorgang|Störungsmeldung|saksnummer|ärendenummer|sagsnummer|asianumero|Factuur\s*n[ro]?\.?|Nota\s*n[ro]?\.?)\s*[:.#]?\s*$/i;
+// "#" before a number marks a reference in every language in scope — a ticket,
+// an order, a line item — and never a postcode or a national identifier.
+const HASH_BEFORE = /#\s*$/;
+// A short uppercase tag hyphenated to the number: "IR-43433", "INC-2024".
+const REF_PREFIX_BEFORE = /(?:^|[\s([])[A-Z]{2,5}-$/;
 const LEGAL_BEFORE = /(?:Art(?:ikel|icle|\.)|§|Artikel|Section|Sectie|Afdeling|paragraaf|Absatz|alinéa|punt|point|Punkt|lid)\s*$/i;
 const MATH_BEFORE = /[=+\-×÷*/]\s*$/;
 const MATH_AFTER = /^\s*[=+\-×÷*/]/;
@@ -52,7 +67,11 @@ const MONTH_NAMES = "january|february|march|april|may|june|july|august|september
     "|gennaio|febbraio|marzo|aprile|maggio|giugno|luglio|agosto|settembre|ottobre|dicembre" +
     "|enero|febrero|abril|mayo|junio|julio|septiembre|octubre|noviembre|diciembre" +
     "|janeiro|fevereiro|março|marco|maio|junho|julho|setembro|outubro|novembro|dezembro" +
-    "|marts|augusti" +
+    // "desember" (nb/nn/is) was the one December spelling missing from a list
+    // that already carried ten others — "1. desember 2025" was a Norwegian
+    // postcode because of it.
+    "|marts|augusti|desember" +
+    "|janúar|febrúar|apríl|maí|júní|júlí|ágúst|nóvember" +
     "|tammikuu|helmikuu|maaliskuu|huhtikuu|toukokuu|kesäkuu|heinäkuu|elokuu|syyskuu|lokakuu|marraskuu|joulukuu" +
     "|jaanuar|veebruar|aprill|juuni|juuli|oktoober|detsember" +
     "|janvāris|februāris|aprīlis|maijs|jūnijs|jūlijs|augusts|septembris|oktobris|novembris|decembris" +
@@ -77,7 +96,11 @@ const DATE_AFTER = /^[./-]\d{1,2}[./-]\d{1,2}\b/;
  * ISO 4217 codes made only of the consonants a Spanish plate accepts, so a money
  * amount reads as a registration. This is why "2297 DKK" was a plate.
  */
-const CURRENCY_CODE = "(?:DKK|SEK|NOK|ISK|CZK|PLN|HUF|RON|BGN|HRK|CHF|GBP|TRY|RSD|MKD|BYN|KZT|CNY|JPY|KRW|ZAR|BRL|MXN|CLP|COP|PLZ|SKK|TRL)";
+// Crypto tickers are the same shape and the same mistake — every surviving
+// plate false positive was "4499 BTC" or a sibling. A ticker is a unit, exactly
+// as an ISO 4217 code is.
+const CURRENCY_CODE = "(?:DKK|SEK|NOK|ISK|CZK|PLN|HUF|RON|BGN|HRK|CHF|GBP|TRY|RSD|MKD|BYN|KZT|CNY|JPY|KRW|ZAR|BRL|MXN|CLP|COP|PLZ|SKK|TRL" +
+    "|BTC|ETH|LTC|XRP|BCH|XLM|XMR|DOT|SOL|ADA|TRX|DOGE|USDT|USDC)";
 const CURRENCY_CODE_TAIL = new RegExp(`\\s${CURRENCY_CODE}$`);
 const CURRENCY_CODE_AFTER = new RegExp(`^\\s*${CURRENCY_CODE}\\b`);
 /** Log-timestamp tails, which the ":"-anchored secret rule picks up. */
@@ -91,6 +114,32 @@ const NOT_A_SECRET = new RegExp("^(?:af|ap|ca|cn|eu|il|me|sa|us|gov)-(?:north|so
 const EXACT_UUID = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/;
 const BIC_SHAPE = /^[A-Z]{6}[A-Z0-9]{2}(?:[A-Z0-9]{3})?$/;
 const BIC_CUE_BEFORE = /(?:BIC|SWIFT|BIC\/SWIFT)\s*[:=]?\s*\(?\s*$/i;
+/** An email address, exactly. Same argument as the UUID and the BIC. */
+const EXACT_EMAIL = /^[\w.!#$%&'*+/=?^`{|}~-]+@[\w-]+(?:\.[\w-]+)+$/;
+/**
+ * A URL, or the tail of one after the scheme has been split off. The secret
+ * rules anchor on ":" and "=", so "https://api.sendgrid.com/v3/mail/send" hands
+ * them "//api.sendgrid.com/v3/mail/send" and a slash-separated path scores as
+ * high-entropy. An endpoint is published documentation, not a credential.
+ */
+const URL_LIKE = /^(?:[a-z][a-z0-9+.-]*:)?\/\/[^\s/]+(?:\/\S*)?$|^[a-z0-9-]+(?:\.[a-z0-9-]+)*\.[a-z]{2,}(?::\d{1,5})?(?:\/\S*)?$/i;
+/**
+ * A URL that *carries* a credential is the opposite case, and it is the common
+ * one: "mongodb://admin:DFKDKi1eb51OOhuHPYz@rds-main.eu-west-1.rds.amazonaws.com"
+ * is a connection string with a live password in it. Suppressing those as "just
+ * a URL" lost 347 real secrets, so the endpoint test must not fire when userinfo
+ * or a credential-bearing query parameter is present.
+ */
+const URL_WITH_CREDENTIALS = /^(?:[a-z][a-z0-9+.-]*:)?\/\/[^/@\s]*:[^/@\s]*@|[?&](?:api_?key|access_?token|auth|token|secret|password|pwd|sig|signature|credential)=/i;
+/** An LDAP distinguished name: "cn=github-actions,dc=corp,dc=eu". */
+const LDAP_DN = /^(?:cn|ou|dc|uid|o|l|st|c)=[^,=]+(?:,\s*(?:cn|ou|dc|uid|o|l|st|c)=[^,=]+)+$/i;
+/**
+ * Lower-case words joined by hyphens, optionally with a short id suffix:
+ * "service-account", "data-lake-33e061". The single-word test below already
+ * rejects "sozialversicherungsnummer" on the reasoning that a real secret would
+ * be mixed case; a hyphenated compound is the same token with a separator.
+ */
+const HYPHENATED_WORDS = /^[a-z]{2,}(?:-[a-z]{2,})+(?:-[0-9a-f]{4,8})?$/;
 /** A dotted quad with every octet in range. */
 const DOTTED_QUAD = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
 /** Two plausible years joined by a hyphen — a school year, a contract term. */
@@ -120,7 +169,7 @@ function suppressSecretOverStructured(text, match) {
     if (match.patternDef.entityType !== types_js_1.EntityType.SECRET)
         return false;
     const token = coreToken(match.text);
-    if (EXACT_UUID.test(token))
+    if (EXACT_UUID.test(token) || EXACT_EMAIL.test(token))
         return true;
     if (BIC_SHAPE.test(token)) {
         return BIC_CUE_BEFORE.test(text.slice(Math.max(0, match.start - 24), match.start));
@@ -145,6 +194,12 @@ function suppressSecretNotASecret(_text, match) {
         return true;
     if (NOT_A_SECRET.test(bare))
         return true;
+    if (URL_LIKE.test(bare) && !URL_WITH_CREDENTIALS.test(bare))
+        return true;
+    if (LDAP_DN.test(bare))
+        return true;
+    if (HYPHENATED_WORDS.test(bare))
+        return true;
     const alpha = /^[A-Za-zÀ-ÿ]+$/.test(bare);
     const oneWord = bare === bare.toLowerCase() ||
         (bare.slice(0, 1) === bare.slice(0, 1).toUpperCase() &&
@@ -205,15 +260,34 @@ function suppressUnits(text, match) {
     const [, after] = getContext(text, match.start, match.end);
     return UNIT_AFTER.test(after);
 }
+/**
+ * Suppress numbers preceded by reference/invoice/dossier keywords.
+ *
+ * POSTAL_CODE belongs here for the same reason every other numeric type does,
+ * and its absence was an oversight: a five-digit ticket number sits in exactly
+ * the shape a German or French postcode occupies, so "Ticket #94730" and
+ * "Incident report IR-43433" were masked as addresses.
+ *
+ * "#" and "XX-" are checked adjacently rather than through the 150-character
+ * 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]);
+    const applicable = REFERENCE_TYPES;
     if (!applicable.has(match.patternDef.entityType))
         return false;
     const [before] = getContext(text, match.start, match.end);
-    return REFERENCE_BEFORE.test(before);
+    if (REFERENCE_BEFORE.test(before))
+        return true;
+    const adjacent = text.slice(Math.max(0, match.start - 8), match.start);
+    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);
@@ -436,8 +510,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() === "")
@@ -446,6 +527,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)
@@ -482,28 +565,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?
@@ -541,25 +670,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\-().]*$/;
@@ -664,20 +797,20 @@ const TYPE_SUPPRESSORS = {
     [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],
-    [types_js_1.EntityType.POSTAL_CODE]: [suppressCurrency, suppressUnits, suppressMath, suppressLegal, suppressYearAsPostal, suppressPostalInsideIban, suppressPostalAsHouseNumber, suppressPostalInLongerIdentifier],
+    [types_js_1.EntityType.POSTAL_CODE]: [suppressCurrency, suppressUnits, suppressMath, suppressLegal, suppressYearAsPostal, suppressPostalInsideIban, suppressPostalAsHouseNumber, suppressPostalInLongerIdentifier, suppressReference],
     [types_js_1.EntityType.BIC]: [suppressBicWithoutEvidence],
     [types_js_1.EntityType.BANK_ACCOUNT]: [suppressReference],
     [types_js_1.EntityType.LICENSE_PLATE]: [suppressPlateInCompound, suppressDePlateUnknownDistrict, suppressPlateAsCurrencyAmount],
     [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)