chaffjs 0.30.0 → 0.32.0

package/src/structure/stamp-order.ts

@@ -0,0 +1,100 @@
+import type { DatedSpan } from "./date-range.ts";
+import type { StructureIssue } from "./issues.ts";
+import { linesOf } from "./lines.ts";
+
+/**
+ * A document's stamp dates out of order: an established date (2024年10月1日 制定, Established: April 1, 2023) later than an
+ * update (2024年9月1日 最終改定, Last updated: September 1, 2024). A stamp line (or one part of a line that holds several dates)
+ * holds one full date and, once the date is taken out, nothing but one stamp word (with colons, brackets, emphasis or a list
+ * marker around it). Only stamps written together are compared. Both stamps are reported, each naming the other: nothing tells
+ * which of the two dates is the wrong one. Pure; the stamp words come from the caller.
+ */
+export type StampWords = { readonly established: readonly string[]; readonly updated: readonly string[] };
+
+type Stamp = { readonly kind: "established" | "updated"; readonly date: DatedSpan; readonly line: number };
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+/** How many lines apart two stamps may be and still be one document's stamp block; further apart, they date two documents. */
+const MAX_LINE_GAP = 6;
+/** What may stand around a stamp word: spaces, colons, brackets, table bars, Markdown emphasis and list markers. */
+const AROUND_WORD = /[\s:：*_()（）[\]「」【】|｜\-‐−・]/u;
+/** A part of a line between a wide space, a tab or a bar. */
+const FIELD = /[^\t\u3000|｜]+/gu;
+
+const bareWord = (text: string): string => {
+  const chars = [...text];
+  const first = chars.findIndex((char) => !AROUND_WORD.test(char));
+  const last = chars.findLastIndex((char) => !AROUND_WORD.test(char));
+  return first === -1
+    ? ""
+    : chars
+        .slice(first, last + 1)
+        .join("")
+        .toLowerCase();
+};
+
+const kindOf = (word: string, words: StampWords): Stamp["kind"] | undefined => {
+  const isOne = (list: readonly string[]): boolean => list.some((entry) => entry.toLowerCase() === word);
+  if (isOne(words.established)) return "established";
+  return isOne(words.updated) ? "updated" : undefined;
+};
+
+type Field = { readonly start: number; readonly end: number; readonly line: number };
+
+const datesIn = (dates: readonly DatedSpan[], field: Field): DatedSpan[] => dates.filter((date) => date.offset >= field.start && date.end <= field.end);
+
+/** A line, or, when it holds more than one date, its parts between wide spaces, tabs and bars (作成：平成16年2月4日, a wide space, 最終改定：令和3年11月19日). */
+const fieldsOf = (source: string, dates: readonly DatedSpan[]): Field[] =>
+  linesOf(source).flatMap((line) => {
+    const whole = { start: line.start, end: line.start + line.text.length, line: line.number };
+    if (datesIn(dates, whole).length < 2) return [whole];
+    return [...line.text.matchAll(FIELD)].map((match) => ({
+      start: line.start + match.index,
+      end: line.start + match.index + match[0].length,
+      line: line.number,
+    }));
+  });
+
+/** The stamps of a text: a line or field holding one full date and one stamp word, nothing else. */
+const stampsOf = (source: string, dates: readonly DatedSpan[], words: StampWords): Stamp[] =>
+  fieldsOf(source, dates).flatMap((field) => {
+    const [date, ...more] = datesIn(dates, field);
+    if (date === undefined || more.length > 0 || !FULL_DATE.test(date.value)) return [];
+    const rest = `${source.slice(field.start, date.offset)} ${source.slice(date.end, field.end)}`;
+    const kind = kindOf(bareWord(rest), words);
+    return kind === undefined ? [] : [{ kind, date, line: field.line }];
+  });
+
+/** Stamps written together, each within MAX_LINE_GAP lines of the one before: one document's stamp block. */
+const blocksOf = (stamps: readonly Stamp[]): Stamp[][] =>
+  stamps.reduce<Stamp[][]>((blocks, stamp, index) => {
+    const previous = stamps[index - 1];
+    const last = blocks.at(-1);
+    if (previous === undefined || last === undefined || stamp.line - previous.line > MAX_LINE_GAP) return [...blocks, [stamp]];
+    return [...blocks.slice(0, -1), [...last, stamp]];
+  }, []);
+
+const valuesOf = (established: Stamp, updated: Stamp): Record<string, string> => ({ established: established.date.value, updated: updated.date.value });
+
+/** In one block: each established stamp later than an update, against the latest such update, and each such update against the first such established stamp. */
+const blockIssues = (block: readonly Stamp[]): StructureIssue[] => {
+  const established = block.filter((stamp) => stamp.kind === "established");
+  const updates = block.filter((stamp) => stamp.kind === "updated").toSorted((a, b) => b.date.value.localeCompare(a.date.value));
+  const ofEstablished = established.flatMap((stamp) => {
+    const latest = updates.find((updated) => updated.date.value < stamp.date.value);
+    return latest === undefined ? [] : [{ offset: stamp.date.offset, values: valuesOf(stamp, latest) }];
+  });
+  const ofUpdates = updates.flatMap((updated) => {
+    const later = established.find((stamp) => stamp.date.value > updated.date.value);
+    return later === undefined ? [] : [{ offset: updated.date.offset, values: { ...valuesOf(later, updated), side: "updated" } }];
+  });
+  return [...ofEstablished, ...ofUpdates];
+};
+
+/** Each established stamp later than an update of its block, and each such update, the one naming the other. */
+export const stampOrderIssues = (source: string, dates: readonly DatedSpan[], words: StampWords): StructureIssue[] => {
+  if (words.established.length === 0 || words.updated.length === 0) return [];
+  return blocksOf(stampsOf(source, dates, words))
+    .flatMap(blockIssues)
+    .toSorted((a, b) => a.offset - b.offset);
+};

