chaffjs 0.27.1 → 0.29.0

package/src/structure/leg-times.ts

@@ -0,0 +1,198 @@
+import type { StructureIssue } from "./issues.ts";
+import { TABLE_RULE } from "./runs.ts";
+import {
+  crossesZones,
+  dayShiftOf,
+  markBefore,
+  markRightAfter,
+  wordOffsets,
+  zonesIn,
+  SECONDS_PER_DAY,
+  type DateSpan,
+  type Mark,
+  type TimeSpan,
+  type TimeWords,
+} from "./time-marks.ts";
+
+/**
+ * 一つの行（箇条書きの項目、表の行、文の一行）に書いた発と着の時刻。着が発より前なら、どちらかの書き間違い。
+ * 発・着は、時刻のすぐ後ろの印（「08:00発」）か、時刻の少し前の印（「departs Boston 7:30 AM」「dep 10:30」）、
+ * または表の列の見出し（出発、到着、Departs、Arrives。語彙表 leg-column）で読む。
+ * 着に翌日の印（翌、+1、next day）があれば一日足す。発と着の両方に日付があれば日付で比べ、片方だけなら比べない。
+ * 違う時間帯の印が二つある行と、「現地時間」のようにどこの時刻かを言わない印のある行は、時刻をそのまま比べられないので言わない。
+ */
+
+/** 発か着の時刻。date はその時刻の前に書いた日付、shift は翌日（1）か前日（-1）の印、zone は時刻の後ろに書いた時間帯（無ければ空）。 */
+type LegTime = {
+  readonly offset: number;
+  readonly end: number;
+  readonly written: string;
+  readonly seconds: number;
+  readonly shift: number;
+  readonly date: string | undefined;
+  readonly zone: string;
+};
+
+type Leg = LegTime & { readonly side: string };
+
+const DEPARTURE = "departure";
+const ARRIVAL = "arrival";
+
+/** 「departs Washington Reagan 1:30 PM」のように、発着の語と時刻の間に挟んでよい字の数（地名）。 */
+const LEG_WORD_GAP = 32;
+/** 発着の語と時刻の間に来れば、その語は時刻にかからない（文や句の切れ目）。 */
+const BREAK = /[。．;；!?！？]|\.\s/u;
+
+type Inputs = { readonly source: string; readonly times: readonly TimeSpan[]; readonly dates: readonly DateSpan[]; readonly words: TimeWords };
+
+const timesWithin = (times: readonly TimeSpan[], start: number, end: number): TimeSpan[] => times.filter((time) => time.start >= start && time.end <= end);
+
+/** 時刻の日付と読む、時刻の前に書いた日付までの字の数（「Feb 8, 1:00 PM」「2月8日 13:00」）。 */
+const DATE_WINDOW = 4;
+
+/** 時刻の後ろで、その時刻の時間帯の印（17:00 JST）を探す字の数。 */
+const ZONE_WINDOW = 12;
+
+/** 時刻を、from から to までの原文（前の時刻の後ろから次の時刻の前まで、表なら升）の中で読む。 */
+const legTimeOf = (time: TimeSpan, from: number, to: number, inputs: Inputs): LegTime => {
+  const head = inputs.source.slice(from, time.start);
+  const date = inputs.dates.filter((span) => span.start >= from && span.end <= time.start && time.start - span.end <= DATE_WINDOW).at(-1)?.value;
+  const shift = dayShiftOf(head, inputs.source, time.end, inputs.words);
+  const zone = zonesIn(inputs.source.slice(time.end, Math.min(to, time.end + ZONE_WINDOW)), inputs.words)[0]?.text ?? "";
+  return { offset: time.start, end: time.end, written: inputs.source.slice(time.start, time.end), seconds: time.seconds, shift, date, zone };
+};
+
+/** 時刻の前の語（departs、dep）。間に句の切れ目があれば、その語はこの時刻のものではない。 */
+const sideBefore = (head: string, legs: readonly Mark[]): string | undefined => {
+  const mark = markBefore(head, legs, LEG_WORD_GAP);
+  if (mark === undefined) return undefined;
+  const at = Math.max(...wordOffsets(head, mark.pattern));
+  return BREAK.test(head.slice(at + mark.pattern.length)) ? undefined : mark.group;
+};
+
+/** 一行の中の発着の時刻を、書いた順に。前の時刻から後ろだけを、その時刻の前置きとして読む。 */
+const legsInLine = (start: number, end: number, inputs: Inputs): Leg[] =>
+  timesWithin(inputs.times, start, end).flatMap((time, index, all) => {
+    const from = all[index - 1]?.end ?? start;
+    const to = all[index + 1]?.start ?? end;
+    const side = markRightAfter(inputs.source, time.end, inputs.words.legs)?.group ?? sideBefore(inputs.source.slice(from, time.start), inputs.words.legs);
+    return side === DEPARTURE || side === ARRIVAL ? [{ ...legTimeOf(time, from, to, inputs), side }] : [];
+  });
+
+/** 発のあとに来た最初の着を、その発の組にする。間に文の切れ目があれば、着は別の文のもので組にしない。 */
+const pairsOf = (source: string, legs: readonly Leg[]): [LegTime, LegTime][] =>
+  legs.reduce<{ pending: LegTime | undefined; pairs: [LegTime, LegTime][] }>(
+    (found, leg) => {
+      if (leg.side === DEPARTURE) return { ...found, pending: leg };
+      if (found.pending === undefined || BREAK.test(source.slice(found.pending.end, leg.offset))) return { ...found, pending: undefined };
+      return { pending: undefined, pairs: [...found.pairs, [found.pending, leg]] };
+    },
+    { pending: undefined, pairs: [] },
+  ).pairs;
+
+/** 年月日、年月、月日は、同じ書き方どうしでしか比べない。 */
+const sameShape = (left: string, right: string): boolean => left.length === right.length;
+
+/**
+ * 着が発より前か。両方に日付があれば日付で、日付が同じなら時刻で比べる。片方だけに日付があれば、もう片方の日が分からない。
+ * 時間帯の印が発と着で違えば（片方だけに書いたときも）、時刻をそのまま比べられない。
+ */
+export const arrivesFirst = (departure: LegTime, arrival: LegTime): boolean => {
+  if ((departure.date === undefined) !== (arrival.date === undefined) || departure.zone !== arrival.zone) return false;
+  if (departure.date !== undefined && arrival.date !== undefined) {
+    if (!sameShape(departure.date, arrival.date)) return false;
+    if (departure.date !== arrival.date) return arrival.date < departure.date;
+  }
+  return arrival.shift * SECONDS_PER_DAY + arrival.seconds < departure.shift * SECONDS_PER_DAY + departure.seconds;
+};
+
+const issueOf = ([departure, arrival]: [LegTime, LegTime]): StructureIssue => ({
+  offset: arrival.offset,
+  values: { arrival: arrival.written, departure: departure.written },
+});
+
+const linesOf = (source: string): { start: number; end: number }[] =>
+  source.split("\n").reduce<{ start: number; end: number }[]>((lines, text) => {
+    const start = (lines.at(-1)?.end ?? -1) + 1;
+    return [...lines, { start, end: start + text.length }];
+  }, []);
+
+/** 行の中で発と着の印から読む組。 */
+const inlinePairs = (inputs: Inputs, zonesOf: (start: number, end: number) => boolean): [LegTime, LegTime][] =>
+  linesOf(inputs.source).flatMap((line) => (zonesOf(line.start, line.end) ? [] : pairsOf(inputs.source, legsInLine(line.start, line.end, inputs))));
+
+type Cell = { readonly start: number; readonly end: number };
+
+/** 表の一行を、| で区切った升に分ける。先頭と末尾の | の外は升ではない。 */
+export const cellsOf = (source: string, start: number, end: number): Cell[] => {
+  const text = source.slice(start, end);
+  const bars = [...text.matchAll(/(?<!\\)\|/gu)].map((match) => start + match.index);
+  const edges = [text.trimStart().startsWith("|") ? undefined : start - 1, ...bars, text.trimEnd().endsWith("|") ? undefined : end].filter(
+    (edge) => edge !== undefined,
+  );
+  return edges.slice(1).map((edge, index) => ({ start: (edges[index] ?? start) + 1, end: edge }));
+};
+
+/** 見出しの升の後ろの括弧書き（「出発（現地時間）」「Departs (JST)」）。列の名前はその前まで。 */
+const NOTE_OPENER = /[(（[［]/u;
+
+const columnName = (heading: string): string => {
+  const note = heading.search(NOTE_OPENER);
+  return (note === -1 ? heading : heading.slice(0, note)).trim();
+};
+
+/** 見出しの升の名前が、発着の列の名前（語彙表 leg-column）と同じ最初の列。 */
+const columnOf = (source: string, header: readonly Cell[], columns: readonly Mark[], side: string): number =>
+  header.findIndex((cell) => {
+    const name = columnName(source.slice(cell.start, cell.end));
+    return columns.some((mark) => mark.group === side && mark.pattern === name);
+  });
+
+/** 升の中の最初の時刻を、発か着として読む。 */
+const cellTime = (cell: Cell | undefined, inputs: Inputs): LegTime | undefined => {
+  if (cell === undefined) return undefined;
+  const time = timesWithin(inputs.times, cell.start, cell.end)[0];
+  return time === undefined ? undefined : legTimeOf(time, cell.start, cell.end, inputs);
+};
+
+type Table = { readonly header: Cell[]; readonly rows: { start: number; end: number }[] };
+
+/** 見出しの行、区切りの行、| のある行が続くあいだを一つの表にする。 */
+const tablesOf = (source: string): Table[] => {
+  const lines = linesOf(source);
+  return lines.flatMap((line, index) => {
+    const header = lines[index - 1];
+    if (header === undefined || !TABLE_RULE.test(source.slice(line.start, line.end))) return [];
+    const after = lines.slice(index + 1);
+    const stop = after.findIndex((row) => !source.slice(row.start, row.end).includes("|"));
+    return [{ header: cellsOf(source, header.start, header.end), rows: stop === -1 ? after : after.slice(0, stop) }];
+  });
+};
+
+/** 発の列と着の列を見出しから読む表の組。見出しに時間帯の印があれば、行と合わせて時間帯を見る。 */
+const columnPairs = (inputs: Inputs, zonesOf: (start: number, end: number) => boolean): [LegTime, LegTime][] =>
+  tablesOf(inputs.source).flatMap((table) => {
+    const departs = columnOf(inputs.source, table.header, inputs.words.columns, DEPARTURE);
+    const arrives = columnOf(inputs.source, table.header, inputs.words.columns, ARRIVAL);
+    const headerLine = { start: table.header[0]?.start ?? 0, end: table.header.at(-1)?.end ?? 0 };
+    if (departs === -1 || arrives === -1) return [];
+    return table.rows.flatMap((row): [LegTime, LegTime][] => {
+      const cells = cellsOf(inputs.source, row.start, row.end);
+      const departure = cellTime(cells[departs], inputs);
+      const arrival = cellTime(cells[arrives], inputs);
+      const zoned = zonesOf(row.start, row.end) || zonesOf(headerLine.start, headerLine.end);
+      return departure === undefined || arrival === undefined || zoned ? [] : [[departure, arrival]];
+    });
+  });
+
+/** 着が発より前の組。同じ着を表の列と行の中の印の両方から読んでも、一度だけ言う。 */
+export const arrivalsBeforeDeparture = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords): StructureIssue[] => {
+  const inputs = { source, times, dates, words };
+  const zonesOf = (start: number, end: number): boolean => crossesZones(zonesIn(source.slice(start, end), words));
+  const issues = [...inlinePairs(inputs, zonesOf), ...columnPairs(inputs, zonesOf)]
+    .filter(([departure, arrival]) => arrivesFirst(departure, arrival))
+    .map(issueOf);
+  return issues
+    .filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index)
+    .toSorted((left, right) => left.offset - right.offset);
+};

