chaffjs 0.27.1 → 0.29.0

package/src/structure/time-marks.ts

@@ -0,0 +1,127 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * 時刻のまわりに書く印を読む。発・着（departs、arr）、翌日（翌、+1、next day）、時間帯（JST、現地時間）。
+ * 語は言語パッケージの語彙表（leg-mark、leg-column、day-shift-mark、time-zone、local-time-mark）から来る。ここは字面を照らすだけで、語を知らない。
+ */
+
+/** 語彙表の一語。position は時刻のどちら側に書くか、group は語の組（departure と arrival、next と previous、local）。 */
+export type Mark = { readonly pattern: string; readonly position?: "before" | "after" | undefined; readonly group?: string | undefined };
+
+/** 時刻と、その原文の範囲。seconds は 0 時からの秒。 */
+export type TimeSpan = { readonly start: number; readonly end: number; readonly seconds: number };
+
+/** 日付と、その原文の範囲。value は年月日、年月、月日のいずれか（2026-04-01、04-01）。 */
+export type DateSpan = { readonly start: number; readonly end: number; readonly value: string };
+
+/** legs は時刻の前後に書く発着の印、columns は表の発着の列の名前、dayShifts は翌日・前日の印、zones は時間帯の印。 */
+export type TimeWords = {
+  readonly legs: readonly Mark[];
+  readonly columns: readonly Mark[];
+  readonly dayShifts: readonly Mark[];
+  readonly zones: readonly Mark[];
+};
+
+export const SECONDS_PER_DAY = 86_400;
+const SECONDS_PER_HOUR = 3600;
+const SECONDS_PER_MINUTE = 60;
+
+/** 「09:30」「21:05:10」の鍵を 0 時からの秒にする。 */
+export const secondsOf = (key: string): number => {
+  const [hour = 0, minute = 0, second = 0] = key.split(":").map(Number);
+  return hour * SECONDS_PER_HOUR + minute * SECONDS_PER_MINUTE + second;
+};
+
+/** 語の端の字の種類。英字は英字と、数字は数字と続けば一つの語（dep と department、+1 と +10）。 */
+const KINDS = [/[A-Za-z]/u, /[0-9０-９]/u];
+
+const joins = (edge: string, beside: string): boolean => KINDS.some((kind) => kind.test(edge) && kind.test(beside));
+
+/** text の at から pattern が、前後の字と続かない一語として書かれているか。 */
+export const isWordAt = (text: string, at: number, pattern: string): boolean => {
+  if (pattern === "" || !text.startsWith(pattern, at)) return false;
+  return !joins(pattern.charAt(0), text.charAt(at - 1)) && !joins(pattern.charAt(pattern.length - 1), text.charAt(at + pattern.length));
+};
+
+/** text の中で pattern が語として書かれた位置。 */
+export const wordOffsets = (text: string, pattern: string): number[] =>
+  [...text.matchAll(new RegExp(escapeRegExp(pattern), "gu"))].flatMap((match) => (isWordAt(text, match.index, pattern) ? [match.index] : []));
+
+const sidesOf = (marks: readonly Mark[], side: "before" | "after"): Mark[] => marks.filter((mark) => mark.position === side);
+
+/** 長い語から照らす（「翌日」を「翌」より先に）。 */
+const longestFirst = (marks: readonly Mark[]): Mark[] => marks.toSorted((left, right) => right.pattern.length - left.pattern.length);
+
+/** 時刻のすぐ後ろ（間を空けない）に書いた印。「08:00発」の「発」。 */
+export const markRightAfter = (text: string, end: number, marks: readonly Mark[]): Mark | undefined =>
+  longestFirst(sidesOf(marks, "after")).find((mark) => isWordAt(text, end, mark.pattern));
+
+/** 時刻の前の、間に letters 字までしか挟まない印。「departs Boston 7:30」の departs、「翌 0:15」の翌。 */
+export const markBefore = (head: string, marks: readonly Mark[], letters: number): Mark | undefined => {
+  const found = longestFirst(sidesOf(marks, "before")).flatMap((mark) =>
+    wordOffsets(head, mark.pattern).map((at) => ({ mark, gap: head.length - at - mark.pattern.length })),
+  );
+  const nearest = found.filter((entry) => entry.gap >= 0 && entry.gap <= letters).toSorted((left, right) => left.gap - right.gap)[0];
+  return nearest?.mark;
+};
+
+/** 時刻の後ろで、空白と開き括弧と発着の印を飛ばした所に書いた印。「0:15（翌日）」「9:50着 +1」。 */
+const SKIPPED_AFTER = /^[\s(（[［]*/u;
+
+export const markSoonAfter = (text: string, end: number, marks: readonly Mark[], skipped: readonly Mark[]): Mark | undefined => {
+  const leg = markRightAfter(text, end, skipped);
+  const from = end + (leg?.pattern.length ?? 0);
+  const gap = SKIPPED_AFTER.exec(text.slice(from))?.[0].length ?? 0;
+  return markRightAfter(text, from + gap, marks);
+};
+
+/** 日をまたぐ印の向き。翌日なら 1、前日なら -1、無ければ 0。 */
+const shiftOf = (mark: Mark | undefined): number => {
+  if (mark === undefined) return 0;
+  return mark.group === "previous" ? -1 : 1;
+};
+
+/** 「翌 0:15」のように前に書く翌日は、間に空白一つまで。 */
+const DAY_SHIFT_GAP = 1;
+
+/** 時刻の前置きから、時刻の直前に書いた翌日・前日の印（「翌 」）を除いたもの。印が無ければそのまま。 */
+export const withoutDayShiftBefore = (head: string, words: TimeWords): string => {
+  const mark = markBefore(head, words.dayShifts, DAY_SHIFT_GAP);
+  return mark === undefined ? head : head.slice(0, head.lastIndexOf(mark.pattern));
+};
+
+/** 時刻に付けた翌日・前日の印。head は時刻の前の原文、text と end は時刻の後ろを読むため。 */
+export const dayShiftOf = (head: string, text: string, end: number, words: TimeWords): number =>
+  shiftOf(markBefore(head, words.dayShifts, DAY_SHIFT_GAP) ?? markSoonAfter(text, end, words.dayShifts, words.legs));
+
+/** 時間帯の印に続けて書いた時差（UTC+9、GMT-5:00）。時差まで含めて一つの時間帯と読む。 */
+const ZONE_OFFSET = /^[+\-−＋]\d{1,2}(?::?\d{2})?/u;
+
+/** 書かれた時間帯。text は時差まで含めた字面。 */
+export type Zone = { readonly text: string; readonly group?: string | undefined };
+
+type ZoneSpan = Zone & { readonly start: number; readonly end: number };
+
+const zoneSpansOf = (text: string, mark: Mark): ZoneSpan[] =>
+  wordOffsets(text, mark.pattern).map((start) => {
+    const after = start + mark.pattern.length;
+    const offset = ZONE_OFFSET.exec(text.slice(after))?.[0] ?? "";
+    return { start, end: after + offset.length, text: mark.pattern + offset, group: mark.group };
+  });
+
+/** text に書かれた時間帯の印（JST、UTC+9、現地時間）。同じ字面は一度だけ。長い語から照らし、短い語が長い語の中で重ねて読まれない。 */
+export const zonesIn = (text: string, words: TimeWords): Zone[] => {
+  const spans = longestFirst(words.zones).reduce<ZoneSpan[]>(
+    (taken, mark) => [...taken, ...zoneSpansOf(text, mark).filter((span) => !taken.some((other) => span.start < other.end && other.start < span.end))],
+    [],
+  );
+  return spans
+    .filter((span, index) => spans.findIndex((other) => other.text === span.text) === index)
+    .map(({ text: written, group }) => ({ text: written, group }));
+};
+
+/**
+ * 時間帯をまたぐ行か。違う時間帯の印が二つ以上あるか、「現地時間」のように時間帯がどこかを言わない印（組 local）があれば、
+ * 時刻をそのまま比べられない。
+ */
+export const crossesZones = (zones: readonly Zone[]): boolean => zones.length >= 2 || zones.some((mark) => mark.group === "local");

package/src/structure/time-order.ts

@@ -0,0 +1,140 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, type Line } from "./runs.ts";
+import { longestInOrder, outOfPlace } from "./date-order.ts";
+import { crossesZones, dayShiftOf, withoutDayShiftBefore, zonesIn, SECONDS_PER_DAY, type DateSpan, type TimeSpan, type TimeWords } from "./time-marks.ts";
+
+/**
+ * 一日の予定として並べた時刻の順番。箇条書きの続いた項目と表の続いた行のうち、頭に時刻を書いたもの（「- 09:00 集合」
+ * 「| 2月9日 09:30 | 受付 |」）を並びとして読む。一日の予定は早い順に並ぶので、向きは決めずに早い順と見る。
+ * 日付の見出しが変われば並びは切れる。行の頭に書いた日付が変わるところ（表の日付の列）、時間帯の印が変わるところでも切る。
+ * 23:30 の次の 0:15 は、翌日の印（翌、+1、next day）があれば翌日の時刻と読む。印が無くても、半日より大きく戻る時刻は
+ * 夜をまたいだものと読み、言わない。打ち間違いの多くは数時間の戻りで、半日を超えて戻る予定は夜通しの予定のほうが多い。
+ * 早い順に並ぶ時刻が半分以下の並びは、時刻で並べた一覧ではないとして何も言わない。
+ */
+
+/** 頭に時刻を書いた項目。seconds は 0 時からの秒、shift は翌日の印（1）か無印（0）。 */
+type Stop = {
+  readonly offset: number;
+  readonly written: string;
+  readonly seconds: number;
+  readonly shift: number;
+  readonly date: string | undefined;
+  readonly zone: string;
+  /** 「09:00–10:30」のように範囲で書いた時刻の終わり。範囲でなければ無い。 */
+  readonly until: number | undefined;
+};
+
+/** 並びとして言うのに要る時刻の数。二つでは、どちらが外れたかも、並べたものかどうかも決められない。 */
+const MIN_STOPS = 3;
+/** 印の無い戻りを夜をまたいだと読む幅。 */
+const HALF_DAY = SECONDS_PER_DAY / 2;
+/** 頭の日付と時刻の間に挟んでよい字（曜日「Monday,」「（火）」）。 */
+const LEAD_BESIDE_DATE = 12;
+
+const ITEM_OPENER = /^[ \t]*(?:(?:[-*+]|\d{1,3}[.)])[ \t]+|\|)?/u;
+const MARKS_ONLY = /^[\s\p{P}\p{S}]*$/u;
+const DIGIT = /[0-9０-９]/u;
+
+/** 頭に書いた日付を除いた残り。日付があれば短い曜日まで、無ければ記号と空白だけなら、時刻が項目の頭にある。 */
+const leadsWithTime = (lead: string, leadStart: number, dates: readonly DateSpan[]): boolean => {
+  if (lead.includes("|")) return false;
+  const inLead = dates.filter((date) => date.start >= leadStart && date.end <= leadStart + lead.length);
+  const rest = inLead.reduceRight((text, date) => text.slice(0, date.start - leadStart) + text.slice(date.end - leadStart), lead).trim();
+  if (inLead.length === 0) return MARKS_ONLY.test(rest);
+  return !DIGIT.test(rest) && rest.length <= LEAD_BESIDE_DATE;
+};
+
+const zoneKeyOf = (text: string, words: TimeWords): string | undefined => {
+  const zones = zonesIn(text, words);
+  if (zones.length >= 2) return undefined;
+  return crossesZones(zones) ? `local:${zones[0]?.text ?? ""}` : (zones[0]?.text ?? "");
+};
+
+type Inputs = { readonly source: string; readonly times: readonly TimeSpan[]; readonly dates: readonly DateSpan[]; readonly words: TimeWords };
+
+/** 時刻と時刻の間が範囲の印だけなら、後ろの時刻は範囲の終わり。 */
+const RANGE_GAP = /^\s?[-–—~〜～]\s?$/u;
+
+const rangeEndOf = (source: string, time: TimeSpan, times: readonly TimeSpan[]): number | undefined => {
+  const next = times.find((candidate) => candidate.start >= time.end);
+  return next !== undefined && RANGE_GAP.test(source.slice(time.end, next.start)) ? next.seconds : undefined;
+};
+
+/** 行の頭の時刻。頭に時刻が無い行、時間帯の印が二つある行、前日の印の付いた時刻は並びに入れない。 */
+const stopOf = (line: Line, inputs: Inputs): Stop | undefined => {
+  const { source, times, dates, words } = inputs;
+  const text = source.slice(line.start, line.end);
+  const time = times.find((candidate) => candidate.start >= line.start && candidate.end <= line.end);
+  const leadStart = line.start + (ITEM_OPENER.exec(text)?.[0].length ?? 0);
+  if (time === undefined || !leadsWithTime(withoutDayShiftBefore(source.slice(leadStart, time.start), words), leadStart, dates)) return undefined;
+  const zone = zoneKeyOf(text, words);
+  const shift = dayShiftOf(source.slice(line.start, time.start), source, time.end, words);
+  if (zone === undefined || shift < 0) return undefined;
+  const date = dates.filter((span) => span.start >= leadStart && span.end <= time.start).at(-1)?.value;
+  const until = rangeEndOf(source, time, times);
+  return { offset: time.start, written: source.slice(time.start, time.end), seconds: time.seconds, shift, date, zone, until };
+};
+
+/** 一日の並びを切る所: 頭の日付が前と違う、時間帯の印が前と違う。 */
+const startsNewDay = (stop: Stop, day: readonly Stop[]): boolean => {
+  const last = day.at(-1);
+  if (last === undefined) return false;
+  const lastDate = day.findLast((earlier) => earlier.date !== undefined)?.date;
+  return (stop.date !== undefined && lastDate !== undefined && stop.date !== lastDate) || stop.zone !== last.zone;
+};
+
+const daysOf = (stops: readonly Stop[]): Stop[][] =>
+  stops.reduce<Stop[][]>((days, stop) => {
+    const day = days.at(-1) ?? [];
+    return startsNewDay(stop, day) ? [...days, [stop]] : [...days.slice(0, -1), [...day, stop]];
+  }, []);
+
+/**
+ * 並びの中の、日をまたいだ秒。翌日の印のある時刻は翌日、印の無い時刻は前の時刻と同じ日。
+ * 前の時刻より半日を超えて戻る無印の時刻は、夜をまたいだ翌日の時刻。
+ */
+export const elapsedSeconds = (stops: readonly { readonly seconds: number; readonly shift: number }[]): number[] =>
+  stops
+    .reduce<{ day: number; seconds: number }[]>((placed, stop) => {
+      const previous = placed.at(-1);
+      const rolled = previous !== undefined && previous.seconds - stop.seconds > HALF_DAY ? previous.day + 1 : (previous?.day ?? 0);
+      return [...placed, { day: stop.shift > 0 ? Math.max(rolled, stop.shift) : rolled, seconds: stop.seconds }];
+    }, [])
+    .map((placed) => placed.day * SECONDS_PER_DAY + placed.seconds);
+
+/** 文字の並びで比べられるよう、秒を桁をそろえた文字にする。 */
+const PADDED = 8;
+const sortable = (seconds: number): string => String(seconds).padStart(PADDED, "0");
+
+/** 外れた時刻に、前の時刻を添える。先頭の時刻には前が無いので、次の時刻を添える。 */
+const issueAt = (day: readonly Stop[], at: number): StructureIssue[] => {
+  const stop = day[at];
+  if (stop === undefined) return [];
+  const neighbour = at === 0 ? { next: day[1]?.written ?? "" } : { previous: day[at - 1]?.written ?? "" };
+  return [{ offset: stop.offset, values: { time: stop.written, ...neighbour } }];
+};
+
+/**
+ * 範囲で書いた時刻の並びで、前の範囲が終わる前に次が始まる一歩が半分を超えるもの。曜日ごとの営業時間（9:00–18:00 が続く）
+ * のように時刻で並べたものではない一覧で、一日の予定ではない。
+ */
+export const isOverlappingRanges = (ranges: readonly { readonly seconds: number; readonly until: number | undefined }[]): boolean => {
+  const steps = ranges.slice(1).map((range, index) => ranges[index]?.until !== undefined && range.seconds < (ranges[index]?.until ?? 0));
+  return steps.length > 0 && steps.filter(Boolean).length * 2 > steps.length;
+};
+
+/** 早い順に逆らう一歩ごとに、並びから外れた時刻を指す。早い順に並ぶ時刻が半分以下の並びと、重なる範囲の並びは言わない。 */
+const breaksIn = (day: readonly Stop[]): StructureIssue[] => {
+  const values = elapsedSeconds(day).map(sortable);
+  if (values.length < MIN_STOPS || longestInOrder(values, 1) * 2 <= values.length || isOverlappingRanges(day)) return [];
+  return values.slice(1).flatMap((value, index) => (value < (values[index] ?? "") ? issueAt(day, outOfPlace(values, index + 1, 1)) : []));
+};
+
+/** 一日の予定の時刻のうち、早い順から外れたもの。 */
+export const timeOrderBreaks = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords): StructureIssue[] => {
+  const inputs = { source, times, dates, words };
+  return runsOf(source).flatMap((run) => {
+    const stops = run.flatMap((line) => stopOf(line, inputs) ?? []);
+    return daysOf(stops).flatMap(breaksIn);
+  });
+};

