euredact 0.3.4 → 0.3.6

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

@@ -194,7 +194,7 @@ const BE = {
         p(types_js_1.EntityType.NATIONAL_ID, String.raw `\b\d{2}\.?\d{2}\.?\d{2}[\-.]?\d{3}\.?\d{2}\b`, "belgian_nn"),
         p(types_js_1.EntityType.IBAN, String.raw `\bBE\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\b`, "iban"),
         p(types_js_1.EntityType.VAT, String.raw `\bBE\s?0\d{3}\.?\d{3}\.?\d{3}\b`, "belgian_vat"),
-        p(types_js_1.EntityType.CHAMBER_OF_COMMERCE, String.raw `\b0\d{3}\.?\d{3}\.?\d{3}\b`, null, "", ["KBO", "BCE", "ondernemingsnummer", "numéro d'entreprise", "enterprise number", "bedrijfsnummer"], true),
+        p(types_js_1.EntityType.CHAMBER_OF_COMMERCE, String.raw `\b0\d{3}\.?\d{3}\.?\d{3}\b`, null, "", ["KBO", "BCE", "ondernemingsnummer", "numéro d'entreprise", "enterprise number", "bedrijfsnummer", "Kruispuntbank", "Banque-Carrefour", "Banque Carrefour", "Ondernemingen", "Entreprises", "onder nummer"], true),
         p(types_js_1.EntityType.PHONE, String.raw `\b0[1-9]\d{0,2}[/\s.\-]?\d{2,3}[.\s\-]?\d{2,3}[.\s\-]?\d{2,3}\b`),
         p(types_js_1.EntityType.PHONE, String.raw `\+32\s?\d{1,3}[\s.\-]?\d{2,3}[\s.\-]?\d{2}[\s.\-]?\d{2}`),
         p(types_js_1.EntityType.PASSPORT, String.raw `\b[A-Z]{2}\d{6}\b`, null, "", ["paspoort", "passport", "passeport", "reisdocument", "travel document", "document de voyage"], true),
@@ -387,8 +387,15 @@ const ES = {
         p(types_js_1.EntityType.PHONE, String.raw `\b[679]\d{2}[\s\-]?\d{3}[\s\-]?\d{3}\b`),
         p(types_js_1.EntityType.PHONE, String.raw `\b[679]\d{8}\b`),
         p(types_js_1.EntityType.PHONE, String.raw `\b[679]\d[\s\-]?\d{3}[\s\-]?\d{2}[\s\-]?\d{2}\b`),
+        // 3-2-2-2. Just as common as the groupings above and absent until now:
+        // "705 97 55 11" matched no phone pattern at all, which cost 674 Spanish
+        // numbers — the single largest PHONE gap.
+        p(types_js_1.EntityType.PHONE, String.raw `\b[679]\d{2}[\s\-]?\d{2}[\s\-]?\d{2}[\s\-]?\d{2}\b`),
         p(types_js_1.EntityType.PHONE, String.raw `\+34\s?[679]\d{2}[\s\-]?\d{3}[\s\-]?\d{3}`),
-        p(types_js_1.EntityType.LICENSE_PLATE, String.raw `\b\d{4}\s?[BCDFGHJKLMNPRSTVWXYZ]{3}\b`),
+        // A single space, not \s: \s matched a line break, so a year ending one
+        // line and a label starting the next ("2002\nCPR") read as one
+        // registration — 310 times across the corpus.
+        p(types_js_1.EntityType.LICENSE_PLATE, String.raw `\b\d{4}[ ]?[BCDFGHJKLMNPRSTVWXYZ]{3}\b`),
         p(types_js_1.EntityType.POSTAL_CODE, String.raw `\b(?:0[1-9]|[1-4]\d|5[0-2])\d{3}\b`, null, "", ["código postal", "C.P.", "CP", "dirección", "domicilio", "calle", "avenida", "plaza", "paseo", "camino", "Postal:"], true),
     ],
 };

package/dist/cjs/rules/engine.js

@@ -90,6 +90,46 @@ function warnUnknownCountry(code) {
         `shared country-independent patterns only (email, IBAN, international ` +
         `phone, credit card, ...). Available: ${available.join(", ")}`);
 }
