chaffjs 0.26.0 → 0.27.0

package/src/detectors/change-rate.ts

@@ -0,0 +1,122 @@
+// change-rate-mismatch: the reading half. Builds the figures, the rates and the words of structure/change-rate.ts from the
+// tree's quantities, the numbers counted with a word ("1,200 companies"), and the lexicons change-direction, change-base,
+// percent-unit and amount-multiplier.
+import type { Detector, Finding, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { changeRateMismatches, type BaseMark, type Direction, type Figure, type Rate } from "../structure/change-rate.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+const DIGITS = /\d[\d,]*(?:\.(\d+))?/u;
+const DECIMAL_BASE = 10;
+const LATIN = /^[A-Za-z]/u;
+
+/** The step a number is written to: its last digit, times the magnitude the tree folded into the value (12億 is 12 × 1億). */
+const stepOf = (written: string, value: number): number | undefined => {
+  const found = DIGITS.exec(written.normalize("NFKC"));
+  const shown = found === null ? Number.NaN : Number(found[0].replaceAll(",", ""));
+  if (!Number.isFinite(shown) || shown === 0) return undefined;
+  return (value / shown) * DECIMAL_BASE ** -(found?.[1]?.length ?? 0);
+};
+
+/** A word of magnitude right after the number ("$12 million"): the values compared must be written to the same one. */
+const WORD_AFTER = /^\s+([A-Za-z]+)/u;
+const WORDS_AFTER = /^\s+([A-Za-z]+)(?:\s+([A-Za-z]+))?/u;
+
+const multiplierAfter = (source: string, end: number, multipliers: readonly string[]): string => {
+  const after = WORD_AFTER.exec(source.slice(end))?.[1]?.toLowerCase() ?? "";
+  return multipliers.includes(after) ? after : "";
+};
+
+const quantityNodes = (tree: StructureNode): StructureNode[] => inDocumentOrder(tree).filter((node) => node.kind === "quantity" || node.kind === "date");
+
+const ratesOf = (doc: ProseDocument, nodes: readonly StructureNode[], units: readonly string[]): Rate[] =>
+  nodes.flatMap((node) => {
+    const unit = String(node.attrs["unit"] ?? "");
+    if (node.kind !== "quantity" || !units.includes(unit)) return [];
+    const decimals = DIGITS.exec(doc.source.slice(node.span.start, node.span.end).normalize("NFKC"))?.[1]?.length ?? 0;
+    return [{ start: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), decimals }];
+  });
+
+const treeFigures = (doc: ProseDocument, nodes: readonly StructureNode[], units: readonly string[], multipliers: readonly string[]): Figure[] =>
+  nodes.flatMap((node) => {
+    const unit = String(node.attrs["unit"] ?? "");
+    const value = Number(node.attrs["value"]);
+    const step = stepOf(doc.source.slice(node.span.start, node.span.end), value);
+    if (node.kind !== "quantity" || units.includes(unit) || step === undefined) return [];
+    return [{ start: node.span.start, end: node.span.end, value, step, unit: `${unit}|${multiplierAfter(doc.source, node.span.end, multipliers)}` }];
+  });
+
+/** A number with no unit the tree reads, counted with the word after it ("1,200 companies", "2.4 million users"). */
+const COUNTED = /(?<![\w.,$€£¥])(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?(?=\s+[A-Za-z])/gu;
+/** A year written alone ("2024 revenue"): a point in time, not a value. */
+const YEAR = /^(?:1[89]|2[01])\d{2}$/u;
+
+/** The unit a counted number is compared in: the word after it, with a word of magnitude before that word ("million users"). */
+const countedUnit = (source: string, end: number, multipliers: readonly string[]): string | undefined => {
+  const words = WORDS_AFTER.exec(source.slice(end));
+  const first = words?.[1]?.toLowerCase() ?? "";
+  const multiplier = multipliers.includes(first) ? first : "";
+  const noun = multiplier === "" ? first : (words?.[2]?.toLowerCase() ?? "");
+  return LATIN.test(noun) ? `${noun}|${multiplier}` : undefined;
+};
+
+const countedFigures = (doc: ProseDocument, taken: readonly Span[], multipliers: readonly string[]): Figure[] =>
+  [...doc.source.matchAll(COUNTED)].flatMap((match) => {
+    const start = match.index;
+    const end = start + match[0].length;
+    const unit = countedUnit(doc.source, end, multipliers);
+    if (unit === undefined || taken.some((span) => span.start < end && start < span.end) || YEAR.test(match[0])) return [];
+    const decimals = match[2] ?? "";
+    const value = Number([(match[1] ?? "").replaceAll(",", ""), decimals].filter((part) => part !== "").join("."));
+    return [{ start, end, value, step: DECIMAL_BASE ** -decimals.length, unit }];
+  });
+
+/** Where a word of the lexicon stands in the source: a Latin word as a whole word, anything else as written. */
+const spansOf = (source: string, word: string): Span[] => {
+  const pattern = LATIN.test(word) ? new RegExp(`\\b${escapeRegExp(word)}\\b`, "giu") : new RegExp(escapeRegExp(word), "gu");
+  return [...source.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const SIGNS: Readonly<Record<string, 1 | -1>> = { rise: 1, fall: -1 };
+
+/** Phrases that hold a direction word but give no direction ("up to 25%" is a ceiling): lexicon change-direction-not. */
+const directionsOf = (doc: ProseDocument): Direction[] => {
+  const not = patternsOf(doc, "change-direction-not").flatMap((phrase) => spansOf(doc.source, phrase));
+  return (doc.lexicons["change-direction"] ?? []).flatMap((entry) => {
+    const sign = SIGNS[entry.group ?? ""];
+    const spans = spansOf(doc.source, entry.pattern).filter((span) => !not.some((phrase) => phrase.start <= span.start && span.end <= phrase.end));
+    return sign === undefined ? [] : spans.map((span) => ({ ...span, sign }));
+  });
+};
+
+const marksOf = (doc: ProseDocument, lexicon: string): BaseMark[] =>
+  (doc.lexicons[lexicon] ?? []).flatMap((entry) =>
+    entry.position === undefined ? [] : spansOf(doc.source, entry.pattern).map((span) => ({ ...span, position: entry.position ?? "before" })),
+  );
+
+export const changeRate: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const nodes = quantityNodes(doc.structure);
+  const units = patternsOf(doc, "percent-unit");
+  const multipliers = patternsOf(doc, "amount-multiplier").map((word) => word.toLowerCase());
+  const taken = nodes.map((node) => node.span);
+  const text = {
+    sentences: doc.sentences.map((sentence) => sentence.span),
+    figures: [...treeFigures(doc, nodes, units, multipliers), ...countedFigures(doc, taken, multipliers)],
+    rates: ratesOf(doc, nodes, units),
+    directions: directionsOf(doc),
+    marks: marksOf(doc, "change-base"),
+    targets: marksOf(doc, "change-target"),
+  };
+  return changeRateMismatches(text).map((issue) => ({
+    rule: "change-rate-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/derived-numbers.ts

@@ -1,6 +1,6 @@
 import type { Detector, Finding, ProseDocument, Span, StructureNode } from "../plugin.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
-import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+import { documentDateOf } from "./document-date.ts";
 import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
 import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
@@ -142,16 +142,8 @@ const markedAges = (doc: ProseDocument): Elapsed[] =>
 
 /** 文書の日付の年: 日付だけの段落か「更新日：」の段落（date-stamp）の、最初の日付。 */
 const referenceYear = (doc: ProseDocument, tree: StructureNode): number | undefined => {
-  const dates = datesOf(tree);
-  const candidates = stampCandidates(
-    doc.source,
-    doc.paragraphs.map((paragraph) => paragraph.span),
-    dates,
-  );
-  const stamps = dateStampIndexes(candidates, patternsOf(doc, "date-stamp-label"));
-  const paragraph = doc.paragraphs.find((_, index) => stamps.has(index));
-  const date = paragraph === undefined ? undefined : dates.find((candidate) => candidate.start >= paragraph.span.start && candidate.end <= paragraph.span.end);
-  return date === undefined ? undefined : yearOf(date.value);
+  const date = documentDateOf(doc, tree);
+  return date === undefined ? undefined : yearOf(date);
 };
 
 /** 起点の年から数えた年数が、文書の日付と合わない。 */

package/src/detectors/document-date.ts

@@ -0,0 +1,18 @@
+// The document's own date: the first date of its date-stamp paragraph (a paragraph that is only a date, or 「更新日：」).
+import type { ProseDocument, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+
+/** The date of the document's date stamp as the tree reads it ("2026-10-06", or "2026" for a year alone), when it has one. */
+export const documentDateOf = (doc: ProseDocument, tree: StructureNode): string | undefined => {
+  const dates = inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+  const candidates = stampCandidates(
+    doc.source,
+    doc.paragraphs.map((paragraph) => paragraph.span),
+    dates,
+  );
+  const labels = (doc.lexicons["date-stamp-label"] ?? []).map((entry) => entry.pattern);
+  const stamps = dateStampIndexes(candidates, labels);
+  const paragraph = doc.paragraphs.find((_, index) => stamps.has(index));
+  return paragraph === undefined ? undefined : dates.find((candidate) => candidate.start >= paragraph.span.start && candidate.end <= paragraph.span.end)?.value;
+};

package/src/detectors/orthographic-variant.ts

@@ -5,6 +5,7 @@ import { isKatakanaWord, stemOf } from "../long-vowel.ts";
 import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { nameSpans, touchesAny } from "../team-names.ts";
 import { furiganaSpans } from "../furigana.ts";
+import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.ts";
 
 /** A word found in the document: where it is, which sentence it is in, its key and spelling, and how it is written when that differs. */
 type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string };
@@ -150,17 +151,20 @@ const isPartOfAddress = (text: string, start: number, end: number): boolean =>
 
 /**
  * Latin words keyed without hyphens and case (e-mail and email, GitHub and Github). A word in capitals only (TEAMS, MAY) is
- * emphasis or an acronym, not a spelling of the word, and is left out.
+ * emphasis or an acronym, not a spelling of the word, and is left out; so are a name in capitals with an ending (SENDs) and
+ * the letters of an acronym of the sentence picked out (CLImatology for CLIPER).
  */
-const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] =>
-  [...sentence.text.matchAll(LATIN_WORD)].flatMap((match): Placed[] => {
+const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] => {
+  const acronyms = acronymsIn(sentence.text);
+  return [...sentence.text.matchAll(LATIN_WORD)].flatMap((match): Placed[] => {
     const word = match[0];
     const plain = word.toLowerCase().replaceAll("-", "");
     const end = match.index + word.length;
-    if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || skip.has(word.toLowerCase())) return [];
+    if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || isCapitalsNotSpelling(word, acronyms) || skip.has(word.toLowerCase())) return [];
     if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end)) return [];
     return [{ key: `latin|${plain}`, spelling: latinSpelling(word), shown: word, sentence, offset: sentence.span.start + match.index }];
   });
+};
 
 /** How the usual spelling is written where it first appears (gitHub is shown GitHub). */
 const shownUsual = (words: readonly Placed[], { word, usual }: OddSpelling<Placed>): string =>

package/src/detectors/registry/change-rate.ts

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

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

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

package/src/detectors/relative-dates.ts

@@ -4,6 +4,7 @@ import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import type { DurationUnit } from "../derived/date-arithmetic.ts";
 import { relativeMismatches, type DatedValue, type Relative } from "../derived/relative-dates.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { dayWordFindings } from "./relative-day-words.ts";
 
 /** 期間の単位の語彙表。relative-year-unit は、向きの語が付くときだけ期間になる単位（「1年前」の年）。 */
 const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
@@ -96,7 +97,7 @@ export const relativeDateMismatch: Detector = (doc): Finding[] => {
     relatives: relativesOf(doc, amounts),
     links: patternsOf(doc, "relative-link"),
   };
-  return relativeMismatches(input).map((mismatch) => ({
+  const counted = relativeMismatches(input).map((mismatch): Finding => ({
     rule: "relative-date-mismatch",
     severity: "warning",
     line: 0,
@@ -110,4 +111,5 @@ export const relativeDateMismatch: Detector = (doc): Finding[] => {
       offset: mismatch.target.start,
     },
   }));
+  return [...counted, ...dayWordFindings(doc, dates)];
 };

package/src/detectors/relative-day-words.ts

@@ -0,0 +1,126 @@
+// relative-date-mismatch, the day words: 「来週月曜（10月12日）」「明日（10月7日）」"next Monday (October 12)" against the
+// date field of an email or minutes. The words are the lexicons relative-week, relative-day, weekday and message-date-field;
+// the reckoning is derived/relative-weekdays.ts.
+import type { Finding, ProseDocument, Span } from "../plugin.ts";
+import type { DatedValue } from "../derived/relative-dates.ts";
+import { relativeDayMismatch, type DayWord } from "../derived/relative-weekdays.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const FULL = /^\d{4}-\d{2}-\d{2}$/u;
+const LATIN = /^[A-Za-z]/u;
+/** 文書の書き出し: 最初の見出しより前と、最初の見出しの節。メールや議事録の頭の日付（日付：、Date:）が書かれる所。 */
+const OPENING_SECTIONS = 1;
+/** The separators a date may follow its day word with: a space, a bracket, a comma (「来週月曜（10月12日）」). */
+const SEPARATORS = /[\s,、，(（:：]/gu;
+
+const wordPattern = (word: string): RegExp => new RegExp(LATIN.test(word) ? `\\b${escapeRegExp(word)}\\b` : escapeRegExp(word), "giu");
+
+const spansOf = (source: string, word: string): Span[] =>
+  [...source.matchAll(wordPattern(word))].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** The weekday written right after a week word (Sunday is 0), and where it ends: the name, or the name without its last 日 (月曜). */
+const weekdayAt = (source: string, at: number, names: readonly string[]): { readonly weekday: number; readonly end: number } | undefined => {
+  const gap = source.slice(at).length - source.slice(at).trimStart().length;
+  const rest = source.slice(at + gap).toLowerCase();
+  const found = names
+    .map((name, weekday) => {
+      const lower = name.toLowerCase();
+      const short = LATIN.test(name) ? lower : lower.slice(0, -1);
+      const written = [lower, short].find((form) => form.length >= 2 && rest.startsWith(form));
+      return written === undefined ? undefined : { weekday, end: at + gap + written.length };
+    })
+    .find((entry) => entry !== undefined);
+  return gap > 1 ? undefined : found;
+};
+
+const dayWordsOf = (doc: ProseDocument): DayWord[] => {
+  const names = (doc.lexicons["weekday"] ?? []).map((entry) => entry.pattern);
+  const weeks = (doc.lexicons["relative-week"] ?? []).flatMap((entry): DayWord[] =>
+    spansOf(doc.source, entry.pattern).flatMap((span) => {
+      const day = weekdayAt(doc.source, span.end, names);
+      return day === undefined ? [] : [{ start: span.start, end: day.end, kind: "weekday", weeks: Number(entry.group), weekday: day.weekday }];
+    }),
+  );
+  const days = (doc.lexicons["relative-day"] ?? []).flatMap((entry): DayWord[] =>
+    spansOf(doc.source, entry.pattern).map((span) => ({ ...span, kind: "day", days: Number(entry.group) })),
+  );
+  // 「再来週」の中の「来週」、「明後日」の中の「明日」は読まない: 長い語が覆う語を落とす。
+  const all = [...weeks, ...days];
+  return all.filter(
+    (word) => !all.some((other) => other !== word && other.start <= word.start && word.end <= other.end && other.end - other.start > word.end - word.start),
+  );
+};
+
+/** The date written right after the day word: only separators and a link word (の, on) between. */
+const targetOf = (doc: ProseDocument, dates: readonly DatedValue[], word: DayWord): DatedValue | undefined => {
+  const next = dates.find((date) => date.start >= word.end);
+  if (next === undefined) return undefined;
+  const between = doc.source.slice(word.end, next.start).replace(SEPARATORS, "").toLowerCase();
+  const links = (doc.lexicons["relative-link"] ?? []).map((entry) => entry.pattern.replace(SEPARATORS, "").toLowerCase());
+  return between === "" || links.includes(between) ? next : undefined;
+};
+
+const lineStartAt = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+const lineAt = (source: string, offset: number): string => {
+  const start = lineStartAt(source, offset);
+  const end = source.indexOf("\n", offset);
+  return source.slice(start, end === -1 ? source.length : end);
+};
+
+const FIELD_MARK = /^\s*(?:[-*+]\s+)?(?<label>[^:：]{1,12})[:：]/u;
+
+/**
+ * The date the day words count from: the first full date on a date field of the opening (「日付:」「日時:」"Date:", lexicon
+ * message-date-field), before the first heading or in the first heading's section. A document without one (a press release
+ * whose only date is an update stamp) has no date to count from.
+ */
+const baseOf = (doc: ProseDocument, dates: readonly DatedValue[], starts: readonly number[]): DatedValue | undefined => {
+  const labels = (doc.lexicons["message-date-field"] ?? []).map((entry) => entry.pattern.toLowerCase());
+  return dates.find((date) => {
+    const label = FIELD_MARK.exec(lineAt(doc.source, date.start))?.groups?.["label"]?.trim().toLowerCase() ?? "";
+    return FULL.test(date.value) && labels.includes(label) && starts.filter((start) => start <= date.start).length <= OPENING_SECTIONS;
+  });
+};
+
+const QUOTED_LINE = /^\s*>/u;
+
+/**
+ * Day words the document's date does not count: in a quoted reply (「> 明日（10月2日）」 counts from the quoted mail's date),
+ * or in a section whose heading names a date (「## 10月1日の会」: its 「本日」 is that day).
+ */
+const countedFromBase = (doc: ProseDocument, word: DayWord, datedHeadings: readonly number[], starts: readonly number[]): boolean => {
+  const section = starts.filter((start) => start <= word.start).at(-1);
+  return !QUOTED_LINE.test(lineAt(doc.source, word.start)) && (section === undefined || !datedHeadings.includes(section));
+};
+
+export const dayWordFindings = (doc: ProseDocument, dates: readonly DatedValue[]): Finding[] => {
+  const starts = doc.sections.filter((section) => section.depth > 0).map((section) => section.span.start);
+  const base = baseOf(doc, dates, starts);
+  if (base === undefined) return [];
+  const datedHeadings = starts.filter((start) => dates.some((date) => date.start >= start && date.start < start + lineAt(doc.source, start).length));
+  return dayWordsOf(doc)
+    .filter((word) => countedFromBase(doc, word, datedHeadings, starts))
+    .flatMap((word): Finding[] => {
+      const target = targetOf(doc, dates, word);
+      const expected = target === undefined || target === base ? undefined : relativeDayMismatch(base.value, word, target.value);
+      if (target === undefined || expected === undefined) return [];
+      return [
+        {
+          rule: "relative-date-mismatch",
+          severity: "warning",
+          line: 0,
+          column: 0,
+          quote: quoteAt(doc.source, target.start),
+          values: {
+            base: doc.source.slice(base.start, base.end),
+            relative: doc.source.slice(word.start, word.end),
+            target: doc.source.slice(target.start, target.end),
+            expected,
+            offset: target.start,
+          },
+        },
+      ];
+    });
+};

package/src/detectors/structure-tree.ts

@@ -1,12 +1,15 @@
-import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+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 { weekdayMismatches } from "../structure/weekday.ts";
+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 { 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";
 
 const QUOTE_LENGTH = 80;
@@ -35,7 +38,39 @@ const findingsOf =
         }));
 
 export const danglingReference: Detector = findingsOf("dangling-reference", danglingReferences);
-export const numberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
+const structureNumberingGap: Detector = findingsOf("numbering-gap", numberingBreaks);
+
+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 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 },
+    }));
+
+/**
+ * 番号の抜けと重なり: 番地の木の並び（条、項、号）と、Markdown の番号付きの箇条書きに書いた番号。条の中の「1.」「2.」は
+ * 両方に読まれるので、木が指した行の箇条書きは重ねて言わない。
+ */
+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"]));
+};
 export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);
 
 /** 曜日の名前は言語パッケージの語彙表（weekday、日曜日から順）から取る。無ければ番号のまま。 */
