chaffjs 0.30.0 → 0.32.0

package/src/name-variants.ts

@@ -2,6 +2,10 @@ import type { Token } from "./plugin.ts";
 import { escapeRegExp } from "./orthography.ts";
 import { nameCueAt, type NameCue, type NameCues } from "./name-cue.ts";
 import { isNearSurname } from "./surname-near.ts";
+import { foldedKeysOf, NO_SPELLING, type SpellingInput } from "./name-spelling-chars.ts";
+import { NO_CHAR_READINGS, readingOfWords } from "./name-char-reading.ts";
+import { isPersonRun } from "./name-person.ts";
+import { heavierFirst, outweighs, type NameWeight } from "./name-weight.ts";
 
 // 同じ名前（人・会社・製品）を、文書の中で少しだけ違う形に書いた所。どの形が正しいかは決めず、少ないほうを指す。
 // 三通りで同じ名前と見る。書き方の違いだけ（GitHub と Github、Mac OS と macOS）、読みが同じ（山田太郎 と 山田太朗）、
@@ -9,7 +13,9 @@ import { isNearSurname } from "./surname-near.ts";
 
 /**
  * words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。person は人の名前と読めるもの（解析器が
- * 人名と読むか、敬称が付く）。cue は前後の語から見た名前らしさ（name-cue.ts）。
+ * 人名と読むか、敬称が付く）。cue は前後の語から見た名前らしさ（name-cue.ts）。ordinary は、ふつうの語でもある一語の名前で、
+ * 文書がその形をどこでも名前に使わないもの（name-ordinary-word.ts）。labelled は、人を書く欄（氏名：、Contractor:）に書いた名前
+ * （person-field.ts）。
  */
 export type NameMention = {
   readonly surface: string;
@@ -18,12 +24,14 @@ export type NameMention = {
   readonly words: readonly string[];
   readonly person?: boolean;
   readonly cue?: NameCue;
+  readonly ordinary?: boolean;
+  readonly labelled?: boolean;
 };
 
 export type NameVariant = {
   readonly mention: NameMention;
   readonly usual: string;
-  readonly kind: "spelling" | "reading" | "near" | "surname" | "character";
+  readonly kind: "spelling" | "kana" | "reading" | "near" | "surname" | "character" | "field";
 };
 
 /** 字体の違う同じ字（斎・斉・齋）。字から、その組の代表の字へ。 */
@@ -78,18 +86,12 @@ const withoutEdgeQuotes = (text: string): string => {
  */
 const NOT_COMPARED = /@|(?:^|\s)\p{L}(?:\s|$)/u;
 
-/** 人名と読む解析器の印（UD の NameType: 姓 Sur、名 Giv、どちらとも言えない人名 Prs）。 */
-const PERSON_TYPES: ReadonlySet<string> = new Set(["Sur", "Giv", "Prs"]);
-
-/** 人の名前か。解析器が人名と読む語を含むか、すぐ後ろに敬称（様、さん、氏）が付く。 */
-const isPerson = (run: readonly Token[], next: Token | undefined, suffixes: readonly string[]): boolean =>
-  run.some((token) => PERSON_TYPES.has(token.features?.["NameType"] ?? "")) || (next !== undefined && suffixes.includes(next.surface));
-
 /**
  * 文の語から、名前の現れ。surface は source の上の書いたまま（折り返しの空白は一つにまとめる）。
  * 大文字だけの名前（ACME INC、NASA）は外す。契約書の署名欄や略語で、ふつうの書き方の別の形ではない。小文字の英字だけの語も外す。
+ * charReadings は解析器が読めない名前の字の読み（name-char-reading.ts）。人の名前と読めるものだけに使う。
  */
-export const mentionsIn = (tokens: readonly Token[], source: string, personSuffixes: readonly string[] = []): NameMention[] =>
+export const mentionsIn = (tokens: readonly Token[], source: string, personSuffixes: readonly string[] = [], charReadings = NO_CHAR_READINGS): NameMention[] =>
   runsOf(tokens).flatMap((run) => {
     const first = run[0];
     const last = run.at(-1);
@@ -98,67 +100,11 @@ export const mentionsIn = (tokens: readonly Token[], source: string, personSuffi
     const surface = withoutEdgeQuotes(written);
     if (surface === "" || isUpperOnly(surface) || LOWER_LATIN_ONLY.test(surface) || NOT_COMPARED.test(surface)) return [];
     const words = run.filter((token) => !JOINERS.has(token.surface));
-    const readings = words.map((token) => token.reading);
-    const reading = readings.every((value) => value !== undefined && value !== "") ? readings.join("") : undefined;
-    const person = isPerson(run, tokens[tokens.indexOf(last) + 1], personSuffixes);
+    const person = isPersonRun(run, tokens, personSuffixes);
+    const reading = readingOfWords(words, person ? charReadings : NO_CHAR_READINGS);
     return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface), person }];
   });
 
