chaffjs 0.34.0 → 0.35.0

package/src/detectors/char-shape.ts

@@ -1,9 +1,11 @@
-import type { Detector, DocumentProfile, Finding, Sentence, Span, Token } from "../plugin.ts";
+import type { Detector, DocumentProfile, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { compacted } from "./gram-place.ts";
-import { leadingCounter } from "./counter-edge.ts";
+import { leadingCounter, trailingPrefix } from "./counter-edge.ts";
 import { maskAddresses } from "../address-chain.ts";
 import { isAddressRun } from "./place-run.ts";
 import { isOneName } from "./name-run.ts";
+import { isOrganisationRun, type OrganisationWords } from "./organisation-run.ts";
+import { endsInTitle, isTitlePosition, isTitledName, type TitleWords } from "./titled-run.ts";
 import { proseText } from "../measure.ts";
 import { parallelDotCount } from "./middle-dot.ts";
 import { maskSpans } from "../mask.ts";
@@ -16,11 +18,17 @@ import { nameSpans } from "../team-names.ts";
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-/** 漢字の連なりと、その文書全体の座標での範囲。quoted は鉤括弧の中身がまるごとこの連なりであること。 */
-type KanjiRun = { readonly text: string; readonly span: Span | undefined; readonly quoted: boolean };
+/**
+ * 漢字の連なりと、その文書全体の座標での範囲。quoted は括弧の中身がまるごとこの連なりであること。
+ * placed は、題の名前の置き方（括弧を閉じる、補いの括弧が続く、文がこれだけ）をしていること。
+ */
+type KanjiRun = { readonly text: string; readonly span: Span | undefined; readonly quoted: boolean; readonly placed: boolean };
 
 const SPACE = /\s/gu;
 
+/** 名前を囲む括弧。鉤括弧と、見出しや分類の名前を囲む隅付き括弧（【浪速区役所公募型比較見積】）。 */
+const NAME_MARKS = { "「": "」", "『": "』", "【": "】" };
+
 /**
  * 同じ連なりが文に二度出ても、それぞれの位置で読む。proseText は空白を詰めたり除いたりするだけなので、
  * 空白でない k 文字目は元の文でも空白でない k 文字目。番地の覆いは長さを保つので、proseText の位置がそのまま使える。
@@ -29,9 +37,9 @@ const SPACE = /\s/gu;
 const maskedProse = (prose: string, profile: DocumentProfile | undefined, names: readonly string[]): string =>
   maskSpans(maskAddresses(prose, profile), nameSpans(prose, names));
 
-/** 鉤括弧の中身が、ちょうどこの範囲（文の先頭からの位置）か。括弧でくくった漢字だけの語は、書き手が 1 つの名前として示したもの。 */
+/** 鉤括弧と隅付き括弧の中身が、ちょうどこの範囲（文の先頭からの位置）か。括弧でくくった漢字だけの語は、書き手が 1 つの名前として示したもの。 */
 const fillsQuote = (sentence: Sentence, start: number, end: number): boolean =>
-  quotedSpans(sentence.text).some((span) => span.start === start && span.end === end);
+  quotedSpans(sentence.text, NAME_MARKS).some((span) => span.start === start && span.end === end);
 
 const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names: readonly string[]): KanjiRun[] => {
   const prose = proseText(sentence);
@@ -39,42 +47,86 @@ const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names:
   return [...maskedProse(prose, profile, names).matchAll(KANJI_RUN)].map((match) => {
     const before = prose.slice(0, match.index).replace(SPACE, "").length;
     const [start, last] = [printed[before], printed[before + match[0].length - 1]];
-    if (start === undefined || last === undefined) return { text: match[0], span: undefined, quoted: false };
-    return { text: match[0], span: { start: sentence.span.start + start, end: sentence.span.start + last + 1 }, quoted: fillsQuote(sentence, start, last + 1) };
+    if (start === undefined || last === undefined) return { text: match[0], span: undefined, quoted: false, placed: false };
+    const span = { start: sentence.span.start + start, end: sentence.span.start + last + 1 };
+    return { text: match[0], span, quoted: fillsQuote(sentence, start, last + 1), placed: isTitlePosition(sentence.text, start, last + 1) };
   });
 };
 
