chaffjs 0.26.0 → 0.27.1

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,223 @@
+// 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" };
+/** A calendar year written in the sentence (「2025年」, "in 2025"). */
+export type Period = Span & { readonly year: number };
+/** A word that starts another subject or clause; one that joins two values ("… in 2025 and …") is read only before the rate. */
+export type Break = Span & { readonly beforeRateOnly: boolean };
+
+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[];
+  readonly periods: readonly Period[];
+  /** Words that start another subject or clause (「利益は」, "and", ";"): a rate after one is not about the values before it. */
+  readonly breaks: readonly Break[];
+  /** The document's text, which the gaps of a pair are measured in. */
+  readonly source: string;
+};
+
+/** 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;
+/**
+ * The two values written together, the earlier then the later or the other way round (「昨年の100万円から今年は150万円」
+ * "from $1.0 million last year to $1.5 million"): how far apart they may stand, and how far after them the rate may
+ * (「150万円になり、前年比20%」", an increase of 20%"). Measured with a Latin word counting as one character.
+ */
+const PAIR_GAP = 16;
+const PAIR_REACH = 16;
+/** How far a year may stand from the value it dates (「2025年の100万円」"$1.0 million in 2025"), a word counting as one. */
+const PERIOD_GAP = 8;
+const LATIN_WORD = /[A-Za-z]+/gu;
+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 gapBetween = (left: Span, right: Span): Span => ({ start: left.end, end: right.start });
+
+/** The length of a gap, a Latin word counting as one character: "an increase of" is as short as 「前年比」. */
+export const gapLength = (source: string, gap: Span): number => source.slice(gap.start, gap.end).replaceAll(LATIN_WORD, "w").length;
+
+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];
+};
+
+type Pair = { readonly base: Figure; readonly current: Figure };
+/** One sentence's parts, with the rate: the one percentage that has a word of direction beside it. */
+type Reading = ChangeText & { readonly rate: Rate; readonly sign: 1 | -1 };
+
+/** A word between the two that starts another subject or clause (「100万円から150万円に増え、利益は20%」). */
+const brokenBetween = (text: Reading, one: Span, other: Span): boolean => {
+  const gap = one.end <= other.start ? gapBetween(one, other) : gapBetween(other, one);
+  return text.breaks.some((word) => within(gap, word));
+};
+
+/** The earlier value marked beside the rate, and the one value in its unit before the rate or marked as reached. */
+const besideRate = (text: Reading): Pair | undefined => {
+  const bases = text.figures.filter((figure) => isBaseFor(figure, text.rate, text.marks) && !brokenBetween(text, figure, text.rate));
+  const [base] = bases;
+  if (bases.length !== 1 || base === undefined) return undefined;
+  const currents = text.figures.filter((figure) => figure !== base && figure.unit === base.unit && isCurrentFor(figure, text.rate, text.targets));
+  const [current] = currents;
+  return currents.length === 1 && current !== undefined ? { base, current } : undefined;
+};
+
+const yearsBeside = (text: Reading, figure: Figure, side: "before" | "after", bound: Span): Period[] =>
+  text.periods.filter((period) => {
+    const [left, right] = side === "before" ? [period, figure] : [figure, period];
+    return left.end <= right.start && within(bound, period) && gapLength(text.source, gapBetween(left, right)) <= PERIOD_GAP;
+  });
+
+/**
+ * Of two values each dated by a year, the earlier year's. The years stand on the same side of both values: before them
+ * (「2025年は100万円、2026年は150万円」) or after them ("$1.0 million in 2025 and $1.5 million in 2026").
+ */
+const datedEarlier = (text: Reading, first: Figure, second: Figure): Figure | undefined => {
+  const middle = gapBetween(first, second);
+  const sides = [
+    [yearsBeside(text, first, "before", { start: 0, end: first.start }), yearsBeside(text, second, "before", middle)],
+    [yearsBeside(text, first, "after", middle), yearsBeside(text, second, "after", { start: second.end, end: text.source.length })],
+  ].filter(([early, late]) => early?.length === 1 && late?.length === 1);
+  const [[early, late] = []] = sides;
+  const [firstYear, secondYear] = [early?.[0]?.year, late?.[0]?.year];
+  if (sides.length !== 1 || firstYear === undefined || secondYear === undefined || firstYear === secondYear) return undefined;
+  return firstYear < secondYear ? first : second;
+};
+
+/** Which of two values written together is the earlier: the one marked (「から」, "from", 「前年の」), else the one dated earlier. */
+const pairOf = (text: Reading, first: Figure, second: Figure): Pair | undefined => {
+  const marked = [first, second].filter((figure) => markOf(figure, text.marks) !== undefined);
+  if (marked.length > 1) return undefined;
+  const base = marked[0] ?? datedEarlier(text, first, second);
+  if (base === undefined) return undefined;
+  return { base, current: base === first ? second : first };
+};
+
+/** Nothing between the later value and the rate that makes the rate another one's: a value, another subject, another base. */
+const leadsTo = (text: Reading, second: Figure): boolean => {
+  const gap = gapBetween(second, text.rate);
+  if (gap.start > gap.end || gapLength(text.source, gap) > PAIR_REACH) return false;
+  return ![...text.figures, ...text.breaks, ...text.marks].some((span) => within(gap, span));
+};
+
+/** Two values of one subject written close, with no rate between them (「売上は100万円、費用は150万円」 is two subjects). */
+const standTogether = (text: Reading, first: Figure, second: Figure): boolean => {
+  const gap = gapBetween(first, second);
+  const inGap = (span: Span): boolean => within(gap, span);
+  if (gapLength(text.source, gap) > PAIR_GAP || text.rates.some(inGap)) return false;
+  return !text.breaks.some((word) => !word.beforeRateOnly && inGap(word));
+};
+
+/** The two values written together right before the rate (「昨年の100万円から今年は150万円になり、前年比20%の増加」). */
+const beforeRate = (text: Reading): Pair | undefined => {
+  const pairs = text.figures.flatMap((first, index) => {
+    const second = text.figures.slice(index + 1).find((figure) => figure.unit === first.unit);
+    const pair = second !== undefined && standTogether(text, first, second) && leadsTo(text, second) ? pairOf(text, first, second) : undefined;
+    return pair === undefined ? [] : [pair];
+  });
+  const [pair] = pairs;
+  return pairs.length === 1 ? pair : undefined;
+};
+
+/**
+ * The sentence's one rate with a word of direction beside it, a word counting for the rate it stands nearest. A percentage
+ * without one (「20%の増加、利益率は10%」) is about something else.
+ */
+const readingIn = (text: ChangeText, sentence: Span): Reading | undefined => {
+  const inSentence = (span: Span): boolean => within(sentence, span);
+  const directions = text.directions.filter(inSentence);
+  const rates = text.rates.filter(inSentence);
+  const nearestTo = (rate: Rate, direction: Direction): boolean => rates.every((other) => distance(direction, rate) <= distance(direction, other));
+  const signed = rates.flatMap((rate) => {
+    const sign = signNear(
+      rate,
+      directions.filter((direction) => nearestTo(rate, direction)),
+    );
+    return sign === undefined ? [] : [{ rate, sign }];
+  });
+  const [only] = signed;
+  if (signed.length !== 1 || only === undefined) return undefined;
+  const parts = {
+    figures: text.figures.filter(inSentence).toSorted((left, right) => left.start - right.start),
+    periods: text.periods.filter(inSentence),
+    breaks: text.breaks.filter(inSentence),
+  };
+  return { ...text, ...parts, ...only, rates };
+};
+
+const issueIn = (text: ChangeText, sentence: Span): StructureIssue[] => {
+  const reading = readingIn(text, sentence);
+  const pair = reading === undefined ? undefined : (besideRate(reading) ?? beforeRate(reading));
+  const range = pair === undefined ? undefined : rateRange(pair.base, pair.current);
+  if (reading === undefined || pair === undefined || range === undefined) return [];
+  const { rate, sign } = reading;
+  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((pair.current.value / pair.base.value - 1) * PERCENT).toFixed(rate.decimals);
+  return [{ offset: rate.start, values: { rate: String(rate.value), computed } }];
+};
+
+/**
+ * Each sentence with one rate of change and its direction, and the two values it is computed from, that disagree: the
+ * earlier value marked beside the rate, or the two values written together right before it.
+ */
+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 } }];
+  });
+};