package/src/structure/line-amount-unit.ts

@@ -0,0 +1,35 @@
+/**
+ * 明細の一行で、数量と単価が同じ単位を数えているか。単価が何かあたり（$100/hour、月額、Rate の列）なら、数量はその単位で
+ * 書かれているか単位の無い数でなければ、掛けても金額にならない。語はすべて語彙表から来る。Pure.
+ */
+export type UnitWord = { readonly pattern: string; readonly unit: string };
+
+/** The marks of a price cell with its per-unit mark taken off, and the unit it named. */
+export type PerUnitPrice = { readonly before: string; readonly after: string; readonly unit: string };
+
+const longestFirst = (words: readonly UnitWord[]): UnitWord[] => words.toSorted((left, right) => right.pattern.length - left.pattern.length);
+
+const lower = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+/** "$" "/hour" → "$" "" hour; "月額" "円" → "" "円" month. Undefined when neither mark says a unit. */
+export const perUnitPrice = (before: string, after: string, marks: readonly UnitWord[]): PerUnitPrice | undefined => {
+  const sorted = longestFirst(marks);
+  const ending = sorted.find((mark) => lower(after).endsWith(lower(mark.pattern)));
+  if (ending !== undefined) return { before, after: after.slice(0, after.length - ending.pattern.length).trim(), unit: ending.unit };
+  const opening = sorted.find((mark) => lower(before).startsWith(lower(mark.pattern)));
+  return opening === undefined ? undefined : { before: before.slice(opening.pattern.length).trim(), after, unit: opening.unit };
+};
+
+/** The unit of a quantity's word ("days" → day), "" when the cell has no word after its number, undefined when the word is not a unit. */
+export const quantityUnit = (word: string, units: readonly UnitWord[]): string | undefined => {
+  const wanted = lower(word).trim().replace(/\.$/u, "");
+  if (wanted === "") return "";
+  return units.find((unit) => lower(unit.pattern) === wanted)?.unit;
+};
+
+/**
+ * Whether quantity × price is meaningful. A price that is per no unit is per whatever the quantity counts. A price per a
+ * unit goes with a bare number (a count of that unit) or a quantity in that unit, and with nothing else.
+ */
+export const unitsAgree = (quantity: string | undefined, pricePer: string | undefined): boolean =>
+  pricePer === undefined || quantity === "" || quantity === pricePer;

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);
 };