chaffjs 0.33.0 → 0.35.0

package/src/detectors/signals.ts

@@ -4,12 +4,17 @@ import { compacted, placeAt, type Compacted } 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 { isExplained } from "./acronym-compound.ts";
+import { statedAcronyms } from "./acronym-definition.ts";
+import { isBracketed, isInHeading, isNamePart } from "./acronym-lone.ts";
 import { conjugatedForms } from "./conjugated-form.ts";
-import { evidenceSpans, hasNumeral, startsWithin } from "./concrete-evidence.ts";
+import { evidenceSpans, hasNumeral, isClaim, isLabelOnly, startsWithin, type AdviceWords } from "./concrete-evidence.ts";
 import { letteredIndexEntries } from "./lettered-index.ts";
+import { outlineLabelSpans } from "./outline-label.ts";
 import { hasPredicateIn } from "./gram-predicate.ts";
+import { gramPassagesOf } from "./gram-passages.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
 import { referenceListSpans } from "../reference-lists.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence } from "../plugin.ts";
@@ -127,12 +132,23 @@ const tallySentence = (doc: ProseDocument, sentence: Sentence, tally: Tally): vo
     });
 };
 
-const gramsOf = (doc: ProseDocument): Tally => {
+const gramsOf = (doc: ProseDocument, sentences: readonly Sentence[]): Tally => {
   const tally: Tally = { counts: new Map(), first: new Map() };
-  doc.sentences.forEach((sentence) => tallySentence(doc, sentence, tally));
+  sentences.forEach((sentence) => tallySentence(doc, sentence, tally));
   return tally;
 };
 
+type Repeat = { readonly key: string; readonly count: number; readonly at: FirstSeen | undefined };
+
+/** 範囲（gram-passages.ts）ごとに数える。よくある質問の別々の答えは別の範囲。 */
+const repeatsOf = (doc: ProseDocument, limit: number): Repeat[] =>
+  gramPassagesOf(doc.sections).flatMap((sentences) => {
+    const tally = gramsOf(doc, sentences);
+    return [...tally.counts.entries()]
+      .filter(([key, count]) => count > limit && isPhrasing(key, doc.lengthUnit))
+      .map(([key, count]) => ({ key, count, at: tally.first.get(key) }));
+  });
+
 /**
  * 語句が文の中で占める範囲に、述語になる動詞か助動詞があるか（gram-predicate.ts）。
  * 品詞が無ければ見分けられないので、これまでどおり言い回しとして数える。
@@ -145,11 +161,8 @@ const hasPredicate = (at: FirstSeen | undefined, unit: ProseDocument["lengthUnit
 
 export const ngramRepetition: Detector = (doc, options): Finding[] => {
   if (wordsOf(doc) < MIN_DOCUMENT_LENGTH[doc.lengthUnit]) return [];
-  const tally = gramsOf(doc);
-  const worst = [...tally.counts.entries()]
-    .filter(([key, count]) => count > options.limit && isPhrasing(key, doc.lengthUnit))
-    .toSorted(([, left], [, right]) => right - left)
-    .map(([key, count]) => ({ key, count, at: tally.first.get(key) }))
+  const worst = repeatsOf(doc, options.limit)
+    .toSorted((left, right) => right.count - left.count)
     .find(({ at }) => hasPredicate(at, doc.lengthUnit));
   if (worst === undefined) return [];
   const at = worst.at?.sentence;
@@ -274,8 +287,8 @@ 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 =>
-  notAcronymSpansOf({
+const notationOf = (doc: ProseDocument): NotAcronymSpans => {
+  const notation = notAcronymSpansOf({
     meridiem: patternsOf(doc, "meridiem"),
     timeZones: patternsOf(doc, "time-zone"),
     currencies: patternsOf(doc, "currency-code"),
@@ -287,6 +300,17 @@ const notationOf = (doc: ProseDocument): NotAcronymSpans =>
     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 definitionVerbsOf = (doc: ProseDocument): string[] => {
@@ -294,30 +318,57 @@ const definitionVerbsOf = (doc: ProseDocument): string[] => {
   return [...verbs, ...conjugatedForms(doc.sentences, verbs)];
 };
 
+const acronymFinding = (acronym: string, hit: Hit, count: number, limit: number): Finding => ({
+  rule: "undefined-acronym",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { word: acronym, count, limit, offset: hit.offset },
+});
+
+const isNamePartAt = (acronym: string, hit: Hit): boolean => {
+  const start = hit.offset - hit.sentence.span.start;
+  return isNamePart(hit.sentence.text, start, start + acronym.length);
+};
+
+/**
+ * 説明のない略語が上限に届かなくても、この文書が自分で上限の数だけ略語を展開しているなら、展開しなかった 1 つも指す。
+ * 書き手が展開する文書では、展開の抜けは抜けとして読める。名前の一部の略語（SRI International）は、そのときも指さない。
+ */
 export const undefinedAcronym: Detector = (doc, options): Finding[] => {
   const body = bodyOf(doc);
-  // HTTP のメソッド名（GET）は略語ではないので、通じる略語と同じく展開を求めない。
+  // HTTP のメソッド名（GET）は略語ではなく、税の名前（VAT、GST）は読み手が名前として知るので、通じる略語と同じく展開を求めない。
   // 並べた名前（JAXA）も、繋いだ略語（JAXA-ISAS）の片割れとして説明済みに数える。
-  const common = new Set([...(options.lexicon ?? []).map((entry) => entry.pattern), ...patternsOf(doc, "http-method"), ...(doc.names ?? [])]);
+  const common = new Set([
+    ...(options.lexicon ?? []).map((entry) => entry.pattern),
+    ...patternsOf(doc, "http-method"),
+    ...patternsOf(doc, "tax-code"),
+    ...(doc.names ?? []),
+  ]);
   const expandedAt = expansionAt({ markers: patternsOf(doc, "definition-marker"), verbs: definitionVerbsOf(doc) });
-  const entries = termEntryAcronyms(doc.source);
+  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)), referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")));
-  const unexplained = new Set([...firstHits(hits).keys()].filter((acronym) => !isExplained(acronym, explainedAlone)));
+  const hits = outsideSpans(acronymsOf(doc, notationOf(doc)), [
+    ...referenceListSpans(doc.source, patternsOf(doc, "reference-list-heading")),
+    ...outlineLabelSpans(doc.source, patternsOf(doc, "numbered-division")),
+  ]);
+  const acronyms = [...firstHits(hits).keys()];
+  const unexplained = new Set(acronyms.filter((acronym) => !isExplained(acronym, explainedAlone)));
+  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) return [];
+  if (unexplained.size < options.limit && !writerSpellsOut) return [];
   const bare = [...firstHits(outsideSpans(hits, dateSpans(doc)))].filter(([acronym]) => unexplained.has(acronym));