+// ── Local cues: what the document calls the value next to it ────────────
+//
+// Country evidence resolves which *national scheme* owns an ambiguous value, but
+// it never looks at the label sitting immediately in front of it. So
+// "Phone: 0705237535" was reported as a Swedish national ID: the digits pass
+// that checksum, the document is Swedish, and nothing consulted the word
+// "Phone".
+//
+// A cue touching the span is the strongest statement the document makes about
+// what the value *is*, so it outranks the checksum — but only among candidates
+// covering the **same span**, so it decides the label and can never change which
+// characters are masked. That is what keeps invariant I1 intact.
+//
+// Measured: 263 phone numbers and 18 French SIREN were reported as national IDs,
+// each with an explicit cue in front of it.
+const LOCAL_CUES = [
+    [types_js_1.EntityType.PHONE,
+        /(?:phone|tel|telephone|téléphone|telefoon|telefon|telefono|teléfono|tlf|mobil|mobile|gsm|handy|sími|puh|móvil|cell)\w*\s*[:.\-]?\s*$/i],
+    [types_js_1.EntityType.CHAMBER_OF_COMMERCE,
+        /(?:siren|siret|kbo|bce|kvk|ondernemingsnummer|handelsregister|company\s*(?:no|number|reg)|organisationsnummer|orgnr)\w*\s*[:.\-]?\s*$/i],
+    [types_js_1.EntityType.VAT,
+        /(?:vat|btw|tva|ust|iva|moms|alv|mwst)[\w.\-]*\s*[:.\-]?\s*$/i],
+    [types_js_1.EntityType.BIC,
+        /(?:bic|swift)[\w/]*\s*[:.\-]?\s*\(?\s*$/i],
+    [types_js_1.EntityType.NATIONAL_ID,
+        /(?:bsn|personnummer|rijksregisternummer|national\s*id|identiteitsnummer|henkilötunnus|kennitala|cpr|nif|dni)\w*\s*[:.\-]?\s*$/i],
+];
+// 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.
+const CUE_WINDOW = 22;
+/** 1 when a cue naming `entityType` sits immediately before the span. */
+function localCueBonus(text, start, entityType) {
+    const before = text.slice(Math.max(0, start - CUE_WINDOW), start);
+    for (const [cuedType, pattern] of LOCAL_CUES) {
+        if (cuedType === entityType && pattern.test(before))
+            return 1;
+    }
+    return 0;
+}
 class RuleEngine {
     matcher = new matchers_js_1.MultiPatternMatcher();
     loadedCountries = new Set();
@@ -373,6 +413,7 @@ class RuleEngine {
                 ? match.countryCode : null;
             candidates.push({
                 blindPriority,
+                cue: localCueBonus(text, match.start, match.patternDef.entityType),
                 priority,
                 length: match.end - match.start,
                 countryScore: countryScores.get(match.countryCode) ?? 0,
@@ -390,7 +431,7 @@ class RuleEngine {
             });
         }
         for (const d of (0, structural_js_1.detectStructuralDob)(text)) {
-            candidates.push({ blindPriority: 1, priority: 1, length: d.end - d.start,
+            candidates.push({ blindPriority: 1, cue: 0, priority: 1, length: d.end - d.start,
                 countryScore: 0, inScope: 1, det: d });
         }
         const detections = this.deduplicate(candidates);
@@ -453,9 +494,10 @@ class RuleEngine {
         const sorted = [...candidates].sort((a, b) => b.length - a.length || // longest first     } country-blind
             tierOf(b) - tierOf(a) || // best tier here    } — decides
             a.det.start - b.det.start || // leftmost          } WHICH span
-            b.priority - a.priority || // country priority  } country-aware
-            b.countryScore - a.countryScore || // country evidence  } — decides the
-            b.inScope - a.inScope); // declared scope    } LABEL only
+            b.cue - a.cue || // local cue         } country-aware
+            b.priority - a.priority || // country priority  } — decides the
+            b.countryScore - a.countryScore || // country evidence  } LABEL only
+            b.inScope - a.inScope); // declared scope    }
         const result = [];
         const occupied = new Set();
         for (const { det } of sorted) {

package/dist/cjs/rules/suppressors.js

@@ -12,14 +12,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;
-const REFERENCE_BEFORE = /(?: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)\s*[:.]?\s*$/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|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*[=+\-×÷*/]/;
@@ -28,12 +43,204 @@ 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
-const ID_LABEL_BEFORE = /(?: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;
+// 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;
 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;
 const SE_ORG_CONTEXT_BEFORE = /(?:org\.?\s*nr\.?|organisationsnummer|organisationsnr|Bolagsverket|företag)\s*[:.]?\s*$/i;
 const NUMERIC_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.POSTAL_CODE]);
+// ── Date adjacency, for the postal-code year gate ───────────────────────
+//
+// Month names in the languages this engine covers. Long, but it is data: the
+// alternative is a proximity heuristic, and proximity is what caused the defect
+// this guards against. Kept in sync with the Python SDK's suppressors.py.
+const MONTH_NAMES = "january|february|march|april|may|june|july|august|september|october|november|december" +
+    "|jan|feb|mar|apr|jun|jul|aug|sep|sept|oct|nov|dec" +
+    "|januar|jänner|februar|märz|mai|juni|juli|oktober|dezember|dez|okt|mrz" +
+    "|janvier|février|mars|avril|juin|juillet|août|aout|septembre|octobre|novembre|décembre|decembre" +
+    "|januari|februari|maart|mei|augustus|mrt" +
+    "|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" +
+    // "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" +
+    "|stycznia|lutego|marca|kwietnia|maja|czerwca|lipca|sierpnia|września|października|listopada|grudnia" +
+    "|ledna|února|března|dubna|května|června|července|srpna|září|října|listopadu|prosince" +
+    "|marec|junij|julij|avgust|siječnja|veljače|ožujka|travnja|svibnja|lipnja|srpnja|kolovoza|rujna|studenoga|prosinca" +
+    "|március|április|május|június|július|augusztus|szeptember|október" +
+    "|ianuarie|februarie|martie|aprilie|iunie|iulie|septembrie|octombrie|noiembrie|decembrie" +
+    "|ιανουαρίου|φεβρουαρίου|μαρτίου|απριλίου|μαΐου|ιουνίου|ιουλίου|αυγούστου|σεπτεμβρίου|οκτωβρίου|νοεμβρίου|δεκεμβρίου" +
+    "|януари|февруари|март|април|май|юни|юли|август|септември|октомври|ноември|декември";
+/** "since" cues, which introduce a bare year in every one of these languages. */
+const SINCE_CUES = "seit|since|depuis|sinds|sedert|vanaf|desde|dal|od|sedan|siden|alates|alkaen|από|от|din|iz|ab";
+/**
+ * A month name, a "since" cue, or a numeric date tail immediately before the
+ * candidate. Adjacent-only on purpose — a cue 150 characters away is what made
+ * this a bug in the first place.
+ */
+const DATE_BEFORE = new RegExp(`(?:\\b(?:${MONTH_NAMES})\\b\\.?|\\b(?:${SINCE_CUES})\\b|\\d{1,2}[./-]\\d{1,2}[./-])\\s*$`, "iu");
+/** A date separator immediately after, making the candidate a leading year. */
+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.
+ */
+// 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. */
+const TIMESTAMP_FRAGMENT = /^\d{1,2}:\d{2}(?::\d{2})?(?:[.,]\d{1,6})?Z?$/;
+/** Cloud region names and similar well-known configuration values. */
+const NOT_A_SECRET = new RegExp("^(?:af|ap|ca|cn|eu|il|me|sa|us|gov)-(?:north|south|east|west|central" +
+    "|northeast|northwest|southeast|southwest)-\\d[a-z]?$" +
+    "|^(?:application|text|image|audio|video|multipart)/[\\w.+-]+$" +
+    "|^(?:utf|iso|windows)-[\\d-]+$" +
+    "|^(?:no-cache|no-store|max-age|gzip|deflate|identity|chunked)\\b", "i");
+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. */
+const YEAR_RANGE = /^(19|20)\d{2}\s?[-–/]\s?(19|20)\d{2}$/;
+/** A digit and a decimal point immediately before, so the match is a fraction. */
+const DECIMAL_TAIL_BEFORE = /\d[.,]$/;
+/**
+ * Punctuation the greedy "[^\s]{8,}" secret rule sweeps up with the token: it
+ * matched "TRIONL2U)." out of "(BIC: TRIONL2U).". Stripped only for the shape
+ * tests — the emitted span is never altered here.
+ */
+const PUNCT_EDGES = /^[\s([{<"'`]+|[\s)\]}>"'`.,;:!?]+$/g;
+function coreToken(raw) {
+    return raw.replace(PUNCT_EDGES, "").replace(PUNCT_EDGES, "");
+}
+/**
+ * A generic secret must not claim a span that is a specific known type.
+ *
+ * The high-entropy rules are deliberately broad and they carry a validator, so
+ * they reach the top priority tier while the structured detector for the same
+ * characters sits at the bottom with nothing to offer. Measured on 152,300
+ * documents: 687 UUIDs and 140 BICs were reported as SECRET, each counted twice
+ * over — a false positive for SECRET and a miss for the type that should have
+ * had it.
+ */
+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) || 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));
+    }
+    return false;
+}
+/**
+ * Reject the three things the ":"-anchored secret rule reliably mistakes:
+ * timestamps ("57:22.283Z]"), ordinary words ("Sozialversicherungsnummer") and
+ * region names ("us-east-1"). All three sit after a colon or equals sign, which
+ * is all that rule asks for, and all three clear the entropy threshold.
+ *
+ * The word test is narrow on purpose: purely alphabetic *and* shaped like one
+ * natural word. A random all-letter token would be mixed case and is left alone
+ * — losing a real secret is the expensive direction.
+ */
+function suppressSecretNotASecret(_text, match) {
+    if (match.patternDef.entityType !== types_js_1.EntityType.SECRET)
+        return false;
+    const bare = coreToken(match.text);
+    if (TIMESTAMP_FRAGMENT.test(bare))
+        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() &&
+            bare.slice(1) === bare.slice(1).toLowerCase());
+    return alpha && oneWord;
+}
+/**
+ * A money amount followed by its ISO 4217 code is not a registration. Spain's
+ * plate shape is four digits then three consonants, and the Nordic and Central
+ * European currency codes are all consonants: "2297 DKK" read as a Spanish plate
+ * 487 times across the corpus.
+ */
+function suppressPlateAsCurrencyAmount(text, match) {
+    if (match.patternDef.entityType !== types_js_1.EntityType.LICENSE_PLATE)
+        return false;
+    if (CURRENCY_CODE_TAIL.test(match.text))
+        return true;
+    return CURRENCY_CODE_AFTER.test(text.slice(match.end, match.end + 12));
+}
+/**
+ * A dotted quad is an address, not a tax number. Germany's tax-number shape
+ * allows dots between its digit groups, which makes it a superset of IPv4. The
+ * address is still redacted — the IP_ADDRESS rule claims the same span — so this
+ * only corrects the label.
+ */
+function suppressTaxidAsIpAddress(_text, match) {
+    if (match.patternDef.entityType !== types_js_1.EntityType.TAX_ID)
+        return false;
+    return DOTTED_QUAD.test(match.text.trim());
+}
+/**
+ * Reject two phone shapes that are arithmetic rather than contact details: a
+ * year range ("Schooljaar 2025-2026") and the fractional part of a decimal
+ * amount ("0.034865 BTC"). Both clear every phone pattern's shape test.
+ */
+function suppressPhoneAsNumberRange(text, match) {
+    if (match.patternDef.entityType !== types_js_1.EntityType.PHONE)
+        return false;
+    if (YEAR_RANGE.test(match.text.trim()))
+        return true;
+    return DECIMAL_TAIL_BEFORE.test(text.slice(Math.max(0, match.start - 2), match.start));
+}
 function suppressCurrency(text, match) {
     if (!NUMERIC_TYPES.has(match.patternDef.entityType))
         return false;
@@ -52,12 +259,27 @@ 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.
+ */
 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 = 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]);
     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]);
