euredact 0.0.1 → 0.2.0

package/dist/esm/rules/engine.js

@@ -0,0 +1,125 @@
+import { DetectionSource } from "../types.js";
+import { MultiPatternMatcher } from "./matchers.js";
+import { shouldSuppress } from "./suppressors.js";
+import { detectStructuralDob } from "./structural.js";
+import { COUNTRY_CONFIGS } from "./countries/index.js";
+export class RuleEngine {
+    matcher = new MultiPatternMatcher();
+    loadedCountries = new Set();
+    addCustomPattern(name, pattern) {
+        const pdef = {
+            entityType: name, pattern, validator: null,
+            description: "", contextKeywords: [], requiresContext: false,
+        };
+        this.matcher.addPattern(pdef, "CUSTOM");
+        this.matcher.compile();
+    }
+    loadCountries(countryCodes) {
+        let configs;
+        if (countryCodes === null) {
+            configs = Object.values(COUNTRY_CONFIGS);
+        }
+        else {
+            configs = [];
+            for (const c of countryCodes) {
+                const code = c.toUpperCase();
+                const config = COUNTRY_CONFIGS[code];
+                if (config)
+                    configs.push(config);
+            }
+            const shared = COUNTRY_CONFIGS["SHARED"];
+            if (shared)
+                configs.push(shared);
+        }
+        let newCountries = false;
+        for (const config of configs) {
+            if (!this.loadedCountries.has(config.code)) {
+                this.matcher.addCountry(config);
+                this.loadedCountries.add(config.code);
+                newCountries = true;
+            }
+        }
+        if (newCountries)
+            this.matcher.compile();
+    }
+    detect(text, countryCodes) {
+        this.loadCountries(countryCodes);
+        let rawMatches = this.matcher.scan(text);
+        if (countryCodes !== null) {
+            const codesUpper = new Set(countryCodes.map(c => c.toUpperCase()));
+            rawMatches = rawMatches.filter(m => codesUpper.has(m.countryCode) || m.countryCode === "SHARED" || m.countryCode === "CUSTOM");
+        }
+        // Matches that have a validator but fail it create suppression zones:
+        // the span is recognisably a specific entity (e.g. IBAN-shaped) so
+        // overlapping regex-only matches (license plate, phone) are false
+        // positives and must be suppressed.
+        const validated = [];
+        const suppressionZones = [];
+        for (const m of rawMatches) {
+            if (this.matcher.validate(m)) {
+                validated.push(m);
+            }
+            else if (m.patternDef.validator !== null && !m.patternDef.requiresContext) {
+                suppressionZones.push([m.start, m.end]);
+            }
+        }
+        // Build candidates with priority: validated (3) > custom (2) > regex-only (1)
+        const candidates = [];
+        for (const match of validated) {
+            if (shouldSuppress(text, match))
+                continue;
+            if (match.patternDef.validator === null && suppressionZones.length > 0) {
+                if (suppressionZones.some(([zStart, zEnd]) => match.start >= zStart && match.end <= zEnd)) {
+                    continue;
+                }
+            }
+            const hasValidator = match.patternDef.validator !== null;
+            const isValid = this.matcher.validate(match);
+            const priority = (hasValidator && isValid) ? 3 : match.countryCode === "CUSTOM" ? 2 : 1;
+            const spanLength = match.end - match.start;
+            const score = priority * 1_000_000 + spanLength;
+            candidates.push({
+                det: {
+                    entityType: match.patternDef.entityType,
+                    start: match.start,
+                    end: match.end,
+                    text: match.text,
+                    source: DetectionSource.RULES,
+                    country: (match.countryCode !== "SHARED" && match.countryCode !== "CUSTOM") ? match.countryCode : null,
+                    confidence: "high",
+                },
+                score,
+            });
+        }
+        for (const d of detectStructuralDob(text)) {
+            candidates.push({ det: d, score: 1_000_000 + (d.end - d.start) });
+        }
+        return this.deduplicate(candidates);
+    }
+    /**
+     * Remove overlapping detections with priority-aware resolution.
+     * Priority: validated (3) > custom (2) > regex-only (1).
+     * Within the same tier, longer span wins.
+     */
+    deduplicate(candidates) {
+        if (candidates.length === 0)
+            return [];
+        const sorted = [...candidates].sort((a, b) => b.score - a.score);
+        const result = [];
+        for (const { det } of sorted) {
+            let overlaps = false;
+            for (const kept of result) {
+                if (det.start < kept.end && det.end > kept.start) {
+                    overlaps = true;
+                    break;
+                }
+            }
+            if (!overlaps)
+                result.push(det);
+        }
+        return result;
+    }
+    getLoadedCountries() {
+        return new Set(this.loadedCountries);
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { CountryConfig, PatternDef } from "../types.js";
+import type { RawMatch } from "./suppressors.js";
+export type { RawMatch };
+export declare class MultiPatternMatcher {
+    private patterns;
+    private compiled;
+    addPattern(patternDef: PatternDef, countryCode: string): void;
+    addCountry(config: CountryConfig): void;
+    compile(): void;
+    scan(text: string): RawMatch[];
+    validate(match: RawMatch): boolean;
+}

package/dist/esm/rules/matchers.js

@@ -0,0 +1,52 @@
+import { VALIDATORS } from "./validators.js";
+export class MultiPatternMatcher {
+    patterns = [];
+    compiled = false;
+    addPattern(patternDef, countryCode) {
+        const regex = new RegExp(patternDef.pattern, "gu");
+        this.patterns.push({ regex, patternDef, countryCode });
+        this.compiled = false;
+    }
+    addCountry(config) {
+        for (const pdef of config.patterns) {
+            // Convert Python-style \b word boundaries — JS handles them natively
+            // But we need the 'u' flag for Unicode support
+            const regex = new RegExp(pdef.pattern, "gu");
+            this.patterns.push({ regex, patternDef: pdef, countryCode: config.code });
+        }
+        this.compiled = false;
+    }
+    compile() {
+        this.compiled = true;
+    }
+    scan(text) {
+        if (!this.compiled)
+            this.compile();
+        const matches = [];
+        for (const { regex, patternDef, countryCode } of this.patterns) {
+            regex.lastIndex = 0;
+            let m;
+            while ((m = regex.exec(text)) !== null) {
+                matches.push({
+                    start: m.index,
+                    end: m.index + m[0].length,
+                    text: m[0],
+                    patternDef,
+                    countryCode,
+                });
+                // Prevent infinite loops on zero-length matches
+                if (m[0].length === 0)
+                    regex.lastIndex++;
+            }
+        }
+        return matches;
+    }
+    validate(match) {
+        if (match.patternDef.validator === null)
+            return true;
+        const validator = VALIDATORS[match.patternDef.validator];
+        if (!validator)
+            return true;
+        return validator(match.text);
+    }
+}

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

@@ -0,0 +1,2 @@
+import { type Detection } from "../types.js";
+export declare function detectStructuralDob(text: string): Detection[];

package/dist/esm/rules/structural.js

@@ -0,0 +1,101 @@
+import { EntityType, DetectionSource } from "../types.js";
+const DATE_RE = /(?:0[1-9]|[12]\d|3[01])[/.\-](?:0[1-9]|1[0-2])[/.\-](?:19|20)\d{2}|(?:19|20)\d{2}[/.\-](?:0[1-9]|1[0-2])[/.\-](?:0[1-9]|[12]\d|3[01])/g;
+const DOB_FIELD_NAMES = [
+    "geboortedatum", "date_naissance", "date de naissance", "geburtsdatum",
+    "dob", "birth_date", "birthdate", "date_of_birth",
+    "fecha_nacimiento", "data_nascita", "born",
+    "naissance", "geboren",
+];
+const JSON_KV = /"([^"]+?)"\s*:\s*"([^"]*?)"/g;
+function detectJsonDob(text) {
+    const detections = [];
+    JSON_KV.lastIndex = 0;
+    let m;
+    while ((m = JSON_KV.exec(text)) !== null) {
+        const key = m[1].toLowerCase().trim();
+        const value = m[2];
+        if (!DOB_FIELD_NAMES.some(kw => key.includes(kw)))
+            continue;
+        DATE_RE.lastIndex = 0;
+        const dm = DATE_RE.exec(value);
+        if (dm) {
+            const valStart = m.index + m[0].indexOf(m[2]);
+            const absStart = valStart + dm.index;
+            const absEnd = absStart + dm[0].length;
+            detections.push({
+                entityType: EntityType.DOB,
+                start: absStart,
+                end: absEnd,
+                text: text.slice(absStart, absEnd),
+                source: DetectionSource.RULES,
+                country: null,
+                confidence: "high",
+            });
+        }
+    }
+    return detections;
+}
+function detectDelimiter(header) {
+    for (const delim of ["|", ";", "\t", ","]) {
+        if ((header.match(new RegExp(delim.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) || []).length >= 2)
+            return delim;
+    }
+    return null;
+}
+function detectCsvDob(text) {
+    const detections = [];
+    const lines = text.split("\n");
+    if (lines.length < 2)
+        return detections;
+    const headerLine = lines[0];
+    const delimiter = detectDelimiter(headerLine);
+    if (!delimiter)
+        return detections;
+    const headers = headerLine.split(delimiter).map(h => h.trim().toLowerCase());
+    if (headers.length < 2)
+        return detections;
+    const dobColumns = [];
+    for (let i = 0; i < headers.length; i++) {
+        if (DOB_FIELD_NAMES.some(kw => headers[i].includes(kw)))
+            dobColumns.push(i);
+    }
+    if (dobColumns.length === 0)
+        return detections;
+    let offset = lines[0].length + 1;
+    for (let li = 1; li < lines.length; li++) {
+        const line = lines[li];
+        if (!line.trim()) {
+            offset += line.length + 1;
+            continue;
+        }
+        const fields = line.split(delimiter);
+        for (const colIdx of dobColumns) {
+            if (colIdx >= fields.length)
+                continue;
+            const field = fields[colIdx];
+            DATE_RE.lastIndex = 0;
+            const dm = DATE_RE.exec(field);
+            if (dm) {
+                let fieldOffset = 0;
+                for (let fi = 0; fi < colIdx; fi++)
+                    fieldOffset += fields[fi].length + delimiter.length;
+                const absStart = offset + fieldOffset + dm.index;
+                const absEnd = absStart + dm[0].length;
+                detections.push({
+                    entityType: EntityType.DOB,
+                    start: absStart,
+                    end: absEnd,
+                    text: text.slice(absStart, absEnd),
+                    source: DetectionSource.RULES,
+                    country: null,
+                    confidence: "high",
+                });
+            }
+        }
+        offset += line.length + 1;
+    }
+    return detections;
+}
+export function detectStructuralDob(text) {
+    return [...detectJsonDob(text), ...detectCsvDob(text)];
+}

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

@@ -0,0 +1,9 @@
+import { type PatternDef } from "../types.js";
+export interface RawMatch {
+    start: number;
+    end: number;
+    text: string;
+    patternDef: PatternDef;
+    countryCode: string;
+}
+export declare function shouldSuppress(text: string, match: RawMatch): boolean;

package/dist/esm/rules/suppressors.js

@@ -0,0 +1,208 @@
+import { EntityType } from "../types.js";
+const CONTEXT_CHARS = 150;
+function getContext(text, start, end) {
+    const ctxStart = Math.max(0, start - CONTEXT_CHARS);
+    const ctxEnd = Math.min(text.length, end + CONTEXT_CHARS);
+    return [text.slice(ctxStart, start), text.slice(end, ctxEnd)];
+}
+// 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;
+// 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;
+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*[=+\-×÷*/]/;
+const SEQUENTIAL_PATTERNS = /^(?:0{6,}|1234567890?|0123456789|9876543210?|1111111111?|000000000|123456789)$/;
+const YEAR_PATTERN = /^(?:19[4-9]\d|20[0-3]\d)$/;
+const DATE_KEYWORD_NEAR = /(?:jaar|year|année|Jahr|datum|date|Datum|in\s+\d{4}|since|sinds|depuis|seit|født|fødselsdato|fødsel|Fødselsdato|född|födelsedatum|födelsedag|syntynyt|syntymäaika|fæddur|fæðingardagur|\d{2}\.\d{2}\.|(?:januar|februar|marts|april|maj|juni|juli|august|september|oktober|november|december|januari|februari|mars|april|mei|juin|juillet|août|Tiltr[æa]delsesdato|Tiltredelsesdato))/i;
+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;
+const SERVICE_NUMBER = /^0800[\-\s]/;
+const DATE_PATTERN_FULL = /^\d{2}[-/.]\d{2}[-/.]\d{4}$/;
+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]);
+function suppressCurrency(text, match) {
+    if (!NUMERIC_TYPES.has(match.patternDef.entityType))
+        return false;
+    const [before, after] = getContext(text, match.start, match.end);
+    if (CURRENCY_AFTER.test(after) || CURRENCY_BEFORE.test(before))
+        return true;
+    if (CURRENCY_COMMA_AFTER.test(after))
+        return true;
+    if (AMOUNT_LABEL_BEFORE.test(before))
+        return true;
+    return false;
+}
+function suppressUnits(text, match) {
+    if (!NUMERIC_TYPES.has(match.patternDef.entityType))
+        return false;
+    const [, after] = getContext(text, match.start, match.end);
+    return UNIT_AFTER.test(after);
+}
+function suppressReference(text, match) {
+    const applicable = new Set([EntityType.PHONE, EntityType.NATIONAL_ID, EntityType.SSN, EntityType.TAX_ID, EntityType.IBAN, EntityType.CHAMBER_OF_COMMERCE]);
+    if (!applicable.has(match.patternDef.entityType))
+        return false;
+    const [before] = getContext(text, match.start, match.end);
+    return REFERENCE_BEFORE.test(before);
+}
+function suppressLegal(text, match) {
+    const applicable = new Set([EntityType.PHONE, EntityType.NATIONAL_ID, EntityType.POSTAL_CODE]);
+    if (!applicable.has(match.patternDef.entityType))
+        return false;
+    const [before] = getContext(text, match.start, match.end);
+    return LEGAL_BEFORE.test(before);
+}
+function suppressMath(text, match) {
+    if (!NUMERIC_TYPES.has(match.patternDef.entityType))
+        return false;
+    const [before, after] = getContext(text, match.start, match.end);
+    return MATH_BEFORE.test(before) || MATH_AFTER.test(after);
+}
+function suppressSequential(_text, match) {
+    const clean = match.text.replace(/[\s.\-]/g, "");
+    return SEQUENTIAL_PATTERNS.test(clean);
+}
+function suppressYearAsPostal(text, match) {
+    if (match.patternDef.entityType !== EntityType.POSTAL_CODE)
+        return false;
+    const clean = match.text.trim();
+    if (!YEAR_PATTERN.test(clean))
+        return false;
+    const immediateBefore = text.slice(Math.max(0, match.start - 3), match.start);
+    if (immediateBefore.endsWith(", ") || immediateBefore.endsWith(",\n"))
+        return false;
+    const [before, after] = getContext(text, match.start, match.end);
+    return DATE_KEYWORD_NEAR.test(before + after);
+}
+function suppressPhoneAfterIdLabel(text, match) {
+    if (match.patternDef.entityType !== EntityType.PHONE)
+        return false;
+    const [before] = getContext(text, match.start, match.end);
+    return ID_LABEL_BEFORE.test(before);
+}
+function suppressPhoneServiceNumber(_text, match) {
+    if (match.patternDef.entityType !== EntityType.PHONE)
+        return false;
+    return SERVICE_NUMBER.test(match.text);
+}
+function suppressPhoneDateOverlap(_text, match) {
+    if (match.patternDef.entityType !== EntityType.PHONE)
+        return false;
+    return DATE_PATTERN_FULL.test(match.text.trim());
+}
+const NOT_CITY_CODES = new Set([
+    "ID", "NR", "NO", "ST", "DR", "MR", "MS", "HR", "FR", "IM", "IN", "OR", "IF", "IS", "IT", "AT", "AD", "AG", "AV",
+    "BE", "DE", "EU", "NL", "LU", "WS", "SS", "IP",
+]);
+function suppressPlateInCompound(text, match) {
+    if (match.patternDef.entityType !== EntityType.LICENSE_PLATE)
+        return false;
+    if (match.start >= 3) {
+        const before = text.slice(Math.max(0, match.start - 10), match.start);
+        if (/[A-Za-zÄÖÜäöüß]{2,}-$/.test(before))
+            return true;
+    }
+    const matched = match.text.trim();
+    const parts = matched.split(/[\s\-]+/);
+    if (parts.length > 0 && NOT_CITY_CODES.has(parts[0])) {
+        const afterChar = match.end < text.length ? text[match.end] : "";
+        const beforeChar = match.start > 0 ? text[match.start - 1] : "";
+        if (/\d/.test(afterChar) || beforeChar === "-")
+            return true;
+        if (parts[0] === "WS" || parts[0] === "SS")
+            return true;
+        if (parts[0] === "IP") {
+            const afterTwo = text.slice(match.end, match.end + 2);
+            if (afterTwo.length >= 2 && afterTwo[0] === "." && /\d/.test(afterTwo[1]))
+                return true;
+        }
+    }
+    if (matched.startsWith("HRA") || matched.startsWith("HRB"))
+        return true;
+    const [before, after] = getContext(text, match.start, match.end);
+    if (/(?:Semester|Hochschule|Uni\b)/i.test(before + after)) {
+        if (parts.length > 0 && (parts[0] === "WS" || parts[0] === "SS"))
+            return true;
+    }
+    return false;
+}
+function suppressNatidAsPassport(text, match) {
+    if (match.patternDef.entityType !== EntityType.NATIONAL_ID)
+        return false;
+    const [before] = getContext(text, match.start, match.end);
+    return PASSPORT_CONTEXT_BEFORE.test(before);
+}
+function suppressSeNatidAsOrg(text, match) {
+    if (match.patternDef.entityType !== EntityType.NATIONAL_ID)
+        return false;
+    if (match.countryCode !== "SE")
+        return false;
+    const [before] = getContext(text, match.start, match.end);
+    return SE_ORG_CONTEXT_BEFORE.test(before);
+}
+function suppressPostalInsideIban(text, match) {
+    if (match.patternDef.entityType !== EntityType.POSTAL_CODE)
+        return false;
+    const beforeChar = match.start > 0 ? text[match.start - 1] : " ";
+    const afterChar = match.end < text.length ? text[match.end] : " ";
+    if (/[A-Za-z0-9]/.test(beforeChar) && /[A-Za-z0-9]/.test(afterChar))
+        return true;
+    if (match.start >= 5) {
+        const prefix = text.slice(match.start - 5, match.start);
+        if (/[A-Z]{2}\d{2}\s$/.test(prefix))
+            return true;
+    }
+    return false;
+}
+function suppressPostalAsHouseNumber(text, match) {
+    if (match.patternDef.entityType !== EntityType.POSTAL_CODE)
+        return false;
+    const clean = match.text.replace(/\s/g, "");
+    if (clean.length > 3)
+        return false;
+    const before = text.slice(Math.max(0, match.start - 30), match.start);
+    if (/[a-záéíóúýþæöðA-ZÁÉÍÓÚÝÞÆÖÐ]{3,}\s+$/.test(before)) {
+        const after = text.slice(match.end, match.end + 5);
+        if (!/^,?\s+[A-ZÁÉÍÓÚÝÞÆÖÐ]/.test(after))
+            return true;
+    }
+    return false;
+}
+function suppressRequiresContext(text, match) {
+    if (!match.patternDef.requiresContext || match.patternDef.contextKeywords.length === 0)
+        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.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],
+    [EntityType.IBAN]: [suppressReference],
+    [EntityType.LICENSE_PLATE]: [suppressPlateInCompound],
+    [EntityType.CHAMBER_OF_COMMERCE]: [suppressReference],
+};
+export function shouldSuppress(text, match) {
+    if (suppressSequential(text, match))
+        return true;
+    const typeSups = TYPE_SUPPRESSORS[match.patternDef.entityType];
+    if (typeSups) {
+        for (const s of typeSups) {
+            if (s(text, match))
+                return true;
+        }
+    }
+    if (match.patternDef.requiresContext)
+        return suppressRequiresContext(text, match);
+    return false;
+}

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

