chaffjs 0.34.0 → 0.36.0

package/src/link-title.ts

@@ -0,0 +1,38 @@
+import type { Span } from "./plugin.ts";
+import { linkTextOf } from "./link-text.ts";
+
+/**
+ * 外のページの題名を引いたリンクの文字。行の頭に置いたリンク（- [達成基準 2.4.4: リンクの目的 (コンテキスト内)](https://…)、
+ * 参考: [ロードバランサーにタグを付ける](https://…)）は、行き先のページの題名をそのまま写したもので、書き手が言い換えられない。
+ * リンクの後ろは行の終わりか、コロンに続く説明（[題名](https://…): 説明）だけを許す。
+ * 文の中のリンク（詳しくは[こちら](https://…)をご覧ください）は書き手の言葉で、文書の中や手元のファイルへのリンク（[README](./README.md)）は題名ではない。
+ */
+
+const EXTERNAL = /^<?https?:\/\//iu;
+const TEXT_END = "](";
+/** リンクの前に書いてよいもの: 行頭の空白と箇条書きの印、その後ろにコロンで終わる短い見出し語（参考:、出典：、See also:）。 */
+const BULLET = /^[ \t]*(?:(?:[-*+]|\d{1,3}[.)])[ \t]+)?/u;
+const LABEL = /^(?:[^\n:：。、.,[\]]{1,15}[:：][ \t]*)?$/u;
+/** リンクの後ろに書いてよいもの: 行末までの空白と句読点か、説明を始めるコロン。 */
+const LINE_TAIL = /^(?:[ \t.,;。、]*(?:\n|$)|[ \t]*[:：])/u;
+
+/** リンクの文字の範囲。[文字](行き先) の形で、行き先が外のページのものだけ。位置は source の上。 */
+const externalTextOf = (source: string, link: Span): Span | undefined => {
+  const written = source.slice(link.start, link.end);
+  const text = linkTextOf(written);
+  if (text === undefined) return undefined;
+  const destination = written.slice(1 + text.length + TEXT_END.length);
+  return EXTERNAL.test(destination) ? { start: link.start + 1, end: link.start + 1 + text.length } : undefined;
+};
+
+const headsItsLine = (source: string, link: Span): boolean => {
+  const lineStart = source.lastIndexOf("\n", link.start - 1) + 1;
+  return LABEL.test(source.slice(lineStart, link.start).replace(BULLET, "")) && LINE_TAIL.test(source.slice(link.end));
+};
+
+/** 外のページの題名を引いたリンクの、文字の範囲（角括弧は含まない）。位置は source の上。links は doc.links。 */
+export const externalLinkTitleSpans = (source: string, links: readonly Span[]): Span[] =>
+  links.flatMap((link) => {
+    const text = externalTextOf(source, link);
+    return text !== undefined && headsItsLine(source, link) ? [text] : [];
+  });

package/src/list-item-paragraphs.ts

@@ -0,0 +1,22 @@
+import type { Span } from "./plugin.ts";
+
+/** 段落の中の文。listItem は、行頭の印で始まる箇条書きの項目を始める文（adapter が入れる）。 */
+type ItemSentence = { readonly span: Span; readonly listItem?: true };
+
+/**
+ * 空行を挟まずに行頭の印（①、・、(1)）で項目を並べた段落を、項目ごとの段落に割る。
+ * 項目の後ろに続く印の無い行は、その項目の続き。割らないと、項目の並び全体が文の多すぎる 1 つの段落に読まれる。
+ *
+ * sentences は段落の中の文（並び順）。項目が無ければ paragraph 1 つ。
+ */
+export const listItemParagraphs = (paragraph: Span, sentences: readonly ItemSentence[]): Span[] => {
+  const firsts = sentences.flatMap((sentence, index) => (index === 0 || sentence.listItem === true ? [index] : []));
+  if (firsts.length <= 1) return [paragraph];
+  return firsts.map((first, index) => {
+    const next = firsts[index + 1];
+    return {
+      start: index === 0 ? paragraph.start : (sentences[first]?.span.start ?? paragraph.start),
+      end: next === undefined ? paragraph.end : (sentences[next - 1]?.span.end ?? paragraph.end),
+    };
+  });
+};

package/src/literal-quote.ts