package/src/structure/percent-sum-prose.ts

@@ -0,0 +1,54 @@
+// A breakdown written in one sentence (「構成比は、Aが50%、Bが30%、Cが20%」, "By product, A made up 50% of sales, B 30% and
+// C 20%") whose shares do not add up to 100%. The table and list form is structure/percent-sum.ts; the words are the same.
+import type { Span } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+import type { Amount } from "./total.ts";
+import type { ShareWords } from "./percent-sum.ts";
+
+const WHOLE = 100;
+/** A sentence names two shares in passing (「AとBで50%」); a breakdown in prose names at least three parts. */
+const MIN_PARTS = 3;
+/**
+ * How far from 100% a sentence may add up and still read as one whole broken down. Far below it, the sentence names only the
+ * larger parts (「Aが50%、Bが20%、Cが10%など」); far above it, the percentages are of different wholes ("55% of directors,
+ * 48% of managers") or of two periods ("45% (40% last year)"), or the total is among them (「合計100%」).
+ */
+const BAND = 10;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+const DECIMALS = /\.(\d+)/u;
+/** A sign before the number (+3%, ▲2%): a change, not a part. */
+const SIGNS = "-+−▲△";
+
+const includesAny = (text: string, words: readonly string[]): boolean => {
+  const lowered = text.toLowerCase();
+  return words.some((word) => lowered.includes(word.toLowerCase()));
+};
+
+const decimalsOf = (source: string, amount: Amount): number => DECIMALS.exec(source.slice(amount.offset, amount.end))?.[1]?.length ?? 0;
+
+const isSigned = (source: string, amount: Amount): boolean => SIGNS.includes(source.slice(0, amount.offset).trimEnd().at(-1) ?? " ");
+
+/** The rounding the parts allow: half the last digit each, at least one point. */
+const toleranceOf = (source: string, shares: readonly Amount[]): number =>
+  Math.max(1, shares.length * HALF * DECIMAL_BASE ** -Math.max(0, ...shares.map((share) => decimalsOf(source, share))));
+
+const isBroken = (sum: number, tolerance: number): boolean => Math.abs(sum - WHOLE) > tolerance && Math.abs(sum - WHOLE) <= BAND;
+
+const issueIn = (source: string, sentence: Span, percents: readonly Amount[], words: ShareWords): StructureIssue[] => {
+  const text = source.slice(sentence.start, sentence.end);
+  if (!includesAny(text, words.labels) || includesAny(text, words.exceptions)) return [];
+  const shares = percents.filter((amount) => amount.offset >= sentence.start && amount.end <= sentence.end);
+  if (shares.length < MIN_PARTS || shares.some((share) => isSigned(source, share))) return [];
+  const sum = shares.reduce((total, share) => total + share.value, 0);
+  const decimals = Math.max(0, ...shares.map((share) => decimalsOf(source, share)));
+  if (!isBroken(sum, toleranceOf(source, shares))) return [];
+  return [{ offset: shares[0]?.offset ?? sentence.start, values: { sum: `${sum.toFixed(decimals)}${shares[0]?.unit ?? ""}` } }];
+};
+
+/** Each sentence that names a share word and three or more unsigned percentages whose sum misses 100% by more than rounding, and by no more than BAND. */
+export const proseShareMismatches = (source: string, sentences: readonly Span[], amounts: readonly Amount[], words: ShareWords): StructureIssue[] => {
+  if (words.labels.length === 0) return [];
+  const percents = amounts.filter((amount) => words.units.includes(amount.unit));
+  return sentences.flatMap((sentence) => issueIn(source, sentence, percents, words));
+};