chaffjs 0.35.0 → 0.37.0

package/src/detectors/email-letter.ts

@@ -1,9 +1,10 @@
 // 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, notice-header, 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";
+import { isNoticeHead, noticeWordsOf } from "../notice-header.ts";
 import type { Detector, Finding, ProseDocument, Span } from "../plugin.ts";
 
 /** A greeting comes before the body: past the subject, the addressee (株式会社… / 総務部 山田様) and the writer's name. */
@@ -123,31 +124,109 @@ export const greetingLineCount = (lines: readonly BodyLine[], sentenceEnds: read
   return Math.max(GREETING_LINES, firstSentence + 1);
 };
 
-/** A missing greeting (none in the first lines, or past the letter's header) and a missing closing (none in the last lines of any part). */
+/** A signing line: a rule of underscores the writer signs on, alone on its line (not "Date: ____", a field to fill in). */
+const SIGNING_LINE = /^[ \t]*_{5,}[ \t]*$/u;
+
+/** The signer's name or title under a signing line is short; a paragraph there means the underscores were a section break. */
+const MAX_SIGNER_LENGTH = 60;
+
+/** Whether the next line with text is a signer's line: short, holding a letter, not a heading. */
+const signerBelow = (lines: readonly SourceLine[], index: number): boolean => {
+  const below = nextText(lines, index);
+  const signer = withoutMarks(below);
+  return !below.startsWith("#") && [...signer].length <= MAX_SIGNER_LENGTH && LETTER.test(signer);
+};
+
+/** Where each signing line starts in the source: underscores alone on a line, a signer's line below, outside a quoted reply. */
+export const signingLines = (source: string, replyQuotes: readonly Span[] = []): number[] => {
+  const quoted = insideCursor(replyQuotes);
+  const lines = linesWithOffsets(source);
+  return lines.flatMap(({ start, text }, index) => (!quoted(start) && SIGNING_LINE.test(text) && signerBelow(lines, index) ? [start] : []));
+};
+
+/** Whether a signing line stands among the part's last lines or between them and the next part: the part is signed off. */
+const signedOff = (part: readonly BodyLine[], next: BodyLine | undefined, signings: readonly number[]): boolean => {
+  const from = part.slice(-CLOSING_LINES)[0]?.start ?? Infinity;
+  return signings.some((offset) => offset >= from && offset < (next?.start ?? Infinity));
+};
+
+/**
+ * A missing greeting (none in the first lines, or past the letter's header) and a missing closing: none in the last lines
+ * of any part, and no part signed off on a signing line (a letter signed before an acceptance block the recipient signs).
+ */
 export const frameSlips = (
   lines: readonly BodyLine[],
   greetings: readonly string[],
   closings: readonly string[],
   sentenceEnds: readonly string[],
+  signings: readonly number[] = [],
 ): FrameSlip[] => {
   const first = lines[0];
   const last = lines.at(-1);
   if (first === undefined || last === undefined) return [];
   const greeted = lines.slice(0, greetingLineCount(lines, sentenceEnds)).some((line) => lineHas(line.text, greetings));
-  const closed = partsOf(lines).some((part) => part.slice(-CLOSING_LINES).some((line) => lineHas(line.text, closings)));
+  const parts = partsOf(lines);
+  const closed = parts.some(
+    (part, index) => part.slice(-CLOSING_LINES).some((line) => lineHas(line.text, closings)) || signedOff(part, parts[index + 1]?.[0], signings),
+  );
   return [
     ...(greeted ? [] : [{ variant: "greeting" as const, offset: first.start }]),
     ...(closed ? [] : [{ variant: "closing" as const, offset: last.start }]),
   ];
 };
 