@@ -0,0 +1,55 @@
+// A quotation that holds a string to be typed as it stands: an e-mail subject (件名に「応募（総務課）」と記載), a file name
+// (「【様式】（氏名）」とファイル名を変更), a title (titled “Rates (2026)”). Its brackets are the string's own; the writer cannot
+// take them out. Which words around a quotation say so come from the language's literal-quote-cue lexicon. Pure.
+import { QUOTATION_MARKS, quotedSpans } from "./quoted-span.ts";
+import type { LexiconEntry, Span } from "./plugin.ts";
+
+export type LiteralCues = { readonly before: readonly string[]; readonly after: readonly string[] };
+
+/** The cues of the lexicon: `position: before` stands in front of the quotation (件名に「…」), the rest right after it (「…」と記載). */
+export const literalCues = (entries: readonly LexiconEntry[]): LiteralCues => ({
+  before: entries.filter((entry) => entry.position === "before").map((entry) => entry.pattern.toLowerCase()),
+  after: entries.filter((entry) => entry.position !== "before").map((entry) => entry.pattern.toLowerCase()),
+});
+
+/** Spaces allowed between a cue and its quotation; farther than this the cue is not the quotation's. */
+const GAP = 8;
+const LATIN_LETTER = /[A-Za-z]/u;
+
+/** A cue that begins or ends with a Latin letter is a word: named does not match the end of unnamed. */
+const standsBefore = (window: string, cue: string): boolean =>
+  window.endsWith(cue) && !(LATIN_LETTER.test(cue.at(0) ?? "") && LATIN_LETTER.test(window.at(-cue.length - 1) ?? ""));
+
+const standsAfter = (window: string, cue: string): boolean =>
+  window.startsWith(cue) && !(LATIN_LETTER.test(cue.at(-1) ?? "") && LATIN_LETTER.test(window.at(cue.length) ?? ""));
+
+/** How far from a quotation to read: the longest cue, one letter more to tell a word from part of one, and the gap. */
+const reachOf = (cues: LiteralCues): number => Math.max(0, ...[...cues.before, ...cues.after].map((cue) => cue.length)) + 1 + GAP;
+
+/** Only the few characters next to the quotation are read, so a sentence of many quotations stays linear. */
+const isLiteral = (text: string, quoted: Span, cues: LiteralCues, reach: number): boolean => {
+  const opener = quoted.start - 1;
+  const closerEnd = quoted.end + 1;
+  const before = text
+    .slice(Math.max(0, opener - reach), opener)
+    .trimEnd()
+    .toLowerCase();
+  const after = text
+    .slice(closerEnd, closerEnd + reach)
+    .trimStart()
+    .toLowerCase();
+  return cues.before.some((cue) => standsBefore(before, cue)) || cues.after.some((cue) => standsAfter(after, cue));
+};
+
+/** The insides of the quotations the cues mark as a literal string, without the quotation marks. Positions count from 0 in `text`. */
+export const literalQuoteSpans = (text: string, cues: LiteralCues): Span[] => {
+  const reach = reachOf(cues);
+  return quotedSpans(text, QUOTATION_MARKS).filter((quoted) => isLiteral(text, quoted, cues, reach));
+};
+
+/** The text with each literal quotation's inside blanked to spaces, so a measure of the sentence's own brackets skips it. */
+export const withoutLiteralQuotes = (text: string, cues: LiteralCues): string => {
+  const units = text.split("");
+  literalQuoteSpans(text, cues).forEach((span) => units.fill(" ", span.start, span.end));
+  return units.join("");
+};

package/src/nado-closed-list.ts

@@ -38,6 +38,8 @@ const CLAUSE_POS: ReadonlySet<string> = new Set(["AUX", "VERB"]);
 /** A verb form that modifies a noun inside a list (a driving licence, used cars). */
 const NOUN_MODIFYING_FORMS: ReadonlySet<string> = new Set(["Ger", "Part"]);
 const LIST_SEPARATOR = /[,、]/u;
+/** The parts of speech a list item is made of. */
+const NAME_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
 
 /** Where a word occurs in a text; a Latin word only as whole words, any case. */
 const placesOf = (text: string, word: string): number[] => {
@@ -59,12 +61,53 @@ const standsAsOpenWord = (tokens: readonly Token[], at: number, open: string): b
   return token !== undefined && open.toLowerCase().startsWith(token.surface.toLowerCase()) && token.features?.NounType !== CLASS_NOUN;
 };
 
-const limitRightAfter = (rest: string, words: ClosedListWords): string | undefined => {
-  const after = rest.slice(BETWEEN_OPEN_AND_LIMIT.exec(rest)?.[0].length ?? 0);
-  if (words.notLimits.some((phrase) => startsWithWord(after, phrase))) return undefined;
+const BRACKET = /[(（)）]/gu;
+const CLOSE_BRACKET = /[)）]/u;
+
+/** Where the bracket still open at offset opened, or -1 when none is. */
+const openBracketBefore = (text: string, at: number): number => {
+  const stillOpen = [...text.slice(0, at).matchAll(BRACKET)].reduce<number[]>(
+    (open, bracket) => (CLOSE_BRACKET.test(bracket[0]) ? open.slice(0, -1) : [...open, bracket.index]),
+    [],
+  );
+  return stillOpen.at(-1) ?? -1;
+};
+
+/**
+ * The open word ends an aside on the word before the bracket, and the limit stands outside it (従業員（エンジニア、デザイナー等）のみ):
+ * the limit governs that word, and the list only gives examples of it.
+ */
+const closesAsideBeforeLimit = (text: string, at: number, skipped: string): boolean => {
+  if (!CLOSE_BRACKET.test(skipped)) return false;
+  const bracket = openBracketBefore(text, at);
+  return LETTER.test(text.slice(0, Math.max(bracket, 0)).trimEnd().at(-1) ?? "");
+};
+
+const limitRightAfter = (text: string, at: number, open: string, words: ClosedListWords): string | undefined => {
+  const rest = text.slice(at + open.length);
+  const skipped = BETWEEN_OPEN_AND_LIMIT.exec(rest)?.[0] ?? "";
+  const after = rest.slice(skipped.length);
+  if (words.notLimits.some((phrase) => startsWithWord(after, phrase)) || closesAsideBeforeLimit(text, at, skipped)) return undefined;
   return longestFirst(words.limitsAfter).find((limit) => startsWithWord(after, limit));
 };
 