-/** 隣の語を探す範囲（UTF-16 の単位）。 */
-const NEIGHBOUR_LOOKBACK = 40;
-/** 隣の語の外側の記号（(Rachel、Floyd.）。名前の側の記号（Rachel, Whitford の ,）は語を切るので残す。 */
-const MARK = /\p{P}/u;
-const withoutLeadingMarks = (word: string): string => {
-  const chars = [...word];
-  const start = chars.findIndex((char) => !MARK.test(char));
-  return start < 0 ? "" : chars.slice(start).join("");
-};
-const withoutTrailingMarks = (word: string): string => {
-  const chars = [...word];
-  return chars.slice(0, chars.findLastIndex((char) => !MARK.test(char)) + 1).join("");
-};
-
-const wordBeforeAt = (source: string, offset: number): string | undefined => {
-  if (source.charAt(offset - 1) !== " ") return undefined;
-  const from = Math.max(0, offset - 1 - NEIGHBOUR_LOOKBACK);
-  const parts = source.slice(from, offset - 1).split(/\s/u);
-  const word = withoutLeadingMarks(parts.at(-1) ?? "");
-  return word === "" || (from > 0 && parts.length === 1) ? undefined : word;
-};
-
-const wordAfterAt = (source: string, end: number): string | undefined => {
-  if (source.charAt(end) !== " ") return undefined;
-  const word = withoutTrailingMarks(source.slice(end + 1, end + 1 + NEIGHBOUR_LOOKBACK).split(/\s/u)[0] ?? "");
-  return word === "" ? undefined : word;
-};
-
-/**
- * 解析器が名前の一語を名前と読まなかった所（to Rachel Whitford の Rachel を動詞と読む）。空白一つで隣の語と合わせた形を、ほかの所で
- * 名前と読めていれば、その形の現れと見る。隣の語がほかの名前の現れに入るなら合わせない。
- */
-export const withKnownNeighbours = (mentions: readonly NameMention[], source: string): NameMention[] => {
-  const known = new Set(mentions.filter((mention) => mention.words.length >= 2).map((mention) => mention.surface));
-  const taken = (start: number, end: number): boolean => mentions.some((mention) => mention.offset < end && start < mention.offset + mention.surface.length);
-  return mentions.map((mention) => {
-    const end = mention.offset + mention.surface.length;
-    const before = wordBeforeAt(source, mention.offset);
-    const after = wordAfterAt(source, end);
-    if (before !== undefined && known.has(`${before} ${mention.surface}`) && !taken(mention.offset - 1 - before.length, mention.offset - 1)) {
-      return {
-        ...mention,
-        surface: `${before} ${mention.surface}`,
-        offset: mention.offset - 1 - before.length,
-        reading: undefined,
-        words: [before, ...mention.words],
-      };
-    }
-    if (after !== undefined && known.has(`${mention.surface} ${after}`) && !taken(end + 1, end + 1 + after.length)) {
-      return { ...mention, surface: `${mention.surface} ${after}`, reading: undefined, words: [...mention.words, after] };
-    }
-    return mention;
-  });
-};
-
 /** 敬称の前の名前の字数（髙橋、髙橋太郎）。長い漢字の連なり（株式会社髙橋）は名前だけを切り出せない。 */
 const MAX_SUFFIXED_NAME = 4;
 const MIN_SUFFIXED_NAME = 2;
@@ -217,7 +163,11 @@ export const nameKey = (surface: string): string =>
  */
 export type NameEvidence = { readonly person: boolean; readonly named: boolean; readonly nameLike: boolean };
 
-type Tally = NameEvidence & { readonly surface: string; readonly first: NameMention; readonly count: number };
+/** readings は書き方の現れの読みのすべて。解析器は同じ字を所によって別に読む（佐伯 を サエキ と サイキ）。 */
+type Tally = NameEvidence & NameWeight & { readonly surface: string; readonly first: NameMention; readonly readings: readonly string[] };
+
+const readingsWith = (readings: readonly string[], reading: string | undefined): readonly string[] =>
+  reading === undefined || readings.includes(reading) ? readings : [...readings, reading];
 
 const evidenceOf = (mention: NameMention): NameEvidence => ({
   person: mention.person === true,
@@ -234,22 +184,24 @@ const talliesOf = (mentions: readonly NameMention[]): Tally[] => {
     tallies.set(
       mention.surface,
       tally === undefined
-        ? { surface: mention.surface, first: mention, count: 1, ...evidence }
+        ? { surface: mention.surface, first: mention, count: 1, readings: readingsWith([], mention.reading), labelled: mention.labelled === true, ...evidence }
         : {
             ...tally,
             count: tally.count + 1,
+            readings: readingsWith(tally.readings, mention.reading),
             person: tally.person || evidence.person,
             named: tally.named || evidence.named,
             nameLike: tally.nameLike || evidence.nameLike,
+            labelled: tally.labelled || mention.labelled === true,
           },
     );
   });
   return [...tallies.values()];
 };
 
