chaffjs 0.31.0 → 0.33.0

package/src/facts/whole-counts.ts

@@ -0,0 +1,183 @@
+import type { Span } from "../plugin.ts";
+import { linesOf, type Line } from "../structure/lines.ts";
+import { cellsOf, tablesOf } from "./table-facts.ts";
+import { withoutEdgeMarks } from "./trim-marks.ts";
+
+/**
+ * 文が全体の数として書いた数（「チケットは、合計4枚です」「for 4 tickets in total」）を、その数を数える表の列（枚数、Tickets）と比べる。
+ * 文の数は、全体の印（合計、in total）と、列の項目を数える語（枚、tickets）の両方が付いたときだけ読む。「うち2枚は」「2 of the tickets」
+ * のような一部の数は印が無いので読まない。
+ * 表の側は、合計の行がその列に数を書いていればそれ。書いていなければ、行が別々のものを数える項目（チケット: 一枚は一つの行にだけ
+ * 載る）に限って、行の数の和。手数料の行（発券手数料 3枚）は同じチケットを数え直すので足さない。人は足さない: 同じ人が参加の行と
+ * 交流会の行の両方に載る。
+ */
+export type CountWord = { readonly pattern: string; readonly group: string };
+export type MarkWord = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type CountWords = {
+  /** 数を数える列の見出し（枚数、Tickets）。group が数えるもの。 */
+  readonly columns: readonly CountWord[];
+  /** 数の後ろの、数えるものの語（枚、tickets）。group が列と同じものだけを比べる。 */
+  readonly counters: readonly CountWord[];
+  /** 行が別々のものを数える group。この group だけ、行の数を足して表の全体の数にする。 */
+  readonly separateRows: readonly string[];
+  /** 全体の印。before は数のすぐ前（合計4枚）、after は数えるものの語のすぐ後ろ（4 tickets in total）。 */
+  readonly wholeMarks: readonly MarkWord[];
+  /** 全体でない数の印。before は文のその数より前のどこか（うち、各、up to）、after は数えるものの語のすぐ後ろ（まで、目）。 */
+  readonly notWhole: readonly MarkWord[];
+  /** 同じものを数え直す行の名前の語（手数料、fee）。足さない。 */
+  readonly restating: readonly string[];
+  /** 合計の行の最初の升の語（小計は入れない）。 */
+  readonly totalLabels: readonly string[];
+  /** 表の一部の合計の行の語（小計）。この行や、合計の語で始まる別の名前の行（合計（税込））がある表は、全体の数がどれか決まらない。 */
+  readonly subtotalLabels: readonly string[];
+};
+
+export type CountSentence = Span & { readonly text: string };
+
+/** 表の全体の数。sum: 合計の行でなく、行を足した数。rows: 合計の行のほかの行の名前（S席、Stalls）。 */
+export type TableCount = { readonly group: string; readonly heading: string; readonly count: number; readonly sum: boolean; readonly rows: readonly string[] };
+
+/** written: 文が書いた数の字（4、４）。数えるものの語はその後ろ。 */
+export type WholeCountConflict = Span & { readonly heading: string; readonly written: string; readonly table: TableCount };
+
+const folded = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+const DIGITS = "[0-9０-９][0-9０-９,，]*";
+const LATIN_EDGE = /^[a-z]$/iu;
+
+const numberOf = (written: string): number => Number(written.normalize("NFKC").replaceAll(",", ""));
+
+const escaped = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** 升の字がちょうど「数 + 数えるものの語」（2枚、2 tickets）のときの数。 */
+const cellCount = (text: string, counters: readonly string[]): number | undefined => {
+  const cell = folded(withoutEdgeMarks(text));
+  const counter = counters.map(folded).find((word) => new RegExp(`^${DIGITS} ?${escaped(word)}$`, "u").test(cell));
+  return counter === undefined ? undefined : numberOf(cell.slice(0, cell.length - counter.length).trim());
+};
+
+const countersOf = (group: string, words: CountWords): string[] => words.counters.filter((word) => word.group === group).map((word) => word.pattern);
+
+type Row = { readonly label: string; readonly cell: string };
+
+const isTotal = (label: string, words: CountWords): boolean => words.totalLabels.some((word) => folded(word) === label);
+const looksTotal = (label: string, words: CountWords): boolean =>
+  [...words.totalLabels, ...words.subtotalLabels].some((word) => label.startsWith(folded(word)));
+const restates = (label: string, words: CountWords): boolean => words.restating.some((word) => label.includes(folded(word)));
+const startsPartial = (label: string, words: CountWords): boolean =>
+  words.notWhole.some((word) => word.position === "before" && label.startsWith(folded(word.pattern)));
+
+/** 行を足した数。どの行も数が読めて、一部の行（うち学生）が無いときだけ。 */
+const rowSum = (rows: readonly Row[], counters: readonly string[], words: CountWords): number | undefined => {
+  const items = rows.filter((row) => !isTotal(row.label, words) && !restates(row.label, words));
+  if (items.length === 0 || items.some((row) => startsPartial(row.label, words))) return undefined;
+  const counts = items.map((row) => cellCount(row.cell, counters));
+  return counts.every((count) => count !== undefined) ? counts.reduce<number>((sum, count) => sum + (count ?? 0), 0) : undefined;
+};
+
+const columnCount = (group: string, heading: string, rows: readonly Row[], words: CountWords): TableCount | undefined => {
+  const counters = countersOf(group, words);
+  const [total, ...moreTotals] = rows.filter((row) => isTotal(row.label, words));
+  if (moreTotals.length > 0 || rows.some((row) => !isTotal(row.label, words) && looksTotal(row.label, words))) return undefined;
+  const written = total === undefined ? undefined : cellCount(total.cell, counters);
+  const labels = rows.map((row) => row.label).filter((label) => label !== "" && !isTotal(label, words));
+  if (written !== undefined) return { group, heading, count: written, sum: false, rows: labels };
+  if (total !== undefined && folded(withoutEdgeMarks(total.cell)) !== "") return undefined;
+  const sum = words.separateRows.includes(group) ? rowSum(rows, counters, words) : undefined;
+  return sum === undefined ? undefined : { group, heading, count: sum, sum: true, rows: labels };
+};
+
+const rowsAt = (rows: readonly Line[], column: number): Row[] =>
+  rows.map((row) => {
+    const cells = cellsOf(row);
+    return { label: folded(withoutEdgeMarks(cells[0]?.text ?? "")), cell: cells[column]?.text ?? "" };
+  });
+
+/** 表の、数を数える列ごとの全体の数。 */
+const tableCounts = (source: string, words: CountWords): TableCount[] =>
+  tablesOf(linesOf(source)).flatMap((table) =>
+    cellsOf(table.header).flatMap((cell, column) => {
+      const heading = withoutEdgeMarks(cell.text);
+      const group = words.columns.find((word) => folded(word.pattern) === folded(heading))?.group;
+      if (group === undefined || column === 0) return [];
+      const count = columnCount(group, heading, rowsAt(table.rows, column), words);
+      return count === undefined ? [] : [count];
+    }),
+  );
+
+type Found = Span & { readonly written: string; readonly group: string };
+
+/** 語の端がラテン文字なら、隣がラテン文字でないこと（per と person を分ける）。 */
+const bounded = (text: string, start: number, end: number): boolean => {
+  const before = text.charAt(start - 1);
+  const after = text.charAt(end);
+  return !(LATIN_EDGE.test(text.charAt(start)) && LATIN_EDGE.test(before)) && !(LATIN_EDGE.test(text.charAt(end - 1)) && LATIN_EDGE.test(after));
+};
+
+const hasWord = (text: string, word: string): boolean => {
+  const at = text.indexOf(word);
+  return at !== -1 && (bounded(text, at, at + word.length) || hasWord(text.slice(at + 1), word));
+};
+
+const notWhole = (text: string, counted: Counted, words: CountWords): boolean => {
+  const before = text.slice(0, counted.start);
+  const after = text.slice(counted.after).trimStart();
+  return words.notWhole.some((word) => {
+    const pattern = folded(word.pattern);
+    return word.position === "before" ? hasWord(before, pattern) : after.startsWith(pattern) && bounded(after, 0, pattern.length);
+  });
+};
+
+/** 印 + 数 + 語（合計4枚、a total of 4 tickets）か、数 + 語 + 印（4 tickets in total）。 */
+const wholePattern = (mark: MarkWord, counter: string): RegExp => {
+  const counted = `(?<counted>${DIGITS} ?${escaped(counter)})`;
+  const word = escaped(mark.pattern);
+  return new RegExp(mark.position === "before" ? `${word} ?${counted}` : `${counted} ${word}`, "gdu");
+};
+
+/** 数と数えるものの語の位置。after: 全体の印も含めた、読んだ所の終わり（4 tickets in total の後ろ）。 */
+type Counted = Span & { readonly after: number };
+
+const matchesOf = (text: string, mark: MarkWord, counter: CountWord): Counted[] =>
+  [...text.matchAll(wholePattern({ ...mark, pattern: folded(mark.pattern) }, folded(counter.pattern)))].flatMap((match) => {
+    const [start, end] = match.indices?.groups?.["counted"] ?? [0, 0];
+    const after = match.index + match[0].length;
+    if (!bounded(text, match.index, after) || /[0-9.]/u.test(text.charAt(start - 1))) return [];
+    return [{ start, end, after }];
+  });
+
+const foundIn = (sentence: CountSentence, words: CountWords): Found[] => {
+  const text = sentence.text.normalize("NFKC").toLowerCase();
+  if (text.length !== sentence.text.length) return [];
+  return words.counters.flatMap((counter) =>
+    words.wholeMarks.flatMap((mark) =>
+      matchesOf(text, mark, counter).flatMap((counted): Found[] => {
+        if (notWhole(text, counted, words)) return [];
+        const { start, end } = counted;
+        const written = sentence.text.slice(start, end);
+        const counterAt = end - counter.pattern.length;
+        return [{ start: sentence.start + start, end: sentence.start + end, written: written.slice(0, counterAt - start).trim(), group: counter.group }];
+      }),
+    ),
+  );
+};
+
+const unique = (found: readonly Found[]): Found[] => found.filter((one, index) => found.findIndex((other) => other.start === one.start) === index);
+
+/**
+ * 文が全体として書いた数と、表のその列の全体の数が違う所。数える列が文書に二つ以上ある項目、その表の行の名前を書いた文
+ * （S席は合計2枚）は比べない。
+ */
+export const wholeCountConflicts = (source: string, sentences: readonly CountSentence[], words: CountWords): WholeCountConflict[] => {
+  const tables = tableCounts(source, words);
+  return sentences.flatMap((sentence) => {
+    const text = folded(sentence.text);
+    return unique(foundIn(sentence, words)).flatMap((found) => {
+      const [table, ...others] = tables.filter((count) => count.group === found.group);
+      if (table === undefined || others.length > 0 || numberOf(found.written) === table.count) return [];
+      if (table.rows.some((label) => hasWord(text, label))) return [];
+      return [{ start: found.start, end: found.end, heading: table.heading, written: found.written, table }];
+    });
+  });
+};