-  if (bare.length < options.limit) return [];
-  return bare.map(([acronym, hit]) => ({
-    rule: "undefined-acronym",
-    severity: "info",
-    line: 0,
-    column: 0,
-    quote: hit.sentence.text.trim(),
-    values: { word: acronym, count: bare.length, limit: options.limit, offset: hit.offset },
-  }));
+  if (bare.length >= options.limit) return bare.map(([acronym, hit]) => acronymFinding(acronym, hit, bare.length, 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));
 };
 
 /**
@@ -341,9 +392,26 @@ const openingOf = (sentence: Sentence | undefined, unit: ProseDocument["lengthUn
 
 const hasNumeralIn = (section: Section): boolean => section.sentences.some((sentence) => hasNumeral(sentence.tokens ?? []));
 
+/** これより短い節は、具体物があるべきか判断できない。 */
+const MIN_SENTENCES = 3;
+
+const adviceWordsOf = (doc: ProseDocument): AdviceWords => ({
+  openers: (doc.lexicons["advice-opener"] ?? []).map((entry) => entry.pattern),
+  endings: (doc.lexicons["advice-ending"] ?? []).map((entry) => entry.pattern),
+});
+
+/** 文の半分以上が問いか指示の節（質問の一覧、手引き）は、数字で裏づける主張をしていない。番号だけの文（a.）は数えない。 */
+const mostlyClaims = (section: Section, language: string, advice: AdviceWords): boolean => {
+  const said = section.sentences.filter((sentence) => !isLabelOnly(sentence));
+  return said.filter((sentence) => isClaim(sentence, language, advice)).length * 2 > said.length;
+};
+
 export const concreteEvidence: Detector = (doc, options): Finding[] => {
   const entries = letteredIndexEntries(doc.sections);
-  const sections = doc.sections.filter((section) => section.sentences.length >= 3 && !entries.has(section));
+  const advice = adviceWordsOf(doc);
+  const sections = doc.sections.filter(
+    (section) => section.sentences.length >= MIN_SENTENCES && !entries.has(section) && mostlyClaims(section, doc.language, advice),
+  );
   const bare = sections.filter(
     (section) => !CONCRETE.test(doc.source.slice(section.span.start, section.span.end)) && !hasNumeralIn(section) && !startsWithin(section.span, doc.links),
   );

package/src/detectors/stated-amounts.ts

@@ -0,0 +1,20 @@
+// The amounts a document states, as the multiple and total checks read them: currency-notation's written amounts, each
+// read with amount-multiplier's words of scale (1億2,000万円 is one amount), the ones that cannot be read left out.
+import type { ProseDocument } from "../plugin.ts";
+import type { StatedAmount } from "../structure/stated-multiple.ts";
+import { scaledAmountOf, scaleWordsOf } from "./amount-scale.ts";
+import { amountsIn, formsOf } from "./currency-notation.ts";
+
+export const statedAmountsOf = (text: string, doc: ProseDocument): StatedAmount[] => {
+  const scales = scaleWordsOf(doc);
+  return amountsIn(
+    text,
+    formsOf(doc),
+    scales.map((scale) => scale.word),
+  ).flatMap((amount) => {
+    const read = scaledAmountOf(text, amount, scales);
+    return read === undefined
+      ? []
+      : [{ offset: read.offset, end: amount.offset + amount.written.length, currency: read.currency, value: read.value, scale: read.unit }];
+  });
+};

package/src/detectors/step-time-sum.ts

@@ -3,6 +3,7 @@
 import { stepTimeSlip, type StepTimeWords } from "../structure/step-times.ts";
 import type { Mark } from "../structure/time-marks.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 
 const SECONDS_PER_HOUR = 3600;
@@ -35,7 +36,7 @@ const wordsOf = (doc: ProseDocument): StepTimeWords => {
 };
 
 export const stepTimeSumMismatch: Detector = (doc): Finding[] => {
-  const slip = stepTimeSlip(doc.source, wordsOf(doc));
+  const slip = stepTimeSlip(withoutCodeBlocks(doc.source), wordsOf(doc));
   if (slip === undefined) return [];
   return [
     {

package/src/detectors/structure-tree.ts

@@ -1,7 +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 { listNumberBreaks, writtenNumbers } from "../structure/list-numbering.ts";
+import { htmlTextBlocks } from "../structure/html-text-blocks.ts";
+import { listsNumberBreaks } from "../structure/list-numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
 import { documentDateOf } from "./document-date.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
@@ -48,19 +49,20 @@ const findingsOf =
           values: { ...issue.values, offset: issue.offset },
         }));
 
-export const danglingReference: Detector = findingsOf("dangling-reference", danglingReferences);
-const structureNumberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
+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 lineStartAt = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
 
-/** The written numbers of the document's Markdown ordered lists that skip or repeat (structure/list-numbering.ts). */
-const QUOTED_LINE = /^[ \t]*>/u;
-
 /** 引用の中の箇条書きは、ほかの文書の例で、この文書の番号ではない。 */
-const isQuotedList = (source: string, start: number): boolean => QUOTED_LINE.test(source.slice(lineStartAt(source, start), start));
+const isQuotedList = (source: string, start: number): boolean => /^[ \t]*>/u.test(source.slice(lineStartAt(source, start), start));
 
+/** The written numbers of the document's Markdown ordered lists that skip or repeat (structure/list-numbering.ts). */
 const listNumberingGaps = (doc: ProseDocument): StructureIssue[] =>
-  doc.lists.filter((list) => !isQuotedList(doc.source, list.span.start)).flatMap((list) => listNumberBreaks(writtenNumbers(doc.source, list.itemSpans) ?? []));
+  listsNumberBreaks(doc.source, doc.lists, (list) => !isQuotedList(doc.source, list.span.start));
 
 const lineFindingOf = (doc: ProseDocument, issue: StructureIssue): Finding => ({
   rule: "numbering-gap",
@@ -265,6 +267,9 @@ const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["struct
     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,

package/src/detectors/team.ts

@@ -2,7 +2,8 @@ import { proseText } from "../measure.ts";
 import { joinWords } from "./word-list.ts";
 import { wordsOf } from "./structure.ts";
 import { nameSpans } from "../team-names.ts";
-import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
+import { conjugatedSpans } from "./conjugated-entry.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 /**
  * チームの言葉。社内でしか通じない語を、チームが chaff.yaml に自分で並べる。
@@ -12,19 +13,24 @@ import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "..
  */
 /**
  * 表層でも原形でも当てる。利用者は辞書形で書く（「握る」）が、本文は活用している（「握った」）。
+ * 複合動詞（「巻き取る」）は語に割れるので、語の並びで原形に照らす（「巻き取ります」）。
  * 品詞解析があれば原形で当たり、無くても表層で当たる。要求はしない。
  */
-const matches = (sentence: Sentence, word: string): boolean => {
+const matches = (sentence: Sentence, entry: LexiconEntry): boolean => {
   // 大文字小文字は区別しない。英語の文頭の「Circle back」も「circle back」として当てる。
-  const wanted = word.toLowerCase();
-  return sentence.text.toLowerCase().includes(wanted) || (sentence.tokens ?? []).some((token) => token.lemma?.toLowerCase() === wanted);
+  const wanted = entry.pattern.toLowerCase();
+  return (
+    sentence.text.toLowerCase().includes(wanted) ||
+    (sentence.tokens ?? []).some((token) => token.lemma?.toLowerCase() === wanted) ||
+    conjugatedSpans(sentence, entry).length > 0
+  );
 };
 
 export const internalJargon: Detector = (doc, options): Finding[] => {
-  const words = (options.lexicon ?? []).map((entry) => entry.pattern);
-  if (words.length === 0) return [];
+  const entries = options.lexicon ?? [];
+  if (entries.length === 0) return [];
   const hits = doc.sentences.flatMap((sentence) => {
-    const matched = words.find((word) => matches(sentence, word));
+    const matched = entries.find((entry) => matches(sentence, entry))?.pattern;
     return matched === undefined ? [] : [{ sentence, matched }];
   });
   if (hits.length < options.limit) return [];

package/src/detectors/template-sections.ts

@@ -0,0 +1,37 @@
+import type { Lexicon, MarkupHeading } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+type Span = { readonly start: number; readonly end: number };
+
+/** Lexicon group of placeholder-word: a word that, in a heading, says what follows is a template (Template, 雛形). */
+export const TEMPLATE = "template";
+
+const LATIN = /\p{Script=Latin}/u;
+
+/** Does the character beside a match end the word? A Latin edge needs a non-letter next to it; a CJK word stands anywhere. */
+const boundsWord = (edge: string, beside: string | undefined): boolean => !LATIN.test(edge) || beside === undefined || !/[\p{L}\p{N}]/u.test(beside);
+
+const holdsWordAt = (text: string, pattern: string, index: number): boolean =>
+  boundsWord(pattern[0] ?? "", text[index - 1]) && boundsWord(pattern.at(-1) ?? "", text[index + pattern.length]);
+
+/** The heading names a template: one of the words appears in it as a whole word, in any case. */
+export const namesTemplate = (heading: string, words: Lexicon): boolean => {
+  const text = heading.toLowerCase();
+  return words.some((word) => {
+    const pattern = word.pattern.toLowerCase();
+    return [...text.matchAll(new RegExp(escapeRegExp(pattern), "gu"))].some((match) => holdsWordAt(text, pattern, match.index));
+  });
+};
+
+/** A heading's section runs from the heading to the next one at its depth or above; text before a template title stays checked. */
+const sectionOf = (headings: readonly MarkupHeading[], index: number, documentEnd: number): Span => {
+  const heading = headings[index];
+  const next = headings.slice(index + 1).find((later) => later.depth <= (heading?.depth ?? 0));
+  return { start: heading?.start ?? 0, end: next?.start ?? documentEnd };
+};
+
+/** The parts of a document under a heading that names a template: their blanks are the point, not a slip. */
+export const templateSections = (headings: readonly MarkupHeading[], documentEnd: number, words: Lexicon): Span[] =>
+  words.length === 0 ? [] : headings.flatMap((heading, index) => (namesTemplate(heading.text, words) ? [sectionOf(headings, index, documentEnd)] : []));
+
+export const isInside = (spans: readonly Span[], offset: number): boolean => spans.some((span) => span.start <= offset && offset < span.end);

package/src/detectors/time-order.ts

@@ -11,6 +11,7 @@ import { reversedTimeRanges } from "../structure/time-range.ts";
 import { cellMinutes, reversedShiftRows, showsOvernightWork } from "../structure/shift-times.ts";
 import { pairedTimesOutOfOrder } from "../structure/labelled-time-order.ts";
 import { quoteAt, rangeWordsOf } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 
 // 一日の予定の時刻の順番と、語の決まった二つの時刻の順番（time-order）、発より前の着（arrival-before-departure）、移動の時間より短い乗り継ぎ（connection-time-short）。時刻は compare/clock-time.ts が読み、
 // 発着・翌日・時間帯の語は言語パッケージの語彙表（leg-mark、leg-column、day-shift-mark、time-zone、local-time-mark）から取る。
@@ -43,11 +44,12 @@ const variantOf = (issue: StructureIssue, variant: string | undefined): string |
   return "end_label" in issue.values ? "columns" : undefined;
 };
 
-/** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。 */
+/** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。コードブロックは例なので覆う。 */
 const detectorOf =
   (rule: string, find: Finder, variant?: string): Detector =>
-  (doc): Finding[] =>
-    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => {
+  (doc): Finding[] => {
+    const source = withoutCodeBlocks(doc.source);
+    return find(source, timesOf(source), datesOf(doc), timeWordsOf(doc), doc).map((issue) => {
       const named = variantOf(issue, variant);
       return {
         rule,
@@ -59,6 +61,7 @@ const detectorOf =
         ...(named === undefined ? {} : { variant: named }),
       };
     });
+  };
 
 const timeOrderInList: Detector = detectorOf("time-order", timeOrderBreaks);
 /** 語の決まった二つの時刻（開場と開演）。語は語彙表 timed-pair-label から取る。 */

package/src/detectors/titled-run.ts

@@ -0,0 +1,43 @@
+import type { Token } from "../plugin.ts";
+import { quotedSpans } from "../quoted-span.ts";
+
+/** 題の付いたものの名前を閉じる語（語彙表 title-ending: 〜要綱、〜試験、〜事業、〜法）。 */
+export type TitleWords = { readonly endings: readonly string[] };
+
+/** 題を囲む括弧。鉤括弧と、見出しや分類の名前を囲む隅付き括弧。 */
+const TITLE_MARKS = { "「": "」", "『": "』", "【": "】" };
+/** 名前のすぐ後ろに付く、その名前の補い（就職氷河期世代）、略称（以下「奨励金」という。）、日付や番号。 */
+const QUALIFIER_OPENERS = new Set(["（", "("]);
+/** 閉じる語の前に要る字数。1 字なら、題ではなく普通の語（新法、本事業）。 */
+const MIN_BODY_LENGTH = 2;
+const BLANK = /^\s*$/u;
+
+const surfaceOf = (tokens: readonly Token[]): string => tokens.map((token) => token.surface).join("");
+
+/**
+ * 連なりの語（run: 隙間なく並ぶ語）が、題の名前を閉じる語で終わるか。閉じる語は語の切れ目で始まる
+ * （地方自治法の「法」は語、解決方法の「法」は方法の一部）。閉じる語の前に 2 字以上の語が要る。
+ */
+export const endsInTitle = (run: readonly Token[], words: TitleWords): boolean =>
+  run.some((_, at) => {
+    const tail = surfaceOf(run.slice(at));
+    return words.endings.includes(tail) && [...surfaceOf(run.slice(0, at))].length >= MIN_BODY_LENGTH;
+  });
+
+/**
+ * 文（text）の start から end までの連なりが、題の名前の置き方をしているか。
+ * 括弧の中身の終わりで閉じる（「令和8年度高度統計人材育成強化拠点形成事業」）、すぐ後ろに補いの括弧が付く
+ * （国家公務員中途採用者選考試験（就職氷河期世代））、または文がその連なりだけ（要綱の題を並べた行）。
+ */
+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 alone = BLANK.test(text.slice(0, start)) && BLANK.test(text.slice(end));
+  return closesBracket || qualified || alone;
+};
+
+/**
+ * 文書の中で題として置かれた名前（titled: 題の置き方をした連なりと、見出しの中の漢字の連なり）に、
+ * この連なりの字（text）が名前の終わりとして含まれるか。同じ名前は、文の中で使っても名前（認定職業訓練実施奨励金の支給額）。
+ */
+export const isTitledName = (text: string, titled: readonly string[]): boolean => titled.some((name) => name.endsWith(text));

package/src/detectors/unbalanced-bracket.ts

@@ -5,6 +5,7 @@ import { quoteAround } from "./quote-around.ts";
 import { mergeSpans } from "../span-merge.ts";
 import { firstEndingAfter } from "../soft-break.ts";
 import { isLabelClose, isLabelInAside } from "./bracket-label.ts";
+import { isInchMark } from "./inch-mark.ts";
 
 /**
  * 括弧の組。どの言語でも同じ字の決まりなので、語彙表ではなくここに置く。family は形（丸・角）で、全角と半角は同じ形の別の幅。
@@ -93,6 +94,8 @@ export const bracketProblems = (text: string): BracketProblem[] => {
   const scan: Scan = { open: [], problems: [] };
   const heads = paragraphHeads(text);
   [...text.matchAll(MARKS)].forEach((match) => {
+    const quoteOpen = scan.open.some((entry) => entry.bracket.family === "quote");
+    if (isInchMark(text, match.index, quoteOpen)) return;
     const opening = BY_OPEN.get(match[0]);
     const closing = BY_CLOSE.get(match[0]);
     if (opening !== undefined) openWith(scan, opening, match.index, heads.has(match.index));

package/src/detectors/undefined-term.ts

@@ -91,6 +91,8 @@ const findingOf = (doc: ProseDocument, use: UndefinedTerm): Finding => ({
 });
 
 const NAME_LISTS = ["proper-name-word", "place-region", "calendar-name", "month-name", "company-form", "party-role"] as const;
+/** The lists whose words end a name right after a comma (Post Holdings, Inc.; Canton, Ohio). */
+const FORM_ENDS = ["company-form", "place-region"] as const;
 
 /** Capitalised terms, for a language whose package lists the words that join one name (name-joiner); Japanese has none. */
 const capitalisedUses = (doc: ProseDocument, sentences: readonly (readonly Token[])[], defined: readonly Defined[]): UndefinedTerm[] => {
@@ -99,6 +101,12 @@ const capitalisedUses = (doc: ProseDocument, sentences: readonly (readonly Token
     names: NAME_LISTS.flatMap((id) => patternsOf(doc, id)),
     divisions: patternsOf(doc, "numbered-division"),
     joiners: patternsOf(doc, "name-joiner"),
+    nameEnds: patternsOf(doc, "proper-name-word"),
+    formEnds: FORM_ENDS.flatMap((id) => patternsOf(doc, id)),
+    definitionMarkers: patternsOf(doc, "definition-marker"),
+    definedElsewhere: patternsOf(doc, "defined-elsewhere"),
+    capacityMarkers: patternsOf(doc, "capacity-marker"),
+    articles: patternsOf(doc, "article"),
   };
   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/unfilled-placeholder.ts

@@ -0,0 +1,10 @@
+import type { Detector } from "../plugin.ts";
+import { unfilledPlaceholder } from "./ai-phrasing.ts";
+import { TEMPLATE, isInside, templateSections } from "./template-sections.ts";
+
+/** A blank under a heading that names a template (Template, 雛形) is what the template is for, so it is not reported. */
+export const unfilledPlaceholderOutsideTemplates: Detector = (doc, options) => {
+  const words = (options.lexicon ?? []).filter((word) => word.group === TEMPLATE);
+  const templates = templateSections(doc.markup?.headings ?? [], doc.source.length, words);
+  return unfilledPlaceholder(doc, options).filter((finding) => !isInside(templates, Number(finding.values["offset"])));
+};

package/src/detectors/unknown-word.ts

@@ -1,5 +1,7 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { isKnownWord, isSplitWord, suggestionFor, wordsToCheck, type CheckedWord, type Speller } from "../spelling.ts";
+import { parse } from "../markdown-read.ts";
+import { eachPreOrder } from "../tree-walk.ts";
 import { quoteAt } from "./structure-tree.ts";
 
 /** これより短い語は見ない。短い語は一字違いの語が多すぎて言い直しが決まらず（tost は test か toast か）、略した語（impl）も多い。 */
@@ -24,14 +26,30 @@ const usedOnce = (words: readonly CheckedWord[]): CheckedWord[] => {
   return words.filter(({ word }) => counts.get(word) === 1);
 };
 
+const LETTERS = /\p{L}+/gu;
+
+/** 文書がコード（コードの区画と `…`）に書いた語。コードに書いた名前（`tidyq check` の tidyq）は、地の文でも打ち間違いではない。 */
+export const codeWordsOf = (source: string): Set<string> => {
+  const words = new Set<string>();
+  eachPreOrder(parse(source), (node) => {
+    if (node.type === "code" || node.type === "inlineCode")
+      (node.value ?? "")
+        .toLowerCase()
+        .match(LETTERS)
+        ?.forEach((word) => words.add(word));
+  });
+  return words;
+};
+
 /**
  * 辞書に無い英語の語で、一字違いの辞書の語があるもの（recieve → receive）。辞書は adapter が持ち、無い言語では動かない。
- * 大文字を含む語（固有名詞・略語）、コード・URL の中、頭の字を分けた語の残り、二度以上使う語、言い直しの無い語は言わない。
+ * 大文字を含む語（固有名詞・略語）、コード・URL の中、頭の字を分けた語の残り、二度以上使う語、言い直しの無い語、
+ * 文書がコードにも書いた語は言わない。
  */
 export const unknownWord: Detector = (doc): Finding[] => {
   if (doc.dictionary === undefined) return [];
   const speller = spellerOf(doc, doc.dictionary());
-  const known = new Set(patternsOf(doc, "known-misspelling"));
+  const known = new Set([...patternsOf(doc, "known-misspelling"), ...codeWordsOf(doc.source)]);
   const words = wordsToCheck(doc.prose ?? doc.source, MIN_LENGTH, MAX_LENGTH).filter(({ offset }) => !isSplitWord(doc.source, offset));
   const used = new Set(words.map(({ word }) => word).filter((word) => isKnownWord(word, speller)));
   return usedOnce(words).flatMap(({ offset, word }) => {

package/src/detectors/use-interval.ts

@@ -4,6 +4,7 @@ import { paragraphsOf } from "../derived/period-counts.ts";
 import { timeLengths, type TimeLength } from "../derived/time-lengths.ts";
 import { limitWordsOf, marksOf, periodCountWordsOf } from "./use-count-words.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 
 // 使う間隔の下限と期間あたりの回数の上限が両立しない、または表の回数と合わない（interval-count-mismatch）。
 // 語は use-count-word と use-interval-word、長さの単位は unit-time から取る。
@@ -14,8 +15,8 @@ const SECONDS_PER_MINUTE = 60;
 const patternsOf = (doc: ProseDocument, lexicon: string, weight?: number): string[] =>
   (doc.lexicons[lexicon] ?? []).filter((entry) => weight === undefined || entry.weight === weight).map((entry) => entry.pattern);
 
-const lengthsOf = (doc: ProseDocument): TimeLength[] =>
-  timeLengths(doc.source, {
+const lengthsOf = (doc: ProseDocument, text: string): TimeLength[] =>
+  timeLengths(text, {
     hourUnits: patternsOf(doc, "unit-time", SECONDS_PER_HOUR),
     minuteUnits: patternsOf(doc, "unit-time", SECONDS_PER_MINUTE),
     halves: patternsOf(doc, "length-half"),
@@ -39,8 +40,10 @@ const valuesOf = (doc: ProseDocument, mismatch: IntervalMismatch): Record<string
     ? { count: written(doc, mismatch.count), interval: written(doc, mismatch.interval), needed: mismatch.neededHours, hours: mismatch.count.hours }
     : { count: written(doc, mismatch.count), column: mismatch.column, table: mismatch.tableCount };
 
-export const intervalCountMismatch: Detector = (doc): Finding[] =>
-  intervalCountMismatches(doc.source, paragraphsOf(doc.source), lengthsOf(doc), wordsOf(doc)).map((mismatch) => ({
+/** コードブロックの中の用法は例なので、覆って読む。 */
+export const intervalCountMismatch: Detector = (doc): Finding[] => {
+  const text = withoutCodeBlocks(doc.source);
+  return intervalCountMismatches(text, paragraphsOf(text), lengthsOf(doc, text), wordsOf(doc)).map((mismatch) => ({
     rule: "interval-count-mismatch",
     severity: "warning",
     line: 0,
@@ -49,3 +52,4 @@ export const intervalCountMismatch: Detector = (doc): Finding[] =>
     values: { ...valuesOf(doc, mismatch), offset: mismatch.count.start },
     ...(mismatch.kind === "table" ? { variant: "table" } : {}),
   }));
+};

package/src/detectors/use-maximum.ts

@@ -3,6 +3,7 @@ import { exceededMaxima } from "../derived/use-maximum.ts";
 import { paragraphsOf } from "../derived/period-counts.ts";
 import { limitWordsOf, marksOf, periodCountWordsOf } from "./use-count-words.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { withoutCodeBlocks } from "./code-fences.ts";
 import { isMoneySpan, type CurrencyMark } from "../derived/money-span.ts";
 
 // 1回の量 × 期間あたりの回数が、その期間の上限を超える（product-exceeds-maximum）。語は use-count-word と use-amount-word から取る。
@@ -19,7 +20,8 @@ export const productExceedsMaximum: Detector = (doc): Finding[] => {
   const marks = currencyMarksOf(doc);
   const unitOf = (span: Span): string => written(doc, span).replace(LEADING_NUMBER, "");
   const isMoney = (span: Span): boolean => isMoneySpan(doc.source, span, unitOf(span), marks);
-  const amounts = exceededMaxima(doc.source, paragraphsOf(doc.source), words).filter((exceeded) => !isMoney(exceeded.maximum) && !isMoney(exceeded.perUse));
+  const text = withoutCodeBlocks(doc.source);
+  const amounts = exceededMaxima(text, paragraphsOf(text), words).filter((exceeded) => !isMoney(exceeded.maximum) && !isMoney(exceeded.perUse));
   return amounts.map((exceeded) => ({
     rule: "product-exceeds-maximum",
     severity: "warning",