chaffjs 0.35.0 → 0.36.0

package/src/detectors/scaled-figure-unit.ts

@@ -0,0 +1,103 @@
+// number-without-unit, in prose: a number written with a word of scale and no unit (83,494百万, 83 million) where the
+// document writes that word of scale with one unit many times and without one nowhere else (83,494百万円, $83 million).
+// Pure; the words of scale, the currency marks and the joiners come from the language's lexicons.
+import { escapeRegExp } from "../orthography.ts";
+import type { CurrencyForm } from "./currency-notation.ts";
+import { AMOUNT } from "./currency-notation.ts";
+
+/** A number with a word of scale: from its currency mark (if any) to the end of its unit, and the unit ("" when bare). */
+export type ScaledFigure = { readonly offset: number; readonly end: number; readonly written: string; readonly scale: string; readonly unit: string };
+
+export type ScaleWords = { readonly scales: readonly string[]; readonly forms: readonly CurrencyForm[]; readonly joiners: readonly string[] };
+
+export type ScaleGap = { readonly figure: ScaledFigure; readonly unit: string };
+
+/** How many numbers must carry the unit before the one without it reads as a slip rather than a way of writing. */
+export const MIN_WITH_UNIT = 5;
+
+const LATIN = /[A-Za-z]/u;
+const longestFirst = (words: readonly string[]): string[] => words.toSorted((left, right) => right.length - left.length);
+
+const figurePattern = (scales: readonly string[]): RegExp => {
+  const scale = longestFirst(scales)
+    .map((word) => `${escapeRegExp(word)}${LATIN.test(word) ? "(?![A-Za-z])" : ""}`)
+    .join("|");
+  return new RegExp(`(?<![\\w.,，．０-９])${AMOUNT}\\s?(?:${scale})`, "gu");
+};
+
+const formMatches = (text: string, pattern: string, side: "before" | "after"): boolean => {
+  if (side === "before") return text.endsWith(pattern) && !(LATIN.test(pattern.charAt(0)) && LATIN.test(text.charAt(text.length - pattern.length - 1)));
+  return text.startsWith(pattern) && !(LATIN.test(pattern.at(-1) ?? "") && LATIN.test(text.charAt(pattern.length)));
+};
+
+/** The currency mark written before a number ($, US$, ¥), with the one space it may have. */
+const markBefore = (text: string, offset: number, forms: readonly CurrencyForm[]): string => {
+  const before = text.slice(Math.max(0, offset - 8), offset);
+  const spaced = before.endsWith(" ") ? before.slice(0, -1) : before;
+  const form = longestFirst(forms.filter((entry) => entry.position === "before").map((entry) => entry.pattern)).find((pattern) =>
+    formMatches(spaced, pattern, "before"),
+  );
+  if (form === undefined) return "";
+  return spaced === before ? form : `${form} `;
+};
+
+/** What follows a word of scale as its unit: a currency word (円, dollars), else the next word ("people", 人, ドル); "" when none. */
+const unitAfter = (rest: string, forms: readonly CurrencyForm[]): string => {
+  const spaced = rest.startsWith(" ") ? rest.slice(1) : rest;
+  const form = longestFirst(forms.filter((entry) => entry.position === "after").map((entry) => entry.pattern)).find((pattern) =>
+    formMatches(spaced, pattern, "after"),
+  );
+  const word = form ?? /^(?:[A-Za-z]+|[\p{Script=Katakana}ー]+|\p{Script=Han})/u.exec(spaced)?.[0];
+  if (word === undefined) return "";
+  return spaced === rest ? word : ` ${word}`;
+};
+
+const figureAt = (text: string, match: RegExpExecArray, words: ScaleWords): ScaledFigure | undefined => {
+  const end = match.index + match[0].length;
+  const rest = text.slice(end);
+  if (/^\s?[0-9０-９]/u.test(rest)) return undefined;
+  const mark = markBefore(text, match.index, words.forms);
+  const after = mark === "" ? unitAfter(rest, words.forms) : "";
+  const scale = longestFirst(words.scales).find((word) => match[0].endsWith(word)) ?? "";
+  return { offset: match.index - mark.length, end: end + after.length, written: match[0], scale, unit: (mark || after).trim() };
+};
+
+/** Every number with a word of scale in a text, in order; one that runs on into another number (1億2,000万円) is left out. */
+export const scaledFiguresIn = (text: string, words: ScaleWords): ScaledFigure[] =>
+  words.scales.length === 0 ? [] : [...text.matchAll(figurePattern(words.scales))].flatMap((match) => figureAt(text, match, words) ?? []);
+
+/** A bare number joined to its neighbour by a range or list word, so that one unit serves both (100百万〜200百万円). */
+const sharesUnit = (text: string, left: ScaledFigure | undefined, right: ScaledFigure | undefined, joiners: readonly string[]): boolean => {
+  if (left === undefined || right === undefined) return false;
+  const gap = text.slice(left.end, right.offset).trim();
+  return gap === "" || joiners.includes(gap) || joiners.includes(gap.toLowerCase());
+};
+
+const gapOfScale = (text: string, figures: readonly ScaledFigure[], joiners: readonly string[]): ScaleGap[] => {
+  const bare = figures.filter(
+    (figure, index) => figure.unit === "" && !sharesUnit(text, figure, figures[index + 1], joiners) && !sharesUnit(text, figures[index - 1], figure, joiners),
+  );
+  const withUnit = figures.filter((figure) => figure.unit !== "");
+  const units = new Set(withUnit.map((figure) => figure.unit));
+  const [unit] = units;
+  const [figure] = bare;
+  if (figure === undefined || unit === undefined || bare.length !== 1 || units.size !== 1 || withUnit.length < MIN_WITH_UNIT) return [];
+  return [{ figure, unit }];
+};
+
+/**
+ * The one bare number of a word of scale whose other numbers all carry one unit, at least MIN_WITH_UNIT times. Two bare
+ * numbers, or two units (百万円 and 百万株), and the document is read as writing the word that way on purpose.
+ */
+export const scaleGaps = (text: string, figures: readonly ScaledFigure[], joiners: readonly string[]): ScaleGap[] => {
+  const scales = [...new Set(figures.map((figure) => figure.scale))];
+  return scales
+    .flatMap((scale) =>
+      gapOfScale(
+        text,
+        figures.filter((figure) => figure.scale === scale),
+        joiners,
+      ),
+    )
+    .toSorted((left, right) => left.figure.offset - right.figure.offset);
+};