package/src/fix-plan/text.ts

@@ -109,7 +109,7 @@ export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
     spots: "見つけた箇所",
     at: (line) => `${String(line)} 行目`,
     notRunHeading: "動かなかったルール",
-    notExperimental: "試験中のルールは動かしていません。AIっぽさのルールの多くは試験中です。--experimental を付けると見ます。",
+    notExperimental: "試験中のルールは動かしていません。--experimental を付けると見ます。",
     checksHeading: "直したあとの確かめ",
     saveAs: (path) => `書き直したものを ${path} に保存して、次を実行します。`,
     checksNote:
@@ -174,7 +174,7 @@ export const FIX_PLAN_TEXT: Texts<FixPlanText> = {
     spots: "Spots",
     at: (line) => `line ${String(line)}`,
     notRunHeading: "Rules that did not run",
-    notExperimental: "The experimental rules did not run, and most rules for generated text are experimental. Add --experimental to run them.",
+    notExperimental: "The experimental rules did not run. Add --experimental to run them.",
     checksHeading: "Check after rewriting",
     saveAs: (path) => `Save the rewrite as ${path} and run:`,
     checksNote:

package/src/lexicon-genres.ts

@@ -0,0 +1,11 @@
+import type { Lexicon } from "./plugin.ts";
+
+/** A genre is in a target when it is the target or one of its genres (legal/contract is in legal). */
+const isIn = (genre: string, target: string): boolean => genre === target || genre.startsWith(`${target}/`);
+
+/**
+ * The entries of a word list that hold for the document's genre: an entry without genres holds everywhere, one with genres only
+ * in those genres or groups. With no genre known, only the entries for every genre.
+ */
+export const entriesForGenre = (lexicon: Lexicon, genre: string | undefined): Lexicon =>
+  lexicon.filter((entry) => entry.genres === undefined || (genre !== undefined && entry.genres.some((target) => isIn(genre, target))));

package/src/name-char-reading.ts

@@ -0,0 +1,24 @@
+/** 解析器が読みを持たない名前の字（健汰 の 汰）から、その字の名前での読みへ。語彙表 name-char-reading が言う。 */
+export type CharReadings = ReadonlyMap<string, string>;
+
+export const NO_CHAR_READINGS: CharReadings = new Map();
+
+type ReadToken = { readonly surface: string; readonly reading?: string | undefined };
+
+const isRead = (reading: string | undefined): reading is string => reading !== undefined && reading !== "";
+
+/**
+ * 語の読み。解析器の読みがあればそれ。無ければ、語の字がどれも語彙表にあるときだけ字の読みをつなぐ。一字でも読めなければ無い
+ * （読めない字を飛ばすと、別の名前を同じ読みと言ってしまう）。
+ */
+export const tokenReadingOf = (token: ReadToken, chars: CharReadings): string | undefined => {
+  if (isRead(token.reading)) return token.reading;
+  const readings = [...token.surface].map((letter) => chars.get(letter));
+  return readings.length > 0 && readings.every(isRead) ? readings.join("") : undefined;
+};
+
+/** 語を並べた名前の読み。読めない語が一つでもあれば無い。 */
+export const readingOfWords = (words: readonly ReadToken[], chars: CharReadings): string | undefined => {
+  const readings = words.map((token) => tokenReadingOf(token, chars));
+  return words.length > 0 && readings.every(isRead) ? readings.join("") : undefined;
+};

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