@doccloak/core 0.11.0 → 0.12.1

package/dist/regex/rules.data.js

@@ -263,7 +263,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:universal:postal_city",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{2,5}[-\\s]?\\d{2,4}\\s+[\\p{L}][\\p{L}]+\\b",
+                "pattern": "\\b\\d{2,5}[-\\s]?\\d{2,4}\\s+[\\p{L}][\\p{L}]+(?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.65,
                 "domains": [
@@ -370,6 +370,7 @@ export const RULES_DATA = [
                 "entityType": "SECRET",
                 "pattern": "-----BEGIN (?:[A-Z]+ )*PRIVATE KEY(?: BLOCK)?-----[\\s\\S]*?-----END (?:[A-Z]+ )*PRIVATE KEY(?: BLOCK)?-----",
                 "flags": "g",
+                "multiline": true,
                 "confidence": 0.99,
                 "domains": [
                     "technical"
@@ -776,7 +777,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:pl:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{2}-\\d{3}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{2}-\\d{3}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -967,7 +968,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:de:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -1161,7 +1162,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:fr:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s'-]+\\b",
+                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s'-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -1320,7 +1321,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:es:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s'-]+\\b",
+                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s'-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.75,
                 "domains": [
@@ -1448,7 +1449,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:pt:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{4}-\\d{3}\\s+[\\p{L}][\\p{L}\\s'-]+\\b",
+                "pattern": "\\b\\d{4}-\\d{3}\\s+[\\p{L}][\\p{L}\\s'-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.85,
                 "domains": [
@@ -1597,7 +1598,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:se:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{3}\\s?\\d{2}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{3}\\s?\\d{2}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -1729,7 +1730,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:no:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -1875,7 +1876,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:it:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -2043,7 +2044,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:be:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b[1-9]\\d{3}\\s+[\\p{L}][\\p{L}\\s'-]+\\b",
+                "pattern": "\\b[1-9]\\d{3}\\s+[\\p{L}][\\p{L}\\s'-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.75,
                 "domains": [
@@ -2113,7 +2114,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:at:postal",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -2179,7 +2180,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:ch:postal-city",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -2292,7 +2293,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:dk:postal-city",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{4}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [
@@ -2335,7 +2336,7 @@ export const RULES_DATA = [
             {
                 "id": "regex:fi:postal-city",
                 "entityType": "ADDRESS",
-                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]+\\b",
+                "pattern": "\\b\\d{5}\\s+[\\p{L}][\\p{L}\\s-]*[\\p{L}](?![\\p{L}\\p{N}])",
                 "flags": "gu",
                 "confidence": 0.8,
                 "domains": [

package/dist/regex/types.d.ts

@@ -24,4 +24,10 @@ export interface RegexRule {
     falsePositiveNotes?: string;
     /** Optional validation function for post-match filtering (e.g., Luhn check, checksum) */
     validate?: (match: string) => boolean;
+    /**
+     * True when the rule must see the whole document (a match spans line
+     * breaks, e.g. PEM key blocks). Default false: detectWithRegex runs the
+     * rule on each line separately (T180, bounds ReDoS cost to line length).
+     */
+    multiline?: boolean;
 }

package/dist/session.d.ts

@@ -11,6 +11,10 @@ export interface SessionOptions {
      */
     salt?: string;
 }
+/** Input accepted by registerDocumentValues: plain values or anything carrying a `value`. */
+export type DocumentValueInput = string | {
+    value: string;
+};
 export declare class AnonymizationSession {
     private forwardMap;
     private reverseMap;
@@ -21,6 +25,34 @@ export declare class AnonymizationSession {
      * the base re-derives its variants and deserialized maps re-link.
      */
     private variantOf;
+    /**
+     * Compiled exact-restore alternation (R4), rebuilt lazily; null after
+     * every reverse-map mutation (see invalidateRestore).
+     */
+    private restoreRe;
+    /**
+     * Every value known to occur in the session's documents (R3), lowercased:
+     * whole entity values plus their person tokens (and hyphen parts). Fed by
+     * anonymizeText, anonymize, importEntries and registerDocumentValues;
+     * cumulative until clear(). A surrogate is never one of these. No
+     * capitalised-word heuristic: it would starve the pools in German and
+     * Polish prose (plan v2 section 9).
+     */
+    private documentValues;
+    /**
+     * Letter-only document tokens of MIN_NAME_TOKEN_LENGTH or more, bucketed
+     * by their first MIN_NAME_TOKEN_LENGTH characters, for the containment
+     * rule in isDocumentValue: linear in the candidate's length instead of
+     * a scan over every document token.
+     */
+    private documentNameIndex;
+    /**
+     * PERSON values that matched two or more mapped people equally well and
+     * therefore got a fresh identity instead of a guessed one (R5).
+     */
+    private ambiguousValues;
+    /** Whether the most recent anonymize() call refused an ambiguous unification. */
+    private lastAmbiguousFlag;
     private mode;
     /** Surrogate-mode salt (T043); constant for the session's lifetime. */
     private salt;
@@ -45,12 +77,67 @@ export declare class AnonymizationSession {
      */
     private nextSurrogate;
     /**
-     * The already-mapped PERSON value that best matches a new variant
-     * (T057): most shared tokens wins; ties keep the first-mapped value.
-     * Deterministic; returns null when nothing matches.
+     * Whether a PERSON surrogate candidate carries a document name (R3):
+     * any of its tokens is a document value, or contains one of at least
+     * MIN_NAME_TOKEN_LENGTH letters ("Johnson" with "John" in the document,
+     * "Nowakowski" with "Nowak"). Other types are covered by the exact
+     * whole-value check alone: their tokens ("+48", "ul.", "GmbH") recur in
+     * every surrogate of the same shape and would starve the pools.
+     */
+    private containsDocumentName;
+    /** Record one document value: whole (lowercased), its tokens and hyphen parts. */
+    private addDocumentValue;
+    /**
+     * Declare values that occur in the session's documents (R3) so no later
+     * surrogate equals or, for people, contains one of them. anonymizeText
+     * registers its entities itself; hosts that call anonymize() value by
+     * value should register the whole entity list first, otherwise a person
+     * mapped early can still receive the name of a person mapped later.
+     * Accepts plain strings or objects with a `value` (DetectedEntity,
+     * ReplacementEntry-like `{ value }` shapes). Cumulative until clear().
+     */
+    registerDocumentValues(input: ReadonlyArray<DocumentValueInput>): void;
+    /**
+     * Whether the most recent anonymize() call met an ambiguous PERSON value
+     * (R5): a bare name that fits two or more mapped people equally well.
+     * Such a value is NOT unified; it gets its own number or surrogate. For
+     * anonymizeText, which maps many values, use getAmbiguousValues().
+     */
+    lastAmbiguous(): boolean;
+    /**
+     * Every PERSON value this session refused to unify because it matched
+     * two or more people equally well (R5), in mapping order. Cumulative
+     * until clear(); hosts can flag them for the user to resolve.
+     */
+    getAmbiguousValues(): string[];
+    /**
+     * One reference name per person group (R5): the fullest mapped original
+     * of each group (most tokens; the first mapped on ties). Variants never
+     * act as match targets on their own, so "Anna" cannot pull "Anna
+     * Kowalska" into Anna Nowak's group, while a group whose fuller form
+     * arrived later ("John" then "John Smith") still matches "Smith".
+     */
+    private personReferences;
+    /**
+     * The mapped person that a new PERSON value is a variant of (T057):
+     * only group references are considered (see personReferences); most
+     * shared tokens wins. A tie between two or more people is AMBIGUOUS
+     * (R5): no guess is made, the value gets a fresh identity and the
+     * session records it (lastAmbiguous / getAmbiguousValues).
+     * Deterministic; match is null when nothing (or too much) matches.
      */
     private findPersonVariant;
     anonymize(original: string, entityType: EntityType): string;
+    /** Drop the cached restore regex; called on every reverse-map change. */
+    private invalidateRestore;
+    /**
+     * The exact-restore regex (R4): ONE alternation of every reverse-map
+     * key, longest first so a longer key always wins at a given position
+     * ("[PERSON_11]" before "[PERSON_1]", "Adam Nowak" before "Adam"), each
+     * key escaped and guarded per restoreKeyPattern. Compiled once per map
+     * state and reused across replies. Null when nothing is restorable.
+     */
+    private restoreRegex;
     /**
      * The group a mapped value belongs to (T171): its base token and the
      * canonical original that token restores to.
@@ -86,6 +173,13 @@ export declare class AnonymizationSession {
      * forms no key owns.
      */
     private deanonymizeMangledTokens;
+    /**
+     * R9: placeholders written LITERALLY in the user's text ("[PERSON_1]" in
+     * a template or a previously anonymized document) raise the per-type
+     * counter above them, so a freshly issued placeholder never restores to
+     * a value the text never carried under that token.
+     */
+    private reserveLiteralPlaceholders;
     anonymizeText(text: string, entities: DetectedEntity[]): string;
     getEntries(): ReplacementEntry[];
     getForward(original: string): string | undefined;
@@ -156,6 +250,10 @@ export declare class AnonymizationSession {
      * forward map but excluded from the reverse map, preserving their
      * irreversibility. Entries merge into whatever the session already
      * holds; call clear() first for a fresh seeded session.
+     *
+     * R11: the input is validated BEFORE anything is applied (an array of
+     * at most 10 000 well-formed entries, see validateImportEntry); a
+     * violation throws and leaves the session untouched.
      */
     importEntries(entries: ReplacementEntry[]): void;
     /**