chaffjs 0.34.0 → 0.35.0

package/src/grade-api.ts

@@ -11,10 +11,13 @@ import { withStyle } from "./config/style.ts";
 import { withExtensions } from "./extension/load.ts";
 import { GENRES } from "./genre.ts";
 import { gradeItem, type GradeSetup } from "./grade/grade-item.ts";
-import { readItem } from "./grade/item.ts";
+import { expectProblems } from "./grade/expect-read.ts";
+import type { GradeExpect } from "./grade/expect.ts";
+import { readItem, type GradeItem } from "./grade/item.ts";
 import type { GradeResult } from "./grade/result.ts";
 import { parseRubric, type Rubric } from "./grade/rubric.ts";
 import { gradeSetup } from "./grade/setup.ts";
+import { taskNamesOf } from "./grade/task-rubric.ts";
 import { GRADE_TEXT } from "./grade/text.ts";
 import { compareVariantGroups, type VariantComparison } from "./grade/variants.ts";
 import { variantGroupsOf, type VariantInput } from "./grade/variants-input.ts";
@@ -36,6 +39,7 @@ export type {
   SupportedFact,
 } from "./grade/result.ts";
 export type { OutputSize } from "./grade/rates.ts";
+export type { GradeExpect } from "./grade/expect.ts";
 export type { AiLevelCounts, GradeAiScore } from "./grade/ai-score.ts";
 export { toScorer, type ChaffScore } from "./grade/scorer.ts";
 export type { Disagreement, VariantColumn, VariantComparison, VariantRates } from "./grade/variants.ts";