-/** 多いほう。同数なら先に書いたほう。 */
+/** 重いほう（name-weight.ts）。同じ重さなら先に書いたほう。 */
 const usualOf = (group: readonly Tally[]): Tally | undefined =>
-  group.toSorted((left, right) => right.count - left.count || left.first.offset - right.first.offset)[0];
+  group.toSorted((left, right) => heavierFirst(left, right) || left.first.offset - right.first.offset)[0];
 
 const groupBy = (tallies: readonly Tally[], keysOf: (tally: Tally) => readonly string[]): Tally[][] => {
   const groups = new Map<string, Tally[]>();
@@ -265,13 +217,17 @@ const groupBy = (tallies: readonly Tally[], keysOf: (tally: Tally) => readonly s
 
 /**
  * 組の中で、それぞれの書き方を、同じ名前と言える相手（alike）のうち多いほうと比べる。組全体で一番多いものとだけ比べると、
- * 同じ読みの別の名前（山田太郎 と 矢間田多労）が多ければ、本当の書き分け（山田太朗）が隠れる。
+ * 同じ読みの別の名前（山田太郎 と 矢間田多労）が多ければ、本当の書き分け（山田太朗）が隠れる。alike が数を問う見方では、
+ * 一度だけ書いた相手を選んだのは人を書く欄に書いたからなので、field と言う。
  */
-const variantsIn = (groups: readonly Tally[][], kind: NameVariant["kind"], alike: (tally: Tally, other: Tally) => boolean = () => true): NameVariant[] =>
+type Alike = (tally: Tally, other: Tally) => boolean;
+
+const variantsIn = (groups: readonly Tally[][], kind: NameVariant["kind"], alike: Alike = () => true, counted = false): NameVariant[] =>
   groups.flatMap((group) =>
     group.flatMap((tally) => {
       const usual = usualOf([tally, ...group.filter((other) => other !== tally && alike(tally, other))]);
-      return usual === undefined || usual === tally ? [] : [{ mention: tally.first, usual: usual.surface, kind }];
+      if (usual === undefined || usual === tally) return [];
+      return [{ mention: tally.first, usual: usual.surface, kind: counted && usual.count === 1 ? "field" : kind }];
     }),
   );
 
@@ -334,28 +290,28 @@ const differingWords = (left: Tally, right: Tally): readonly [string, string] |
   return leftWords.length === rightWords.length && leftWord !== undefined && rightWord !== undefined ? [leftWord, rightWord] : undefined;
 };
 
-/** 一語だけが一字違いで、相手が二度以上、こちらが一度だけ。 */
+/** 一語だけが一字違いで、相手のほうが重い（outweighs）。どちらもふつうの語（Green と Greek）なら、別の二つの語。 */
 const isSlipOf = (tally: Tally, other: Tally): boolean => {
-  if (tally.count !== 1 || other.count < 2) return false;
+  if (!outweighs(other, tally) || (tally.first.ordinary === true && other.first.ordinary === true)) return false;
   const words = differingWords(tally, other);
   return words !== undefined && isNearWord(...words);
 };
 
-const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "near", isSlipOf);
+const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "near", isSlipOf, true);
 
 /**
  * 名が同じで姓だけが二字ほど違う人の名前（Rachel Whitford と Rachel Whitfield）。一字違い（near）より遠いので、名と姓の二語以上
- * で、違うのが最後の語のときに限る。相手が二度以上、こちらが一度だけ。名の違う二人（Sara Whitford と Rachel Whitfield）は比べない。
+ * で、違うのが最後の語のときに限る。相手のほうが重い（outweighs）。名の違う二人（Sara Whitford と Rachel Whitfield）は比べない。
  */
 const isSurnameSlipOf = (tally: Tally, other: Tally): boolean => {
-  if (tally.count !== 1 || other.count < 2) return false;
+  if (!outweighs(other, tally)) return false;
   const [words, others] = [wordsOf(tally.surface), wordsOf(other.surface)];
   const last = words.length - 1;
   const sameBefore = words.slice(0, last).every((word, index) => word === others[index]);
   return last >= 1 && words.length === others.length && sameBefore && isNearSurname(words[last] ?? "", others[last] ?? "");
 };
 
