chaffjs 0.30.0 → 0.32.0

package/src/structure/ratio.ts

@@ -0,0 +1,296 @@
+/**
+ * ratio-mismatch: the deciding half. A ratio written in percent (営業利益率 7.3%, Operating margin 7.5%) against the numerator
+ * and the denominator it names (営業利益 ÷ 売上高), in a results table or in one sentence. Which ratio names which two rows is
+ * data (lexicons ratio-label and ratio-term); nothing here knows a word of accounting. Pure.
+ */
+import type { StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "./issues.ts";
+
+/** An amount as written: its value in the unit it is written in, the step of its last written digit, and that unit. */
+export type Figure = { readonly start: number; readonly value: number; readonly step: number; readonly unit: string };
+
+/** A ratio as written: its value in percent and the number of its decimals. */
+export type WrittenRate = { readonly start: number; readonly value: number; readonly decimals: number };
+
+/** A ratio label and the names of the terms it divides (営業利益率 → operating-profit / sales). */
+export type RatioLabel = { readonly pattern: string; readonly numerator: string; readonly denominator: string };
+
+export type RatioTerm = { readonly pattern: string; readonly term: string };
+
+export type RatioWords = { readonly labels: readonly RatioLabel[]; readonly terms: readonly RatioTerm[]; readonly percentUnits: readonly string[] };
+
+export type RatioIssue = { readonly offset: number; readonly values: Readonly<Record<string, string>> };
+
+const PERCENT = 100;
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+/** Floating error must not push a ratio that sits on the edge of its rounding out of it. */
+const FLOAT_SLACK = 1e-9;
+
+/** The ratio written as a decimal-point string of the written precision (7.3, 12.50). */
+const shown = (value: number, decimals: number): string => value.toFixed(decimals);
+
+/**
+ * The ratio the two amounts give, when the written ratio cannot be it; undefined when it can or when they cannot be compared.
+ * The written ratio stands for the half step of its last digit around it (7.3% is 7.25% to 7.35%). Each amount may be off by a
+ * whole step of its last digit, not half: results tables round down (百万円未満切捨て) as often as to nearest, and the margin is
+ * worked out from the unrounded amounts.
+ */
+export const ratioDisagreement = (rate: WrittenRate, numerator: Figure, denominator: Figure): string | undefined => {
+  if (numerator.unit !== denominator.unit || numerator.value < 0 || denominator.value - denominator.step <= 0) return undefined;
+  const lowest = (Math.max(0, numerator.value - numerator.step) / (denominator.value + denominator.step)) * PERCENT;
+  const highest = ((numerator.value + numerator.step) / (denominator.value - denominator.step)) * PERCENT;
+  const half = HALF * DECIMAL_BASE ** -rate.decimals + FLOAT_SLACK;
+  if (rate.value + half >= lowest && rate.value - half <= highest) return undefined;
+  return shown((numerator.value / denominator.value) * PERCENT, rate.decimals);
+};
+
+/** The words compared: NFKC, lower case, one space. */
+export const keyOf = (text: string): string => text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
+
+const PREFIX = /^[^\d\s]*/u;
+const NUMBER = /^(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?/u;
+/** Marks that make an amount negative or a note ((1,200), ▲50, -50, +3%): such a cell is not read. */
+const SIGNED = /[-−▲△+＋(（]/u;
+const DIGIT = /\d/u;
+
+/** The value of a number written with grouping commas and its decimals apart ("1,320" and "5"). */
+const numberOf = (integer: string, decimals: string): number => Number([integer.replaceAll(",", ""), decimals].filter((part) => part !== "").join("."));
+
+export type ReadCell = { readonly prefix: string; readonly value: number; readonly decimals: number; readonly suffix: string };
+
+/** A cell holding one number with what is written before and after it ("$2,400 million", "1,320百万円", "7.3%"). */
+export const readNumber = (text: string): ReadCell | undefined => {
+  const plain = text.normalize("NFKC").trim();
+  const prefix = PREFIX.exec(plain)?.[0] ?? "";
+  const number = NUMBER.exec(plain.slice(prefix.length));
+  if (number === null || SIGNED.test(prefix)) return undefined;
+  const suffix = plain.slice(prefix.length + number[0].length).trim();
+  if (DIGIT.test(suffix) || SIGNED.test(suffix)) return undefined;
+  const decimals = number[2] ?? "";
+  return { prefix, value: numberOf(number[1] ?? "", decimals), decimals: decimals.length, suffix };
+};
+
+/** A cell read as a percentage: a percent unit after the number, or nothing after it when the row says it is in percent. */
+export const cellRate = (text: string, start: number, percentUnits: readonly string[], rowInPercent: boolean): WrittenRate | undefined => {
+  const cell = readNumber(text);
+  if (cell === undefined || cell.prefix !== "") return undefined;
+  const inPercent = percentUnits.some((unit) => keyOf(unit) === keyOf(cell.suffix)) || (rowInPercent && cell.suffix === "");
+  return inPercent ? { start, value: cell.value, decimals: cell.decimals } : undefined;
+};
+
+/** A cell read as an amount, in the unit written around its number. A percentage is not an amount. */
+export const cellFigure = (text: string, start: number, percentUnits: readonly string[]): Figure | undefined => {
+  const cell = readNumber(text);
+  if (cell === undefined || percentUnits.some((unit) => keyOf(unit) === keyOf(cell.suffix))) return undefined;
+  return { start, value: cell.value, step: DECIMAL_BASE ** -cell.decimals, unit: `${keyOf(cell.prefix)}|${keyOf(cell.suffix)}` };
+};
+
+export type TableCell = { readonly start: number; readonly text: string };
+
+/** A table row: its label (the first cell, as written) and the cells after it. */
+export type TableRow = { readonly label: string; readonly cells: readonly TableCell[] };
+
+/** A note in brackets after a row label (営業利益率（%）, Net sales (millions)): not part of the label. */
+const LABEL_NOTE = /[(（][^()（）]*[)）]$/u;
+
+export const labelKey = (label: string): string => keyOf(label.replace(LABEL_NOTE, ""));
+
+export const noteOf = (label: string): string => LABEL_NOTE.exec(label.normalize("NFKC").trim())?.[0] ?? "";
+
+/** The one row whose label is a term of the name; undefined when no row or more than one row is. */
+const onlyRow = (rows: readonly TableRow[], terms: readonly RatioTerm[], name: string): TableRow | undefined => {
+  const patterns = terms.filter((term) => term.term === name).map((term) => keyOf(term.pattern));
+  const found = rows.filter((row) => patterns.includes(labelKey(row.label)));
+  return found.length === 1 ? found[0] : undefined;
+};
+
+/** An amount cell, in its unit and the unit its row label notes (Net sales (thousand yen)): rows noted differently differ. */
+const rowFigure = (cell: TableCell, row: TableRow, percentUnits: readonly string[]): Figure | undefined => {
+  const figure = cellFigure(cell.text, cell.start, percentUnits);
+  return figure === undefined ? undefined : { ...figure, unit: `${figure.unit}|${keyOf(noteOf(row.label))}` };
+};
+
+const sameWidth = (rows: readonly TableRow[]): boolean => rows.every((row) => row.cells.length === rows[0]?.cells.length);
+
+const columnIssues = (ratioRow: TableRow, numeratorRow: TableRow, denominatorRow: TableRow, words: RatioWords): RatioIssue[] => {
+  const inPercent = words.percentUnits.some((unit) => noteOf(ratioRow.label).includes(unit.normalize("NFKC")));
+  return ratioRow.cells.flatMap((cell, column) => {
+    const rate = cellRate(cell.text, cell.start, words.percentUnits, inPercent);
+    const top = numeratorRow.cells[column];
+    const bottom = denominatorRow.cells[column];
+    const numerator = top === undefined ? undefined : rowFigure(top, numeratorRow, words.percentUnits);
+    const denominator = bottom === undefined ? undefined : rowFigure(bottom, denominatorRow, words.percentUnits);
+    if (rate === undefined || numerator === undefined || denominator === undefined) return [];
+    const computed = ratioDisagreement(rate, numerator, denominator);
+    return computed === undefined ? [] : [{ offset: rate.start, values: { written: shown(rate.value, rate.decimals), computed } }];
+  });
+};
+
+/**
+ * In one table, each row labelled with a ratio against the one row of its numerator and the one row of its denominator,
+ * column by column. A table whose three rows do not have the same number of cells is not read: its columns may not line up.
+ */
+export const tableRatioMismatches = (rows: readonly TableRow[], words: RatioWords): RatioIssue[] =>
+  rows.flatMap((ratioRow) => {
+    const label = words.labels.find((entry) => keyOf(entry.pattern) === labelKey(ratioRow.label));
+    if (label === undefined) return [];
+    const numeratorRow = onlyRow(rows, words.terms, label.numerator);
+    const denominatorRow = onlyRow(rows, words.terms, label.denominator);
+    if (numeratorRow === undefined || denominatorRow === undefined || !sameWidth([ratioRow, numeratorRow, denominatorRow])) return [];
+    return columnIssues(ratioRow, numeratorRow, denominatorRow, words).map((issue) => ({
+      offset: issue.offset,
+      values: { ...issue.values, ratio: ratioRow.label.trim() },
+    }));
+  });
+
+/** How amounts are written around their number: currency marks before and after it, and words of magnitude (million, 万). */
+export type AmountWords = {
+  readonly before: readonly string[];
+  readonly after: readonly string[];
+  readonly multipliers: readonly string[];
+  readonly percentUnits: readonly string[];
+};
+
+/** A quantity the structure tree read: where it stands in the document and the unit it names (円, $, %, 社). */
+export type ProseQuantity = { readonly start: number; readonly end: number; readonly unit: string };
+
+/** The tree's quantities, in document order. */
+export const proseQuantitiesOf = (tree: StructureNode | undefined): ProseQuantity[] =>
+  tree === undefined
+    ? []
+    : inDocumentOrder(tree).flatMap((node) =>
+        node.kind === "quantity" ? [{ start: node.span.start, end: node.span.end, unit: String(node.attrs["unit"] ?? "") }] : [],
+      );
+
+const PROSE_NUMBER = /(?<![\d.,])(\d{1,3}(?:,\d{3})+|\d+)(?:\.(\d+))?(?![\d,.]\d)/gu;
+const NEGATIVE_BEFORE = /[-−▲△]$/u;
+/** Words after the quantity ("$198 million", "1,320 million yen"). */
+const WORDS_AFTER = /^\s+([A-Za-z]+)(?:\s+([A-Za-z]+))?/u;
+
+/** The currency mark before a number, which may stand one space apart ($5, € 5, US$5), and the text before that mark. */
+const markBefore = (before: string, marks: readonly string[]): { readonly mark: string; readonly rest: string } => {
+  const gapped = before.endsWith(" ") ? before.slice(0, -1) : before;
+  const mark = marks.filter((entry) => gapped.endsWith(entry)).toSorted((left, right) => right.length - left.length)[0];
+  return mark === undefined ? { mark: "", rest: before } : { mark, rest: gapped.slice(0, gapped.length - mark.length) };
+};
+
+/**
+ * An amount of money as written in prose. The mark is the currency written before the number ($, US$); the suffix is what is
+ * written after it: the magnitude and the mark inside the quantity (百万円 of 96百万円), or up to two words of magnitude or
+ * currency (million, million yen). Both are compared as written (NFKC, lower case), so US$ and $ differ, and so do 百万円 and
+ * 億円. writtenStart and writtenEnd are where the whole amount, its marks and words included, stands.
+ */
+export type ProseFigure = Figure & { readonly mark: string; readonly suffix: string; readonly writtenStart: number; readonly writtenEnd: number };
+
+/** Up to two words of magnitude or currency after the quantity, and where they end. */
+const wordsAfter = (after: string, words: AmountWords): { readonly named: string; readonly length: number } => {
+  const units = [...words.multipliers, ...words.after].map((word) => word.toLowerCase());
+  const found = WORDS_AFTER.exec(after);
+  const [first = "", second = ""] = [found?.[1] ?? "", found?.[2] ?? ""];
+  if (found === null || !units.includes(first.toLowerCase())) return { named: "", length: 0 };
+  if (!units.includes(second.toLowerCase())) return { named: first, length: after.indexOf(first) + first.length };
+  return { named: `${first} ${second}`, length: found[0].length };
+};
+
+/** What a piece of text holds: amounts of money, percentages, and the other numbers (years, counts), by where they start. */
+export type ProseValues = { readonly figures: readonly ProseFigure[]; readonly rates: readonly WrittenRate[]; readonly others: readonly number[] };
+
+type ProseNumber = { readonly figure: ProseFigure } | { readonly rate: WrittenRate } | { readonly other: number };
+
+type NumberRead = { readonly start: number; readonly value: number; readonly decimals: number };
+
+const figureOf = (text: string, offset: number, match: RegExpExecArray, quantity: ProseQuantity, words: AmountWords): ProseFigure => {
+  const { mark, rest } = markBefore(text.slice(0, match.index), words.before);
+  const [end, quantityEnd] = [match.index + match[0].length, quantity.end - offset];
+  const after = wordsAfter(text.slice(quantityEnd), words);
+  const [mine, suffix] = [keyOf(mark), keyOf(`${text.slice(end, quantityEnd)} ${after.named}`)];
+  const decimals = match[2] ?? "";
+  const written = { writtenStart: offset + (mark === "" ? match.index : rest.length), writtenEnd: offset + quantityEnd + after.length };
+  const value = numberOf(match[1] ?? "", decimals);
+  return { start: offset + match.index, value, step: DECIMAL_BASE ** -decimals.length, unit: `${mine}|${suffix}`, mark: mine, suffix, ...written };
+};
+
+const proseNumber = (text: string, offset: number, match: RegExpExecArray, quantities: readonly ProseQuantity[], words: AmountWords): ProseNumber[] => {
+  if (NEGATIVE_BEFORE.test(markBefore(text.slice(0, match.index), words.before).rest)) return [];
+  const decimals = match[2] ?? "";
+  const read: NumberRead = { start: offset + match.index, value: numberOf(match[1] ?? "", decimals), decimals: decimals.length };
+  const quantity = quantities.find((entry) => entry.start === read.start);
+  if (quantity === undefined) return [{ other: read.start }];
+  if (words.percentUnits.includes(quantity.unit)) return [{ rate: read }];
+  if (![...words.before, ...words.after].includes(quantity.unit)) return [{ other: read.start }];
+  return [{ figure: figureOf(text, offset, match, quantity, words) }];
+};
+
+/**
+ * The numbers of a piece of text, read with the tree's quantities (offset is where the text starts in the document, and the
+ * quantities are in the same coordinates). A quantity in a currency is an amount of money and one in a percent unit a
+ * percentage; any other number (a count, a year, the first of a range) is kept only by where it starts. Signed numbers (-5,
+ * ▲5, -$5) are not read at all.
+ */
+export const proseValues = (text: string, offset: number, quantities: readonly ProseQuantity[], words: AmountWords): ProseValues => {
+  const numbers = [...text.matchAll(PROSE_NUMBER)].flatMap((match) => proseNumber(text, offset, match, quantities, words));
+  return {
+    figures: numbers.flatMap((number) => ("figure" in number ? [number.figure] : [])),
+    rates: numbers.flatMap((number) => ("rate" in number ? [number.rate] : [])),
+    others: numbers.flatMap((number) => ("other" in number ? [number.other] : [])),
+  };
+};
+
+/** A word of the lexicons found in a sentence. */
+export type LabelHit = { readonly start: number; readonly end: number } & ({ readonly label: RatioLabel } | { readonly term: string });
+
+/** What one sentence holds: where it ends, the words found in it, and its numbers. */
+export type RatioSentence = Omit<ProseValues, "figures"> & {
+  readonly figures: readonly Figure[];
+  readonly end: number;
+  readonly hits: readonly LabelHit[];
+};
+
+/** How far after its word a value may start (「営業利益は」, "net sales of", "an operating margin of"). */
+const MAX_GAP = 16;
+
+type Value = { readonly start: number } & ({ readonly figure: Figure } | { readonly rate: WrittenRate } | { readonly other: true });
+
+const valuesOf = (sentence: RatioSentence): Value[] => [
+  ...sentence.figures.map((figure) => ({ start: figure.start, figure })),
+  ...sentence.rates.map((rate) => ({ start: rate.start, rate })),
+  ...sentence.others.map((start): Value => ({ start, other: true })),
+];
+
+/**
+ * The value of a word: the only number between it and the next word of the lexicons (or the end of the sentence), close to
+ * it. Two numbers there (「前期の84百万円から96百万円に」, "in 2026 was $198 million") leave it unknown.
+ */
+const valueAfter = (hit: LabelHit, sentence: RatioSentence): Value | undefined => {
+  const until = Math.min(sentence.end, ...sentence.hits.filter((other) => other.start >= hit.end).map((other) => other.start));
+  const between = valuesOf(sentence).filter((value) => value.start >= hit.end && value.start < until);
+  const only = between.length === 1 ? between[0] : undefined;
+  return only !== undefined && only.start - hit.end <= MAX_GAP ? only : undefined;
+};
+
+const termHits = (sentence: RatioSentence, name: string): LabelHit[] => sentence.hits.filter((hit) => "term" in hit && hit.term === name);
+
+const figureAfter = (hits: readonly LabelHit[], sentence: RatioSentence): Figure | undefined => {
+  const hit = hits.length === 1 ? hits[0] : undefined;
+  const value = hit === undefined ? undefined : valueAfter(hit, sentence);
+  return value !== undefined && "figure" in value ? value.figure : undefined;
+};
+
+/**
+ * One sentence that names a ratio, its numerator and its denominator, each once, each with its value right after it
+ * (「営業利益は96百万円、売上高は1,320百万円で、営業利益率は7.3%」). Any other shape is not read.
+ */
+export const sentenceRatioMismatch = (sentence: RatioSentence): RatioIssue | undefined => {
+  const ratios = sentence.hits.filter((hit) => "label" in hit);
+  const ratio = ratios.length === 1 ? ratios[0] : undefined;
+  if (ratio === undefined || !("label" in ratio)) return undefined;
+  const value = valueAfter(ratio, sentence);
+  const numerator = figureAfter(termHits(sentence, ratio.label.numerator), sentence);
+  const denominator = figureAfter(termHits(sentence, ratio.label.denominator), sentence);
+  if (value === undefined || !("rate" in value) || numerator === undefined || denominator === undefined) return undefined;
+  const computed = ratioDisagreement(value.rate, numerator, denominator);
+  return computed === undefined
+    ? undefined
+    : { offset: value.start, values: { written: shown(value.rate.value, value.rate.decimals), computed, ratio: ratio.label.pattern } };
+};

package/src/structure/reference-flags.ts

@@ -0,0 +1,156 @@
+// reference-flag-mismatch: a row of a lab or checkup results table whose flag (H, L, 高, 低, 基準内, Normal) says the opposite of
+// where its value stands against the reference range on the same row. The column headings, the flags and the bound marks come
+// from the lexicons (lab-result-column with reference-column-heading, reference-flag, range-band-word, reference-bound-mark). Pure.
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { labColumnsOf, type LabColumnWord } from "./lab-columns.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { parseBand, type Band, type BandWords, type Bound } from "./range-bands.ts";
+
+/** What a flag says: above the range, below it, inside it, or outside it on either side (基準外, *). */
+export type FlagMeaning = "high" | "low" | "normal" | "outside";
+
+export type ReferenceWords = {
+  readonly headings: readonly LabColumnWord[];
+  readonly flags: readonly { readonly pattern: string; readonly meaning: FlagMeaning }[];
+  /** How a range is read: range-band-word with the reference marks (≤, >), and no units (the row's own unit is taken out first). */
+  readonly band: BandWords;
+};
+
+export type Position = "below" | "inside" | "above";
+
+/**
+ * "inside": flagged high, low or outside although inside the range. "outside": flagged normal although outside it. "below": flagged
+ * high although below the range; "above": flagged low although above it.
+ */
+export type FlagSlipKind = "inside" | "outside" | "below" | "above";
+
+export type FlagSlip = {
+  readonly kind: FlagSlipKind;
+  readonly item: string;
+  readonly value: string;
+  readonly range: string;
+  readonly flag: Cell;
+};
+
+/** A result cell: one number and what follows it (its unit, possibly nothing). */
+export type ReadValue = { readonly number: number; readonly unit: string };
+
+const DIGITS = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?/u;
+const STARTS_NUMERIC = /^[\d.,]/u;
+/** A unit has no figure and no note: 1.2/1, 88 (fasting) and 3.5 x10^4/μL are not a number and its unit. */
+const NOT_A_UNIT = /[\d()[\]]/u;
+const NOTE_OPEN = /[([]/u;
+/** A unit is a whole word when no Latin or Greek letter runs on from it: cm in 90 cm未満, not the l of less. */
+const LETTER = /[\p{Script=Latin}\p{Script=Greek}]/u;
+const SPACES = /\s+/gu;
+
+const normalized = (text: string): string => withoutEdgeMarks(text.normalize("NFKC").toLowerCase().replace(SPACES, " ").trim());
+
+/** The number of a result cell and the unit after it; undefined when the cell is not a plain number (<0.5, 陰性, —). */
+export const valueOf = (text: string): ReadValue | undefined => {
+  const plain = normalized(text);
+  const digits = DIGITS.exec(plain)?.[0];
+  if (digits === undefined) return undefined;
+  const unit = plain.slice(digits.length).trim();
+  if (STARTS_NUMERIC.test(unit) || NOT_A_UNIT.test(unit)) return undefined;
+  return { number: Number(digits.replaceAll(",", "")), unit };
+};
+
+const isLetterAt = (text: string, index: number): boolean => LETTER.test(text.charAt(index));
+
+/** The text with every whole occurrence of the unit blanked out: mg/dL in "30〜149 mg/dL", not the l of "less". */
+const withoutUnit = (text: string, unit: string): string => {
+  if (unit === "") return text;
+  const at = text.indexOf(unit);
+  if (at === -1) return text;
+  const end = at + unit.length;
+  const whole = !(LETTER.test(unit.charAt(0)) && isLetterAt(text, at - 1)) && !(LETTER.test(unit.charAt(unit.length - 1)) && isLetterAt(text, end));
+  const head = text.slice(0, at) + (whole ? " " : unit);
+  return head + withoutUnit(text.slice(end), unit);
+};
+
+/**
+ * The reference range of a row, read once the row's unit is taken out: 30〜149 mg/dL, 79 U/L 以下, ≤79, below 102 cm. undefined
+ * when anything else is left (another unit, a range for men and one for women, a note), so a row in two units is not read.
+ */
+export const rangeOf = (text: string, unit: string, words: ReferenceWords): Band | undefined => {
+  const bare = withoutUnit(normalized(text), unit);
+  return NOTE_OPEN.test(bare) ? undefined : parseBand(bare, words.band);
+};
+
+/** A heading without the unit in brackets at its end: Result (mg/dL), 結果（mg/dL）. */
+const headingKeyOf = (heading: string): string => {
+  const key = normalized(heading);
+  const open = key.lastIndexOf("(");
+  return key.endsWith(")") && open > 0 ? key.slice(0, open).trim() : key;
+};
+
+/** A flag compared as written: emphasis marks dropped, unless the flag is only such a mark (*). */
+const flagKeyOf = (text: string): string => {
+  const plain = normalized(text);
+  return plain === "" ? text.normalize("NFKC").trim().toLowerCase() : plain;
+};
+
+/** What a flag cell says, by the flag lexicon; undefined for a flag chaff does not know (A, 要再検査, —). */
+export const flagOf = (text: string, words: ReferenceWords): FlagMeaning | undefined => {
+  const key = flagKeyOf(text);
+  return key === "" ? undefined : words.flags.find((flag) => flagKeyOf(flag.pattern) === key)?.meaning;
+};
+
+/**
+ * A two-sided range written with only a range mark (30〜149, 4.0–5.6) includes its ends: a reference interval names the lowest
+ * and the highest value counted as within it, so 149 against 30〜149 is inside. 未満, 超, under and < leave their end out.
+ */
+const belowLow = (value: number, low: Bound | undefined): boolean => low !== undefined && (low.kind === "exclusive" ? value <= low.value : value < low.value);
+const aboveHigh = (value: number, high: Bound | undefined): boolean =>
+  high !== undefined && (high.kind === "exclusive" ? value >= high.value : value > high.value);
+
+export const positionOf = (value: number, range: Band): Position => {
+  if (belowLow(value, range.low)) return "below";
+  return aboveHigh(value, range.high) ? "above" : "inside";
+};
+
+/** Whether a flag contradicts the value's place against its range, and how. */
+export const slipKindOf = (flag: FlagMeaning, position: Position): FlagSlipKind | undefined => {
+  if (position === "inside") return flag === "normal" ? undefined : "inside";
+  if (flag === "normal") return "outside";
+  if (flag === "high" && position === "below") return "below";
+  return flag === "low" && position === "above" ? "above" : undefined;
+};
+
+type Columns = { readonly result: number; readonly range: number; readonly flag: number };
+
+const COLUMNS = ["result", "range", "flag"] as const;
+
+/** The column of each kind, by its heading; undefined unless each kind names exactly one column. */
+export const columnsOf = (headings: readonly string[], words: ReferenceWords): Columns | undefined => {
+  const kinds = labColumnsOf(headings, words.headings, headingKeyOf);
+  const found = COLUMNS.map((column) => kinds.flatMap((kind, index) => (kind === column ? [index] : [])));
+  const [result, range, flag] = found.map((indexes) => (indexes.length === 1 ? indexes[0] : undefined));
+  return result === undefined || range === undefined || flag === undefined ? undefined : { result, range, flag };
+};
+
+const rowSlip = (row: Line, columns: Columns, words: ReferenceWords): FlagSlip[] => {
+  const cells = cellsOf(row);
+  const [valueCell, rangeCell, flagCell] = [cells[columns.result], cells[columns.range], cells[columns.flag]];
+  if (valueCell === undefined || rangeCell === undefined || flagCell === undefined) return [];
+  const flag = flagOf(flagCell.text, words);
+  const value = valueOf(valueCell.text);
+  const range = value === undefined ? undefined : rangeOf(rangeCell.text, value.unit, words);
+  if (flag === undefined || value === undefined || range === undefined) return [];
+  const kind = slipKindOf(flag, positionOf(value.number, range));
+  if (kind === undefined) return [];
+  const item = withoutEdgeMarks((cells[0]?.text ?? "").trim());
+  return [{ kind, item, value: valueCell.text.trim(), range: rangeCell.text.trim(), flag: flagCell }];
+};
+
+/** Every row of every results table of the text whose flag contradicts its value and reference range. */
+export const referenceFlagSlips = (text: string, words: ReferenceWords): FlagSlip[] =>
+  tablesOf(linesOf(text)).flatMap((table) => {
+    const columns = columnsOf(
+      cellsOf(table.header).map((cell) => cell.text),
+      words,
+    );
+    return columns === undefined ? [] : table.rows.flatMap((row) => rowSlip(row, columns, words));
+  });

package/src/structure/reference-number-repeated.ts

@@ -0,0 +1,57 @@
+// reference-number-repeated: in a table of separate items (expense lines, invoice lines), the same receipt, invoice or slip
+// number on two rows. The column is found by its heading words only (lexicon reference-column). Pure.
+import type { ChangeTable, TableCell } from "./change-rate-table.ts";
+import { plain } from "./change-rate-table.ts";
+
+/** The second row that carries a number, and the first row that already did (both as offsets into the source). */
+export type RepeatedReference = { readonly offset: number; readonly firstOffset: number; readonly number: string; readonly heading: string };
+
+/** A heading or a number compared without case, width or spaces: 「領収書 No.」 is 「領収書No.」, "t-0384" is "T-0384". */
+const keyOf = (text: string): string => plain(text).toLowerCase().replace(/\s+/gu, "");
+
+const DIGIT = /\d/u;
+
+/** The one column whose heading is a reference-number heading; undefined when none or several are. */
+export const referenceColumnOf = (headings: readonly string[], words: readonly string[]): number | undefined => {
+  const wanted = new Set(words.map(keyOf));
+  const indexes = headings.flatMap((heading, index) => (wanted.has(keyOf(heading)) ? [index] : []));
+  return indexes.length === 1 ? indexes[0] : undefined;
+};
+
+const offsetOf = (cell: TableCell): number => cell.start + (cell.text.length - cell.text.trimStart().length);
+
+/** The cells of the column that hold a number: blank, a dash, 「なし」 and "N/A" hold no digit and are not numbers. */
+const numberCells = (rows: readonly (readonly TableCell[])[], column: number): TableCell[] =>
+  rows.flatMap((row) => {
+    const cell = row[column];
+    return cell !== undefined && DIGIT.test(plain(cell.text)) ? [cell] : [];
+  });
+
+/**
+ * A table's one repeated number. Only a table where exactly one number is written exactly twice is read: when several
+ * numbers repeat, or one three times, the rows are grouped by slip (the lines of one invoice, an invoice and its payment),
+ * and a repeat is how the table is meant to be read.
+ */
+const repeatOf = (cells: readonly TableCell[], heading: string): RepeatedReference[] => {
+  const byKey = cells.reduce((groups, cell) => {
+    const key = keyOf(cell.text);
+    return groups.set(key, [...(groups.get(key) ?? []), cell]);
+  }, new Map<string, TableCell[]>());
+  const repeated = [...byKey.values()].filter((group) => group.length > 1);
+  const [only] = repeated;
+  if (repeated.length !== 1 || only?.length !== 2) return [];
+  const [first, second] = only;
+  if (first === undefined || second === undefined) return [];
+  return [{ offset: offsetOf(second), firstOffset: offsetOf(first), number: plain(second.text), heading: plain(heading) }];
+};
+
+export const repeatedReferences = (tables: readonly ChangeTable[], words: readonly string[]): RepeatedReference[] =>
+  tables.flatMap((table) => {
+    const column = referenceColumnOf(
+      table.header.map((cell) => cell.text),
+      words,
+    );
+    const heading = column === undefined ? undefined : table.header[column];
+    if (column === undefined || heading === undefined) return [];
+    return repeatOf(numberCells(table.rows, column), heading.text);
+  });

package/src/structure/reference-unit.ts

@@ -0,0 +1,105 @@
+import type { StructureIssue } from "./issues.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { labColumnsOf, type LabColumn, type LabColumnWord } from "./lab-columns.ts";
+
+/**
+ * 検査結果の表で、結果の単位と基準値の単位が違う行（64 mmol/L と 40〜96 mg/dL）。結果・基準値・単位の列は見出しの語
+ * （lab-result-column と reference-unit-column）で見つけ、単位は語彙表 reference-unit で読む。group が同じ単位
+ * （mg/dL と mg/dl、×10⁴/µL と 万/µL）は同じ単位。升に単位が無ければ、列の見出しの単位、次にその行の単位の列を使う。どちらかの単位が読めなければ比べない。Pure.
+ */
+export type UnitWord = { readonly pattern: string; readonly unit: string };
+type ColumnRole = Exclude<LabColumn, "flag">;
+export type ReferenceUnitWords = { readonly units: readonly UnitWord[]; readonly columns: readonly LabColumnWord[] };
+
+type UnitsIn = (text: string) => ReadonlySet<string>;
+type Column = { readonly index: number; readonly role: ColumnRole; readonly units: ReadonlySet<string> };
+
+const NO_UNITS: ReadonlySet<string> = new Set();
+const DIGIT = /\d/u;
+const BRACKET_OPEN = /[([]/u;
+const SPACES = /\s+/gu;
+
+const fold = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+/** A unit written as a count per volume ("/µL") is not read right after a scale it does not include ("× 10⁴/µL" is not "/µL"). */
+const AFTER_SCALE = "(?<![×x]\\s*10\\^?\\d*\\s*)";
+
+const alternationOf = (patterns: readonly string[]): string => patterns.map(escapeRegExp).join("|");
+
+/** The units written in a text, by their group, never inside a longer word or unit ("mol/L" is not in "mmol/L", "mg" not in "mg/kg"). */
+export const unitMatcher = (units: readonly UnitWord[]): UnitsIn => {
+  const unitOf = new Map(units.map((word) => [fold(word.pattern), word.unit]));
+  if (unitOf.size === 0) return () => NO_UNITS;
+  const patterns = [...unitOf.keys()];
+  const perVolume = alternationOf(patterns.filter((pattern) => pattern.startsWith("/")));
+  const others = alternationOf(patterns.filter((pattern) => !pattern.startsWith("/")));
+  const alternation = [others, perVolume === "" ? "" : `${AFTER_SCALE}(?:${perVolume})`].filter((part) => part !== "").join("|");
+  const pattern = new RegExp(`(?<!\\p{L})(?:${alternation})(?![\\p{L}\\d/])`, "gu");
+  return (text) => new Set([...fold(text).matchAll(pattern)].map((match) => unitOf.get(match[0]) ?? match[0]));
+};
+
+/** Two units are said to disagree only when both are known and the two share none (a cell may give a conversion too). */
+export const unitsDisagree = (result: ReadonlySet<string>, range: ReadonlySet<string>): boolean =>
+  result.size > 0 && range.size > 0 && ![...result].some((unit) => range.has(unit));
+
+/** A heading without what it says in brackets ("結果（mg/dL）" is 結果, "Reference range (adult)" is reference range). */
+const headingKey = (text: string): string => {
+  const folded = fold(withoutEdgeMarks(text));
+  const bracket = folded.search(BRACKET_OPEN);
+  return (bracket === -1 ? folded : folded.slice(0, bracket)).replace(SPACES, " ").trim();
+};
+
+const columnsOf = (header: Line, words: ReferenceUnitWords, unitsIn: UnitsIn): Column[] => {
+  const cells = cellsOf(header);
+  const kinds = labColumnsOf(
+    cells.map((cell) => cell.text),
+    words.columns,
+    headingKey,
+  );
+  return cells.flatMap((cell, index) => {
+    const role = kinds[index];
+    return role === undefined || role === "flag" ? [] : [{ index, role, units: unitsIn(cell.text) }];
+  });
+};
+
+/** A cell's units: its own, else its column heading's, else the row's unit column. None when the cell holds no number. */
+const unitsOfCell = (cell: Cell | undefined, fallbacks: readonly ReadonlySet<string>[], unitsIn: UnitsIn): ReadonlySet<string> => {
+  if (cell === undefined || !DIGIT.test(fold(cell.text))) return NO_UNITS;
+  const own = unitsIn(cell.text);
+  return own.size > 0 ? own : (fallbacks.find((units) => units.size > 0) ?? NO_UNITS);
+};
+
+const issueAt = (cell: Cell, item: string, range: Cell): StructureIssue => ({
+  offset: cell.start + (cell.text.length - cell.text.trimStart().length),
+  values: { item, result: withoutEdgeMarks(cell.text), range: withoutEdgeMarks(range.text) },
+});
+
+/** Each result cell against each reference range cell (two ranges, for men and women, are two comparisons); one issue a result. */
+const rowIssues = (row: Line, columns: readonly Column[], unitsIn: UnitsIn): StructureIssue[] => {
+  const cells = cellsOf(row);
+  const unitColumn = columns.find((column) => column.role === "unit");
+  const rowUnits = unitColumn === undefined ? NO_UNITS : unitsIn(cells[unitColumn.index]?.text ?? "");
+  const unitsAt = (column: Column): ReadonlySet<string> => unitsOfCell(cells[column.index], [column.units, rowUnits], unitsIn);
+  const ranges = columns.filter((column) => column.role === "range");
+  const item = withoutEdgeMarks(cells[0]?.text ?? "");
+  return columns.flatMap((column) => {
+    const cell = cells[column.index];
+    if (column.role !== "result" || cell === undefined) return [];
+    const range = ranges.find((candidate) => unitsDisagree(unitsAt(column), unitsAt(candidate)));
+    const rangeCell = range === undefined ? undefined : cells[range.index];
+    return rangeCell === undefined ? [] : [issueAt(cell, item, rangeCell)];
+  });
+};
+
+/** The rows of every result table whose result is in another unit than its reference range. */
+export const referenceUnitMismatches = (source: string, words: ReferenceUnitWords): StructureIssue[] => {
+  const unitsIn = unitMatcher(words.units);
+  return tablesOf(linesOf(source)).flatMap((table) => {
+    const columns = columnsOf(table.header, words, unitsIn);
+    if (!columns.some((column) => column.role === "result") || !columns.some((column) => column.role === "range")) return [];
+    return table.rows.flatMap((row) => rowIssues(row, columns, unitsIn));
+  });
+};