chaffjs 0.27.1 → 0.29.0

package/src/detectors/parameter-table.ts

@@ -0,0 +1,17 @@
+// parameter-table-mismatch: a parameter table that names a parameter the signature above it does not take, or leaves out
+// one it does (parameter-table.ts). The header words of a parameter table come from the parameter-header lexicon.
+import { quoteAt } from "./structure-tree.ts";
+import { parameterSlips } from "../parameter-table.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+export const parameterTable: Detector = (doc): Finding[] => {
+  const headers = new Set((doc.lexicons["parameter-header"] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  return parameterSlips(doc.source, headers).map((slip) => ({
+    rule: "parameter-table-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { name: slip.name, function: slip.fn, side: slip.side, offset: slip.offset },
+  }));
+};

package/src/detectors/phone-number-variant.ts

@@ -0,0 +1,18 @@
+// phone-number-variant: one phone number written with two neighbouring digits swapped somewhere else in the document,
+// after a label of the same kind (phone-numbers.ts).
+import { labelledPhoneNumbers, phoneVariants } from "../phone-numbers.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+export const phoneNumberVariant: Detector = (doc, options): Finding[] => {
+  const labels = options.lexicon ?? [];
+  if (labels.length === 0) return [];
+  return phoneVariants(labelledPhoneNumbers(doc.prose ?? doc.source, labels)).map(({ number, other }) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, number.offset),
+    values: { written: number.written, other: other.written, offset: number.offset },
+  }));
+};

package/src/detectors/prerequisite-order.ts

@@ -0,0 +1,35 @@
+// prerequisite-after-step: a sentence opening with a prerequisite (Before you begin, 作業を始める前に) after the numbered
+// steps of its own section (prerequisite-order.ts).
+import { quoteAt } from "./structure-tree.ts";
+import { latePrerequisites } from "../prerequisite-order.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const ORDERED_ITEM = /^\s*\d{1,3}[.)]\s/u;
+/** A numbered list needs this many steps to be a procedure. */
+const MIN_STEPS = 3;
+
+const QUOTED_LINE = /^[ \t]*>/u;
+
+/** Whether a list stands in a block quote: a quoted procedure is someone else's, not the document's steps. */
+const isQuoted = (source: string, start: number): boolean => QUOTED_LINE.test(source.slice(source.lastIndexOf("\n", start - 1) + 1, start + 1));
+
+const proceduresOf = (doc: ProseDocument): { start: number; end: number }[] =>
+  doc.lists
+    .filter((list) => list.itemSpans.length >= MIN_STEPS && ORDERED_ITEM.test(doc.source.slice(list.span.start, list.span.end)))
+    .filter((list) => !isQuoted(doc.source, list.span.start))
+    .map((list) => ({ start: list.span.start, end: list.span.end }));
+
+export const prerequisiteOrder: Detector = (doc): Finding[] => {
+  const openers = (doc.lexicons["prerequisite-opener"] ?? []).map((entry) => entry.pattern);
+  if (openers.length === 0) return [];
+  const sections = doc.sections.map((section) => ({ start: section.span.start, end: section.span.end }));
+  const sentences = doc.sentences.map((sentence) => ({ start: sentence.span.start, end: sentence.span.end, text: sentence.text }));
+  return latePrerequisites(sections, proceduresOf(doc), sentences, openers).map((sentence) => ({
+    rule: "prerequisite-after-step",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, sentence.start),
+    values: { offset: sentence.start },
+  }));
+};

package/src/detectors/quote-unnamed-speaker.ts