@@ -90,6 +312,16 @@ function suppressYearAsPostal(text, match) {
     const clean = match.text.trim();
     if (!RECENT_YEAR.test(clean))
         return false;
+    // A date construction *touching* the candidate settles it, whatever the rest
+    // of the document says. Without this, the postal-context test below rescued
+    // every year in every document with an address in it — and "Adresse", "rue"
+    // and "Str." appear in the header of essentially every business letter.
+    // Measured: 1,691 of 3,322 postal false positives were plausible years,
+    // 1,636 of them literally "2025".
+    if (DATE_BEFORE.test(text.slice(Math.max(0, match.start - 24), match.start)))
+        return true;
+    if (DATE_AFTER.test(text.slice(match.end, match.end + 8)))
+        return true;
     const [before, after] = getContext(text, match.start, match.end);
     const context = before + after;
     // Keep as postal code if postal/address context nearby
@@ -453,22 +685,59 @@ function suppressPostalInLongerIdentifier(text, match) {
         return true;
     return false;
 }
+/**
+ * A delimited data row: at least three fields separated by one delimiter.
+ * Export formats carry their meaning in the column, not in a nearby word, so a
+ * value filling an entire field has structural context even when the line
+ * contains no cue.
+ */
+const DELIMITED_ROW = /^[^\n]*?([,;|\t])[^\n]*?\1[^\n]*?\1/;
+/**
+ * Types for which filling a delimited field counts as context. Narrow shapes
+ * only: applied to every type it was measured a net loss — SECRET gained 1,678
+ * false positives, CHAMBER_OF_COMMERCE 456 and POSTAL_CODE 295. A broad shape
+ * plus a required cue is a deliberate pairing, and removing the cue leaves only
+ * the broad shape.
+ */
+const DELIMITED_FIELD_TYPES = new Set([
+    types_js_1.EntityType.PHONE, types_js_1.EntityType.DOB, types_js_1.EntityType.DATE_OF_DEATH,
+]);
+/** True when the span is exactly one field of a delimited row. */
+function fillsADelimitedField(text, start, end) {
+    const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+    let lineEnd = text.indexOf("\n", end);
+    if (lineEnd < 0)
+        lineEnd = text.length;
+    if (!DELIMITED_ROW.test(text.slice(lineStart, lineEnd)))
+        return false;
+    const before = text.slice(lineStart, start);
+    const after = text.slice(end, lineEnd);
+    const opens = before === "" || ",;|\t".includes(before[before.length - 1]);
+    const closes = after === "" || ",;|\t".includes(after[0]);
+    return opens && closes;
+}
 function suppressRequiresContext(text, match) {
     if (!match.patternDef.requiresContext || match.patternDef.contextKeywords.length === 0)
         return false;
+    // A value filling an entire field of a delimited row is introduced by its
+    // column, not by a word, so that is context — but only for narrow shapes.
+    if (DELIMITED_FIELD_TYPES.has(match.patternDef.entityType) &&
+        fillsADelimitedField(text, match.start, match.end))
+        return false;
     const [before, after] = getContext(text, match.start, match.end);
     const context = (before + " " + after).toLowerCase();
     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],
+    [types_js_1.EntityType.PHONE]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressPhoneAfterIdLabel, 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],
-    [types_js_1.EntityType.POSTAL_CODE]: [suppressCurrency, suppressUnits, suppressMath, suppressLegal, suppressYearAsPostal, suppressPostalInsideIban, suppressPostalAsHouseNumber, suppressPostalInLongerIdentifier],
+    [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, suppressReference],
     [types_js_1.EntityType.BIC]: [suppressBicWithoutEvidence],
     [types_js_1.EntityType.BANK_ACCOUNT]: [suppressReference],