@@ -0,0 +1,43 @@
+export declare function validateIban(candidate: string): boolean;
+export declare function validateBsn(candidate: string): boolean;
+export declare function validateBelgianNn(candidate: string): boolean;
+export declare function validateLuhn(candidate: string): boolean;
+export declare function validateBelgianVat(candidate: string): boolean;
+export declare function validateVatNl(candidate: string): boolean;
+export declare function validateVatDe(candidate: string): boolean;
+export declare function validateVatFr(candidate: string): boolean;
+export declare function validateVatLu(candidate: string): boolean;
+export declare function validateGermanTaxId(candidate: string): boolean;
+export declare function validateFrenchNir(candidate: string): boolean;
+export declare function validateVin(candidate: string): boolean;
+export declare function validateBic(candidate: string): boolean;
+export declare function validateKvk(candidate: string): boolean;
+export declare function validateSwedishPnr(candidate: string): boolean;
+export declare function validateNorwegianFnr(candidate: string): boolean;
+export declare function validateFinnishHetu(candidate: string): boolean;
+export declare function validateIcelandicKt(candidate: string): boolean;
+export declare function validateDanishVat(candidate: string): boolean;
+export declare function validateFinnishBusinessId(candidate: string): boolean;
+export declare function validateImei(candidate: string): boolean;
+export declare function validateDanishCpr(candidate: string): boolean;
+export declare function validateNorwegianOrg(candidate: string): boolean;
+export declare function validateAustrianSvnr(candidate: string): boolean;
+export declare function validateSwissAhv(candidate: string): boolean;
+export declare function validateItalianCf(candidate: string): boolean;
+export declare function validateSpanishDni(candidate: string): boolean;
+export declare function validateSpanishNie(candidate: string): boolean;
+export declare function validatePortugueseNif(candidate: string): boolean;
+export declare function validatePolishPesel(candidate: string): boolean;
+export declare function validatePolishNip(candidate: string): boolean;
+export declare function validateCzechBirthNumber(candidate: string): boolean;
+export declare function validateRomanianCnp(candidate: string): boolean;
+export declare function validateHungarianTaj(candidate: string): boolean;
+export declare function validateBulgarianEgn(candidate: string): boolean;
+export declare function validateCroatianOib(candidate: string): boolean;
+export declare function validateSlovenianEmso(candidate: string): boolean;
+export declare function validateIrishPps(candidate: string): boolean;
+export declare function validateEstonianId(candidate: string): boolean;
+export declare function validateUkNhs(candidate: string): boolean;
+export declare function validateGreekAfm(candidate: string): boolean;
+export declare function validateGreekAmka(candidate: string): boolean;
+export declare const VALIDATORS: Record<string, (candidate: string) => boolean>;