chaffjs 0.35.0 → 0.37.0

package/src/detectors/signals.ts

@@ -1,20 +1,23 @@
 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 { linkedListTerms, linkTitleSpans } from "./acronym-link.ts";
+import { caseVariantsIn, spelledOutAcronyms } from "./acronym-mention.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 +100,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 +134,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 +182,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 +273,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 +287,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 +318,51 @@ 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]);
+  // 一覧の語のすぐ下でその語を名指すリンク（- GPL / [GNU General Public License …](…)）と、略語を話題にして書き出した文
+  // （the abbreviation DOB … date of birth）も、略語の説明と読む。
+  const spelled = spelledOutAcronyms(
+    doc.sentences.map((sentence) => sentence.text),
+    patternsOf(doc, "abbreviation-mention"),
+  );
+  const entries = new Set([...termEntryAcronyms(doc.source), ...stated, ...linkedListTerms(doc.source), ...spelled]);
   const headings = doc.sections.map((section) => section.heading);
-  const explainedAlone = (word: string): boolean =>
+  const explainedAsWritten = (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)), [
+  // 大文字の違うだけの書き方（TCoP と TCOP）は同じ略語と読む。どちらかで説明してあれば説明済み。
+  const written = [body, ...headings].join("\n");
+  const explained = new Map<string, boolean>();
+  const explainedAlone = (word: string): boolean => {
+    const known = explained.get(word) ?? (explainedAsWritten(word) || caseVariantsIn(written, word).some(explainedAsWritten));
+    explained.set(word, known);
+    return known;
+  };
+  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/superlative-name.ts

@@ -31,3 +31,13 @@ export const namesQuantity = (tokens: readonly Token[], range: TokenRange, quant
   const last = single ? lastJoined(tokens, range.end) : undefined;
   return last !== undefined && measures(last, quantities);
 };
+
+/**
+ * 最上級の名詞に空白を挟まず接尾辞が付いて、別の語になっているか（最大化・最大化する）。「最大にする」という動詞で、
+ * 何かが一番だという主張ではない。接尾辞は言語パッケージの語彙表が持つ。
+ */
+export const makesWord = (tokens: readonly Token[], range: TokenRange, suffixes: Lexicon): boolean => {
+  const last = tokens[range.end - 1];
+  const next = tokens[range.end];
+  return last !== undefined && next !== undefined && last.span.end === next.span.start && suffixes.some((entry) => entry.pattern === next.surface);
+};

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

package/src/detectors/titled-run.ts

@@ -6,8 +6,12 @@ export type TitleWords = { readonly endings: readonly string[] };
 
 /** 題を囲む括弧。鉤括弧と、見出しや分類の名前を囲む隅付き括弧。 */
 const TITLE_MARKS = { "「": "」", "『": "』", "【": "】" };
-/** 名前のすぐ後ろに付く、その名前の補い（就職氷河期世代）、略称（以下「奨励金」という。）、日付や番号。 */
-const QUALIFIER_OPENERS = new Set(["（", "("]);
+/**
+ * 名前のすぐ後ろ（同じ行の空白を挟んでもよい）に付く、その名前の補い（就職氷河期世代、＜創業型＞）、略称（以下「奨励金」という。）、
+ * 日付や番号、ファイルの種類と大きさ（[PDFファイル／333KB]）の括弧。角括弧は同じ行で閉じ、Markdown のリンク（[文字](…)）でないもの。
+ * 半角の < は HTML の札と見分けられないので読まない。
+ */
+const QUALIFIER = /^[ \t\u3000]*(?:[（(＜〈［]|\[[^\]\n]*\](?![([]))/u;
 /** 閉じる語の前に要る字数。1 字なら、題ではなく普通の語（新法、本事業）。 */
 const MIN_BODY_LENGTH = 2;
 const BLANK = /^\s*$/u;
@@ -27,11 +31,12 @@ export const endsInTitle = (run: readonly Token[], words: TitleWords): boolean =
 /**
  * 文（text）の start から end までの連なりが、題の名前の置き方をしているか。
  * 括弧の中身の終わりで閉じる（「令和8年度高度統計人材育成強化拠点形成事業」）、すぐ後ろに補いの括弧が付く
- * （国家公務員中途採用者選考試験（就職氷河期世代））、または文がその連なりだけ（要綱の題を並べた行）。
+ * （国家公務員中途採用者選考試験（就職氷河期世代）、持続化補助金＜創業型＞、登録申込書 [PDFファイル／333KB]）、
+ * または文がその連なりだけ（要綱の題を並べた行）。
  */
 export const isTitlePosition = (text: string, start: number, end: number): boolean => {
   const closesBracket = quotedSpans(text, TITLE_MARKS).some((span) => span.end === end && span.start <= start);
-  const qualified = QUALIFIER_OPENERS.has(text.charAt(end));
+  const qualified = QUALIFIER.test(text.slice(end));
   const alone = BLANK.test(text.slice(0, start)) && BLANK.test(text.slice(end));
   return closesBracket || qualified || alone;
 };

package/src/detectors/token-shape.ts

@@ -1,10 +1,13 @@
 import { hasParticle, isClosed, lastContent } from "../sentence-shape.ts";
 import { isWithinAny, quotedIn } from "../quoted-span.ts";
+import { chronologyRows } from "../chronology-rows.ts";
+import { externalLinkTitleSpans } from "../link-title.ts";
 import type { Detector, Finding, Span, Token } from "../plugin.ts";
+import { countedTokens, uncountedWordsOf } from "../uncounted-particles.ts";
 
 /**
  * 文末が名詞で終わる（体言止め）。箇条書きでは普通だが、本文では文が途中で切れて読める。
- * 実文書で測ったら、指摘の 9 割が箇条書きの項目だった。箇条書きは除く。
+ * 実文書で測ったら、指摘の 9 割が箇条書きの項目だった。箇条書きは除く。年表の行（1950年4月 設立。）も名詞で止める書き方なので除く。
  */
 const NOMINAL = new Set(["NOUN", "PROPN"]);
 
@@ -14,8 +17,9 @@ const isDependent = (token: Token): boolean => token.features?.["NounType"] ===
 const inside = (span: Span, spans: readonly Span[]): boolean => spans.some((other) => span.start >= other.start && span.start < other.end);
 
 export const nounEnding: Detector = (doc, options): Finding[] => {
+  const rows = chronologyRows(doc);
   const ended = doc.sentences.filter((sentence) => {
-    if (inside(sentence.span, doc.listSpans) || !isClosed(sentence) || !hasParticle(sentence)) return false;
+    if (inside(sentence.span, doc.listSpans) || rows.has(sentence) || !isClosed(sentence) || !hasParticle(sentence)) return false;
     const last = lastContent(sentence);
     return last !== undefined && NOMINAL.has(last.pos) && !isDependent(last);
   });
@@ -62,19 +66,26 @@ const BREAK: Run = { surface: "", tokens: [] };
  *
  * 鉤括弧で引いたもの（括弧ごと）は、名詞と同じく連なりの中身として飛ばす。引いた題名（「食品中のウイルスの制御のための…ガイドライン」）や
  * 発言は書き手が言い換えられないので、中の助詞は数えない。題名も名前なので、外の連なり（弊社の「新製品」の販売の計画）は続けて数える。
+ * 外のページの題名を引いたリンクの文字（- [サービスの料金の計算の方法](https://…)）も、引いた題名と同じに読む。
  */
-const runsOf = (tokens: readonly Token[], nesting: readonly string[], quoted: readonly Span[]): Run[] =>
+const runsOf = (tokens: readonly Token[], nesting: readonly string[], breaks: readonly string[], quoted: readonly Span[]): Run[] =>
   tokens.reduce<Run[]>((acc, token) => {
     if (isWithinAny(quoted, token.span)) return acc;
     if (nesting.includes(token.surface)) return extend(acc, token);
-    if (token.pos === "PUNCT" || PARTICLE.has(token.pos)) acc.push(BREAK);
+    if (token.pos === "PUNCT" || PARTICLE.has(token.pos) || breaks.includes(token.surface)) acc.push(BREAK);
     return acc;
   }, []);
 
+/** 句と句の間の記号（制限=タグの制限、A→B）。半角の = や : は名詞として読まれ、句読点のようには切れない。 */
+const RUN_BREAK_LEXICON = "particle-run-break";
+
 export const doubledParticle: Detector = (doc, options): Finding[] => {
   const nesting = (options.lexicon ?? []).map((entry) => entry.pattern);
+  const titles = externalLinkTitleSpans(doc.source, doc.links);
+  const breaks = (doc.lexicons[RUN_BREAK_LEXICON] ?? []).map((entry) => entry.pattern);
+  const numbering = uncountedWordsOf(doc.lexicons, nesting);
   return doc.sentences.flatMap((sentence) =>
-    runsOf(sentence.tokens ?? [], nesting, quotedIn(sentence))
+    runsOf(countedTokens(sentence.tokens ?? [], numbering), nesting, breaks, [...quotedIn(sentence), ...titles])
       .filter((run) => run.tokens.length > options.limit)
       .map((run) => ({
         rule: "no-doubled-joshi",

package/src/detectors/undefined-term.ts

@@ -81,6 +81,12 @@ export const undefinedTerms = (source: string, sentences: readonly (readonly Tok
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
+/** The words of one group of a lexicon; undefined: the entries with no group. */
+const groupOf = (doc: ProseDocument, lexicon: string, group: string | undefined): string[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+const ATTACHED = "attached-document-cue";
+
 const findingOf = (doc: ProseDocument, use: UndefinedTerm): Finding => ({
   rule: "undefined-term",
   severity: "info",
@@ -107,6 +113,8 @@ const capitalisedUses = (doc: ProseDocument, sentences: readonly (readonly Token
     definedElsewhere: patternsOf(doc, "defined-elsewhere"),
     capacityMarkers: patternsOf(doc, "capacity-marker"),
     articles: patternsOf(doc, "article"),
+    attachedCues: groupOf(doc, ATTACHED, undefined),
+    attachedTitleEnds: groupOf(doc, ATTACHED, "title-end"),
   };
   const marked = [...(doc.markup?.headings ?? []), ...doc.links, ...setApartSpans(doc.source)];
   return capitalisedTerms({ source: doc.source, readable: readableText(doc.source), sentences, defined, named: namedWords(doc.source), marked, words });

package/src/detectors/unknown-word.ts

@@ -13,7 +13,7 @@ const MAX_LENGTH = 30;
 const patternsOf = (doc: ProseDocument, name: string): string[] => (doc.lexicons[name] ?? []).map((entry) => entry.pattern.toLowerCase());
 
 /** 辞書と、語彙表 extra-word の語と、チームの names と、別の rule が言う誤り（known-misspelling）を足した語。 */
-const spellerOf = (doc: ProseDocument, dictionary: ReadonlySet<string>): Speller => ({
+export const spellerOf = (doc: ProseDocument, dictionary: ReadonlySet<string>): Speller => ({
   words: [dictionary, new Set([...patternsOf(doc, "extra-word"), ...(doc.names ?? []).map((name) => name.toLowerCase())])],
   suffixes: (doc.lexicons["word-suffix"] ?? []).map((entry) => ({ suffix: entry.pattern, replacement: entry.instead_of ?? "" })),
   prefixes: patternsOf(doc, "word-prefix"),

package/src/detectors/vague-density.ts

@@ -8,8 +8,11 @@ import { escapeRegExp } from "../orthography.ts";
 import type { Detector, Finding, Lexicon, LexiconEntry, Sentence } from "../plugin.ts";
 import { comparableText, comparableWords, entryRanges } from "./lexicon-match.ts";
 import { rateOver } from "./lexicon.ts";
+import { specifiedByBracket } from "./bracket-specified.ts";
 
 const TERMS_OF_ART = "vague-word-term-of-art";
+/** The words that start an aside giving a name (以下「HR」という, hereinafter): such an aside pins nothing down. */
+const NAME_MARKERS = "definition-marker";
 
 type Place = { readonly start: number; readonly end: number };
 
@@ -36,13 +39,25 @@ const covers = (outer: Place, inner: Place): boolean => outer.start <= inner.sta
 
 const isLonger = (outer: Match, inner: Match): boolean => outer.place.end - outer.place.start > inner.place.end - inner.place.start;
 
-/** The vague words of one sentence, in the order written, each once: none inside a longer vague word or a term of art. */
-export const vagueWordsIn = (sentence: Sentence, vague: Lexicon, termsOfArt: Lexicon): string[] => {
+/** Whether a bracket right after the match pins the word down; token places are in the document, text places in the comparable text. */
+const pinnedDown = (sentence: Sentence, match: Match, byTokens: boolean, nameMarkers: readonly string[]): boolean =>
+  byTokens
+    ? specifiedByBracket(sentence.text, match.place.end - sentence.span.start, nameMarkers)
+    : specifiedByBracket(comparableText(sentence), match.place.end, nameMarkers);
+
+/**
+ * The vague words of one sentence, in the order written, each once: none inside a longer vague word or a term of art,
+ * and none pinned down by the bracket right after it (一定の事項（…）). nameMarkers: the words that start a name in an aside.
+ */
+export const vagueWordsIn = (sentence: Sentence, vague: Lexicon, termsOfArt: Lexicon, nameMarkers: readonly string[] = []): string[] => {
   const byTokens = readsTokens(sentence, [...vague, ...termsOfArt]);
   const matches = matchesOf(sentence, vague, byTokens);
   const terms = matchesOf(sentence, termsOfArt, byTokens);
   const kept = matches.filter(
-    (match) => !matches.some((other) => isLonger(other, match) && covers(other.place, match.place)) && !terms.some((term) => covers(term.place, match.place)),
+    (match) =>
+      !matches.some((other) => isLonger(other, match) && covers(other.place, match.place)) &&
+      !terms.some((term) => covers(term.place, match.place)) &&
+      !pinnedDown(sentence, match, byTokens, nameMarkers),
   );
   return [...new Set(kept.toSorted((left, right) => left.place.start - right.place.start).map((match) => match.pattern))];
 };
@@ -51,8 +66,9 @@ type SentenceHits = { readonly sentence: Sentence; readonly words: readonly stri
 
 export const vagueDensity: Detector = (doc, options): Finding[] => {
   const termsOfArt = entriesForGenre(doc.lexicons[TERMS_OF_ART] ?? [], options.genre);
+  const nameMarkers = (doc.lexicons[NAME_MARKERS] ?? []).map((entry) => entry.pattern);
   const hits: SentenceHits[] = doc.sentences
-    .map((sentence) => ({ sentence, words: vagueWordsIn(sentence, options.lexicon ?? [], termsOfArt) }))
+    .map((sentence) => ({ sentence, words: vagueWordsIn(sentence, options.lexicon ?? [], termsOfArt, nameMarkers) }))
     .filter((hit) => hit.words.length > 0);
   const count = hits.reduce((sum, hit) => sum + hit.words.length, 0);
   const density = rateOver(doc, count, options.limit);