chaffjs 0.13.0 → 0.14.0

package/src/detectors/conjugated-form.ts

@@ -0,0 +1,40 @@
+import type { Sentence, Token } from "../plugin.ts";
+
+/**
+ * 語彙表が原形で書いた語句（という、と呼ぶ）が、文の中で活用して書かれた形（といいます、と呼びました）。
+ * 語句の最後の動詞を原形（lemma）で照らし、その前の部分は字面で照らす。語句を語に分けて並びで照らさないのは、
+ * 解析器が単独の「という」を 1 つの助詞に、「といいます」を と・いい・ます に分け、「称し」の原形を 称す とするから。
+ * 活用した形は、動詞に続く助動詞（ます、た）まで。品詞が無い文からは何も出ない。
+ */
+
+type Run = { readonly start: number; readonly end: number };
+
+/** 動詞と、そのすぐ後ろに続く助動詞の、文の中の範囲。 */
+const inflectedRun = (sentence: Sentence, tokens: readonly Token[], index: number, verb: Token): Run => {
+  const rest = tokens.slice(index + 1);
+  const stop = rest.findIndex((token) => token.pos !== "AUX");
+  const last = (stop === -1 ? rest : rest.slice(0, stop)).at(-1) ?? verb;
+  return { start: verb.span.start - sentence.span.start, end: last.span.end - sentence.span.start };
+};
+
+const formsAt = (sentence: Sentence, tokens: readonly Token[], index: number, bases: readonly string[]): string[] => {
+  const verb = tokens[index];
+  const lemma = verb?.lemma;
+  if (verb?.pos !== "VERB" || lemma === undefined || lemma === "") return [];
+  const run = inflectedRun(sentence, tokens, index, verb);
+  const before = sentence.text.slice(0, run.start);
+  const written = sentence.text.slice(run.start, run.end);
+  return bases
+    .filter((base) => base.endsWith(lemma))
+    .map((base) => base.slice(0, base.length - lemma.length))
+    .filter((head) => before.endsWith(head))
+    .map((head) => `${head}${written}`);
+};
+
+export const conjugatedForms = (sentences: readonly Sentence[], bases: readonly string[]): string[] => {
+  const forms = sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokens.flatMap((_token, index) => formsAt(sentence, tokens, index, bases));
+  });
+  return [...new Set(forms)];
+};

package/src/detectors/enumerated-runs.ts