package/src/structure/title-lines.ts

@@ -0,0 +1,33 @@
+import type { MarkupHeading, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "./issues.ts";
+import { lineNumberAt, type Line } from "./lines.ts";
+
+// 題・見出しの行。見出しは節の中身に名前を付けるだけで、本文の文ではない。純関数: 木と行と Markdown の見出しを受け取る。
+
+/** 見出しの行に、見出しの言葉のほかにあってよい字（括弧と空白）。法令の「（解雇の予告）」。 */
+const CAPTION_MARKS = /[\s()（）［］[\]【】〔〕]/gu;
+
+/** 条の前の行が、その条の見出しだけの行か。 */
+const isCaptionLine = (line: Line | undefined, heading: string): boolean =>
+  line !== undefined && heading !== "" && line.text.replaceAll(CAPTION_MARKS, "") === heading.replaceAll(CAPTION_MARKS, "");
+
+const lineNumbersOfTree = (tree: StructureNode, lines: readonly Line[]): number[] =>
+  inDocumentOrder(tree).flatMap((node) => {
+    if (node.kind === "chapter" || node.kind === "section") return [node.line];
+    if (node.kind !== "article") return [];
+    const caption = node.line - 1;
+    return isCaptionLine(lines[caption - 1], String(node.attrs["heading"] ?? "")) ? [caption] : [];
+  });
+
+/**
+ * 題・見出しの行の番号（1 始まり）。Markdown の見出しの行、木の章・節の行、条の前に置いた見出しだけの行。
+ * 条の行の中の見出し（第一条（目的））は条の本文と同じ行なので入れない。
+ */
+export const titleLineNumbers = (tree: StructureNode | undefined, lines: readonly Line[], headings: readonly MarkupHeading[]): ReadonlySet<number> =>
+  new Set([
+    ...(tree === undefined ? [] : lineNumbersOfTree(tree, lines)),
+    ...headings.flatMap((heading) => {
+      const line = lineNumberAt(lines, heading.start);
+      return line === undefined ? [] : [line];
+    }),
+  ]);

package/src/structure/total.ts

@@ -142,6 +142,10 @@ const SIGN_REACH = 2;
 const signBefore = (source: string, total: Placed, start: number): string =>
   total.cents !== undefined && total.cents < 0 ? (SIGN_BEFORE.exec(source.slice(Math.max(0, start - SIGN_REACH), start))?.[0] ?? "") : "";
 
+/** 数の後ろに書いた単位。単位の組の名前（credit）と書いた語（credits）が違えば、書いた語を見せる。 */
+const unitAfterNumber = (written: string, unit: string): string =>
+  written.endsWith(unit) ? unit : written.slice(written.split("").findLastIndex((char) => char >= "0" && char <= "9") + 1);
+
 /** 合計の行に書いた金額と、上の和を、同じ書き方で見せる。負の和には、合計に書いた印（無ければ -）を付ける。 */
 const shownAmounts = (source: string, total: Placed, sumCents: number): Record<string, string> => {
   const unitStart = unitStartBefore(source, total);
@@ -151,7 +155,7 @@ const shownAmounts = (source: string, total: Placed, sumCents: number): Record<s
   const sumSign = sumCents < 0 ? sign || "-" : "";
   const sum = formatCents(Math.abs(sumCents), written);
   if (unitStart !== undefined) return { written, sum: `${sumSign}${source.slice(unitStart, total.offset)}${sum}` };
-  return { written, sum: `${sumSign}${sum}${written.endsWith(total.unit) ? total.unit : ""}` };
+  return { written, sum: `${sumSign}${sum}${unitAfterNumber(written, total.unit)}` };
 };
 
 /** 文の中の合計の金額（符号の無い、単位付きの金額）と和を、合計の書き方で見せる。 */

package/src/structure/version-mismatch.ts

@@ -1,5 +1,6 @@
 // A version written in the lead-in to a code block ("Install version 2.3.0 from npm:") that the block itself does not
 // show (npm install tidyq@2.4.0). Pure: reads the source, the code blocks, and the prose with code covered.
+import { escapeRegExp } from "../orthography.ts";
 import type { Span } from "../plugin.ts";
 import type { StructureIssue } from "./issues.ts";
 
@@ -85,19 +86,72 @@ const leadInOf = (source: string, blockStart: number): Span | undefined => {
   return text === "" || NOT_PROSE.test(text) || !LETTER.test(words) ? undefined : { start, end: lines.length };
 };
 
+/** A pin with the version it pins, of any number of parts: redis 7.4 in redis:7.4-alpine and in library/redis:7.4. */
+const PIN_VERSION = /^([\w.-]+)(?:@|==|=|:)[v^~]?(\d+(?:\.\d+)*)/u;
+const HAS_LETTER = /[A-Za-z]/u;
+
+/** Each name the block pins, with the one version it pins it to; a name pinned to two versions is left out. */
+const pinnedVersions = (code: string): Map<string, string> => {
+  const byName = new Map<string, Set<string>>();
+  codeWords(code).forEach((word) => {
+    const match = PIN_VERSION.exec(word.slice(word.lastIndexOf("/") + 1));
+    if (match?.[1] === undefined || match[2] === undefined || !HAS_LETTER.test(match[1])) return;
+    const name = match[1].toLowerCase();
+    byName.set(name, new Set([...(byName.get(name) ?? []), match[2]]));
+  });
+  const single = new Map<string, string>();
+  byName.forEach((versions, name) => {
+    const [only] = versions;
+    if (versions.size === 1 && only !== undefined) single.set(name, only);
+  });
+  return single;
+};
+
+/** 7 and 7.4, or 7.4 and 7.4.1: one names the other's series, so they agree. */
+const sameSeries = (written: string, pinned: string): boolean => {
+  const [shorter, longer] = [written.split("."), pinned.split(".")].toSorted((left, right) => left.length - right.length);
+  return (shorter ?? []).every((part, index) => part === longer?.[index]);
+};
+
 /**
- * Each version in a code block's lead-in that differs from the one version the block shows. A block with no version, or
- * with two (an upgrade from one to the other), says nothing to compare; a version marked as a bound, or named after another
- * program, is not the one installed.
+ * Each version written right after the name of a program the block pins ("We run Redis 7.2" over redis:7.4) that is not of
+ * the pinned version's series. The name says whose version it is, so a version of two parts is read here, where a bare 7.2
+ * is too often a decimal; one part (port 6379, Node 20) is too often another number.
  */
-export const versionMismatches = (source: string, prose: string, blocks: readonly CodeBlock[], words: VersionWords): StructureIssue[] =>
-  blocks.flatMap((block) => {
-    const shown = [...new Set(versionsIn(block.code).map((found) => found.version))];
-    const leadIn = leadInOf(source, block.start);
-    const [code] = shown;
-    if (shown.length !== 1 || code === undefined || leadIn === undefined) return [];
-    const names = pinnedNames(block.code);
-    return versionsIn(prose.slice(leadIn.start, leadIn.end), leadIn.start)
-      .filter((found) => found.version !== code && !isBound(prose, found, words.ranges) && isAboutBlock(prose, found, names, words.versionWords))
-      .map((found) => ({ offset: found.start, values: { written: found.version, code } }));
+const namedMismatches = (prose: string, leadIn: Span, code: string, ranges: readonly RangeWord[]): StructureIssue[] =>
+  [...pinnedVersions(code)].flatMap(([name, pinned]) => {
+    const pattern = new RegExp(`(?<![\\w.-])${escapeRegExp(name)}\\s+v?(\\d+(?:\\.\\d+){1,2})(?![\\w.]|\\.\\d)`, "giu");
+    return [...prose.slice(leadIn.start, leadIn.end).matchAll(pattern)].flatMap((match) => {
+      const written = match[1] ?? "";
+      const span = { start: leadIn.start + match.index, end: leadIn.start + match.index + match[0].length };
+      if (sameSeries(written, pinned) || isBound(prose, span, ranges)) return [];
+      return [{ offset: span.end - written.length, values: { written, code: pinned } }];
+    });
   });
+
+/**
+ * Each version in the lead-in that differs from the one version the block shows. A block with no version, or with two (an
+ * upgrade from one to the other), says nothing to compare; a version marked as a bound, or named after another program, is
+ * not the one installed.
+ */
+const shownMismatches = (prose: string, leadIn: Span, code: string, words: VersionWords): StructureIssue[] => {
+  const shown = [...new Set(versionsIn(code).map((found) => found.version))];
+  const [only] = shown;
+  if (shown.length !== 1 || only === undefined) return [];
+  const names = pinnedNames(code);
+  return versionsIn(prose.slice(leadIn.start, leadIn.end), leadIn.start)
+    .filter((found) => found.version !== only && !isBound(prose, found, words.ranges) && isAboutBlock(prose, found, names, words.versionWords))
+    .map((found) => ({ offset: found.start, values: { written: found.version, code: only } }));
+};
+
+/** Both readings of one block; a version both report is reported once, against the pin of the program it names. */
+const blockMismatches = (source: string, prose: string, block: CodeBlock, words: VersionWords): StructureIssue[] => {
+  const leadIn = leadInOf(source, block.start);
+  if (leadIn === undefined) return [];
+  const issues = [...namedMismatches(prose, leadIn, block.code, words.ranges), ...shownMismatches(prose, leadIn, block.code, words)];
+  return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+};
+
+/** Each version in a code block's lead-in that differs from the version the block installs. */
+export const versionMismatches = (source: string, prose: string, blocks: readonly CodeBlock[], words: VersionWords): StructureIssue[] =>
+  blocks.flatMap((block) => blockMismatches(source, prose, block, words));

package/src/structure/version-order.ts

@@ -0,0 +1,84 @@
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * Versions listed in order, a changelog's headings or a list of releases, with one out of place. The direction (newest or
+ * oldest first) is taken from most of the steps, and a version that fits in no longest run along it is pointed out.
+ */
+export type VersionPoint = { readonly offset: number; readonly label: string };
+
+type Version = { readonly parts: readonly number[]; readonly prerelease: string };
+
+/** A version at the start of a heading or an item: 3.2.0, v3.2.0, [3.2.0], 3.2.0-beta.1. */
+const VERSION_START = /^\[?v?(\d{1,4})\.(\d{1,4})\.(\d{1,4})(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?\]?(?![\w.])/u;
+
+/** The version a heading or an item starts with, as written; undefined when it does not start with one. */
+export const leadingVersion = (text: string): string | undefined => VERSION_START.exec(text.trim())?.[0];
+
+const parse = (label: string): Version | undefined => {
+  const match = VERSION_START.exec(label);
+  if (match === null) return undefined;
+  return { parts: [match[1], match[2], match[3]].map(Number), prerelease: match[4] ?? "" };
+};
+
+/** A prerelease (3.0.0-beta.1) comes before its release (3.0.0). */
+const comparePrerelease = (left: string, right: string): number => {
+  if (left === right) return 0;
+  if (left === "") return 1;
+  return right === "" ? -1 : Math.sign(left.localeCompare(right, "en", { numeric: true }));
+};
+
+const compareVersions = (left: Version, right: Version): number => {
+  const differing = left.parts.findIndex((part, index) => part !== right.parts[index]);
+  return differing === -1 ? comparePrerelease(left.prerelease, right.prerelease) : Math.sign((left.parts[differing] ?? 0) - (right.parts[differing] ?? 0));
+};
+
+/** The longest run along direction ending at each version (equal versions do not break it). */
+const longestEndingAt = (versions: readonly Version[], direction: number): number[] =>
+  versions.reduce<number[]>((lengths, version, index) => {
+    const along = versions.slice(0, index).map((earlier, at) => (compareVersions(version, earlier) === -direction ? 0 : (lengths[at] ?? 0)));
+    return [...lengths, 1 + Math.max(0, ...along)];
+  }, []);
+
+const majorityOf = (versions: readonly Version[]): number =>
+  Math.sign(versions.slice(1).reduce((sum, version, index) => sum + compareVersions(version, versions[index] ?? version), 0));
+
+/** The fewest versions an order is read from: with two, either one could be the one out of place. */
+const MIN_VERSIONS = 3;
+
+/**
+ * The versions that belong to no longest run along the majority direction. A run that holds no more than half of them is
+ * taken as sorted by something else, and nothing is said.
+ */
+export const versionOrderBreaks = (points: readonly VersionPoint[]): StructureIssue[] => {
+  const parsed = points.flatMap((point) => {
+    const version = parse(point.label);
+    return version === undefined ? [] : [{ point, version }];
+  });
+  const versions = parsed.map((entry) => entry.version);
+  const direction = majorityOf(versions);
+  if (versions.length < MIN_VERSIONS || direction === 0) return [];
+  const forward = longestEndingAt(versions, direction);
+  const backward = longestEndingAt(versions.toReversed(), -direction).toReversed();
+  const longest = Math.max(...forward);
+  if (longest * 2 <= versions.length) return [];
+  return parsed.flatMap((entry, index) =>
+    (forward[index] ?? 0) + (backward[index] ?? 0) - 1 === longest
+      ? []
+      : [{ offset: entry.point.offset, values: { version: entry.point.label, previous: parsed[index - 1]?.point.label ?? "" } }],
+  );
+};
+
+/** A version whose last part is zero (3.1.0) is no section number: the sections under 3.1 count from 3.1.1. */
+const endsInZero = (version: Version): boolean => version.parts.at(-1) === 0;
+
+/**
+ * Whether dotted labels (1.2.1, 1.2.2) are a version history rather than section numbers: all of them versions, and
+ * either one ends in zero or most steps go down (newest first). Section numbers only go up. version-order checks the
+ * histories and numbering-gap the rest, so a sequence is never reported by both.
+ */
+export const isVersionHistory = (labels: readonly string[]): boolean => {
+  const versions = labels.map(parse);
+  const parsed = versions.filter((version) => version !== undefined);
+  if (labels.length < 2 || parsed.length !== labels.length) return false;
+  return parsed.some(endsInZero) || majorityOf(parsed) < 0;
+};

package/src/table-text.ts

@@ -0,0 +1,39 @@
+// The prose with its Markdown tables read back in. The prose masks tables, but a quote or an invoice keeps most of its
+// amounts in one, and a rule comparing how amounts are written has to see them.
+import type { ProseDocument, Span } from "./plugin.ts";
+import { maskSpans } from "./mask.ts";
+import { opaqueSpans, readMarkdown, spansOfType } from "./markdown-read.ts";
+import { TABLE_RULE } from "./structure/runs.ts";
+
+const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
+
+/**
+ * The prose, with each table span as the source writes it, except what stays hidden inside it (code in a cell). Offsets
+ * are kept. Pure.
+ */
+export const proseWithTables = (prose: string, source: string, tables: readonly Span[], hidden: readonly Span[]): string => {
+  if (tables.length === 0) return prose;
+  const shown = maskSpans(source, hidden);
+  const pieces: string[] = [];
+  const end = tables
+    .toSorted((left, right) => left.start - right.start)
+    .reduce((from, table) => {
+      if (table.start < from) return from;
+      pieces.push(prose.slice(from, table.start), shown.slice(table.start, table.end));
+      return table.end;
+    }, 0);
+  pieces.push(prose.slice(end));
+  return pieces.join("");
+};
+
+const hasTableRule = (source: string): boolean => source.split("\n").some((line) => TABLE_RULE.test(line) && line.includes("-"));
+
+/** The document's prose with its tables, outside code and quoted replies. A document that is not Markdown keeps its prose. */
+export const proseAndTablesOf = (doc: ProseDocument): string => {
+  const prose = doc.prose ?? doc.source;
+  if (doc.prose === undefined || doc.markup?.markdown !== true || !hasTableRule(doc.source)) return prose;
+  const { root } = readMarkdown(doc.source);
+  const quoted = [...spansOfType(root, "blockquote"), ...(doc.replyQuotes ?? [])];
+  const tables = spansOfType(root, "table").filter((table) => !quoted.some((quote) => within(table, quote)));
+  return proseWithTables(doc.prose, doc.source, tables, opaqueSpans(root));
+};

package/src/ui-labels.ts

@@ -0,0 +1,55 @@
+// The same label on the screen written two ways in one manual (**Start Restore** and **Start restore**, ［復元を開始］ and
+// ［復元開始］). Pure: reads the labels a manual marks as labels, bold or in ［］, and points at the form written less often.
+
+import { escapeRegExp } from "./orthography.ts";
+
+export type Label = { readonly surface: string; readonly offset: number };
+export type LabelVariant = { readonly label: Label; readonly usual: string };
+
+/** What a manual marks as a label on the screen: bold (** or __), or the full-width brackets Japanese manuals use. */
+const MARKED = /\*\*([^*\n]{1,40})\*\*|__([^_\n]{1,40})__|［([^］\n]{1,40})］/gu;
+const SPACES = /\s+/gu;
+const LETTER = /\p{L}/u;
+
+/** Each label marked in the source whose text is prose (not covered as code in prose) and holds a letter. */
+export const labelsIn = (source: string, prose: string): Label[] =>
+  [...source.matchAll(MARKED)].flatMap((match) => {
+    const surface = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+    const inner = match.index + match[0].indexOf(surface);
+    const covered = prose.slice(inner, inner + surface.length) !== surface;
+    return covered || !LETTER.test(surface) ? [] : [{ surface, offset: inner }];
+  });
+
+/**
+ * Two forms of one label differ only in case, spaces, or a word a label is written with or without (the label-particle
+ * lexicon: 復元を開始 and 復元開始).
+ */
+const keyOf = (surface: string, particles: readonly string[]): string =>
+  particles.reduce((text, particle) => text.replace(joining(particle), ""), surface.replace(SPACES, "")).toLowerCase();
+
+/** A particle between two kanji or katakana (復元を開始), not one inside a word (その他). */
+const joining = (particle: string): RegExp =>
+  new RegExp(`(?<=[\\p{Script=Han}\\p{Script=Katakana}ー])${escapeRegExp(particle)}(?=[\\p{Script=Han}\\p{Script=Katakana}])`, "gu");
+
+/** Two forms that differ only in the case of their first letter (Note and note): emphasis at a sentence's start, not two labels. */
+const onlyFirstLetterDiffers = (forms: readonly string[]): boolean =>
+  new Set(forms.map((form) => `${form.charAt(0).toLowerCase()}${form.slice(1)}`)).size === 1;
+
+const groupBy = (labels: readonly Label[], keyFor: (label: Label) => string): Map<string, Label[]> =>
+  labels.reduce((groups, label) => groups.set(keyFor(label), [...(groups.get(keyFor(label)) ?? []), label]), new Map<string, Label[]>());
+
+/**
+ * Each label written in a form other than the one its key is written in most; on a tie, the later form. A label written
+ * one way only says nothing.
+ */
+export const labelVariants = (labels: readonly Label[], particles: readonly string[] = []): LabelVariant[] => {
+  const byKey = groupBy(labels, (label) => keyOf(label.surface, particles));
+  return [...byKey.values()].flatMap((group) => {
+    const counts = groupBy(group, (label) => label.surface);
+    if (counts.size < 2 || onlyFirstLetterDiffers([...counts.keys()])) return [];
+    const [first] = counts;
+    if (first === undefined) return [];
+    const usual = [...counts].reduce((best, entry) => (entry[1].length > best[1].length ? entry : best), first)[0];
+    return group.filter((label) => label.surface !== usual).map((label) => ({ label, usual }));
+  });
+};