@link-foundation/sensitive-data-sanitizer 0.14.0 → 0.16.0

package/src/personal-variants.js

@@ -1,4 +1,5 @@
 import { escapePattern, failure } from './detection.js';
+import { russianNameRoles } from './russian-names.js';
 
 const boundary = '[\\p{L}\\p{M}\\p{N}_]';
 export function organizationCore(value) {
@@ -7,9 +8,26 @@ export function organizationCore(value) {
     .replace(/^[«“"]|[»”"]$/gu, '')
     .trim();
 }
+// `Вектор-1` also identifies its base name and numbered siblings like `Вектор-2`.
+export function organizationFamily(core) {
+  const base = /^(.{3,})-\d{1,9}$/u.exec(core)?.[1];
+  return base
+    ? {
+        base,
+        pattern: new RegExp(
+          `(?<!${boundary})${escapePattern(base)}(?:-\\d{1,9})?(?!${boundary}|-\\d)`,
+          'giu'
+        ),
+      }
+    : undefined;
+}
+// ё and е are one letter in ordinary Russian writing; the i flag covers Ё and Е.
+const foldYo = (pattern) => pattern.replace(/[еёЕЁ]/gu, '[её]');
+const fleeting = { павел: 'Павл', лев: 'Льв' };
+const hardCases = '(?:а|у|ом|е)';
 // Only caller-confirmed Russian words receive finite case alternatives. A
 // minimum three-letter stem avoids turning short names into broad matches.
-function wordPattern(word) {
+function cyrillicPattern(word, type) {
   const endings = [
     [/(?:ова|ева|ина)$/u, 1, '(?:а|ой|ою|у|е|ы)'],
     [/(?:ая)$/u, 2, '(?:ая|ой|ою|ую)'],
@@ -18,24 +36,76 @@ function wordPattern(word) {
       2,
       '(?:ий|ый|ой|ого|его|ому|ему|им|ым|ом|ем|ия|ию|ием|ии)',
     ],
+    [/[аеуюя]й$/u, 1, '(?:й|я|ю|ем|е)'],
     [/(?:ов|ев|ин)$/u, 0, '(?:а|у|ым|ом|е|ой)?'],
+    [/[жчшщц]$/u, 0, '(?:а|у|ем|ом|е)?'],
+    [/[жчшщц]а$/u, 1, '(?:а|и|е|у|ей|ею|ой|ою)'],
     [/а$/u, 1, '(?:а|ы|и|е|у|ой|ою)'],
     [/я$/u, 1, '(?:я|и|е|ю|ей|ею)'],
-    [/ь$/u, 1, '(?:ь|я|ю|ем|и)'],
+    [/ь$/u, 1, '(?:ь|я|ю|ем|е|и|ью)'],
   ];
   const lower = word.toLowerCase();
-  if (/^[а-яё]+$/u.test(lower)) {
-    for (const [ending, remove, suffix] of endings) {
-      if (ending.test(lower) && word.length - remove >= 3) {
-        return escapePattern(remove ? word.slice(0, -remove) : word) + suffix;
-      }
+  if (fleeting[lower]) {
+    return `(?:${word}|${fleeting[lower]}${hardCases})`;
+  }
+  for (const [ending, remove, suffix] of endings) {
+    if (ending.test(lower) && word.length - remove >= 3) {
+      return escapePattern(remove ? word.slice(0, -remove) : word) + suffix;
     }
   }
-  if (/^[а-яё]{4,}[бвгджзклмнпрстфхцчшщ]$/u.test(lower)) {
-    return `${escapePattern(word)}(?:а|у|ом|е|ы|ов|ам|ами|ах)?`;
+  if (/^[а-яё]{3,}[бвгджзклмнпрстфхцчшщ]$/u.test(lower)) {
+    // Plural forms would turn a given name into a surname: Петр and Петров.
+    return `${escapePattern(word)}${type === 'PERSON' ? `${hardCases}?` : '(?:а|у|ом|е|ы|ов|ам|ами|ах)?'}`;
   }
   return escapePattern(word);
 }
+export function wordPattern(word, type) {
+  return foldYo(
+    word
+      .split('-')
+      .map((part) =>
+        /^[а-яё]+$/iu.test(part)
+          ? cyrillicPattern(part, type)
+          : escapePattern(part)
+      )
+      .join('-')
+  );
+}
+const initialGap = '[ \\t\\u00a0]*';
+const initialPattern = (word) => `${foldYo(escapePattern(word[0]))}\\.`;
+// Everyday orders, partial forms and initials of a Russian full name, longest
+// first so that alternation prefers the complete form at each position.
+function russianForms(words, roles, type) {
+  const name = Object.fromEntries(
+    Object.entries(roles).map(([role, i]) => [role, words[i]])
+  );
+  const gap = '[ \\t]+';
+  const full = (...parts) =>
+    parts.map((part) => wordPattern(part, type)).join(gap);
+  if (name.surname === undefined) {
+    return [];
+  }
+  const initial = initialPattern(name.given);
+  const last = wordPattern(name.surname, type);
+  const short = [
+    full(name.surname, name.given),
+    full(name.given, name.surname),
+    `${last}${gap}${initial}`,
+    `${initial}[ \\t\\u00a0]+${last}`,
+  ];
+  if (name.patronymic === undefined) {
+    return short;
+  }
+  const initials = `${initial}${initialGap}${initialPattern(name.patronymic)}`;
+  return [
+    full(name.surname, name.given, name.patronymic),
+    full(name.given, name.patronymic, name.surname),
+    `${last}[ \\t\\u00a0]+${initials}`,
+    `${initials}[ \\t\\u00a0]+${last}`,
+    ...short,
+    full(name.given, name.patronymic),
+  ];
+}
 export function personalPatterns(value, type) {
   if (value.length > 256) {
     // Large explicit values still support literal matching without expansion.
@@ -52,13 +122,22 @@ export function personalPatterns(value, type) {
   for (const surface of values) {
     const parts = surface.split(/([ \t]+)/u);
     const pattern = parts
-      .map((part, i) => (i % 2 ? '[ \\t]+' : wordPattern(part)))
+      .map((part, i) => (i % 2 ? '[ \\t]+' : wordPattern(part, type)))
       .join('');
     patterns.add(pattern);
-    if (type === 'PERSON' && parts.length === 3) {
-      patterns.add(
-        [wordPattern(parts[2]), wordPattern(parts[0])].join('[ \\t]+')
-      );
+    if (type === 'PERSON') {
+      const words = parts.filter((_part, i) => i % 2 === 0);
+      const roles = russianNameRoles(words);
+      for (const form of roles ? russianForms(words, roles, type) : []) {
+        patterns.add(form);
+      }
+      if (words.length === 2) {
+        patterns.add(
+          [wordPattern(words[1], type), wordPattern(words[0], type)].join(
+            '[ \\t]+'
+          )
+        );
+      }
     }
   }
   return [...patterns];
@@ -77,18 +156,33 @@ export function samePersonal(value, original, type) {
 export function detectKnownPersonal(text, entries, rule, emit, options) {
   let count = 0;
   for (const entry of entries ?? []) {
-    for (const match of text.matchAll(personalRegex(entry.value, entry.type))) {
-      if (++count > (options.maxFindings ?? 100000)) {
-        throw failure('ERR_LIMIT');
+    const family =
+      rule === 'confirmed-personal' &&
+      options.documentEntities &&
+      !options.knownOnly &&
+      entry.type === 'ORGANIZATION' &&
+      organizationFamily(organizationCore(entry.value));
+    for (const pattern of [
+      personalRegex(entry.value, entry.type),
+      ...(family ? [family.pattern] : []),
+    ]) {
+      for (const match of text.matchAll(pattern)) {
+        // A stored capitalized word in lower case is ordinary text: `Мороз`, `мороз`.
+        if (entry.properCase && /^\p{Ll}/u.test(match[0])) {
+          continue;
+        }
+        if (++count > (options.maxFindings ?? 100000)) {
+          throw failure('ERR_LIMIT');
+        }
+        emit({
+          start: match.index,
+          end: match.index + match[0].length,
+          type: entry.type,
+          category: 'personal',
+          rule,
+          confidence: rule === 'known-personal' ? 0.85 : 0.9,
+        });
       }
-      emit({
-        start: match.index,
-        end: match.index + match[0].length,
-        type: entry.type,
-        category: 'personal',
-        rule,
-        confidence: rule === 'known-personal' ? 0.85 : 0.9,
-      });
     }
   }
 }

package/src/personal.js

@@ -29,6 +29,9 @@ const ibanLengths = Object.fromEntries(
     .map((entry) => [entry.slice(0, 2), Number(entry.slice(2))])
 );
 
+// `@handle/jane@example.com` is a mention and an address, not a package path.
+const mentionedEmail =
+  /^\/[\p{L}\p{N}_.!#$%&'*+?^`{|}~-]+@[\p{L}\p{N}][\p{L}\p{N}.-]{0,252}\.\p{L}{2,63}(?![\p{L}\p{N}_-])/u;
 export function iban(value) {
   const compact = value.replace(/\s/g, '').toUpperCase();
   if (
@@ -207,10 +210,11 @@ export function detectPersonal(text, emit) {
   }
   collectMatches(
     text,
-    /(?:компании|организации|company|organization|société|empresa|Firma)[ \t]+([\p{Lu}][\p{L}\p{M}&'-]{1,80})/gu,
+    /(?:компании|организации|company|organization|société|empresa|Firma)[ \t]+([\p{Lu}][\p{L}\p{M}&']{0,80}(?:-[\p{L}\p{M}\p{N}&']{1,40}){0,4})/gu,
     emit,
     details('ORGANIZATION', 'organization-context', 0.7),
-    1
+    1,
+    (value) => value.length >= 2
   );
   collectMatches(
     text,
@@ -236,10 +240,12 @@ export function detectPersonal(text, emit) {
     emit,
     details('USERNAME', 'messenger-handle', 0.65),
     0,
-    (_value, match) =>
-      !/^\/[a-z0-9][a-z0-9_.-]*/i.test(
-        text.slice(match.index + match[0].length)
-      )
+    (_value, match) => {
+      const rest = text.slice(match.index + match[0].length);
+      return (
+        !/^\/[a-z0-9][a-z0-9_.-]*/i.test(rest) || mentionedEmail.test(rest)
+      );
+    }
   );
   collectMatches(
     text,

package/src/placeholders.js

@@ -1,6 +1,7 @@
 import { failure, REDACTED, escapePattern } from './detection.js';
 import { reservedPlaceholderTypes } from './placeholder-types.js';
 import { samePersonal } from './personal-variants.js';
+import { isNameForm } from './russian-names.js';
 import { nameAliases } from './transliteration.js';
 import { createHash } from 'node:crypto';
 import { jsonStringLiterals } from './json-string-runs.js';
@@ -85,13 +86,50 @@ export function placeholderKnown(options) {
       ...map.entries
         .filter((entry) => entry.type !== 'CREDENTIAL')
         .flatMap((entry) =>
-          entry.values
+          (entry.type === 'PERSON' ? reusablePersonValues(entry) : entry.values)
             .filter((value) => value.length <= 256)
-            .map((value) => ({ type: entry.type, value }))
+            .map((value) => ({
+              type: entry.type,
+              value,
+              ...(entry.type === 'PERSON' && properCaseWord(value)
+                ? { properCase: true }
+                : {}),
+            }))
         ),
     ],
   };
 }
+const singleWord = (value) => !/\s/u.test(value.trim());
+const properCaseWord = (value) =>
+  singleWord(value) && /^\p{Lu}/u.test(value.trim());
+// A bare part recorded while replacing a fuller name in its own document is not
+// evidence on its own in the next one, so a reused map offers only the full
+// values, parts listed by the caller and values that were stored alone.
+function reusablePersonValues(entry) {
+  const longer = entry.values.filter((value) => !singleWord(value));
+  return [
+    ...new Set([
+      ...entry.values.filter(
+        (value) =>
+          !singleWord(value) ||
+          !longer.some((full) => partOfPerson(value, full))
+      ),
+      ...(entry.standalone ?? []),
+    ]),
+  ];
+}
+function partOfPerson(value, full) {
+  return (
+    related(
+      value,
+      { type: 'PERSON', aliases: aliases(full, 'PERSON') },
+      true
+    ) ||
+    full
+      .split(/\s+/u)
+      .some((word) => word && samePersonal(value, word, 'PERSON'))
+  );
+}
 const stem = (word) =>
   word.replace(
     /(?:овым|евым|овой|евой|ова|ева|ову|еву|ове|еве|ов|ев|ovym|evym|ovoi|evoi|ova|eva|ovu|evu|ove|eve|ov|ev)$/u,
@@ -107,7 +145,30 @@ function aliases(value, type) {
     ),
   ];
 }
-function related(value, entry) {
+// A bare name is the same entity as its numbered form, including maps saved
+// when the span stopped at the hyphen of `Вектор-99`.
+function numberedOrganization(value, entry) {
+  return (entry.values ?? []).some((original) => {
+    const base = original.replace(/-\d*$/u, '');
+    return base !== original && samePersonal(value, base, entry.type);
+  });
+}
+function wordsMatchAlias(words, full, parts) {
+  if (words.length === 1) {
+    return parts && words[0].length > 1 && full.includes(words[0]);
+  }
+  return (
+    words.length > 1 &&
+    words.length === full.length &&
+    words.every(
+      (part, i) =>
+        part === full[i] || (part.length === 1 && full[i].startsWith(part))
+    )
+  );
+}
+// `parts` links a bare word to a fuller alias. Only callers that hold evidence
+// from the current document may ask for it; a stored entry alone is not enough.
+function related(value, entry, parts = false) {
   if (
     (entry.values ?? []).some((original) =>
       samePersonal(value, original, entry.type)
@@ -119,49 +180,41 @@ function related(value, entry) {
   if (candidates.some((alias) => entry.aliases.includes(alias))) {
     return true;
   }
+  if (entry.type === 'ORGANIZATION') {
+    return numberedOrganization(value, entry);
+  }
   if (entry.type !== 'PERSON') {
     return false;
   }
-  for (const candidate of candidates) {
-    const parts = candidate.match(/[\p{L}\p{M}]+/gu) ?? [];
-    for (const alias of entry.aliases) {
-      const full = alias.match(/[\p{L}\p{M}]+/gu) ?? [];
-      if (
-        parts.length === 1 &&
-        parts[0].length > 1 &&
-        full.includes(parts[0])
-      ) {
-        return true;
-      }
-      if (
-        parts.length === full.length &&
-        parts.length > 1 &&
-        parts.every(
-          (part, i) =>
-            part === full[i] || (part.length === 1 && full[i].startsWith(part))
-        )
-      ) {
-        return true;
-      }
-    }
-  }
-  return false;
+  return candidates.some((candidate) => {
+    const words = candidate.match(/[\p{L}\p{M}]+/gu) ?? [];
+    return entry.aliases.some((alias) =>
+      wordsMatchAlias(words, alias.match(/[\p{L}\p{M}]+/gu) ?? [], parts)
+    );
+  });
 }
 export function placeholderNameFindings(text, findings, options) {
   if (!hasPlaceholders(options) || options.knownOnly) {
     return findings;
   }
-  const people = [
+  const state = options[placeholderState];
+  const patterns = new Set();
+  // Bare surname forms need the full name in this document. A stored person
+  // keeps only the initial form, which is itself a full mention.
+  for (const person of [
     ...findings
       .filter((f) => f.type === 'PERSON')
       .map((f) => text.slice(f.start, f.end)),
-    ...(options[placeholderState]?.map.entries ?? [])
-      .filter((e) => e.type === 'PERSON')
-      .flatMap((e) => e.values),
-  ];
-  const patterns = new Set();
-  for (const person of people) {
-    addNamePatterns(person, patterns);
+    ...earlierPeople(options),
+  ]) {
+    addNamePatterns(person, patterns, true);
+  }
+  for (const entry of state?.map.entries ?? []) {
+    if (entry.type === 'PERSON') {
+      for (const person of entry.values) {
+        addNamePatterns(person, patterns, false);
+      }
+    }
   }
   const result = [...findings];
   for (const pattern of patterns) {
@@ -183,7 +236,56 @@ export function placeholderNameFindings(text, findings, options) {
   }
   return result;
 }
-function addNamePatterns(person, patterns) {
+// Stream batches and decoded layers are pieces of the document being replaced.
+function earlierPeople(options) {
+  const state = options[placeholderState];
+  return state?.stream || options[placeholderNested]
+    ? (state?.people ?? [])
+    : [];
+}
+const nameNeighbour = "\\p{Lu}[\\p{L}\\p{M}'’-]{1,31}";
+const nameBefore = new RegExp(
+  `(?<![\\p{L}\\p{M}\\p{N}_-])(${nameNeighbour})[ \\t]+$`,
+  'u'
+);
+const nameAfter = new RegExp(
+  `^[ \\t]+(${nameNeighbour})(?![\\p{L}\\p{M}\\p{N}_])`,
+  'u'
+);
+const neighbourWindow = 64;
+// `Алина` beside a bare `петрову` is the rest of that mention: replacing only the
+// surname would leave that given name beside the token of the surname's owner.
+export function coverAdjacentNames(text, findings, options) {
+  if (!hasPlaceholders(options)) {
+    return findings;
+  }
+  return findings.map((finding) => {
+    if (
+      finding.type !== 'PERSON' ||
+      !singleWord(text.slice(finding.start, finding.end))
+    ) {
+      return finding;
+    }
+    let { start, end } = finding;
+    // A given name and a patronymic can both stand on one side of a surname.
+    for (let step = 0; step < 2; step++) {
+      const before = nameBefore.exec(
+        text.slice(Math.max(0, start - neighbourWindow), start)
+      );
+      if (before && isNameForm(before[1])) {
+        start -= before[0].length;
+      }
+      const after = nameAfter.exec(text.slice(end, end + neighbourWindow));
+      if (after && isNameForm(after[1])) {
+        end += after[0].length;
+      }
+    }
+    return start === finding.start && end === finding.end
+      ? finding
+      : { ...finding, start, end, rule: 'name-variant' };
+  });
+}
+function addNamePatterns(person, patterns, bareForms) {
   const words = person.match(/[\p{L}\p{M}]+/gu) ?? [];
   if (words.length < 2 || words.some((word) => word.length < 2)) {
     return;
@@ -196,7 +298,7 @@ function addNamePatterns(person, patterns) {
     patterns.add(
       `${escapePattern(parts[0][0])}\\.[ \\t]+${parts.slice(1).map(escapePattern).join('[ \\t]+')}`
     );
-    for (const word of parts) {
+    for (const word of bareForms ? parts : []) {
       if (/^[а-яё]+(?:ов|ев)$/u.test(word)) {
         patterns.add(`${escapePattern(word)}(?:ым|ой|а|у|е|ы|ых|ами)?`);
       }
@@ -230,14 +332,16 @@ export function preparePlaceholderText(text, findings, options) {
   if (namespaceCollision(text, pattern)) {
     throw failure('ERR_PLACEHOLDER_COLLISION');
   }
-  const people = findings
-    .filter((f) => f.type === 'PERSON')
-    .map((f) => text.slice(f.start, f.end));
   state.people = [
-    ...people,
-    ...state.map.entries
-      .filter((e) => e.type === 'PERSON')
-      .flatMap((e) => e.values),
+    ...new Set([
+      ...earlierPeople(options),
+      ...findings
+        .filter((f) => f.type === 'PERSON')
+        .map((f) => text.slice(f.start, f.end)),
+      ...(options.knownPersonal ?? [])
+        .filter((e) => e.type === 'PERSON')
+        .map((e) => e.value),
+    ]),
   ];
 }
 function namespaceCollision(text, pattern) {
@@ -257,14 +361,18 @@ function namespaceCollision(text, pattern) {
   return false;
 }
 
-function canonicalPerson(value, people) {
+export function canonicalPerson(value, people) {
   // Resolve components only when there is a unique compatible full name.
   const matches = people.filter((person) => {
     const words = person.match(/\p{L}+/gu) ?? [];
     return (
       words.length > 1 &&
       words.every((word) => word.length > 1) &&
-      related(value, { type: 'PERSON', aliases: aliases(person, 'PERSON') })
+      related(
+        value,
+        { type: 'PERSON', aliases: aliases(person, 'PERSON') },
+        true
+      )
     );
   });
   const distinct = new Map(
@@ -279,10 +387,36 @@ function canonicalKnown(value, type, options, state) {
   const known = (options.knownPersonal ?? []).filter(
     (e) => e.type === type && samePersonal(value, e.value, type)
   );
-  if (known.length === 1) {
-    return known[0].value;
+  // `Петров Данил` and `Петров Данил Сергеевич` are one person: the fullest wins.
+  const longest = Math.max(0, ...known.map((e) => e.value.length));
+  const fullest = known.filter((e) => e.value.length === longest);
+  const listed = fullest.length === 1 ? fullest[0].value : value;
+  if (type !== 'PERSON') {
+    return listed;
+  }
+  // The caller's list names each person once, while the document may hold the
+  // same full name in several cases, so the list settles a listed part first.
+  const named = canonicalPerson(
+    listed,
+    (options.knownPersonal ?? [])
+      .filter((e) => e.type === 'PERSON')
+      .map((e) => e.value)
+  );
+  return named === listed ? canonicalPerson(listed, state.people ?? []) : named;
+}
+// A part the caller listed is stored as its own value, unlike a part that was
+// only recorded as a surface of a longer name.
+function rememberListedParts(entry, value, options) {
+  for (const known of options.knownPersonal ?? []) {
+    if (
+      known.type === 'PERSON' &&
+      singleWord(known.value) &&
+      samePersonal(value, known.value, 'PERSON') &&
+      !entry.standalone?.includes(known.value)
+    ) {
+      (entry.standalone ??= []).push(known.value);
+    }
   }
-  return type === 'PERSON' ? canonicalPerson(value, state.people ?? []) : value;
 }
 export function placeholderReplacement(value, finding, transform, options) {
   if (finding.category === 'credential' && !transform.credentials) {
@@ -303,7 +437,12 @@ export function placeholderReplacement(value, finding, transform, options) {
   const candidates = map.entries.filter(
     (entry) => entry.type === type && related(canonical, entry)
   );
-  let entry = candidates.length === 1 ? candidates[0] : undefined;
+  // Several related entities are ambiguous, unless one holds this exact value.
+  const exact = candidates.filter((entry) =>
+    entry.values.some((original) => samePersonal(canonical, original, type))
+  );
+  const matches = candidates.length === 1 ? candidates : exact;
+  let entry = matches.length === 1 ? matches[0] : undefined;
   if (!entry) {
     if (map.entries.length >= (options.maxFindings ?? 100000)) {
       throw failure('ERR_LIMIT');
@@ -333,6 +472,9 @@ export function placeholderReplacement(value, finding, transform, options) {
   if (!entry.values.includes(value)) {
     entry.values.push(value);
   }
+  if (type === 'PERSON') {
+    rememberListedParts(entry, value, options);
+  }
   return entry.token;
 }
 export function finishPlaceholders(result, occurrences, options) {

package/src/propagation.js

@@ -1,6 +1,6 @@
 import { personalPattern, maxPropagationLength, failure } from './detection.js';
 import { actionable } from './confidence.js';
-import { organizationCore } from './personal-variants.js';
+import { organizationCore, organizationFamily } from './personal-variants.js';
 import { nameAliases } from './transliteration.js';
 
 function mrzSeeds(value, finding, seeds) {
@@ -50,12 +50,16 @@ function eligibleSeed(finding, options) {
       ].includes(finding.type))
   );
 }
-function organizationSeed(value, finding, seeds, options) {
+function organizationSeed(text, value, finding, seeds, options) {
   if (options.documentEntities && finding.type === 'ORGANIZATION') {
     const core = organizationCore(value);
     if (core.length >= 3) {
       seeds.set(core, finding);
     }
+    const family = organizationFamily(core);
+    for (const match of family ? text.matchAll(family.pattern) : []) {
+      seeds.set(match[0], finding);
+    }
   }
 }
 // Only confirmed values seed propagation. A low-score numeric coincidence
@@ -82,7 +86,7 @@ export function confirmedSeeds(text, findings, options) {
       mrzSeeds(value, finding, seeds);
     } else if (value.length >= 2) {
       seeds.set(value, finding);
-      organizationSeed(value, finding, seeds, options);
+      organizationSeed(text, value, finding, seeds, options);
       if (finding.type === 'PERSON') {
         for (const name of value.match(/\p{L}{2,}/gu) ?? []) {
           seeds.set(name, finding);

package/src/restore-map.js

@@ -85,7 +85,8 @@ function validateEntries(map) {
       tokens.has(entry.token) ||
       !nonemptyStrings(entry.values) ||
       !Array.isArray(entry.aliases) ||
-      entry.aliases.some((v) => typeof v !== 'string' || !v)
+      entry.aliases.some((v) => typeof v !== 'string' || !v) ||
+      (entry.standalone !== undefined && !nonemptyStrings(entry.standalone))
     ) {
       throw failure('ERR_MAP');
     }