@@ -0,0 +1,19 @@
+// quote-unnamed-speaker: a quotation given to a role with no name (業界のアナリストは「…」と述べた, "…," said an analyst).
+// The decision is in unnamed-speaker.ts.
+import { speakerWords, unnamedSpeakerQuotes } from "../unnamed-speaker.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+export const quoteUnnamedSpeaker: Detector = (doc, options): Finding[] => {
+  const words = speakerWords(options.lexicon ?? [], doc.lexicons["quote-attribution"] ?? []);
+  return doc.paragraphs
+    .flatMap((paragraph) => paragraph.sentences)
+    .flatMap((sentence) => unnamedSpeakerQuotes({ start: sentence.span.start, text: sentence.text }, words))
+    .map((hit) => ({
+      rule: "quote-unnamed-speaker",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: hit.quote,
+      values: { quote: hit.quote, speaker: hit.speaker, offset: hit.offset },
+    }));
+};

package/src/detectors/quote-without-source.ts

@@ -1,8 +1,11 @@
 // A quotation the text gives to someone (「…」と述べている, according to X, "…") in a paragraph that names no source for it:
 // no link, no footnote or numbered citation, no year in brackets. Whether the words are really that person's is for
 // `chaff cite` against the source; this only says that there is nothing to check them against. The words that give a
-// quotation to someone come from the language package's word list quote-attribution. Pure.
+// quotation to someone come from the language package's word list quote-attribution. A Markdown block quotation is
+// given to someone by a dash line (> … / — Name) instead. Pure.
 import { QUOTATION_MARKS, quotedSpans } from "../quoted-span.ts";
+import { readMarkdown } from "../markdown-read.ts";
+import { blockQuotations, type BlockQuotation } from "./block-quotation.ts";
 import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
 
 export type QuoteText = { readonly start: number; readonly text: string };