package/src/structure/stated-multiple.ts

@@ -0,0 +1,82 @@
+import { escapeRegExp } from "../orthography.ts";
+
+/**
+ * The reading shared by the rules that compare an amount stated as a number of another stated amount: a deposit in months
+ * of rent (rent-multiple.ts), an annual premium in monthly payments (period-multiple.ts). Words are matched whole, amounts
+ * are read as the interval their written digits allow, and a multiple is taken of the nearest stated base. Pure.
+ */
+
+/** One amount of money as read: its currency, its value, and the value of the word of scale written in it (万), if any. */
+export type StatedAmount = {
+  readonly offset: number;
+  readonly end: number;
+  readonly currency: string;
+  readonly value: number;
+  readonly scale: number | undefined;
+};
+
+/** An amount read as the interval its written digits allow (9.8万円 is anything from 97,500 to 98,500). */
+export type Interval = { readonly low: number; readonly high: number };
+
+export type Span = { readonly start: number; readonly end: number };
+
+/** Rounding to the currency's unit (a yen, a dollar) is allowed on top of the written precision. */
+const UNIT_SLACK = 1;
+
+const LATIN = /[A-Za-z]/u;
+const SEPARATORS = /[\s|｜:：=＝、，,・/／'’()（）[\]［］-]/gu;
+const PARENTHETICAL_WITHOUT_DIGITS = /[（(][^()（）0-9０-９]*[)）]/gu;
+/** The possessive after a count (2 months' rent, 1 month's rent). */
+const POSSESSIVE = /['’]s?(?![A-Za-z])/gu;
+
+const wordPattern = (word: string): string => {
+  const edgeStart = LATIN.test(word.charAt(0)) ? "(?<![A-Za-z])" : "";
+  const edgeEnd = LATIN.test(word.charAt(word.length - 1)) ? "(?![A-Za-z])" : "";
+  return `${edgeStart}${escapeRegExp(word)}${edgeEnd}`;
+};
+
+/** One alternation of the words, longest first so 月額賃料 wins over 賃料. Undefined when there are none. */
+export const alternation = (words: readonly string[]): string | undefined =>
+  words.length === 0
+    ? undefined
+    : words
+        .toSorted((left, right) => right.length - left.length)
+        .map(wordPattern)
+        .join("|");
+
+export const occurrences = (text: string, words: readonly string[]): Span[] => {
+  const pattern = alternation(words);
+  if (pattern === undefined) return [];
+  return [...text.matchAll(new RegExp(pattern, "giu"))].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const withoutWords = (text: string, words: readonly string[]): string => {
+  const pattern = alternation(words);
+  return pattern === undefined ? text : text.replace(new RegExp(pattern, "giu"), "");
+};
+
+/** Whether only separators, bracketed words and link words stand in the gap (「 | 」, " (monthly): ", "の", "'s rent ("). */
+export const isPlainGap = (gap: string, words: readonly string[]): boolean =>
+  withoutWords(gap.replace(PARENTHETICAL_WITHOUT_DIGITS, "").replace(POSSESSIVE, ""), words).replace(SEPARATORS, "") === "";
+
+const decimalsOf = (written: string): number => /[.．]([0-9０-９]+)/u.exec(written)?.[1]?.length ?? 0;
+
+/** The interval an amount's digits allow: a word of scale (9.8万) leaves half its last digit either way; plain digits are exact. */
+export const intervalOf = (amount: StatedAmount, written: string): Interval => {
+  const half = amount.scale === undefined ? 0 : (amount.scale * 10 ** -decimalsOf(written)) / 2;
+  return { low: amount.value - half, high: amount.value + half };
+};
+
+/** Whether the amount is the count of one of the bases, within the written precision and a unit's rounding. */
+export const isMultiple = (count: number, amount: Interval, bases: readonly Interval[]): boolean =>
+  bases.some((base) => count * base.low - UNIT_SLACK <= amount.high && amount.low <= count * base.high + UNIT_SLACK);
+
+type Stated = { readonly offset: number; readonly range: Interval | undefined };
+
+/** The base a statement at this offset is of: the nearest before it, or, before any, the one base the document states. */
+export const nearestStated = <T extends Stated>(bases: readonly T[], offset: number): T | undefined => {
+  const before = bases.filter((base) => base.offset < offset).at(-1);
+  if (before !== undefined) return before;
+  const [first] = bases;
+  return bases.every((base) => base.range !== undefined && base.range.low === first?.range?.low && base.range.high === first.range.high) ? first : undefined;
+};

package/src/structure/stated-period.ts

@@ -1,5 +1,7 @@
 import { escapeRegExp } from "../orthography.ts";
 import { withoutTrailingWeekday } from "./date-range.ts";
+import { keyValueCell } from "./key-value-row.ts";
+import { TABLE_ROW } from "./runs.ts";
 
 /**
  * 文書が書いた期間（旅行期間：10月12日〜10月15日、Trip period: Oct 12–15）。期間の語（period-label）で始まる一行だけを読む。
@@ -19,15 +21,12 @@ export type PeriodWords = {
 
 export type Period = { readonly start: string; readonly end: string; readonly written: string };
 
-/**
- * 行の頭の印（見出し、箇条書き、引用）と、語を囲む太字や括弧の開き。表の行は読まない。
- * 「| Conference | May 3–5 |」は催しを並べた表の一行で、文書の期間ではない。
- */
+/** 行の頭の印（見出し、箇条書き、引用）と、語を囲む太字や括弧の開き。表の行は statedPeriod が別に読む。 */
 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 => {
+export 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);
 };
@@ -149,13 +148,26 @@ const datesOf = (line: string, lineStart: number, from: number, dates: readonly
   return monthRange(line.slice(from), words);
 };
 
+/** 期間を書いた部分の、行の中の始まりと終わり。表の行は、その表（tableOf）を渡したときだけ、二列の表の内容の升を読む。 */
+const valueSpan = (line: string, labels: readonly string[], tableOf: (() => readonly string[]) | undefined): { from: number; to: number } | undefined => {
+  if (TABLE_ROW.test(line)) return tableOf === undefined ? undefined : keyValueCell(line, tableOf, labels);
+  const from = afterLabel(line, labels);
+  return from === undefined ? undefined : { from, to: line.length };
+};
+
 /**
  * 期間の語で始まる一行の期間。行の中の日付が二つで間が範囲の記号なら、その二つ。一つなら、その前か後ろに日だけを書いた片方を読む。
- * 日付の無い行は、月の名と日の範囲を読む。読めなければ undefined。
+ * 日付の無い行は、月の名と日の範囲を読む。読めなければ undefined。tableOf はその行を含む表の行を返し、渡すと二列の表の一行（| 対象期間 | … |）も読む。
  */
-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() };
+export const statedPeriod = (
+  line: string,
+  lineStart: number,
+  dates: readonly DateMention[],
+  words: PeriodWords,
+  tableOf?: () => readonly string[],
+): Period | undefined => {
+  const span = valueSpan(line, words.labels, tableOf);
+  if (span === undefined) return undefined;
+  const found = datesOf(line.slice(0, span.to), lineStart, span.from, dates, words);
+  return found === undefined ? undefined : { ...found, written: line.slice(span.from, span.to).trim() };
 };

package/src/structure/step-times.ts

@@ -0,0 +1,169 @@
+import type { Span } from "../plugin.ts";
+import { labelOf, timeLengths, type LengthWords, type TimeLength } from "../derived/time-lengths.ts";
+import { isWordAt, type Mark } from "./time-marks.ts";
+import { linesOf } from "./lines.ts";
+
+/**
+ * A stated total time (所要時間：80分, Total time: 1 hr 20 min) against the sum of the times written in the numbered steps
+ * ((10分), bake for 40 minutes). The words come from the language packages; nothing here knows a language. Pure.
+ */
+export type StepTimeWords = {
+  readonly lengths: LengthWords;
+  /** Labels of a total time (所要時間, Total time), written before the length. */
+  readonly totals: readonly Mark[];
+  /** Marks of a rough figure (約, about, 程度): the total or a step that carries one is compared with a margin. */
+  readonly approximate: readonly Mark[];
+  /** Marks of a time that is not how long the step takes (10分後, every 5 minutes, after 10 minutes). */
+  readonly notOwn: readonly Mark[];
+  /** What joins the two ends of a range (10〜15分, 10 to 15 minutes): a step or total with a range is not read. */
+  readonly rangeJoiners: readonly string[];
+};
+
+/** A length of time with whether it was written as a rough figure. */
+export type ReadTime = Span & { readonly minutes: number; readonly approximate: boolean };
+
+export type StepTimeSlip = {
+  readonly total: ReadTime;
+  readonly sum: number;
+  readonly steps: number;
+  /** How far the sum may be from the total and still agree, in minutes: 0 unless a rough figure is involved. */
+  readonly margin: number;
+};
+
+/** A rough total agrees with a sum within this share of the total, and never less than ROUGH_MINUTES. */
+export const ROUGH_SHARE = 0.1;
+export const ROUGH_MINUTES = 5;
+const MIN_STEPS = 2;
+
+/** 1. or 1) with a space after it (so 1.5 hours is no step); the full-width 1．or 1）may run straight on. */
+const STEP_ITEM = /^\s*\p{Nd}{1,3}(?:[.)]\s|[．）])/u;
+const INDENTED = /^\s+\S/u;
+
+type ListRead = { readonly lists: Span[][]; readonly open: boolean; readonly lastLine: number };
+
+/** One line's place in the numbered lists: a new item, a line under the last item, a blank, or the end of the list. */
+const readLine = (read: ListRead, line: { readonly text: string; readonly start: number; readonly number: number }): ListRead => {
+  const end = line.start + line.text.length;
+  const list = read.lists[read.lists.length - 1];
+  const last = list?.[list.length - 1];
+  if (STEP_ITEM.test(line.text)) {
+    if (read.open && list !== undefined) list.push({ start: line.start, end });
+    else read.lists.push([{ start: line.start, end }]);
+    return { lists: read.lists, open: true, lastLine: line.number };
+  }
+  if (line.text.trim() === "") return read;
+  if (read.open && list !== undefined && last !== undefined && INDENTED.test(line.text)) {
+    if (read.lastLine === line.number - 1) list[list.length - 1] = { start: last.start, end };
+    return { ...read, lastLine: line.number };
+  }
+  return { ...read, open: false };
+};
+
+/** The numbered lists of the source, each a run of items with only blank or indented lines between them. An item holds its line and the indented lines right under it. */
+export const stepLists = (source: string): Span[][] => linesOf(source).reduce<ListRead>(readLine, { lists: [], open: false, lastLine: 0 }).lists;
+
+/** Every numbered step of the source. */
+export const stepItems = (source: string): Span[] => stepLists(source).flat();
+
+const lower = (text: string): string => text.toLowerCase();
+
+const sideOf = (marks: readonly Mark[], side: "before" | "after"): string[] =>
+  marks
+    .filter((mark) => (mark.position ?? "before") === side)
+    .map((mark) => lower(mark.pattern))
+    .filter((pattern) => pattern !== "")
+    .toSorted((left, right) => right.length - left.length);
+
+/** The mark written right before at (white space between only), and where it starts. */
+const markEndingAt = (text: string, at: number, patterns: readonly string[]): number | undefined => {
+  const head = lower(text.slice(0, at)).trimEnd();
+  const found = patterns.find((pattern) => isWordAt(head, head.length - pattern.length, pattern));
+  return found === undefined ? undefined : head.length - found.length;
+};
+
+/** Whether a mark is written right after at (white space between only). */
+const markStartingAt = (text: string, at: number, patterns: readonly string[]): boolean => {
+  const tail = lower(text.slice(at));
+  const gap = tail.length - tail.trimStart().length;
+  return patterns.some((pattern) => isWordAt(tail, gap, pattern));
+};
+
+const DIGIT_BEFORE = /\p{Nd}\s*$/u;
+
+/** Whether the length is the second end of a range: a joiner right before it, after a number, a number word or a unit (10〜15分, one to two hours, 10 minutes to 15 minutes). */
+const endsRange = (text: string, at: number, words: StepTimeWords): boolean => {
+  const start = markEndingAt(text, at, words.rangeJoiners.map(lower));
+  if (start === undefined) return false;
+  const { numberWords, hourUnits, minuteUnits } = words.lengths;
+  const ends = [...numberWords, ...hourUnits, ...minuteUnits].map(lower).filter((word) => word !== "");
+  return DIGIT_BEFORE.test(text.slice(0, start)) || markEndingAt(text, start, ends) !== undefined;
+};
+
+type Reading = { readonly time: ReadTime; readonly from: number; readonly own: boolean; readonly range: boolean };
+
+/** Each length in text, with where its rough-figure mark starts, whether it is the step's own time, and whether it ends a range. */
+const readingsOf = (text: string, words: StepTimeWords): Reading[] =>
+  timeLengths(text, words.lengths).map((length: TimeLength): Reading => {
+    const roughBefore = markEndingAt(text, length.start, sideOf(words.approximate, "before"));
+    const roughAfter = markStartingAt(text, length.end, sideOf(words.approximate, "after"));
+    const from = roughBefore ?? length.start;
+    const notOwn =
+      markEndingAt(text, from, sideOf(words.notOwn, "before")) !== undefined ||
+      (!roughAfter && markStartingAt(text, length.end, sideOf(words.notOwn, "after")));
+    return {
+      time: { start: length.start, end: length.end, minutes: length.minutes, approximate: roughBefore !== undefined || roughAfter },
+      from,
+      own: !notOwn,
+      range: endsRange(text, length.start, words),
+    };
+  });
+
+/** How long one step takes: its one own length of time. undefined when it has none, more than one, or a range. */
+export const stepTime = (text: string, words: StepTimeWords): ReadTime | undefined => {
+  const readings = readingsOf(text, words);
+  if (readings.some((reading) => reading.range)) return undefined;
+  const own = readings.filter((reading) => reading.own);
+  return own.length === 1 ? own[0]?.time : undefined;
+};
+
+const outside = (offset: number, items: readonly Span[]): boolean => !items.some((item) => offset >= item.start && offset < item.end);
+
+/** The totals written on one line. A line with a range (Total time: 10 to 15 minutes) states no exact total. */
+const totalsOn = (line: { readonly text: string; readonly start: number }, words: StepTimeWords): ReadTime[] => {
+  const readings = readingsOf(line.text, words);
+  if (readings.some((reading) => reading.range)) return [];
+  return readings.flatMap((reading): ReadTime[] => {
+    const label = labelOf(line.text, { start: reading.from, end: reading.time.end }, words.totals);
+    if (label === undefined || !reading.own) return [];
+    return [{ ...reading.time, start: line.start + reading.time.start, end: line.start + reading.time.end }];
+  });
+};
+
+/** The total time the source states outside its steps: a length with a total label right before it. Only one value is read. */
+export const statedTotal = (source: string, items: readonly Span[], words: StepTimeWords): ReadTime | undefined => {
+  const totals = linesOf(source)
+    .filter((line) => outside(line.start, items))
+    .flatMap((line) => totalsOn(line, words));
+  const values = new Set(totals.map((total) => total.minutes));
+  return values.size === 1 ? totals[0] : undefined;
+};
+
+/** The margin a rough figure allows: ROUGH_SHARE of the total, at least ROUGH_MINUTES. */
+export const marginOf = (total: number, rough: boolean): number => (rough ? Math.max(ROUGH_MINUTES, total * ROUGH_SHARE) : 0);
+
+/**
+ * The stated total against the sum of the steps' times, when the document has one numbered list, every step's time is readable,
+ * and they do not agree. Two lists may be two procedures, or one of them no procedure, so a document with two is not read.
+ */
+export const stepTimeSlip = (source: string, words: StepTimeWords): StepTimeSlip | undefined => {
+  const lists = stepLists(source);
+  const [items] = lists;
+  if (lists.length !== 1 || items === undefined || items.length < MIN_STEPS) return undefined;
+  const total = statedTotal(source, items, words);
+  if (total === undefined) return undefined;
+  const times = items.map((item) => stepTime(source.slice(item.start, item.end), words));
+  if (times.some((time) => time === undefined)) return undefined;
+  const sum = times.reduce((minutes, time) => minutes + (time?.minutes ?? 0), 0);
+  const margin = marginOf(total.minutes, total.approximate || times.some((time) => time?.approximate === true));
+  return Math.abs(sum - total.minutes) <= margin ? undefined : { total, sum, steps: items.length, margin };
+};