+/** 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 =>
+  headLines(source, sentenceEnds).some((line) => isMemoLabel(line, labels));
+
+/** The source's lines before the first sentence (the first lines, when no line ends one), past blank lines and a quoted reply. */
+export const headLines = (source: string, sentenceEnds: readonly string[]): string[] => {
+  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);
+};
+
+/** A memo (TO: / 発信者：) or an official notice (課資2－7 / 各国税局長 殿) takes no greeting and no closing. */
+const takesNoFrame = (doc: ProseDocument, sentenceEnds: readonly string[]): boolean =>
+  isMemo(doc.source, patternsOf(doc, "memo-header-label"), sentenceEnds) ||
+  isNoticeHead(headLines(doc.source, sentenceEnds), noticeWordsOf(doc.lexicons["notice-header"] ?? []));
+
+const frameSlipsOf = (doc: ProseDocument): FrameSlip[] => {
+  const sentenceEnds = patternsOf(doc, "email-sentence-end");
+  if (takesNoFrame(doc, 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, signingLines(doc.source, doc.replyQuotes ?? []));
+};
+
 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 +259,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 +319,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 +356,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/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/fullwidth-alnum.ts

@@ -91,6 +91,14 @@ const otherWidth = (run: AlnumRun): string => (run.fullwidth ? run.written.norma
 
 type Located = { readonly sentence: Sentence; readonly run: AlnumRun };
 
+const HALFWIDTH_LOWER = /[a-z]/u;
+
+/**
+ * 小文字を含む半角の英字の語（AI for Science の for と Science）。英語の語は、略語を全角で書く文書（ＡＩ）でも半角で書く。
+ * 文書の英字の書き方の票には入れるが、少ないほうとしては指摘しない。
+ */
+const isHalfwidthEnglishWord = (run: AlnumRun): boolean => run.kind === "letters" && !run.fullwidth && HALFWIDTH_LOWER.test(run.written);
+
 const findingOf = ({ sentence, run }: Located, count: number, of: number, limit: number): Finding => ({
   rule: "",
   severity: "warning",
@@ -113,6 +121,6 @@ export const fullwidthAlnum: Detector = (doc, options): Finding[] => {
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter(({ run }) => run.kind === kind);
     const odd = minorityWithin(ofKind, ({ run }) => run.fullwidth, options.limit);
-    return odd.map((entry) => findingOf(entry, odd.length, ofKind.length, options.limit));
+    return odd.filter(({ run }) => !isHalfwidthEnglishWord(run)).map((entry) => findingOf(entry, odd.length, ofKind.length, options.limit));
   });
 };

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,50 @@
+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;
+
+/** 番号の印（（1）、(2)、3．、第4、⑤）。数の点の後ろに数字が続けば小数（3.14）。 */
+const ITEM_LABEL = String.raw`(?:[（(][\d０-９一二三四五六七八九十]{1,3}[）)]|[\d０-９]{1,3}[．.)）](?![\d０-９])|第[\d０-９一二三四五六七八九十]{1,3}|[①-⑳])`;
+/** 箇条書きの印（- 、1. ）。 */
+const LIST_MARKER = String.raw`(?:[-*+]|\d{1,3}[.)])[ \t]+`;
+const OPENS_WITH_LABEL = new RegExp(String.raw`^\s*${ITEM_LABEL}`, "u");
+const SENTENCE_END = /[。．.!?！？]\s*$/u;
+/** 行の頭か、箇条書きの印の後ろ。 */
+const LINE_START = new RegExp(String.raw`(?:^|\n)[ \t]*(?:${LIST_MARKER})?$`, "u");
+const LINE_START_REACH = 8;
+/**
+ * 行の終わりの後ろの、次の空でない行が本文であること。次の行も番号の印で始まれば、番号を振った項目の並び（（1）申請書を出す、
+ * （2）…）で、見出しではない。
+ */
+const FOLLOWED_BY_BODY = new RegExp(String.raw`^[ \t]*\n\s*(?!(?:${LIST_MARKER})?${ITEM_LABEL})\S`, "u");
+
+/**
+ * 行の頭の番号の印で始まり、句点で終わらず、一行を占め、後ろに本文が続く文（「（1）芸術の振興に係る規定に関する改正（第8条関係）」）。項目ごとの見出しで、
+ * 並べた見出しは同じ枠（…に係る規定に関する改正）を繰り返す。言い回しがどれもこの文にだけ出るなら見出しのひな形。
+ */
+export const itemTitles = (sentences: readonly Sentence[], source: string): Sentence[] =>
+  sentences.filter(
+    (sentence) =>
+      OPENS_WITH_LABEL.test(sentence.text) &&
+      !SENTENCE_END.test(sentence.text) &&
+      LINE_START.test(source.slice(Math.max(0, sentence.span.start - LINE_START_REACH), sentence.span.start)) &&
+      FOLLOWED_BY_BODY.test(source.slice(sentence.span.end, sentence.span.end + LOOKAHEAD)),
+  );
+
+/**
+ * 見出しのある節の最初の文のうち、次の行から箇条書きか表が続くもの。参照用の文書は、節ごとに同じ書き出しで一覧を導く
+ * （「…によると以下の制約である。」の後ろに制約の箇条書き）。言い回しがどれもこの文にだけ出るなら節のひな形で、書き手が言い直したのではない。
+ * 後ろが本文の文なら、節ごとの口癖（正直なところ、…）と見分けられないので入れない。導入部（見出しの前）は節ではない。
+ */
+const leadsIntoList = (section: Pick<Section, "depth" | "sentences">, source: string): Sentence[] => {
+  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] : [];
+};
+
+/** 節のひな形の文: 一覧を導く節の最初の文と、項目ごとの見出し（itemTitles）。 */
+export const sectionOpeners = (sections: readonly Pick<Section, "depth" | "sentences">[], source: string): Set<Sentence> =>
+  new Set(sections.flatMap((section) => [...leadsIntoList(section, source), ...itemTitles(section.sentences, source)]));

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)