-    [types_js_1.EntityType.LICENSE_PLATE]: [suppressPlateInCompound, suppressDePlateUnknownDistrict],
+    [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) {

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

@@ -191,7 +191,7 @@ const BE = {
         p(EntityType.NATIONAL_ID, String.raw `\b\d{2}\.?\d{2}\.?\d{2}[\-.]?\d{3}\.?\d{2}\b`, "belgian_nn"),
         p(EntityType.IBAN, String.raw `\bBE\d{2}\s?\d{4}\s?\d{4}\s?\d{4}\b`, "iban"),
         p(EntityType.VAT, String.raw `\bBE\s?0\d{3}\.?\d{3}\.?\d{3}\b`, "belgian_vat"),
-        p(EntityType.CHAMBER_OF_COMMERCE, String.raw `\b0\d{3}\.?\d{3}\.?\d{3}\b`, null, "", ["KBO", "BCE", "ondernemingsnummer", "numéro d'entreprise", "enterprise number", "bedrijfsnummer"], true),
+        p(EntityType.CHAMBER_OF_COMMERCE, String.raw `\b0\d{3}\.?\d{3}\.?\d{3}\b`, null, "", ["KBO", "BCE", "ondernemingsnummer", "numéro d'entreprise", "enterprise number", "bedrijfsnummer", "Kruispuntbank", "Banque-Carrefour", "Banque Carrefour", "Ondernemingen", "Entreprises", "onder nummer"], true),
         p(EntityType.PHONE, String.raw `\b0[1-9]\d{0,2}[/\s.\-]?\d{2,3}[.\s\-]?\d{2,3}[.\s\-]?\d{2,3}\b`),
         p(EntityType.PHONE, String.raw `\+32\s?\d{1,3}[\s.\-]?\d{2,3}[\s.\-]?\d{2}[\s.\-]?\d{2}`),
         p(EntityType.PASSPORT, String.raw `\b[A-Z]{2}\d{6}\b`, null, "", ["paspoort", "passport", "passeport", "reisdocument", "travel document", "document de voyage"], true),
@@ -384,8 +384,15 @@ const ES = {
         p(EntityType.PHONE, String.raw `\b[679]\d{2}[\s\-]?\d{3}[\s\-]?\d{3}\b`),
         p(EntityType.PHONE, String.raw `\b[679]\d{8}\b`),
         p(EntityType.PHONE, String.raw `\b[679]\d[\s\-]?\d{3}[\s\-]?\d{2}[\s\-]?\d{2}\b`),
+        // 3-2-2-2. Just as common as the groupings above and absent until now:
+        // "705 97 55 11" matched no phone pattern at all, which cost 674 Spanish
+        // numbers — the single largest PHONE gap.
+        p(EntityType.PHONE, String.raw `\b[679]\d{2}[\s\-]?\d{2}[\s\-]?\d{2}[\s\-]?\d{2}\b`),
         p(EntityType.PHONE, String.raw `\+34\s?[679]\d{2}[\s\-]?\d{3}[\s\-]?\d{3}`),
-        p(EntityType.LICENSE_PLATE, String.raw `\b\d{4}\s?[BCDFGHJKLMNPRSTVWXYZ]{3}\b`),
+        // A single space, not \s: \s matched a line break, so a year ending one
+        // line and a label starting the next ("2002\nCPR") read as one
+        // registration — 310 times across the corpus.
+        p(EntityType.LICENSE_PLATE, String.raw `\b\d{4}[ ]?[BCDFGHJKLMNPRSTVWXYZ]{3}\b`),
         p(EntityType.POSTAL_CODE, String.raw `\b(?:0[1-9]|[1-4]\d|5[0-2])\d{3}\b`, null, "", ["código postal", "C.P.", "CP", "dirección", "domicilio", "calle", "avenida", "plaza", "paseo", "camino", "Postal:"], true),
     ],
 };

package/dist/esm/rules/engine.js

@@ -53,6 +53,46 @@ function warnUnknownCountry(code) {
         `shared country-independent patterns only (email, IBAN, international ` +
         `phone, credit card, ...). Available: ${available.join(", ")}`);
 }