-/** 漢字の連なりが住所（東京都港区新橋二丁目）か 1 つの名前（日本銀行）か。形態素解析の地名・人名・組織名と数で決める。 */
-const isPlaceName = (tokens: readonly Token[], span: Span, topUnits: ReadonlySet<string>): boolean => {
-  const covering = tokens.flatMap((token, index) => (token.span.start < span.end && span.start < token.span.end ? [index] : []));
-  return isAddressRun(tokens, covering, topUnits) || isOneName(tokens, covering);
+/** 連なりを数えないと決める語彙: 住所の先頭にしか来ない単位（都道府県）と、組織の名前の形と単位と、題の名前を閉じる語。 */
+type NameWords = { readonly topUnits: ReadonlySet<string>; readonly organisation: OrganisationWords; readonly title: TitleWords };
+
+/** 1 つの文書で連なりを読むのに要るもの。titled は、文書の中で題として置かれた名前（titledNames）。 */
+type RunContext = {
+  readonly profile: DocumentProfile | undefined;
+  readonly names: readonly string[];
+  readonly words: NameWords;
+  readonly titled: readonly string[];
 };
 
+const coveringOf = (tokens: readonly Token[], span: Span): number[] =>
+  tokens.flatMap((token, index) => (token.span.start < span.end && span.start < token.span.end ? [index] : []));
+
 /**
- * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）は数えない。
- * 住所か名前かは、助数詞を外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
+ * 漢字の連なりが住所（東京都港区新橋二丁目）か 1 つの名前（日本銀行）か 1 つの組織の名前（国立研究開発法人産業技術総合研究所）か。
+ * 形態素解析の地名・人名・組織名と数、組織の語彙で決める。
  */
-const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, topUnits: ReadonlySet<string>): string => {
+const isPlaceName = (tokens: readonly Token[], span: Span, words: NameWords): boolean => {
+  const covering = coveringOf(tokens, span);
+  return isAddressRun(tokens, covering, words.topUnits) || isOneName(tokens, covering) || isOrganisationRun(tokens, covering, words.organisation);
+};
+
+/** 題の名前（大阪市鶴見区役所公募型比較見積実施要綱）か。題を閉じる語で終わり、ここか文書のほかの所で題として置かれている。 */
+const isTitle = (tokens: readonly Token[], span: Span, text: string, placed: boolean, context: RunContext): boolean =>
+  endsInTitle(
+    coveringOf(tokens, span).flatMap((index) => tokens.slice(index, index + 1)),
+    context.words.title,
+  ) &&
+  (placed || isTitledName(text, context.titled));
+
+/**
+ * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）と、尻の、数に付く接頭の語（施行令第172条の「第」）は数えない。
+ * 住所か名前かは、それを外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
+ */
+const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, context: RunContext): string => {
   if (run.quoted) return "";
   if (tokens === undefined || run.span === undefined) return run.text;
   const counter = leadingCounter(tokens, run.span.start, run.text);
-  const rest = counter === undefined ? run.span : { start: counter.span.end, end: run.span.end };
-  return isPlaceName(tokens, rest, topUnits) ? "" : run.text.slice(counter?.surface.length ?? 0);
+  const prefix = trailingPrefix(tokens, run.span.end, run.text);
+  const rest = { start: counter?.span.end ?? run.span.start, end: prefix?.span.start ?? run.span.end };
+  const text = run.text.slice(counter?.surface.length ?? 0, run.text.length - (prefix?.surface.length ?? 0));
+  return isPlaceName(tokens, rest, context.words) || isTitle(tokens, rest, text, run.placed, context) ? "" : text;
 };
 
-const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>, names: readonly string[]): string =>
-  runsOf(sentence, profile, names)
-    .map((run) => measuredRun(sentence.tokens, run, topUnits))
+const longestKanji = (sentence: Sentence, context: RunContext): string =>
+  runsOf(sentence, context.profile, context.names)
+    .map((run) => measuredRun(sentence.tokens, run, context))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
+/**
+ * 文書の中で題として置かれた漢字の連なり: 題の置き方をした文の中の連なりと、見出しの中の連なり。
+ * 同じ名前を文の中で使えば（認定職業訓練実施奨励金の支給額）、それも題の名前と読む。
+ */
+const titledNames = (doc: ProseDocument, profile: DocumentProfile | undefined, names: readonly string[]): string[] => [
+  ...doc.sentences.flatMap((sentence) => runsOf(sentence, profile, names).flatMap((run) => (run.placed ? [run.text] : []))),
+  ...(doc.markup?.headings ?? []).flatMap((heading) => [...heading.text.matchAll(KANJI_RUN)].map((match) => match[0])),
+];
+
 /**
  * 漢字が続くと、どこで語が切れるのか読み手が探すことになる。
  * 「情報処理推進機構認定試験」は 12 字。ひらがなを 1 つ挟むだけで読める。
  */
 export const kanjiRun: Detector = (doc, options): Finding[] => {
-  const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
+  const patterns = (id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+  const words: NameWords = {
+    topUnits: new Set(patterns("prefecture-unit")),
+    organisation: { forms: patterns("organisation-form"), units: patterns("organisation-unit") },
+    title: { endings: patterns("title-ending") },
+  };
+  const names = doc.names ?? [];
+  const context: RunContext = { profile: doc.profile, names, words, titled: titledNames(doc, doc.profile, names) };
   return doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits, doc.names ?? []) }))
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, context) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",

package/src/detectors/clause-shape.ts

@@ -1,5 +1,6 @@
 import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Token } from "../plugin.ts";
 import { isWithinAny, quotedIn } from "../quoted-span.ts";
+import { definitionWordsOf, isParallelDefinition } from "./parallel-definition.ts";
 
 // The shape of a clause read from its words: how it ends, a paired word left alone, an adverb that needs a
 // negation, a particle used where another one belongs. Every word comes from a lexicon; this file knows parts of speech.