@@ -56,6 +60,10 @@ export type GradeOptions = {
   readonly genre?: string;
   /** The prompt, model or setting that produced the output, kept on the result for compareVariants(). */
   readonly variant?: string;
+  /** The rubric task to grade under: one of chaff.yaml's `grade.tasks`. The top-level rubric when left out. */
+  readonly task?: string;
+  /** Facts the output must state (`facts`) and must not (`absent`), each one fact as `chaff compare` reads it. */
+  readonly expect?: Partial<GradeExpect>;
   /** Run the experimental rules too, as --experimental does. chaff.yaml's `experimental` when left out. */
   readonly experimental?: boolean;
   /** chaff.yaml's path, or settings already read. Without it chaff's defaults apply and no file is read. */
@@ -125,36 +133,32 @@ const rubricOf = (config: Config): Rubric | undefined => {
  */
 const setups = new WeakMap<Config, Map<string, Promise<GradeSetup>>>();
 
-const setupFor = (config: Config, experimental: boolean, languages: readonly string[]): Promise<GradeSetup> => {
+const setupFor = (config: Config, rubric: Rubric | undefined, experimental: boolean, languages: readonly string[]): Promise<GradeSetup> => {
   const run = { experimental, genre: undefined };
   const own = setups.get(config) ?? new Map<string, Promise<GradeSetup>>();
   setups.set(config, own);
-  const key = `${String(experimental)}\n${languages.join(",")}`;
+  // The rubric is in the key: an item's task was checked against this rubric, so the setup must grade by the same one.
+  const key = `${String(experimental)}\n${languages.join(",")}\n${JSON.stringify(rubric) ?? ""}`;
   const known = own.get(key);
   if (known !== undefined) return known;
-  const made = remember(own, key, gradeSetup(config, run, languages, rubricOf(config)));
+  const made = remember(own, key, gradeSetup(config, run, languages, rubric));
   // A language package that failed to load may be installed before the next call: do not keep the failure.
   made.catch(() => own.delete(key));
   return made;
 };
 
 /** The setup, or GradeInputError when a language package cannot be loaded, as `chaff grade` ends with 2 then. */
-const loadedSetup = async (config: Config, experimental: boolean, languages: readonly string[]): Promise<GradeSetup> => {
+const loadedSetup = async (config: Config, rubric: Rubric | undefined, experimental: boolean, languages: readonly string[]): Promise<GradeSetup> => {
   try {
-    return await setupFor(config, experimental, languages);
+    return await setupFor(config, rubric, experimental, languages);
   } catch (error) {
     if (error instanceof GradeInputError) throw error;
     throw new GradeInputError([TEXT.cannotLoad(error instanceof Error ? error.message : String(error))]);
   }
 };
 
-/**
- * Grades one output (spec §29.6): its findings and rates, its facts against `reference`, its `citations` against
- * `sources`, and pass or fail by chaff.yaml's `grade:` or the default. Reads a file only when `config` is a path, and
- * never writes one. Throws GradeInputError for an input or a chaff.yaml `chaff grade` would refuse with exit 2.
- */
-export const grade = async (output: string, options: GradeOptions = {}): Promise<GradeResult> => {
-  const config = await configOf(options.config);
+/** The options read as one line of `chaff grade`'s input, refused as that line would be. `tasks`: those the rubric defines. */
+const itemOf = (output: string, options: GradeOptions, tasks: readonly string[]): GradeItem => {
   const raw = {
     id: options.id ?? "output",
     output,
@@ -165,11 +169,29 @@ export const grade = async (output: string, options: GradeOptions = {}): Promise
     language: options.language,
     genre: options.genre,
     variant: options.variant,
+    task: options.task,
+    expect: options.expect,
   };
-  const read = readItem(raw, { isLanguage: (language) => packageFor(language) !== undefined, genres: GENRES });
+  const read = readItem(raw, { isLanguage: (language) => packageFor(language) !== undefined, genres: GENRES, tasks });
   if ("problem" in read) throw new GradeInputError([TEXT.problem(read.problem)]);
-  const languages = read.item.language === undefined ? [] : [read.item.language];
-  return gradeItem(read.item, await loadedSetup(config, options.experimental ?? config.experimental, languages));
+  return read.item;
+};
+
+/**
+ * Grades one output (spec §29.6): its findings and rates, its facts against `reference`, its `citations` against
+ * `sources`, its `expect` facts, and pass or fail by chaff.yaml's `grade:` (its `task`'s rubric when named) or the
+ * default. Reads a file only when `config` is a path, and never writes one. Throws GradeInputError for an input or a
+ * chaff.yaml `chaff grade` would refuse with exit 2, an unknown `task` or an `expect` entry that is not one fact among them.
+ */
+export const grade = async (output: string, options: GradeOptions = {}): Promise<GradeResult> => {
+  const config = await configOf(options.config);
+  const rubric = rubricOf(config);
+  const item = itemOf(output, options, taskNamesOf(rubric));
+  const languages = item.language === undefined ? [] : [item.language];
+  const setup = await loadedSetup(config, rubric, options.experimental ?? config.experimental, languages);
+  const problems = await expectProblems(item, 0, setup);
+  if (problems.length > 0) throw new GradeInputError(problems.map((problem) => TEXT.problem(problem)));
+  return gradeItem(item, setup);
 };
 
 /**

package/src/heading-numbering.ts

@@ -41,16 +41,31 @@ const labelPattern = (label: NumberLabel): RegExp =>
 /** 見出しの頭の強調の印と空白。「**1. 概要**」も「1. 概要」と読む。 */
 const LEAD = /^[\s*_]+/u;
 
-/** 見出しの言葉から、番号の書き方を読む。番号を持つ語（第1章）を先に、字だけの形（1.）を後に見る。 */
-export const numberingStyleOf = (heading: string, labels: readonly NumberLabel[]): string => {
+type NumberMark = { readonly style: string; readonly mark: string };
+
+const markOf = (heading: string, labels: readonly NumberLabel[]): NumberMark => {
   const text = heading.replace(LEAD, "");
   const label = labels.find((candidate) => labelPattern(candidate).test(text));
-  if (label !== undefined) return `label:${label.word.toLowerCase()}`;
-  return SHAPES.find(([, shape]) => shape.test(text))?.[0] ?? UNNUMBERED;
+  if (label !== undefined) return { style: `label:${label.word.toLowerCase()}`, mark: labelPattern(label).exec(text)?.[0] ?? "" };
+  const shape = SHAPES.find(([, pattern]) => pattern.test(text));
+  return shape === undefined ? { style: UNNUMBERED, mark: "" } : { style: shape[0], mark: shape[1].exec(text)?.[0] ?? "" };
+};
+
+/** 見出しの言葉から、番号の書き方を読む。番号を持つ語（第1章）を先に、字だけの形（1.）を後に見る。 */
+export const numberingStyleOf = (heading: string, labels: readonly NumberLabel[]): string => markOf(heading, labels).style;
+
+/** 番号の中の数の一つ一つ（「7.1」の 7 と 1、「Chapter II」の II）。番号は印の最後に来るので、語の頭の大文字（Chapter の C）は最後にならない。 */
+const NUMBER_TOKEN = /[0-9０-９]+|[A-ZⅠ-Ⅻ①-⑳一二三四五六七八九十百]+/gu;
+const FIRST_NUMBERS: ReadonlySet<string> = new Set(["1", "１", "I", "Ⅰ", "A", "①", "一"]);
+
+/** 番号が並びの最初（1.、1.1、第1章、A.、①）か。最後の数が最初の数のときで、番号の無い見出しは並びを始めない。 */
+export const opensNumbering = (heading: string, labels: readonly NumberLabel[]): boolean => {
+  const last = markOf(heading, labels).mark.match(NUMBER_TOKEN)?.at(-1);
+  return last !== undefined && FIRST_NUMBERS.has(last);
 };
 
-/** 見出し 1 つ。depth は深さ（#の数）、style は番号の書き方、skipped は番号を付けない前後の見出し（目次・参考文献）。 */
-export type NumberedHeading = { readonly depth: number; readonly style: string; readonly skipped: boolean };
+/** 見出し 1 つ。depth は深さ（#の数）、style は番号の書き方、skipped は番号を付けない前後の見出し（目次・参考文献）、opens は番号が 1 から始まるか。 */
+export type NumberedHeading = { readonly depth: number; readonly style: string; readonly skipped: boolean; readonly opens: boolean };
 
 /** 親（直前の浅い見出し）と深さが同じ見出しの組。番号は兄弟の見出しのあいだで揃える。位置は渡した並びの添え字。 */
 export const siblingGroups = (headings: readonly NumberedHeading[]): number[][] => {
@@ -87,13 +102,25 @@ const minorityBy = (members: readonly number[], keyOf: (at: number) => string):
 const minoritiesOf = (split: Split | undefined, kind: NumberingMinority["kind"]): NumberingMinority[] =>
   split === undefined ? [] : split.minority.map((at) => ({ at, kind, majority: split.majority, count: split.count, example: split.example }));
 
+/** 番号の並びの最初の兄弟が 1 から始まるとき、その前の番号の無い兄弟（文書の題、「Applies to England」）は並びの外。番号付きの兄弟が二つ以上あるときだけ。 */
+const MIN_NUMBERED_RUN = 2;
+
+const leadingFrontMatter = (members: readonly number[], headings: readonly NumberedHeading[]): ReadonlySet<number> => {
+  const numbered = members.filter((at) => (headings[at]?.style ?? UNNUMBERED) !== UNNUMBERED);
+  const first = numbered[0];
+  if (first === undefined || numbered.length < MIN_NUMBERED_RUN || headings[first]?.opens !== true) return new Set();
+  return new Set(members.filter((at) => at < first));
+};
+
 /**
  * 兄弟の見出しのうち、少ないほうの書き方のもの。先に番号の有無を比べ（「1. 概要」「2. 手順」「まとめ」の「まとめ」）、
- * 番号の付いた見出しのあいだで書き方を比べる（「1.」「2.」「3）」の「3）」）。同じ数なら言わない（二つだけの兄弟は必ず同じ数か一つの書き方）。前後の見出し（目次・参考文献）は数えない。
+ * 番号の付いた見出しのあいだで書き方を比べる（「1.」「2.」「3）」の「3）」）。同じ数なら言わない（二つだけの兄弟は必ず同じ数か一つの書き方）。前後の見出し（目次・参考文献）と、1 から始まる番号の前の見出しは数えない。
  */
 export const numberingMinorities = (headings: readonly NumberedHeading[]): NumberingMinority[] =>
   siblingGroups(headings).flatMap((group) => {
-    const members = group.filter((at) => headings[at]?.skipped !== true);
+    const listed = group.filter((at) => headings[at]?.skipped !== true);
+    const front = leadingFrontMatter(listed, headings);
+    const members = listed.filter((at) => !front.has(at));
     const styleOf = (at: number): string => headings[at]?.style ?? UNNUMBERED;
     const numbered = members.filter((at) => styleOf(at) !== UNNUMBERED);
     return [

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,64 @@ 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;
+
+/** 項目名に出る品詞。名詞だけで、助詞・副詞（およそ）・接頭の語（約）を含めば、量の前置きか文。 */
+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 };
+};
+
 /**
- * 「所属：経済学部 経済学科 1年」「物件：メゾンかえで 203号室」「振込先：みなと銀行 普通 1234567」のように、項目名とコロンの後ろに
- * 値の組を空白で並べた行で、組と、数で始まる次の組のあいだの空白。値の区切りで、日本語と数字のあいだの空け方ではない。
- * boundary は空けた数字の前の境目（text[offset] が空白）。tokens は文書全体の座標で、base は text の先頭の位置。
+ * 「最高速度 40km/h」「（内線 3839～40）」「- 定員 30名」のように、短い項目名と、それが名指す値を空白一つで並べただけの組の、名と値のあいだの空白。
+ * 組は行・括弧の中・表の升目にそれだけで書くか、読点で並べる。項目の区切りで、文の中の空け方ではない。
+ * 囲みの中に助詞や動詞がある（定員 30名で行います、参加者 30名、来場者50名を見込みます）、値の後ろに語が続く（内線 3839 まで）、
+ * 項目名が 1 字（約 30名）か名詞でない語を含む組は、文の中の空白として数える。
  */
-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 isLabelledValue = (text: string, boundary: Boundary, tokens: readonly Token[], base: number): boolean => {
+  const enclosure = enclosureAround(text, lineAround(text, boundary.offset), boundary.offset);
+  const pair = pairAround(text, enclosure, boundary.offset);
+  const label = { start: pair.start, end: boundary.offset };
+  if (!PAIR_LABEL.test(text.slice(label.start, label.end)) || !PAIR_VALUE.test(text.slice(boundary.offset + 1, pair.end))) 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 +117,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,36 @@
+import type { Token } from "./plugin.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(["、", "，", ","]);
+
+/**
+ * A free noun after the stem form may begin the next clause (疾病にかかり療養のために), so the stem form stays a verb; a suffix
+ * (払込み等), or a noun the caller lists as one (受取り前), may not.
+ */
+const verbGoesOn = (next: Token, suffixes: ReadonlySet<string>): boolean =>
+  VERB_GOES_ON.has(next.pos) || CLAUSE_COMMA.has(next.surface) || (next.pos === "NOUN" && next.features?.["Bound"] !== "Yes" && !suffixes.has(next.surface));
+
+/**
+ * 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.
+ */
+export const asNounWhereNominal = (token: Token, next: Token | undefined, suffixes: ReadonlySet<string> = new Set()): Token => {
+  if (token.pos !== "VERB" || token.lemma === undefined || !isStemForm(token.surface, token.lemma)) return token;
+  return next !== undefined && verbGoesOn(next, suffixes) ? token : { ...token, pos: "NOUN", lemma: token.surface };
+};

package/src/sentence-load.ts

@@ -20,18 +20,23 @@ const BRACKETS: Readonly<Record<string, string>> = {
   "“": "”",
 };
 
+/** A closer and the same closer in the other width: a numbering marker written (1） closes the bracket it opened. */
+const OTHER_WIDTH: Readonly<Record<string, string>> = { ")": "）", "）": ")", "]": "］", "］": "]" };
+
 /** A formula written in TeX ($d^k = -\nabla f(x^k)$): its brackets are the formula's, not the sentence's. */
 const FORMULA = /\$\$[^$]*\$\$|\$[^$\n]*\$/gu;
 
 /**
  * The deepest the brackets of a text nest: 「計画（案）」 is one, 「（注（a）を参照）」 two, plain text none. A closer with no
- * opener (the 1) of a list) is ignored, an opener never closed counts as open until the end, and formulas in $…$ are skipped.
+ * opener (the 1) of a list) is ignored, an opener never closed counts as open until the end, a closer of the other width closes
+ * its opener ((1） is one), and formulas in $…$ are skipped.
  */
 export const bracketDepth = (text: string): number => {
   // The closers still awaited, innermost last. Pushed and popped in place: copying it per character is quadratic on deep nesting.
   const awaited: string[] = [];
   return [...text.replace(FORMULA, " ")].reduce((deepest, char) => {
-    if (awaited.at(-1) === char) awaited.pop();
+    const innermost = awaited.at(-1);
+    if (innermost !== undefined && (innermost === char || innermost === OTHER_WIDTH[char])) awaited.pop();
     else if (BRACKETS[char] !== undefined) awaited.push(BRACKETS[char]);
     return Math.max(deepest, awaited.length);
   }, 0);

package/src/structure/cited-document-section.ts

@@ -0,0 +1,42 @@
+import type { StructureNode } from "../plugin.ts";
+
+// 他の文書を引き写した節。「##### 地方公務員法」の下に引いた第十六条の「第六十条」は、地方公務員法の条で、この文書の条ではない。
+
+/** heading: いちばん近い見出しの節の言葉。inArticle: 条の中か。 */
+type Visit = { readonly node: StructureNode; readonly heading: string | undefined; readonly inArticle: boolean };
+
+/** 見出しの言葉。文書の最初の見出しは文書自身の題（「# 就業規則」）なので、他の文書の名前として読まない。 */
+const headingOf = (node: StructureNode, title: StructureNode | undefined): string | undefined =>
+  node === title ? undefined : String(node.attrs["heading"] ?? "").trim();
+
+const documentsCited = (nodes: readonly StructureNode[]): ReadonlySet<string> =>
+  new Set(nodes.flatMap((node) => (node.kind === "reference" && typeof node.attrs["document"] === "string" ? [node.attrs["document"]] : [])));
+
+/** 木を上から順に、見出しの言葉と条の中かと一緒に並べる。再帰にしないのは、深い木でスタックを使い切らないため。 */
+const visitsOf = (tree: StructureNode): Visit[] => {
+  const title = tree.children.find((child) => child.kind === "section");
+  const visits: Visit[] = [];
+  const pending: Visit[] = [{ node: tree, heading: undefined, inArticle: false }];
+  while (pending.length > 0) {
+    const visit = pending.pop();
+    if (visit === undefined) break;
+    visits.push(visit);
+    const { node } = visit;
+    const heading = node.kind === "section" ? headingOf(node, title) : visit.heading;
+    const inArticle = node.kind === "section" ? false : visit.inArticle || node.kind === "article";
+    node.children.toReversed().forEach((child) => pending.push({ node: child, heading, inArticle }));
+  }
+  return visits;
+};
+
+/**
+ * 見出しが他の文書の名前そのものである節に引き写した条の中の参照。その名前を文書がほかで他の文書として引いている
+ * （「地方公務員法第16条」）ときだけ、節はその文書を引き写したものと読む。条の外の地の文の参照は、この文書のもの。Pure.
+ */
+export const referencesInCitedDocuments = (tree: StructureNode): ReadonlySet<StructureNode> => {
+  const visits = visitsOf(tree);
+  const cited = documentsCited(visits.map((visit) => visit.node));
+  if (cited.size === 0) return new Set();
+  const quoted = visits.filter((visit) => visit.node.kind === "reference" && visit.inArticle && visit.heading !== undefined && cited.has(visit.heading));
+  return new Set(quoted.map((visit) => visit.node));
+};