+// ── Local cues: what the document calls the value next to it ────────────
+//
+// Country evidence resolves which *national scheme* owns an ambiguous value, but
+// it never looks at the label sitting immediately in front of it. So
+// "Phone: 0705237535" was reported as a Swedish national ID: the digits pass
+// that checksum, the document is Swedish, and nothing consulted the word
+// "Phone".
+//
+// A cue touching the span is the strongest statement the document makes about
+// what the value *is*, so it outranks the checksum — but only among candidates
+// covering the **same span**, so it decides the label and can never change which
+// characters are masked. That is what keeps invariant I1 intact.
+//
+// Measured: 263 phone numbers and 18 French SIREN were reported as national IDs,
+// each with an explicit cue in front of it.
+const LOCAL_CUES = [
+    [EntityType.PHONE,
+        /(?:phone|tel|telephone|téléphone|telefoon|telefon|telefono|teléfono|tlf|mobil|mobile|gsm|handy|sími|puh|móvil|cell)\w*\s*[:.\-]?\s*$/i],
+    [EntityType.CHAMBER_OF_COMMERCE,
+        /(?:siren|siret|kbo|bce|kvk|ondernemingsnummer|handelsregister|company\s*(?:no|number|reg)|organisationsnummer|orgnr)\w*\s*[:.\-]?\s*$/i],
+    [EntityType.VAT,
+        /(?:vat|btw|tva|ust|iva|moms|alv|mwst)[\w.\-]*\s*[:.\-]?\s*$/i],
+    [EntityType.BIC,
+        /(?:bic|swift)[\w/]*\s*[:.\-]?\s*\(?\s*$/i],
+    [EntityType.NATIONAL_ID,
+        /(?:bsn|personnummer|rijksregisternummer|national\s*id|identiteitsnummer|henkilötunnus|kennitala|cpr|nif|dni)\w*\s*[:.\-]?\s*$/i],
+];
+// 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.
+const CUE_WINDOW = 22;
+/** 1 when a cue naming `entityType` sits immediately before the span. */
+function localCueBonus(text, start, entityType) {
+    const before = text.slice(Math.max(0, start - CUE_WINDOW), start);
+    for (const [cuedType, pattern] of LOCAL_CUES) {
+        if (cuedType === entityType && pattern.test(before))
+            return 1;
+    }
+    return 0;
+}
 export class RuleEngine {
     matcher = new MultiPatternMatcher();
     loadedCountries = new Set();
@@ -336,6 +376,7 @@ export class RuleEngine {
                 ? match.countryCode : null;
             candidates.push({
                 blindPriority,
+                cue: localCueBonus(text, match.start, match.patternDef.entityType),
                 priority,
                 length: match.end - match.start,
                 countryScore: countryScores.get(match.countryCode) ?? 0,
@@ -353,7 +394,7 @@ export class RuleEngine {
             });
         }
         for (const d of detectStructuralDob(text)) {
-            candidates.push({ blindPriority: 1, priority: 1, length: d.end - d.start,
+            candidates.push({ blindPriority: 1, cue: 0, priority: 1, length: d.end - d.start,
                 countryScore: 0, inScope: 1, det: d });
         }
         const detections = this.deduplicate(candidates);
@@ -416,9 +457,10 @@ export class RuleEngine {
         const sorted = [...candidates].sort((a, b) => b.length - a.length || // longest first     } country-blind
             tierOf(b) - tierOf(a) || // best tier here    } — decides
             a.det.start - b.det.start || // leftmost          } WHICH span
-            b.priority - a.priority || // country priority  } country-aware
-            b.countryScore - a.countryScore || // country evidence  } — decides the
-            b.inScope - a.inScope); // declared scope    } LABEL only
+            b.cue - a.cue || // local cue         } country-aware
+            b.priority - a.priority || // country priority  } — decides the
+            b.countryScore - a.countryScore || // country evidence  } LABEL only
+            b.inScope - a.inScope); // declared scope    }
         const result = [];
         const occupied = new Set();
         for (const { det } of sorted) {

package/dist/esm/rules/suppressors.js

@@ -9,14 +9,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;
-const REFERENCE_BEFORE = /(?: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)\s*[:.]?\s*$/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|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*[=+\-×÷*/]/;
@@ -25,12 +40,204 @@ 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
-const ID_LABEL_BEFORE = /(?: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;
+// 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;
 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;
 const SE_ORG_CONTEXT_BEFORE = /(?:org\.?\s*nr\.?|organisationsnummer|organisationsnr|Bolagsverket|företag)\s*[:.]?\s*$/i;
 const NUMERIC_TYPES = new Set([EntityType.PHONE, EntityType.NATIONAL_ID, EntityType.SSN, EntityType.TAX_ID, EntityType.POSTAL_CODE]);
+// ── Date adjacency, for the postal-code year gate ───────────────────────
+//
+// Month names in the languages this engine covers. Long, but it is data: the
+// alternative is a proximity heuristic, and proximity is what caused the defect
+// this guards against. Kept in sync with the Python SDK's suppressors.py.
+const MONTH_NAMES = "january|february|march|april|may|june|july|august|september|october|november|december" +
+    "|jan|feb|mar|apr|jun|jul|aug|sep|sept|oct|nov|dec" +
+    "|januar|jänner|februar|märz|mai|juni|juli|oktober|dezember|dez|okt|mrz" +
+    "|janvier|février|mars|avril|juin|juillet|août|aout|septembre|octobre|novembre|décembre|decembre" +
+    "|januari|februari|maart|mei|augustus|mrt" +
+    "|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" +
+    // "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" +
+    "|stycznia|lutego|marca|kwietnia|maja|czerwca|lipca|sierpnia|września|października|listopada|grudnia" +
+    "|ledna|února|března|dubna|května|června|července|srpna|září|října|listopadu|prosince" +
+    "|marec|junij|julij|avgust|siječnja|veljače|ožujka|travnja|svibnja|lipnja|srpnja|kolovoza|rujna|studenoga|prosinca" +
+    "|március|április|május|június|július|augusztus|szeptember|október" +
+    "|ianuarie|februarie|martie|aprilie|iunie|iulie|septembrie|octombrie|noiembrie|decembrie" +
+    "|ιανουαρίου|φεβρουαρίου|μαρτίου|απριλίου|μαΐου|ιουνίου|ιουλίου|αυγούστου|σεπτεμβρίου|οκτωβρίου|νοεμβρίου|δεκεμβρίου" +
+    "|януари|февруари|март|април|май|юни|юли|август|септември|октомври|ноември|декември";
+/** "since" cues, which introduce a bare year in every one of these languages. */
+const SINCE_CUES = "seit|since|depuis|sinds|sedert|vanaf|desde|dal|od|sedan|siden|alates|alkaen|από|от|din|iz|ab";
+/**
+ * A month name, a "since" cue, or a numeric date tail immediately before the
+ * candidate. Adjacent-only on purpose — a cue 150 characters away is what made
+ * this a bug in the first place.
+ */
+const DATE_BEFORE = new RegExp(`(?:\\b(?:${MONTH_NAMES})\\b\\.?|\\b(?:${SINCE_CUES})\\b|\\d{1,2}[./-]\\d{1,2}[./-])\\s*$`, "iu");
+/** A date separator immediately after, making the candidate a leading year. */
+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.
+ */
+// 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. */
+const TIMESTAMP_FRAGMENT = /^\d{1,2}:\d{2}(?::\d{2})?(?:[.,]\d{1,6})?Z?$/;
+/** Cloud region names and similar well-known configuration values. */
+const NOT_A_SECRET = new RegExp("^(?:af|ap|ca|cn|eu|il|me|sa|us|gov)-(?:north|south|east|west|central" +
+    "|northeast|northwest|southeast|southwest)-\\d[a-z]?$" +
+    "|^(?:application|text|image|audio|video|multipart)/[\\w.+-]+$" +
+    "|^(?:utf|iso|windows)-[\\d-]+$" +
+    "|^(?:no-cache|no-store|max-age|gzip|deflate|identity|chunked)\\b", "i");
+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. */
+const YEAR_RANGE = /^(19|20)\d{2}\s?[-–/]\s?(19|20)\d{2}$/;
+/** A digit and a decimal point immediately before, so the match is a fraction. */
+const DECIMAL_TAIL_BEFORE = /\d[.,]$/;
+/**
+ * Punctuation the greedy "[^\s]{8,}" secret rule sweeps up with the token: it
+ * matched "TRIONL2U)." out of "(BIC: TRIONL2U).". Stripped only for the shape
+ * tests — the emitted span is never altered here.
+ */
+const PUNCT_EDGES = /^[\s([{<"'`]+|[\s)\]}>"'`.,;:!?]+$/g;
+function coreToken(raw) {
+    return raw.replace(PUNCT_EDGES, "").replace(PUNCT_EDGES, "");
+}
+/**
+ * A generic secret must not claim a span that is a specific known type.
+ *
+ * The high-entropy rules are deliberately broad and they carry a validator, so
+ * they reach the top priority tier while the structured detector for the same
+ * characters sits at the bottom with nothing to offer. Measured on 152,300
+ * documents: 687 UUIDs and 140 BICs were reported as SECRET, each counted twice
+ * over — a false positive for SECRET and a miss for the type that should have
+ * had it.
+ */
+function suppressSecretOverStructured(text, match) {
+    if (match.patternDef.entityType !== EntityType.SECRET)
+        return false;
+    const token = coreToken(match.text);
+    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));
+    }
+    return false;
+}
+/**
+ * Reject the three things the ":"-anchored secret rule reliably mistakes:
+ * timestamps ("57:22.283Z]"), ordinary words ("Sozialversicherungsnummer") and
+ * region names ("us-east-1"). All three sit after a colon or equals sign, which
+ * is all that rule asks for, and all three clear the entropy threshold.
+ *
+ * The word test is narrow on purpose: purely alphabetic *and* shaped like one
+ * natural word. A random all-letter token would be mixed case and is left alone
+ * — losing a real secret is the expensive direction.
+ */
+function suppressSecretNotASecret(_text, match) {
+    if (match.patternDef.entityType !== EntityType.SECRET)
+        return false;
+    const bare = coreToken(match.text);
+    if (TIMESTAMP_FRAGMENT.test(bare))
+        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() &&
+            bare.slice(1) === bare.slice(1).toLowerCase());
+    return alpha && oneWord;
+}
+/**
+ * A money amount followed by its ISO 4217 code is not a registration. Spain's
+ * plate shape is four digits then three consonants, and the Nordic and Central
+ * European currency codes are all consonants: "2297 DKK" read as a Spanish plate
+ * 487 times across the corpus.
+ */
+function suppressPlateAsCurrencyAmount(text, match) {
+    if (match.patternDef.entityType !== EntityType.LICENSE_PLATE)
+        return false;
+    if (CURRENCY_CODE_TAIL.test(match.text))
+        return true;
+    return CURRENCY_CODE_AFTER.test(text.slice(match.end, match.end + 12));
+}
+/**
+ * A dotted quad is an address, not a tax number. Germany's tax-number shape
+ * allows dots between its digit groups, which makes it a superset of IPv4. The
+ * address is still redacted — the IP_ADDRESS rule claims the same span — so this
+ * only corrects the label.
+ */
+function suppressTaxidAsIpAddress(_text, match) {
+    if (match.patternDef.entityType !== EntityType.TAX_ID)
+        return false;
+    return DOTTED_QUAD.test(match.text.trim());
+}
+/**
+ * Reject two phone shapes that are arithmetic rather than contact details: a
+ * year range ("Schooljaar 2025-2026") and the fractional part of a decimal
+ * amount ("0.034865 BTC"). Both clear every phone pattern's shape test.
+ */
+function suppressPhoneAsNumberRange(text, match) {
+    if (match.patternDef.entityType !== EntityType.PHONE)
+        return false;
+    if (YEAR_RANGE.test(match.text.trim()))
+        return true;
+    return DECIMAL_TAIL_BEFORE.test(text.slice(Math.max(0, match.start - 2), match.start));
+}
 function suppressCurrency(text, match) {
     if (!NUMERIC_TYPES.has(match.patternDef.entityType))
         return false;
@@ -49,12 +256,27 @@ 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.
+ */
 function suppressReference(text, match) {
-    const applicable = new Set([EntityType.PHONE, EntityType.NATIONAL_ID, EntityType.SSN, EntityType.TAX_ID, EntityType.IBAN, EntityType.CHAMBER_OF_COMMERCE]);
+    const applicable = new Set([EntityType.PHONE, EntityType.NATIONAL_ID, EntityType.SSN, EntityType.TAX_ID, EntityType.IBAN, EntityType.CHAMBER_OF_COMMERCE, EntityType.POSTAL_CODE]);
     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([EntityType.PHONE, EntityType.NATIONAL_ID, EntityType.POSTAL_CODE]);
@@ -87,6 +309,16 @@ function suppressYearAsPostal(text, match) {
     const clean = match.text.trim();
     if (!RECENT_YEAR.test(clean))
         return false;
+    // A date construction *touching* the candidate settles it, whatever the rest
+    // of the document says. Without this, the postal-context test below rescued
+    // every year in every document with an address in it — and "Adresse", "rue"
+    // and "Str." appear in the header of essentially every business letter.
+    // Measured: 1,691 of 3,322 postal false positives were plausible years,
+    // 1,636 of them literally "2025".
+    if (DATE_BEFORE.test(text.slice(Math.max(0, match.start - 24), match.start)))
+        return true;
+    if (DATE_AFTER.test(text.slice(match.end, match.end + 8)))
+        return true;
     const [before, after] = getContext(text, match.start, match.end);
     const context = before + after;
     // Keep as postal code if postal/address context nearby
@@ -450,22 +682,59 @@ function suppressPostalInLongerIdentifier(text, match) {
         return true;
     return false;
 }
+/**
+ * A delimited data row: at least three fields separated by one delimiter.
+ * Export formats carry their meaning in the column, not in a nearby word, so a
+ * value filling an entire field has structural context even when the line
+ * contains no cue.
+ */
+const DELIMITED_ROW = /^[^\n]*?([,;|\t])[^\n]*?\1[^\n]*?\1/;
+/**
+ * Types for which filling a delimited field counts as context. Narrow shapes
+ * only: applied to every type it was measured a net loss — SECRET gained 1,678
+ * false positives, CHAMBER_OF_COMMERCE 456 and POSTAL_CODE 295. A broad shape
+ * plus a required cue is a deliberate pairing, and removing the cue leaves only
+ * the broad shape.
+ */
+const DELIMITED_FIELD_TYPES = new Set([
+    EntityType.PHONE, EntityType.DOB, EntityType.DATE_OF_DEATH,
+]);
+/** True when the span is exactly one field of a delimited row. */
+function fillsADelimitedField(text, start, end) {
+    const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+    let lineEnd = text.indexOf("\n", end);
+    if (lineEnd < 0)
+        lineEnd = text.length;
+    if (!DELIMITED_ROW.test(text.slice(lineStart, lineEnd)))
+        return false;
+    const before = text.slice(lineStart, start);
+    const after = text.slice(end, lineEnd);
+    const opens = before === "" || ",;|\t".includes(before[before.length - 1]);
+    const closes = after === "" || ",;|\t".includes(after[0]);
+    return opens && closes;
+}
 function suppressRequiresContext(text, match) {
     if (!match.patternDef.requiresContext || match.patternDef.contextKeywords.length === 0)
         return false;
+    // A value filling an entire field of a delimited row is introduced by its
+    // column, not by a word, so that is context — but only for narrow shapes.
+    if (DELIMITED_FIELD_TYPES.has(match.patternDef.entityType) &&
+        fillsADelimitedField(text, match.start, match.end))
+        return false;
     const [before, after] = getContext(text, match.start, match.end);
     const context = (before + " " + after).toLowerCase();
     return !match.patternDef.contextKeywords.some(kw => context.includes(kw.toLowerCase()));
 }
 const TYPE_SUPPRESSORS = {
-    [EntityType.PHONE]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressPhoneAfterIdLabel, suppressPhoneServiceNumber, suppressPhoneDateOverlap],
+    [EntityType.PHONE]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressPhoneAfterIdLabel, suppressPhoneServiceNumber, suppressPhoneDateOverlap, suppressPhoneAsNumberRange],
     [EntityType.NATIONAL_ID]: [suppressCurrency, suppressUnits, suppressReference, suppressLegal, suppressMath, suppressNatidAsPassport, suppressSeNatidAsOrg],
     [EntityType.SSN]: [suppressCurrency, suppressUnits, suppressReference, suppressMath],
-    [EntityType.TAX_ID]: [suppressCurrency, suppressUnits, suppressReference, suppressMath],
-    [EntityType.POSTAL_CODE]: [suppressCurrency, suppressUnits, suppressMath, suppressLegal, suppressYearAsPostal, suppressPostalInsideIban, suppressPostalAsHouseNumber, suppressPostalInLongerIdentifier],
+    [EntityType.TAX_ID]: [suppressCurrency, suppressUnits, suppressReference, suppressMath, suppressTaxidAsIpAddress],
+    [EntityType.POSTAL_CODE]: [suppressCurrency, suppressUnits, suppressMath, suppressLegal, suppressYearAsPostal, suppressPostalInsideIban, suppressPostalAsHouseNumber, suppressPostalInLongerIdentifier, suppressReference],
     [EntityType.BIC]: [suppressBicWithoutEvidence],
     [EntityType.BANK_ACCOUNT]: [suppressReference],
-    [EntityType.LICENSE_PLATE]: [suppressPlateInCompound, suppressDePlateUnknownDistrict],
+    [EntityType.LICENSE_PLATE]: [suppressPlateInCompound, suppressDePlateUnknownDistrict, suppressPlateAsCurrencyAmount],
+    [EntityType.SECRET]: [suppressSecretOverStructured, suppressSecretNotASecret],
     [EntityType.CHAMBER_OF_COMMERCE]: [suppressReference],
 };
 export function shouldSuppress(text, match) {

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "euredact",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "European PII redaction SDK -- fast, zero-dependency, rule-based detection and redaction of personal data across 31 European countries",
+  "homepage": "https://euredact.dev",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/cjs/index.js",
@@ -66,5 +67,8 @@
   "devDependencies": {
     "typescript": "^5.4.0",
     "tsx": "^4.7.0"
+  },
+  "bugs": {
+    "url": "https://github.com/euredact/euredact/issues"
   }
 }