@@ -74,13 +75,22 @@ const runFinding = (run: readonly Ended[], limit: number): Finding => {
   };
 };
 
-/** More than limit sentences in a row within one paragraph that end with the same words. */
-export const endingRun: Detector = (doc, options): Finding[] =>
-  doc.paragraphs.flatMap((paragraph) =>
+/** More than limit sentences in a row within one paragraph that end with the same words, unless they define different terms in one frame. */
+export const endingRun: Detector = (doc, options): Finding[] => {
+  const words = definitionWordsOf(options.lexicon);
+  return doc.paragraphs.flatMap((paragraph) =>
     endingRuns(paragraph.sentences)
-      .filter((run) => run.length > options.limit)
+      .filter(
+        (run) =>
+          run.length > options.limit &&
+          !isParallelDefinition(
+            run.map(({ sentence }) => sentence),
+            words,
+          ),
+      )
       .map((run) => runFinding(run, options.limit)),
   );
+};
 
 // --- unpaired-parallel: a word that lists by pairs (〜たり) used once, followed by another clause -----------------
 

package/src/detectors/concrete-evidence.ts

@@ -1,5 +1,6 @@
-import type { Span, StructureKind, StructureNode, Token } from "../plugin.ts";
+import type { Sentence, Span, StructureKind, StructureNode, Token } from "../plugin.ts";
 import { preOrder } from "../tree-walk.ts";
+import { isStatement } from "./technical-docs.ts";
 
 /**
  * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
@@ -30,3 +31,78 @@ const EVIDENCE: ReadonlySet<StructureKind> = new Set(["reference", "quantity", "
 
 export const evidenceSpans = (root: StructureNode | undefined): Span[] =>
   root === undefined ? [] : preOrder(root).flatMap((node) => (EVIDENCE.has(node.kind) ? [node.span] : []));
+
+/** 読み手にすることを伝える言い方。英語は文の書き出し（Never use, Please submit）、日本語は文末（〜ください、〜しましょう）。 */
+export type AdviceWords = { readonly openers: readonly string[]; readonly endings: readonly string[] };
+
+const CLOSERS = new Set(Array.from("\"'”’」』）)】〕〉》］]"));
+const TERMINALS = new Set(Array.from("。．.!！"));
+const QUESTION_MARKS = new Set(["?", "？"]);
+const SKIPPED = new Set(["PUNCT", "SYM", "X", "SPACE"]);
+
+/** 文末から、閉じ括弧・引用符（と、渡されれば句点）を外した残り。 */
+const withoutTail = (text: string, tail: ReadonlySet<string>): string => {
+  const chars = Array.from(text.trimEnd());
+  const last = chars.findLastIndex((char) => !tail.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+const isQuestion = (text: string): boolean => QUESTION_MARKS.has(Array.from(withoutTail(text, CLOSERS)).at(-1) ?? "");
+
+const opensWith = (text: string, openers: readonly string[]): boolean => {
+  const lower = text.trimStart().toLowerCase();
+  return openers.some((opener) => lower.startsWith(`${opener} `));
+};
+
+const endsWith = (text: string, endings: readonly string[]): boolean => {
+  const body = withoutTail(text, new Set([...CLOSERS, ...TERMINALS]));
+  return endings.some((ending) => body.endsWith(ending));
+};
+
+/** 項目の番号（a, 12, iv）。 */
+const ENUMERATOR = /^(?:\p{L}|\p{Nd}{1,3}|[ivx]{1,4})$/iu;
+const BRACKETED = /^[(（](.+)[)）]$/u;
+const MARKED = /^(.+)[.)）．]$/u;
+
+/** 項目の番号だけが文として切り出されたもの（a. や (1)）。述べることも問うことも無い。 */
+export const isLabelOnly = (sentence: Pick<Sentence, "text">): boolean => {
+  const text = sentence.text.trim();
+  const core = BRACKETED.exec(text)?.[1] ?? MARKED.exec(text)?.[1];
+  return core !== undefined && ENUMERATOR.test(core);
+};
+
+/** 動詞の目的語の書き出し（Use a generator, Review our benefits）。名詞と読まれた語の後ろにこれが来れば、その語は動詞。 */
+const OBJECT_OPENER = new Set(["DET", "PRON"]);
+
+/**
+ * 原形の動詞（Keep, Take）。解析器が名詞と読んだ、動詞にもなる語も、目的語が続けば同じ（Use a generator）。
+ * 後ろが名詞や前置詞なら名詞句の頭（evidence of complexity, trust development plans）。
+ */
+const isBaseVerb = (token: Token, next: Token | undefined): boolean =>
+  (token.pos === "VERB" && token.lemma?.toLowerCase() === token.surface.toLowerCase() && token.features?.["VerbForm"] === undefined) ||
+  (token.pos === "NOUN" && token.features?.["AlsoVerb"] === "Yes" && token.features["Number"] !== "Plur" && OBJECT_OPENER.has(next?.pos ?? ""));
+
+/** 頭の語が一語として立っている。空白を置かずに続けば、語の一部（Cloud.gov の Cloud）。 */
+const standsAlone = (tokens: readonly Token[], head: Token): boolean => {
+  const after = tokens[tokens.indexOf(head) + 1];
+  return after === undefined || after.span.start > head.span.end || after === tokens.at(-1) || after.surface === ",";
+};
+
+/**
+ * 動詞で始まる英語の文（Keep freezers closed）は指示。すぐ後ろがコロンなら見出し語（Release: none）で、主語のある文は述べる文。
+ * 日本語は動詞が文末に来るので、品詞では読まない。
+ */
+const opensWithVerb = (tokens: readonly Token[], language: string): boolean => {
+  const [head, next] = tokens.filter((token) => !SKIPPED.has(token.pos) || token.surface === ":");
+  return language === "en" && head !== undefined && isBaseVerb(head, next) && standsAlone(tokens, head) && next?.surface !== ":" && !isStatement(tokens);
+};
+
+/**
+ * 読み手が裏づけを求められることを述べた文。問い（情報提供の依頼に並ぶ質問）と指示（安全の手引き）は主張ではなく、
+ * 数字が欠けているとは言えない。
+ */
+export const isClaim = (sentence: Pick<Sentence, "text" | "tokens">, language: string, words: AdviceWords): boolean =>
+  !isQuestion(sentence.text) &&
+  !opensWith(sentence.text, words.openers) &&
+  !endsWith(sentence.text, words.endings) &&
+  !opensWithVerb(sentence.tokens ?? [], language);

package/src/detectors/contraction-minority.ts

@@ -0,0 +1,11 @@
+/** 1 つの対（「don't」と「do not」）が、文書の中でそれぞれ何回出てくるか。 */
+export type PairUses = { readonly short: number; readonly long: number };
+
+/**
+ * その対で少ないほうの書きかた。"short" なら短縮形、"long" なら長い形、少数派が無ければ undefined。
+ * 片方しか出てこない対は揃っている。両方が同じ回数なら、どちらを指しても当て推量になる。
+ */
+export const pairMinority = (uses: PairUses): "short" | "long" | undefined => {
+  if (uses.short === 0 || uses.long === 0 || uses.short === uses.long) return undefined;
+  return uses.short < uses.long ? "short" : "long";
+};

package/src/detectors/counter-edge.ts

@@ -27,3 +27,26 @@ export const leadingCounter = (tokens: readonly Token[], start: number, run: str
   if (counter === undefined || !isCounter(counter) || !isNumber(wordBefore(tokens, at))) return undefined;
   return run.startsWith(counter.surface) ? counter : undefined;
 };
+
+const isPrefix = (token: Token | undefined): boolean => token?.pos === "ADJ" && token.features?.["Bound"] === "Yes";
+
+/** at の語のすぐ後ろの語。空白一つ（改行を含む）を挟んでもよい（「第\n172条」）。 */
+const wordAfter = (tokens: readonly Token[], at: number): Token | undefined => {
+  const [token, next] = [tokens[at], tokens[at + 1]];
+  if (token === undefined || next === undefined || !touches(token, next)) return undefined;
+  if (!BLANK.test(next.surface)) return next;
+  const beyond = tokens[at + 2];
+  return beyond !== undefined && touches(next, beyond) ? beyond : undefined;
+};
+
+/**
+ * 漢字の連なり run（文書全体の座標で end に終わる）の尻が、すぐ後ろの数に付く接頭の語（地方自治法施行令第172条の「第」）なら、その語。
+ * 接頭の語は後ろの数の一部で、前の複合語の一部ではない。そうでなければ undefined。
+ */
+export const trailingPrefix = (tokens: readonly Token[], end: number, run: string): Token | undefined => {
+  // 折り返しをまたぐ語は span が surface より長いので、end で終わる語ではなく end の直前の字を覆う語を探す。
+  const at = tokens.findIndex((token) => token.span.start < end && end <= token.span.end);
+  const prefix = tokens[at];
+  if (prefix === undefined || !isPrefix(prefix) || !isNumber(wordAfter(tokens, at))) return undefined;
+  return run.endsWith(prefix.surface) ? prefix : undefined;
+};

package/src/detectors/date-any-year.ts

@@ -9,10 +9,14 @@ export const YEAR_SPAN_JOINER_LEXICON = "year-span-joiner";
 
 /**
  * Where a marker reaches. `sentence`: earlier in the date's sentence, not closed off by a bracket (例えば…4月1日), or the
- * line a list of dates hangs from ("for example:"). `adjacent`: just before the date ("each December 31"). `label`: before
- * the bracket the date is in (年末年始閉庁日（12月29日～1月3日）).
+ * line a list of dates hangs from ("for example:"). `example`: as `sentence`, and on to the end of the list item it is in.
+ * `adjacent`: just before the date ("each December 31"). `near`: ending a few characters before it (決算日は、12月31日).
+ * `label`: before the bracket the date is in (年末年始閉庁日（12月29日～1月3日）). `continues`: opening a list item just
+ * after an example's item, it carries the example on ("- For example, … June 22." then "- If instead … June 25").
  */
-export type MarkerReach = "sentence" | "adjacent" | "label";
+export type MarkerReach = "sentence" | "example" | "adjacent" | "near" | "label" | "continues";
+
+export const MARKER_REACHES: readonly MarkerReach[] = ["sentence", "example", "adjacent", "near", "label", "continues"];
 
 export type AnyYearMarker = { readonly word: string; readonly reach: MarkerReach };
 
@@ -25,6 +29,9 @@ const SPAN_GAP_REACH = 12;
 /** How many lines above a list item its introducing line is looked for: a longer list is read as no example. */
 const LIST_REACH = 64;
 
+/** How many characters a `near` marker may end before the date: 「は、」 of 「決算日は、」, " is " of "fiscal year end is". */
+const NEAR_REACH = 4;
+
 /** The end of a sentence: 。, a line break, or a full stop before a capital or a digit ("Mar 3. The", "so. 10 November"). */
 const SENTENCE_END = /[。！？\n]|[.!?]["'”’)\]]*\s+(?=[A-Z0-9])/u;
 const OPENERS = "(（「『[【〔";
@@ -109,17 +116,56 @@ const introOf = (source: string, before: string, offset: number): string | undef
 /** The line ends with the marker, before or after its colon: 「例：」 and "for example:" alike. */
 const introEndsWith = (intro: string, word: string): boolean => isAdjacent(intro, word) || isAdjacent(intro.replace(COLON_END, ""), word);
 
+const wordsOf = (markers: readonly AnyYearMarker[], reach: MarkerReach): string[] =>
+  markers.flatMap((marker) => (marker.reach === reach && marker.word !== "" ? [latinLower(marker.word)] : []));
+
+/** A list item's text after its bullet: "If instead …" of "    - If instead …". */
+const itemText = (line: string): string => line.replace(LIST_ITEM, "");
+
+const indentOf = (line: string): number => line.length - line.trimStart().length;
+
+/** The line just above the one at `offset`, when it is a list item at the same depth (no blank line between). */
+const itemAbove = (source: string, offset: number): string | undefined => {
+  const start = lineStart(source, offset);
+  if (start === 0) return undefined;
+  const above = source.slice(lineStart(source, start - 1), start - 1);
+  return LIST_ITEM.test(above) && indentOf(above) === indentOf(source.slice(start, offset)) ? above : undefined;
+};
+
+const opensWith = (text: string, word: string): boolean => text.startsWith(word) && !runsOn(text, word);
+
+const opensWithAny = (line: string, words: readonly string[]): boolean => words.some((word) => opensWith(latinLower(itemText(line)), word));
+
+/** `item` holds an example, or carries one on from the item above it; `steps` bounds how far up the chain is followed. */
+const exampleItem = (source: string, item: string, itemEnd: number, markers: readonly AnyYearMarker[], steps: number): boolean => {
+  if (wordsOf(markers, "example").some((word) => lastWordAt(latinLower(item), word) !== -1)) return true;
+  if (steps === 0 || !opensWithAny(item, wordsOf(markers, "continues"))) return false;
+  const above = itemAbove(source, itemEnd);
+  return above !== undefined && exampleItem(source, above, lineStart(source, itemEnd) - 1, markers, steps - 1);
+};
+
+/** The date's list item opens with a word that carries on the example in the list item just above it. */
+const continuesExample = (date: DateSpan, before: string, source: string, markers: readonly AnyYearMarker[]): boolean => {
+  if (!LIST_ITEM.test(before) || !opensWithAny(before, wordsOf(markers, "continues"))) return false;
+  const above = itemAbove(source, date.offset);
+  return above !== undefined && exampleItem(source, above, lineStart(source, date.offset) - 1, markers, LIST_REACH);
+};
+
+const coversDate = (before: string, dateStart: string, intro: string | undefined, word: string, reach: MarkerReach): boolean => {
+  if (reach === "adjacent") return isAdjacent(latinLower(before), word);
+  if (reach === "near") return lastWordAt(latinLower(before.slice(-(word.length + NEAR_REACH))), word) !== -1;
+  if (reach === "label") return latinLower(labelOf(before) ?? "").includes(word);
+  if (reach === "continues") return false;
+  const inItem = reach === "example" && LIST_ITEM.test(before) && lastWordAt(latinLower(before), word) !== -1;
+  return inItem || inSentence(before, dateStart, word) || (intro !== undefined && introEndsWith(latinLower(intro), word));
+};
+
 /** The date is a recurring day or a worked example: a marker stands where its reach covers the date. */
 export const anyYearDate = (date: DateSpan, source: string, markers: readonly AnyYearMarker[]): boolean => {
   const before = source.slice(lineStart(source, date.offset), date.offset);
   const intro = introOf(source, before, date.offset);
-  return markers.some(({ word: written, reach }) => {
-    const word = latinLower(written);
-    if (word === "") return false;
-    if (reach === "adjacent") return isAdjacent(latinLower(before), word);
-    if (reach === "label") return latinLower(labelOf(before) ?? "").includes(word);
-    return inSentence(before, source.charAt(date.offset), word) || (intro !== undefined && introEndsWith(latinLower(intro), word));
-  });
+  const covered = markers.some(({ word, reach }) => word !== "" && coversDate(before, source.charAt(date.offset), intro, latinLower(word), reach));
+  return covered || continuesExample(date, before, source, markers);
 };
 
 /** The date opens a period whose other end, just after it, follows a joiner (「4月1日から翌年3月31日」). */

package/src/detectors/date-heading-year.ts

@@ -0,0 +1,55 @@
+// The year a section's heading gives the dates under it: "FY27-Q2 (May 1)", 「2026年度の予定」, 「令和8年の行事」. A yearless
+// date in such a section has its year. Pure.
+import type { StructureNode } from "../plugin.ts";
+
+/** A fiscal-year name with its year as a number: "FY{y}" of the language's reporting-period-frame lexicon. */
+export type YearLabel = { readonly before: string; readonly after: string };
+
+/** The words that name a year in a heading: era names (令和) and fiscal-year labels ("FY{y}"). */
+export type HeadingYearWords = { readonly eras: readonly string[]; readonly labels: readonly YearLabel[] };
+
+/** A year written as figures: 2024年度, "2024 events". */
+const YEAR_FIGURES = /(?<![0-9０-９])(?:1[89]|20)\d{2}(?![0-9０-９])/u;
+/** An era's year after its name: 8年 of 令和8年, 元年 of 令和元年度 (not 8月). */
+const ERA_YEAR_NUMBER = /^[ \t]?(?:[0-9０-９]{1,2}|元)[ \t]?年/u;
+/** A fiscal year's number: two figures (FY27) or four (FY2027). */
+const LABEL_YEAR = /^(?:\d{2}|\d{4})(?!\d)/u;
+const LETTER = /\p{L}/u;
+
+/** "FY{y}" as the lexicon writes it: the words before and after the year. A name with no {y} names no year. */
+export const yearLabelOf = (pattern: string): YearLabel | undefined => {
+  const at = pattern.indexOf("{y}");
+  return at === -1 || pattern.includes("{", at + 1) ? undefined : { before: pattern.slice(0, at).toLowerCase(), after: pattern.slice(at + 3).toLowerCase() };
+};
+
+const startsAt = (text: string, index: number): boolean => index === 0 || !LETTER.test(text.charAt(index - 1));
+
+const indicesOf = (text: string, word: string, from = 0): number[] => {
+  const at = word === "" ? -1 : text.indexOf(word, from);
+  return at === -1 ? [] : [at, ...indicesOf(text, word, at + 1)];
+};
+
+const namesLabelYear = (heading: string, label: YearLabel): boolean => {
+  const text = heading.toLowerCase();
+  return indicesOf(text, label.before).some((at) => {
+    if (!startsAt(text, at)) return false;
+    const year = LABEL_YEAR.exec(text.slice(at + label.before.length))?.[0];
+    return year !== undefined && text.startsWith(label.after, at + label.before.length + year.length);
+  });
+};
+
+const namesEraYear = (heading: string, era: string): boolean => indicesOf(heading, era).some((at) => ERA_YEAR_NUMBER.test(heading.slice(at + era.length)));
+
+/** The heading names a year: figures (2026年度), an era's year (令和8年), or a fiscal year (FY27). */
+export const headingNamesYear = (heading: string, words: HeadingYearWords): boolean =>
+  YEAR_FIGURES.test(heading) || words.eras.some((era) => namesEraYear(heading, era)) || words.labels.some((label) => namesLabelYear(heading, label));
+
+const sectionHeading = (node: StructureNode, current: string): string =>
+  node.kind === "section" && node.attrs["heading"] !== undefined ? String(node.attrs["heading"]) : current;
+
+/** The offsets of the dates whose own section, the innermost one they are in, has a heading that names a year. */
+export const datesUnderYearHeadings = (tree: StructureNode, words: HeadingYearWords, heading = ""): number[] => {
+  const own = sectionHeading(tree, heading);
+  if (tree.kind === "date") return headingNamesYear(own, words) ? [tree.span.start] : [];
+  return tree.children.flatMap((child) => datesUnderYearHeadings(child, words, own));
+};

package/src/detectors/date-year.ts

@@ -3,15 +3,27 @@
 import type { Detector, Finding, LexiconEntry, ProseDocument, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { quoteAt } from "./structure-tree.ts";
-import { ANY_YEAR_MARKER_LEXICON, YEAR_SPAN_JOINER_LEXICON, anyYearDate, opensSpan, type AnyYearMarker, type MarkerReach } from "./date-any-year.ts";
+import {
+  ANY_YEAR_MARKER_LEXICON,
+  MARKER_REACHES,
+  YEAR_SPAN_JOINER_LEXICON,
+  anyYearDate,
+  opensSpan,
+  type AnyYearMarker,
+  type MarkerReach,
+} from "./date-any-year.ts";
+import { datesUnderYearHeadings, yearLabelOf, type HeadingYearWords } from "./date-heading-year.ts";
 
 /** The words that make a yearless date any year's (毎年, 例えば, "each") and that join a period's two ends (から, "to"). */
 export type AnyYearWords = { readonly markers: readonly AnyYearMarker[]; readonly joiners: readonly string[] };
 
 const NO_ANY_YEAR_WORDS: AnyYearWords = { markers: [], joiners: [] };
 
-/** A date as the tree reads it: "2026-10-14" with its year, "10-14" without. */
-export type DatePoint = { readonly offset: number; readonly end: number; readonly value: string };
+/**
+ * A date as the tree reads it: "2026-10-14" with its year, "10-14" without. `yearHeaded`: the heading of its section
+ * names a year ("FY27-Q2 (May 1)", 「2026年度の予定」), which the date takes.
+ */
+export type DatePoint = { readonly offset: number; readonly end: number; readonly value: string; readonly yearHeaded?: boolean };
 
 /** The first and the last year of the document's dated dates. */
 export type YearSpan = { readonly from: number; readonly to: number };
@@ -106,9 +118,23 @@ const hasYearWord = (point: DatePoint, source: string, yearWords: readonly YearW
  */
 const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: string, yearWords: readonly YearWord[]): boolean => {
   const start = lineStart(source, point.offset);
-  return hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
+  return point.yearHeaded === true || hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
 };
 
+const DAY_MS = 24 * 60 * 60 * 1000;
+const COMMON_YEAR_MS = 365 * DAY_MS;
+/** A year with no 29 February, so that "03-01" follows "02-28" as it does in most years. */
+const COMMON_YEAR = 2025;
+
+const dayOf = (value: string): number => Date.UTC(COMMON_YEAR, Number(value.slice(0, 2)) - 1, Number(value.slice(3, 5)));
+
+/**
+ * A period of one whole year: its end is the day before its start (January 1 to December 31, 4月1日から3月31日). Without
+ * a year it is every year's, like a calendar or a fiscal year.
+ */
+export const wholeYear = (start: string, end: string): boolean =>
+  MONTH_DAY.test(start) && MONTH_DAY.test(end) && (dayOf(end) + DAY_MS - dayOf(start)) % COMMON_YEAR_MS === 0;
+
 /**
  * The yearless dates whose year the reader cannot tell. Where most dates carry a year (at least two, and more than the
  * yearless ones) and those years differ, every yearless one is reported: in a one-year document the year is plain. Where
@@ -124,9 +150,13 @@ export const yearGaps = (
   const dated = points.filter((point) => FULL.test(point.value));
   const anchors = [...dated, ...points.filter((point) => hasYearWord(point, source, yearWords))];
   const nextOf = new Map(points.map((point, index) => [point, points[index + 1]]));
+  const previousOf = new Map(points.map((point, index) => [point, points[index - 1]]));
+  const yearlySpan = (start: DatePoint | undefined, end: DatePoint | undefined): boolean =>
+    start !== undefined && end !== undefined && wholeYear(start.value, end.value) && opensSpan(start, end, source, anyYear.joiners);
   const yearOfAny = (point: DatePoint): boolean => {
     const next = nextOf.get(point);
     if (anyYearDate(point, source, anyYear.markers)) return true;
+    if (yearlySpan(point, next) || yearlySpan(previousOf.get(point), point)) return true;
     return next !== undefined && opensSpan(point, next, source, anyYear.joiners) && hasYearWord(next, source, yearWords);
   };
   // A recurring day or an example's date has no year to write, and is not the document's way of writing dates either.
@@ -134,20 +164,35 @@ export const yearGaps = (
   const span = spanOf(dated);
   const unclear = dated.length >= 2 && yearless.length < dated.length && span !== undefined && span.to > span.from;
   const datedSides = new Set(dated.flatMap((point) => sideOf(monthOf(FULL, point.value)) ?? []));
-  const previousOf = new Map(points.map((point, index) => [point, points[index - 1]]));
   return yearless.flatMap((point): YearGap[] => {
     if (unclear) return [{ point, kind: "years", span }];
     return crossesYear(point, previousOf.get(point), datedSides) ? [{ point, kind: "boundary", span }] : [];
   });
 };
 
-export const datePoints = (tree: StructureNode): DatePoint[] =>
-  inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : []));
+const NO_HEADING_YEAR_WORDS: HeadingYearWords = { eras: [], labels: [] };
+
+export const datePoints = (tree: StructureNode, headingWords: HeadingYearWords = NO_HEADING_YEAR_WORDS): DatePoint[] => {
+  const yearHeaded = new Set(datesUnderYearHeadings(tree, headingWords));
+  return inDocumentOrder(tree).flatMap((node) =>
+    node.kind === "date"
+      ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]), yearHeaded: yearHeaded.has(node.span.start) }]
+      : [],
+  );
+};
 
 const yearWordsOf = (doc: ProseDocument): YearWord[] =>
   (doc.lexicons[YEAR_REFERENCE_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, position: entry.position }));
 
-const reachOf = (group: string | undefined): MarkerReach => (group === "adjacent" || group === "label" ? group : "sentence");
+/** The era names (calendar-era) and the fiscal-year names ("FY{y}" of reporting-period-frame) a heading may give a year with. */
+const headingYearWordsOf = (doc: ProseDocument): HeadingYearWords => ({
+  eras: (doc.lexicons["calendar-era"] ?? []).map((entry: LexiconEntry) => entry.pattern),
+  labels: (doc.lexicons["reporting-period-frame"] ?? []).flatMap((entry: LexiconEntry) =>
+    entry.group === "fiscal-year" ? (yearLabelOf(entry.pattern) ?? []) : [],
+  ),
+});
+
+const reachOf = (group: string | undefined): MarkerReach => MARKER_REACHES.find((reach) => reach === group) ?? "sentence";
 
 const anyYearWordsOf = (doc: ProseDocument): AnyYearWords => ({
   markers: (doc.lexicons[ANY_YEAR_MARKER_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, reach: reachOf(entry.group) })),
@@ -157,7 +202,7 @@ const anyYearWordsOf = (doc: ProseDocument): AnyYearWords => ({
 export const dateWithoutYear: Detector = (doc: ProseDocument): Finding[] =>
   doc.structure === undefined
     ? []
-    : yearGaps(datePoints(doc.structure), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
+    : yearGaps(datePoints(doc.structure, headingYearWordsOf(doc)), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
         rule: "date-without-year",
         severity: "warning",
         line: 0,

package/src/detectors/defined-term-form.ts

@@ -199,11 +199,31 @@ const MIN_NAME_CHARS = 4;
 /** In English a long name has two words or more (Acme Corporation); one capitalised word is the term's own kind of word. */
 const MIN_NAME_WORDS = 2;
 const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const JAPANESE = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]/u;
 
 const isNamePart = (token: Token): boolean => NAME_PARTS.has(token.pos) || NAME_MARKS.has(token.surface);
 
+/**
+ * A label for each of several things or for all of them together ((each, a "Certificate"), (collectively, the "Plans"))
+ * names the head of the clause before it (a certificate that represented any share of Common Stock), not its last words.
+ */
+const LABELS_THE_CLAUSE = /^[(（](?:each|collectively)\b/iu;
+
+/**
+ * Whether the words make a long name. In English, two words with letters, one of them capitalised: a figure is not a word
+ * of a name (as amended on January 26, 2015 (the "Indenture"), a par value of $1.00 (the "Preference Stock")), and lower-case
+ * words (with respect thereto) are used in their own sense. A name with Japanese in it (株式会社ABC), four characters or more.
+ */
+const isLongName = (name: string): boolean => {
+  const words = name.split(/\s+/u).filter((word) => LETTER.test(word));
+  if (words.length === 0 || [...name].length < MIN_NAME_CHARS) return false;
+  return !LATIN.test(name) || JAPANESE.test(name) || (words.length >= MIN_NAME_WORDS && words.some((word) => UPPER_START.test(word)));
+};
+
 /** The long name written right before an inline definition: the run of name words that ends at its opening bracket. */
 export const nameBefore = (sentence: Sentence, bracket: number): string | undefined => {
+  if (LABELS_THE_CLAUSE.test(sentence.text.slice(bracket - sentence.span.start))) return undefined;
   const tokens = (sentence.tokens ?? []).filter((token) => token.span.end <= bracket);
   const firstOfRun = tokens.findLastIndex((token) => !isNamePart(token)) + 1;
   if (isModifier(tokens[firstOfRun - 1])) return undefined;
@@ -212,16 +232,17 @@ export const nameBefore = (sentence: Sentence, bracket: number): string | undefi
   const end = run.at(-1);
   if (first === undefined || end === undefined || bracket - end.span.end > 1) return undefined;
   const name = withoutTrailingMarks(sentence.text.slice(first.span.start - sentence.span.start, end.span.end - sentence.span.start));
-  const words = name.split(/\s+/u).length;
-  return [...name].length < MIN_NAME_CHARS || (LATIN.test(name) && words < MIN_NAME_WORDS) ? undefined : name;
+  return isLongName(name) ? name : undefined;
 };
 
 /**
- * A word that narrows the name before it: an article, an adjective, a verb, or の (妊娠中の女性従業員, the Beta Preview, 本利用規約).
- * The words then name a kind of thing the definition picks out, not one party, and are used in their own sense again.
+ * A word that narrows the name before it: an article, an adjective, a verb, or a possessive (妊娠中の女性従業員, the Beta
+ * Preview, 本利用規約, users of Customer's Web site). The words then name a kind of thing the definition picks out, not one
+ * party, and are used in their own sense again.
  */
 const MODIFIERS = new Set(["DET", "ADJ", "VERB", "AUX"]);
-const isModifier = (token: Token | undefined): boolean => token !== undefined && (MODIFIERS.has(token.pos) || token.surface === "の");
+const POSSESSIVES = new Set(["の", "'s", "’s", "'", "’"]);
+const isModifier = (token: Token | undefined): boolean => token !== undefined && (MODIFIERS.has(token.pos) || POSSESSIVES.has(token.surface));
 
 const TRAILING_MARKS = new Set([",", ".", " "]);