package/src/structure/table-scale.ts

@@ -0,0 +1,239 @@
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "./lines.ts";
+
+/**
+ * A results table that mixes scales without saying so: a cell written in another scale unit than the table's (110,000千円 among
+ * 百万円), or, under a stated unit, one row entered a thousand times too large (52,000 among 1,200 and 84 under 単位：百万円).
+ * The scale units, the caption marks and the total labels come from the language packages. Pure.
+ */
+export type ScaleUnit = { readonly word: string; readonly value: number };
+
+export type TableScaleWords = {
+  /** Words of scale written in a cell or a caption (百万円, million, millions), with the number they multiply by. */
+  readonly units: readonly ScaleUnit[];
+  /** What marks a line as a table's caption of unit (単位, in, of). */
+  readonly captionMarks: readonly string[];
+  /** Row labels of a total (合計, Total): a total row is large by nature. */
+  readonly totalLabels: readonly string[];
+};
+
+export type TableScaleSlip = {
+  /** "unit": the cell is written in another scale unit; "row": the row is a thousand times its neighbours. */
+  readonly kind: "unit" | "row";
+  readonly item: string;
+  readonly cell: Cell;
+  /** The table's scale as written: the caption's word, or the word most cells carry. */
+  readonly tableUnit: string;
+  /** For "row": the row's first figure divided by the factor, as it would read in the table's unit. */
+  readonly reading?: number | undefined;
+};
+
+/** A cell read as one number with, at most, a scale unit after it. */
+export type ScaleCell = { readonly number: number; readonly digits: string; readonly unit: ScaleUnit | undefined };
+
+/** A row a thousand times its neighbours: the factor between thousands and millions, or millions and billions. */
+export const ROW_FACTOR = 1000;
+/** The row's figure must be at least this many times the largest of the other rows in its column. */
+const LARGER_THAN_OTHERS = 10;
+/** A row is compared on at least this many columns, and with at least this many other rows. */
+const MIN_COLUMNS = 2;
+const MIN_OTHER_ROWS = 2;
+/** A caption of unit is a short line; a longer one is a sentence about the figures. */
+const MAX_CAPTION_LENGTH = 40;
+/** How many blank lines may stand between the caption and the table. */
+const CAPTION_REACH = 2;
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const DIGIT = /\p{Nd}/u;
+/** Currency marks and minus signs written before the figure ($, ¥, △52, -$52). */
+const LEAD = /^(?:US\$|[$¥€£\-−△▲\s])+/u;
+const NEGATIVE = /[-−△▲]/u;
+const DIGITS = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?/u;
+/** An accounting negative: the figure in brackets, (52,000). */
+const BRACKETED = /^[(（]([^()（）]+)[)）]$/u;
+const CURRENCY_TAIL = /^[\p{L} ]*$/u;
+
+const boundaryAt = (text: string, index: number): boolean => {
+  const char = text[index];
+  return char === undefined || !LETTER.test(char);
+};
+
+/** The longest unit written at index, when it is a whole word (a Latin word must not run on: million in millions is not). */
+const unitAt = (text: string, index: number, units: readonly ScaleUnit[]): ScaleUnit | undefined => {
+  const lower = text.toLowerCase();
+  return units
+    .filter((unit) => lower.startsWith(unit.word.toLowerCase(), index))
+    .filter((unit) => !LATIN.test(unit.word) || (boundaryAt(text, index - 1) && boundaryAt(text, index + unit.word.length)))
+    .toSorted((left, right) => right.word.length - left.word.length)[0];
+};
+
+/** Every unit written in the text, longest first at each place, without overlaps (百万円 is not also 万円). */
+export const unitsIn = (text: string, units: readonly ScaleUnit[]): ScaleUnit[] => {
+  const found: ScaleUnit[] = [];
+  const step = (index: number): void => {
+    if (index >= text.length) return;
+    const unit = unitAt(text, index, units);
+    if (unit !== undefined) found.push(unit);
+    step(index + (unit?.word.length ?? 1));
+  };
+  step(0);
+  return found;
+};
+
+/** The unit after a figure, with nothing after it but a currency word (円, US dollars); null when there is no unit. */
+const unitAfter = (rest: string, units: readonly ScaleUnit[]): ScaleUnit | null | undefined => {
+  if (rest === "") return null;
+  const unit = unitAt(rest, 0, units);
+  return unit !== undefined && CURRENCY_TAIL.test(rest.slice(unit.word.length)) ? unit : undefined;
+};
+
+const negated = (cell: ScaleCell | undefined): ScaleCell | undefined => (cell === undefined || cell.number < 0 ? undefined : { ...cell, number: -cell.number });
+
+/** A cell's number and its scale unit; undefined when the cell is not one figure (7.0%, 1,200人, —). */
+export const scaleCellOf = (text: string, units: readonly ScaleUnit[]): ScaleCell | undefined => {
+  const plain = withoutEdgeMarks(text.trim());
+  const bracketed = BRACKETED.exec(plain)?.[1];
+  if (bracketed !== undefined) return negated(scaleCellOf(bracketed, units));
+  const lead = LEAD.exec(plain)?.[0] ?? "";
+  const digits = DIGITS.exec(plain.slice(lead.length))?.[0];
+  if (digits === undefined) return undefined;
+  const unit = unitAfter(plain.slice(lead.length + digits.length).trim(), units);
+  if (unit === undefined) return undefined;
+  const number = Number(digits.replaceAll(",", "")) * (NEGATIVE.test(lead) ? -1 : 1);
+  return { number, digits, unit: unit ?? undefined };
+};
+
+const hasMark = (text: string, mark: string): boolean => {
+  const lower = text.toLowerCase();
+  const word = mark.toLowerCase();
+  const at = lower.indexOf(word);
+  if (at === -1) return false;
+  return !LATIN.test(mark) || (boundaryAt(text, at - 1) && boundaryAt(text, at + word.length)) || hasMark(text.slice(at + word.length), mark);
+};
+
+/** The unit a line states for the table under it: a short line with no figure, a caption mark and one scale unit. */
+export const captionUnitOf = (text: string, words: TableScaleWords): ScaleUnit | undefined => {
+  const line = text.trim();
+  if (line.length === 0 || line.length > MAX_CAPTION_LENGTH || DIGIT.test(line) || line.startsWith("|")) return undefined;
+  if (!words.captionMarks.some((mark) => hasMark(line, mark))) return undefined;
+  const found = unitsIn(line, words.units);
+  const values = new Set(found.map((unit) => unit.value));
+  return values.size === 1 ? found[0] : undefined;
+};
+
+const captionOf = (lines: readonly Line[], header: Line, words: TableScaleWords): ScaleUnit | undefined => {
+  const index = lines.indexOf(header);
+  const before = lines.slice(Math.max(0, index - CAPTION_REACH - 1), index).toReversed();
+  const caption = before.find((line) => line.text.trim() !== "");
+  return caption === undefined ? undefined : captionUnitOf(caption.text, words);
+};
+
+type ReadCell = { readonly cell: Cell; readonly read: ScaleCell; readonly column: number };
+type ReadRow = { readonly item: string; readonly cells: readonly ReadCell[] };
+
+const rowsOf = (rows: readonly Line[], units: readonly ScaleUnit[]): ReadRow[] =>
+  rows.map((row) => {
+    const [first, ...rest] = cellsOf(row);
+    const cells = rest.flatMap((cell, column): ReadCell[] => {
+      const read = scaleCellOf(cell.text, units);
+      return read === undefined ? [] : [{ cell, read, column }];
+    });
+    return { item: withoutEdgeMarks((first?.text ?? "").trim()), cells };
+  });
+
+/** The unit most cells carry, when at least two do and no other unit is as common. */
+const usualUnitOf = (rows: readonly ReadRow[]): ScaleUnit | undefined => {
+  const counts = new Map<number, { unit: ScaleUnit; count: number }>();
+  rows.forEach((row) =>
+    row.cells.forEach(({ read }) => {
+      if (read.unit === undefined) return;
+      const seen = counts.get(read.unit.value);
+      counts.set(read.unit.value, { unit: seen?.unit ?? read.unit, count: (seen?.count ?? 0) + 1 });
+    }),
+  );
+  const [top, second] = [...counts.values()].toSorted((left, right) => right.count - left.count);
+  return top !== undefined && top.count >= MIN_OTHER_ROWS && (second === undefined || second.count < top.count) ? top.unit : undefined;
+};
+
+/**
+ * Whether a cell's unit departs from the table's. Under a stated unit, any other unit does. Without one, only a smaller unit
+ * with a figure of one table unit or more (110,000千円 among 百万円): a larger unit for a large figure ($2.4 billion among
+ * $130 million) is a normal way of writing.
+ */
+const departs = (read: ScaleCell, table: ScaleUnit, stated: boolean): boolean => {
+  if (read.unit === undefined || read.unit.value === table.value) return false;
+  if (stated) return true;
+  return read.unit.value < table.value && Math.abs(read.number) * read.unit.value >= table.value;
+};
+
+const unitSlips = (rows: readonly ReadRow[], table: ScaleUnit, stated: boolean): TableScaleSlip[] =>
+  rows.flatMap((row) => {
+    const odd = row.cells.find(({ read }) => departs(read, table, stated));
+    return odd === undefined ? [] : [{ kind: "unit" as const, item: row.item, cell: odd.cell, tableUnit: table.word }];
+  });
+
+const isTotal = (item: string, labels: readonly string[]): boolean => labels.some((label) => item.toLowerCase().startsWith(label.toLowerCase()));
+
+/** A row's figure that reads as entered in a unit a thousand times smaller: whole thousands, at least one thousand. */
+const wholeThousands = (read: ScaleCell): boolean =>
+  read.unit === undefined && !read.digits.includes(".") && Math.abs(read.number) >= ROW_FACTOR && read.number % ROW_FACTOR === 0;
+
+type BareRow = { readonly row: ReadRow; readonly figures: ReadonlyMap<number, ReadCell> };
+
+const bareRowsOf = (rows: readonly ReadRow[]): BareRow[] =>
+  rows.map((row) => ({ row, figures: new Map(row.cells.filter((entry) => entry.read.unit === undefined).map((entry) => [entry.column, entry])) }));
+
+/**
+ * Whether one figure stands a thousand times above its column: at least ten times the largest other figure, and a thousandth
+ * of it no larger than that figure, so it reads as one of them once divided.
+ */
+const standsAbove = (figure: ScaleCell, others: readonly number[]): boolean => {
+  const largest = Math.max(...others.map((value) => Math.abs(value)));
+  return others.length >= MIN_OTHER_ROWS && Math.abs(figure.number) >= LARGER_THAN_OTHERS * largest && Math.abs(figure.number) / ROW_FACTOR <= largest;
+};
+
+const rowStandsAbove = (candidate: BareRow, rows: readonly BareRow[]): boolean => {
+  const figures = [...candidate.figures.entries()];
+  return (
+    figures.length >= MIN_COLUMNS &&
+    figures.every(([column, figure]) => {
+      const others = rows.flatMap((row) => {
+        const other = row === candidate ? undefined : row.figures.get(column);
+        return other === undefined ? [] : [other.read.number];
+      });
+      return wholeThousands(figure.read) && standsAbove(figure.read, others);
+    })
+  );
+};
+
+/**
+ * The one row, under a stated unit, entered a thousand times too large. Every figure of the row must be whole thousands (a row
+ * multiplied by a thousand always is; a genuinely large row, such as total assets, almost never is in every column), stand ten
+ * times above every other row of its column, and fall among them once divided. A total row and a row whose label carries its
+ * own unit in brackets (従業員数（人）) are left alone, and so is a table where more than one row stands out (each in its own columns).
+ */
+const rowSlips = (rows: readonly ReadRow[], table: ScaleUnit, words: TableScaleWords): TableScaleSlip[] => {
+  const bare = bareRowsOf(rows);
+  const standing = bare.filter((row) => !isTotal(row.row.item, words.totalLabels) && !/[(（]/u.test(row.row.item) && rowStandsAbove(row, bare));
+  const [only] = standing;
+  if (only === undefined || standing.length > 1) return [];
+  const first = [...only.figures.values()][0];
+  return first === undefined ? [] : [{ kind: "row", item: only.row.item, cell: first.cell, tableUnit: table.word, reading: first.read.number / ROW_FACTOR }];
+};
+
+const tableSlips = (lines: readonly Line[], table: { header: Line; rows: Line[] }, words: TableScaleWords): TableScaleSlip[] => {
+  const rows = rowsOf(table.rows, words.units);
+  const caption = captionOf(lines, table.header, words);
+  const unit = caption ?? usualUnitOf(rows);
+  if (unit === undefined) return [];
+  const units = unitSlips(rows, unit, caption !== undefined);
+  return caption === undefined ? units : [...units, ...rowSlips(rows, caption, words)];
+};
+
+/** Every table of the text that mixes scales, and the cells or rows that depart. */
+export const tableScaleSlips = (text: string, words: TableScaleWords): TableScaleSlip[] => {
+  const lines = linesOf(text);
+  return tablesOf(lines).flatMap((table) => tableSlips(lines, table, words));
+};