@@ -0,0 +1,68 @@
+import type { Sentence, Span, StructureNode, Token } from "../plugin.ts";
+
+/** 番号の付いた行。start は行の始まり（字下げの前）、label は言語パッケージが読んだ番号（「（1）」）。 */
+export type NumberedStart = { readonly start: number; readonly label: string };
+
+const labelOf = (node: StructureNode): string => {
+  const label = node.attrs["label"];
+  return typeof label === "string" ? label : "";
+};
+
+/**
+ * 条の外で、番号の付いた行（言語パッケージが項目と読んだ「（1）」など）。
+ * 条の中の番号付きの行は、条の項（条の本文の続き）でもありうるので数えない。
+ */
+export const numberedStarts = (node: StructureNode, inArticle = false): NumberedStart[] => [
+  ...(node.kind === "item" && !inArticle ? [{ start: node.span.start, label: labelOf(node) }] : []),
+  ...node.children.flatMap((child) => numberedStarts(child, inArticle || node.kind === "article")),
+];
+
+const INDENT = /^[ \t\u3000]*/u;
+
+const lineAt = (source: string, start: number): string => {
+  const end = source.indexOf("\n", start);
+  return source.slice(start, end === -1 ? source.length : end);
+};
+
+/** 番号の直後の語。字下げと番号と空白を飛ばした先の、最初の語。 */
+const wordAfter = (numbered: NumberedStart, sentences: readonly Sentence[], source: string): Token | undefined => {
+  const after = numbered.start + (INDENT.exec(lineAt(source, numbered.start))?.[0].length ?? 0) + numbered.label.length;
+  const sentence = sentences.find((candidate) => candidate.span.end > after);
+  return sentence?.tokens?.find((token) => token.span.start >= after && token.surface.trim() !== "");
+};
+
+/**
+ * 並びの項目として番号を振った行の始まり。番号の直後が助詞（「（1）の金額は」「（2）は対象外」）なら、
+ * 番号は項目の印ではなく、項目を指す本文の主語や修飾なので除く。
+ */
+export const enumeratorStarts = (numbered: readonly NumberedStart[], sentences: readonly Sentence[], source: string): number[] =>
+  numbered.filter((line) => wordAfter(line, sentences, source)?.pos !== "ADP").map((line) => line.start);
+
+/** 番号の付いた行の始まりと段落の始まりのあいだが字下げだけなら、段落はその行から始まる。 */
+const opensWithItem = (paragraph: Span, starts: readonly number[], source: string): boolean =>
+  starts.some((start) => start <= paragraph.start && source.slice(start, paragraph.start).trim() === "");
+
+const isBlank = (source: string, from: number, to: number): boolean => source.slice(from, to).trim() === "";
+
+/** 並びと読むのに要る、番号の付いた行の数。一つだけなら、並びではなく番号で始まる本文の段落かもしれない。 */
+const MIN_ITEMS = 2;
+
+/** 番号の行の始まりは字下げの前なので、並びの最初の行の頭から数える。 */
+const itemsIn = (run: Span, starts: readonly number[], source: string): number => {
+  const lineStart = source.lastIndexOf("\n", run.start - 1) + 1;
+  return starts.filter((start) => start >= lineStart && start < run.end).length;
+};
+
+/**
+ * 番号で始まる段落が、空行だけを挟んで続く範囲。番号の付いた行を二つ以上含むものだけ。
+ * 要件や条件を「（1）…であること。」と並べるのは、段落でも箇条書きと同じ書き方で、本文の調子とは別に揃える。
+ */
+export const enumeratedRuns = (paragraphs: readonly Span[], starts: readonly number[], source: string): Span[] => {
+  const enumerated = paragraphs.filter((paragraph) => opensWithItem(paragraph, starts, source));
+  const runs = enumerated.reduce<Span[]>((joined, paragraph) => {
+    const last = joined.at(-1);
+    if (last === undefined || !isBlank(source, last.end, paragraph.start)) return [...joined, paragraph];
+    return [...joined.slice(0, -1), { start: last.start, end: paragraph.end }];
+  }, []);
+  return runs.filter((run) => itemsIn(run, starts, source) >= MIN_ITEMS);
+};

package/src/detectors/middle-dot.ts

@@ -0,0 +1,10 @@
+const MIDDLE_DOT = /・/gu;
+
+/** 文頭か行頭（前に空白だけ）の「・」。前に並べる項目が無いので、箇条書きの印。 */
+const BULLET_DOT = /(^|\n)[^\S\n]*・/gu;
+
+/**
+ * 項目を並べる中黒の数。箇条書きの印の「・」は数えない。
+ * 「・ 水分を補給すること」が何行続いても、どこまでが 1 つの項目かは改行で読める。
+ */
+export const parallelDotCount = (text: string): number => [...text.replace(BULLET_DOT, "$1").matchAll(MIDDLE_DOT)].length;

package/src/detectors/orthography.ts

@@ -1,6 +1,6 @@
 import type { Detector, Finding, Sentence } from "../plugin.ts";
 import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
