chaffjs 0.34.0 → 0.36.0

package/src/detectors/email-letter.ts

@@ -1,6 +1,6 @@
 // A work email or letter's own parts: a greeting and a closing, a subject line, and an attachment the text mentions.
 // Pure. The words (お世話になっております, Dear, Best regards, 件名, attached) come from the language's email-greeting,
-// email-closing, email-sentence-end, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
+// email-closing, email-sentence-end, memo-header-label, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
 // header and the signature are masked in doc.prose; a quoted reply is someone else's words and is left out.
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
@@ -141,13 +141,49 @@ export const frameSlips = (
   ];
 };
 
+/** The marks around a label line: a heading's #, emphasis, 【】. */
+const LINE_MARKS = new Set("#*_【】 \t\u3000");
+
+const withoutMarks = (line: string): string => {
+  const chars = [...line];
+  const first = chars.findIndex((char) => !LINE_MARKS.has(char));
+  return first === -1 ? "" : chars.slice(first, chars.findLastIndex((char) => !LINE_MARKS.has(char)) + 1).join("");
+};
+
+const LABEL_END = /^(?:[:：]|$)/u;
+
+/** An inline HTML tag around a label (<h3> FROM: <br/>, <b>TO</b>:), dropped so the colon still follows the label. */
+const INLINE_HTML_TAG = /<\/?[A-Za-z][A-Za-z0-9-]*(?:\s[^<>]*)?\/?>/gu;
+
+/**
+ * Whether a line is a memo's header label (TO:, SUBJECT:, MEMORANDUM, 発信者：): a label as the lexicon writes it, case
+ * included, then a colon or the line's end. A memo sets its labels in capitals; a mail program writes "To:" and "Subject:".
+ */
+export const isMemoLabel = (line: string, labels: readonly string[]): boolean => {
+  const bare = withoutMarks(line.replace(INLINE_HTML_TAG, ""));
+  return labels.some((label) => bare.startsWith(label) && LABEL_END.test(bare.slice(label.length)));
+};
+
+/**
+ * A memo: one of its header labels among the source's lines before the first sentence (the first lines, when no line ends
+ * one). The source, not the body, since a block of TO: / FROM: lines is masked as an email's header. A memo takes no
+ * greeting and no closing.
+ */
+export const isMemo = (source: string, labels: readonly string[], sentenceEnds: readonly string[]): boolean => {
+  const lines = source.split("\n").filter((line) => line.trim() !== "" && !line.trimStart().startsWith(">"));
+  const firstSentence = lines.findIndex((line) => endsSentence(line, sentenceEnds));
+  return lines.slice(0, firstSentence === -1 ? HEADER_LINES : firstSentence).some((line) => isMemoLabel(line, labels));
+};
+
+const frameSlipsOf = (doc: ProseDocument): FrameSlip[] => {
+  const sentenceEnds = patternsOf(doc, "email-sentence-end");
+  if (isMemo(doc.source, patternsOf(doc, "memo-header-label"), sentenceEnds)) return [];
+  const lines = bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []);
+  return frameSlips(lines, patternsOf(doc, "email-greeting"), patternsOf(doc, "email-closing"), sentenceEnds);
+};
+
 export const emailFrame: Detector = (doc): Finding[] =>
