chaffjs 0.12.0 → 0.14.0

package/src/detectors/sentence-ending.ts

@@ -1,41 +1,54 @@
-import { endingTokens, hasPredicate, isClosed } from "../sentence-shape.ts";
-import type { Detector, Finding, Sentence } from "../plugin.ts";
+import { endingTokens, isClosed } from "../sentence-shape.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";
 
 /**
  * 文末の調子が混ざっているかを見る。日本語の「ですます / である」がこれ。
  *
  * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
  * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
+ * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）は文として数えない。
  */
-/**
- * 述語を持たないものは文として数えない。見出しの下の `MaaSサービス` のような
- * 名前だけの行がそのまま「である調」の少数派になり、実文書の誤検知はすべてこれだった。
- */
-const isSentence = (sentence: Sentence): boolean => isClosed(sentence) && hasPredicate(sentence) && endingTokens(sentence).length > 0;
+type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
-/**
- * 文末の語だけを見る。文の途中の引用（「ご覧ください」という表現を使う。）は文末の調子ではない。
- * 書いた形でも原形でも当てる。「ください」の原形は「くださる」で、原形だけを見ると丁寧な文末を見落とす。
- */
-const isPolite = (sentence: Sentence, polite: readonly string[]): boolean =>
-  endingTokens(sentence).some((token) => polite.includes(token.surface) || (token.lemma !== undefined && polite.includes(token.lemma)));
+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 judged = doc.sentences.filter(isSentence).map((sentence) => ({ sentence, polite: isPolite(sentence, polite) }));
-  const counts = { polite: judged.filter((entry) => entry.polite).length, plain: judged.length - judged.filter((entry) => entry.polite).length };
-  const minorityIsPolite = counts.polite <= counts.plain;
-  const few = minorityIsPolite ? counts.polite : counts.plain;
-  // 片方しか無ければ一貫している。少数派が閾値を超えて多ければ、混在ではなく別の文体。
-  if (few === 0 || few > options.limit) return [];
-  return judged
-    .filter((entry) => entry.polite === minorityIsPolite)
-    .map(({ sentence }) => ({
-      rule: "no-mixed-desumasu",
-      severity: "warning",
-      line: 0,
-      column: 0,
-      quote: sentence.text.trim(),
-      values: { count: few, limit: options.limit, offset: sentence.span.start },
-    }));
+  const polite = options.lexicon ?? [];
+  const lists = doc.lists.map((list) => list.span);
+  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 }];
+  });
+  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",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { count, limit: options.limit, offset: sentence.span.start },
+  }));
 };

package/src/detectors/signals.ts

@@ -1,8 +1,9 @@
 import { proseText } from "../measure.ts";
 import { wordsOf } from "./structure.ts";
 import { compacted, placeOf } from "./gram-place.ts";
-import { notAcronymSpans } from "./acronym-context.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;
@@ -183,18 +184,18 @@ type Span = { readonly start: number; readonly end: number };
 
 const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
 