-const surnameVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "surname", isSurnameSlipOf);
+const surnameVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "surname", isSurnameSlipOf, true);
 
 /** 字体の違う字（斎と斉）を組の代表の字に寄せた形。 */
 const characterKey = (tally: Tally, chars: VariantChars): string => [...tally.surface].map((letter) => chars.get(letter) ?? letter).join("");
@@ -386,26 +342,27 @@ const oneCharApart = (left: string, right: string): boolean => {
 };
 
 /**
- * 読みが同じ人の名前が、一字だけ違う（松本 と 松元）。読みの同じ別の姓（伊藤 と 伊東）もあるので、多いほうが二度以上、
- * 少ないほうが一度だけのときに限る。
+ * 読みが同じ人の名前が、一字だけ違う（松本 と 松元）。読みの同じ別の姓（伊藤 と 伊東）もあるので、相手のほうが重い（outweighs）
+ * ときに限る。
  */
-const isPersonSlipOf = (tally: Tally, other: Tally): boolean => tally.count === 1 && other.count >= 2 && oneCharApart(tally.surface, other.surface);
+const isPersonSlipOf = (tally: Tally, other: Tally): boolean => outweighs(other, tally) && oneCharApart(tally.surface, other.surface);
 
 const personReadingVariants = (tallies: readonly Tally[]): NameVariant[] =>
   variantsIn(
     groupBy(
       tallies.filter((tally) => tally.person),
-      (tally) => (tally.first.reading === undefined ? [] : [tally.first.reading]),
+      (tally) => tally.readings,
     ),
     "reading",
     isPersonSlipOf,
+    true,
   );
 
 /**
  * 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。chars は字体の
  * 違う同じ字の組（語彙表 name-variant-char）。
  */