@@ -59,10 +94,33 @@ const quotedDates = (doc: ProseDocument, from: DatedSpan | undefined, until: Dat
 
 const dateAt = (dates: readonly DatedSpan[], offset: number): number => dates.findIndex((date) => date.offset === offset);
 
+/** A year written as figures in a heading: 2024年度, FY2024, "2024 events". */
+const YEAR_FIGURES = /(?<![0-9０-９])(?:1[89]|20)\d{2}(?![0-9０-９])/u;
+const ERA_YEAR_NUMBER = /^[ \t]?(?:[0-9０-９]{1,2}|元)/u;
+
+/** 見出しが年を名指すか: 数字の年（2024年度、FY2024）か、暦の元号の年（語彙表 calendar-era、令和6年度）。 */
+const namesYear = (heading: string, eras: readonly string[]): boolean =>
+  YEAR_FIGURES.test(heading) ||
+  eras.some((era) => {
+    const at = heading.indexOf(era);
+    return at !== -1 && ERA_YEAR_NUMBER.test(heading.slice(at + era.length));
+  });
+
 export const dateWeekdayMismatch: Detector = (doc): Finding[] => {
   if (doc.structure === undefined) return [];
   const dates = datedSpans(doc.structure);
-  return weekdayMismatches(doc.structure)
+  const sections = doc.sections.filter((section) => section.depth > 0);
+  const eras = (doc.lexicons["calendar-era"] ?? []).map((entry) => entry.pattern);
+  const context = {
+    stamp: documentDateOf(doc, doc.structure),
+    sectionStarts: sections.map((section) => section.span.start),
+    yearHeadings: sections.filter((section) => namesYear(section.heading, eras)).map((section) => section.span.start),
+    anchorable: (node: StructureNode): boolean => {
+      const date = dates[dateAt(dates, node.span.start)];
+      return !quotedDates(doc, date, date, WEEKDAY_WORDS);
+    },
+  };
+  return weekdayMismatches(doc.structure, context)
     .filter((issue) => {
       const date = dates[dateAt(dates, issue.offset)];
       return !quotedDates(doc, date, date, WEEKDAY_WORDS);
@@ -178,10 +236,24 @@ const shareWordsOf = (doc: ProseDocument): ShareWords => ({
 });
 
 /** 構成比や内訳の百分率の和が 100% にならない。割合の語と百分率の単位は言語パッケージの語彙表から取る。 */
+/**
+ * 表や箇条書きの内訳と、一つの文に並べた内訳（「構成比は、Aが50%、Bが30%、Cが20%」）。箇条書きの項目の文は両方に読まれうるので、
+ * 表や箇条書きが指した行の文は重ねて言わない。
+ */
+const percentSumIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
+  const amounts = amountsOf(tree);
+  const words = shareWordsOf(doc);
+  const runs = percentSumMismatches(doc.source, amounts, words);
+  const reported = new Set(runs.map((issue) => lineStartAt(doc.source, issue.offset)));
+  const sentences = doc.sentences.map((sentence) => sentence.span);
+  const prose = proseShareMismatches(doc.source, sentences, amounts, words).filter((issue) => !reported.has(lineStartAt(doc.source, issue.offset)));
+  return [...runs, ...prose].toSorted((left, right) => left.offset - right.offset);
+};
+
 export const percentSumMismatch: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : percentSumMismatches(doc.source, amountsOf(doc.structure), shareWordsOf(doc)).map((issue) => ({
+    : percentSumIssues(doc, doc.structure).map((issue) => ({
         rule: "percent-sum-mismatch",
         severity: "warning",
         line: 0,

package/src/detectors/version-mismatch.ts

@@ -0,0 +1,23 @@
+// version-mismatch: the version a code block's lead-in names against the one the block shows (structure/version-mismatch.ts).
+// The words that make a version a bound (「から」「以上」, "from", "or later") are the lexicon version-range; the words that
+// lead to the version installed (version, install) are version-lead.
+import type { Detector, Finding } from "../plugin.ts";
+import { versionMismatches, type RangeWord, type VersionWords } from "../structure/version-mismatch.ts";
+import { codeFences } from "./code-fences.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+export const versionMismatch: Detector = (doc): Finding[] => {
+  const words: VersionWords = {
+    ranges: (doc.lexicons["version-range"] ?? []).map((entry): RangeWord => ({ word: entry.pattern, position: entry.position ?? "before" })),
+    versionWords: (doc.lexicons["version-lead"] ?? []).map((entry) => entry.pattern),
+  };
+  const blocks = codeFences(doc.source).map((fence) => ({ start: fence.start, code: fence.lines.join("\n") }));
+  return versionMismatches(doc.source, doc.prose ?? doc.source, blocks, words).map((issue) => ({
+    rule: "version-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/structure/change-rate.ts

@@ -0,0 +1,103 @@
+// A rate of change written beside the two values it is computed from (「前年同月の1,000社から20%増えました」 with 1,200社,
+// "up 20% from 1,000 companies" with 1,200 companies) that the two values do not give. Pure; the detector reads the
+// figures, the rate and the words from the tree and the language's lexicons.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/** A value with its unit as the sentence compares it (円, 社, $, companies) and the step it is written to (1 for 1,200; 1億 for 12億). */
+export type Figure = Span & { readonly value: number; readonly unit: string; readonly step: number };
+/** A percentage, with the number of decimals written. */
+export type Rate = Span & { readonly value: number; readonly decimals: number };
+/** A word that says which way the value moved (増加, up: 1; 減少, down: -1). */
+export type Direction = Span & { readonly sign: 1 | -1 };
+/** A word that marks a value: the earlier one after it (「1,000社から」) or before it ("from 1,000"), the later one (「1,200社に」, "to 1,200"). */
+export type BaseMark = Span & { readonly position: "before" | "after" };
+
+export type ChangeText = {
+  readonly sentences: readonly Span[];
+  readonly figures: readonly Figure[];
+  readonly rates: readonly Rate[];
+  readonly directions: readonly Direction[];
+  readonly marks: readonly BaseMark[];
+  /** Words that mark the later value ("to", 「に」). */
+  readonly targets: readonly BaseMark[];
+};
+
+/** How far a direction word may stand from the rate (「20%の増加」「20%増えました」, "an increase of 20%", "up 20%"). */
+const DIRECTION_REACH = 8;
+/** How far a base mark may stand from its value ("from $10" has the currency sign between). */
+const MARK_GAP = 3;
+/**
+ * How far the earlier value may stand from the rate (「1,000社から20%」「10億円に比べて20%」"20% from $10 million"). Further
+ * away, the rate is of something else in the sentence (「100店から120店に増え、売上は15%増えた」).
+ */
+const BASE_REACH = 12;
+const PERCENT = 100;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+
+const within = (outer: Span, inner: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
+
+const distance = (left: Span, right: Span): number => Math.max(left.start - right.end, right.start - left.end, 0);
+
+const markOf = (figure: Figure, marks: readonly BaseMark[]): BaseMark | undefined =>
+  marks.find((mark) => {
+    const gap = mark.position === "after" ? mark.start - figure.end : figure.start - mark.end;
+    return gap >= 0 && gap <= MARK_GAP;
+  });
+
+/** The earlier value: marked, with the value or its mark beside the rate ("up 25% compared with $1,000"). */
+const isBaseFor = (figure: Figure, rate: Rate, marks: readonly BaseMark[]): boolean => {
+  const mark = markOf(figure, marks);
+  return mark !== undefined && Math.min(distance(figure, rate), distance(mark, rate)) <= BASE_REACH;
+};
+
+/**
+ * The later value is written before the rate (「1,200社となり、…20%増えました」"1,200 companies, up 20%") or marked as the
+ * value reached (「1,200社に」"to 1,200"). Another amount after the rate is about something else ("…, and revenue was $1,300").
+ */
+const isCurrentFor = (figure: Figure, rate: Rate, targets: readonly BaseMark[]): boolean => figure.end <= rate.start || markOf(figure, targets) !== undefined;
+
+/** The one sign the direction words beside the rate agree on. */
+const signNear = (rate: Rate, directions: readonly Direction[]): 1 | -1 | undefined => {
+  const signs = new Set(directions.filter((direction) => distance(direction, rate) <= DIRECTION_REACH).map((direction) => direction.sign));
+  const [sign] = signs;
+  return signs.size === 1 ? sign : undefined;
+};
+
+/**
+ * The rates of change the two values allow. Each value may be off by half the step it is written to: 12億 is anything from
+ * 11.5億 to 12.5億, so 12億 from 10億 is a rise of 9.5% to 31.6%, and only a rate outside that is a mistake.
+ */
+const rateRange = (base: Figure, current: Figure): readonly [number, number] | undefined => {
+  const [baseLow, baseHigh] = [base.value - base.step * HALF, base.value + base.step * HALF];
+  const [currentLow, currentHigh] = [current.value - current.step * HALF, current.value + current.step * HALF];
+  if (baseLow <= 0) return undefined;
+  return [(currentLow / baseHigh - 1) * PERCENT, (currentHigh / baseLow - 1) * PERCENT];
+};
+
+const issueIn = (text: ChangeText, sentence: Span): StructureIssue[] => {
+  const rates = text.rates.filter((rate) => within(sentence, rate));
+  const figures = text.figures.filter((figure) => within(sentence, figure));
+  const [rate] = rates;
+  if (rates.length !== 1 || rate === undefined) return [];
+  const sign = signNear(
+    rate,
+    text.directions.filter((direction) => within(sentence, direction)),
+  );
+  const bases = figures.filter((figure) => isBaseFor(figure, rate, text.marks));
+  const [base] = bases;
+  if (sign === undefined || bases.length !== 1 || base === undefined) return [];
+  const currents = figures.filter((figure) => figure !== base && figure.unit === base.unit && isCurrentFor(figure, rate, text.targets));
+  const [current] = currents;
+  const range = currents.length === 1 && current !== undefined ? rateRange(base, current) : undefined;
+  if (range === undefined || current === undefined) return [];
+  const written = sign * rate.value;
+  const slack = HALF * DECIMAL_BASE ** -rate.decimals;
+  if (written >= range[0] - slack && written <= range[1] + slack) return [];
+  const computed = Math.abs((current.value / base.value - 1) * PERCENT).toFixed(rate.decimals);
+  return [{ offset: rate.start, values: { rate: String(rate.value), computed } }];
+};
+
+/** Each sentence with one rate of change, one direction, one marked earlier value and one other value in its unit, that disagree. */
+export const changeRateMismatches = (text: ChangeText): StructureIssue[] => text.sentences.flatMap((sentence) => issueIn(text, sentence));

package/src/structure/list-numbering.ts

@@ -0,0 +1,34 @@
+// The numbers written on the items of a Markdown ordered list (「1.」「2.」「4.」) that skip or repeat. Markdown renders an
+// ordered list from its first number on, but the source shows the numbers as written, and a "see step 4" points at those.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+
+const ITEM_NUMBER = /^(?<number>\d{1,9})(?<delimiter>[.)])[ \t]/u;
+
+/** One item's written number: where the item starts, the number and the number as written (「4.」). */
+export type WrittenNumber = { readonly offset: number; readonly number: number; readonly label: string };
+
+/** The number written at the start of each item, or undefined when an item has none (a bulleted list). */
+export const writtenNumbers = (source: string, itemSpans: readonly Span[]): WrittenNumber[] | undefined => {
+  const numbers = itemSpans.map((span) => {
+    const found = ITEM_NUMBER.exec(source.slice(span.start, span.end))?.groups;
+    return found === undefined
+      ? undefined
+      : { offset: span.start, number: Number(found["number"]), label: `${found["number"] ?? ""}${found["delimiter"] ?? ""}` };
+  });
+  return numbers.every((entry) => entry !== undefined) ? numbers : undefined;
+};
+
+/**
+ * Each item whose number is not one more than the item before it. A list that writes one number on every item (「1.」 on
+ * each, which Markdown counts up) is numbered by the renderer, not by the writer, and is not read. An item numbered 1
+ * starts a new count, as the structure rule reads a 1 that follows other items.
+ */
+export const listNumberBreaks = (items: readonly WrittenNumber[]): StructureIssue[] => {
+  if (new Set(items.map((item) => item.number)).size < 2) return [];
+  return items.flatMap((item, index) => {
+    const previous = items[index - 1];
+    if (previous === undefined || item.number === previous.number + 1 || item.number === 1) return [];
+    return [{ offset: item.offset, values: { previous: previous.label, label: item.label, expected: previous.number + 1, found: item.number } }];
+  });
+};