-import { digitRunAround, isNumberName } from "../number-name.ts";
+import { digitRunAround, isNumberName, sequenceLabelStarts } from "../number-name.ts";
 
 /** チームが chaff.yaml の prefer に書いた「使わない書き方」。書いていなければ何も言わない。 */
 export const preferredTerm: Detector = (doc, options): Finding[] => {
@@ -31,10 +31,10 @@ const digitBeside = (boundary: Boundary): number => {
 };
 
 /** 番号・識別子として書かれた数の境目は、空け方の好みではないので数えない（number-name.ts）。 */
-const isCounted = (sentence: Sentence, boundary: Boundary): boolean => {
+const isCounted = (sentence: Sentence, boundary: Boundary, sequence: ReadonlySet<number>): boolean => {
   if (boundary.kind === "letter") return true;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
-  return run === undefined || !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start);
+  return run === undefined || !isNumberName(sentence.text, run, sentence.tokens, sentence.span.start, sequence);
 };
 
 /**
@@ -42,9 +42,11 @@ const isCounted = (sentence: Sentence, boundary: Boundary): boolean => {
  * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
  */
 export const latinSpacing: Detector = (doc, options): Finding[] => {
+  // 覆った文（prose）で探す。コードの中の「1 件」は並びに入れない。
+  const sequence = sequenceLabelStarts(doc.prose ?? doc.source);
   const located: Located[] = doc.sentences.flatMap((sentence) =>
     latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
-      .filter((boundary) => isCounted(sentence, boundary))
+      .filter((boundary) => isCounted(sentence, boundary, sequence))
       .map((boundary) => ({ sentence, ...boundary })),
   );
   return KINDS.flatMap((kind) => {

package/src/detectors/polite-word.ts

@@ -0,0 +1,14 @@
+import type { LexiconEntry, Token } from "../plugin.ts";
+
+/** 語彙表の語が解析器で一語になったときの、その語。二語以上（「ございます」）は読みで照らさない。 */
+const singleWord = (entry: LexiconEntry): Token | undefined => (entry.tokens?.length === 1 ? entry.tokens[0] : undefined);
+
+/**
+ * 読みと品詞が同じなら、表記が違っても同じ語の同じ形。解析器は「下さい」の原形を「下さる」、「ください」の原形を「くださる」と
+ * 別の字で返すが、読み（クダサイ）と品詞は同じ。品詞も比べるのは、読みだけだと「升（マス）」が「ます」に当たるから。
+ */
+const sameReading = (token: Token, word: Token | undefined): boolean => word?.reading !== undefined && token.reading === word.reading && token.pos === word.pos;
+
+/** 語が丁寧語の語彙表の語か。書いた形か原形が語彙表の語と同じか、語彙表の一語と読みと品詞が同じ。 */
+export const isPoliteWord = (token: Token, entries: readonly LexiconEntry[]): boolean =>
+  entries.some((entry) => token.surface === entry.pattern || token.lemma === entry.pattern || sameReading(token, singleWord(entry)));

package/src/detectors/register.ts

@@ -1,4 +1,5 @@
-import type { Sentence, Span, Token } from "../plugin.ts";
+import { isPoliteWord } from "./polite-word.ts";
+import type { LexiconEntry, Sentence, Span, Token } from "../plugin.ts";
 
 export type Register = "polite" | "plain";
 
@@ -25,13 +26,12 @@ const withPreceding = (ending: readonly Token[], preceding: readonly Token[]): r
  * 文末の語の調子。preceding は文末の語より前の語。
  * 文末に述語（動詞・形容詞・助動詞）が無ければ、ですます調でもである調でもないので undefined。
  * 「以下の通り。」「円錐形の麦わら帽子。」のような名詞で終わる文を数えると、そのままである調の少数派になっていた。
- * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
+ * 書いた形でも原形でも読みでも当てる（polite-word.ts）。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
  */
-export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly string[]): Register | undefined => {
+export const registerOf = (ending: readonly Token[], preceding: readonly Token[], polite: readonly LexiconEntry[]): Register | undefined => {
   const judged = withPreceding(ending, preceding);
   if (!judged.some(isPredicate)) return undefined;
-  const isPolite = judged.some((token) => polite.includes(token.surface) || (token.lemma !== undefined && polite.includes(token.lemma)));
-  return isPolite ? "polite" : "plain";
+  return judged.some((token) => isPoliteWord(token, polite)) ? "polite" : "plain";
 };
 
 const EXCLAIMED = /[！？!?]$/u;
@@ -49,7 +49,11 @@ export const outermostList = (offset: number, lists: readonly Span[]): number |
     .filter((list) => offset >= list.start && offset < list.end)
     .reduce<number | undefined>((outer, list) => (outer === undefined || list.start < outer ? list.start : outer), undefined);
 
-/** group: 文が入っている箇条書き（outermostList の値）。本文なら undefined。 */
+/** 文が入っているまとまりの始まり。一番外側の箇条書き、それが無ければ番号で始まる段落の並び（runs）。本文なら undefined。 */
+export const groupOf = (offset: number, lists: readonly Span[], runs: readonly Span[]): number | undefined =>
+  outermostList(offset, lists) ?? outermostList(offset, runs);
+
+/** group: 文が入っているまとまり（groupOf の値）。本文なら undefined。 */
 export type Judged = { readonly register: Register; readonly group: number | undefined };
 
 /** 混ざった文と、その文が属する本文または箇条書きの中の少数派の数。 */
@@ -74,7 +78,7 @@ const slipsInGroup = <T extends Judged>(judged: readonly T[], group: number | un
 };
 
 /**
- * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きは 1 つずつ、その中で揃っているかを見る。
+ * 調子が混ざった文を、judged の順で。本文は本文どうし、箇条書きと番号で始まる段落の並びは 1 つずつ、その中で揃っているかを見る。
  * ですます調の本文に常体の箇条書きを置くのはよくある書き方で、箇条書きが丸ごと揃っていれば混在ではない。
  */
 export const slipsOf = <T extends Judged>(judged: readonly T[], limit: number): Slip<T>[] => {

package/src/detectors/roman-numeral.ts

@@ -0,0 +1,5 @@
+/**
+ * 崩れのない書き方のローマ数字（I〜MMMM）。IIII や VX は数として書かれないので、略語の側に残す。
+ * 各桁が省けるので空文字にも当たる。1 文字目があることを先読みで求める。
+ */
+export const ROMAN_NUMERAL = "(?=[MDCLXVI])M{0,4}(?:CM|CD|D?C{0,3})(?:XC|XL|L?X{0,3})(?:IX|IV|V?I{0,3})";

package/src/detectors/sentence-ending.ts

@@ -1,6 +1,7 @@
 import { endingTokens, isClosed } from "../sentence-shape.ts";
-import { continuesInto, outermostList, registerOf, slipsOf, type Register } from "./register.ts";
-import type { Detector, Finding, Sentence } from "../plugin.ts";
+import { enumeratedRuns, enumeratorStarts, numberedStarts } from "./enumerated-runs.ts";
+import { continuesInto, groupOf, registerOf, slipsOf, type Register } from "./register.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /**
  * 文末の調子が混ざっているかを見る。日本語の「ですます / である」がこれ。
@@ -11,21 +12,37 @@ import type { Detector, Finding, Sentence } from "../plugin.ts";
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
-const registerOfSentence = (sentence: Sentence, polite: readonly string[]): Register | undefined => {
+const registerOfSentence = (sentence: Sentence, polite: readonly LexiconEntry[]): Register | undefined => {
   const ending = endingTokens(sentence);
   const tokens = sentence.tokens ?? [];
   const head = ending[0] === undefined ? -1 : tokens.indexOf(ending[0]);
   return registerOf(ending, head > 0 ? tokens.slice(0, head) : [], polite);
 };
 
+/** 番号で始まる段落の並び。木を組むのは高いので、調子が一つだけの文書（混ざりようがない）では組まない。 */
+const runsOf = (doc: ProseDocument, registers: readonly Register[]): Span[] => {
+  const tree = new Set(registers).size > 1 ? doc.structure : undefined;
+  if (tree === undefined) return [];
+  return enumeratedRuns(
+    doc.paragraphs.map((paragraph) => paragraph.span),
+    enumeratorStarts(numberedStarts(tree), doc.sentences, doc.source),
+    doc.source,
+  );
+};
+
 export const sentenceEnding: Detector = (doc, options): Finding[] => {
-  const polite = (options.lexicon ?? []).map((entry) => entry.pattern);
+  const polite = options.lexicon ?? [];
   const lists = doc.lists.map((list) => list.span);
-  const judged = doc.sentences.flatMap((sentence, index): Entry[] => {
+  const found = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
     if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1])) return [];
     const register = registerOfSentence(sentence, polite);
-    return register === undefined ? [] : [{ sentence, register, group: outermostList(sentence.span.start, lists) }];
+    return register === undefined ? [] : [{ sentence, register }];
   });
+  const runs = runsOf(
+    doc,
+    found.map((entry) => entry.register),
+  );
+  const judged = found.map((entry): Entry => ({ ...entry, group: groupOf(entry.sentence.span.start, lists, runs) }));
   return slipsOf(judged, options.limit).map(({ entry: { sentence }, count }) => ({
     rule: "no-mixed-desumasu",
     severity: "warning",

package/src/detectors/signals.ts

@@ -3,6 +3,7 @@ import { wordsOf } from "./structure.ts";
 import { compacted, placeOf } from "./gram-place.ts";
 import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
 import { expansionAt, type ExpandedAt } from "./acronym-expansion.ts";
+import { conjugatedForms } from "./conjugated-form.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
 const PER = 1000;
@@ -216,8 +217,15 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     currencies: patternsOf(doc, "currency-code"),
     usStates: patternsOf(doc, "us-state-code"),
     emphasis: patternsOf(doc, "emphasis-word"),
+    divisions: patternsOf(doc, "numbered-division"),
   });
 
+/** 定義の語は、語彙表の形（という）と、この文書で活用して書かれた形（といいます）の両方で照らす。 */
+const definitionVerbsOf = (doc: ProseDocument): string[] => {
+  const verbs = patternsOf(doc, "definition-verb");
+  return [...verbs, ...conjugatedForms(doc.sentences, verbs)];
+};
+
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
   const common = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
@@ -225,7 +233,7 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   acronymsOf(doc, notationOf(doc)).forEach(({ word, hit }) => {
     if (!common.has(word) && !seen.has(word)) seen.set(word, hit);
   });
-  const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: patternsOf(doc, "definition-verb") });
+  const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
   const bare = [...seen.entries()].filter(([acronym]) => !isExpanded(body, acronym, expandedAt));
   if (bare.length < options.limit) return [];
   return bare.map(([acronym, hit]) => ({

package/src/detectors/structure.ts

@@ -2,6 +2,7 @@ import { charLength, lengthOf } from "../measure.ts";
 import type { BulletList, Detector, Finding, Paragraph, ProseDocument, Section, Span } from "../plugin.ts";
 import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
+import { preambleParagraphs } from "../preamble-paragraphs.ts";
 
 /**
  * ばらつきは変動係数（標準偏差 ÷ 平均）で測る。
@@ -116,7 +117,7 @@ const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[])
 export const preambleLength: Detector = (doc, options): Finding[] => {
   const body = doc.sections.find((section) => section.depth >= 2);
   if (body === undefined) return [];
-  const all = doc.paragraphs.filter((paragraph) => paragraph.span.start < body.span.start);
+  const all = preambleParagraphs(doc.paragraphs, body.span.start);
   if (all.length <= options.limit) return [];
   const before = withoutDateStamps(doc, all);
   if (before.length <= options.limit) return [];

package/src/number-name.ts

@@ -5,8 +5,8 @@ import type { Span, Token } from "./plugin.ts";
  * 「〒102-0094 東京都」の郵便番号は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
  * 空け方を数える材料にしない。
  *
- * 形で名前と読むのは三つだけ。0 で始まる組を含むハイフンつなぎの番号、※ や鉤括弧のすぐ後ろの番号、文頭の階層つきの節番号（2.1、3.1.2）。
- * 文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
+ * 形で名前と読むのは四つだけ。0 で始まる組を含むハイフンつなぎの番号、※ や鉤括弧のすぐ後ろの番号、文頭の階層つきの節番号（2.1、3.1.2）、
+ * 続き番号になった行の頭の番号（白書の注）。文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
  * そのうえで、すぐ後ろ（空白 1 つまで）の語が数につく語（助数詞・数・助詞・助動詞）なら数量として数え続ける（「3-5 日」「26.7 万行」）。
  * 品詞が無ければ判断せず、名前とは読まない。
  */
@@ -51,6 +51,26 @@ const wordAfter = (tokens: readonly Token[], text: string, run: Span, base: numb
 const isBoundToNumber = (token: Token): boolean =>
   token.features?.["NounType"] === "Class" || token.features?.["NumType"] === "Card" || BOUND_TO_NUMBER.has(token.pos);
 
+/** 「1 又は 2」の接続詞は数どうしをつなぐが、続き番号の注の本文は「31 ただし、…」のように接続詞でも始まる。 */
+const CONJUNCTIONS = new Set(["CCONJ", "SCONJ"]);
+
+/**
+ * 白書の注（「9 首相に…」「10 日本経済新聞…」）のように、行の頭に階層の無い番号を置き、次の行の頭の番号が 1 つ大きいもの。
+ * 一行だけ見ると「223 言語に対応」と区別がつかないので、前後の番号の行と続き番号になっているものだけを番号と読む。
+ * 後ろが英字（「15 Federal Bureau…」）の行も並びには数える。値は行の頭の位置（文書全体の座標）。
+ */
+const NUMBERED_LINE = /^[ \t]*(?:[-*+][ \t]+)?(?<number>\d{1,3})[ \t]+\S/gmu;
+
+export const sequenceLabelStarts = (text: string): ReadonlySet<number> => {
+  const lines = [...text.matchAll(NUMBERED_LINE)].map((match) => {
+    const number = match.groups?.["number"] ?? "";
+    return { start: match.index + match[0].indexOf(number), value: Number(number) };
+  });
+  const continues = (index: number): boolean =>
+    lines[index - 1]?.value === (lines[index]?.value ?? 0) - 1 || lines[index + 1]?.value === (lines[index]?.value ?? 0) + 1;
+  return new Set(lines.flatMap((line, index) => (continues(index) ? [line.start] : [])));
+};
+
 /** ハイフンでつないだ識別子か、番号の立つ位置の番号か、文頭の節番号か。 */
 const isNameShaped = (text: string, run: Span): boolean => {
   const [before, digits] = [text.slice(0, run.start), text.slice(run.start, run.end)];
@@ -58,11 +78,19 @@ const isNameShaped = (text: string, run: Span): boolean => {
 };
 
 /**
- * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。
+ * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。sequence は sequenceLabelStarts の結果。
  * 後ろの語が読めない（品詞が無い、語の切れ目が合わない）ときは、数量として数え続ける。
  */
-export const isNumberName = (text: string, run: Span, tokens: readonly Token[] | undefined, base: number): boolean => {
-  if (tokens === undefined || !isNameShaped(text, run)) return false;
+export const isNumberName = (
+  text: string,
+  run: Span,
+  tokens: readonly Token[] | undefined,
+  base: number,
+  sequence: ReadonlySet<number> = new Set(),
+): boolean => {
+  const inSequence = sequence.has(base + run.start);
+  if (tokens === undefined || !(inSequence || isNameShaped(text, run))) return false;
   const next = wordAfter(tokens, text, run, base);
-  return next !== undefined && !isBoundToNumber(next);
+  if (next === undefined) return false;
+  return !isBoundToNumber(next) || (inSequence && CONJUNCTIONS.has(next.pos));
 };

package/src/plugin.ts

@@ -20,6 +20,8 @@ export type Token = {
   readonly surface: string;
   readonly pos: string;
   readonly lemma?: string;
+  /** 書いた形の読み（日本語はカタカナ）。表記の違う同じ語（下さい・ください）を同じと見るため。読めない adapter は持たない。 */
+  readonly reading?: string;
   readonly features?: Readonly<Record<string, string>>;
 };
 

package/src/preamble-paragraphs.ts

@@ -0,0 +1,9 @@
+import type { Paragraph } from "./plugin.ts";
+import { isClosed } from "./sentence-shape.ts";
+
+/**
+ * 本題の前にあって、読み手が読み通す段落。文が一つも終止符で閉じない段落は数えない。
+ * 分類の札（「エネルギー・環境」）、著者と所属の行、「印刷」、テンプレートの指示は文ではなく、読ませる前置きではない。
+ */
+export const preambleParagraphs = (paragraphs: readonly Paragraph[], bodyStart: number): Paragraph[] =>
+  paragraphs.filter((paragraph) => paragraph.span.start < bodyStart && paragraph.sentences.some(isClosed));

package/src/structure/build.ts

@@ -8,6 +8,7 @@ import type { DocumentProfile, Mention, NumberedLine, NumberingContext, Span, St
 import { lineNumberAt, linesOf, type Line } from "./lines.ts";
 import { dottedNumber } from "./universal.ts";
 import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
+import { readsOnHeading } from "./heading-leaves.ts";
 
 /** 組み立て中の節点。できあがったら StructureNode に固める。 */
 type Draft = {
@@ -179,17 +180,19 @@ const scopeOf = (state: State, patterns: StructurePatterns, text: string): Reado
   return within === undefined ? { scope: "local" } : { scope: "local", within: within.address };
 };
 
-const addLeaves = (state: State, patterns: StructurePatterns, line: Line, text: string, offset: number): void => {
+const addLeaves = (state: State, patterns: StructurePatterns, line: Line, text: string, offset: number, onHeading: boolean): void => {
   const parent = top(state).draft;
   const scope = scopeOf(state, patterns, text);
-  const leaves = LEAVES.flatMap(({ kind, find }) =>
-    find(patterns, text, state.profile).map((mention) => ({
-      kind,
-      start: line.start + offset + mention.start,
-      end: line.start + offset + mention.end,
-      attrs: mention.attrs,
-    })),
-  ).sort((left, right) => left.start - right.start);
+  const leaves = LEAVES.filter(({ kind }) => !onHeading || readsOnHeading(kind))
+    .flatMap(({ kind, find }) =>
+      find(patterns, text, state.profile).map((mention) => ({
+        kind,
+        start: line.start + offset + mention.start,
+        end: line.start + offset + mention.end,
+        attrs: mention.attrs,
+      })),
+    )
+    .sort((left, right) => left.start - right.start);
   leaves.forEach((leaf) =>
     parent.children.push({
       kind: leaf.kind,
@@ -303,7 +306,7 @@ const readLine = (state: State, patterns: StructurePatterns, line: Line, heading
   // 番号付きの行は番号の後ろだけを読む。「第3条（支払）」の「第3条」を自分への参照として拾わない。
   const scanned = numbered === undefined ? text : numbered.rest;
   const offset = Math.max(0, line.text.lastIndexOf(scanned));
-  if (scanned !== "") addLeaves(state, patterns, line, scanned, offset);
+  if (scanned !== "") addLeaves(state, patterns, line, scanned, offset, heading !== undefined);
 };
 
 /**

package/src/structure/heading-leaves.ts

@@ -0,0 +1,7 @@
+import type { StructureKind } from "../plugin.ts";
+
+/**
+ * 見出しの行から拾う葉か。見出しは節の題で、「『特別警報』とは」は下の本文が定義する語を掲げているだけで、定義ではない。
+ * 定義として数えると、本文の「『特別警報』とは、…」が二度目の定義に見える。参照や数量は見出しにあっても読む。
+ */
+export const readsOnHeading = (kind: StructureKind): boolean => kind !== "definition";