chaffjs 0.27.1 → 0.29.0

package/src/structure/ordinal-runs.ts

@@ -0,0 +1,107 @@
+// The numbered runs a schedule writes as 第N回, 第N週, Week N or Session N (lexicon ordinal-frame), in the first cell of
+// table rows, at the start of list items or at the start of lines, and the places where such a run skips or repeats a
+// number. Pure: the frames come from the lexicon, the leads from the caller.
+import type { Lexicon } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/** One frame of the lexicon: the form with its number, and the form's opening followed by a figure. */
+export type OrdinalFrame = { readonly group: string; readonly written: RegExp; readonly opened: RegExp | undefined };
+
+/** A lead that carries a frame: its number (or the first and last of a joined 1-2) as written. */
+export type FramedNumber = { readonly group: string; readonly ordinal: number; readonly last: number; readonly label: string };
+
+/** A lead that opens a frame (第2, Week 3) without the form being readable (第2・第3回): it ends the group's run. */
+export type UnreadableFrame = { readonly group: string; readonly unreadable: true };
+
+/** Where a lead starts and what it reads as. */
+export type Lead = { readonly offset: number; readonly read: readonly (FramedNumber | UnreadableFrame)[] };
+
+const PLACEHOLDER = "{n}";
+const FIGURES = "[0-9０-９]{1,3}";
+const JOINER = "[ \\t]?[-–—~〜～・,、][ \\t]?";
+const FOLLOWER = "(?=$|[\\s\\u3000:：|（(.)）\\]\\-–—、,*_])";
+const SPACE = /[ \t\u3000]+/gu;
+const FULLWIDTH_ZERO = 0xff10;
+
+const escaped = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&").replace(SPACE, "[ \\t\\u3000]*");
+
+const frameOf = (pattern: string, group: string): OrdinalFrame | undefined => {
+  const at = pattern.indexOf(PLACEHOLDER);
+  if (at === -1) return undefined;
+  const opening = escaped(pattern.slice(0, at));
+  const closing = escaped(pattern.slice(at + PLACEHOLDER.length));
+  const written = new RegExp(`^${opening}(?<first>${FIGURES})(?:${JOINER}(?<last>${FIGURES}))?${closing}${FOLLOWER}`, "iu");
+  return { group, written, opened: opening === "" ? undefined : new RegExp(`^${opening}[0-9０-９]`, "iu") };
+};
+
+/** The lexicon's frames. An entry without {n} or without a group is not a frame. */
+export const ordinalFramesOf = (lexicon: Lexicon): OrdinalFrame[] =>
+  lexicon.flatMap((entry) => {
+    const frame = entry.group === undefined ? undefined : frameOf(entry.pattern, entry.group);
+    return frame === undefined ? [] : [frame];
+  });
+
+const figureValue = (figures: string): number =>
+  Number([...figures].map((char) => (char >= "０" && char <= "９" ? String(char.charCodeAt(0) - FULLWIDTH_ZERO) : char)).join(""));
+
+const readFrame = (lead: string, frame: OrdinalFrame): FramedNumber | UnreadableFrame | undefined => {
+  const found = frame.written.exec(lead);
+  if (found === null) return frame.opened?.test(lead) === true ? { group: frame.group, unreadable: true } : undefined;
+  const ordinal = figureValue(found.groups?.["first"] ?? "");
+  const last = found.groups?.["last"];
+  return { group: frame.group, ordinal, last: last === undefined ? ordinal : figureValue(last), label: found[0].trim() };
+};
+
+/** What the text at the start of a lead reads as, under each frame that matches it. */
+export const framesAt = (lead: string, frames: readonly OrdinalFrame[]): Lead["read"] => {
+  const read = frames.flatMap((frame) => readFrame(lead, frame) ?? []);
+  const groups = new Set(read.filter((each) => !("unreadable" in each)).map((each) => each.group));
+  return read.filter((each) => !("unreadable" in each) || !groups.has(each.group));
+};
+
+/** One number of a run, and where its lead starts. */
+export type RunNumber = FramedNumber & { readonly offset: number };
+
+/**
+ * The leads of one block (one table, one list, one section's lines), cut into runs per group. An unreadable lead ends its
+ * group's run, and a number 1 starts a new one (a second term counting again).
+ */
+export const ordinalRuns = (leads: readonly Lead[]): RunNumber[][] => {
+  const runs: RunNumber[][] = [];
+  const open = new Map<string, RunNumber[]>();
+  leads.forEach((lead) =>
+    lead.read.forEach((read) => {
+      if ("unreadable" in read) {
+        open.delete(read.group);
+        return;
+      }
+      const openRun = open.get(read.group) ?? [];
+      const run = read.ordinal === 1 && openRun.length > 0 ? [] : openRun;
+      if (run.length === 0) runs.push(run);
+      open.set(read.group, run);
+      run.push({ ...read, offset: lead.offset });
+    }),
+  );
+  return runs;
+};
+
+/** A run shorter than this is too short to tell a numbering from a mention. */
+const SHORTEST_RUN = 3;
+
+const followsOn = (current: FramedNumber, previous: FramedNumber): boolean => current.ordinal === previous.last + 1;
+
+/**
+ * Each number in the run that does not follow the one before it: a skip or a repeat. A run
+ * where fewer than half the steps follow on lists chosen numbers (weeks 2, 5, 9), not a sequence, and is not read; so
+ * is a run shorter than three, and a run writing one number throughout.
+ */
+export const ordinalRunBreaks = (run: readonly RunNumber[]): StructureIssue[] => {
+  if (run.length < SHORTEST_RUN || new Set(run.map((item) => item.ordinal)).size < 2) return [];
+  const steps = run.slice(1).map((item, index) => ({ item, previous: run[index] ?? item }));
+  const breaks = steps.filter(({ item, previous }) => !followsOn(item, previous));
+  if (breaks.length * 2 > steps.length) return [];
+  return breaks.map(({ item, previous }) => ({
+    offset: item.offset,
+    values: { previous: previous.label, label: item.label, expected: previous.last + 1, found: item.ordinal },
+  }));
+};

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