-const spansOf = (text: string): Span[] => [
+const spansOf = (text: string, notation: NotAcronymSpans): Span[] => [
   ...[...text.matchAll(UNCASED_STRETCH)].filter((match) => SHOUTED_RUN.test(match[0])).map(spanOf),
   ...[...text.matchAll(IDENTIFIER)].filter((match) => /\d/u.test(match[0])).map(spanOf),
   ...[QUOTED_CAPS, REQUIREMENT_WORD, LICENCE].flatMap((pattern) => [...text.matchAll(pattern)].map(spanOf)),
-  ...notAcronymSpans(text),
+  ...notation(text),
 ];
 
 type AcronymHit = { readonly word: string; readonly hit: Hit };
 
-const acronymsOf = (doc: ProseDocument): AcronymHit[] =>
+const acronymsOf = (doc: ProseDocument, notation: NotAcronymSpans): AcronymHit[] =>
   doc.sentences.flatMap((sentence) => {
-    const excluded = spansOf(sentence.text);
+    const excluded = spansOf(sentence.text, notation);
     return [...sentence.text.matchAll(ACRONYM)]
       .filter((match) => !excluded.some((span) => span.start <= match.index && match.index + match[0].length <= span.end))
       .map((match) => ({ word: match[0], hit: { sentence, offset: sentence.span.start + match.index } }));
@@ -209,14 +210,30 @@ const isExpanded = (body: string, acronym: string, expandedAt: ExpandedAt): bool
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
+const notationOf = (doc: ProseDocument): NotAcronymSpans =>
+  notAcronymSpansOf({
+    meridiem: patternsOf(doc, "meridiem"),
+    timeZones: patternsOf(doc, "time-zone"),
+    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));
   const seen = new Map<string, Hit>();
-  acronymsOf(doc).forEach(({ word, hit }) => {
+  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

@@ -0,0 +1,96 @@
+import type { Span, Token } from "./plugin.ts";
+
+/**
+ * 数量ではなく名前として書かれた数（番号・識別子）。鉤括弧で引いた「3.1 リサーチの原則」の節番号、※1 のような注の番号、
+ * 「〒102-0094 東京都」の郵便番号は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
+ * 空け方を数える材料にしない。
+ *
+ * 形で名前と読むのは四つだけ。0 で始まる組を含むハイフンつなぎの番号、※ や鉤括弧のすぐ後ろの番号、文頭の階層つきの節番号（2.1、3.1.2）、
+ * 続き番号になった行の頭の番号（白書の注）。文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
+ * そのうえで、すぐ後ろ（空白 1 つまで）の語が数につく語（助数詞・数・助詞・助動詞）なら数量として数え続ける（「3-5 日」「26.7 万行」）。
+ * 品詞が無ければ判断せず、名前とは読まない。
+ */
+
+/** 数と結びついて読まれる語。助数詞は NounType=Class、数は NumType=Card で渡る。 */
+const BOUND_TO_NUMBER = new Set(["ADP", "PART", "AUX", "SCONJ", "CCONJ"]);
+
+/** 番号が立つ位置の直前: 題を包む鉤括弧、注の印。 */
+const LABEL_LEAD = /[「『【※]$/u;
+
+/** 文頭（前に空白と箇条書きの印だけ）。 */
+const LINE_HEAD = /^[\s\-*+・•]*$/u;
+
+/** 階層つきの節番号（2.1、3.1.2）。 */
+const SECTION_NUMBER = /^\d+(?:\.\d+)+$/u;
+
+/**
+ * 0 で始まる組を含む、ハイフンでつないだ番号（〒102-0094、03-3501）。二つの数だけの「3-5」は範囲（3-5 営業日）とも読めるので
+ * 数え続ける。三つ以上つないだもの（073-489-5909）は、orthography.ts が境目を作る前に外している。
+ */
+const isHyphenIdentifier = (digits: string): boolean => {
+  const parts = digits.split("-").filter((part) => part !== "");
+  return parts.length > 1 && parts.some((part) => part.startsWith("0"));
+};
+
+const RUN_CHAR = /[\d.-]/u;
+
+/** at を含む、数字・小数点・ハイフンの並び。at が並びの中に無ければ undefined。 */
+export const digitRunAround = (text: string, at: number): Span | undefined => {
+  if (!RUN_CHAR.test(text[at] ?? "")) return undefined;
+  const startAt = (index: number): number => (index > 0 && RUN_CHAR.test(text[index - 1] ?? "") ? startAt(index - 1) : index);
+  const endAt = (index: number): number => (index < text.length && RUN_CHAR.test(text[index] ?? "") ? endAt(index + 1) : index);
+  return { start: startAt(at), end: endAt(at) };
+};
+
+/** 並びの後ろ（空白 1 つまで）で始まる語。 */
+const wordAfter = (tokens: readonly Token[], text: string, run: Span, base: number): Token | undefined => {
+  const next = text[run.end] === " " ? run.end + 1 : run.end;
+  return tokens.find((token) => token.span.start === base + next);
+};
+
+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)];
+  return isHyphenIdentifier(digits) || LABEL_LEAD.test(before) || (LINE_HEAD.test(before) && SECTION_NUMBER.test(digits));
+};
+
+/**
+ * text の run が名前として書かれた数か。tokens は文書全体の座標で、base は text の先頭の位置。sequence は sequenceLabelStarts の結果。
+ * 後ろの語が読めない（品詞が無い、語の切れ目が合わない）ときは、数量として数え続ける。
+ */
+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);
+  if (next === undefined) return false;
+  return !isBoundToNumber(next) || (inSequence && CONJUNCTIONS.has(next.pos));
+};