-  frameSlips(
-    bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []),
-    patternsOf(doc, "email-greeting"),
-    patternsOf(doc, "email-closing"),
-    patternsOf(doc, "email-sentence-end"),
-  ).map((slip) => ({
+  frameSlipsOf(doc).map((slip) => ({
     rule: "email-greeting-closing",
     severity: "info",
     line: 0,
@@ -180,14 +216,53 @@ export const fieldOf = (line: string): { readonly name: string; readonly value:
       };
 };
 
+/** The subject field's names and reply marks, and what tells the body's first line from a subject: a greeting, a sentence's end. */
+export type SubjectVocabulary = {
+  readonly fields: readonly string[];
+  readonly replyMarks: readonly string[];
+  readonly headerFields: readonly string[];
+  readonly greetings: readonly string[];
+  readonly sentenceEnds: readonly string[];
+};
+
+/** The text of the first line with text after `index`, trimmed. Scans only the blank lines between, so many empty subjects stay linear. */
+const nextText = (lines: readonly SourceLine[], index: number): string => {
+  for (let at = index + 1; at < lines.length; at += 1) {
+    const text = lines[at]?.text.trim() ?? "";
+    if (text !== "") return text;
+  }
+  return "";
+};
+
+/** A header field's line (From: Ann). Not any colon: a subject may hold one (Re: Lunch, 10:00 meeting, Q3: budget). */
+const isHeaderField = (line: string, headerFields: readonly string[]): boolean => {
+  const name = fieldOf(line)?.name.toLowerCase();
+  return name !== undefined && headerFields.some((field) => field.toLowerCase() === name);
+};
+
+/**
+ * The value under a subject label with nothing after its colon: the next line with text, as a form that sets the label and
+ * the value in two columns reads once it is text ("SUBJECT:" over "Car park repairs"). A quoted line, a header field, a
+ * greeting or a sentence there is the body, and the subject stays empty.
+ */
+export const valueBelow = (lines: readonly SourceLine[], index: number, vocabulary: SubjectVocabulary): string => {
+  const text = nextText(lines, index);
+  const isBody =
+    text.startsWith(">") || isHeaderField(text, vocabulary.headerFields) || lineHas(text, vocabulary.greetings) || endsSentence(text, vocabulary.sentenceEnds);
+  return isBody ? "" : text;
+};
+
 /** The subject lines (Subject: …, 件名：…), outside a quoted reply, with reply and forward marks (Re:, Fwd:) taken off the value. */
-export const subjectLines = (source: string, fields: readonly string[], replyMarks: readonly string[], replyQuotes: readonly Span[]): SubjectLine[] => {
-  const names = new Set(fields.map((field) => field.toLowerCase()));
+export const subjectLines = (source: string, vocabulary: SubjectVocabulary, replyQuotes: readonly Span[]): SubjectLine[] => {
+  const names = new Set(vocabulary.fields.map((field) => field.toLowerCase()));
   const quoted = insideCursor(replyQuotes);
-  return linesWithOffsets(source).flatMap(({ start, text }): SubjectLine[] => {
+  const lines = linesWithOffsets(source);
+  return lines.flatMap(({ start, text }, index): SubjectLine[] => {
     const field = fieldOf(text);
     const inQuote = quoted(start);
-    return field === undefined || inQuote || !names.has(field.name.toLowerCase()) ? [] : [{ start, subject: withoutReplyMarks(field.value, replyMarks) }];
+    if (field === undefined || inQuote || !names.has(field.name.toLowerCase())) return [];
+    const value = field.value === "" ? valueBelow(lines, index, vocabulary) : field.value;
+    return [{ start, subject: withoutReplyMarks(value, vocabulary.replyMarks) }];
   });
 };
 
@@ -201,7 +276,17 @@ export const withoutReplyMarks = (subject: string, marks: readonly string[]): st
 };
 
 export const emailSubject: Detector = (doc, options): Finding[] =>
-  subjectLines(doc.source, patternsOf(doc, "email-subject-field"), patternsOf(doc, "email-reply-mark"), doc.replyQuotes ?? []).flatMap((line): Finding[] => {
+  subjectLines(
+    doc.source,
+    {
+      fields: patternsOf(doc, "email-subject-field"),
+      replyMarks: patternsOf(doc, "email-reply-mark"),
+      headerFields: patternsOf(doc, "email-header-field"),
+      greetings: patternsOf(doc, "email-greeting"),
+      sentenceEnds: patternsOf(doc, "email-sentence-end"),
+    },
+    doc.replyQuotes ?? [],
+  ).flatMap((line): Finding[] => {
     const length = [...line.subject].length;
     if (length > 0 && length <= options.limit) return [];
     return [
@@ -228,15 +313,6 @@ export const firstMention = (lines: readonly BodyLine[], mentions: readonly stri
   return line === undefined ? undefined : line.start + line.text.length - line.text.trimStart().length;
 };
 
-/** The marks around a label line: a heading's #, emphasis, 【】. */
-const LINE_MARKS = new Set("#*_【】 \t\u3000");
-
-const withoutMarks = (line: string): string => {
-  const chars = [...line];
-  const first = chars.findIndex((char) => !LINE_MARKS.has(char));
-  return first === -1 ? "" : chars.slice(first, chars.findLastIndex((char) => !LINE_MARKS.has(char)) + 1).join("");
-};
-
 /** A line that labels what is attached: the label and a colon (Attachment: quote.pdf), or the label alone (### Enclosures, 【添付資料】). */
 const labelsAttachment = (line: string, labels: readonly string[]): boolean => {
   const bare = withoutMarks(line).toLowerCase();

package/src/detectors/en-shape.ts

@@ -1,6 +1,7 @@
 import { lengthOf } from "../measure.ts";
 import { isClosed } from "../sentence-shape.ts";
 import { isTitleCase, minorityCase, pageTitleOf } from "./heading-case.ts";
+import { namesWrittenMidSentence } from "./heading-names.ts";
 import type { Detector, Finding, Lexicon, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 import { entryOpens } from "./lexicon-match.ts";
 
@@ -137,7 +138,10 @@ const headingsOf = (sections: readonly Section[], fixedCase: ReadonlySet<string>
  * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。題名は指摘しない（minorityCase）。
  */
 export const titleCaseMix: Detector = (doc, options): Finding[] => {
-  const fixedCase = new Set(FIXED_CASE_LISTS.flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)));
+  const fixedCase = new Set([
+    ...FIXED_CASE_LISTS.flatMap((id) => (doc.lexicons[id] ?? []).map((entry) => entry.pattern)),
+    ...namesWrittenMidSentence(doc.sentences.map((sentence) => sentence.text)),
+  ]);
   const pageTitle = pageTitleOf(doc.sections);
   const judged = headingsOf(
     doc.sections.filter((section) => section !== pageTitle),

package/src/detectors/fact-consistency.ts

@@ -140,9 +140,10 @@ const readFacts = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
   );
   const read = new Set([...termed, ...labelled.map((fact) => fact.value.start)]);
   const verbs = verbQuantityFacts(doc.source, values, verbQuantityWordsOf(doc)).filter((fact) => !read.has(fact.value.start));
-  const tabled = tableFacts(doc.source, values, totalColumnsOf(doc), countLabelWordsOf(doc.lexicons));
+  const tabled = tableFacts(doc.source, values, totalColumnsOf(doc), countLabelWordsOf(doc.lexicons), { columnGroups: true });
   const facts = withQualifiedKeys(doc, [...labelled, ...terms, ...verbs, ...tabled]);
-  return withCellKeys(scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading")), qualifierWordsOf(doc));
+  const scoped = scopedFacts(facts, tree, doc.source, patternsOf(doc, "summary-heading"), { paragraphHeads: true });
+  return withCellKeys(scoped, qualifierWordsOf(doc));
 };
 
 /** 文書の名前付きの値。二つの rule が読むので、文書ごとに一度だけ読む。 */

package/src/detectors/field-label.ts

@@ -0,0 +1,25 @@
+// The label of a field that opens a line ("Current project status: Ongoing", 「現在の状況：継続中」). Pure.
+
+/** A label is a short name, not a clause: this many words at most. */
+const MAX_LABEL_WORDS = 5;
+const MAX_LABEL_CHARS = 40;
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+const FIELD = /^([^:：\n]+)[:：](?!\/\/)/u;
+const HAS_LETTER = /\p{L}/u;
+/** A sentence ends before the colon, so what precedes it is not a label. */
+const SENTENCE_END = /[.!?。！？]/u;
+
+const isLabel = (label: string): boolean =>
+  HAS_LETTER.test(label) && !SENTENCE_END.test(label) && label.length <= MAX_LABEL_CHARS && label.trim().split(/\s+/u).length <= MAX_LABEL_WORDS;
+
+/**
+ * Where the value of a field on the text's first line starts, just past the colon (the value may be blank), or undefined
+ * when the first line opens with no label. Whether the label is a name and not a clause ("The following apply:") is the
+ * caller's to judge from the parts of speech.
+ */
+export const fieldValueStart = (text: string): number | undefined => {
+  const marker = LIST_MARKER.exec(text)?.[0] ?? "";
+  const field = FIELD.exec(text.slice(marker.length));
+  if (field?.[1] === undefined || !isLabel(field[1].replaceAll("**", ""))) return undefined;
+  return marker.length + field[0].length;
+};

package/src/detectors/footnote-mismatch.ts

@@ -26,9 +26,12 @@ const markdownMarks = (text: string): NoteMark[] =>
     return { offset: match.index, label: `[^${match.groups?.["key"] ?? ""}]`, kind: MARKDOWN, key: (match.groups?.["key"] ?? "").toLowerCase(), note };
   });
 
-/** 印と一桁か二桁の番号。後ろに数字や小数が続けば年や数（※2018年度、※1.2倍）で、注の番号ではない。 */
+/** 番号の後ろに続くと、番号が英語の序数（1st、2nd、23rd）になるもの。 */
+const ORDINAL_SUFFIX = "(?:[sS][tT]|[nN][dD]|[rR][dD]|[tT][hH])(?![A-Za-z])";
+
+/** 印と一桁か二桁の番号。後ろに数字や小数が続けば年や数（※2018年度、※1.2倍）、序数が続けば英語の語（※1st Party）で、注の番号ではない。 */
 const wordMarks = (text: string, mark: string): NoteMark[] =>
-  [...text.matchAll(new RegExp(`${escapeRegExp(mark)}(?<key>[0-9０-９]{1,2})(?![0-9０-９]|[.．,，][0-9０-９])`, "gu"))].map((match) => ({
+  [...text.matchAll(new RegExp(`${escapeRegExp(mark)}(?<key>[0-9０-９]{1,2})(?![0-9０-９]|[.．,，][0-9０-９]|${ORDINAL_SUFFIX})`, "gu"))].map((match) => ({
     offset: match.index,
     label: match[0],
     kind: mark,
@@ -36,11 +39,38 @@ const wordMarks = (text: string, mark: string): NoteMark[] =>
     note: NOTE_LINE_HEAD.test(lineHeadOf(text, match.index)),
   }));
 
+const QUOTE_LINE = /^[ \t]{0,3}>/u;
+const QUOTE_MARKS = /^(?:[ \t]{0,3}>)+/u;
+/** 引用の段落を終わらせる行（見出し、コード、箇条書き、脚注の定義）。これ以外の空でない行は、引用の段落の続き（CommonMark の lazy continuation）。 */
+const BLOCK_START = /^[ \t]{0,3}(?:[#`~]|[-*+][ \t]|\d{1,9}[.)][ \t]|\[\^)/u;
+const CODE_SPAN = /(`+)[\s\S]*?\1/gu;
+
+const quotedLines = (source: string): string[] =>
+  source.split("\n").reduce<{ lines: string[]; open: boolean }>(
+    (state, line) => {
+      const open = QUOTE_LINE.test(line) || (state.open && line.trim() !== "" && !BLOCK_START.test(line));
+      return { lines: open ? [...state.lines, line.replace(QUOTE_MARKS, "")] : state.lines, open };
+    },
+    { lines: [], open: false },
+  ).lines;
+
+/**
+ * 引用（`>`）の中の Markdown の脚注の印の番号。引用は本文から覆われるが、引用の中の印も注を指している。
+ * 引用の中の印に注が無くても言わない（引用元の注かもしれない）。注が指されているかだけに使う。
+ */
+export const quotedFootnoteKeys = (source: string): ReadonlySet<string> =>
+  new Set(
+    markdownMarks(quotedLines(source).join("\n").replace(CODE_SPAN, ""))
+      .filter((mark) => !mark.note)
+      .map((mark) => mark.key),
+  );
+
 /** 一つの種類の印のうち、合わないもの。印の語（※）は、その種類の注が一つも無ければ注を別に置いた文書と読んで言わない。 */
-const slipsOfKind = (marks: readonly NoteMark[], kind: string): NoteSlip[] => {
+const slipsOfKind = (marks: readonly NoteMark[], kind: string, quotedKeys: ReadonlySet<string>): NoteSlip[] => {
   const ofKind = marks.filter((mark) => mark.kind === kind);
   const notes = new Set(ofKind.filter((mark) => mark.note).map((mark) => mark.key));
-  const referenced = new Set(ofKind.filter((mark) => !mark.note).map((mark) => mark.key));
+  const quoted = kind === MARKDOWN ? [...quotedKeys] : [];
+  const referenced = new Set([...ofKind.filter((mark) => !mark.note).map((mark) => mark.key), ...quoted]);
   if (notes.size === 0 && kind !== MARKDOWN) return [];
   const missing = ofKind
     .filter((mark) => !mark.note && !notes.has(mark.key))
@@ -52,15 +82,17 @@ const slipsOfKind = (marks: readonly NoteMark[], kind: string): NoteSlip[] => {
 };
 
 /** 文字列の中の、注の無い印と印の無い注。 */
-export const noteSlips = (text: string, words: readonly string[]): NoteSlip[] => {
+export const noteSlips = (text: string, words: readonly string[], quotedKeys: ReadonlySet<string> = new Set()): NoteSlip[] => {
   const marks = [...markdownMarks(text), ...words.flatMap((word) => wordMarks(text, word))];
-  return [...new Set(marks.map((mark) => mark.kind))].flatMap((kind) => slipsOfKind(marks, kind)).toSorted((left, right) => left.offset - right.offset);
+  return [...new Set(marks.map((mark) => mark.kind))]
+    .flatMap((kind) => slipsOfKind(marks, kind, quotedKeys))
+    .toSorted((left, right) => left.offset - right.offset);
 };
 
 export const footnoteMismatch: Detector = (doc): Finding[] => {
   const text = doc.prose ?? doc.source;
   const words = (doc.lexicons["note-mark"] ?? []).map((entry) => entry.pattern);
-  return noteSlips(text, words).map((slip) => ({
+  return noteSlips(text, words, quotedFootnoteKeys(doc.source)).map((slip) => ({
     rule: "",
     severity: "warning",
     line: 0,

package/src/detectors/graded-step.ts

@@ -0,0 +1,52 @@
+import type { Span, Token } from "../plugin.ts";
+import { isWithinAny } from "../quoted-span.ts";
+
+/**
+ * 段階の一つとしての比較（より良い（BESTな）改善 と 良い（BETTERな）改善、より良い実装例1 と 良い実装例2）。文書が同じ語を
+ * 比べる副詞なしでも書いていれば（良い改善）、「より良い」の相手はその一段下の段で、相手は書いてある。
+ * 段は、程度を言う語の原形と、その後ろの名詞で見分ける。間の括弧の添え書き（（BESTな））は飛ばす。
+ */
+
+/** 程度を言う語が語の位置 at で始まるか。bare-comparative.ts の判定を受け取る。 */
+export type IsGradable = (tokens: readonly Token[], at: number) => boolean;
+
+/** 形容動詞の語幹の後ろに来る語（豊かな）。この語の後ろから名詞を探す。 */
+const ADJECTIVAL_TAIL = new Set(["な", "に", "だ", "です", "で"]);
+const OPENING = new Set(["（", "("]);
+const CLOSING = new Set(["）", ")"]);
+
+/** 程度を言う語（at）の後ろの最初の語の位置。形容動詞の語尾と、括弧の添え書きを飛ばす。 */
+const afterWord = (tokens: readonly Token[], at: number): number => {
+  const next = tokens[at]?.pos === "NOUN" && ADJECTIVAL_TAIL.has(tokens[at + 1]?.surface ?? "") ? at + 2 : at + 1;
+  if (!OPENING.has(tokens[next]?.surface ?? "")) return next;
+  const close = tokens.findIndex((token, index) => index > next && CLOSING.has(token.surface));
+  return close === -1 ? next : close + 1;
+};
+
+/** 段の名前: 程度を言う語の原形と、後ろの名詞。後ろが名詞でなければ段ではない。 */
+export const stepKeyAt = (tokens: readonly Token[], at: number): string | undefined => {
+  const [word, noun] = [tokens[at], tokens[afterWord(tokens, at)]];
+  if (word === undefined || noun === undefined || noun.pos !== "NOUN") return undefined;
+  return `${word.lemma ?? word.surface}|${noun.surface}`;
+};
+
+/** 文の語と、引いたもの（鉤括弧の中）の範囲。引いた語（「良い対応」という表現）は文書が書いた段ではない。 */
+export type StepSentence = { readonly tokens: readonly Token[]; readonly quoted: readonly Span[] };
+
+/** 文書が比べる副詞（markers）なしで書いた、程度を言う語と名詞の段の名前。 */
+export const plainStepKeys = (sentences: readonly StepSentence[], markers: ReadonlySet<string>, isGradable: IsGradable): ReadonlySet<string> =>
+  new Set(
+    sentences.flatMap(({ tokens, quoted }) =>
+      tokens.flatMap((token, at) => {
+        if (markers.has(tokens[at - 1]?.surface ?? "") || isWithinAny(quoted, token.span) || !isGradable(tokens, at)) return [];
+        const key = stepKeyAt(tokens, at);
+        return key === undefined ? [] : [key];
+      }),
+    ),
+  );
+
+/** 比べた語（word）が、文書が一段下を書いた段の一つか。 */
+export const isNamedStep = (tokens: readonly Token[], word: Token, steps: ReadonlySet<string>): boolean => {
+  const key = stepKeyAt(tokens, tokens.indexOf(word));
+  return key !== undefined && steps.has(key);
+};

package/src/detectors/gram-openers.ts

@@ -0,0 +1,21 @@
+import type { Section, Sentence } from "../plugin.ts";
+
+/** A list item or a table row on a line after the sentence: what the sentence leads into. */
+const LIST_OR_TABLE_NEXT = /^[ \t]*\n\s*(?:[-*+]\s|\d{1,3}[.)]\s|\|)/u;
+
+/** How far past the sentence to look for that line: blank lines between, never the rest of a long document. */
+const LOOKAHEAD = 200;
+
+/**
+ * 見出しのある節の最初の文のうち、次の行から箇条書きか表が続くもの。参照用の文書は、節ごとに同じ書き出しで一覧を導く
+ * （「…によると以下の制約である。」の後ろに制約の箇条書き）。言い回しがどれもこの文にだけ出るなら節のひな形で、書き手が言い直したのではない。
+ * 後ろが本文の文なら、節ごとの口癖（正直なところ、…）と見分けられないので入れない。導入部（見出しの前）は節ではない。
+ */
+export const sectionOpeners = (sections: readonly Pick<Section, "depth" | "sentences">[], source: string): Set<Sentence> =>
+  new Set(
+    sections.flatMap((section) => {
+      const first = section.sentences[0];
+      if (section.depth === 0 || first === undefined) return [];
+      return LIST_OR_TABLE_NEXT.test(source.slice(first.span.end, first.span.end + LOOKAHEAD)) ? [first] : [];
+    }),
+  );

package/src/detectors/gram-passages.ts

@@ -0,0 +1,36 @@
+import type { Section, Sentence } from "../plugin.ts";
+
+/**
+ * 問いの印で終わる見出し。後ろに括弧の注記（(updated Nov. 14, 2024)）が付いてもよい。
+ * 「Q1」の札だけでは問いと見ない。四半期（Q1 2024）の見出しと見分けられない。
+ */
+const QUESTION_END = /[?？]\s*(?:[(（][^()（）]*[)）])?$/u;
+
+export const isQuestionHeading = (heading: string): boolean => QUESTION_END.test(heading.trim());
+
+/** 範囲を決めるのに見るのは、見出しと深さと文だけ。 */
+type Heading = Pick<Section, "depth" | "heading" | "sentences">;
+
+type Answer = { readonly depth: number; readonly sentences: Sentence[] };
+type Passages = { readonly rest: Sentence[]; readonly answers: Answer[]; readonly open: readonly Answer[] };
+
+/** 節は、それを囲む一番内側の問いの答えに入る。同じ深さか浅い見出しが来れば、その問いは閉じている。 */
+const place = (passages: Passages, section: Heading): Passages => {
+  const open = passages.open.filter((answer) => answer.depth < section.depth);
+  if (isQuestionHeading(section.heading)) {
+    const answer = { depth: section.depth, sentences: [...section.sentences] };
+    return { ...passages, answers: [...passages.answers, answer], open: [...open, answer] };
+  }
+  const owner = open.at(-1);
+  (owner?.sentences ?? passages.rest).push(...section.sentences);
+  return { ...passages, open };
+};
+
+/**
+ * 言い回しを数える範囲。問いの見出しの下（より深い見出しの「A1」も含む）はそれぞれ一つの答えで、読み手は答えを一つずつ読む。
+ * 別の答えで同じ案内（〜をご覧ください）を繰り返しても、書き手が言い直したのではない。問いでない節は、文書全体で一つの範囲。
+ */
+export const gramPassagesOf = (sections: readonly Heading[]): Sentence[][] => {
+  const passages = sections.reduce<Passages>(place, { rest: [], answers: [], open: [] });
+  return [passages.rest, ...passages.answers.map((answer) => answer.sentences)].filter((sentences) => sentences.length > 0);
+};

package/src/detectors/gram-place.ts

@@ -1,5 +1,5 @@
 import { softBreaks } from "../soft-break.ts";
-import type { LengthUnit, Span } from "../plugin.ts";
+import type { LengthUnit, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /** 数えるために詰めた文と、詰めた文の各文字が元の文のどこにあったか。 */
 export type Compacted = { readonly text: string; readonly offsets: readonly number[] };
@@ -50,3 +50,12 @@ export const placeOf = (source: Compacted, gram: string): Span | undefined => {
   const at = source.text.indexOf(gram);
   return at === -1 ? undefined : placeAt(source, { start: at, end: at + gram.length });
 };
+
+/** 詰めた文の index 番目の文字が、リンクの文字か。 */
+export const linkedIn = (doc: ProseDocument, sentence: Sentence, source: Compacted): ((index: number) => boolean) => {
+  const links = doc.links.filter((link) => link.start < sentence.span.end && sentence.span.start < link.end);
+  return (index) => {
+    const at = sentence.span.start + (source.offsets[index] ?? -1);
+    return links.some((link) => link.start <= at && at < link.end);
+  };
+};

package/src/detectors/gram-predicate.ts

@@ -9,12 +9,28 @@ const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
 /** 中身を持たない語。名前の前後に付いても、名前の繰り返しを言い回しに変えない。 */
 const FUNCTION_POS = new Set(["ADP", "DET", "CCONJ", "SCONJ", "PART", "PUNCT", "SYM", "X"]);
 
+/** 形式名詞（とき、こと）。動詞が節を名詞にしているだけで、用語は作らない（承認又は断るとき）。 */
+const isDependentNoun = (token: Token | undefined): boolean => token?.features?.["NounType"] === "Dependent";
+
+/**
+ * 日本語で、名詞と接続詞（又は、及び）のすぐ後ろで名詞を飾る動詞（行為又は怠る事実）は、名詞を並べた一つの用語の中にあり、述語ではない。
+ * 用語は言い換えられないので、繰り返して当たり前。名詞に「する」が付いた動詞（承認又は拒否する）は、行為を並べた述語と見分けられないので外さない。
+ */
+const inCoordinatedNoun = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean =>
+  unit === "char" &&
+  tokens[index]?.pos === "VERB" &&
+  tokens[index]?.features?.["VerbType"] !== "Light" &&
+  tokens[index - 1]?.pos === "CCONJ" &&
+  NOUNS.has(tokens[index - 2]?.pos ?? "") &&
+  NOUNS.has(tokens[index + 1]?.pos ?? "") &&
+  !isDependentNoun(tokens[index + 1]);
+
 /**
  * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
- * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
+ * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、接続詞の後ろの用語の中（inCoordinatedNoun）だけを外す。
  */
 const modifiesNoun = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean =>
-  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
+  (unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "")) || inCoordinatedNoun(tokens, index, unit);
 
 /** 英語で大文字の名前の一部になった動詞（Procedures Guide、the Location Object）も、述語ではない。 */
 const namePartAt = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean => unit === "word" && isNamePart(tokens, index);
@@ -40,10 +56,34 @@ const onlyNamesBeside = (tokens: readonly Token[], predicate: number, window: Sp
   return names.length > 0 && rest.every((index) => FUNCTION_POS.has(tokens[index]?.pos ?? ""));
 };
 
+const COMPOUND_POS = new Set(["NOUN", "PROPN", "ADJ", "NUM"]);
+/** 動詞の前の名詞句がこれだけの語を持てば、動詞はその名詞句の最後の名詞。the contract says は 1 語なので述語のまま。 */
+const MIN_COMPOUND_WORDS = 2;
+
+/** 語形を変えていない動詞（rate）か -ing 形（subcontracting）。名詞と同じ形で、名詞の読み違いになりうる。described や says は述語の形。 */
+const isNounShaped = (token: Token): boolean =>
+  token.features?.["VerbForm"] === "Ger" || (token.lemma !== undefined && token.lemma === token.surface.toLowerCase());
+
+/** 動詞の目的語の始まり（models generate the text の the）。後ろにこれが続く動詞は述語。 */
+const OBJECT_START = new Set(["DET", "PRON", "NUM"]);
+
+/**
+ * 英語で、窓の最後の名詞の形の動詞の前が名詞と形容詞だけ（先頭の冠詞は許す）で、後ろに目的語が続かなければ、動詞は名詞の続きの
+ * 読み違い（the federal funds rate の rate、small business subcontracting）。窓の中に機能語があれば言い回し（your contract says）。
+ */
+const endsNounCompound = (tokens: readonly Token[], index: number, window: Span, unit: LengthUnit): boolean => {
+  const verb = tokens[index];
+  if (unit !== "word" || verb?.pos !== "VERB" || !isNounShaped(verb) || OBJECT_START.has(tokens[index + 1]?.pos ?? "")) return false;
+  const touched = tokens.flatMap((token, at) => (overlaps(token, window) ? [at] : []));
+  if (touched.at(-1) !== index) return false;
+  const before = touched.slice(0, -1).filter((at, order) => !(order === 0 && tokens[at]?.pos === "DET"));
+  return before.length >= MIN_COMPOUND_WORDS && before.every((at) => COMPOUND_POS.has(tokens[at]?.pos ?? ""));
+};
+
 const countsAsPredicate = (tokens: readonly Token[], index: number, window: Span, unit: LengthUnit): boolean => {
   const token = tokens[index];
   if (token === undefined || !PREDICATE_POS.has(token.pos) || !overlaps(token, window)) return false;
-  if (modifiesNoun(tokens, index, unit) || namePartAt(tokens, index, unit)) return false;
+  if (modifiesNoun(tokens, index, unit) || namePartAt(tokens, index, unit) || endsNounCompound(tokens, index, window, unit)) return false;
   return !isCut(token, window) || !onlyNamesBeside(tokens, index, window, unit);
 };
 

package/src/detectors/heading-echo.ts

@@ -1,13 +1,15 @@
 import { lengthOf, proseText } from "../measure.ts";
 import { newContentMorphemes } from "./content-morphemes.ts";
 import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
+import { fieldValueStart } from "./field-label.ts";
 import { formValueTokens, isFormBlock } from "./form-line.ts";
 import { titleTokens } from "../heading-label.ts";
 import { announcerWords, makesClaim } from "./heading-claim.ts";
 import { handsOver } from "./lead-in.ts";
 import { holdsLink, namesLocation } from "./location-pointer.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
-import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
+import { namesHeadingSubject } from "./subject-name-line.ts";
+import type { Detector, Finding, LengthUnit, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
 const MIN_GRAMS = 4;
@@ -105,8 +107,33 @@ const opensForm = (section: Section): boolean => {
   return newContentMorphemes(heading, formValueTokens(first.text, first.span.start, first.tokens)) > 0;
 };
 
+/** 最初の行が、見出しが扱うものの名前だけ（リンクや添付の札、見出しの名の一覧）。見出しを言い直す文ではない。 */
+const namesSubject = (doc: ProseDocument, section: Section): boolean => {
+  const first = section.firstSentence;
+  if (first?.tokens === undefined || section.headingTokens === undefined) return false;
+  const heading = titleTokens(section.heading, measuredHeading(section), section.headingTokens);
+  const announcing = announcerWords(doc.lexicons["heading-announcer"] ?? []).announcing;
+  return namesHeadingSubject(measuredHeading(section), heading, first.text, first.span.start, first.tokens, announcing);
+};
+
+/** 述語の品詞。項目名にあれば、コロンの前は名前ではなく文の頭（The following expenses require receipts:）。 */
+const PREDICATE_POS: ReadonlySet<string> = new Set(["VERB", "AUX"]);
+
+/**
+ * 行頭の項目名（Current project status: Ongoing）を除いた文。報告の書式が見出しの語で項目を立てるのは書式で、書き手が言ったのは値。
+ * 品詞が読めなければ、項目名かどうか決められないので除かない。
+ */
+const withoutFieldLabel = (sentence: Sentence): string => {
+  const valueStart = fieldValueStart(sentence.text);
+  if (valueStart === undefined || sentence.tokens === undefined) return sentence.text;
+  const labelEnd = sentence.span.start + valueStart;
+  const isClause = sentence.tokens.some((token) => token.span.start < labelEnd && PREDICATE_POS.has(token.pos));
+  return isClause ? sentence.text : sentence.text.slice(valueStart);
+};
+
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
-const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
+const echoedText = (section: Section): string =>
+  section.firstSentence === undefined ? "" : withoutQuotedVariants(withoutFieldLabel(section.firstSentence), measuredHeading(section));
 
 export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
@@ -117,7 +144,8 @@ export const headingEcho: Detector = (doc, options): Finding[] => {
         !leadsIn(doc, section, leadIns) &&
         !pointsElsewhere(doc, section) &&
         !statesFigure(section.heading, section.firstSentence?.text ?? "") &&
-        !opensForm(section),
+        !opensForm(section) &&
+        !namesSubject(doc, section),
     )
     .map((section) => ({ section, overlap: Math.round(containment(trigrams(measuredHeading(section)), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)

package/src/detectors/heading-end-mark.ts

@@ -39,8 +39,21 @@ export const endMarkOf = (heading: string, words: readonly string[] = []): strin
 
 type Judged = { readonly heading: MarkupHeading; readonly mark: string };
 
-/** The odd ones among headings of one depth, each with the usual side's first heading and count. */
-const oddAtDepth = (doc: ProseDocument, judged: readonly Judged[]): Finding[] => {
+const LOWER_CASE = /\p{Ll}/u;
+/** A word of this many capitals is a word set in capitals, not only an acronym (AGENCY, DATES; not FAQ). */
+const CAPITALS_WORD = /\p{Lu}{4,}/u;
+
+/**
+ * Whether a heading is set in capitals ("AGENCY:", "FOR FURTHER INFORMATION CONTACT:"). A notice's captions are one kind of
+ * heading and its sections in ordinary case ("Footnotes") another, so the two are compared apart.
+ */
+export const isCapitalsHeading = (heading: string): boolean => !LOWER_CASE.test(heading) && CAPITALS_WORD.test(heading);
+
+/** Headings compared with one another: the same depth, and the same case (capitals or ordinary). */
+const kindOf = (entry: Judged): string => `${String(entry.heading.depth)}:${String(isCapitalsHeading(entry.heading.text))}`;
+
+/** The odd ones among headings of one kind, each with the usual side's first heading and count. */
+const oddOfKind = (doc: ProseDocument, judged: readonly Judged[]): Finding[] => {
   if (judged.length < MIN_HEADINGS) return [];
   const odd = minorityWithin(judged, (entry) => entry.mark !== "", MINORITY_PERCENT);
   const usual = judged.filter((entry) => !odd.includes(entry));
@@ -56,9 +69,9 @@ const oddAtDepth = (doc: ProseDocument, judged: readonly Judged[]): Finding[] =>
 };
 
 /**
- * Headings that end with a colon or a full stop where most headings of the same depth do not, or the other way round. Headings
- * of one depth are one kind of heading; a depth of labels ("Optional:") is its own way. The page title (one top-level heading
- * that opens the document) is a name and is not compared.
+ * Headings that end with a colon or a full stop where most headings of the same depth and case do not, or the other way round.
+ * Headings of one depth are one kind of heading; a depth of labels ("Optional:") is its own way, and so are captions set in
+ * capitals. The page title (one top-level heading that opens the document) is a name and is not compared.
  */
 export const headingEndMark: Detector = (doc, options): Finding[] => {
   const words = (options.lexicon ?? []).map((entry) => entry.pattern);
@@ -70,12 +83,12 @@ export const headingEndMark: Detector = (doc, options): Finding[] => {
       const mark = endMarkOf(heading.text, words);
       return mark === undefined ? [] : [{ heading, mark }];
     });
-  const depths = [...new Set(judged.map((entry) => entry.heading.depth))];
-  return depths
-    .flatMap((depth) =>
-      oddAtDepth(
+  const kinds = [...new Set(judged.map(kindOf))];
+  return kinds
+    .flatMap((kind) =>
+      oddOfKind(
         doc,
-        judged.filter((entry) => entry.heading.depth === depth),
+        judged.filter((entry) => kindOf(entry) === kind),
       ),
     )
     .toSorted((left, right) => Number(left.values["offset"]) - Number(right.values["offset"]));