chaffjs 0.28.0 → 0.29.0

package/src/structure/line-amount.ts

@@ -0,0 +1,162 @@
+import type { StructureIssue } from "./issues.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { CELL_SEPARATOR } from "./bare-numbers.ts";
+import { TABLE_RULE } from "./runs.ts";
+import { roundedMatches } from "./tax.ts";
+import { perUnitPrice, quantityUnit, unitsAgree, type UnitWord } from "./line-amount-unit.ts";
+
+/**
+ * 明細の表で、数量 × 単価が金額と合わない行。見出しの行から数量・単価・金額の列を語（quantity-column、unit-price-column、
+ * line-amount-column）で見つけ、本体の行ごとに数量の升の頭の数と単価の升の数を掛け、金額の升の数と比べる。
+ * 単価と金額は、数の前後に書いた印（$、円、万円）が同じときだけ比べる。端数は切り捨て・四捨五入・切り上げのどれでもよい。
+ * 単価が何かあたり（$100/hour、月額、Rate の列）なら、数量がその単位か単位の無い数のときだけ比べる。Pure.
+ */
+export type LineAmountWords = {
+  readonly quantity: readonly string[];
+  readonly unitPrice: readonly string[];
+  readonly amount: readonly string[];
+  /** Unit words of a quantity (rate-unit). */
+  readonly units: readonly UnitWord[];
+  /** Marks saying a price is per a unit (per-unit-mark). */
+  readonly perUnitMarks: readonly UnitWord[];
+  /** Column headings that say the unit of their column (Hours, Rate). */
+  readonly headerUnits: readonly UnitWord[];
+};
+
+type Cell = { readonly start: number; readonly text: string };
+
+/** A number with what is written before and after it in one cell: "$1,500.00" is $ 1500 "", "15万円" is "" 15 万円. */
+type CellNumber = {
+  readonly before: string;
+  readonly value: number;
+  readonly after: string;
+  readonly offset: number;
+  readonly written: string;
+  readonly grouped: boolean;
+  readonly decimals: number;
+};
+
+const CENTS = 100;
+const ONE_NUMBER = /^([^\d]*?)(\d{1,3}(?:,\d{3})+|\d+)(\.\d+)?([^\d]*)$/u;
+const LEADING_NUMBER = /^(\d{1,3}(?:,\d{3})+|\d+)(\.\d+)?(?![\d,])/u;
+const NEGATIVE = /[-−▲△(（]/u;
+
+const cellsOf = (line: Line): Cell[] => {
+  const bounds = [-1, ...[...line.text.matchAll(CELL_SEPARATOR)].map((match) => match.index), line.text.length];
+  const cells = bounds.slice(1).map((end, index) => {
+    const from = (bounds[index] ?? 0) + 1;
+    return { start: line.start + from, text: line.text.slice(from, end) };
+  });
+  const trimmed = line.text.trim();
+  return cells.slice(trimmed.startsWith("|") ? 1 : 0, trimmed.endsWith("|") ? cells.length - 1 : cells.length);
+};
+
+const plain = (text: string): string => text.normalize("NFKC").replace(/[*_`]/gu, "").trim();
+
+/** The one number of a price cell with its marks, undefined when the cell holds none, more, or a negative one. */
+export const cellNumber = (cell: Cell): CellNumber | undefined => {
+  const text = plain(cell.text);
+  const match = ONE_NUMBER.exec(text);
+  if (match === null) return undefined;
+  const [, before = "", whole = "", fraction = "", after = ""] = match;
+  if (NEGATIVE.test(before) || NEGATIVE.test(after)) return undefined;
+  return {
+    before: before.trim(),
+    value: Number(`${whole.replaceAll(",", "")}${fraction}`),
+    after: after.trim(),
+    offset: cell.start + (cell.text.length - cell.text.trimStart().length),
+    written: text,
+    grouped: whole.includes(","),
+    decimals: Math.max(0, fraction.length - 1),
+  };
+};
+
+/** The number a quantity cell starts with ("4", "3人日", "2.5 hours"), undefined when it does not, or holds another ("2 x 3"). */
+export const quantityOf = (cell: Cell): number | undefined => {
+  const text = plain(cell.text);
+  const match = LEADING_NUMBER.exec(text);
+  if (match === null || /\d/u.test(text.slice(match[0].length))) return undefined;
+  return Number(`${(match[1] ?? "").replaceAll(",", "")}${match[2] ?? ""}`);
+};
+
+/** What a quantity cell writes after its number ("days" in "2 days"). */
+const quantityWord = (cell: Cell): string => plain(cell.text).replace(LEADING_NUMBER, "").trim();
+
+const columnNamed = (header: readonly Cell[], names: readonly string[]): number => {
+  const wanted = names.map((name) => name.toLowerCase());
+  return header.findIndex((cell) => wanted.includes(plain(cell.text).toLowerCase()));
+};
+
+type Columns = { readonly quantity: number; readonly unitPrice: number; readonly amount: number };
+
+/** A table's columns, and the units its quantity and price headings say (undefined when they say none). */
+type Table = { readonly columns: Columns; readonly quantityUnit: string | undefined; readonly priceUnit: string | undefined };
+
+const headerUnit = (cell: Cell | undefined, words: LineAmountWords): string | undefined =>
+  cell === undefined ? undefined : words.headerUnits.find((word) => word.pattern.toLowerCase() === plain(cell.text).toLowerCase())?.unit;
+
+const tableOf = (header: readonly Cell[], words: LineAmountWords): Table | undefined => {
+  const columns = { quantity: columnNamed(header, words.quantity), unitPrice: columnNamed(header, words.unitPrice), amount: columnNamed(header, words.amount) };
+  if (Object.values(columns).some((index) => index < 0) || new Set(Object.values(columns)).size < 3) return undefined;
+  return { columns, quantityUnit: headerUnit(header[columns.quantity], words), priceUnit: headerUnit(header[columns.unitPrice], words) };
+};
+
+/** The unit the quantity cell counts: its own word, else its heading's ("Hours"). */
+const rowQuantityUnit = (cell: Cell, table: Table, words: LineAmountWords): string | undefined => {
+  const unit = quantityUnit(quantityWord(cell), words.units);
+  return unit === "" && table.quantityUnit !== undefined ? table.quantityUnit : unit;
+};
+
+/** quantity × price, written the way the amount cell writes its number (grouping, decimals, marks). */
+const shownExpected = (amount: CellNumber, exactCents: number): string => {
+  const exact = exactCents / CENTS;
+  const decimals = Number.isInteger(Math.round(exact * CENTS) / CENTS) && amount.decimals === 0 ? 0 : Math.max(amount.decimals, 2);
+  const number = exact.toLocaleString("en-US", { minimumFractionDigits: decimals, maximumFractionDigits: decimals, useGrouping: amount.grouped });
+  return `${amount.before}${number}${amount.after}`;
+};
+
+/** Another cell than the item name with a number in it (a discount, a tax rate): the amount may not be quantity × price alone. */
+const hasOtherNumber = (cells: readonly Cell[], columns: Columns): boolean =>
+  cells.some((cell, index) => index > 0 && !Object.values(columns).includes(index) && /\d/u.test(plain(cell.text)));
+
+const rowIssue = (row: Line, table: Table, words: LineAmountWords): StructureIssue[] => {
+  const { columns } = table;
+  const cells = cellsOf(row);
+  if (hasOtherNumber(cells, columns)) return [];
+  const quantityCell = cells[columns.quantity];
+  const priceCell = cells[columns.unitPrice];
+  const amountCell = cells[columns.amount];
+  if (quantityCell === undefined || priceCell === undefined || amountCell === undefined) return [];
+  const quantity = quantityOf(quantityCell);
+  const price = cellNumber(priceCell);
+  const amount = cellNumber(amountCell);
+  if (quantity === undefined || price === undefined || amount === undefined) return [];
+  const perUnit = perUnitPrice(price.before, price.after, words.perUnitMarks);
+  const marks = perUnit ?? price;
+  if (marks.before !== amount.before || marks.after !== amount.after) return [];
+  if (!unitsAgree(rowQuantityUnit(quantityCell, table, words), perUnit?.unit ?? table.priceUnit)) return [];
+  const exactCents = quantity * price.value * CENTS;
+  if (roundedMatches(Math.round(amount.value * CENTS), exactCents, amount.decimals === 0)) return [];
+  return [
+    {
+      offset: amount.offset,
+      values: { written: amount.written, quantity: plain(quantityCell.text), price: price.written, expected: shownExpected(amount, exactCents) },
+    },
+  ];
+};
+
+/** Each table: its header row and its body rows. */
+const tablesOf = (lines: readonly Line[]): { header: Line; rows: Line[] }[] =>
+  lines.flatMap((line, index) => {
+    const header = lines[index - 1];
+    if (!TABLE_RULE.test(line.text) || header === undefined || !header.text.includes("|")) return [];
+    const after = lines.slice(index + 1);
+    const end = after.findIndex((row) => !row.text.includes("|"));
+    return [{ header, rows: end === -1 ? after : after.slice(0, end) }];
+  });
+
+export const lineAmountMismatches = (source: string, words: LineAmountWords): StructureIssue[] =>
+  tablesOf(linesOf(source)).flatMap(({ header, rows }) => {
+    const table = tableOf(cellsOf(header), words);
+    return table === undefined ? [] : rows.flatMap((row) => rowIssue(row, table, words));
+  });

package/src/structure/number-word-figure.ts

@@ -0,0 +1,199 @@
+// number-word-figure-mismatch: the reading half. A number written in words and then in figures in brackets ("six (7)
+// months", 「金参拾万円（30,000円）」) is read on both sides; the words come from the lexicon number-word, the marks that may
+// stand around the figure from currency-notation and amount-multiplier.
+
+export type NumberWordKind = "digit" | "place" | "scale" | "joiner" | "lead" | "unit";
+
+export type NumberWord = { readonly word: string; readonly kind: NumberWordKind; readonly value: number };
+
+/** What the scan needs: the number words, the marks that may stand before or after the figure, and the words of scale. */
+export type NumberVocabulary = {
+  readonly words: readonly NumberWord[];
+  readonly marksBefore: readonly string[];
+  readonly marksAfter: readonly string[];
+  readonly multipliers: readonly { readonly word: string; readonly value: number }[];
+};
+
+export type WordFigureSlip = { readonly offset: number; readonly end: number; readonly written: string; readonly words: number; readonly figure: number };
+
+type Reading = {
+  readonly done: number;
+  readonly total: number;
+  readonly current: number;
+  readonly hasCurrent: boolean;
+  readonly lastPlace: number;
+  readonly lastScale: number;
+};
+
+const START: Reading = { done: 0, total: 0, current: 0, hasCurrent: false, lastPlace: Infinity, lastScale: Infinity };
+const TENS_MIN = 20;
+const TENS_MAX = 90;
+const TEN = 10;
+
+/** "twenty" then "one" is 21; any other digit after a digit ("five five", 二〇) is not one number. */
+const joinsDigit = (reading: Reading, value: number): boolean =>
+  !reading.hasCurrent || (reading.current >= TENS_MIN && reading.current <= TENS_MAX && reading.current % TEN === 0 && value > 0 && value < TEN);
+
+const stepWord = (reading: Reading | undefined, word: NumberWord): Reading | undefined => {
+  if (reading === undefined) return undefined;
+  if (word.kind === "digit") return joinsDigit(reading, word.value) ? { ...reading, current: reading.current + word.value, hasCurrent: true } : undefined;
+  if (word.kind === "place") {
+    if (word.value >= reading.lastPlace) return undefined;
+    return { ...reading, total: reading.total + (reading.hasCurrent ? reading.current : 1) * word.value, current: 0, hasCurrent: false, lastPlace: word.value };
+  }
+  const group = reading.total + reading.current;
+  if (word.kind !== "scale" || word.value >= reading.lastScale || (group === 0 && !reading.hasCurrent)) return undefined;
+  return { ...START, done: reading.done + group * word.value, lastScale: word.value };
+};
+
+const CLOSES_GROUP: ReadonlySet<NumberWordKind> = new Set(["place", "scale"]);
+
+/** Whether each joiner ("and") stands after a place or scale and before a digit: one hundred and five, not one and hundred. */
+const joinersInside = (words: readonly NumberWord[]): boolean =>
+  words.every((word, index) => word.kind !== "joiner" || (CLOSES_GROUP.has(words[index - 1]?.kind ?? "joiner") && words[index + 1]?.kind === "digit"));
+
+/**
+ * The value of a number written in words, read left to right: digits add, a place multiplies the digits before it (five
+ * hundred, 三千), a scale multiplies everything before it (fifty thousand, 参拾万). undefined when the words are not one
+ * well-formed number: empty, starting with a scale, a digit after a digit, places or scales out of order.
+ */
+export const numberOfWords = (words: readonly NumberWord[]): number | undefined => {
+  if (words.length === 0 || words[0]?.kind === "scale" || !joinersInside(words)) return undefined;
+  const reading = words.filter((word) => word.kind !== "joiner").reduce<Reading | undefined>(stepWord, START);
+  return reading === undefined ? undefined : reading.done + reading.total + reading.current;
+};
+
+const FULLWIDTH_ZERO = 0xff10;
+const halfWidth = (text: string): string =>
+  text
+    .replace(/[０-９]/gu, (char) => String(char.charCodeAt(0) - FULLWIDTH_ZERO))
+    .replace(/．/gu, ".")
+    .replace(/，/gu, ",");
+
+const FIGURE = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?/u;
+
+/** The longest of the words the text starts with, compared without regard to case. */
+const leadingWord = (text: string, words: readonly string[]): string =>
+  words
+    .filter((word) => word !== "" && text.toLowerCase().startsWith(word.toLowerCase()))
+    .reduce((longest, word) => (word.length > longest.length ? word : longest), "");
+
+/**
+ * The value of a figure in brackets: digits with separators, a currency mark before ($5,000) or after (300,000円), a word of
+ * scale ($5 million), a unit after (5%). undefined when the bracket holds anything else (Section 6, a name, a date).
+ */
+export const figureValue = (content: string, vocabulary: NumberVocabulary): number | undefined => {
+  const trimmed = halfWidth(content).trim();
+  const afterMark = trimmed.slice(leadingWord(trimmed, vocabulary.marksBefore).length).trimStart();
+  const figure = FIGURE.exec(afterMark)?.[0];
+  if (figure === undefined) return undefined;
+  const rest = afterMark.slice(figure.length).trimStart();
+  const multiplier = leadingWord(
+    rest,
+    vocabulary.multipliers.map((entry) => entry.word),
+  );
+  const tail = rest.slice(multiplier.length).trimStart();
+  if (tail.slice(leadingWord(tail, vocabulary.marksAfter).length).trim() !== "") return undefined;
+  const scale = vocabulary.multipliers.find((entry) => entry.word === multiplier)?.value ?? 1;
+  return Number(figure.replace(/,/gu, "")) * scale;
+};
+
+const BRACKET = /[(（]([^()（）\n]{1,40})[)）]/gu;
+const SEPARATOR = " \t-";
+const SPACE = " \t";
+/** How far back spaces are skipped, and how many words one number in words may have (one million two hundred and five is six). */
+const SKIP_REACH = 40;
+const MAX_RUN_WORDS = 16;
+const RUN_KINDS: ReadonlySet<NumberWordKind> = new Set(["digit", "place", "scale", "joiner"]);
+const SCRIPTS = [/\p{Script=Han}/u, /\p{Script=Latin}/u, /\p{Script=Hiragana}/u, /\p{Script=Katakana}/u, /\p{Script=Cyrillic}/u, /\p{Script=Greek}/u];
+
+/** Whether two letters are of one script: 統 before 一 makes one word (統一), は before 三 does not. */
+const sameScript = (a: string, b: string): boolean => SCRIPTS.some((script) => script.test(a) && script.test(b));
+
+/** The longest of the words the text ends with at `end`, compared without regard to case. */
+const endingWord = <T extends { readonly word: string }>(text: string, end: number, words: readonly T[]): T | undefined =>
+  words
+    .filter((entry) => entry.word !== "" && text.slice(Math.max(0, end - entry.word.length), end).toLowerCase() === entry.word.toLowerCase())
+    .reduce<T | undefined>((longest, entry) => (longest === undefined || entry.word.length > longest.word.length ? entry : longest), undefined);
+
+/** Where the run of `chars` (spaces, hyphens) that ends at `end` starts, looking back no further than SKIP_REACH. */
+const skipBack = (text: string, end: number, chars: string): number => {
+  const window = text.slice(Math.max(0, end - SKIP_REACH), end).split("");
+  const lastOther = window.findLastIndex((char) => !chars.includes(char));
+  return end - (window.length - (lastOther + 1));
+};
+
+type Placed = { readonly word: NumberWord; readonly start: number };
+
+/**
+ * The number words that end at `end`, read backwards: the first right at `end`, the others past spaces or hyphens. A run
+ * longer than any number in words is not one number, and gives none.
+ */
+const placedBefore = (text: string, end: number, words: readonly NumberWord[], found: readonly Placed[] = []): readonly Placed[] => {
+  const from = found.length === 0 ? end : skipBack(text, end, SEPARATOR);
+  const word = endingWord(text, from, words);
+  if (word === undefined) return found;
+  if (found.length >= MAX_RUN_WORDS) return [];
+  const start = from - word.word.length;
+  return placedBefore(text, start, words, [{ word, start }, ...found]);
+};
+
+/** The run of number words before `end`, without the joiners it starts with ("and one" is "one"). */
+const runBefore = (text: string, end: number, words: readonly NumberWord[]): readonly Placed[] => {
+  const placed = placedBefore(text, end, words);
+  const first = placed.findIndex((entry) => entry.word.kind !== "joiner");
+  return first < 0 ? [] : placed.slice(first);
+};
+
+/** Numerals written one character to a word and two or more in a row (契約期間十二) are a number even right after a word. */
+const isSolidNumeral = (run: readonly Placed[]): boolean => run.length > 1 && run[0]?.word.word.length === 1;
+
+/**
+ * Whether the run is a number of its own: the letter before it is of another script, it is a solid numeral, or a lead stands
+ * before it (金参, 年五). A single numeral after a word of its script is part of that word (統一, 唯一, often).
+ */
+const startsWord = (text: string, run: readonly Placed[], vocabulary: NumberVocabulary): boolean => {
+  const start = run[0]?.start ?? 0;
+  const before = text.charAt(start - 1);
+  const leads = vocabulary.words.filter((word) => word.kind === "lead");
+  return before === "" || !sameScript(before, text.charAt(start)) || isSolidNumeral(run) || endingWord(text, start, leads) !== undefined;
+};
+
+const YEAR = /^\s*[12]\d{3}\s*$/u;
+const YEAR_WORDS_BELOW = 1000;
+
+/** A bare four-digit figure after a small number in words is a year in brackets ("two (2026)"), not the same number again. */
+const isYear = (content: string, words: number): boolean => YEAR.test(halfWidth(content)) && words < YEAR_WORDS_BELOW;
+
+/** Where the words before a bracket end: past the spaces and one unit or currency word ("Dollars", 円, percent). */
+const wordsEnd = (text: string, bracket: number, vocabulary: NumberVocabulary): number => {
+  const spaced = skipBack(text, bracket, SPACE);
+  const unit = endingWord(
+    text,
+    spaced,
+    vocabulary.marksAfter.map((word) => ({ word })),
+  );
+  return unit === undefined ? spaced : skipBack(text, spaced - unit.word.length, SPACE);
+};
+
+const RELATIVE_TOLERANCE = 1e-9;
+const differ = (a: number, b: number): boolean => Math.abs(a - b) > RELATIVE_TOLERANCE * Math.max(1, Math.abs(a), Math.abs(b));
+
+const slipAt = (text: string, match: RegExpExecArray, vocabulary: NumberVocabulary, runWords: readonly NumberWord[]): WordFigureSlip | undefined => {
+  const content = match[1] ?? "";
+  const run = runBefore(text, wordsEnd(text, match.index, vocabulary), runWords);
+  const start = run[0]?.start;
+  if (start === undefined || !startsWord(text, run, vocabulary)) return undefined;
+  const words = numberOfWords(run.map((entry) => entry.word));
+  const figure = figureValue(content, vocabulary);
+  if (words === undefined || figure === undefined || !differ(words, figure) || isYear(content, words)) return undefined;
+  const end = match.index + match[0].length;
+  return { offset: start, end, written: text.slice(start, end), words, figure };
+};
+
+/** Every number written in words whose figure in brackets right after it says another number. */
+export const wordFigureSlips = (text: string, vocabulary: NumberVocabulary): WordFigureSlip[] => {
+  const runWords = vocabulary.words.filter((word) => RUN_KINDS.has(word.kind));
+  if (runWords.length === 0) return [];
+  return [...text.matchAll(BRACKET)].flatMap((match) => slipAt(text, match, vocabulary, runWords) ?? []);
+};

package/src/structure/numbering.ts

@@ -1,6 +1,7 @@
 import type { StructureNode } from "../plugin.ts";
 import { inDocumentOrder, type StructureIssue } from "./issues.ts";
 import { numbersQuotedInside } from "./quoted-number.ts";
+import { isVersionHistory } from "./version-order.ts";
 
 const labelOf = (node: StructureNode): string => String(node.attrs["label"] ?? node.address);
 
@@ -43,11 +44,13 @@ const breaksIn = (sequence: readonly Ordered[]): StructureIssue[] =>
  * 文書全体の通し番号として比べると抜けに見える。最初の番号は見ない。日本語の項は 2 から番号を振る。
  * 1 に戻った番号は新しい並びの始まりとして扱うので、「(a) の後の (a)」の重なりは見逃す。
  * 同じ番号の節を中に持つ節（ほかの文書の条を引いた手本の見出し）は、並びに入れない。
+ * 変更履歴の版の見出し（## 3.1.0）は番号の並びではない。版の順番は version-order が見る。
  */
 export const numberingBreaks = (tree: StructureNode): StructureIssue[] => {
   const quoting = numbersQuotedInside(tree);
   return inDocumentOrder(tree)
     .flatMap((parent) => sequencesOf(parent, quoting))
+    .filter((sequence) => !isVersionHistory(sequence.map((ordered) => labelOf(ordered.node))))
     .flatMap(breaksIn)
     .toSorted((left, right) => left.offset - right.offset);
 };

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];