@@ -1,5 +1,6 @@
 // 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 { escapeRegExp } from "../orthography.ts";
 import type { Span } from "../plugin.ts";
 import type { StructureIssue } from "./issues.ts";
 import type { Amount } from "./total.ts";
@@ -35,20 +36,62 @@ const toleranceOf = (source: string, shares: readonly Amount[]): number =>
 
 const isBroken = (sum: number, tolerance: number): boolean => Math.abs(sum - WHOLE) > tolerance && Math.abs(sum - WHOLE) <= BAND;
 
+/** How far before a percentage the word for the rest may stand: 「その他が 」, "and other ". */
+const REST_REACH = 16;
+/** What may stand between the word for the rest and its percentage: a space, a colon, a particle, an opening parenthesis. */
+const REST_GAP = /^[\s:：、,がはで(（]*$/u;
+const LATIN_START = /^[A-Za-z]/u;
+const LETTER_BEFORE = /\p{L}$/u;
+const LETTER = /\p{L}/u;
+
+/** A word in a text; a Latin one as a whole word ("other", not "another"; "up", not "upkeep"). */
+const hasWord = (text: string, word: string): boolean => {
+  const lowered = text.toLowerCase();
+  const target = word.toLowerCase();
+  if (!LATIN_START.test(word)) return lowered.includes(target);
+  return [...lowered.matchAll(new RegExp(escapeRegExp(target), "gu"))].some(
+    (match) => !LETTER.test(lowered[match.index - 1] ?? "") && !LETTER.test(lowered[match.index + target.length] ?? ""),
+  );
+};
+
+/** How far from a percentage a word for which way it moved may stand: "grew 45%", 「8%増加」. */
+const CHANGE_REACH = 12;
+
+const movesNear = (source: string, sentence: Span, share: Amount, changes: readonly string[]): boolean => {
+  const near = source.slice(Math.max(sentence.start, share.offset - CHANGE_REACH), Math.min(sentence.end, share.end + CHANGE_REACH));
+  return changes.some((word) => hasWord(near, word));
+};
+
+/**
+ * The last share is the rest of the whole (その他が 5%, other 5%): only the parts of one whole have a rest, and it is listed
+ * last. Percentages next to a word for which way they moved (grew 45%, 8%増加) are changes, whose rest is no part of a whole.
+ */
+const namesRest = (source: string, sentence: Span, shares: readonly Amount[], words: ShareWords): boolean => {
+  const last = shares.at(-1);
+  if (last === undefined || shares.some((share) => movesNear(source, sentence, share, words.changes ?? []))) return false;
+  const before = source.slice(Math.max(sentence.start, last.offset - REST_REACH), last.offset).toLowerCase();
+  return (words.rests ?? []).some((word) => {
+    const at = before.lastIndexOf(word.toLowerCase());
+    if (at < 0 || !REST_GAP.test(before.slice(at + word.length))) return false;
+    return !(LATIN_START.test(word) && LETTER_BEFORE.test(before.slice(0, at)));
+  });
+};
+
 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 [];
+  if (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 [];
+  if (!includesAny(text, words.labels) && !namesRest(source, sentence, shares, words)) 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. */
+/** Each sentence that names a share word (or names one share as the rest) 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 [];
+  if (words.labels.length === 0 && (words.rests ?? []).length === 0) return [];
   const percents = amounts.filter((amount) => words.units.includes(amount.unit));
   return sentences.flatMap((sentence) => issueIn(source, sentence, percents, words));
 };

package/src/structure/percent-sum.ts

@@ -3,6 +3,7 @@ import { runsOf, TABLE_ROW, TABLE_RULE, type Line } from "./runs.ts";
 import { columnOf, isTotalLabel, type Amount } from "./total.ts";
 import { CELL_SEPARATOR } from "./bare-numbers.ts";
 import { joined, lineAbove, linesAbove } from "../text-above.ts";
+import { isShareColumn, mentionsAny } from "./share-column.ts";
 
 /**
  * 一つの全体を分けた割合（構成比、内訳、breakdown）の和が 100% にならない。箇条書きの続いた項目か、表の続いた行の百分率を足す。
@@ -11,8 +12,16 @@ import { joined, lineAbove, linesAbove } from "../text-above.ts";
  */
 export type ShareWords = {
   readonly labels: readonly string[];
+  /** 表の列の見出しの升がその語だけのとき、全体を分けた割合の列と読む語（割合、Weight）。 */
+  readonly columnLabels?: readonly string[];
+  /** 行ごとの率を名指す語（前年比、達成率、growth）。表の上の文にあれば、columnLabels の列は足さない。 */
+  readonly rates?: readonly string[];
   /** 足しても 100% にならない集計（複数回答）。 */
   readonly exceptions: readonly string[];
+  /** 全体の残りを名指す語（その他、other）。一つの文の百分率のすぐ前にあれば、その文は内訳。 */
+  readonly rests?: readonly string[];
+  /** 値の動いた向きの語（伸び、grew）。その文の百分率は変化で、「その他」があっても内訳ではない。 */
+  readonly changes?: readonly string[];
   readonly units: readonly string[];
   readonly totalLabels: readonly string[];
 };
@@ -97,12 +106,13 @@ const tolerance = (shares: readonly Share[]): number => Math.max(1, shares.lengt
 /** 和は、項目のいちばん細かい桁で、最初の項目の単位を付けて見せる。 */
 const shownSum = (shares: readonly Share[]): string => `${sumOf(shares).toFixed(decimalsOf(shares))}${shares[0]?.unit ?? ""}`;
 
-type Named = { readonly header: readonly string[]; readonly above: string };
+type Named = { readonly header: readonly string[]; readonly above: string; readonly rows: string };
 
 /** 列が全体を分けた割合と名指されているか。表は列の見出しか、百分率の列が一つだけの表の上の文。箇条書きは上の文。 */
 const namesShares = (named: Named, column: number, percentColumns: number, words: ShareWords): boolean => {
   const header = named.header[column] ?? "";
   if (named.header.length > 0 && includesAny(header, words.labels)) return true;
+  if (isShareColumn(header, words.columnLabels ?? []) && !mentionsAny(`${named.above} ${named.rows}`, words.rates ?? [])) return true;
   return (named.header.length === 0 || percentColumns === 1) && includesAny(named.above, words.labels);
 };
 
@@ -110,7 +120,11 @@ const namesShares = (named: Named, column: number, percentColumns: number, words
 const isBreakdown = (source: string, run: readonly Line[], totalLabels: readonly string[]): boolean =>
   run.length >= MIN_PARTS && !run.some((line) => isTotalLabel(source.slice(line.start, line.end), totalLabels));
 
-const namingOf = (source: string, run: readonly Line[], first: Line): Named => ({ header: headerCells(source, first), above: textAbove(source, run) });
+const namingOf = (source: string, run: readonly Line[], first: Line): Named => ({
+  header: headerCells(source, first),
+  above: textAbove(source, run),
+  rows: run.map((line) => source.slice(line.start, line.end)).join("\n"),
+});
 
 const mismatchesIn = (source: string, run: readonly Line[], percents: readonly Amount[], words: ShareWords): StructureIssue[] => {
   const first = run[0];

package/src/structure/release-list.ts

@@ -0,0 +1,69 @@
+// The releases a document lists: a run of version headings (## 3.2.0 - 2026-09-14), each with its section, or a run of
+// list items that start with a version (- 3.2.0 (2026-09-14): ...). Pure: reads the source, its headings and code fences.
+import type { Span } from "../plugin.ts";
+import type { Release } from "./install-pin.ts";
+import { runsOf, type Line } from "./runs.ts";
+import { isVersionHistory, leadingVersion } from "./version-order.ts";
+
+export type Heading = Span & { readonly depth: number; readonly text: string };
+
+const BARE = /\d[\w.-]*/u;
+
+/** The version as compared: 3.2.0 from [v3.2.0]. */
+const bareVersion = (label: string): string => BARE.exec(label)?.[0] ?? label;
+
+type Labelled = Release & { readonly label: string };
+
+/** Kept only when its versions read as a history (all versions, newest or oldest first), not as section numbers. */
+const asHistory = (run: readonly Labelled[]): Release[] =>
+  isVersionHistory(run.map((release) => release.label)) ? run.map(({ version, start, end }) => ({ version, start, end })) : [];
+
+/** A heading's section: up to the next heading of its depth or shallower. */
+const sectionEnd = (headings: readonly Heading[], index: number, length: number): number => {
+  const depth = headings[index]?.depth ?? 0;
+  return headings.slice(index + 1).find((later) => later.depth <= depth)?.start ?? length;
+};
+
+/**
+ * Version headings one after another at one depth. A deeper heading (### Added) stays inside the run; any other heading
+ * at its depth or shallower (## Install) ends it, so versioned headings spread over a manual are no release list.
+ */
+const headingReleases = (headings: readonly Heading[], length: number): Release[] => {
+  const runs: Labelled[][] = [];
+  const open: { depth: number; run: Labelled[] } = { depth: 0, run: [] };
+  headings.forEach((heading, index) => {
+    const label = leadingVersion(heading.text);
+    const continues = label !== undefined && heading.depth === open.depth;
+    if (!continues && (label !== undefined || heading.depth <= open.depth)) {
+      open.run = [];
+      open.depth = label === undefined ? 0 : heading.depth;
+      runs.push(open.run);
+    }
+    if (label !== undefined) open.run.push({ label, version: bareVersion(label), start: heading.start, end: sectionEnd(headings, index, length) });
+  });
+  return runs.flatMap(asHistory);
+};
+
+const ITEM_MARKER = /^[ \t]*(?:[-*+]|\d{1,3}[.)])[ \t]*/u;
+
+const itemReleases = (source: string, run: readonly Line[]): Release[] =>
+  asHistory(
+    run.flatMap((line) => {
+      const text = source.slice(line.start, line.end);
+      const marker = ITEM_MARKER.exec(text)?.[0];
+      const label = marker === undefined ? undefined : leadingVersion(text.slice(marker.length));
+      return label === undefined ? [] : [{ label, version: bareVersion(label), start: line.start, end: line.end }];
+    }),
+  );
+
+/** Every release the document lists, outside code fences (an example changelog in a block is not the document's). */
+export const releasesOf = (source: string, headings: readonly Heading[], fences: readonly Span[]): Release[] => {
+  const inFence = (line: Line): boolean => fences.some((fence) => line.start >= fence.start && line.start < fence.end);
+  const items = runsOf(source).flatMap((run) =>
+    itemReleases(
+      source,
+      run.filter((line) => line.kind === "list" && !inFence(line)),
+    ),
+  );
+  return [...headingReleases(headings, source.length), ...items].toSorted((left, right) => left.start - right.start);
+};

package/src/structure/share-column.ts

@@ -0,0 +1,25 @@
+/**
+ * 表の列の見出しが、それだけで全体を分けた割合の列と名指すか（割合、配点、Weight）。これらの語は文の中では行ごとの率にも使うので、
+ * 見出しの升がその語だけ（単位の括弧と % は除く）のときに限る。
+ */
+
+/** 見出しの升から外す飾り: 括弧に入れた単位（(%)、（％）、[%]）、% の記号、強調の印。単位でない括弧（（達成率））は残す。 */
+const DECORATION = /[(（［[](?:\s|[%％]|percent|pct)*[)）］\]]|[%％*_]/giu;
+const LATIN = /^\p{ASCII}+$/u;
+const WORD_BREAK = /[^\p{L}\p{N}]+/u;
+
+const bareCell = (cell: string): string => cell.replace(DECORATION, "").trim().toLowerCase();
+
+export const isShareColumn = (cell: string, columnLabels: readonly string[]): boolean => {
+  const bare = bareCell(cell);
+  return bare.length > 0 && columnLabels.some((label) => label.toLowerCase() === bare);
+};
+
+/** 英字の語は語の切れ目で探す（rate を separate に当てない）。日本語の語は文字列の中で探す。 */
+const mentions = (text: string, word: string): boolean => {
+  const lowered = word.toLowerCase();
+  if (!LATIN.test(lowered)) return text.includes(word);
+  return ` ${text.toLowerCase().split(WORD_BREAK).join(" ")} `.includes(` ${lowered} `);
+};
+
+export const mentionsAny = (text: string, words: readonly string[]): boolean => words.some((word) => mentions(text, word));

package/src/structure/stated-period.ts

@@ -0,0 +1,161 @@
+import { escapeRegExp } from "../orthography.ts";
+import { withoutTrailingWeekday } from "./date-range.ts";
+
+/**
+ * 文書が書いた期間（旅行期間：10月12日〜10月15日、Trip period: Oct 12–15）。期間の語（period-label）で始まる一行だけを読む。
+ * 日付は年月日（2026-10-12）か月日（10-12）。片方にだけ年があれば、もう片方にも同じ年を補う。
+ * 言語の知識（期間の語、範囲の記号、月の名、曜日の名）は語彙表から受け取る。
+ */
+export type DateMention = { readonly offset: number; readonly end: number; readonly value: string };
+
+export type PeriodWords = {
+  readonly labels: readonly string[];
+  /** 二つの日付の間に置いて期間を作る記号と語（〜、–、から、to）。 */
+  readonly connectors: readonly string[];
+  /** 月の名。頭の 12 個が 1 月から 12 月、略した名はその頭の字で月を決める。 */
+  readonly months: readonly string[];
+  readonly weekdays: readonly string[];
+};
+
+export type Period = { readonly start: string; readonly end: string; readonly written: string };
+
+/**
+ * 行の頭の印（見出し、箇条書き、引用）と、語を囲む太字や括弧の開き。表の行は読まない。
+ * 「| Conference | May 3–5 |」は催しを並べた表の一行で、文書の期間ではない。
+ */
+const LINE_MARKS = /^[ \t]*(?:(?:#{1,6}|[-*+>]|\d{1,3}[.)])[ \t]*)*/u;
+const LABEL_OPEN = /^(?:\*\*|__|【|\[)?/u;
+const LABEL_END = /^(?:\*\*|__|】|\])?(?:[ \t]*[:：][ \t]*|[ \t\u3000]+)/u;
+
+const leadOf = (line: string): number => {
+  const marks = LINE_MARKS.exec(line)?.[0].length ?? 0;
+  return marks + (LABEL_OPEN.exec(line.slice(marks))?.[0].length ?? 0);
+};
+
+/** 期間の語に続く、期間を書いた部分の行の中の位置。期間の語で始まらない行は undefined。 */
+export const afterLabel = (line: string, labels: readonly string[]): number | undefined => {
+  const lead = leadOf(line);
+  const rest = line.slice(lead);
+  const label = labels.find((word) => rest.toLowerCase().startsWith(word.toLowerCase()) && LABEL_END.test(rest.slice(word.length)));
+  if (label === undefined) return undefined;
+  return lead + label.length + (LABEL_END.exec(rest.slice(label.length))?.[0].length ?? 0);
+};
+
+/** 日付に添えた曜日（（水））と時刻（10:00）。期間のつなぎ目ではない。 */
+const ASIDES = /[（(][^（()）\n]{1,6}[）)]|\d{1,2}[:：]\d{2}/gu;
+
+const isJoint = (between: string, words: PeriodWords): boolean => {
+  const bare = between
+    .replace(ASIDES, "")
+    .replace(/^[\s,]+/u, "")
+    .trim()
+    .toLowerCase();
+  const joint = withoutTrailingWeekday(bare, words.weekdays).trim();
+  return words.connectors.some((connector) => connector.toLowerCase() === joint);
+};
+
+const connectorPattern = (words: PeriodWords): string =>
+  words.connectors
+    .toSorted((left, right) => right.length - left.length)
+    .map(escapeRegExp)
+    .join("|");
+
+const hasYear = (value: string): boolean => /^\d{4}-/u.test(value);
+const DAY_VALUE = /^(?:\d{4}-)?\d{2}-\d{2}$/u;
+
+const withDay = (value: string, day: string): string => `${value.slice(0, -2)}${day.padStart(2, "0")}`;
+
+const shiftYear = (value: string, by: number): string => `${String(Number(value.slice(0, 4)) + by)}${value.slice(4)}`;
+
+/** 年を片方にだけ書いた期間に、もう片方の年を補う（December 28 – January 4, 2027 は 2026 年の 12 月から）。 */
+const withYears = (start: string, end: string): string[] => {
+  if (hasYear(start) === hasYear(end)) return [start, end];
+  if (hasYear(start)) {
+    const filled = `${start.slice(0, 4)}-${end}`;
+    return [start, filled < start ? shiftYear(filled, 1) : filled];
+  }
+  const filled = `${end.slice(0, 4)}-${start}`;
+  return [filled > end ? shiftYear(filled, -1) : filled, end];
+};
+
+type Dates = Omit<Period, "written">;
+
+const periodOf = (start: string, end: string): Dates | undefined => {
+  if (!DAY_VALUE.test(start) || !DAY_VALUE.test(end)) return undefined;
+  const [from = start, to = end] = withYears(start, end);
+  return hasYear(from) && to < from ? undefined : { start: from, end: to };
+};
+
+/** 時刻の範囲の終わり（May 3, 3–5pm）。日の範囲ではない。 */
+const CLOCK = "\\s*[AaPp]\\.?[Mm]\\b";
+
+/** 一つ書いた日付の後ろに日だけを書いた終わり（10月12日〜15日、Oct 12–15）。 */
+const dayAfter = (text: string, date: DateMention, lineStart: number, words: PeriodWords): Dates | undefined => {
+  const tail = text.slice(date.end - lineStart).replace(ASIDES, "");
+  const found = new RegExp(`^\\s*(?:${connectorPattern(words)})\\s*(\\d{1,2})(?:st|nd|rd|th|日)?(?![\\d/:月.]|\\s*\\p{Lu}|${CLOCK})`, "u").exec(tail);
+  const day = found?.[1];
+  return day === undefined ? undefined : periodOf(date.value, withDay(date.value, day));
+};
+
+/** 一つ書いた日付の前に日だけを書いた始まり（3–5 May 2026）。前に月の名がある日（May 3–June 5）は、終わりの月の日ではない。 */
+const dayBefore = (text: string, date: DateMention, lineStart: number, words: PeriodWords): Dates | undefined => {
+  const head = text.slice(0, date.offset - lineStart);
+  const found = new RegExp(`(?<![\\d/.]|\\p{L}\\.?\\s)(\\d{1,2})\\s*(?:${connectorPattern(words)})\\s*$`, "u").exec(head);
+  const day = found?.[1];
+  return day === undefined ? undefined : periodOf(withDay(date.value, day), date.value);
+};
+
+const MONTHS_IN_YEAR = 12;
+const ABBREVIATION = 3;
+
+const monthNumber = (name: string, months: readonly string[]): number => {
+  const head = name.slice(0, ABBREVIATION).toLowerCase();
+  return months.slice(0, MONTHS_IN_YEAR).findIndex((month) => month.slice(0, ABBREVIATION).toLowerCase() === head) + 1;
+};
+
+const monthDay = (name: string, day: string, months: readonly string[]): string | undefined => {
+  const month = monthNumber(name, months);
+  return month === 0 ? undefined : `${String(month).padStart(2, "0")}-${day.padStart(2, "0")}`;
+};
+
+const DAY = "(\\d{1,2})(?:st|nd|rd|th)?";
+
+/**
+ * 日付として読まれなかった、月の名と日の範囲（May 3–5, 2026、Dec 28–Jan 4, 2027）。英語の日付は、年を終わりにだけ書くと始まりを日付にしない。
+ * 年は終わりの日付のもので、始まりには年をまたいで補う。
+ */
+const monthRange = (text: string, words: PeriodWords): Dates | undefined => {
+  const names = words.months.map(escapeRegExp).join("|");
+  if (names === "") return undefined;
+  const month = `(${names})\\.?\\s+`;
+  const pattern = `(?<!\\p{L})${month}${DAY}\\s*(?:${connectorPattern(words)})\\s*(?:${month})?${DAY}(?![\\d:]|${CLOCK})(?:,?\\s+(\\d{4}))?`;
+  const found = new RegExp(pattern, "u").exec(text);
+  if (found === null) return undefined;
+  const [, startMonth = "", first = "", endMonth, last = "", year] = found;
+  const start = monthDay(startMonth, first, words.months);
+  const end = monthDay(endMonth ?? startMonth, last, words.months);
+  if (start === undefined || end === undefined) return undefined;
+  return periodOf(start, year === undefined ? end : `${year}-${end}`);
+};
+
+const fromTwo = (text: string, lineStart: number, first: DateMention, second: DateMention, words: PeriodWords): Dates | undefined =>
+  isJoint(text.slice(first.end - lineStart, second.offset - lineStart), words) ? periodOf(first.value, second.value) : undefined;
+
+const datesOf = (line: string, lineStart: number, from: number, dates: readonly DateMention[], words: PeriodWords): Dates | undefined => {
+  const inside = dates.filter((date) => date.offset >= lineStart + from && date.end <= lineStart + line.length);
+  const [first, second] = inside;
+  if (first !== undefined && second !== undefined) return fromTwo(line, lineStart, first, second, words);
+  if (first !== undefined) return dayAfter(line, first, lineStart, words) ?? dayBefore(line, first, lineStart, words) ?? monthRange(line.slice(from), words);
+  return monthRange(line.slice(from), words);
+};
+
+/**
+ * 期間の語で始まる一行の期間。行の中の日付が二つで間が範囲の記号なら、その二つ。一つなら、その前か後ろに日だけを書いた片方を読む。
+ * 日付の無い行は、月の名と日の範囲を読む。読めなければ undefined。
+ */
+export const statedPeriod = (line: string, lineStart: number, dates: readonly DateMention[], words: PeriodWords): Period | undefined => {
+  const from = afterLabel(line, words.labels);
+  if (from === undefined) return undefined;
+  const found = datesOf(line, lineStart, from, dates, words);
+  return found === undefined ? undefined : { ...found, written: line.slice(from).trim() };
+};

package/src/structure/subject-change.ts

@@ -0,0 +1,35 @@
+import type { Token } from "../plugin.ts";
+
+// Whether a joining word ("and") starts a clause about another subject: "Revenue was $1,000 in 2025 and costs were $1,500
+// in 2026" joins two subjects, "… in 2025 and $1,500 in 2026" or "… and revenue was $1,500" one. Two words for one thing
+// ("sales" and "revenue") read as two subjects, so the pair is left alone rather than read wrongly. Pure: reads the tagger's
+// parts of speech and lemmas.
+
+const NOUN: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
+/** Words that may stand before the noun that starts the clause ("and the costs", "and our operating costs"). */
+const BEFORE_NOUN: ReadonlySet<string> = new Set(["DET", "ADJ", "PRON"]);
+
+const wordOf = (token: Token): string => (token.lemma ?? token.surface).toLowerCase();
+
+/** The last noun of the run of nouns at the start of tokens, past determiners and adjectives ("the operating costs" → cost). */
+const leadingNoun = (tokens: readonly Token[]): Token | undefined => {
+  const start = tokens.findIndex((token) => !BEFORE_NOUN.has(token.pos));
+  if (start < 0) return undefined;
+  const end = tokens.slice(start).findIndex((token) => !NOUN.has(token.pos));
+  const nouns = tokens.slice(start, end < 0 ? tokens.length : start + end);
+  return nouns.at(-1);
+};
+
+/**
+ * The joining word at index is followed by a noun the sentence has not used before it: "and costs were", "and costs $1,500"
+ * after "Revenue was $1,000", where "and revenue was" after "ACME's revenue was $1,000" names the same thing again. A
+ * sentence with no noun before the joining word gives nothing to compare with.
+ */
+export const startsOtherSubject = (tokens: readonly Token[], index: number): boolean => {
+  const next = leadingNoun(tokens.slice(index + 1));
+  const before = tokens
+    .slice(0, index)
+    .filter((token) => NOUN.has(token.pos))
+    .map(wordOf);
+  return next !== undefined && before.length > 0 && !before.includes(wordOf(next));
+};

package/src/structure/tax.ts

@@ -0,0 +1,114 @@
+import type { StructureIssue } from "./issues.ts";
+import { runsOf, type Line } from "./runs.ts";
+import { columnOf, isTotalLabel, shownTotal, type Amount } from "./total.ts";
+
+/**
+ * 税の行と、その上の金額に率を掛けた額。表か箇条書きの並びで、税の語（消費税・Sales tax）で始まり率（10%）を書いた行の
+ * 金額を、上の最後の合計の行（小計）の金額に率を掛けた額と比べる。合計の行が無ければ、上の項目の和に掛ける。
+ * 端数は切り捨て・四捨五入・切り上げのどれでもよく、円の位でも銭（セント）の位でもよい。
+ * 内税（「うち消費税」）の行と、率の違う税の行が並ぶ並び（軽減税率）は読まない。Pure.
+ */
+export type TaxWords = {
+  /** 税の行の頭の語（消費税、Sales tax）。 */
+  readonly labels: readonly string[];
+  /** 合計の行の頭の語（小計、Subtotal）。 */
+  readonly totals: readonly string[];
+  /** 税の行が内税だと分かる語（うち、included）。 */
+  readonly included: readonly string[];
+};
+
+const RATE = /(\d{1,2}(?:\.\d{1,2})?)[ \t]?[%％]/u;
+const PERCENT = new Set(["%", "％"]);
+/** A sign or an opening bracket right before an amount (-$200, ▲500, (1,200)): the amount may be negative. */
+const SIGNED = /[-−▲△(（][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
+const CENTS = 100;
+const MAX_RATE = 100;
+
+type Row = { readonly line: Line; readonly text: string; readonly amounts: readonly Amount[] };
+
+const rowsOf = (source: string, run: readonly Line[], amounts: readonly Amount[]): Row[] =>
+  run.map((line) => ({
+    line,
+    text: source.slice(line.start, line.end),
+    amounts: amounts.filter((amount) => amount.offset >= line.start && amount.offset <= line.end && !PERCENT.has(amount.unit)),
+  }));
+
+const rateOf = (text: string): number | undefined => {
+  const rate = Number(RATE.exec(text)?.[1]);
+  return Number.isFinite(rate) && rate > 0 && rate < MAX_RATE ? rate : undefined;
+};
+
+const isTaxRow = (row: Row, words: TaxWords): boolean =>
+  isTotalLabel(row.text, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
+
+/** The list marker at the start of a line (- $500) is not a sign. */
+const isSigned = (source: string, row: Row, amount: Amount): boolean => {
+  const before = source.slice(row.line.start, amount.offset);
+  const sign = SIGNED.exec(before);
+  return sign !== null && before.slice(0, sign.index).trim().length > 0;
+};
+
+/**
+ * The one amount of the row in the column and unit of the tax amount, undefined when there is none, more than one, or
+ * one that may be negative (a discount is not added as written).
+ */
+const amountAt = (source: string, row: Row, column: number, unit: string): Amount | undefined => {
+  const matching = row.amounts.filter((amount) => amount.unit === unit && columnOf(source, row.line, amount.offset) === column);
+  const [only] = matching;
+  return matching.length === 1 && only !== undefined && !isSigned(source, row, only) ? only : undefined;
+};
+
+/**
+ * The base the tax is on: the last total row above, or the sum of the item rows above when there is no total row. A row
+ * with an amount between the total and the tax (a discount, shipping) may or may not be taxed, so there is no base.
+ */
+const baseOf = (source: string, above: readonly Row[], tax: Amount, column: number, words: TaxWords): Amount | undefined => {
+  const lastTotalIndex = above.findLastIndex((row) => isTotalLabel(row.text, words.totals));
+  const lastTotal = above[lastTotalIndex];
+  if (lastTotal !== undefined) {
+    const between = above.slice(lastTotalIndex + 1);
+    return between.some((row) => row.amounts.length > 0) ? undefined : amountAt(source, lastTotal, column, tax.unit);
+  }
+  const items = above.map((row) => amountAt(source, row, column, tax.unit));
+  if (items.length === 0 || items.some((item) => item === undefined)) return undefined;
+  const values = items.flatMap((item) => (item === undefined ? [] : [item.value]));
+  return { offset: tax.offset, end: tax.end, unit: tax.unit, value: values.reduce((sum, value) => sum + value, 0) };
+};
+
+/**
+ * Whether a written amount is an exact one rounded down, to nearest or up, to the cent or (when toUnit) to the unit. Both
+ * in cents. An amount written with cents ($59.00) is rounded to the cent only.
+ */
+export const roundedMatches = (writtenCents: number, exactCents: number, toUnits = true): boolean => {
+  const toCent = [Math.floor(exactCents), Math.round(exactCents), Math.ceil(exactCents)];
+  const toUnit = toUnits ? [Math.floor, Math.round, Math.ceil].map((round) => round(exactCents / CENTS) * CENTS) : [];
+  return [...toCent, ...toUnit].some((candidate) => Math.abs(candidate - writtenCents) < 1);
+};
+
+/** Whether the written tax is base × rate, rounded down, to nearest or up, to the unit or to the cent. */
+// base × rate% in cents: base × 100 × rate / 100.
+export const taxMatches = (writtenCents: number, base: number, rate: number): boolean => roundedMatches(writtenCents, base * rate);
+
+const issueOf = (source: string, rows: readonly Row[], index: number, rate: number, words: TaxWords): StructureIssue[] => {
+  const row = rows[index];
+  const tax = row?.amounts.length === 1 ? row.amounts[0] : undefined;
+  if (row === undefined || tax === undefined || isSigned(source, row, tax)) return [];
+  const column = columnOf(source, row.line, tax.offset);
+  const base = baseOf(source, rows.slice(0, index), tax, column, words);
+  if (base === undefined || taxMatches(Math.round(tax.value * CENTS), base.value, rate)) return [];
+  const expectedCents = Math.round(base.value * rate);
+  const shown = shownTotal(source, tax, expectedCents);
+  return [{ offset: tax.offset, values: { written: shown.written ?? "", expected: shown.sum ?? "", rate: `${String(rate)}%` } }];
+};
+
+const runIssues = (source: string, rows: readonly Row[], words: TaxWords): StructureIssue[] => {
+  const taxRows = rows.flatMap((row, index) => {
+    const rate = isTaxRow(row, words) ? rateOf(row.text) : undefined;
+    return rate === undefined ? [] : [{ index, rate }];
+  });
+  if (new Set(taxRows.map((row) => row.rate)).size > 1) return [];
+  return taxRows.flatMap(({ index, rate }) => issueOf(source, rows, index, rate, words));
+};
+
+export const taxMismatches = (source: string, amounts: readonly Amount[], words: TaxWords): StructureIssue[] =>
+  words.labels.length === 0 ? [] : runsOf(source).flatMap((run) => runIssues(source, rowsOf(source, run, amounts), words));