package/src/orthography.ts

@@ -62,23 +62,53 @@ const latinBeside = (japanese: string | undefined, other: string | undefined, di
   isJapanese(japanese) ? kindOf(other, digitSide) : undefined;
 
 /** 日本語の字の隣にある英字・数字との境目。間が半角空白 1 つなら「空けている」、何も無ければ「詰めている」。 */
-const ALPHANUMERIC = /[A-Za-z0-9.]/u;
+// 「confidence=0」のような設定の書き方も、= を含めて一つの並びとして読む。
+const ALPHANUMERIC = /[A-Za-z0-9.=]/u;
+// 名前の語は英数字だけ。「API = 0」の空白で囲んだ = は式の記号で、名前の一部ではない。
+const WORD_CHAR = /[A-Za-z0-9.]/u;
+
+/** chars[last] を末尾とし、pattern の字が続く並びの、先頭の位置。 */
+const runStartIndex = (chars: readonly string[], last: number, pattern: RegExp = ALPHANUMERIC): number => {
+  let first = last;
+  while (first > 0 && pattern.test(chars[first - 1] ?? "")) first -= 1;
+  return first;
+};
+
+/** 並び first の前に、半角空白 1 つずつで続く英数字の語。「Phase 1」の「Phase」、「JIS X 0301」の「JIS X」。無ければ空。 */
+const wordsBefore = (chars: readonly string[], first: number): string => {
+  const words: string[] = [];
+  let space = first - 1;
+  while (chars[space] === " " && WORD_CHAR.test(chars[space - 1] ?? "")) {
+    const start = runStartIndex(chars, space - 1, WORD_CHAR);
+    words.unshift(chars.slice(start, space).join(""));
+    space = start - 1;
+  }
+  return words.join(" ");
+};
+
+// 「1ファイル x 1シート」の x のように、1 字だけの英字は記号か変数で、名前の頭ではない。
+const MIN_NAME_LETTERS = 2;
 
 /**
- * 日本語の左にある英数字の並びの、先頭の字。「3GBの」の「GB」は数量の単位で、並びは数字で始まる。
- * そうした並びと日本語の境目は、英字の空け方ではなく数字の後ろの空け方として数える（「3回」と同じ）。
- * 逆に「H30 等」「EC2 で」は英字で始まる名前で、書き手は英単語と同じに空ける。数字の後ろとしては数えない。
+ * 「Phase 1 は」「iOS 17以上」の数字は、英字の語に続く名前の一部。空白は名前の中の空白で、日本語との境目は
+ * 「H30 等」と同じく英字の空け方として数える。
  */
-const runStart = (chars: readonly string[], last: number): string | undefined => {
-  let first = last;
-  while (first > 0 && ALPHANUMERIC.test(chars[first - 1] ?? "")) first -= 1;
-  return chars[first];
+const isNameTail = (chars: readonly string[], first: number): boolean => {
+  const words = wordsBefore(chars, first);
+  return LETTER.test(words[0] ?? "") && (words.match(/[A-Za-z]/gu)?.length ?? 0) >= MIN_NAME_LETTERS;
 };
 
-/** 左の並びの種類は先頭の字で決める。数字で始まる並び（3GB、10ms）は数字、英字で始まる並び（H30、v1.2）は英字。 */
+/**
+ * 日本語の左にある英数字の並びの種類は、先頭の字で決める。「3GBの」の「GB」は数量の単位で、並びは数字で始まる。
+ * そうした並びと日本語の境目は、英字の空け方ではなく数字の後ろの空け方として数える（「3回」と同じ）。
+ * 逆に「H30 等」「EC2 で」「v1.2の」は英字で始まる名前で、書き手は英単語と同じに空ける。
+ */
 const leftRunBeside = (chars: readonly string[], last: number, japanese: string | undefined): SpacingKind | undefined => {
   const kind = latinBeside(japanese, chars[last], "after-digit");
-  return kind === undefined ? undefined : (kindOf(runStart(chars, last), "after-digit") ?? kind);
+  if (kind === undefined) return undefined;
+  const first = runStartIndex(chars, last);
+  if (DIGIT.test(chars[first] ?? "") && isNameTail(chars, first)) return "letter";
+  return kindOf(chars[first], "after-digit") ?? kind;
 };
 
 /**
@@ -94,10 +124,37 @@ const isOrdinalRun = (chars: readonly string[], index: number): boolean => {
   return chars[before] === ORDINAL_PREFIX;
 };
 
+/**
+ * 「073-489-5909」「2026-06-02」「Ⅰ-4-1-3」のように - でつないだ 3 組以上の数字は、電話番号・日付・図の番号で
+ * 数量ではない。後ろの空白は欄の区切りで、「3回」の空け方とは別のもの。両側とも数えない。
+ * 2 組（「1-3ヶ月」「20-30分」）は幅のある数量なので数える。
+ */
+const MIN_CODE_GROUPS = 3;
+const CODE_CHAR = /[\d-]/u;
+
+const isCode = (chars: readonly string[], digit: number): boolean => {
+  let [first, last] = [digit, digit];
+  while (first > 0 && CODE_CHAR.test(chars[first - 1] ?? "")) first -= 1;
+  while (last < chars.length - 1 && CODE_CHAR.test(chars[last + 1] ?? "")) last += 1;
+  const groups = chars
+    .slice(first, last + 1)
+    .join("")
+    .split("-");
+  return groups.filter((group) => group !== "").length >= MIN_CODE_GROUPS;
+};
+
+/** 日本語との境目にある数字が、数えない書き方（「第3条」の番地、「073-489-5909」の符号）か。 */
+const isUncountedNumber = (chars: readonly string[], index: number): boolean => {
+  const [left, right] = [chars[index], chars[index + 1]];
+  if (DIGIT.test(left ?? "")) return isOrdinalRun(chars, index) || isCode(chars, index);
+  const next = right === " " ? index + 2 : index + 1;
+  if (!DIGIT.test(chars[next] ?? "")) return false;
+  return left === ORDINAL_PREFIX || (isJapanese(left) && isCode(chars, next));
+};
+
 const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "offset"> | undefined => {
+  if (isUncountedNumber(chars, index)) return undefined;
   const [left, right, after] = [chars[index], chars[index + 1], chars[index + 2]];
-  const numberAfterPrefix = left === ORDINAL_PREFIX && DIGIT.test((right === " " ? after : right) ?? "");
-  if (numberAfterPrefix || (DIGIT.test(left ?? "") && isOrdinalRun(chars, index))) return undefined;
   const touching = latinBeside(left, right, "before-digit") ?? leftRunBeside(chars, index, right);
   if (touching !== undefined) return { kind: touching, spaced: false };
   if (right !== " ") return undefined;
@@ -105,15 +162,19 @@ const boundaryAt = (chars: readonly string[], index: number): Omit<Boundary, "of
   return spaced === undefined ? undefined : { kind: spaced, spaced: true };
 };
 
-/** 文の中の境目を全部。offset は境目の位置（左の字の直後、UTF-16）。配列を作り直さずに一度なめる。 */
-export const latinBoundaries = (text: string): Boundary[] => {
+/**
+ * 文の中の境目を全部。offset は境目の位置（左の字の直後、UTF-16）。配列を作り直さずに一度なめる。
+ * text は本文でないものを空白で覆った文、written は覆う前の同じ範囲。覆ってできた空白（リンクの「[」など）は
+ * 書き手が空けたものではないので、「空けている」とは数えない。
+ */
+export const latinBoundaries = (text: string, written: string = text): Boundary[] => {
   const chars = [...text];
   const found: Boundary[] = [];
   let offset = 0;
   chars.forEach((char, index) => {
     offset += char.length;
     const boundary = boundaryAt(chars, index);
-    if (boundary !== undefined) found.push({ ...boundary, offset });
+    if (boundary !== undefined && (!boundary.spaced || written[offset] === " ")) found.push({ ...boundary, offset });
   });
   return found;
 };

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";