chaffjs 0.34.0 → 0.36.0

package/src/detectors/char-shape.ts

@@ -1,9 +1,12 @@
-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 { trailingAddressee } from "./addressee-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 +19,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 +38,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 +48,103 @@ 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;
+  /** 数の後ろで日付・時刻の位置を言う単位（月）。連なりの頭にあれば、数に付いた助数詞。 */
+  readonly positional: readonly string[];
+  /** 宛先の名前に付く語（宛、御中）。連なりの尻にあれば、名前の後ろに付いた語。 */
+  readonly addressee: readonly string[];
+};
+
+/** 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] : []));
+
+/**
+ * 漢字の連なりが住所（東京都港区新橋二丁目）か 1 つの名前（日本銀行）か 1 つの組織の名前（国立研究開発法人産業技術総合研究所）か。
+ * 形態素解析の地名・人名・組織名と数、組織の語彙で決める。
+ */
+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日日本弁護士連合会の「日」）は数えない。
- * 住所か名前かは、助数詞を外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
+ * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）と、尻の、数に付く接頭の語（施行令第172条の「第」）と
+ * 宛先に付く語（市政情報課宛ての「宛」）は数えない。
+ * 住所か名前かは、それを外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
  */
-const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, topUnits: ReadonlySet<string>): string => {
+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 counter = leadingCounter(tokens, run.span.start, run.text, context.words.positional);
+  const prefix = trailingPrefix(tokens, run.span.end, run.text);
+  const tail =
+    prefix === undefined ? trailingAddressee(tokens, run.span.end, run.text, context.words.addressee) : { surface: prefix.surface, start: prefix.span.start };
+  const rest = { start: counter?.span.end ?? run.span.start, end: tail?.start ?? run.span.end };
+  const text = run.text.slice(counter?.surface.length ?? 0, run.text.length - (tail?.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"),
+      closingForms: (doc.lexicons["organisation-form"] ?? []).filter((entry) => entry.position !== "before").map((entry) => entry.pattern),
+      units: patterns("organisation-unit"),
+    },
+    title: { endings: patterns("title-ending") },
+    positional: patterns("calendar-unit"),
+    addressee: patterns("addressee-suffix"),
+  };
+  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",
@@ -89,10 +159,12 @@ export const kanjiRun: Detector = (doc, options): Finding[] => {
 /**
  * 中黒で並べると、どこまでが 1 つの項目か分からなくなる。
  * 「企画・開発・運用・保守体制」は、保守体制が 1 つなのか保守と体制なのか読めない。
+ * 語彙表（nakaguro-word）の、中黒を含めて 1 語の語（キャッシュ・フロー）の中黒は並べていないので数えない。
  */
-export const middleDot: Detector = (doc, options): Finding[] =>
-  doc.sentences
-    .map((sentence) => ({ sentence, count: parallelDotCount(sentence.text) }))
+export const middleDot: Detector = (doc, options): Finding[] => {
+  const words = (options.lexicon ?? []).map((entry) => entry.pattern).toSorted((left, right) => right.length - left.length);
+  return doc.sentences
+    .map((sentence) => ({ sentence, count: parallelDotCount(sentence.text, words) }))
     .filter(({ count }) => count > options.limit)
     .map(({ sentence, count }) => ({
       rule: "no-nakaguro-parallel",
@@ -102,3 +174,4 @@ export const middleDot: Detector = (doc, options): Finding[] =>
       quote: sentence.text.trim(),
       values: { count, limit: options.limit, offset: sentence.span.start },
     }));
+};

package/src/detectors/cited-title.ts

@@ -71,13 +71,24 @@ const VENUE_END = /^\s*(?:[,;.]|$)/u;
  */
 const holdsPhrase = (runs: Runs, start: number, end: number): boolean => firstIn(runs.phrasePair, { start: start + 1, end: end + 1 }) !== -1;
 
+const LETTER = /\p{L}/u;
+
+/** 語の続きのすぐ前が、題名を導く語（whose full title is、entitled）で終わるか。語の途中（retitled）からは読まない。 */
+const afterTitleCue = (source: string, first: Token, titleCues: readonly string[]): boolean => {
+  const before = source.slice(source.lastIndexOf("\n", first.span.start - 1) + 1, first.span.start);
+  if (before === before.trimEnd()) return false;
+  const lead = before.trimEnd().toLowerCase();
+  return titleCues.some((cue) => cue !== "" && lead.endsWith(cue.toLowerCase()) && !LETTER.test(lead.charAt(lead.length - cue.length - 1)));
+};
+
 /**
  * 文の and / or が、引用した題名の中にあるか。and / or の両隣が Title Case の語の続きで、2 語以上の句を含み、その続きが
- * 引用符か強調の印で囲まれているか、引用符で閉じた論文名のすぐ後ろにあって読点か文の終わりが続く（誌名）とき。
+ * 引用符か強調の印で囲まれているか、引用符で閉じた論文名のすぐ後ろにあって読点か文の終わりが続く（誌名）か、題名を導く語
+ * （titleCues: whose full title is、entitled）のすぐ後ろにあるとき。
  * 本文の固有名詞の並び（Login.gov, TTS Engineering and USAi）や著者の並びは囲まれていないので、題名と読まない。
  * 文を一度だけ読み、どの位置の問いにも続きを読み直さずに答える。
  */
-export const citedTitles = (tokens: readonly Token[], source: string): ((at: number) => boolean) => {
+export const citedTitles = (tokens: readonly Token[], source: string, titleCues: readonly string[] = []): ((at: number) => boolean) => {
   const runs = runsOf(tokens, source);
   return (at) => {
     const start = leftStart(runs, at);
@@ -88,7 +99,8 @@ export const citedTitles = (tokens: readonly Token[], source: string): ((at: num
     if (!holdsPhrase(runs, start, end)) return false;
     const before = source.slice(Math.max(0, first.span.start - MARK_REACH), first.span.start);
     const after = source.slice(last.span.end, last.span.end + MARK_REACH);
-    return (OPENING.test(before) && CLOSING.test(after)) || (AFTER_QUOTED_TITLE.test(before) && VENUE_END.test(after));
+    const quoted = (OPENING.test(before) && CLOSING.test(after)) || (AFTER_QUOTED_TITLE.test(before) && VENUE_END.test(after));
+    return quoted || afterTitleCue(source, first, titleCues);
   };
 };
 

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

@@ -16,14 +16,52 @@ const wordBefore = (tokens: readonly Token[], at: number): Token | undefined =>
   return beyond !== undefined && touches(beyond, previous) ? beyond : undefined;
 };
 
+const DIGITS = /^[0-9０-９]+$/u;
+
+/**
+ * 数と一語に解析された日付の単位（全角の「４月」）。連なりは単位から始まるので、単位の分だけの語にして返す。
+ * positional は数の後ろに置くだけで暦や時計の位置を言う単位（月、時）。
+ */
+const gluedUnit = (tokens: readonly Token[], start: number, run: string, positional: readonly string[]): Token | undefined => {
+  const token = tokens.find((candidate) => candidate.span.start < start && start < candidate.span.end);
+  if (token === undefined) return undefined;
+  const unit = positional.find((word) => token.surface.endsWith(word) && DIGITS.test(token.surface.slice(0, -word.length)));
+  return unit !== undefined && run.startsWith(unit) ? { ...token, surface: unit, span: { start, end: token.span.end } } : undefined;
+};
+
 /**
  * 漢字の連なり run（文書全体の座標で start から始まる）の頭が、直前の数に付いた助数詞（2日、第76回、24時間）なら、その助数詞の語。
  * 数字が区切りを見せるので、助数詞は数と読まれ、後ろの複合語の一部ではない。そうでなければ undefined。
+ * 解析が助数詞と言わない日付の単位（4月の「月」）も、positional にあれば助数詞と読む。
  * 折り返しをまたぐ語（年\n度）は span が surface より長いので、連なりの残りは span の終わりから始まる。
  */
-export const leadingCounter = (tokens: readonly Token[], start: number, run: string): Token | undefined => {
+export const leadingCounter = (tokens: readonly Token[], start: number, run: string, positional: readonly string[] = []): Token | undefined => {
   const at = tokens.findIndex((token) => token.span.start === start);
   const counter = tokens[at];
-  if (counter === undefined || !isCounter(counter) || !isNumber(wordBefore(tokens, at))) return undefined;
+  if (counter === undefined) return gluedUnit(tokens, start, run, positional);
+  if (!(isCounter(counter) || positional.includes(counter.surface)) || !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,15 @@ 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").
+ * `listed`: named in one list with the date, only list joiners between (祝休日及び12月29日, "public holidays and December 24").
  */
-export type MarkerReach = "sentence" | "adjacent" | "label";
+export type MarkerReach = "sentence" | "example" | "adjacent" | "near" | "label" | "continues" | "listed";
+
+export const MARKER_REACHES: readonly MarkerReach[] = ["sentence", "example", "adjacent", "near", "label", "continues", "listed"];
 
 export type AnyYearMarker = { readonly word: string; readonly reach: MarkerReach };
 
@@ -25,6 +30,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 +117,76 @@ 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);
 
-/** 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 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);
+};
+
+/** What is left of `gap` once the list joiners at its head and the spaces around them are taken off. */
+const afterJoiners = (gap: string, joiners: readonly string[]): string => {
+  const trimmed = gap.trimStart();
+  const joiner = joiners.find((candidate) => candidate !== "" && trimmed.startsWith(candidate) && !runsOn(trimmed, candidate));
+  return joiner === undefined ? trimmed : afterJoiners(trimmed.slice(joiner.length), joiners);
+};
+
+/** The word stands just before the date with only list joiners between: 「祝休日及び」, "holidays, and ". */
+const listedBefore = (before: string, word: string, joiners: readonly string[]): boolean => {
+  const found = lastWordAt(before, word);
+  if (found === -1) return false;
+  const gap = before.slice(found + word.length);
+  return gap.trim() !== "" && afterJoiners(gap, joiners) === "";
+};
+
+const coversDate = (before: string, dateStart: string, intro: string | undefined, word: string, reach: MarkerReach, joiners: readonly string[]): boolean => {
+  if (reach === "adjacent") return isAdjacent(latinLower(before), word);
+  if (reach === "listed") return listedBefore(latinLower(before), word, joiners);
+  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. `listJoiners` are the
+ * words a `listed` marker may stand before the date with (及び, "and").
+ */
+export const anyYearDate = (date: DateSpan, source: string, markers: readonly AnyYearMarker[], listJoiners: readonly string[] = []): 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 joiners = listJoiners.map(latinLower);
+  const covered = markers.some(({ word, reach }) => word !== "" && coversDate(before, source.charAt(date.offset), intro, latinLower(word), reach, joiners));
+  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-format.ts

@@ -22,7 +22,8 @@ export const dateFormat: Detector = (doc, options): Finding[] => {
     eras: (doc.lexicons["calendar-era"] ?? []).map((entry) => entry.pattern),
   };
   const text = doc.prose ?? doc.source;
-  return dateGroups(text, datesIn(text, words)).flatMap((group) => {
+  const stampLabels = (doc.lexicons["date-stamp-label"] ?? []).map((entry) => entry.pattern);
+  return dateGroups(text, datesIn(text, words), stampLabels).flatMap((group) => {
     const minority = dateMinority(group, options.limit);
     return minority === undefined ? [] : findingsOf(doc, minority);
   });

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));
+};