chaffjs 0.31.0 → 0.32.0

package/src/name-line-block.ts

@@ -0,0 +1,40 @@
+import type { Token } from "./plugin.ts";
+
+/**
+ * 1 行に 1 つずつ書いた短い行の並び（署名の 名前／役職／学校名、住所の行）。Markdown では一つの段落、一つの文になり、名前の
+ * 語の続きが次の行の頭の語（Mr Daniel Whitfield⏎Head of Year 9 の Head）まで伸びる。行が文の終わりの記号で終わらず、どの行も
+ * 短く、小文字で始まらず、行の数も少ないときだけ、行ごとに名前を読む。折り返したふつうの文は最後の行が文の終わりの記号で
+ * 終わるか、行が長いか、小文字で始まる行を持つ。
+ */
+
+/** 行ごとに読む行の語の数の上限。折り返した文の行はこれより長い。 */
+const MAX_LINE_WORDS = 6;
+/** 行ごとに読む文の行の数の上限。署名や住所は収まる。長い一覧の一語の地名は、分けるとふつうの語と一字違いに見える。 */
+const MAX_BLOCK_LINES = 8;
+const SENTENCE_END = /[.!?。！？:;：；]["'”’)）]*$/u;
+const LOWERCASE_START = /^\p{Ll}/u;
+const NEWLINE = /\r?\n/u;
+const WORD = /\S+/gu;
+
+const isItemLine = (line: string): boolean =>
+  line !== "" && !SENTENCE_END.test(line) && !LOWERCASE_START.test(line) && (line.match(WORD) ?? []).length <= MAX_LINE_WORDS;
+
+/** 文が、短い行を 1 行に 1 つずつ並べたものか。 */
+export const isLineBlock = (text: string): boolean => {
+  const lines = text
+    .trim()
+    .split(NEWLINE)
+    .map((line) => line.trim());
+  return lines.length >= 2 && lines.length <= MAX_BLOCK_LINES && lines.every(isItemLine);
+};
+
+/** 語を、あいだに改行を挟むところで分けた並び。text は start の位置から始まる文字列で、語の範囲を覆う。 */
+export const tokensByLine = (tokens: readonly Token[], text: string, start = 0): Token[][] =>
+  tokens.reduce<Token[][]>((lines, token, index) => {
+    const previous = tokens[index - 1];
+    const breaks = previous !== undefined && NEWLINE.test(text.slice(previous.span.end - start, token.span.start - start));
+    const current = lines.at(-1);
+    if (current === undefined || breaks) lines.push([token]);
+    else current.push(token);
+    return lines;
+  }, []);

package/src/name-lookalike-chars.ts

@@ -0,0 +1,53 @@
+import type { NameMention } from "./name-variants.ts";
+
+// 人の名前で、形が似ていて取り違えやすい別の字（太 と 大、未 と 末）。どの字が似ているかは語彙表 name-lookalike-char が組（group）
+// ごとに言う。読みが違うので、読みの同じ名前の見方では比べられない。
+
+/** 字から、その組の代表の字へ。 */
+export type LookalikeChars = ReadonlyMap<string, string>;
+
+export const NO_LOOKALIKES: LookalikeChars = new Map();
+
+const isSameGroup = (left: string, right: string, lookalikes: LookalikeChars): boolean => {
+  const group = lookalikes.get(left);
+  return group !== undefined && group === lookalikes.get(right);
+};
+
+/** 字数が同じで、同じ位置の一字だけが違い、その二字が同じ組にある（山本 健太 と 山本 健大）。 */
+export const isLookalikeApart = (left: string, right: string, lookalikes: LookalikeChars): boolean => {
+  const [leftChars, rightChars] = [[...left], [...right]];
+  if (leftChars.length !== rightChars.length) return false;
+  const differ = leftChars.flatMap((char, index) => (char === rightChars[index] ? [] : [index]));
+  const [at] = differ;
+  return differ.length === 1 && at !== undefined && isSameGroup(leftChars[at] ?? "", rightChars[at] ?? "", lookalikes);
+};
+
+/** 書き方ごとの最初の現れと数。姓と名のそろった（二語以上の）人の名前だけ。 */
+const fullPersonNamesOf = (mentions: readonly NameMention[]): Map<string, { readonly first: NameMention; readonly count: number }> => {
+  const names = new Map<string, { readonly first: NameMention; readonly count: number }>();
+  mentions
+    .filter((mention) => mention.person === true && mention.words.length >= 2)
+    .forEach((mention) => {
+      const known = names.get(mention.surface);
+      names.set(mention.surface, { first: known?.first ?? mention, count: (known?.count ?? 0) + 1 });
+    });
+  return names;
+};
+
+export type LookalikeSlip = { readonly mention: NameMention; readonly usual: string };
+
+/**
+ * 姓と名のそろった人の名前が、形の似た別の字一字だけで違う所（山本 健太 と 山本 健大）。兄弟（健太 と 健大）もありうるので、
+ * 多いほうが二度以上、少ないほうが一度だけのときに限る。相手が二つあれば多いほう、同数なら先に書いたほう。
+ */
+export const lookalikeSlipsIn = (mentions: readonly NameMention[], lookalikes: LookalikeChars): LookalikeSlip[] => {
+  const names = [...fullPersonNamesOf(mentions).values()];
+  return names
+    .filter((name) => name.count === 1)
+    .flatMap((slip) => {
+      const usual = names
+        .filter((other) => other.count >= 2 && isLookalikeApart(slip.first.surface, other.first.surface, lookalikes))
+        .toSorted((left, right) => right.count - left.count || left.first.offset - right.first.offset)[0];
+      return usual === undefined ? [] : [{ mention: slip.first, usual: usual.first.surface }];
+    });
+};

package/src/name-neighbours.ts

@@ -0,0 +1,58 @@
+import type { NameMention } from "./name-variants.ts";
+
+// 解析器が名前の一語を名前と読まなかった所を、隣の語と合わせて名前の現れにする（to Rachel Whitford の Rachel）。
+
+/** 隣の語を探す範囲（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;
+  });
+};

package/src/name-ordinary-word.ts

@@ -0,0 +1,68 @@
+import type { Token } from "./plugin.ts";
+import type { NameMention } from "./name-variants.ts";
+import { escapeRegExp } from "./orthography.ts";
+
+// 名前と読んだ一語が、ふつうの語でもある所（文頭や題の Green、国の名の Greek）。二つのふつうの語（Green と Greek、Course と
+// Curse）は一字違いでも別の語で、同じ名前の書き損じではない。
+
+/** 解析器が名前と読んだ語が、小文字で書けばふつうの語か（adapter の OrdinaryWord=Yes）。 */
+export const isOrdinaryToken = (token: Token): boolean => token.features?.["OrdinaryWord"] === "Yes";
+
+/** 文書が word を敬称か肩書きの後ろに書くか（Mr. Green、Senator Marsh）。書けば、その語を人の名前に使っている。 */
+export const isTitledIn = (source: string, titles: readonly string[], word: string): boolean =>
+  titles.some((title) => new RegExp(`(?<![\\p{L}\\p{N}])${escapeRegExp(title)}\\s+${escapeRegExp(word)}(?![\\p{L}\\p{N}])`, "u").test(source));
+
+/** 人を書く欄の行の頭の、Markdown の印（箇条書き、引用、見出し、太字）。 */
+const LINE_MARKS = /^[\s>*#+-]*(?:\*\*|__)?/u;
+/** 欄の後ろの名前: 大文字で始まる一語から三語（Ellen J. Marsh）。行の終わりか、「,」か括弧の前まで。 */
+const FIELD_NAME = /^(?:\*\*|__)?[ \t]*(\p{Lu}[\p{L}'’.-]*(?:[ \t]+\p{Lu}[\p{L}'’.-]*){0,2})[ \t]*(?:[,(（].*)?$/u;
+
+/** 行が人を書く欄（Customer: Ellen Marsh）なら、欄の後ろの名前の最後の語（姓）。欄の語は、行の頭の「:」の前の語まるごとで照らす。 */
+const labelledSurname = (line: string, labels: ReadonlySet<string>): string | undefined => {
+  const colon = line.search(/[:：]/u);
+  if (colon < 0) return undefined;
+  const label = line
+    .slice(0, colon)
+    .replace(LINE_MARKS, "")
+    .replace(/(?:\*\*|__)$/u, "")
+    .trim()
+    .toLowerCase();
+  if (!labels.has(label)) return undefined;
+  return FIELD_NAME.exec(line.slice(colon + 1))?.[1]
+    ?.split(/[ \t]+/u)
+    .at(-1)
+    ?.replace(/\.$/u, "");
+};
+
+/**
+ * 文書が word を、人を書く欄の名前の最後の語（姓）に書くか（Customer: Ellen Marsh、Client: Marsh）。書けば、その語を人の名前に
+ * 使っている。欄の後ろの最後の語だけを見るので、Name: Green Valley Farm の Green は名前に使った語にならない。
+ */
+const labelledSurnamesIn = (source: string, labels: readonly string[]): ReadonlySet<string> => {
+  const wanted = new Set(labels.map((label) => label.toLowerCase()));
+  return new Set(wanted.size === 0 ? [] : source.split(/\r?\n/u).flatMap((line) => labelledSurname(line, wanted) ?? []));
+};
+
+export const isLabelledIn = (source: string, labels: readonly string[], word: string): boolean => labelledSurnamesIn(source, labels).has(word);
+
+/**
+ * 一語の名前の現れのうち、その語がふつうの語でもあり（ordinaryStarts は、そういう語の頭の位置）、文書のどこでも敬称や肩書きの
+ * 後ろにも、人を書く欄（labels）の姓にも書かないものに ordinary を付ける。同じ形の現れが一つでもそうでなければ、その形のどの現れにも付けない。
+ */
+export const withOrdinaryWords = (
+  mentions: readonly NameMention[],
+  ordinaryStarts: ReadonlySet<number>,
+  source: string,
+  titles: readonly string[],
+  labels: readonly string[] = [],
+): NameMention[] => {
+  const isOrdinary = (mention: NameMention): boolean => {
+    const [word] = mention.words;
+    return mention.words.length === 1 && word !== undefined && ordinaryStarts.has(mention.offset);
+  };
+  const named = new Set(mentions.filter((mention) => !isOrdinary(mention)).map((mention) => mention.surface));
+  const ordinarySurfaces = new Set(mentions.filter((mention) => !named.has(mention.surface) && isOrdinary(mention)).map((mention) => mention.surface));
+  const labelled = labelledSurnamesIn(source, labels);
+  const neverNamed = new Set([...ordinarySurfaces].filter((surface) => !isTitledIn(source, titles, surface) && !labelled.has(surface)));
+  return mentions.map((mention) => (neverNamed.has(mention.surface) ? { ...mention, ordinary: true } : mention));
+};

package/src/name-person.ts

@@ -0,0 +1,31 @@
+import type { Token } from "./plugin.ts";
+
+// 固有名詞の続きが人の名前と読めるか。解析器の人名の印か、後ろの敬称で決める。
+
+/** 人名と読む解析器の印（UD の NameType: 姓 Sur、名 Giv、どちらとも言えない人名 Prs）。 */
+const PERSON_TYPES: ReadonlySet<string> = new Set(["Sur", "Giv", "Prs"]);
+
+/** 行の中の空き（半角・全角の空白、タブ）。名前と敬称のあいだに置く（森下 千尋 様）。改行は越えない。 */
+const INLINE_BLANK = /^[\t\p{Zs}]+$/u;
+
+/** 名前の後ろの語。行の中の空きを一つ越える（森下 千尋 様 の 様）。 */
+const wordAfter = (tokens: readonly Token[], last: Token): Token | undefined => {
+  const at = tokens.indexOf(last) + 1;
+  const next = tokens[at];
+  return next !== undefined && INLINE_BLANK.test(next.surface) ? tokens[at + 1] : next;
+};
+
+/** 語の後ろに敬称（様、さん、氏）が付くか。行の中の空きを挟んでもよい。 */
+export const isFollowedBySuffix = (token: Token, tokens: readonly Token[], suffixes: readonly string[]): boolean => {
+  const next = wordAfter(tokens, token);
+  return next !== undefined && suffixes.includes(next.surface);
+};
+
+/**
+ * 人の名前か。解析器が人名と読む語を含むか、後ろに敬称が付く。解析器は名を地名と読むことがある（千尋 を Geo）ので、敬称は空白を
+ * 挟んでも見る。
+ */
+export const isPersonRun = (run: readonly Token[], tokens: readonly Token[], suffixes: readonly string[]): boolean => {
+  const last = run.at(-1);
+  return run.some((token) => PERSON_TYPES.has(token.features?.["NameType"] ?? "")) || (last !== undefined && isFollowedBySuffix(last, tokens, suffixes));
+};

package/src/name-separator.ts

@@ -0,0 +1,48 @@
+import type { Boundary } from "./orthography.ts";
+import type { Span, Token } from "./plugin.ts";
+
+/** 名前を空白で並べた行（署名・連絡先・所属の行）に出る品詞。助詞・動詞・助動詞・連体詞が一つでもあれば、その行は文。 */
+const NAME_LINE_POS = new Set(["NOUN", "PROPN", "NUM", "PUNCT", "SYM"]);
+
+/** units は部署・拠点・役目の名前を閉じる語（語彙表 organization-unit）、forms は会社の形の語（語彙表 company-form）。 */
+export type OrganizationWords = { readonly units: ReadonlySet<string>; readonly forms: readonly string[] };
+
+/** at を含む行の範囲。 */
+const lineAround = (text: string, at: number): Span => {
+  const end = text.indexOf("\n", at);
+  return { start: text.lastIndexOf("\n", at - 1) + 1, end: end === -1 ? text.length : end };
+};
+
+/** 語を区切る空白。 */
+const WORD_BREAKS = [" ", "\t", "\n", "\r", "\u00a0", "\u3000"];
+
+/** end の前の、空白で区切った語の頭の位置。 */
+const wordStart = (text: string, end: number): number => Math.max(...WORD_BREAKS.map((space) => text.slice(0, end).lastIndexOf(space))) + 1;
+
+/** start からの、空白で区切った語の終わりの位置。 */
+const wordEnd = (text: string, start: number): number =>
+  Math.min(...WORD_BREAKS.map((space) => text.indexOf(space, start)).map((at) => (at === -1 ? text.length : at)));
+
+/** span の中の語。tokens は文書全体の座標で、base は text の先頭の位置。 */
+const tokensIn = (tokens: readonly Token[], span: Span, base: number): Token[] =>
+  tokens.filter((token) => token.span.start >= base + span.start && token.span.end <= base + span.end);
+
+/** 行の語がどれも名前の語か。品詞の無い行は名前の並びと読まない。 */
+const isNameLine = (lineTokens: readonly Token[]): boolean => lineTokens.length > 0 && lineTokens.every((token) => NAME_LINE_POS.has(token.pos));
+
+/** 空白で区切った語が、組織の名前か。最後の語が部署・拠点・役目の語（経営企画部、IR担当）か、会社の形の語で始まるか終わる（株式会社ABC）。 */
+const isOrganizationName = (word: string, wordTokens: readonly Token[], words: OrganizationWords): boolean =>
+  words.units.has(wordTokens.at(-1)?.surface ?? "") || words.forms.some((form) => word.length > form.length && (word.startsWith(form) || word.endsWith(form)));
+
+/**
+ * 「株式会社あおば電子 経営企画部 IR担当」「東京本社 PR室」のように、名前だけを空白で並べた行で、空白の両側がどちらも組織の名前のときの空白。
+ * 名前と名前の区切りで、英字の前後の空け方ではない。文の中の空白（この IT システムは）や、組織の名前でない語のあいだ（生成AI 活用事例、Patch リリース）は区切りと読まない。
+ * boundary は空けた英字の境目（text[offset] が空白）。tokens は文書全体の座標で、base は text の先頭の位置。
+ */
+export const isNameSeparator = (text: string, boundary: Boundary, tokens: readonly Token[] | undefined, base: number, words: OrganizationWords): boolean => {
+  if (tokens === undefined || boundary.kind !== "letter" || !boundary.spaced) return false;
+  const before = { start: wordStart(text, boundary.offset), end: boundary.offset };
+  const after = { start: boundary.offset + 1, end: wordEnd(text, boundary.offset + 1) };
+  const isName = (span: Span): boolean => isOrganizationName(text.slice(span.start, span.end), tokensIn(tokens, span, base), words);
+  return isName(before) && isName(after) && isNameLine(tokensIn(tokens, lineAround(text, boundary.offset), base));
+};

package/src/name-variants.ts

@@ -3,6 +3,9 @@ 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）、読みが同じ（山田太郎 と 山田太朗）、
@@ -10,7 +13,9 @@ import { foldedKeysOf, NO_SPELLING, type SpellingInput } from "./name-spelling-c
 
 /**
  * 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;
@@ -19,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" | "kana" | "reading" | "near" | "surname" | "character";
+  readonly kind: "spelling" | "kana" | "reading" | "near" | "surname" | "character" | "field";
 };
 
 /** 字体の違う同じ字（斎・斉・齋）。字から、その組の代表の字へ。 */
@@ -79,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);
@@ -99,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;
@@ -218,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,
@@ -235,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[]>();
@@ -266,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 }];
     }),
   );
 
@@ -335,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("");
@@ -387,19 +342,20 @@ 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,
   );
 
 /**
@@ -418,7 +374,7 @@ export const nameVariants = (mentions: readonly NameMention[], chars: VariantCha
       "kana",
     ),
     ...variantsIn(
-      groupBy(tallies, (tally) => (tally.first.reading === undefined ? [] : [tally.first.reading])),
+      groupBy(tallies, (tally) => tally.readings),
       "reading",
       oneWordApart,
     ),

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);
+};