@@ -53,34 +56,78 @@ const cueStarts = (text: string, cue: string): number[] => {
 
 type Quoted = { readonly start: number; readonly end: number };
 
+/** The word lists the rule reads: quote-attribution, and quote-advice (「…」と述べる方が: a wording suggested, not quoted). */
+export type QuoteWords = { readonly cues: readonly LexiconEntry[]; readonly advice?: readonly LexiconEntry[] };
+
+const patternsIn = (entries: readonly LexiconEntry[], group: string): string[] =>
+  entries.filter((entry) => entry.group === group && entry.pattern !== "").map((entry) => entry.pattern);
+
+/**
+ * Whether the words right after the closing mark suggest saying it that way: a say word, then an advice word (「…」と書く方が適切です).
+ * A say word alone is not enough: 「…」と述べる方が多い reports what people say.
+ */
+const isAdvice = (text: string, quoted: Quoted, advice: readonly LexiconEntry[]): boolean => {
+  const after = quoted.end + 1;
+  const tails = patternsIn(advice, "advice");
+  return patternsIn(advice, "say").some((say) => text.startsWith(say, after) && tails.some((tail) => text.startsWith(tail, after + say.length)));
+};
+
 /** A cue just before the quotation's opening mark, or just after its closing mark. position says which side it may stand on. */
-const isAttributed = (text: string, quoted: Quoted, cues: readonly LexiconEntry[]): boolean =>
-  cues.some((cue) =>
+/** Advice after the quotation silences only the cue after it: 山田氏によれば「…」と言う方が適切だ still gives the words to someone. */
+const isAttributed = (text: string, quoted: Quoted, { cues, advice = [] }: QuoteWords): boolean => {
+  const advised = isAdvice(text, quoted, advice);
+  return cues.some((cue) =>
     cueStarts(text, cue.pattern).some((at) => {
       const before = cue.position !== "after" && at + cue.pattern.length <= quoted.start - 1 && at + cue.pattern.length >= quoted.start - 1 - CUE_REACH_BEFORE;
-      const after = cue.position !== "before" && at >= quoted.end + 1 && at <= quoted.end + 1 + CUE_REACH_AFTER;
+      const after = !advised && cue.position !== "before" && at >= quoted.end + 1 && at <= quoted.end + 1 + CUE_REACH_AFTER;
       return before || after;
     }),
   );
+};
 
-const quotesIn = (sentence: QuoteText, cues: readonly LexiconEntry[]): UnsourcedQuote[] => {
+const quotesIn = (sentence: QuoteText, words: QuoteWords): UnsourcedQuote[] => {
   return quotedSpans(sentence.text, QUOTATION_MARKS)
-    .filter((span) => [...sentence.text.slice(span.start, span.end).trim()].length >= MIN_QUOTE_CHARS && isAttributed(sentence.text, span, cues))
+    .filter((span) => [...sentence.text.slice(span.start, span.end).trim()].length >= MIN_QUOTE_CHARS && isAttributed(sentence.text, span, words))
     .map((span) => ({ offset: sentence.start + span.start, quote: sentence.text.slice(span.start, span.end).trim() }));
 };
 
 /** Each quotation given to someone, in a paragraph that names no source. cues: the word list quote-attribution. */
-export const unsourcedQuotes = (paragraphs: readonly QuoteParagraph[], cues: readonly LexiconEntry[]): UnsourcedQuote[] =>
-  paragraphs.filter((paragraph) => !namesSource(paragraph.source)).flatMap((paragraph) => paragraph.sentences.flatMap((sentence) => quotesIn(sentence, cues)));
+export const unsourcedQuotes = (paragraphs: readonly QuoteParagraph[], cues: readonly LexiconEntry[], advice: readonly LexiconEntry[] = []): UnsourcedQuote[] =>
+  paragraphs
+    .filter((paragraph) => !namesSource(paragraph.source))
+    .flatMap((paragraph) => paragraph.sentences.flatMap((sentence) => quotesIn(sentence, { cues, advice })));
 
-export const quoteWithoutSource: Detector = (doc: ProseDocument): Finding[] =>
+/** Each block quotation given to someone by a dash line (— Name) with no source in it or on that line. */
+export const unsourcedBlockQuotes = (quotations: readonly BlockQuotation[]): UnsourcedQuote[] =>
+  quotations
+    .filter((quotation) => [...quotation.quote].length >= MIN_QUOTE_CHARS && !namesSource(quotation.passage))
+    .map(({ offset, quote }) => ({ offset, quote }));
+
+/** A dash and a `>` must both be there before the Markdown is read again. */
+const MAY_HOLD_BLOCK_QUOTE = /^[ \t]*>/mu;
+const MAY_HOLD_DASH = /[—―–]|--/u;
+
+const blockQuotesOf = (doc: ProseDocument): UnsourcedQuote[] => {
+  if (!MAY_HOLD_BLOCK_QUOTE.test(doc.source) || !MAY_HOLD_DASH.test(doc.source) || doc.markup?.markdown !== true) return [];
+  return unsourcedBlockQuotes(blockQuotations(readMarkdown(doc.source).root, doc.source));
+};
+
+const paragraphQuotesOf = (doc: ProseDocument): UnsourcedQuote[] =>
   unsourcedQuotes(
     doc.paragraphs.map((paragraph) => ({
       source: doc.source.slice(paragraph.span.start, paragraph.span.end),
       sentences: paragraph.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text })),
     })),
     doc.lexicons["quote-attribution"] ?? [],
-  ).map((hit) => ({
+    doc.lexicons["quote-advice"] ?? [],
+  );
+
+/** Every quotation in the document given to someone with no source, in document order: what the rule and `cite --scaffold` list. */
+export const documentQuotesWithoutSource = (doc: ProseDocument): UnsourcedQuote[] =>
+  [...paragraphQuotesOf(doc), ...blockQuotesOf(doc)].toSorted((left, right) => left.offset - right.offset);
+
+export const quoteWithoutSource: Detector = (doc: ProseDocument): Finding[] =>
+  documentQuotesWithoutSource(doc).map((hit) => ({
     rule: "quote-without-source",
     severity: "info",
     line: 0,

package/src/detectors/registry/amount-range.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { amountRange } from "../amount-range.ts";
+
+export const detector: Detector = amountRange;

package/src/detectors/registry/amount-scale.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { amountScale } from "../amount-scale.ts";
+
+export const detector: Detector = amountScale;

package/src/detectors/registry/arrival-before-departure.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { arrivalBeforeDeparture } from "../time-order.ts";
+
+export const detector: Detector = arrivalBeforeDeparture;

package/src/detectors/registry/date-outside-period.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dateOutsidePeriod } from "../date-outside-period.ts";
+
+export const detector: Detector = dateOutsidePeriod;

package/src/detectors/registry/default-values.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { defaultValues } from "../default-values.ts";
+
+export const detector: Detector = defaultValues;

package/src/detectors/registry/deprecated-use.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { deprecatedUse } from "../deprecated-use.ts";
+
+export const detector: Detector = deprecatedUse;

package/src/detectors/registry/due-date.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { dueDate } from "../due-date.ts";
+
+export const detector: Detector = dueDate;

package/src/detectors/registry/kana-function-word.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { kanaFunctionWord } from "../kana-function-word.ts";
+
+export const detector: Detector = kanaFunctionWord;

package/src/detectors/registry/line-amount.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { lineAmount } from "../line-amount.ts";
+
+export const detector: Detector = lineAmount;

package/src/detectors/registry/nado-closed-list.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { nadoClosedList } from "../nado-closed-list.ts";
+
+export const detector: Detector = nadoClosedList;

package/src/detectors/registry/number-word-figure.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { numberWordFigure } from "../number-word-figure.ts";
+
+export const detector: Detector = numberWordFigure;

package/src/detectors/registry/obligation-without-deadline.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { obligationWithoutDeadline } from "../obligation-without-deadline.ts";
+
+export const detector: Detector = obligationWithoutDeadline;

package/src/detectors/registry/parameter-table.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { parameterTable } from "../parameter-table.ts";
+
+export const detector: Detector = parameterTable;

package/src/detectors/registry/phone-number-variant.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { phoneNumberVariant } from "../phone-number-variant.ts";
+
+export const detector: Detector = phoneNumberVariant;

package/src/detectors/registry/prerequisite-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { prerequisiteOrder } from "../prerequisite-order.ts";
+
+export const detector: Detector = prerequisiteOrder;

package/src/detectors/registry/quote-unnamed-speaker.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { quoteUnnamedSpeaker } from "../quote-unnamed-speaker.ts";
+
+export const detector: Detector = quoteUnnamedSpeaker;

package/src/detectors/registry/tax-amount.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { taxAmount } from "../tax-amount.ts";
+
+export const detector: Detector = taxAmount;

package/src/detectors/registry/time-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { timeOrder } from "../time-order.ts";
+
+export const detector: Detector = timeOrder;

package/src/detectors/registry/ui-label.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { uiLabel } from "../ui-label.ts";
+
+export const detector: Detector = uiLabel;

package/src/detectors/registry/undefined-call.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { undefinedCall } from "../undefined-call.ts";
+
+export const detector: Detector = undefinedCall;

package/src/detectors/registry/undefined-term.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { undefinedTerm } from "../undefined-term.ts";
+
+export const detector: Detector = undefinedTerm;

package/src/detectors/registry/version-order.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { versionOrder } from "../version-order.ts";
+
+export const detector: Detector = versionOrder;

package/src/detectors/registry/warning-action.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { warningAction } from "../warning-action.ts";
+
+export const detector: Detector = warningAction;

package/src/detectors/requirement-smell.ts

@@ -1,20 +1,25 @@
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
 import { entryCloses, entryIn, entryRanges } from "./lexicon-match.ts";
+import { openEndAt, openEndNames, type OpenEndNames } from "./open-end-names.ts";
 
 // Requirements smells (Femmer et al. 2017; Berry et al. 2003; ISO/IEC/IEEE 29148): a loophole, an open-ended list and
 // "and/or", in a sentence that states a requirement. What makes a sentence a requirement, and each smell's words, come
 // from the language's lexicons; this file knows neither language.
 
+const OPEN_END = "requirement-open-end";
+
 /** Each smell: the lexicon of its words, and the finding's variant (the rule's messages). */
 const SMELLS = [
   { lexicon: "requirement-loophole", variant: "loophole" },
-  { lexicon: "requirement-open-end", variant: "open-end" },
+  { lexicon: OPEN_END, variant: "open-end" },
   { lexicon: "requirement-either", variant: "either" },
 ] as const;
 
 const MARKERS = "requirement-marker";
 /** Sentence ends that look like a marker and are not one (「…のこと。」 defines a term). The language may have none. */
 const NOT_MARKERS = "requirement-not-marker";
+/** The language's words of a definition (をいう, means): a name defined with them closes its own list (銀行等（…をいう。）). */
+const STATEMENTS = "definition-statement";
 
 /** A marker with position: after counts only at the end of the sentence (「…できること。」); any other, anywhere in it. */
 const isMarkedBy = (sentence: Sentence, entry: LexiconEntry): boolean => (entry.position === "after" ? entryCloses(sentence, entry) : entryIn(sentence, entry));
@@ -28,25 +33,40 @@ const offsetOf = (sentence: Sentence, entry: LexiconEntry): number => {
   return range === undefined ? sentence.span.start : (sentence.tokens?.[range.start]?.span.start ?? sentence.span.start);
 };
 
-const findingOf = (sentence: Sentence, entry: LexiconEntry, variant: string): Finding => ({
+const findingOf = (sentence: Sentence, entry: LexiconEntry, variant: string, offset: number): Finding => ({
   rule: "",
   severity: "warning",
   line: 0,
   column: 0,
   quote: sentence.text.trim(),
   variant,
-  values: { matched: entry.pattern, offset: offsetOf(sentence, entry) },
+  values: { matched: entry.pattern, offset },
 });
 
+/** Where the word stands as a smell. An open-end word inside a name the document gives (業務執行取締役等) is none; without tokens it cannot be told apart. */
+const smellAt = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string, names: () => OpenEndNames): number | undefined => {
+  if (!entryIn(sentence, entry)) return undefined;
+  const tokenized = sentence.tokens !== undefined && (entry.tokens?.length ?? 0) > 0;
+  return lexicon === OPEN_END && tokenized ? openEndAt(doc, sentence, entry, names()) : offsetOf(sentence, entry);
+};
+
 /** The first word of each smell in one requirement sentence: one finding per smell, not per word. */
-const smellsIn = (sentence: Sentence, lexicons: ProseDocument["lexicons"]): Finding[] =>
-  SMELLS.flatMap(({ lexicon, variant }) => {
-    const entry = (lexicons[lexicon] ?? []).find((candidate) => entryIn(sentence, candidate));
-    return entry === undefined ? [] : [findingOf(sentence, entry, variant)];
-  });
+const smellsIn = (doc: ProseDocument, sentence: Sentence, names: () => OpenEndNames): Finding[] =>
+  SMELLS.flatMap(({ lexicon, variant }) =>
+    (doc.lexicons[lexicon] ?? [])
+      .flatMap((entry) => {
+        const offset = smellAt(doc, sentence, entry, lexicon, names);
+        return offset === undefined ? [] : [findingOf(sentence, entry, variant, offset)];
+      })
+      .slice(0, 1),
+  );
 
 export const requirementSmell: Detector = (doc): Finding[] => {
   const markers = doc.lexicons[MARKERS] ?? [];
   const notMarkers = doc.lexicons[NOT_MARKERS] ?? [];
-  return doc.sentences.filter((sentence) => isRequirement(sentence, markers, notMarkers)).flatMap((sentence) => smellsIn(sentence, doc.lexicons));
+  const statements = (doc.lexicons[STATEMENTS] ?? []).map((entry) => entry.pattern);
+  // Read once, and only when a requirement has an open-end word to tell apart from a name.
+  const cache: { names?: OpenEndNames } = {};
+  const names = (): OpenEndNames => (cache.names ??= openEndNames(doc, doc.lexicons[OPEN_END] ?? [], statements));
+  return doc.sentences.filter((sentence) => isRequirement(sentence, markers, notMarkers)).flatMap((sentence) => smellsIn(doc, sentence, names));
 };

package/src/detectors/structure-tree.ts

@@ -7,10 +7,12 @@ import { documentDateOf } from "./document-date.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
 import { proseTotalMismatches } from "../structure/prose-total.ts";
+import { countedAmounts, type SummedCounter } from "../structure/counted-amounts.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 import { proseShareMismatches } from "../structure/percent-sum-prose.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
+import { ordinalRunGaps } from "./ordinal-run-gaps.ts";
 
 const QUOTE_LENGTH = 80;
 
@@ -48,28 +50,34 @@ const QUOTED_LINE = /^[ \t]*>/u;
 /** 引用の中の箇条書きは、ほかの文書の例で、この文書の番号ではない。 */
 const isQuotedList = (source: string, start: number): boolean => QUOTED_LINE.test(source.slice(lineStartAt(source, start), start));
 
-const listNumberingGaps = (doc: ProseDocument): Finding[] =>
-  doc.lists
-    .filter((list) => !isQuotedList(doc.source, list.span.start))
-    .flatMap((list) => listNumberBreaks(writtenNumbers(doc.source, list.itemSpans) ?? []))
-    .map((issue) => ({
-      rule: "numbering-gap",
-      severity: "error",
-      line: 0,
-      column: 0,
-      quote: quoteAt(doc.source, issue.offset),
-      values: { ...issue.values, offset: issue.offset },
-    }));
+const listNumberingGaps = (doc: ProseDocument): StructureIssue[] =>
+  doc.lists.filter((list) => !isQuotedList(doc.source, list.span.start)).flatMap((list) => listNumberBreaks(writtenNumbers(doc.source, list.itemSpans) ?? []));
+
+const lineFindingOf = (doc: ProseDocument, issue: StructureIssue): Finding => ({
+  rule: "numbering-gap",
+  severity: "error",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, issue.offset),
+  values: { ...issue.values, offset: issue.offset },
+});
 
 /**
- * 番号の抜けと重なり: 番地の木の並び（条、項、号）と、Markdown の番号付きの箇条書きに書いた番号。条の中の「1.」「2.」は
- * 両方に読まれるので、木が指した行の箇条書きは重ねて言わない。
+ * 番号の抜けと重なり: 番地の木の並び（条、項、号）、Markdown の番号付きの箇条書きに書いた番号、日程の第N回・Week N の並び
+ * （detectors/ordinal-run-gaps.ts）。一つの行が二つ以上に読まれる（条の中の「1.」、「1. Week 1」）ので、先に指した行は重ねて言わない。
  */
 export const numberingGap: Detector = (doc, options): Finding[] => {
   const fromTree = structureNumberingGap(doc, options);
   const reported = new Set(fromTree.map((finding) => lineStartAt(doc.source, Number(finding.values["offset"]))));
-  const fromLists = listNumberingGaps(doc).filter((finding) => !reported.has(lineStartAt(doc.source, Number(finding.values["offset"]))));
-  return [...fromTree, ...fromLists].toSorted((left, right) => Number(left.values["offset"]) - Number(right.values["offset"]));
+  const fromLines = [...listNumberingGaps(doc), ...ordinalRunGaps(doc)].filter((issue) => {
+    const line = lineStartAt(doc.source, issue.offset);
+    if (reported.has(line)) return false;
+    reported.add(line);
+    return true;
+  });
+  return [...fromTree, ...fromLines.map((issue) => lineFindingOf(doc, issue))].toSorted(
+    (left, right) => Number(left.values["offset"]) - Number(right.values["offset"]),
+  );
 };
 export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);
 
@@ -141,33 +149,43 @@ export const dateWeekdayMismatch: Detector = (doc): Finding[] => {
 };
 
 /** 木の日付を、原文の位置と一緒に並べる。 */
-const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
+export const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
   inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, value: String(node.attrs["value"]) }] : []));
 