package/src/detectors/sentence-counts.ts

@@ -1,4 +1,5 @@
-import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Token } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
 import { isWithinAny, quotedIn } from "../quoted-span.ts";
 import { entryOpens } from "./lexicon-match.ts";
 
@@ -6,10 +7,25 @@ type TokenTest = (token: Token, at: number, tokens: readonly Token[]) => boolean
 
 const wordsOf = (lexicon: Lexicon | undefined): ReadonlySet<string> => new Set((lexicon ?? []).map((entry) => entry.pattern));
 
-/** The tokens of a sentence that pass the test, outside anything quoted in 「」『』: a quotation is not the writer's to rephrase. */
-const countedTokens = (sentence: Sentence, test: TokenTest): Token[] => {
-  const quoted = quotedIn(sentence);
-  return (sentence.tokens ?? []).filter((token, at, tokens) => test(token, at, tokens) && !isWithinAny(quoted, token.span));
+/** The terms whose counted word belongs to the term itself (電磁的方法), not to the writer's style. */
+export const FIXED_TERM_LEXICON = "teki-fixed-term";
+
+/** Where the sentence holds one of the terms, in the document's coordinates. */
+const termSpans = (sentence: Sentence, terms: Lexicon): Span[] =>
+  terms.flatMap((entry) =>
+    [...sentence.text.matchAll(new RegExp(escapeRegExp(entry.pattern), "gu"))].map((match) => ({
+      start: sentence.span.start + match.index,
+      end: sentence.span.start + match.index + entry.pattern.length,
+    })),
+  );
+
+/**
+ * The tokens of a sentence that pass the test, outside anything quoted in 「」『』 and outside the fixed terms: neither a
+ * quotation nor a term the law defines (電磁的方法) is the writer's to rephrase.
+ */
+const countedTokens = (sentence: Sentence, test: TokenTest, fixedTerms: Lexicon): Token[] => {
+  const kept = [...quotedIn(sentence), ...termSpans(sentence, fixedTerms)];
+  return (sentence.tokens ?? []).filter((token, at, tokens) => test(token, at, tokens) && !isWithinAny(kept, token.span));
 };
 
 const findingOf = (sentence: Sentence, counted: readonly Token[], limit: number): Finding => ({
@@ -21,16 +37,16 @@ const findingOf = (sentence: Sentence, counted: readonly Token[], limit: number)
   values: { word: counted[0]?.surface ?? "", count: counted.length, limit, offset: sentence.span.start },
 });
 
-const sentencesOver = (doc: ProseDocument, limit: number, test: TokenTest): Finding[] =>
+const sentencesOver = (doc: ProseDocument, limit: number, test: TokenTest, fixedTerms: Lexicon = []): Finding[] =>
   doc.sentences.flatMap((sentence) => {
-    const counted = countedTokens(sentence, test);
+    const counted = countedTokens(sentence, test, fixedTerms);
     return counted.length > limit ? [findingOf(sentence, counted, limit)] : [];
   });
 
 /** A sentence holding more than limit tokens written as one of the lexicon's words (the suffix 的). */
 export const sentenceWordCount: Detector = (doc, options): Finding[] => {
   const words = wordsOf(options.lexicon);
-  return sentencesOver(doc, options.limit, (token) => words.has(token.surface));
+  return sentencesOver(doc, options.limit, (token) => words.has(token.surface), doc.lexicons[FIXED_TERM_LEXICON] ?? []);
 };
 
 const NOMINAL: ReadonlySet<string> = new Set(["NOUN", "PROPN", "NUM"]);

package/src/detectors/sentence-ending.ts

@@ -1,7 +1,9 @@
 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 { continuesInto, groupOf, majorityOf, registerOf, slipsOf, type Register } from "./register.ts";
 import { isRunInLabel } from "./run-in-label.ts";
+import { noticeSentences } from "./notice-paragraph.ts";
+import { chronologyRows } from "../chronology-rows.ts";
 import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /**
@@ -10,6 +12,8 @@ import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } f
  * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
  * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
  * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）と、項目や段落の頭の太字の札（**速く書ける。**）は文として数えない。
+ * 年表の行（1921年信号装置の製作を開始する。）も、文書の文体と揃えない書き方なので数えない。
+ * 断り書きの段落（…ご了承ください。）も、本文とは別の声で書く決まり文句なので数えない（notice-paragraph.ts）。
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
@@ -35,11 +39,16 @@ const runsOf = (doc: ProseDocument, registers: readonly Register[]): Span[] => {
 export const judgedSentences = (doc: ProseDocument, polite: readonly LexiconEntry[]): Entry[] => {
   const neutral = doc.lexicons["neutral-ending"] ?? [];
   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]) || isRunInLabel(doc.source, sentence.span)) return [];
+  const rows = chronologyRows(doc);
+  const all = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
+    if (!isClosed(sentence) || rows.has(sentence) || continuesInto(sentence, doc.sentences[index + 1]) || isRunInLabel(doc.source, sentence.span)) return [];
     const register = registerOfSentence(sentence, polite, neutral);
     return register === undefined ? [] : [{ sentence, register }];
   });
+  const registers = new Map(all.map((entry) => [entry.sentence, entry.register]));
+  const majority = majorityOf(all.map((entry) => ({ register: entry.register, group: undefined })));
+  const notices = noticeSentences(doc.paragraphs, doc.lexicons["notice-phrase"] ?? [], (sentence) => registers.get(sentence), majority);
+  const found = all.filter((entry) => !notices.has(entry.sentence));
   const runs = runsOf(
     doc,
     found.map((entry) => entry.register),

package/src/detectors/sentence-load.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
 import { proseText } from "../measure.ts";
 import { quotedSpans } from "../quoted-span.ts";
+import { literalCues, withoutLiteralQuotes } from "../literal-quote.ts";
 import { bracketDepth, clauseCount, topicDistance } from "../sentence-load.ts";
 
 const findingOf = (sentence: Sentence, count: number, limit: number): Finding => ({
@@ -35,8 +36,14 @@ const ownTokens = (sentence: Sentence): Token[] => {
   return (sentence.tokens ?? []).filter((token) => !inQuote(token));
 };
 
-/** Brackets inside brackets: 「（注（a）参照）」. The depth is read from the text, so it works in every language. */
-export const bracketNesting: Detector = overLimit((sentence) => bracketDepth(sentence.text));
+/**
+ * Brackets inside brackets: 「（注（a）参照）」. The depth is read from the text, so it works in every language. A quotation of a
+ * string to type as it stands (件名に「応募（総務課）」と記載) counts as one bracket: its own brackets cannot be taken out.
+ */
+export const bracketNesting: Detector = (doc, options) => {
+  const cues = literalCues(doc.lexicons["literal-quote-cue"] ?? []);
+  return overLimit((sentence) => bracketDepth(withoutLiteralQuotes(sentence.text, cues)))(doc, options);
+};
 
 /** Clauses chained in one sentence (調べて、まとめ、報告したが、返事がないので、…). Needs the language's tokens. */
 export const clauseChain: Detector = overLimit((sentence) => (sentence.tokens === undefined ? undefined : clauseCount(ownTokens(sentence))));

package/src/detectors/signals.ts

@@ -1,20 +1,22 @@
 import { proseText } from "../measure.ts";
 import { dateSpans, wordsOf } from "./structure.ts";
-import { compacted, placeAt, type Compacted } from "./gram-place.ts";
+import { compacted, linkedIn, placeAt } from "./gram-place.ts";
 import { charWindows, wordWindows } from "./gram-windows.ts";
 import { furnitureMask, isFurniture } from "./gram-furniture.ts";
-import { notAcronymSpansOf, type NotAcronymSpans } from "./acronym-context.ts";
-import { nameSpansOf } from "./acronym-name.ts";
-import { abbreviates, expansionAt, termEntryAcronyms, type ExpandedAt } from "./acronym-expansion.ts";
+import { lexiconNotationOf, type NotAcronymSpans } from "./acronym-context.ts";
+import { abbreviates, expansionAt, termEntryAcronyms, type DefinitionWords, type ExpandedAt } from "./acronym-expansion.ts";
 import { isExplained } from "./acronym-compound.ts";
 import { statedAcronyms } from "./acronym-definition.ts";
 import { isBracketed, isInHeading, isNamePart } from "./acronym-lone.ts";
+import { linkTitleSpans } from "./acronym-link.ts";
 import { conjugatedForms } from "./conjugated-form.ts";
 import { evidenceSpans, hasNumeral, isClaim, isLabelOnly, startsWithin, type AdviceWords } from "./concrete-evidence.ts";
 import { letteredIndexEntries } from "./lettered-index.ts";
+import { knownByDocument } from "./acronym-known.ts";
 import { outlineLabelSpans } from "./outline-label.ts";
 import { hasPredicateIn } from "./gram-predicate.ts";
 import { gramPassagesOf } from "./gram-passages.ts";
+import { sectionOpeners } from "./gram-openers.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
 import { referenceListSpans } from "../reference-lists.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
@@ -97,15 +99,6 @@ type FirstSeen = { readonly gram: string; readonly sentence: Sentence; readonly
 
 type Tally = { readonly counts: Map<string, number>; readonly first: Map<string, FirstSeen> };
 
-/** 詰めた文の index 番目の文字が、リンクの文字か。 */
-const linkedIn = (doc: ProseDocument, sentence: Sentence, source: Compacted): ((index: number) => boolean) => {
-  const links = doc.links.filter((link) => link.start < sentence.span.end && sentence.span.start < link.end);
-  return (index) => {
-    const at = sentence.span.start + (source.offsets[index] ?? -1);
-    return links.some((link) => link.start <= at && at < link.end);
-  };
-};
-
 /** 英語は大文字と小文字を区別せずに数える。文頭の "Proposals submitted via" も文中の "proposals submitted via" も同じ言い回し。 */
 const keyOf = (gram: string, unit: ProseDocument["lengthUnit"]): string => (unit === "word" ? gram.toLowerCase() : gram);
 
@@ -140,12 +133,16 @@ const gramsOf = (doc: ProseDocument, sentences: readonly Sentence[]): Tally => {
 
 type Repeat = { readonly key: string; readonly count: number; readonly at: FirstSeen | undefined };
 
-/** 範囲（gram-passages.ts）ごとに数える。よくある質問の別々の答えは別の範囲。 */
-const repeatsOf = (doc: ProseDocument, limit: number): Repeat[] =>
+/** 範囲（gram-passages.ts）ごとに数える。よくある質問の別々の答えは別の範囲。節の最初の文にだけ出るものは節のひな形（gram-openers.ts）。 */
+const repeatsOf = (doc: ProseDocument, limit: number, openers = sectionOpeners(doc.sections, doc.source)): Repeat[] =>
   gramPassagesOf(doc.sections).flatMap((sentences) => {
     const tally = gramsOf(doc, sentences);
+    const opening = gramsOf(
+      doc,
+      sentences.filter((sentence) => openers.has(sentence)),
+    ).counts;
     return [...tally.counts.entries()]
-      .filter(([key, count]) => count > limit && isPhrasing(key, doc.lengthUnit))
+      .filter(([key, count]) => count > limit && isPhrasing(key, doc.lengthUnit) && (opening.get(key) ?? 0) < count)
       .map(([key, count]) => ({ key, count, at: tally.first.get(key) }));
   });
 
@@ -184,9 +181,10 @@ export const ngramRepetition: Detector = (doc, options): Finding[] => {
  *
  * & で繋いだ大文字は 1 語として読む（ATT&CK、M&IE）。割ると CK や IE が別の略語に見える。
  * - で繋いだ略語どうしも 1 語（RT-PCR）。割ると RT が別の略語に見える。数字を含むもの（COVID-19）は識別子として外す。
+ * 下付きの数字が続く大文字は化学式（CO₂、SO₄）で、説明を待つ略語ではない。数字や小文字が続くもの（CO2、NOx）と同じく語の途中と読む。
  */
 const EDGE_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
-const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&])`;
+const EDGE_AFTER = String.raw`(?![A-Za-z0-9_&\u2080-\u2089])`;
 /** 略語として読む大文字の長さの上限。これより長い大文字の語（BILLING）は、普通の語を大文字で書いたもの。 */
 const ACRONYM_MAX = 6;
 const ACRONYM_PART = String.raw`(?:[A-Z]+(?:&[A-Z]+)+|[A-Z]{2,${ACRONYM_MAX}})`;
@@ -274,9 +272,10 @@ const outsideSpans = (hits: readonly AcronymHit[], spans: readonly Span[]): Acro
 /**
  * どこか 1 か所で展開してあればよい。初出が節の見出し代わりの語（「5.3. DPA.」）で、
  * 展開がその直後の文にあることが契約書では普通にある。見るのは語として現れた所だけ（CISA の中の CI は見ない）。
+ * 複数形（Special Interest Groups (SIGs)）の展開は、s の無い略語（SIG）の展開でもある。
  */
 const isExpanded = (body: string, acronym: string, expandedAt: ExpandedAt): boolean =>
-  [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}${EDGE_AFTER}`, "gu"))].some((match) => expandedAt(body, acronym, match.index));
+  [...body.matchAll(new RegExp(`${EDGE_BEFORE}${acronym}s?${EDGE_AFTER}`, "gu"))].some((match) => expandedAt(body, match[0], match.index));
 
 /**
  * 見出しは文にならないので、見出しの中の展開（Maximum Envelope of Water (MEOW) runs）は見出しの文字列で探す。
@@ -287,35 +286,13 @@ const expandsInHeading = (heading: string, acronym: string, expandedAt: Expanded
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
 
-const notationOf = (doc: ProseDocument): NotAcronymSpans => {
-  const notation = 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"),
-    abbreviatedLabels: patternsOf(doc, "abbreviated-label"),
-    honorifics: patternsOf(doc, "honorific"),
-    titles: patternsOf(doc, "name-title"),
-    dateTimeUnits: patternsOf(doc, "date-time-unit"),
-  });
-  const names = nameSpansOf({
-    legalForms: patternsOf(doc, "legal-form"),
-    determiners: patternsOf(doc, "name-determiner"),
-    citationSeries: patternsOf(doc, "citation-series"),
-    carriers: patternsOf(doc, "carrier-name"),
-    namePrefixes: patternsOf(doc, "name-prefix"),
-    streetSuffixes: patternsOf(doc, "street-suffix"),
-    capitalPhrases: patternsOf(doc, "capital-phrase"),
-  });
-  return (text) => [...notation(text), ...names(text)];
-};
+const notationOf = (doc: ProseDocument): NotAcronymSpans => lexiconNotationOf((id) => patternsOf(doc, id));
 
-/** 定義の語は、語彙表の形（という）と、この文書で活用して書かれた形（といいます）の両方で照らす。 */
-const definitionVerbsOf = (doc: ProseDocument): string[] => {
+/** 定義の語。定義の動詞は、語彙表の形（という）と、この文書で活用して書かれた形（といいます）の両方で照らす。 */
+const definitionWordsOf = (doc: ProseDocument): DefinitionWords => {
   const verbs = patternsOf(doc, "definition-verb");
-  return [...verbs, ...conjugatedForms(doc.sentences, verbs)];
+  const alternatives = patternsOf(doc, "definition-alternative");
+  return { markers: patternsOf(doc, "definition-marker"), verbs: [...verbs, ...conjugatedForms(doc.sentences, verbs)], alternatives };
 };
 
 const acronymFinding = (acronym: string, hit: Hit, count: number, limit: number): Finding => ({
@@ -340,32 +317,37 @@ export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
   // HTTP のメソッド名（GET）は略語ではなく、税の名前（VAT、GST）は読み手が名前として知るので、通じる略語と同じく展開を求めない。
   // 並べた名前（JAXA）も、繋いだ略語（JAXA-ISAS）の片割れとして説明済みに数える。
+  // 文書が自分で知らせた語（select を書いた文書の SELECT、リンクで引いた講演の場 [Jane Roe, FOSDEM 2024](…)）も同じ。
   const common = new Set([
     ...(options.lexicon ?? []).map((entry) => entry.pattern),
-    ...patternsOf(doc, "http-method"),
-    ...patternsOf(doc, "tax-code"),
+    ...knownByDocument(doc.source, doc.links).concat(patternsOf(doc, "http-method"), patternsOf(doc, "tax-code")),
     ...(doc.names ?? []),
   ]);
-  const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
+  const expandedAt = expansionAt(definitionWordsOf(doc));
   const stated = statedAcronyms(doc.source, { statements: patternsOf(doc, "definition-statement"), markers: patternsOf(doc, "definition-marker") });
   const entries = new Set([...termEntryAcronyms(doc.source), ...stated]);
   const headings = doc.sections.map((section) => section.heading);
   const explainedAlone = (word: string): boolean =>
     common.has(word) || entries.has(word) || isExpanded(body, word, expandedAt) || headings.some((heading) => expandsInHeading(heading, word, expandedAt));
-  const hits = outsideSpans(acronymsOf(doc, notationOf(doc)), [
+  const counted = outsideSpans(acronymsOf(doc, notationOf(doc)), [
     ...referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")),
     ...outlineLabelSpans(doc.source, patternsOf(doc, "numbered-division")),
   ]);
+  // リンク先のページの題名の略語（[NASA Fprime AI Policy](https://…)）は、読み手が出会う説明の無い略語として数に入れるが、
+  // 書き手が直せないので指さない。
+  const hits = outsideSpans(counted, linkTitleSpans(doc.source, doc.links));
   const acronyms = [...firstHits(hits).keys()];
   const unexplained = new Set(acronyms.filter((acronym) => !isExplained(acronym, explainedAlone)));
+  const quoted = [...firstHits(counted).keys()].filter((acronym) => !acronyms.includes(acronym) && !isExplained(acronym, explainedAlone)).length;
   const bracketed = (acronym: string): boolean => [body, ...headings].some((text) => isBracketed(text, acronym));
   // 定義の一覧（"SOW" means …）で定義する書き手も、略語を展開する書き手と数える。
   const definedByWriter = (acronym: string): boolean => bracketed(acronym) || stated.has(acronym);
   const writerSpellsOut = acronyms.filter((acronym) => !common.has(acronym) && explainedAlone(acronym) && definedByWriter(acronym)).length >= options.limit;
   // 日付を読むには文書の木を作る。上限に届かない文書では作らない。
-  if (unexplained.size < options.limit && !writerSpellsOut) return [];
+  if (unexplained.size + quoted < options.limit && !writerSpellsOut) return [];
   const bare = [...firstHits(outsideSpans(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
-  if (bare.length >= options.limit) return bare.map(([acronym, hit]) => acronymFinding(acronym, hit, bare.length, options.limit));
+  const met = bare.length + quoted;
+  if (met >= options.limit) return bare.map(([acronym, hit]) => acronymFinding(acronym, hit, met, options.limit));
   if (!writerSpellsOut) return [];
   const alone = bare.filter(([acronym, hit]) => !isNamePartAt(acronym, hit) && !isInHeading(headings, acronym));
   return alone.map(([acronym, hit]) => acronymFinding(acronym, hit, alone.length, options.limit));

package/src/detectors/structure-tree.ts

@@ -1,6 +1,8 @@
 import type { Detector, Finding, ProseDocument, StructureNode } from "../plugin.ts";
 import { danglingReferences, duplicateDefinitions, inDocumentOrder, type StructureIssue } from "../structure/issues.ts";
 import { numberingBreaks } from "../structure/numbering.ts";
+import { attachedPartStarts } from "../structure/attached-parts.ts";
+import { sideStepReader } from "../structure/side-step.ts";
 import { htmlTextBlocks } from "../structure/html-text-blocks.ts";
 import { listsNumberBreaks } from "../structure/list-numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
@@ -9,6 +11,7 @@ import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
 import { isListedTotal, isPeriodTotalLine, isTotalLikeLine, isTotalLine } from "../structure/total-line.ts";
 import { proseTotalMismatches } from "../structure/prose-total.ts";
+import { proseTotalWordsOf } from "./prose-total-words.ts";
 import { countedAmounts, type SummedCounter } from "../structure/counted-amounts.ts";
 import { measuredAmounts, type MeasureMarks, type SummedMeasure } from "../structure/measured-amounts.ts";
 import { withCompoundHours } from "../structure/compound-hours.ts";
@@ -41,7 +44,7 @@ const findingsOf =
     doc.structure === undefined
       ? []
       : issuesOf(doc.structure, doc.source).map((issue) => ({
-          rule,
+          ...(issue.variant === undefined ? { rule } : { rule, variant: issue.variant }),
           severity: "error",
           line: 0,
           column: 0,
@@ -52,8 +55,11 @@ const findingsOf =
 export const danglingReference: Detector = (doc, options) =>
   findingsOf("dangling-reference", (tree, source) => danglingReferences(tree, source, patternsOf(doc, "section-name-noun")))(doc, options);
 /** Markdown の HTML ブロックの中の条は木に入らない。そこを挟んだ抜けは、見えなかった番号かもしれない。 */
-const structureNumberingGap: Detector = (doc, options) =>
-  findingsOf("numbering-gap", (tree, source) => numberingBreaks(tree, doc.markup?.markdown === true ? htmlTextBlocks(source) : []))(doc, options);
+const structureNumberingGap: Detector = (doc, options) => {
+  const isSideStep = sideStepReader(patternsOf(doc, "side-step-label"));
+  const hiddenBlocks = (source: string) => (doc.markup?.markdown === true ? htmlTextBlocks(source) : []);
+  return findingsOf("numbering-gap", (tree, source) => numberingBreaks(tree, hiddenBlocks(source), isSideStep))(doc, options);
+};
 
 const lineStartAt = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
 
@@ -90,7 +96,10 @@ export const numberingGap: Detector = (doc, options): Finding[] => {
     (left, right) => Number(left.values["offset"]) - Number(right.values["offset"]),
   );
 };
-export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);
+export const duplicateDefinition: Detector = (doc, options) => {
+  const labels = patternsOf(doc, "attached-instrument-label");
+  return findingsOf("duplicate-definition", (tree, source) => duplicateDefinitions(tree, attachedPartStarts(source, labels)))(doc, options);
+};
 
 /** 曜日の名前は言語パッケージの語彙表（weekday、日曜日から順）から取る。無ければ番号のまま。 */
 const dayName = (doc: ProseDocument, day: unknown): string => {
@@ -262,20 +271,11 @@ const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["struct
     (text) => isPeriodTotalLine(text, words),
     { isListed: (text) => isListedTotal(text, words), isTotalLike: (text, header) => isTotalLikeLine(text, words, header) },
   );
-  const phrases = {
-    totals: patternsOf(doc, "total-phrase"),
-    breakdowns: patternsOf(doc, "breakdown-phrase"),
-    discounts: patternsOf(doc, "discount-word"),
-    joiners: patternsOf(doc, "breakdown-gap-joiner"),
-    leads: patternsOf(doc, "total-breakdown-lead"),
-    partials: patternsOf(doc, "breakdown-partial-word"),
-    backReferences: patternsOf(doc, "total-back-reference"),
-  };
   const prose = proseTotalMismatches(
     doc.source,
     doc.sentences.map((sentence) => sentence.span),
     amounts,
-    phrases,
+    proseTotalWordsOf(doc),
   );
   return [...lines, ...prose.filter((issue) => !lines.some((line) => line.offset === issue.offset))];
 };

package/src/detectors/structure.ts

@@ -138,7 +138,8 @@ const withoutDateStamps = (doc: ProseDocument, paragraphs: readonly Paragraph[])
 export const preambleLength: Detector = (doc, options): Finding[] => {
   const body = bodySectionOf(doc.sections);
   if (body === undefined) return [];
-  const all = preambleParagraphs(doc.paragraphs, body.span.start, doc.source);
+  const noteMarks = (doc.lexicons["note-mark"] ?? []).map((entry) => entry.pattern);
+  const all = preambleParagraphs(doc.paragraphs, body.span.start, doc.source, noteMarks);
   if (all.length <= options.limit) return [];
   const before = withoutDateStamps(doc, all);
   if (before.length <= options.limit) return [];

package/src/detectors/subject-name-line.ts

@@ -0,0 +1,66 @@
+// A line under a heading that gives the name of what the heading is about, not a sentence restating it: the label of a
+// link or an attachment the heading introduces (### 実施要綱について → 実施要綱), or a list named after the heading
+// (## 皆さんの声 → 「皆さんの声」一覧). A converted page keeps such labels as plain lines. Pure.
+import { isContent } from "./content-morphemes.ts";
+import type { Token } from "../plugin.ts";
+
+/** A title is made of these: names, the words that build a name (annual, の, of, and), no predicate. */
+const TITLE_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN", "NUM", "PUNCT", "SYM", "X", "ADJ", "ADP", "DET", "CCONJ"]);
+/** A line that ends like a sentence says something, whatever its words. */
+const SENTENCE_END = /[。．.!?！？]$/u;
+
+const isTitle = (tokens: readonly Token[]): boolean => tokens.some(isContent) && tokens.every((token) => TITLE_POS.has(token.pos));
+
+const baseForm = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();
+
+/** Brackets a line quotes a title in. */
+const QUOTES: readonly (readonly [string, string])[] = [
+  ["「", "」"],
+  ["『", "』"],
+  ["“", "”"],
+  ['"', '"'],
+];
+
+type Span = { readonly start: number; readonly end: number };
+
+/** Where the line quotes the whole heading as a title, in the tokens' coordinates. */
+const quotedHeading = (heading: string, line: string, lineStart: number): Span | undefined => {
+  const quoted = QUOTES.map(([open, close]) => `${open}${heading}${close}`).find((form) => line.includes(form));
+  if (quoted === undefined) return undefined;
+  const start = lineStart + line.indexOf(quoted);
+  return { start, end: start + quoted.length };
+};
+
+/** 「見出し」一覧: the heading quoted as a title, and only a name after it that says what the line is (一覧, page). */
+const namesListAfterHeading = (outside: readonly Token[]): boolean => isTitle(outside);
+
+/**
+ * 実施要綱 under ### 実施要綱について: the line is a title, and what the heading has beyond it only frames the name (について,
+ * About, 紹介). A line that copies the heading whole (### 研究科 → 研究科) is a repeat, and one that drops a word of the
+ * heading's own (### 精算方法の概要 → 精算方法) does not name the heading's subject.
+ */
+const namesHeadingTopic = (heading: readonly Token[], line: readonly Token[], announcing: ReadonlySet<string>): boolean => {
+  if (!isTitle(line)) return false;
+  const named = new Set(line.map(baseForm));
+  const beyond = heading.filter((token) => token.pos !== "PUNCT" && !named.has(baseForm(token)));
+  return beyond.length > 0 && beyond.every((token) => !isContent(token) || announcing.has(baseForm(token)));
+};
+
+/**
+ * The first line under a heading names what the heading is about. `heading` is the heading's text without its number
+ * label, `headingTokens` its tokens; `lineTokens` are the line's, in the coordinates `lineStart` gives. `announcing`
+ * holds the words that only frame a subject (the heading-announcer lexicon's ungrouped entries).
+ */
+export const namesHeadingSubject = (
+  heading: string,
+  headingTokens: readonly Token[],
+  line: string,
+  lineStart: number,
+  lineTokens: readonly Token[],
+  announcing: ReadonlySet<string>,
+): boolean => {
+  if (line.trim().includes("\n") || SENTENCE_END.test(line.trim()) || heading.trim() === "") return false;
+  const quoted = quotedHeading(heading.trim(), line, lineStart);
+  if (quoted !== undefined) return namesListAfterHeading(lineTokens.filter((token) => token.span.start < quoted.start || token.span.start >= quoted.end));
+  return namesHeadingTopic(headingTokens, lineTokens, announcing);
+};

package/src/detectors/table-header.ts

@@ -53,7 +53,21 @@ const rawCells = (line: Line): { readonly raw: string; readonly from: number }[]
   return inner.at(-1)?.raw.trim() === "" ? inner.slice(0, -1) : inner;
 };
 
-const labelCell = (line: Line, { raw, from }: { readonly raw: string; readonly from: number }): HeaderCell[] => {
+/**
+ * An inline HTML tag in a cell (`<div style="…">`, `</div>`, `<br/>`): the reader sees none of it. A tag name ends at a space,
+ * a slash or `>`, so an autolink (`<https://…>`) is not one; an attribute in double quotes may hold a `>`.
+ */
+const HTML_TAG = /<\/?[A-Za-z][\w-]*(?:\s(?:"[^"]*"|[^<>"])*)?\/?>/gu;
+
+/**
+ * The cell with its HTML tags blanked out, same length, so the words keep their offsets and the spaces around them trim.
+ * A cell with a code span is left whole: a tag written in code is text the reader sees.
+ */
+const withoutTags = (raw: string): string => (raw.includes("`") ? raw : raw.replace(HTML_TAG, (tag) => " ".repeat(tag.length)));
+
+const labelCell = (line: Line, cell: { readonly raw: string; readonly from: number }): HeaderCell[] => {
+  const { from } = cell;
+  const raw = withoutTags(cell.raw);
   const trimmed = raw.trim();
   const unwrapped = unwrap(trimmed);
   const written = unwrapped.replace(INNER_MARKS, "").trim();

package/src/detectors/technical-docs.ts

@@ -6,6 +6,7 @@ import { codeFences, codeSpans, type CodeFence } from "./code-fences.ts";
 import { opensAsNounPhrase } from "./nominal-step.ts";
 import { quoteAt } from "./structure-tree.ts";
 import { escapeRegExp } from "../orthography.ts";
+import { isFormatTemplate } from "../format-template.ts";
 import type { Detector, Finding, ProseDocument, Span, Token } from "../plugin.ts";
 
 const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
@@ -25,6 +26,9 @@ const finding = (doc: ProseDocument, rule: string, offset: number, values: Reado
   values: { ...values, offset },
 });
 
+/** A fence that should name a language: an untagged format template (<MAJOR>.<MINOR>) is in none, so it is left out. */
+const wantsLanguage = (fence: CodeFence): boolean => fence.language !== "" || !isFormatTemplate(fence.lines);
+
 /** Fences without a language, when they are the fewer kind: a document that mostly leaves the language out is not reported. */
 export const untaggedFewer = (fences: readonly CodeFence[], limit: number): readonly CodeFence[] => {
   const untagged = fences.filter((fence) => fence.language === "");
@@ -33,7 +37,7 @@ export const untaggedFewer = (fences: readonly CodeFence[], limit: number): read
 };
 
 export const codeFenceLanguage: Detector = (doc, options): Finding[] => {
-  const fences = codeFences(doc.source);
+  const fences = codeFences(doc.source).filter(wantsLanguage);
   const tagged = fences.filter((fence) => fence.language !== "").length;
   return untaggedFewer(fences, options.limit).map((fence) =>
     finding(doc, "code-fence-language-mix", fence.start, { tagged, untagged: fences.length - tagged }),

package/src/detectors/term-mention-sentence.ts

@@ -0,0 +1,31 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { Sentence } from "../plugin.ts";
+
+// An entry of a definitions list opens with the term it defines, in quotes ("Capital Contributions" The capital
+// contribution to the Venture …). The words after the quoted name are the definition's own body, not uses of the term.
+// Pure.
+
+/** The ending a quoted name may carry past the term: a plural or a possessive (Contributions, Contribution's). */
+const ENDING = String.raw`(?:e?s|['’]s)?`;
+/** The label of a list item before the entry (a., (b), 1., iv)). */
+const ITEM_LABEL = String.raw`(?:\(?[\p{L}\p{N}]{1,4}[.)]\s+)?`;
+/** The quotes a term is named in, each with its own closing mark. */
+const QUOTE_PAIRS = [
+  ['"', '"'],
+  ["“", "”"],
+  ["「", "」"],
+  ["『", "』"],
+] as const;
+
+const entryHead = (term: string): RegExp => {
+  const quoted = QUOTE_PAIRS.map(([open, close]) => `${open}${escapeRegExp(term)}${ENDING}${close}`).join("|");
+  return new RegExp(`^\\s*${ITEM_LABEL}(?:${quoted})`, "u");
+};
+
+/** Whether the sentence holding offset is a definitions entry that opens with the term in quotes, and offset is after that name. */
+export const inEntryOfTerm = (sentences: readonly Sentence[], term: string, offset: number): boolean => {
+  const sentence = sentences.find((candidate) => candidate.span.start <= offset && offset < candidate.span.end);
+  if (sentence === undefined) return false;
+  const head = entryHead(term).exec(sentence.text);
+  return head !== null && offset - sentence.span.start >= head[0].length;
+};