+const isItemToken = (token: Token | undefined): token is Token => token !== undefined && NAME_POS.has(token.pos);
+
+/** Where the run of nouns written right before end starts (監査 in 監査指示 before 等), or end when no noun ends there. */
+const itemStart = (tokens: readonly Token[], end: number): number => {
+  const last = tokens.find((token) => token.span.end === end);
+  return isItemToken(last) ? itemStart(tokens, last.span.start) : end;
+};
+
+/** The nouns written right before the open word (指示 in 指示等), by the tokens; empty when none are. */
+const itemBefore = (text: string, tokens: readonly Token[], at: number): string => text.slice(itemStart(tokens, at), at);
+
+/** The same list written earlier in the sentence (個別の指示等が … 当該指示等に限り): the open word refers back to it, and leaves nothing new open. */
+const repeatsEarlierList = (text: string, tokens: readonly Token[], at: number, open: string): boolean => {
+  const item = itemBefore(text, tokens, at);
+  return item !== "" && placesOf(text.slice(0, at - item.length), open).some((earlier) => itemBefore(text, tokens, earlier) === item);
+};
+
 const longestFirst = (words: readonly string[]): string[] => [...words].sort((a, b) => b.length - a.length);
 
 const insideNotLimit = (text: string, at: number, notLimits: readonly string[]): boolean =>