-/** 日程の並びに逆らう日付。並びの読み方は原文の行を見るので、木と原文の両方を渡す。 */
+/** 日程の並びに逆らう日付。並びの読み方は原文の行と見出しを見るので、木と原文と見出しを渡す。 */
 export const dateOrder: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : dateOrderBreaks(doc.source, datedPoints(doc.structure)).map((issue) => ({
+    : dateOrderBreaks(doc.source, datedPoints(doc.structure), doc.markup?.headings ?? []).map((issue) => ({
         rule: "date-order",
         severity: "warning",
         line: 0,
         column: 0,
         quote: quoteAt(doc.source, issue.offset),
         values: { ...issue.values, offset: issue.offset },
+        ...("next" in issue.values ? { variant: "first" } : {}),
       }));
 
 /** 木の数量を、原文の位置と一緒に並べる。 */
-const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
+export const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
   inDocumentOrder(tree).flatMap((node) =>
     node.kind === "quantity" ? [{ offset: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), unit: String(node.attrs["unit"]) }] : [],
   );
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
+const summedCountersOf = (doc: ProseDocument): SummedCounter[] =>
+  (doc.lexicons["summed-counter"] ?? []).map((entry) => ({ pattern: entry.pattern, unit: entry.group ?? entry.pattern }));
+
+/** 木の数量に、解析器が助数詞と読まない足せる助数詞（16単位、3 credits）の付いた数を加えて、書いた順に並べる。 */
+const summableAmountsOf = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): Amount[] => {
+  const known = amountsOf(tree);
+  return [...known, ...countedAmounts(doc.source, summedCountersOf(doc), known)].toSorted((left, right) => left.offset - right.offset);
+};
+
 /** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。 */
 const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
-  const amounts = amountsOf(tree);
+  const amounts = summableAmountsOf(doc, tree);
   const lines = totalMismatches(doc.source, amounts, patternsOf(doc, "total-label"));
   const words = {
     totals: patternsOf(doc, "total-phrase"),
@@ -230,7 +248,11 @@ export const dateRangeReversed: Detector = (doc): Finding[] => {
 
 const shareWordsOf = (doc: ProseDocument): ShareWords => ({
   labels: (doc.lexicons["share-label"] ?? []).map((entry) => entry.pattern),
+  columnLabels: (doc.lexicons["share-column"] ?? []).map((entry) => entry.pattern),
+  rates: (doc.lexicons["share-column-rate"] ?? []).map((entry) => entry.pattern),
   exceptions: (doc.lexicons["share-exception"] ?? []).map((entry) => entry.pattern),
+  rests: (doc.lexicons["share-rest"] ?? []).map((entry) => entry.pattern),
+  changes: (doc.lexicons["change-direction"] ?? []).map((entry) => entry.pattern),
   units: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
   totalLabels: (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
 });

package/src/detectors/superlative-scope.ts

@@ -42,6 +42,18 @@ const compound = (tokens: readonly Token[], range: TokenRange): boolean => {
   return before !== undefined && first !== undefined && NOMINAL.has(before.pos) && before.span.end === first.span.start;
 };
 
+const CLAUSE_END = new Set(["VERB", "AUX"]);
+
+/**
+ * 連体修飾の節が空白を挟まずに付いた最上級（バグを検出できる唯一の・社員が選んだ最高の）。節が何の中で最もなのかを言う。
+ * 節の終わりは原形の動詞か助動詞。「首都であり最大の」の「あり」と「大切な最大の」の「な」は原形でないので節の終わりと読まない。
+ */
+const clauseBefore = (tokens: readonly Token[], range: TokenRange): boolean => {
+  const before = tokens[range.start - 1];
+  const first = tokens[range.start];
+  return before !== undefined && first !== undefined && CLAUSE_END.has(before.pos) && before.surface === before.lemma && before.span.end === first.span.start;
+};
+
 /** 名前 + 範囲の語 + 最上級（日本で最も・トヨタで最も・東京都で最大）。「費用で最大の効果」の「費用」は名前ではないので範囲にしない。 */
 const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexicon): boolean =>
   isMarker(tokens[range.start - 1], markers) && isNamed(tokens[range.start - 2]);
@@ -68,4 +80,4 @@ const phraseAfter = (tokens: readonly Token[], range: TokenRange, markers: Lexic
 };
 
 export const scoped = (tokens: readonly Token[], range: TokenRange, markers: ScopeMarkers): boolean =>
-  compound(tokens, range) || namedBefore(tokens, range, markers.before) || phraseAfter(tokens, range, markers.after);
+  compound(tokens, range) || clauseBefore(tokens, range) || namedBefore(tokens, range, markers.before) || phraseAfter(tokens, range, markers.after);

package/src/detectors/tax-amount.ts

@@ -0,0 +1,25 @@
+// tax-mismatch: the reading half. The words of a tax row, a total row and an included tax come from the language's
+// lexicons (tax-label, total-label, tax-included-word); the amounts are the structure tree's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { taxMismatches, type TaxWords } from "../structure/tax.ts";
+import { amountsOf, quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): TaxWords => ({
+  labels: patternsOf(doc, "tax-label"),
+  totals: patternsOf(doc, "total-label"),
+  included: patternsOf(doc, "tax-included-word"),
+});
+
+export const taxAmount: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : taxMismatches(doc.source, amountsOf(doc.structure), wordsOf(doc)).map((issue) => ({
+        rule: "tax-mismatch",
+        severity: "error",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));

package/src/detectors/technical-docs.ts

@@ -190,6 +190,11 @@ const MIN_STEPS = 3;
 const isInflected = (token: Token): boolean =>
   token.lemma !== undefined && token.lemma !== "" && token.surface.toLowerCase() !== token.lemma && token.features?.["VerbForm"] !== "Part";
 
+const NOMINAL = new Set(["NOUN", "PROPN"]);
+
+/** A determiner right after a noun opens a clause inside the phrase (a buffer that is big): the verb after it is the clause's, not a subject's. */
+const opensClause = (words: readonly Token[]): boolean => words.some((token, at) => at > 0 && token.pos === "DET" && NOMINAL.has(words[at - 1]?.pos ?? ""));
+
 /**
  * A step written as a statement: a subject, then its verb. The subject opens with an article or a pronoun (The installer
  * asks, You click), or it is a name or a noun whose verb is inflected (Docker builds). A noun before a base-form verb is
@@ -201,7 +206,8 @@ export const isStatement = (tokens: readonly Token[]): boolean => {
   if (head === undefined || words.length < MIN_STEP_TOKENS || !SUBJECT_HEAD.has(head.pos)) return false;
   const verbAt = rest.findIndex((token) => PREDICATE.has(token.pos));
   const verb = rest[verbAt];
-  if (verb === undefined || !rest.slice(0, verbAt).every((token) => SUBJECT_PART.has(token.pos))) return false;
+  const subject = [head, ...rest.slice(0, verbAt)];
+  if (verb === undefined || !rest.slice(0, verbAt).every((token) => SUBJECT_PART.has(token.pos)) || opensClause(subject)) return false;
   // Punctuation before the verb is no subject: a label (Guests: the users who …) or an opening phrase (On the left bar, select …).
   const interrupted = tokens.some((token) => token.pos === "PUNCT" && token.span.start > head.span.start && token.span.start < verb.span.start);
   return !interrupted && (SUBJECT_OPENER.has(head.pos) || isInflected(verb));