@link-foundation/sensitive-data-sanitizer 0.19.3 → 0.20.0

package/src/national.js

@@ -1,112 +1,330 @@
 import { numericNoise, epochNumber } from './confidence.js';
-import {
-  digitsOf,
-  datePart,
-  nhs,
-  snils,
-  inn,
-  pesel,
-  rrn,
-  tfn,
-  nric,
-  fiscalCode,
-  personnummer,
-  southAfricanId,
-  shortLuhn,
-} from './national-checks.js';
+import * as checks from './national-checks.js';
 
-const rules = [
+const never = () => false;
+const always = () => true;
+// Each rule is data: `context` near the value, a `checksum` and a distinctive
+// `plausible` shape raise confidence; `valid` (when present) must always hold.
+// Callers may reuse or extend this list through `nationalRules`.
+export const nationalRules = Object.freeze(
   [
-    'UK_NHS',
-    /\d{3}[ -]?\d{3}[ -]?\d{4}/g,
-    /\b(?:NHS|patient|healthcare|provider)\b/i,
-    nhs,
-  ],
-  [
-    'KR_RRN',
-    /\d{6}[ -]?[1-8]\d{6}/g,
-    /\bRRN\b|주민등록/iu,
-    rrn,
-    (v) => datePart(digitsOf(v)),
-  ],
-  [
-    'IT_FISCAL_CODE',
-    /[A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST][0-9LMNPQRSTUV]{2}[A-Z][0-9LMNPQRSTUV]{3}[A-Z]/g,
-    /\bCF\b|codice fiscale/iu,
-    fiscalCode,
-    () => true,
-  ],
-  ['SG_NRIC_FIN', /[STFGM]\d{7}[A-Z]/g, /\b(?:NRIC|FIN)\b/iu, nric, () => true],
-  ['PL_PESEL', /\d{11}/g, /\bPESEL\b/iu, pesel],
-  [
-    'SE_PERSONNUMMER',
-    /(?:\d{2})?\d{6}[-+]\d{4}/g,
-    /personnummer/iu,
-    personnummer,
-  ],
-  [
-    'ZA_ID_NUMBER',
-    /\d{10}[0-2][89]\d/g,
-    /\b(?:SA ID|RSA ID)\b|south african id/iu,
-    southAfricanId,
-  ],
-  ['AU_TFN', /\d{3}[ -]?\d{3}[ -]?\d{3}/g, /\bTFN\b|tax file number/iu, tfn],
-  [
-    'CA_SIN',
-    /\d{3}[ -]?\d{3}[ -]?\d{3}/g,
-    /\bSIN\b|social insurance/iu,
-    shortLuhn,
-  ],
-  [
-    'RU_SNILS',
-    /\d{3}[- ]\d{3}[- ]\d{3}[ -]\d{2}|\d{11}/g,
-    /\bSNILS\b|снилс|пенсионное|страховое свидетельство|страховой номер/iu,
-    snils,
-  ],
-  ['RU_INN', /\d{12}|\d{10}/g, /\bINN\b|инн/iu, inn],
-];
+    {
+      type: 'UK_NHS',
+      pattern: /\d{3}[ -]?\d{3}[ -]?\d{4}/g,
+      context: /\b(?:NHS|patient|healthcare|provider)\b/i,
+      checksum: checks.nhs,
+    },
+    {
+      type: 'KR_RRN',
+      pattern: /\d{6}[ -]?[1-8]\d{6}/g,
+      context: /\bRRN\b|주민등록/iu,
+      checksum: checks.rrn,
+      plausible: (v) => checks.datePart(checks.digitsOf(v)),
+    },
+    {
+      type: 'IT_FISCAL_CODE',
+      pattern:
+        /[A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST][0-9LMNPQRSTUV]{2}[A-Z][0-9LMNPQRSTUV]{3}[A-Z]/g,
+      context: /\bCF\b|codice fiscale/iu,
+      checksum: checks.fiscalCode,
+      plausible: always,
+    },
+    {
+      type: 'SG_NRIC_FIN',
+      pattern: /[STFGM]\d{7}[A-Z]/g,
+      context: /\b(?:NRIC|FIN)\b/iu,
+      checksum: checks.nric,
+      plausible: always,
+    },
+    {
+      type: 'PL_PESEL',
+      pattern: /\d{11}/g,
+      context: /\bPESEL\b/iu,
+      checksum: checks.pesel,
+    },
+    {
+      type: 'SE_PERSONNUMMER',
+      pattern: /(?:\d{2})?\d{6}[-+]\d{4}/g,
+      context: /personnummer/iu,
+      checksum: checks.personnummer,
+    },
+    {
+      type: 'ZA_ID_NUMBER',
+      pattern: /\d{10}[0-2][89]\d/g,
+      context: /\b(?:SA ID|RSA ID)\b|south african id/iu,
+      checksum: checks.southAfricanId,
+    },
+    {
+      type: 'AU_TFN',
+      pattern: /\d{3}[ -]?\d{3}[ -]?\d{3}/g,
+      context: /\bTFN\b|tax file number/iu,
+      checksum: checks.tfn,
+    },
+    {
+      type: 'CA_SIN',
+      pattern: /\d{3}[ -]?\d{3}[ -]?\d{3}/g,
+      context: /\b(?:SIN|NAS)\b|social insurance|assurance sociale/iu,
+      checksum: checks.shortLuhn,
+    },
+    {
+      type: 'RU_SNILS',
+      pattern: /\d{3}[- ]\d{3}[- ]\d{3}[ -]\d{2}|\d{11}/g,
+      context:
+        /\bSNILS\b|снилс|пенсионное|страховое свидетельство|страховой номер/iu,
+      checksum: checks.snils,
+    },
+    {
+      type: 'RU_INN',
+      pattern: /\d{12}|\d{10}/g,
+      context: /\bINN\b|инн/iu,
+      checksum: checks.inn,
+    },
+    {
+      type: 'US_ITIN',
+      pattern: /9\d{2}([- ]?)(?:5\d|6[0-5]|7\d|8[0-8]|9[0-2]|9[4-9])\1\d{4}/g,
+      context: /\bITIN\b|taxpayer identification/iu,
+      checksum: never,
+      plausible: (v) => /^\d{3}-\d{2}-\d{4}$/.test(v),
+    },
+    {
+      type: 'ABA_ROUTING_NUMBER',
+      pattern: /\d{4}-?\d{4}-?\d/g,
+      context: /\b(?:routing|ABA|RTN|transit)\b/iu,
+      checksum: checks.abaRouting,
+      valid: checks.abaRouting,
+    },
+    {
+      type: 'US_BANK_NUMBER',
+      pattern: /\d{8,17}/g,
+      context:
+        /\bbank\s+account\b|\b(?:account|acct)\.?\s*(?:number|num|no\.?|#)|\b(?:checking|savings)\s+account\b/iu,
+      checksum: never,
+    },
+    {
+      type: 'US_DRIVER_LICENSE',
+      pattern: /[A-Z]{1,2}\d{4,14}|\d{7,14}/g,
+      context: /\bdriver'?s?[ -]licen[cs]e\b|\bDLN?\b|\bD\.L\.(?=\s|$)/iu,
+      checksum: never,
+    },
+    {
+      type: 'UK_DRIVING_LICENCE',
+      pattern: /[A-Z9]{5}\d[0156]\d{4}[A-Z9]{2}\d[A-Z]{2}/g,
+      context: /\bdriv(?:ing|er'?s?)[ -]licen[cs]e\b|\bDVLA\b/iu,
+      checksum: never,
+      plausible: always,
+    },
+    {
+      type: 'UK_NATIONAL_INSURANCE_NUMBER',
+      pattern: /[A-Z]{2} ?\d{2} ?\d{2} ?\d{2} ?[A-D]/g,
+      context: /\bNINO\b|national insurance|\bNI (?:number|no\b)/iu,
+      checksum: never,
+    },
+    {
+      type: 'ES_NIE',
+      pattern: /[XYZ]-?\d{7}-?[A-Z]/g,
+      context: /\bNIE\b|extranjero/iu,
+      checksum: (v) => checks.spanishNie(v.replace(/-/g, '')),
+      plausible: always,
+    },
+    {
+      type: 'IT_VAT_CODE',
+      pattern: /\d{11}/g,
+      context: /partita\s+iva|\bP\.?\s?IVA\b|\bVAT\b/iu,
+      checksum: checks.shortLuhn,
+    },
+    {
+      type: 'AU_ABN',
+      pattern: /\d{2} ?\d{3} ?\d{3} ?\d{3}/g,
+      context: /\bABN\b|australian business number/iu,
+      checksum: checks.abn,
+      plausible: (v) => /^\d{2} \d{3} \d{3} \d{3}$/.test(v),
+    },
+    {
+      type: 'AU_ACN',
+      pattern: /\d{3} ?\d{3} ?\d{3}/g,
+      context: /\bACN\b|australian company number/iu,
+      checksum: checks.acn,
+    },
+    {
+      type: 'AU_MEDICARE',
+      pattern: /[2-6]\d{3} ?\d{5} ?\d(?:[ -/]?\d)?/g,
+      context: /\bmedicare\b/iu,
+      checksum: checks.medicare,
+    },
+    {
+      type: 'IN_AADHAAR',
+      pattern: /[2-9]\d{3}([ -]?)\d{4}\1\d{4}/g,
+      context: /aadhaa?r|आधार|\bUIDAI\b/iu,
+      checksum: checks.aadhaar,
+    },
+    {
+      type: 'IN_GSTIN',
+      pattern: /\d{2}[A-Z]{5}\d{4}[A-Z][1-9A-Z]Z[0-9A-Z]/g,
+      context: /\bGSTIN?\b|goods and services tax/iu,
+      checksum: checks.gstin,
+      plausible: always,
+    },
+    {
+      type: 'IN_VOTER',
+      pattern: /[A-Z]{3}\d{7}/g,
+      context: /\bvoter\b|\bEPIC\b|election commission/iu,
+      checksum: never,
+    },
+    {
+      type: 'IN_PASSPORT',
+      pattern: /[A-PR-WY][1-9]\d ?\d{4}[1-9]/g,
+      context: /\bpassport\b/iu,
+      checksum: never,
+    },
+    {
+      type: 'FI_PERSONAL_IDENTITY_CODE',
+      pattern: /\d{6}[-+A-FU-Y]\d{3}[0-9A-FHJ-NPR-Y]/g,
+      context:
+        /henkilötunnus|\bHETU\b|personal identity code|personbeteckning/iu,
+      checksum: checks.finnishIdentityCode,
+      plausible: always,
+    },
+    {
+      type: 'TH_TNIN',
+      pattern: /[1-8]\d{12}|[1-8]-\d{4}-\d{5}-\d{2}-\d/g,
+      context: /\bthai\b|\bTNIN\b|เลขประจำตัวประชาชน|บัตรประชาชน/iu,
+      checksum: checks.thaiId,
+    },
+    {
+      type: 'MEDICAL_LICENSE',
+      pattern: /[ABCDEFGHJKLMPRSTUX][A-Z9]\d{7}/g,
+      context: /\bDEA\b|medical licen[cs]e|prescriber/iu,
+      checksum: checks.dea,
+    },
+    {
+      type: 'IMEI',
+      pattern: /\d{15}|\d{2}-\d{6}-\d{6}-\d/g,
+      context: /\bIMEI\b/iu,
+      checksum: checks.shortLuhn,
+    },
+    {
+      type: 'SWIFT_CODE',
+      pattern: /[A-Z]{6}[A-Z0-9]{2}(?:[A-Z0-9]{3})?/g,
+      context: /\b(?:SWIFT|BIC)\b/iu,
+      checksum: never,
+      valid: checks.swiftCode,
+    },
+    {
+      type: 'VIN',
+      pattern: /[A-HJ-NPR-Z\d]{17}/g,
+      context: /\bVIN\b|vehicle identification|chassis/iu,
+      checksum: checks.vin,
+      valid: (v) => /\d/.test(v) && /[A-Z]/.test(v),
+    },
+    {
+      type: 'UK_POSTCODE',
+      pattern: /[A-Z]{1,2}\d[A-Z\d]? ?\d[ABD-HJLNP-UW-Z]{2}/g,
+      context: /\bpost ?code\b|\bpostal code\b/iu,
+      checksum: never,
+    },
+    {
+      type: 'SG_UEN',
+      pattern: /\d{8}[A-Z]|(?:19|20)\d{7}[A-Z]|[TSR]\d{2}[A-Z]{2}\d{4}[A-Z]/g,
+      context: /\bUEN\b|unique entity number/iu,
+      checksum: never,
+    },
+    {
+      type: 'DE_TAX_ID',
+      pattern: /[1-9]\d(?: ?\d{3}){3}|[1-9]\d{10}/g,
+      context: /steuer[ -]?id|steueridentifikationsnummer|\bIdNr\b|\bTIN\b/iu,
+      checksum: checks.germanTaxId,
+    },
+    {
+      // EU VAT identification numbers by member-state prefix (VIES formats).
+      type: 'EU_VAT_NUMBER',
+      pattern:
+        /(?:AT ?U\d{8}|BE ?[01]\d{9}|DE ?[1-9]\d{8}|DK ?\d{8}|EL ?\d{9}|ES ?[0-9A-Z]\d{7}[0-9A-Z]|FI ?\d{8}|FR ?[0-9A-HJ-NP-Z]{2}\d{9}|IE ?\d[0-9A-Z+*]\d{5}[A-Z]{1,2}|IT ?\d{11}|LU ?\d{8}|NL ?\d{9}B\d{2}|PL ?\d{10}|PT ?\d{9}|SE ?\d{12})/g,
+      context:
+        /\bVAT\b|\bUSt\b|USt-?Id|Umsatzsteuer|\bMwSt\b|\bTVA\b|\bBTW\b|\bIVA\b|\bALV\b|\bmoms\b|\bNIP\b|\bNIF\b/iu,
+      checksum: checks.germanVat,
+      plausible: (v) => /^(?:ATU|NL\d{9}B)/.test(v),
+    },
+    {
+      type: 'AE_EMIRATES_ID',
+      pattern: /784-?(?:19|20)\d{2}-?\d{7}-?\d/g,
+      context: /emirates\s+id|\bEID\b|الهوية/iu,
+      checksum: checks.emiratesId,
+      plausible: (v) => /^784-\d{4}-\d{7}-\d$/.test(v),
+    },
+    {
+      type: 'SA_NATIONAL_ID',
+      pattern: /[12]\d{9}/g,
+      context: /\biqama\b|saudi|national\s+id|رقم الهوية|الإقامة/iu,
+      checksum: checks.saudiId,
+    },
+    {
+      type: 'IL_ID_NUMBER',
+      pattern: /\d{9}/g,
+      context: /teudat\s+zehut|israeli\s+id|תעודת זהות|\bת\.ז\b/iu,
+      checksum: checks.israeliId,
+    },
+    {
+      type: 'STEAM_ID',
+      pattern: /7656119\d{10}/g,
+      context: /\bsteam/iu,
+      checksum: never,
+    },
+    {
+      type: 'TRACKING_NUMBER',
+      pattern: /1Z[0-9A-Z]{15}\d|9[2-5]\d{2}(?: ?\d{4}){4}(?: ?\d{2})?/g,
+      context: /tracking|\bUPS\b|\bUSPS\b|shipment|parcel/iu,
+      checksum: checks.upsTracking,
+      plausible: (v) => v.startsWith('1Z'),
+    },
+  ].map((rule) => Object.freeze(rule))
+);
 function distinctiveShape(type, value) {
   return (
     (type === 'RU_SNILS' && /^\d{3}([- ])\d{3}\1\d{3} \d{2}$/.test(value)) ||
     (type === 'RU_INN' && value.length === 12)
   );
 }
-export function detectNational(text, emit) {
-  for (const [type, pattern, context, checksum, plausible] of rules) {
-    for (const match of text.matchAll(pattern)) {
-      const start = match.index,
-        end = start + match[0].length;
-      if (!nationalBoundary(text, start, end)) {
-        continue;
-      }
-      const hasContext = context.test(
-        text.slice(Math.max(0, start - 64), end + 32)
-      );
-      if (
-        !hasContext &&
-        (numericNoise(text, start, end) || epochNumber(match[0]))
-      ) {
-        continue;
-      }
-      const checked = checksum(match[0]);
-      if (checked || hasContext || plausible?.(match[0])) {
+export function detectNational(text, emit, rules = nationalRules) {
+  for (const rule of rules) {
+    for (const match of text.matchAll(rule.pattern)) {
+      const confidence = nationalMatch(text, rule, match);
+      if (confidence !== undefined) {
         emit({
-          start,
-          end,
-          type,
+          start: match.index,
+          end: match.index + match[0].length,
+          type: rule.type,
           category: 'personal',
           rule: 'national-format',
-          confidence: nationalConfidence(
-            hasContext,
-            checked,
-            plausible?.(match[0]) ||
-              (checked && distinctiveShape(type, match[0]))
-          ),
+          confidence,
         });
       }
     }
   }
 }
+// Confidence for one candidate, or undefined when it is not an identifier.
+function nationalMatch(text, rule, match) {
+  const value = match[0],
+    start = match.index,
+    end = start + value.length;
+  if (!nationalBoundary(text, start, end) || rule.valid?.(value) === false) {
+    return undefined;
+  }
+  const hasContext = rule.context.test(
+    text.slice(Math.max(0, start - 64), end + 32)
+  );
+  if (!hasContext && (numericNoise(text, start) || epochNumber(value))) {
+    return undefined;
+  }
+  const checked = rule.checksum(value),
+    plausible = rule.plausible?.(value);
+  return checked || hasContext || plausible
+    ? nationalConfidence(
+        hasContext,
+        checked,
+        plausible || (checked && distinctiveShape(rule.type, value))
+      )
+    : undefined;
+}
 function nationalBoundary(text, start, end) {
   return !(
     /[\p{L}\p{N}_.+-]/u.test(text[start - 1] ?? '') ||

package/src/pattern-detector.js

@@ -0,0 +1,219 @@
+import { failure, escapePattern } from './detection.js';
+
+// Declarative recognizers in the style of Presidio's PatternRecognizer
+// (patterns with scores, deny lists, context words, validate_result) and
+// Google custom infoTypes (regex/dictionary plus hotword likelihood rules).
+// The result is an ordinary Detector, so it composes with every other port.
+const typePattern = /^[A-Z][A-Z0-9_]{0,63}$/;
+const rulePattern = /^[a-z0-9@/._-]{1,120}$/;
+const maxPatterns = 64,
+  maxWords = 10000;
+
+const score = (value) =>
+  typeof value === 'number' &&
+  Number.isFinite(value) &&
+  value >= 0 &&
+  value <= 1;
+const optional = (value, test) => value === undefined || test(value);
+const words = (list) =>
+  Array.isArray(list) &&
+  list.length <= maxWords &&
+  list.every((word) => typeof word === 'string' && word.trim().length > 0);
+
+const validEntry = (raw) =>
+  Boolean(raw) &&
+  (raw.regex instanceof RegExp ||
+    (typeof raw.regex === 'string' && raw.regex.length > 0)) &&
+  optional(raw.confidence, score) &&
+  optional(raw.group, (group) => Number.isSafeInteger(group) && group >= 0);
+
+function globalRegex(regex) {
+  try {
+    return regex instanceof RegExp
+      ? new RegExp(
+          regex.source,
+          regex.flags.includes('g') ? regex.flags : `${regex.flags}g`
+        )
+      : new RegExp(regex, 'gu');
+  } catch {
+    throw failure('ERR_CONFIG');
+  }
+}
+
+function compile(entry) {
+  const raw =
+    entry instanceof RegExp || typeof entry === 'string'
+      ? { regex: entry }
+      : entry;
+  if (!validEntry(raw)) {
+    throw failure('ERR_CONFIG');
+  }
+  return {
+    regex: globalRegex(raw.regex),
+    confidence: raw.confidence,
+    group: raw.group ?? 0,
+  };
+}
+
+function window(value) {
+  if (value === undefined) {
+    return { before: 64, after: 16 };
+  }
+  const shape = typeof value === 'number' ? { before: value, after: 0 } : value;
+  if (
+    !shape ||
+    ![shape.before ?? 0, shape.after ?? 0].every(
+      (n) => Number.isSafeInteger(n) && n >= 0 && n <= 4096
+    )
+  ) {
+    throw failure('ERR_CONFIG');
+  }
+  return { before: shape.before ?? 0, after: shape.after ?? 0 };
+}
+
+const specChecks = [
+  (spec) => typePattern.test(spec.type ?? ''),
+  (spec) =>
+    optional(spec.category, (c) => ['personal', 'credential'].includes(c)),
+  (spec) => optional(spec.rule, (rule) => rulePattern.test(rule)),
+  (spec) => optional(spec.confidence, score),
+  (spec) => optional(spec.denyListConfidence, score),
+  (spec) =>
+    optional(
+      spec.patterns,
+      (list) => Array.isArray(list) && list.length <= maxPatterns
+    ),
+  (spec) => optional(spec.denyList, words),
+  (spec) => optional(spec.context, words),
+  (spec) =>
+    optional(
+      spec.contextBoost,
+      (boost) => typeof boost === 'number' && Math.abs(boost) <= 1
+    ),
+  (spec) => optional(spec.validate, (fn) => typeof fn === 'function'),
+  (spec) => Boolean(spec.patterns?.length || spec.denyList?.length),
+];
+
+function compileSpec(spec) {
+  if (
+    !spec ||
+    typeof spec !== 'object' ||
+    !specChecks.every((check) => check(spec))
+  ) {
+    throw failure('ERR_CONFIG');
+  }
+  const patterns = (spec.patterns ?? []).map(compile);
+  if (spec.denyList?.length) {
+    patterns.push({
+      regex: new RegExp(
+        `(?<![\\p{L}\\p{N}_])(?:${[...spec.denyList]
+          .sort((a, b) => b.length - a.length)
+          .map(escapePattern)
+          .join('|')})(?![\\p{L}\\p{N}_])`,
+        spec.caseSensitive ? 'gu' : 'giu'
+      ),
+      confidence: spec.denyListConfidence ?? 1,
+      group: 0,
+    });
+  }
+  const context = spec.context?.length
+    ? new RegExp(
+        `(?<![\\p{L}\\p{N}])(?:${spec.context.map(escapePattern).join('|')})(?![\\p{L}\\p{N}])`,
+        'iu'
+      )
+    : undefined;
+  return Object.freeze({
+    type: spec.type,
+    category: spec.category ?? 'personal',
+    rule: spec.rule ?? 'custom-pattern',
+    confidence: spec.confidence ?? 0.6,
+    patterns,
+    context,
+    window: window(spec.contextWindow),
+    boost: spec.contextBoost ?? 0.35,
+    validate: spec.validate,
+  });
+}
+
+function scored(spec, base, text, start, end, value) {
+  let confidence = base;
+  if (
+    spec.context?.test(
+      `${text.slice(Math.max(0, start - spec.window.before), start)}\n${text.slice(end, end + spec.window.after)}`
+    )
+  ) {
+    // Presidio raises a context-supported score by 0.35 with a 0.4 floor;
+    // a negative boost models Google's "decrease likelihood" hotwords.
+    confidence =
+      spec.boost >= 0
+        ? Math.max(0.4, confidence + spec.boost)
+        : confidence + spec.boost;
+  }
+  if (spec.validate) {
+    const verdict = spec.validate(value);
+    if (verdict === false) {
+      return undefined;
+    }
+    if (typeof verdict === 'number' && score(verdict)) {
+      confidence = verdict;
+    }
+  }
+  return Math.min(1, Math.max(0, confidence));
+}
+
+function* matches(spec, text) {
+  for (const pattern of spec.patterns) {
+    pattern.regex.lastIndex = 0;
+    for (const match of text.matchAll(pattern.regex)) {
+      const value = match[pattern.group];
+      if (!value) {
+        continue;
+      }
+      const start = match.index + (pattern.group ? match[0].indexOf(value) : 0);
+      yield {
+        start,
+        end: start + value.length,
+        value,
+        base: pattern.confidence ?? spec.confidence,
+      };
+    }
+  }
+}
+
+/**
+ * Builds a synchronous Detector from declarative specs. Each spec matches
+ * `patterns` (RegExp, string sources or `{regex, confidence, group}`) and/or
+ * a whole-word `denyList`, raises or lowers confidence when a `context` word
+ * occurs within `contextWindow`, and lets `validate(value)` reject a match
+ * (false) or set its confidence (0–1). Patterns are trusted configuration:
+ * avoid catastrophic backtracking in caller-supplied expressions.
+ */
+export function createPatternDetector(specs, { id = 'pattern-rules' } = {}) {
+  const list = Array.isArray(specs) ? specs : [specs];
+  if (!list.length || list.length > maxPatterns) {
+    throw failure('ERR_CONFIG');
+  }
+  const compiled = list.map(compileSpec);
+  return {
+    id,
+    detect(text) {
+      const findings = [];
+      for (const spec of compiled) {
+        for (const { start, end, value, base } of matches(spec, text)) {
+          const confidence = scored(spec, base, text, start, end, value);
+          if (confidence !== undefined) {
+            findings.push({
+              start,
+              end,
+              type: spec.type,
+              category: spec.category,
+              rule: spec.rule,
+              confidence,
+            });
+          }
+        }
+      }
+      return findings;
+    },
+  };
+}

package/src/personal-context.js

@@ -6,8 +6,9 @@ export const months =
   'January February March April May June July August September October November December Jan Feb Mar Apr Jun Jul Aug Sep Sept Oct Nov Dec января февраля марта апреля мая июня июля августа сентября октября ноября декабря январь февраль март апрель май июнь июль август сентябрь октябрь ноябрь декабрь'
     .split(' ')
     .join('|');
+const ordinal = '(?:st|nd|rd|th)?';
 const dates = new RegExp(
-  `(?<![\\p{L}\\p{N}_])(?:\\d{4}-\\d{1,2}-\\d{1,2}|\\d{1,2}[/.]\\d{1,2}[/.]\\d{4}|\\d{1,2}[ \\t]+(?:${months})[ \\t]+\\d{4}|(?:${months})[ \\t]+\\d{1,2},?[ \\t]+\\d{4})(?![\\p{L}\\p{N}_])`,
+  `(?<![\\p{L}\\p{N}_])(?:\\d{4}-\\d{1,2}-\\d{1,2}|\\d{1,2}[/.-]\\d{1,2}[/.-]\\d{4}|\\d{1,2}${ordinal}[ \\t]+(?:of[ \\t]+)?(?:${months})\\.?,?[ \\t]+\\d{4}|(?:${months})\\.?[ \\t]+\\d{1,2}${ordinal},?[ \\t]+\\d{4})(?![\\p{L}\\p{N}_])`,
   'giu'
 );
 const phoneContext =
@@ -30,7 +31,7 @@ export function detectPersonalContext(text, emit) {
   );
   collectMatches(
     text,
-    /(?<![\p{L}\p{N}_])(?:phone|fax|ĐT|điện thoại)(?:[ \t]*[:：][ \t]*|[ \t]+)(\+?\(?\d[\d() .-]{5,38}\d)(?![\p{L}\p{N}_])/giu,
+    /(?<![\p{L}\p{N}_])(?:(?:phone|fax|ĐT|điện thoại)(?:[ \t]*[:：][ \t]*|[ \t]+)|(?:telephone|tel|mobile|mob|cell|desk|ph)\.?[ \t]*[:：][ \t]*)(\+?\(?\d[\d() .-]{5,38}\d)(?![\p{L}\p{N}_])/giu,
     emit,
     phone,
     1,