@@ -97,9 +140,9 @@ const limitBefore = (text: string, tokens: readonly Token[], at: number, words:
 export const openWordsOnClosedLists = (text: string, tokens: readonly Token[], words: ClosedListWords): OpenOnClosed[] =>
   words.open
     .flatMap((open) => placesOf(text, open).map((at) => ({ open, at })))
-    .filter(({ open, at }) => standsAsOpenWord(tokens, at, open))
+    .filter(({ open, at }) => standsAsOpenWord(tokens, at, open) && !repeatsEarlierList(text, tokens, at, open))
     .flatMap(({ open, at }) => {
-      const limit = limitRightAfter(text.slice(at + open.length), words) ?? limitBefore(text, tokens, at, words);
+      const limit = limitRightAfter(text, at, open, words) ?? limitBefore(text, tokens, at, words);
       return limit === undefined ? [] : [{ offset: at, open, limit }];
     })
     .sort((a, b) => a.offset - b.offset || b.open.length - a.open.length)

package/src/name-end-letter.ts

@@ -31,6 +31,15 @@ export type WordUse = { readonly ordinary: ReadonlySet<string>; readonly common:
 
 export const NO_WORD_USE: WordUse = { ordinary: new Set(), common: new Set() };
 
+/**
+ * 終わりの重なった字の一つの抜け（Licensee と License、Bennett と Bennet）で、どちらかを文書が小文字か普通名詞で書く（license）。
+ * 語の終わりの抜けと同じく、語の形の違い（License と、その許諾を受ける Licensee）。
+ */
+export const isWordFormOf = (left: string, right: string, use: WordUse): boolean => {
+  const [longer, shorter] = left.length > right.length ? [left, right] : [right, left];
+  return longer.slice(0, -1) === shorter && (use.common.has(longer) || use.common.has(shorter));
+};
+
 /**
  * 名前の語（words、小文字）の at の語を usual と書いた名前があるとき、その違いを書き損じと見るか。違う語が最後の語（姓）なら、
  * 終わりの一字の抜けか足しか、四字以上の一字違い（oneLetterApart）で、前の語がどれも文書の中で普通名詞として書かない語（Rachel、Mr）

package/src/name-given-before.ts

@@ -0,0 +1,40 @@
+import type { Token } from "./plugin.ts";
+
+// 姓のすぐ前に書いた名（Jeffrey D. Walker の Jeffrey）。名の違う二人（Jeffrey D. Walker と Christopher J. Waller）は、姓が一字違いでも
+// 別の人で、書き損じではない。
+
+const GIVEN_NAME = /^\p{Lu}\p{Ll}+$/u;
+const INITIAL = /^\p{Lu}$/u;
+const NEWLINE = /\n/u;
+
+const isInitial = (token: Token | undefined): boolean => INITIAL.test(token?.surface ?? "");
+
+/** 名と名前のあいだの頭文字（D.、D）を飛ばした、名の語の添字。 */
+const givenIndexOf = (tokens: readonly Token[], index: number): number => {
+  if (tokens[index - 1]?.surface === "." && isInitial(tokens[index - 2])) return index - 3;
+  return isInitial(tokens[index - 1]) ? index - 2 : index - 1;
+};
+
+/** 名前の書き方ごとの、すぐ前に書いた名のすべて。 */
+export type GivenNames = ReadonlyMap<string, readonly string[]>;
+
+export const givenNamesBySurface = (mentions: readonly { readonly surface: string; readonly givenName?: string | undefined }[]): GivenNames =>
+  mentions.reduce((names, { surface, givenName }) => {
+    const known = names.get(surface) ?? [];
+    return givenName === undefined || known.includes(givenName) ? names : names.set(surface, [...known, givenName]);
+  }, new Map<string, string[]>());
+
+/** どちらの書き方にも名前のすぐ前の名があり、一つも同じでない（Jeffrey D. Walker と Christopher J. Waller）。別の人。 */
+export const areOtherPeople = (left: readonly string[] = [], right: readonly string[] = []): boolean =>
+  left.length > 0 && right.length > 0 && !left.some((name) => right.includes(name));
+
+/**
+ * tokens[index] で始まる名前のすぐ前の名。解析器が固有名詞と読んだ、大文字一字に小文字の続く語で、あいだに頭文字一つを挟んでよい。
+ * 行を越えては読まない（一行に一人ずつ並べた出席者の名簿）。
+ */
+export const givenNameBefore = (tokens: readonly Token[], index: number, source: string): string | undefined => {
+  const name = tokens[index];
+  const given = tokens[givenIndexOf(tokens, index)];
+  if (name === undefined || given === undefined || given.pos !== "PROPN" || !GIVEN_NAME.test(given.surface)) return undefined;
+  return NEWLINE.test(source.slice(given.span.end, name.span.start)) ? undefined : given.surface;
+};

package/src/name-separator.ts

@@ -49,13 +49,89 @@ const QUANTITY_LEAD_POS = new Set(["ADJ", "ADV", "ADP", "AUX", "VERB", "SCONJ",
 /** 値の組の最も短い長さ。1 字の語（計 5件）は量の前置き。 */
 const MIN_PART_LENGTH = 2;
 
+/** 組を囲む字（括弧・表の升目の線）。組が囲みの中で読点で並ぶこともある（電話 03-1234-5678、内線 3839）。 */
+const LAST_ENCLOSURE_OPEN = /[（(｜|][^（(｜|]*$/u;
+const ENCLOSURE_CLOSE = /[）)｜|]/u;
+
+/** 組と組を分ける読点。数の桁の区切り（1,000）のコンマは除く。 */
+const PAIR_COMMA = /[、，]|(?<!\d),|,(?!\d)/gu;
+
+/** 行の頭の字下げと箇条書きの印（「- 」「1. 」）。 */
+const PAIR_LEAD = /^[ \t\u3000]*(?:(?:[-*+]|\d{1,3}[.．)）])[ \t\u3000]+)?/u;
+
+/** 項目名: 空白・数字・区切りの字を含まない短い語。値: 数字で始まり、空白も区切りも文の終わりも含まない一続き（桁の区切りのコンマは含む）。 */
+const PAIR_LABEL = /^[^\s\d、，,（）()｜|：:。！？]{2,12}$/u;
+const PAIR_VALUE = /^\d(?:[^\s、，,（）()｜|。！？]|(?<=\d),(?=\d))*$/u;
+
 /**
- * 「所属：経済学部 経済学科 1年」「物件：メゾンかえで 203号室」「振込先：みなと銀行 普通 1234567」のように、項目名とコロンの後ろに
- * 値の組を空白で並べた行で、組と、数で始まる次の組のあいだの空白。値の区切りで、日本語と数字のあいだの空け方ではない。
- * boundary は空けた数字の前の境目（text[offset] が空白）。tokens は文書全体の座標で、base は text の先頭の位置。
+ * 値の後ろに括弧で添えた説明（10万円 (税込 11万円)）の、開く字と閉じる字。囲みは閉じ括弧の手前で終わるので、最後の開き括弧から後ろが説明。
+ * 入れ子の括弧（(税込 (内訳))）は読まない。
  */
-export const isFieldSeparator = (text: string, boundary: Boundary, tokens: readonly Token[] | undefined, base: number): boolean => {
-  if (tokens === undefined || boundary.kind !== "before-digit" || !boundary.spaced) return false;
+const ASIDE_PAIRS: ReadonlyMap<string, string> = new Map([
+  ["(", ")"],
+  ["（", "）"],
+]);
+
+/** 説明の括弧の後ろに残ってよいもの: 空白と強調の印。語が続けば（で募集します）文の中の値。 */
+const LINE_REST = /^[\s*_]*$/u;
+
+/**
+ * 組の値。値の後ろに同じ形の括弧で閉じた説明を添えて行が終わるなら、説明を除いた値。閉じていないか、
+ * 説明の後ろに語が続けば undefined。fromEnclosureEnd は囲みの終わり（閉じ括弧か行末）から行末まで。
+ */
+const valueOf = (written: string, fromEnclosureEnd: string): string | undefined => {
+  const aside = Math.max(...[...ASIDE_PAIRS.keys()].map((open) => written.lastIndexOf(open)));
+  if (aside < 0) return written;
+  const closed = fromEnclosureEnd[0] === ASIDE_PAIRS.get(written[aside] ?? "");
+  return closed && LINE_REST.test(fromEnclosureEnd.slice(1)) ? written.slice(0, aside).trimEnd() : undefined;
+};
+
+/** 項目名に出る品詞。名詞だけで、助詞・副詞（およそ）・接頭の語（約）を含めば、量の前置きか文。 */
+const PAIR_LABEL_POS = new Set(["NOUN", "PROPN"]);
+
+const SPACE_RUN = /^[ \t\u3000]*/u;
+
+/** at を含む囲み: 括弧か表の升目の線の内側、無ければ行（字下げと箇条書きの印の後ろ）。 */
+const enclosureAround = (text: string, line: Span, at: number): Span => {
+  const open = LAST_ENCLOSURE_OPEN.exec(text.slice(line.start, at));
+  const start = open === null ? line.start + (PAIR_LEAD.exec(text.slice(line.start, line.end))?.[0].length ?? 0) : line.start + open.index + 1;
+  const close = text.slice(at, line.end).search(ENCLOSURE_CLOSE);
+  return { start, end: close === -1 ? line.end : at + close };
+};
+
+/** 囲みの中で at を含む組。読点で区切り、前後の空白を除く。 */
+const pairAround = (text: string, enclosure: Span, at: number): Span => {
+  const commas = [...text.slice(enclosure.start, enclosure.end).matchAll(PAIR_COMMA)].map((match) => enclosure.start + match.index);
+  const rawStart = (commas.filter((comma) => comma < at).at(-1) ?? enclosure.start - 1) + 1;
+  const rawEnd = commas.find((comma) => comma > at) ?? enclosure.end;
+  const start = rawStart + (SPACE_RUN.exec(text.slice(rawStart, at))?.[0].length ?? 0);
+  return { start, end: rawStart + text.slice(rawStart, rawEnd).trimEnd().length };
+};
+
+/**
+ * 「最高速度 40km/h」「（内線 3839～40）」「- 定員 30名」のように、短い項目名と、それが名指す値を空白一つで並べただけの組の、名と値のあいだの空白。
+ * 組は行・括弧の中・表の升目にそれだけで書くか、読点で並べる。項目の区切りで、文の中の空け方ではない。
+ * 囲みの中に助詞や動詞がある（定員 30名で行います、参加者 30名、来場者50名を見込みます）、値の後ろに語が続く（内線 3839 まで）、
+ * 項目名が 1 字（約 30名）か名詞でない語を含む組は、文の中の空白として数える。
+ */
+const isLabelledValue = (text: string, boundary: Boundary, tokens: readonly Token[], base: number): boolean => {
+  const line = lineAround(text, boundary.offset);
+  const enclosure = enclosureAround(text, line, boundary.offset);
+  const pair = pairAround(text, enclosure, boundary.offset);
+  const label = { start: pair.start, end: boundary.offset };
+  const value = valueOf(text.slice(boundary.offset + 1, pair.end), text.slice(enclosure.end, line.end));
+  if (!PAIR_LABEL.test(text.slice(label.start, label.end)) || value === undefined || !PAIR_VALUE.test(value)) return false;
+  if (SENTENCE_END.test(text.slice(enclosure.start, enclosure.end))) return false;
+  const labelTokens = tokensIn(tokens, label, base);
+  return (
+    labelTokens.length > 0 &&
+    labelTokens.every((token) => PAIR_LABEL_POS.has(token.pos)) &&
+    !tokensIn(tokens, enclosure, base).some((token) => CLAUSE_POS.has(token.pos))
+  );
+};
+
+/** 項目名とコロンの後ろに値の組を並べた行の、組と、数で始まる次の組のあいだの空白か。 */
+const isColonFieldPart = (text: string, boundary: Boundary, tokens: readonly Token[], base: number): boolean => {
   const line = lineAround(text, boundary.offset);
   const label = FIELD_LABEL.exec(text.slice(line.start, line.end));
   if (label === null || SENTENCE_END.test(text.slice(line.start, line.end))) return false;
@@ -66,6 +142,16 @@ export const isFieldSeparator = (text: string, boundary: Boundary, tokens: reado
   return boundary.offset - partStart >= MIN_PART_LENGTH && partEnd !== undefined && !QUANTITY_LEAD_POS.has(partEnd.pos);
 };
 
+/**
+ * 項目と値を分ける空白。「所属：経済学部 経済学科 1年」「振込先：みなと銀行 普通 1234567」のように項目名とコロンの後ろに値の組を並べた行の組と組のあいだか、
+ * 「最高速度 40km/h」「（内線 3839）」のように短い項目名と値を並べただけの組の、名と値のあいだ。値の区切りで、日本語と数字のあいだの空け方ではない。
+ * boundary は空けた数字の前の境目（text[offset] が空白）。tokens は文書全体の座標で、base は text の先頭の位置。
+ */
+export const isFieldSeparator = (text: string, boundary: Boundary, tokens: readonly Token[] | undefined, base: number): boolean => {
+  if (tokens === undefined || boundary.kind !== "before-digit" || !boundary.spaced) return false;
+  return isColonFieldPart(text, boundary, tokens, base) || isLabelledValue(text, boundary, tokens, base);
+};
+
 /**
  * 「株式会社あおば電子 経営企画部 IR担当」「東京本社 PR室」のように、名前だけを空白で並べた行で、空白の両側がどちらも組織の名前のときの空白。
  * 名前と名前の区切りで、英字の前後の空け方ではない。文の中の空白（この IT システムは）や、組織の名前でない語のあいだ（生成AI 活用事例、Patch リリース）は区切りと読まない。

package/src/name-variants.ts

@@ -2,7 +2,8 @@ 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 { isEndWordSlip, NO_WORD_USE, type WordUse } from "./name-end-letter.ts";
+import { isEndWordSlip, isWordFormOf, NO_WORD_USE, type WordUse } from "./name-end-letter.ts";
+import { areOtherPeople, givenNamesBySurface, type GivenNames } from "./name-given-before.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";
@@ -17,7 +18,8 @@ import { heavierFirst, outweighs, type NameWeight } from "./name-weight.ts";
  * 人名と読むか、敬称が付く）。cue は前後の語から見た名前らしさ（name-cue.ts）。ordinary は、ふつうの語でもある一語の名前で、
  * 文書がその形をどこでも名前に使わないもの（name-ordinary-word.ts）。labelled は、人を書く欄（氏名：、Contractor:）に書いた名前
  * （person-field.ts）。givenNameReading は、空白を挟んだ姓と名の名を、名の中での字の読みで読み直した読み（name-char-reading.ts の
- * givenNameReadingOf）。解析器が名を別の読みに切ったとき（建太 を タテフトシ）のもう一通りの読み。
+ * givenNameReadingOf）。解析器が名を別の読みに切ったとき（建太 を タテフトシ）のもう一通りの読み。givenName は、名前のすぐ前に
+ * 書いた名（Jeffrey D. Walker の Jeffrey、name-given-before.ts）。
  */
 export type NameMention = {
   readonly surface: string;
@@ -29,6 +31,7 @@ export type NameMention = {
   readonly ordinary?: boolean;
   readonly labelled?: boolean;
   readonly givenNameReading?: string | undefined;
+  readonly givenName?: string | undefined;
 };
 
 export type NameVariant = {
@@ -310,11 +313,13 @@ const differingWords = (left: Tally, right: Tally): readonly [string, string] |
 };
 
 /** 一語だけが一字違いで、相手のほうが重い（outweighs）。どちらもふつうの語（Green と Greek）なら、別の二つの語。 */
-const isSlipOf = (tally: Tally, other: Tally): boolean => {
-  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 isSlipOf =
+  (use: WordUse): Alike =>
+  (tally, other) => {
+    if (!outweighs(other, tally) || (tally.first.ordinary === true && other.first.ordinary === true)) return false;
+    const words = differingWords(tally, other);
+    return words !== undefined && isNearWord(...words) && !isWordFormOf(...words, use);
+  };
 
 /**
  * 二語以上の名前の一語だけが、終わりの一字の抜けか足し（Rachel Whitmore と Rachel Whitmor）か、最後の語（姓）が四字でも一字違い
@@ -330,9 +335,14 @@ const isEndSlipOf =
     return !use.ordinary.has(word) && !use.ordinary.has(usual) && isEndWordSlip(words, at, usual, use, isOneLetterApart);
   };
 
-const nearVariants = (tallies: readonly Tally[], use: WordUse): NameVariant[] => {
-  const isEndSlip = isEndSlipOf(use);
-  return variantsIn(groupBy(tallies, maskedKeys), "near", (tally, other) => isSlipOf(tally, other) || isEndSlip(tally, other), true);
+const nearVariants = (tallies: readonly Tally[], use: WordUse, givenNames: GivenNames): NameVariant[] => {
+  const [isSlip, isEndSlip] = [isSlipOf(use), isEndSlipOf(use)];
+  return variantsIn(
+    groupBy(tallies, maskedKeys),
+    "near",
+    (tally, other) => !areOtherPeople(givenNames.get(tally.surface), givenNames.get(other.surface)) && (isSlip(tally, other) || isEndSlip(tally, other)),
+    true,
+  );
 };
 
 /**
@@ -419,7 +429,7 @@ export const nameVariants = (
       "reading",
       oneWordApart,
     ),
-    ...nearVariants(tallies, use),
+    ...nearVariants(tallies, use, givenNamesBySurface(mentions)),
     ...surnameVariants(tallies),
     ...characterVariants(tallies, chars),
     ...personReadingVariants(tallies),

package/src/name-word-order.ts

@@ -41,12 +41,25 @@ const CAPITALISED = "\\p{Lu}[\\p{L}'’-]*";
 
 const FIRST_WORD = new RegExp(`^${CAPITALISED}[ \\t]+`, "u");
 
+/** 小さな語の並び。冠詞（the）は前置詞（of、for）のすぐ後ろにだけ立つ（Bank of the West）。 */
+const joinerPattern = (joiners: readonly string[], articles: readonly string[]): string => {
+  if (joiners.length === 0) return "";
+  const article = articles.length === 0 ? "" : `(?:(?:${articles.map(escapeRegExp).join("|")})[ \\t]+)?`;
+  return `(?:(?:${joiners.map(escapeRegExp).join("|")})[ \\t]+${article})*`;
+};
+
 /**
- * 大文字で始まる語が二つ以上並んだ所（Foundations of Statistics）。語のあいだに小さな語（of）を挟んでよい。文の頭の語は、
- * 文の頭だから大文字のことがあるので、外す（Take Data Lab の Take）。
+ * 大文字で始まる語が二つ以上並んだ所（Foundations of Statistics）。語のあいだに小さな語（of、of the）を挟んでよい。冠詞だけを
+ * 挟んだ二つの語（this Agreement the Stockholders）は、句の切れ目をまたぐので一つの名前にしない。文の頭の語は、文の頭だから
+ * 大文字のことがあるので、外す（Take Data Lab の Take）。
  */
-export const titleCaseSpans = (text: string, joiners: readonly string[], isSentenceStart: (offset: number) => boolean = () => false): NameSpan[] => {
-  const joiner = joiners.length === 0 ? "" : `(?:(?:${joiners.map(escapeRegExp).join("|")})[ \\t]+)*`;
+export const titleCaseSpans = (
+  text: string,
+  joiners: readonly string[],
+  isSentenceStart: (offset: number) => boolean = () => false,
+  articles: readonly string[] = [],
+): NameSpan[] => {
+  const joiner = joinerPattern(joiners, articles);
   const pattern = new RegExp(`(?<![\\p{L}'’-])${CAPITALISED}(?:[ \\t]+${joiner}${CAPITALISED})+`, "gu");
   return [...text.matchAll(pattern)].map((found) => {
     const start = found.index ?? 0;
@@ -112,16 +125,33 @@ export const orderNamesOf = (text: string, spans: readonly NameSpan[], words: re
     .toSorted((left, right) => left.offset - right.offset);
 };
 
-type Tally = { readonly first: OrderName; readonly count: number; readonly anchored: boolean };
-
-const talliesOf = (names: readonly OrderName[]): Tally[] => [
-  ...names
-    .reduce<Map<string, Tally>>((tallies, name) => {
-      const known = tallies.get(name.surface);
-      return tallies.set(name.surface, { first: known?.first ?? name, count: (known?.count ?? 0) + 1, anchored: (known?.anchored ?? false) || name.anchored });
-    }, new Map())
-    .values(),
-];
+type Tally = { readonly first: OrderName; readonly count: number; readonly anchored: boolean; readonly offsets: readonly number[] };
+
+/** 書き方ごとの、現れの位置のすべて。 */
+const offsetsBySurface = (names: readonly OrderName[]): Map<string, number[]> =>
+  names.reduce((offsets, name) => {
+    const known = offsets.get(name.surface);
+    if (known === undefined) offsets.set(name.surface, [name.offset]);
+    else known.push(name.offset);
+    return offsets;
+  }, new Map<string, number[]>());
+
+const talliesOf = (names: readonly OrderName[]): Tally[] => {
+  const offsets = offsetsBySurface(names);
+  return [
+    ...names
+      .reduce<Map<string, Tally>>((tallies, name) => {
+        const known = tallies.get(name.surface);
+        return tallies.set(name.surface, {
+          first: known?.first ?? name,
+          count: (known?.count ?? 0) + 1,
+          anchored: (known?.anchored ?? false) || name.anchored,
+          offsets: offsets.get(name.surface) ?? [],
+        });
+      }, new Map())
+      .values(),
+  ];
+};
 
 /** 多いほうが前。同じ数なら先に書いたほうが前。 */
 const byUse = (left: Tally, right: Tally): number => right.count - left.count || left.first.offset - right.first.offset;
@@ -135,15 +165,30 @@ export const isReordered = (left: OrderName, right: OrderName): boolean =>
   !left.surface.includes(right.surface) &&
   !right.surface.includes(left.surface);
 
+/** 文の番号。同じ文の二つの書き方を見分けるため。 */
+export type SentenceOf = (offset: number) => number;
+
+/** 二つの書き方を、どこかで同じ文に並べて書いたか（“Request Additional Time” or “Additional Time Requests”）。 */
+const sharesSentence = (left: Tally, right: Tally, sentenceOf: SentenceOf): boolean => {
+  const sentences = new Set(left.offsets.map(sentenceOf));
+  return right.offsets.some((offset) => sentences.has(sentenceOf(offset)));
+};
+
 /**
  * 多く使った書き方と同じ語を違う順に並べた名前。少ないほうを一つずつ指す。二つのどちらかが名前として書いた所（anchored）に
- * あるときだけ。surfaces は表の升まるごとの書き方で、その書き方の名前も anchored と見る。
+ * あるときだけ。surfaces は表の升まるごとの書き方で、その書き方の名前も anchored と見る。同じ文に並べて書いた二つは、書き手が
+ * 言い分けた別の名前（画面の二つの項目、定義する語とその中身）なので比べない。
  */
-export const wordOrderVariants = (names: readonly OrderName[], surfaces: ReadonlySet<string> = new Set()): OrderVariant[] => {
+export const wordOrderVariants = (
+  names: readonly OrderName[],
+  surfaces: ReadonlySet<string> = new Set(),
+  sentenceOf: SentenceOf = (offset) => offset,
+): OrderVariant[] => {
   const tallies = talliesOf(names).toSorted(byUse);
   const anchored = (tally: Tally): boolean => tally.anchored || surfaces.has(tally.first.surface);
+  const apart = (left: Tally, right: Tally): boolean => !sharesSentence(left, right, sentenceOf);
   return tallies.flatMap((tally, index) => {
-    const usual = tallies.slice(0, index).find((other) => (anchored(other) || anchored(tally)) && isReordered(other.first, tally.first));
+    const usual = tallies.slice(0, index).find((other) => (anchored(other) || anchored(tally)) && isReordered(other.first, tally.first) && apart(other, tally));
     return usual === undefined ? [] : [{ name: tally.first, usual: usual.first.surface }];
   });
 };

package/src/nominal-stem.ts

@@ -0,0 +1,93 @@
+import type { Token } from "./plugin.ts";
+import { kanjiSkeleton } from "./kana-spelling.ts";
+
+/** The last kana of a verb's dictionary form, and the kana its stem form (連用形) ends in instead: 払い込む → 払い込み. */
+const STEM_ENDING: Readonly<Record<string, string>> = { う: "い", く: "き", ぐ: "ぎ", す: "し", つ: "ち", ぬ: "に", ぶ: "び", む: "み", る: "り" };
+
+/**
+ * Whether a verb is written in its stem form (払い込み from 払い込む, 申出 from 申出る). Other forms that differ from the
+ * dictionary form (ください from 下さる, 払い込ん before で) are not: they are never a noun.
+ */
+export const isStemForm = (surface: string, lemma: string): boolean => {
+  const last = lemma.slice(-1);
+  const stem = lemma.slice(0, -1);
+  if (stem === "") return false;
+  return surface === stem + (STEM_ENDING[last] ?? "\u0000") || (last === "る" && surface === stem);
+};
+
+/** What carries a verb on (払い込み、払い込んで, 払い込みます, 払い込みやすい): after these the stem form is still the verb. */
+const VERB_GOES_ON = new Set(["AUX", "SCONJ", "VERB", "ADJ"]);
+const CLAUSE_COMMA = new Set(["、", "，", ","]);
+/** The verbs that make a verb of a noun written right before them (申出する, 申出できる): the stem form there is the noun. */
+const LIGHT_VERBS = new Set(["する", "できる", "出来る"]);
+
+const carriesTheVerb = (next: Token): boolean => VERB_GOES_ON.has(next.pos) && !(next.pos === "VERB" && LIGHT_VERBS.has(next.lemma ?? ""));
+
+/** A word's kanji and reading, one key for 申出 and 申し出 (申出|モウシデ); undefined for a word with no kanji or no reading. */
+export const nounKeyOf = (token: Token): string | undefined => {
+  const kanji = kanjiSkeleton(token.surface);
+  return kanji === "" || token.reading === undefined ? undefined : `${kanji}|${token.reading}`;
+};
+
+const isAmong = (token: Token, nouns: ReadonlySet<string>): boolean => {
+  const key = nounKeyOf(token);
+  return key !== undefined && nouns.has(key);
+};
+
+/**
+ * A free noun after the stem form may begin the next clause (疾病にかかり療養のために), so the stem form stays a verb; a suffix
+ * (払込み等), a noun the caller lists as one (受取り前), or any noun after a word the document writes as a noun elsewhere
+ * (申し出期限 beside 申出の撤回) may not.
+ */
+const verbGoesOn = (token: Token, next: Token, suffixes: ReadonlySet<string>, nouns: ReadonlySet<string>): boolean =>
+  carriesTheVerb(next) ||
+  CLAUSE_COMMA.has(next.surface) ||
+  (next.pos === "NOUN" && next.features?.["Bound"] !== "Yes" && !suffixes.has(next.surface) && !isAmong(token, nouns));
+
+/**
+ * A verb's stem form that the verb does not go on from (払込みの期日, 申出により, 株式の買取り）): a noun the analyser read as the
+ * verb, returned as the noun it is, spelled as written. Official Japanese spells the noun and the verb apart (払込み, 払い込む),
+ * so the two are not one word in two spellings; the noun is compared with nouns. Any other token is returned as it is.
+ * nouns holds the document's nouns (documentNounKeys).
+ */
+export const asNounWhereNominal = (
+  token: Token,
+  next: Token | undefined,
+  suffixes: ReadonlySet<string> = new Set(),
+  nouns: ReadonlySet<string> = new Set(),
+): Token => {
+  if (token.pos !== "VERB" || token.lemma === undefined || !isStemForm(token.surface, token.lemma)) return token;
+  return next !== undefined && verbGoesOn(token, next, suffixes, nouns) ? token : { ...token, pos: "NOUN", lemma: token.surface };
+};
+
+/** A particle that ties what is before it to a noun after it (の, での, に関する, における): what follows it is a noun. */
+const ATTRIBUTIVE_PARTICLE = /[のる]$/u;
+
+const isStemAfterParticle = (token: Token, previous: Token | undefined, next: Token | undefined): boolean =>
+  previous?.pos === "ADP" &&
+  ATTRIBUTIVE_PARTICLE.test(previous.surface) &&
+  CLAUSE_COMMA.has(next?.surface ?? "") &&
+  token.pos === "VERB" &&
+  token.lemma !== undefined &&
+  isStemForm(token.surface, token.lemma);
+
+/**
+ * The sentence with a stem form between a particle that ties it to a noun and a comma (地域の取組み、) read as the noun it is,
+ * spelled as written: before a comma the stem form is otherwise the verb (課題に取り組み、成果を上げた).
+ */
+export const withNounsAfterParticles = (tokens: readonly Token[]): readonly Token[] =>
+  tokens.map((token, at) => (isStemAfterParticle(token, tokens[at - 1], tokens[at + 1]) ? { ...token, pos: "NOUN", lemma: token.surface } : token));
+
+/**
+ * The keys (nounKeyOf) of the nouns a document writes, stem forms the verb does not go on from included (申出 before の): what
+ * tells asNounWhereNominal that a stem form before a noun makes a compound (申し出期限) rather than ends a clause (疾病にかかり療養).
+ */
+export const documentNounKeys = (sentences: readonly (readonly Token[])[], suffixes: ReadonlySet<string> = new Set()): Set<string> =>
+  new Set(
+    sentences.map(withNounsAfterParticles).flatMap((tokens) =>
+      tokens.flatMap((token, at) => {
+        const key = asNounWhereNominal(token, tokens[at + 1], suffixes).pos === "NOUN" ? nounKeyOf(token) : undefined;
+        return key === undefined ? [] : [key];
+      }),
+    ),
+  );