-export const nameVariants = (mentions: readonly NameMention[], chars: VariantChars = new Map()): NameVariant[] => {
+export const nameVariants = (mentions: readonly NameMention[], chars: VariantChars = new Map(), spelling: SpellingInput = NO_SPELLING): NameVariant[] => {
   const tallies = talliesOf(mentions);
   const found = [
     ...variantsIn(
@@ -413,7 +370,11 @@ export const nameVariants = (mentions: readonly NameMention[], chars: VariantCha
       "spelling",
     ),
     ...variantsIn(
-      groupBy(tallies, (tally) => (tally.first.reading === undefined ? [] : [tally.first.reading])),
+      groupBy(talliesOf([...mentions, ...spelling.alsoWritten]), (tally) => foldedKeysOf(tally.surface, spelling.chars).map(nameKey)),
+      "kana",
+    ),
+    ...variantsIn(
+      groupBy(tallies, (tally) => tally.readings),
       "reading",
       oneWordApart,
     ),
@@ -424,10 +385,6 @@ export const nameVariants = (mentions: readonly NameMention[], chars: VariantCha
   ];
   const reported = new Set<string>();
   return found
-    .filter((variant) => {
-      if (reported.has(variant.mention.surface)) return false;
-      reported.add(variant.mention.surface);
-      return true;
-    })
+    .filter((variant) => !reported.has(variant.mention.surface) && reported.add(variant.mention.surface).size > 0)
     .toSorted((left, right) => left.mention.offset - right.mention.offset);
 };

package/src/name-weight.ts

@@ -0,0 +1,12 @@
+// 同じ名前の二つの書き方のうち、どちらを正しい形と見るか。多く書いたほう。どちらも一度だけなら、人を書く欄（氏名：、
+// Contractor:）に書いたほう。欄に書いた名前は、書き手が確かめて書いた形。
+
+/** count は文書の中で書いた数、labelled はどれかの現れを人を書く欄に書いたか。 */
+export type NameWeight = { readonly count: number; readonly labelled: boolean };
+
+/** 並べたとき重いほうが先。数が多いほう、同数なら欄に書いたほう。 */
+export const heavierFirst = (left: NameWeight, right: NameWeight): number => right.count - left.count || Number(right.labelled) - Number(left.labelled);
+
+/** 一度だけ書いた slip を、other の書き損じと見てよいか。other が二度以上か、どちらも一度だけで other だけを欄に書いたとき。 */
+export const outweighs = (other: NameWeight, slip: NameWeight): boolean =>
+  slip.count === 1 && (other.count >= 2 || (other.count === 1 && other.labelled && !slip.labelled));

package/src/person-field.ts

@@ -0,0 +1,43 @@
+// 人を書く欄（氏名：山下 美咲、Contractor: Priya Raman）に書いた名前。欄の語は語彙表 person-label から。
+
+const FIELD_COLON = /[：:]/u;
+/** 欄の行の頭の、Markdown の印（箇条書き、引用、見出し、太字）。 */
+const LINE_MARKS = /^[\s>*#+-]*(?:\*\*|__)?/u;
+const TRAILING_BOLD = /(?:\*\*|__)$/u;
+/** 「：」と名前のあいだ: 空白と太字の印だけ。欄の値の途中の名前（ご宿泊者：森下 千尋 様 の 千尋 様）は欄の名前でない。 */
+const VALUE_START = /^(?:[ \t\u3000]|\*\*|__)*$/u;
+/** 名前の後ろ: 太字の閉じと、行の終わり。日付などの括弧一つで終わってもよい。「,」の後ろは文の続きのことがある（Priya Raman, and …）。 */
+const FIELD_END = /^(?:\*\*|__)?[ \t\u3000]*(?:[(（][^()（）\n]*[)）][ \t\u3000]*)?(?:\r?\n|$)/u;
+const LEADING_SPACE = /^[ \t\u3000]+/u;
+/** 欄の語の前で語を切らない字。Company name の name は欄の語 Name ではない。患者氏名 の 氏名 は 氏名。 */
+const WORD_BEFORE = /[\s\p{Script=Latin}]$/u;
+
+const lineStart = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+/** 欄の語。行の頭の「:」の前まるごとで、大文字小文字は見ない。漢字やかなの欄の語は、前に語が付いてもよい（患者氏名）。 */
+const isPersonLabel = (label: string, labels: readonly string[]): boolean => {
+  const lower = label.toLowerCase();
+  return labels.some((pattern) => {
+    const wanted = pattern.toLowerCase();
+    return lower === wanted || (lower.endsWith(wanted) && !WORD_BEFORE.test(lower.slice(0, -wanted.length)));
+  });
+};
+
+/** 名前の後ろの敬称（中村 健太 様）を一つ除いた残り。 */
+const afterSuffix = (rest: string, suffixes: readonly string[]): string => {
+  const trimmed = rest.replace(LEADING_SPACE, "");
+  const suffix = suffixes.find((word) => trimmed.startsWith(word));
+  return suffix === undefined ? rest : trimmed.slice(suffix.length);
+};
+
+/**
+ * source の offset から length の名前が、人を書く欄の行の、欄の語と「：」のすぐ後ろにあり、そこで行が終わるか（氏名：山下 美咲、
+ * 患者氏名：中村 健太 様、- **Contractor:** Priya Raman、Name: **Priya Raman**）。suffixes は名前の後ろに付いてよい敬称（様）。
+ */
+export const isInPersonField = (source: string, offset: number, length: number, labels: readonly string[], suffixes: readonly string[] = []): boolean => {
+  const head = source.slice(lineStart(source, offset), offset);
+  const colon = head.search(FIELD_COLON);
+  if (colon < 0 || !VALUE_START.test(head.slice(colon + 1)) || !FIELD_END.test(afterSuffix(source.slice(offset + length), suffixes))) return false;
+  const label = head.slice(0, colon).replace(LINE_MARKS, "").replace(TRAILING_BOLD, "").trim();
+  return label !== "" && isPersonLabel(label, labels);
+};

package/src/person-full-name.ts

@@ -0,0 +1,70 @@
+import type { NameCue } from "./name-cue.ts";
+import type { NameMention } from "./name-variants.ts";
+import type { Span, Token } from "./plugin.ts";
+import { isFollowedBySuffix } from "./name-person.ts";
+
+// 空白（半角か全角）を挟んで書いた姓と名（田中 裕子）。解析器は空白で名前を切るので、名だけ（裕子）が名前の現れになり、別の人の
+// 名（鈴木 祐子 の 祐子）と比べてしまう。姓と名を一つの現れにして、名前まるごとで比べる。
+
+/** 姓と名のあいだの空白（半角、全角）。 */
+const NAME_SPACE = /^[ \u3000]$/u;
+
+const nameTypeOf = (token: Token | undefined): string | undefined => (token?.pos === "PROPN" ? token.features?.["NameType"] : undefined);
+
+/** 姓の後ろの名。解析器が名（Giv）と読む語か、名を地名と読んでも（千尋 を Geo）後ろに敬称が付く、姓でない固有名詞。 */
+const isGivenName = (token: Token | undefined, tokens: readonly Token[], suffixes: readonly string[]): boolean => {
+  const type = nameTypeOf(token);
+  return type === "Giv" || (token?.pos === "PROPN" && type !== "Sur" && isFollowedBySuffix(token, tokens, suffixes));
+};
+
+/** 姓と名を分ける空白の語。前の語を解析器が姓（Sur）と読み、後ろの語が名の、空白一つ。suffixes は敬称（様、さん）。 */
+export const fullNameGaps = (tokens: readonly Token[], suffixes: readonly string[] = []): Span[] =>
+  tokens.flatMap((token, index) =>
+    NAME_SPACE.test(token.surface) && nameTypeOf(tokens[index - 1]) === "Sur" && isGivenName(tokens[index + 1], tokens, suffixes) ? [token.span] : [],
+  );
+
+const CUE_STRENGTH: readonly (NameCue | undefined)[] = [undefined, "bare", "slot", "person"];
+
+/** 二つの現れの名前らしさの強いほう。前置き（担当の）は姓の前に、敬称（様）は名の後ろに付く。 */
+const strongerCue = (left: NameCue | undefined, right: NameCue | undefined): NameCue | undefined =>
+  CUE_STRENGTH.indexOf(left) >= CUE_STRENGTH.indexOf(right) ? left : right;
+
+const joined = (surname: NameMention, given: NameMention): NameMention => {
+  const cue = strongerCue(surname.cue, given.cue);
+  return {
+    ...surname,
+    surface: `${surname.surface} ${given.surface}`,
+    reading: surname.reading === undefined || given.reading === undefined ? undefined : surname.reading + given.reading,
+    words: [...surname.words, ...given.words],
+    person: surname.person === true || given.person === true,
+    ...(cue === undefined ? {} : { cue }),
+  };
+};
+
+/** 空白をちょうど挟む、一語の姓と名か。名は解析器が二語に切ることがある（健汰 を 健 と 汰）。 */
+const isPair = (surname: NameMention, given: NameMention, gaps: readonly Span[]): boolean =>
+  surname.words.length === 1 && gaps.some((gap) => gap.start === surname.offset + surname.surface.length && gap.end === given.offset);
+
+/** 空白を挟んだ一語の姓と名（田中 裕子）を、一つの名前の現れにする。名だけ、姓だけの現れはそのまま。 */
+export const joinFullNames = (mentions: readonly NameMention[], gaps: readonly Span[]): NameMention[] => {
+  const names: NameMention[] = [];
+  mentions
+    .toSorted((left, right) => left.offset - right.offset)
+    .forEach((mention) => {
+      const previous = names.at(-1);
+      if (previous !== undefined && isPair(previous, mention, gaps)) names.splice(-1, 1, joined(previous, mention));
+      else names.push(mention);
+    });
+  return names;
+};
+
+const LATIN = /\p{Script=Latin}/u;
+const SPACE = /\s/u;
+const withoutSpaces = (surface: string): string => surface.replaceAll(/\s/gu, "");
+
+/**
+ * 日本語の名前の、姓と名のあいだに空白を置くかどうかだけが違う二つ（田中 裕子 と 田中裕子）。書き方の揺れとしては指さない。空白の
+ * 幅の違い（半角と全角）と、英字の名前の空白（Mac OS と MacOS）は書き方の違いなので、ここには入れない。
+ */
+export const spacedOnly = (left: string, right: string): boolean =>
+  !LATIN.test(left) && !LATIN.test(right) && SPACE.test(left) !== SPACE.test(right) && withoutSpaces(left) === withoutSpaces(right);

package/src/phone-numbers.ts

@@ -20,9 +20,22 @@ const NUMBER_EDGE_AFTER = String.raw`(?![\d\-‐−]|[.,]\d)`;
 const COUNTRY_CODE = String.raw`(?:\+\d{1,3}[ -]?)?`;
 /** Groups of digits joined by hyphens or brackets (03-1234-5678, 03（1234）5678, (555) 123-4567, +81-3-1234-5678). */
 const NUMBER_SHAPE = new RegExp(String.raw`${NUMBER_EDGE_BEFORE}${COUNTRY_CODE}[(（]?\d{1,5}(?:${GROUP_JOIN}\d{1,5}){1,3}${NUMBER_EDGE_AFTER}`, "gu");
+/**
+ * Groups of digits joined by spaces (020 7946 0186, +44 20 7946 0186, 03 1234 5678). The last group has three digits or
+ * more and no such group follows it, so a count after the number ("0186 24 hours") is left out and a run that does not
+ * split one way only ("2026 10 09 020 7946 0186") is not read.
+ */
+const SPACED_SHAPE = new RegExp(
+  String.raw`${NUMBER_EDGE_BEFORE}(?:\+\d{1,3}[ \u00A0])?\d{1,5}(?:[ \u00A0]\d{1,5}){0,2}[ \u00A0]\d{3,5}${NUMBER_EDGE_AFTER}(?![ \u00A0]\d{3})`,
+  "gu",
+);
+/** Spaced digits are a phone number only with a country code, or right after their label: dates, amounts and ids are spaced too. */
+const COUNTRY_CODE_START = /^\+/u;
+const LABEL_TO_NUMBER = /^(?:[\s:：.．]|\uFE0F)*$/u;
 const NOT_DIGIT = /\D/gu;
 const LATIN_START = /^[A-Za-z]/u;
-const LETTER = /\p{L}/u;
+/** A Latin label is a whole word among Latin letters only: 「FAX受付」 has no spaces between words. */
+const LETTER = /\p{Script=Latin}/u;
 /** How far before a number its label may end: 「電話でのお問合せは、」, "by phone, call". */
 const MAX_LABEL_GAP = 15;
 const URL = /\b(?:https?:\/\/|www\.)\S+/giu;
@@ -35,35 +48,72 @@ const lastPlace = (before: string, label: string): number => {
   return whole.at(-1) ?? -1;
 };
 
-/** The group of the label ending nearest before a number on its line, the longest when two end together (携帯電話 over 電話). */
-const labelBefore = (text: string, offset: number, labels: readonly LexiconEntry[]): string | undefined => {
-  const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
-  const before = text.slice(lineStart, offset).toLowerCase();
-  const nearest = labels
+type LabelBefore = { readonly group: string; readonly between: string };
+type LabelHit = { readonly group: string; readonly at: number; readonly end: number };
+
+/** The label ending nearest the end of a line's text, the longest when two end together (携帯電話 over 電話). */
+const nearestLabel = (before: string, labels: readonly LexiconEntry[]): LabelHit | undefined =>
+  labels
     .map((entry) => {
       const at = lastPlace(before, entry.pattern);
       return { group: entry.group ?? entry.pattern, at, end: at + entry.pattern.length };
     })
     .filter((hit) => hit.at >= 0 && before.length - hit.end <= MAX_LABEL_GAP)
     .toSorted((a, b) => b.end - a.end || a.at - b.at)[0];
-  return nearest?.group;
+
+/** A desk's name (窓口, Recall Line) says where a number goes, not what it is: FAX受付窓口 and Fax line name fax numbers. */
+const DESK_GROUP = "desk";
+const DESK_DEFAULT_GROUP = "phone";
+const DIGIT = /\d/u;
+
+/** The kind a label right before a desk's name gives its number, with no digits between; a phone number when there is none. */
+const deskKind = (before: string, desk: LabelHit, labels: readonly LexiconEntry[]): string => {
+  const kinds = labels.filter((entry) => entry.group !== DESK_GROUP);
+  const kind = nearestLabel(before.slice(0, desk.at), kinds);
+  return kind === undefined || DIGIT.test(before.slice(kind.end, desk.at)) ? DESK_DEFAULT_GROUP : kind.group;
 };
 
+/** The label ending nearest before a number on its line, the kind of number it gives, and what lies between. */
+export const labelBefore = (text: string, offset: number, labels: readonly LexiconEntry[]): LabelBefore | undefined => {
+  const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+  const before = text.slice(lineStart, offset).toLowerCase();
+  const nearest = nearestLabel(before, labels);
+  if (nearest === undefined) return undefined;
+  const between = before.slice(nearest.end);
+  if (nearest.group !== DESK_GROUP) return { group: nearest.group, between };
+  return ANY_LETTER.test(between) ? undefined : { group: deskKind(before, nearest, labels), between };
+};
+
+/** A word between a desk's name and the digits says they are something else: Support ticket, 窓口受付番号. */
+const ANY_LETTER = /\p{L}/u;
+const UNCLOSED_OPENING = /^[(（](?!.*[)）])/u;
+
+/** A number as quoted: the bracket the number is put in (窓口（0120-123-456）) is not part of it, an area code's is ((555) 123-4567). */
+const withoutUnclosedBracket = (written: string): string => written.replace(UNCLOSED_OPENING, "");
+
 /** URLs covered with spaces, so neither a path segment (/call/) nor an id in one is read. Offsets stay the same. */
-const withoutUrls = (text: string): string => text.replaceAll(URL, (url) => " ".repeat(url.length));
+export const withoutUrls = (text: string): string => text.replaceAll(URL, (url) => " ".repeat(url.length));
 
 /** The phone numbers of a text that have a label shortly before them on their line; unlabelled digits and URLs are not read. */
 export const labelledPhoneNumbers = (source: string, labels: readonly LexiconEntry[]): PhoneNumber[] => {
   const text = withoutUrls(source);
-  return [...text.matchAll(NUMBER_SHAPE)].flatMap((match) => {
+  const read = (match: RegExpExecArray, spaced: boolean): PhoneNumber[] => {
     const digits = match[0].replaceAll(NOT_DIGIT, "");
     if (digits.length < MIN_DIGITS || digits.length > MAX_DIGITS) return [];
     const label = labelBefore(text, match.index, labels);
-    return label === undefined ? [] : [{ offset: match.index, written: match[0].trim(), digits, label }];
-  });
+    if (label === undefined) return [];
+    if (spaced && !COUNTRY_CODE_START.test(match[0]) && !LABEL_TO_NUMBER.test(label.between)) return [];
+    const matched = match[0].trim();
+    const written = withoutUnclosedBracket(matched);
+    return [{ offset: match.index + matched.length - written.length, written, digits, label: label.group }];
+  };
+  return [
+    ...[...text.matchAll(NUMBER_SHAPE)].flatMap((match) => read(match, false)),
+    ...[...text.matchAll(SPACED_SHAPE)].flatMap((match) => read(match, true)),
+  ].toSorted((a, b) => a.offset - b.offset);
 };
 
-/** Whether two digit strings are the same but for one pair of neighbours swapped. */
+/** Whether two strings (digits, or a reference number's letters and digits) are the same but for one pair of neighbours swapped. */
 export const swapsNeighbours = (a: string, b: string): boolean => {
   if (a.length !== b.length || a === b) return false;
   const differ = [...a].flatMap((digit, index) => (digit === b[index] ? [] : [index]));
@@ -71,24 +121,27 @@ export const swapsNeighbours = (a: string, b: string): boolean => {
   return differ.length === 2 && first !== undefined && second === first + 1 && a[first] === b[second] && a[second] === b[first];
 };
 
-const keyOf = (number: PhoneNumber): string => `${number.label}\u0000${number.digits}`;
+/** A labelled writing compared with the others of its label: where it is and the label's group. */
+type LabelledWriting = { readonly offset: number; readonly label: string };
 
 /**
- * Every writing of a number that is another number of the same label with two neighbours swapped: of the two, the one
- * written fewer times, or the one first written later when both are written as often. Each comes with the other number.
+ * Every writing that is another writing of the same label with two neighbouring characters swapped (characters is what is
+ * compared): of the two, the one written fewer times, or the one first written later when both are written as often. Each
+ * comes with the other writing.
  */
-export const phoneVariants = (numbers: readonly PhoneNumber[]): PhoneVariant[] => {
-  const writings = numbers.reduce((byKey, number) => byKey.set(keyOf(number), [...(byKey.get(keyOf(number)) ?? []), number]), new Map<string, PhoneNumber[]>());
-  const timesOf = (number: PhoneNumber): number => writings.get(keyOf(number))?.length ?? 0;
+export const swappedVariants = <T extends LabelledWriting>(writtenAll: readonly T[], characters: (writing: T) => string): { number: T; other: T }[] => {
+  const keyOf = (writing: T): string => `${writing.label}\u0000${characters(writing)}`;
+  const writings = writtenAll.reduce((byKey, writing) => byKey.set(keyOf(writing), [...(byKey.get(keyOf(writing)) ?? []), writing]), new Map<string, T[]>());
+  const timesOf = (writing: T): number => writings.get(keyOf(writing))?.length ?? 0;
   const firsts = [...writings.values()].flatMap((group) => group.slice(0, 1));
-  const minorityOf = (a: PhoneNumber, b: PhoneNumber): PhoneNumber => {
+  const minorityOf = (a: T, b: T): T => {
     if (timesOf(a) !== timesOf(b)) return timesOf(a) < timesOf(b) ? a : b;
     return a.offset > b.offset ? a : b;
   };
   return firsts
     .flatMap((first, index) =>
       firsts.slice(index + 1).flatMap((second) => {
-        if (first.label !== second.label || !swapsNeighbours(first.digits, second.digits)) return [];
+        if (first.label !== second.label || !swapsNeighbours(characters(first), characters(second))) return [];
         const minority = minorityOf(first, second);
         const other = minority === first ? second : first;
         return (writings.get(keyOf(minority)) ?? []).map((number) => ({ number, other }));
@@ -96,3 +149,6 @@ export const phoneVariants = (numbers: readonly PhoneNumber[]): PhoneVariant[] =
     )
     .toSorted((a, b) => a.number.offset - b.number.offset);
 };
+
+/** Every phone number that is another of the same label with two neighbouring digits swapped (swappedVariants). */
+export const phoneVariants = (numbers: readonly PhoneNumber[]): PhoneVariant[] => swappedVariants(numbers, (number) => number.digits);