chaffjs 0.31.0 → 0.33.0

package/src/structure/total.ts

@@ -1,5 +1,5 @@
 import type { StructureIssue } from "./issues.ts";
-import { runsOf, type Line } from "./runs.ts";
+import { runsOf, TABLE_RULE, type Line } from "./runs.ts";
 import { bareNumbersIn, CELL_SEPARATOR, NO_UNIT } from "./bare-numbers.ts";
 
 /**
@@ -32,7 +32,11 @@ const OPEN_PAREN_BEFORE = /[(（][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
 type Cell = { readonly column: number; readonly unit: string };
 /** cents が undefined の金額は、符号が決まらない。 */
 type Placed = Amount & Cell & { readonly cents: number | undefined };
-type Entry = { readonly label: boolean; readonly amounts: readonly Placed[] };
+/**
+ * spanTotal: 合計が足す期間の語を付けた合計の行（年間合計、Total for the year）。
+ * closing: 見出しが名指さない名詞を付けた、表を締める合計の行（項目の表の差引合計）。上の行の一部の和とも比べる。
+ */
+type Entry = { readonly label: boolean; readonly spanTotal: boolean; readonly closing?: boolean; readonly amounts: readonly Placed[] };
 
 export const columnOf = (source: string, line: Line, offset: number): number => source.slice(line.start, offset).split(CELL_SEPARATOR).length - 1;
 
@@ -65,11 +69,41 @@ const centsOf = (source: string, line: Line, amount: Amount): number | undefined
   return Math.round(amount.value * CENTS) * (isNegative(source, line, amount) ? -1 : 1);
 };
 
-/** 行が合計の行か。語彙で決める判定は呼ぶ側が渡す。 */
-export type IsTotalLine = (text: string) => boolean;
+/** 行が合計の行か。語彙で決める判定は呼ぶ側が渡す。header は表の見出しの行（無ければ undefined）。 */
+export type IsTotalLine = (text: string, header: string | undefined) => boolean;
+
+/** source の中で start から始まる行のすぐ前の行。 */
+const lineBefore = (source: string, start: number): { readonly start: number; readonly text: string } | undefined => {
+  if (start === 0) return undefined;
+  const begin = source.lastIndexOf("\n", start - 2) + 1;
+  return { start: begin, text: source.slice(begin, start - 1) };
+};
+
+/** 表の行のすぐ上が区切りの行（| --- |）なら、そのすぐ上の見出しの行。続けて書いた次の表の見出しも、ここで行ごとに拾う。 */
+const headerAbove = (source: string, line: Line): string | undefined => {
+  const rule = lineBefore(source, line.start);
+  if (line.kind !== "table" || rule === undefined || !TABLE_RULE.test(rule.text)) return undefined;
+  const header = lineBefore(source, rule.start);
+  return header?.text.includes("|") === true ? header.text : undefined;
+};
+
+/** 一つの並びに続けて書いた表を、見出しごとに分ける。下の表の合計に、上の表の行を足さないため。 */
+const tablesIn = (source: string, run: readonly Line[]): Line[][] =>
+  run.reduce<Line[][]>((tables, line, index) => {
+    const current = tables.at(-1);
+    if (current === undefined || (index > 0 && headerAbove(source, line) !== undefined)) tables.push([line]);
+    else current.push(line);
+    return tables;
+  }, []);
 
-const entryOf = (source: string, line: Line, amounts: readonly Amount[], isTotal: IsTotalLine): Entry => ({
-  label: isTotal(source.slice(line.start, line.end)),
+/** 行が、合計が足す期間の語を付けた合計の行か（年間合計、Total for the year）。 */
+export type IsSpanTotal = (text: string) => boolean;
+
+type LineKinds = { readonly isTotal: (text: string) => boolean; readonly isSpanTotal: IsSpanTotal };
+
+const entryOf = (source: string, line: Line, amounts: readonly Amount[], kinds: LineKinds): Entry => ({
+  label: kinds.isTotal(source.slice(line.start, line.end)),
+  spanTotal: kinds.isSpanTotal(source.slice(line.start, line.end)),
   amounts: amounts
     .filter((amount) => amount.offset >= line.start && amount.offset <= line.end)
     .map((amount) => ({ ...amount, column: columnOf(source, line, amount.offset), cents: centsOf(source, line, amount) })),
@@ -124,6 +158,16 @@ const candidateSums = (above: RowsAbove): number[] => {
   return [sumOf(above.parts), sumOf(above.sinceLast), ...(last === undefined ? [] : [last + sumOf(above.sinceLast)])];
 };
 
+/**
+ * 表を締める合計の行の、ほかの足し方: 下から続けた項目の和（支給の行の下に控除の行を並べた表の控除合計）と、
+ * その上の項目の和からそれを引いた額（同じ表の差し引いた後の額）。
+ */
+const blockSums = (parts: readonly number[]): number[] =>
+  parts.flatMap((_, start) => {
+    const below = sumOf(parts.slice(start));
+    return start === 0 ? [below] : [below, sumOf(parts.slice(0, start)) - below];
+  });
+
 /** 項目が無く小計だけが並ぶ表は、小計の和。 */
 const reportedSum = (above: RowsAbove): number => (above.parts.length === 0 ? sumOf(above.totals) : (above.totals.at(-1) ?? 0) + sumOf(above.sinceLast));
 
@@ -203,6 +247,13 @@ const measuredMismatch = (source: string, total: Placed, scale: number, sums: re
   return [{ offset: total.offset, values: { written: number, sum: `${sum}${unitAfterNumber(number, total.unit)}` } }];
 };
 
+/** 一年の中の期間の数（四半期、月、週）。期間の合計が和のちょうどこの倍なら、内訳を一年に直した額と読む。二倍は書き誤りでも起きるので入れない。 */
+const SPAN_MULTIPLES: readonly number[] = [4, 12, 52];
+
+/** 書いた合計が、どれかの足し方の和を一年に直した額か（月額の内訳に年間合計）。 */
+const isSpanMultiple = (writtenCents: number, sums: readonly number[]): boolean =>
+  sums.some((sum) => SPAN_MULTIPLES.some((multiple) => sum !== 0 && writtenCents === sum * multiple));
+
 const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue[] =>
   entries.flatMap((entry, index) => {
     if (!entry.label) return [];
@@ -210,17 +261,75 @@ const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue
       const writtenCents = valueIn(entry, total);
       const above = windowAbove(entries.slice(0, index), total);
       if (typeof writtenCents !== "number" || above === undefined || !enoughRows(above) || !readsAsSum(total, writtenCents, above)) return [];
-      if (total.scale !== undefined) return measuredMismatch(source, total, total.scale, candidateSums(above), reportedSum(above));
-      if (candidateSums(above).includes(writtenCents)) return [];
+      const sums = entry.closing === true ? [...candidateSums(above), ...blockSums(above.parts)] : candidateSums(above);
+      if (entry.spanTotal && isSpanMultiple(writtenCents, sums)) return [];
+      if (total.scale !== undefined) return measuredMismatch(source, total, total.scale, sums, reportedSum(above));
+      if (sums.includes(writtenCents)) return [];
       return [{ offset: total.offset, values: shownAmounts(source, total, reportedSum(above)) }];
     });
   });
 
-export const totalMismatches = (source: string, amounts: readonly Amount[], isTotal: IsTotalLine): StructureIssue[] =>
+/**
+ * 表を締める合計の行を読む語彙。isListed: 見出しが名指さなくても上の行の和と読める合計か（差引合計、Total deductions）。
+ * isTotalLike: 合計のような行か（合計の行、支給合計、総支給額）。header は表の見出しの行。
+ */
+export type ClosingTotal = {
+  readonly isListed: (text: string) => boolean;
+  readonly isTotalLike: (text: string, header: string) => boolean;
+};
+
+/** 表の行の金額が、見出しの列（最初の升）のほかに一つの列だけにあり、どの行にも一つまでか。 */
+const oneAmountColumn = (source: string, table: readonly Line[], entries: readonly Entry[]): boolean => {
+  const valuesOf = (line: Line, entry: Entry): Placed[] => {
+    const labelColumn = source.slice(line.start, line.end).trimStart().startsWith("|") ? 1 : 0;
+    return entry.amounts.filter((amount) => amount.column > labelColumn);
+  };
+  const rows = table.map((line, index) => {
+    const entry = entries[index];
+    return entry === undefined ? [] : valuesOf(line, entry);
+  });
+  return rows.every((values) => values.length <= 1) && new Set(rows.flat().map((amount) => amount.column)).size === 1;
+};
+
+/**
+ * 表の最後の行が、表を締める合計の行か。見出しのある表で、最後の行が isListed の合計で、上に合計のような行が一つも無く、
+ * 金額の列が一つのときだけ。上に支給の合計や総支給額があれば、合計が表のどこからどこまでの和か決まらないので読まない。
+ */
+const closesTable = (source: string, table: readonly Line[], entries: readonly Entry[], header: string | undefined, closing: ClosingTotal): boolean => {
+  const texts = table.map((line) => source.slice(line.start, line.end));
+  const last = entries.at(-1);
+  const lastText = texts.at(-1);
+  if (header === undefined || last === undefined || lastText === undefined || last.label || !closing.isListed(lastText)) return false;
+  return !texts.slice(0, -1).some((text) => closing.isTotalLike(text, header)) && oneAmountColumn(source, table, entries);
+};
+
+/** 一つの表（見出しの下の行）の合計。名詞の付いた合計の行は、その表の見出しで読む。 */
+const tableMismatches = (
+  source: string,
+  table: readonly Line[],
+  amounts: readonly Amount[],
+  isTotal: IsTotalLine,
+  isSpanTotal: IsSpanTotal,
+  closing: ClosingTotal | undefined,
+): StructureIssue[] => {
+  const header = table[0] === undefined ? undefined : headerAbove(source, table[0]);
+  const kinds = { isTotal: (text: string): boolean => isTotal(text, header), isSpanTotal };
+  const entries = table.map((line) => entryOf(source, line, amounts, kinds));
+  if (closing === undefined || !closesTable(source, table, entries, header, closing)) return mismatchesIn(source, entries);
+  return mismatchesIn(
+    source,
+    entries.map((entry, index) => (index === entries.length - 1 ? { ...entry, label: true, closing: true } : entry)),
+  );
+};
+
+export const totalMismatches = (
+  source: string,
+  amounts: readonly Amount[],
+  isTotal: IsTotalLine,
+  isSpanTotal: IsSpanTotal = () => false,
+  closing?: ClosingTotal,
+): StructureIssue[] =>
   runsOf(source).flatMap((run) => {
     const inRun = [...amounts, ...bareNumbersIn(source, run)];
-    return mismatchesIn(
-      source,
-      run.map((line) => entryOf(source, line, inRun, isTotal)),
-    );
+    return tablesIn(source, run).flatMap((table) => tableMismatches(source, table, inRun, isTotal, isSpanTotal, closing));
   });

package/src/structure/variance-table.ts

@@ -0,0 +1,167 @@
+// variance-mismatch: a budget-versus-actual table whose variance cell is not the actual less the budget, or the budget less
+// the actual, whichever the table's other rows follow. Which heading names which column is data (lexicon variance-column);
+// the cells are read with change-rate-table's readers. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf } from "./order-quantity.ts";
+
+export type VarianceRole = "rate" | "variance" | "budget" | "actual";
+export type VarianceWord = { readonly pattern: string; readonly role: VarianceRole };
+export type VarianceWords = {
+  readonly columns: readonly VarianceWord[];
+  /** Words of magnitude (千, million): an amount written in them is rounded. */
+  readonly multipliers: readonly string[];
+};
+
+/** Rate words first (増減率 holds 増減, 予算比率 holds 予算), then the variance (予算比 holds 予算). */
+const ROLE_ORDER: readonly VarianceRole[] = ["rate", "variance", "budget", "actual"];
+const NEGATIVE_MARKS: ReadonlySet<string> = new Set(["-", "−", "▲", "△"]);
+/** A negative written in brackets: ($20.00), $(20.00), (6,000)円. */
+const BRACKETED = /^([^()\d]*)\(([^()]*)\)([^()\d]*)$/u;
+/** The mark of a negative or positive: △6,000円, ▲6,000, -$20.00, $-20.00, +4,680円. */
+const SIGN = /[△▲\-−+]/u;
+const SIGN_OR_BRACKET = /[△▲\-−+()]/u;
+const DIGIT_OR_MARK = /[\d△▲\-−+()]/u;
+const HALF = 0.5;
+
+type Columns = { readonly budget: number; readonly actual: number; readonly variance: number };
+type Amount = { readonly value: number; readonly step: number; readonly marks: string };
+type Variance = Amount & { readonly written: string };
+
+/** The heading's role; none when it names both the budget and the actual and no variance or rate (Budget / Actual). */
+const roleOf = (heading: string, words: readonly VarianceWord[]): VarianceRole | undefined => {
+  const key = plain(heading).toLowerCase();
+  const named = ROLE_ORDER.filter((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+  const [first] = named;
+  return first === "budget" && named.includes("actual") ? undefined : first;
+};
+
+/** The one budget, actual and variance column the headings name; undefined when any is missing or named twice. */
+export const varianceColumnsOf = (headings: readonly string[], words: readonly VarianceWord[]): Columns | undefined => {
+  const roles = headings.map((heading) => roleOf(heading, words));
+  const only = (role: VarianceRole): number | undefined => {
+    const indexes = roles.flatMap((found, index) => (found === role ? [index] : []));
+    return indexes.length === 1 ? indexes[0] : undefined;
+  };
+  const [budget, actual, variance] = [only("budget"), only("actual"), only("variance")];
+  return budget === undefined || actual === undefined || variance === undefined ? undefined : { budget, actual, variance };
+};
+
+/** The signed amount a variance cell writes: △, ▲, −, - or brackets for a negative; undefined when it is not an amount (—, 1.2%). */
+export const signedIn = (text: string): Amount | undefined => {
+  const cell = plain(text);
+  const bracket = BRACKETED.exec(cell);
+  if (bracket !== null) {
+    const inner = valueIn(`${bracket[1] ?? ""}${bracket[2] ?? ""}${bracket[3] ?? ""}`);
+    return inner === undefined ? undefined : { ...inner, value: -inner.value };
+  }
+  const at = cell.search(SIGN);
+  if (at < 0) return valueIn(cell);
+  const [before, mark, after] = [cell.slice(0, at), cell.charAt(at), cell.slice(at + 1)];
+  if (DIGIT_OR_MARK.test(before) || SIGN_OR_BRACKET.test(after)) return undefined;
+  const inner = valueIn(`${before.trimEnd()}${after.trimStart()}`);
+  if (inner === undefined) return undefined;
+  return NEGATIVE_MARKS.has(mark) ? { ...inner, value: -inner.value } : inner;
+};
+
+/** A mark of currency and no word of magnitude: the amounts are exact. A bare number or 千円, $ million may be rounded. */
+const isRounded = (marks: string, multipliers: readonly string[]): boolean =>
+  marks === "|" || multipliers.some((word) => marks.toLowerCase().includes(word.toLowerCase()));
+
+type Row = {
+  readonly cell: TableCell;
+  readonly label: string;
+  readonly variance: Variance;
+  /** actual − budget */
+  readonly difference: number;
+  readonly gap: number;
+};
+
+/** How far a written variance may be from the difference: rounded amounts by one step of the coarsest last digit. */
+const gapOf = (amounts: readonly Amount[], rounded: boolean): number => {
+  const steps = amounts.map((amount) => amount.step);
+  const [finest, coarsest] = [Math.min(...steps), Math.max(...steps)];
+  return rounded ? coarsest + HALF * finest : HALF * finest;
+};
+
+const rowOf = (row: readonly TableCell[], columns: Columns, words: VarianceWords): Row | undefined => {
+  const [budgetCell, actualCell, cell] = [row[columns.budget], row[columns.actual], row[columns.variance]];
+  const budget = budgetCell === undefined ? undefined : valueIn(budgetCell.text);
+  const actual = actualCell === undefined ? undefined : valueIn(actualCell.text);
+  const variance = cell === undefined ? undefined : signedIn(cell.text);
+  if (cell === undefined || budget === undefined || actual === undefined || variance === undefined) return undefined;
+  if (budget.marks !== actual.marks || (variance.marks !== budget.marks && variance.marks !== "|")) return undefined;
+  const gap = gapOf([budget, actual, variance], isRounded(budget.marks, words.multipliers));
+  return { cell, label: plain(row[0]?.text ?? ""), variance: { ...variance, written: plain(cell.text) }, difference: actual.value - budget.value, gap };
+};
+
+type Convention = 1 | -1;
+const CONVENTIONS: readonly Convention[] = [1, -1];
+
+const opposite = (convention: Convention): Convention => (convention === 1 ? -1 : 1);
+
+const follows = (row: Row, convention: Convention): boolean => Math.abs(row.variance.value - convention * row.difference) <= row.gap;
+
+/** Rows whose variance is the same under both conventions (a zero difference) say nothing about which one the table uses. */
+const votesFor = (rows: readonly Row[], convention: Convention): number =>
+  rows.filter((row) => follows(row, convention) && !follows(row, opposite(convention))).length;
+
+/**
+ * The convention most rows follow (1: actual − budget, -1: budget − actual); undefined on a tie. A row following the
+ * other convention is a sign slip only when it is the one such row: two or more are a convention the writer chose.
+ */
+const conventionOf = (rows: readonly Row[]): { readonly convention: Convention; readonly others: number } | undefined => {
+  const [forward, backward] = CONVENTIONS.map((convention) => votesFor(rows, convention));
+  if (forward === backward || forward === undefined || backward === undefined) return undefined;
+  return forward > backward ? { convention: 1, others: backward } : { convention: -1, others: forward };
+};
+
+const NUMBER = /\d[\d,]*(?:\.\d+)?/u;
+const SIGN_MARKS = /[△▲\-−+()]/gu;
+
+const sameSign = (value: number, expected: number): boolean => value < 0 === expected < 0;
+
+/** The expected variance written the way a cell of the same sign in the table is (△6,900円, ($10.80)), else like the written one. */
+const shown = (expected: number, row: Row, rows: readonly Row[]): string => {
+  const like = rows.find((other) => other.variance.marks === row.variance.marks && sameSign(other.variance.value, expected)) ?? row;
+  const decimals = Math.max(0, -Math.round(Math.log10(row.variance.step)));
+  const number = Math.abs(expected).toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+    useGrouping: like.variance.written.includes(","),
+  });
+  const filled = like.variance.written.replace(NUMBER, number);
+  if (sameSign(like.variance.value, expected)) return filled;
+  const unsigned = filled.replace(SIGN_MARKS, "").trim();
+  return expected < 0 ? `-${unsigned}` : unsigned;
+};
+
+const tableIssues = (rows: readonly Row[], fallback: Convention | undefined): StructureIssue[] => {
+  const silent = votesFor(rows, 1) === 0 && votesFor(rows, -1) === 0;
+  const decided = silent && fallback !== undefined ? { convention: fallback, others: 0 } : conventionOf(rows);
+  if (decided === undefined) return [];
+  const { convention, others } = decided;
+  return rows.flatMap((row) => {
+    if (follows(row, convention) || (follows(row, opposite(convention)) && others > 1)) return [];
+    const expected = convention * row.difference;
+    return [{ offset: offsetOf(row.cell), values: { item: row.label, written: row.variance.written, expected: shown(expected, row, rows) } }];
+  });
+};
+
+/**
+ * Each row of a budget / actual / variance table whose variance is neither rounding away from the actual less the budget
+ * nor, in a table whose rows take the budget less the actual, from that. The convention is the one most of the table's
+ * rows follow; a table where no row tells takes the document's, and one where the rows split evenly is left alone.
+ */
+export const varianceMismatches = (tables: readonly ChangeTable[], words: VarianceWords): StructureIssue[] => {
+  const read = tables.flatMap((table) => {
+    const columns = varianceColumnsOf(
+      table.header.map((cell) => cell.text),
+      words.columns,
+    );
+    if (columns === undefined) return [];
+    return [bodyRows(table).flatMap((row) => rowOf(row, columns, words) ?? [])];
+  });
+  const fallback = conventionOf(read.flat())?.convention;
+  return read.flatMap((rows) => tableIssues(rows, fallback));
+};

package/src/table-names.ts

@@ -1,6 +1,7 @@
 import { isNearWord, nameKey, type NameMention } from "./name-variants.ts";
 import type { TableCell, Token } from "./plugin.ts";
 import { withoutEdgeMarks } from "./facts/trim-marks.ts";
+import { NO_CHAR_READINGS, readingOfWords, type CharReadings } from "./name-char-reading.ts";
 
 // 表の升に書いた名前と、本文の名前の書き分け（本文は Sofia Mendes、担当者の表は Sofia Mendez）。表の升は品詞解析を通らないので、
 // 名前の形をした升だけを読み、本文で読めた名前と比べる。比べるのは姓と名のように二語以上の名前で、一語だけが違うときに限る。
@@ -22,20 +23,19 @@ const CJK_NAME = /^[\p{Script=Han}\p{Script=Katakana}ー々]+(?:[ \u3000][\p{Scr
 const SPACE = /[ \u3000]/u;
 const LOWER = /\p{Ll}/u;
 
-/** 範囲の中の語の読みをつないだもの。記号と空白の語は読まない。読めない語があれば無い。 */
-export const readingWithin = (tokens: readonly Token[], start: number, end: number): string | undefined => {
+/** 範囲の中の語の読みをつないだもの。記号と空白の語は読まない。読めない語があれば無い。charReadings は解析器が読めない名前の字の読み。 */
+export const readingWithin = (tokens: readonly Token[], start: number, end: number, charReadings = NO_CHAR_READINGS): string | undefined => {
   const words = tokens.filter((token) => token.span.start >= start && token.span.end <= end && token.pos !== "PUNCT" && token.surface.trim() !== "");
-  const readings = words.map((token) => token.reading);
-  return words.length > 0 && readings.every((reading) => reading !== undefined && reading !== "") ? readings.join("") : undefined;
+  return readingOfWords(words, charReadings);
 };
 
 /** 名前の形をした升。升の字の前後の空白と強調の印は名前の外。 */
-export const cellNamesIn = (cells: readonly TableCell[]): CellName[] =>
+export const cellNamesIn = (cells: readonly TableCell[], charReadings: CharReadings = NO_CHAR_READINGS): CellName[] =>
   cells.flatMap((cell) => {
     const surface = withoutEdgeMarks(cell.text.trim());
     if (!(LATIN_NAME.test(surface) && LOWER.test(surface)) && !CJK_NAME.test(surface)) return [];
     const offset = cell.start + cell.text.indexOf(surface);
-    return [{ surface, offset, words: surface.split(SPACE), reading: readingWithin(cell.tokens ?? [], offset, offset + surface.length) }];
+    return [{ surface, offset, words: surface.split(SPACE), reading: readingWithin(cell.tokens ?? [], offset, offset + surface.length, charReadings) }];
   });
 
 /**

package/src/unlabelled-references.ts

@@ -0,0 +1,83 @@
+// A document's own code (an item code, GP-0512) labelled once — after a label in the prose, or in a table under a label —
+// and written elsewhere, with no label, with two neighbours swapped (GP-0521). Pure: reads the document's text.
+import type { LexiconEntry } from "./plugin.ts";
+import { swapsNeighbours, withoutUrls } from "./phone-numbers.ts";
+import { linesOf } from "./structure/lines.ts";
+import { cellsOf, tablesOf, type Cell } from "./facts/table-facts.ts";
+import { withoutEdgeMarks } from "./facts/trim-marks.ts";
+import { charactersOf, MAX_CHARACTERS, MIN_DIGITS, REFERENCE_SHAPE, type ReferenceNumber, type ReferenceVariant } from "./reference-numbers.ts";
+
+const SEPARATOR = /[-‐−－]/u;
+const LATIN_LETTER = /[A-Z]/u;
+const DIGIT = /\d/gu;
+
+/** A code: letters, a hyphen and four digits or more (GP-0512). A plain number (48215, 2026-118) is never one. */
+const isCode = (written: string): boolean => {
+  const characters = charactersOf(written);
+  return (
+    SEPARATOR.test(written) && LATIN_LETTER.test(characters) && (characters.match(DIGIT)?.length ?? 0) >= MIN_DIGITS && characters.length <= MAX_CHARACTERS
+  );
+};
+
+const keyOf = (text: string): string => withoutEdgeMarks(text).normalize("NFKC").toLowerCase();
+
+/** The group of a cell that is a label and nothing else (| 品番 |, | Item code |). */
+const labelOfCell = (cell: Cell | undefined, labels: readonly LexiconEntry[]): string | undefined => {
+  if (cell === undefined) return undefined;
+  const entry = labels.find((label) => keyOf(label.pattern) === keyOf(cell.text));
+  return entry === undefined ? undefined : (entry.group ?? entry.pattern);
+};
+
+/** A cell holding one code and nothing else, as a reference number of the group. */
+const codeOfCell = (cell: Cell | undefined, group: string): ReferenceNumber[] => {
+  if (cell === undefined) return [];
+  const written = withoutEdgeMarks(cell.text);
+  if (!isCode(written) || [...written.matchAll(REFERENCE_SHAPE)].length !== 1) return [];
+  return [{ offset: cell.start + cell.text.indexOf(written), written, characters: charactersOf(written), label: group }];
+};
+
+/**
+ * The codes a table labels: in a row whose first cell is a label (| 品番 | GP-0512 |), and in a column whose heading is
+ * one (| 品番 | 品名 | over | GP-0512 | …). Pass the text with its tables (proseAndTablesOf).
+ */
+export const tableLabelledCodes = (text: string, labels: readonly LexiconEntry[]): ReferenceNumber[] =>
+  tablesOf(linesOf(text)).flatMap((table) => {
+    const headings = cellsOf(table.header).map((cell) => labelOfCell(cell, labels));
+    return table.rows.flatMap((row) => {
+      const cells = cellsOf(row);
+      const rowGroup = labelOfCell(cells[0], labels);
+      const byRow = rowGroup === undefined ? [] : codeOfCell(cells[1], rowGroup);
+      const byColumn = cells.flatMap((cell, index) => {
+        const group = headings[index];
+        return group === undefined ? [] : codeOfCell(cell, group);
+      });
+      return [...byRow, ...byColumn];
+    });
+  });
+
+/** The letters and digits of every code a cell holds. */
+const codesInCell = (cell: Cell): string[] =>
+  [...cell.text.matchAll(REFERENCE_SHAPE)].filter((match) => isCode(match[0])).map((match) => charactersOf(match[0]));
+
+/** Every code written anywhere in a table, its heading row too, labelled or not: a code a table lists is an item of its own, never a slip. */
+export const tableCodes = (text: string): Set<string> =>
+  new Set(tablesOf(linesOf(text)).flatMap((table) => [table.header, ...table.rows].flatMap((row) => cellsOf(row).flatMap(codesInCell))));
+
+/**
+ * Every code of the prose written with no label that is one labelled code with two neighbours swapped. Only when exactly
+ * one labelled code swaps to it, and when the writing is not itself a code the document labels or lists in a table: a
+ * catalog's AB-1234 and AB-1243 are two items.
+ */
+export const unlabelledVariants = (prose: string, labelled: readonly ReferenceNumber[], known: ReadonlySet<string>): ReferenceVariant[] => {
+  const labelledAt = new Set(labelled.map((number) => number.offset));
+  const anchors = [...new Map(labelled.map((number) => [number.characters, number])).values()];
+  return [...withoutUrls(prose).matchAll(REFERENCE_SHAPE)].flatMap((match) => {
+    if (labelledAt.has(match.index) || !isCode(match[0])) return [];
+    const characters = charactersOf(match[0]);
+    if (known.has(characters) || labelled.some((number) => number.characters === characters)) return [];
+    const swapped = anchors.filter((anchor) => swapsNeighbours(anchor.characters, characters));
+    const [other] = swapped;
+    if (swapped.length !== 1 || other === undefined) return [];
+    return [{ number: { offset: match.index, written: match[0], characters, label: other.label }, other }];
+  });
+};

package/src/vehicle-plates.ts

@@ -0,0 +1,142 @@
+// A vehicle's plate written two ways in one document (ひばり野 330 ね 48-15 and 48-75). Pure: reads the document's text; the
+// labels come from the reference-label lexicon and the plate's shapes from the vehicle-plate lexicon, each a pattern whose
+// named parts are the plate's parts. The part named serial is the one a slip changes; the others must be the same.
+import type { LexiconEntry } from "./plugin.ts";
+import { escapeRegExp } from "./orthography.ts";
+import { withoutUrls } from "./phone-numbers.ts";
+import type { ReferenceNumber } from "./reference-numbers.ts";
+import { boundedMatches } from "./custom/bounded-match.ts";
+
+/**
+ * A plate as written, in its shape's group. fixed is its parts but the serial; opensSentence whether its label opens its
+ * sentence (no word before it says whose plate it is, as 代車の does); onField whether its line holds only the label and the
+ * plate (登録番号：ひばり野 330 ね 48-15), the vehicle the document is about.
+ */
+export type VehiclePlate = ReferenceNumber & {
+  readonly fixed: string;
+  readonly serial: string;
+  readonly opensSentence: boolean;
+  readonly onField: boolean;
+};
+
+/** A plate that is the document's own with one character of its serial changed, and the document's own plate. */
+export type PlateVariant = { readonly number: VehiclePlate; readonly other: VehiclePlate };
+
+type LabelHit = { readonly start: number; readonly end: number };
+
+const SERIAL_PART = "serial";
+const PART_JOIN = "\u0000";
+const PLATE_GAP = /[\s\-‐−－・･.]/gu;
+/** Only spaces and a colon, comma or opening bracket between a label and its plate, and nothing alphanumeric right after it. */
+const BEFORE_PLATE = String.raw`^([\s:：,，、#＃(（「『[［]{0,4})`;
+const PLATE_END = String.raw`(?![0-9０-９A-Za-zＡ-Ｚａ-ｚ\-‐−－])`;
+const SENTENCE_END = /[。！？!?]|\.(?=\s)/u;
+const LATIN_START = /^[a-z]/u;
+const LETTER = /\p{Script=Latin}/u;
+const FLAGS = "u";
+
+/** Every place a label is written; a Latin label only as a whole word. */
+const labelHits = (text: string, labels: readonly LexiconEntry[]): LabelHit[] => {
+  const lowered = text.toLowerCase();
+  const isWhole = (label: string, at: number): boolean =>
+    !LATIN_START.test(label) || (!LETTER.test(lowered[at - 1] ?? "") && !LETTER.test(lowered[at + label.length] ?? ""));
+  return labels.flatMap((entry) => {
+    const label = entry.pattern.toLowerCase();
+    if (label === "") return [];
+    return [...lowered.matchAll(new RegExp(escapeRegExp(label), "gu"))]
+      .filter((match) => isWhole(label, match.index))
+      .map((match) => ({ start: match.index, end: match.index + label.length }));
+  });
+};
+
+const lineEnd = (text: string, offset: number): number => {
+  const end = text.indexOf("\n", offset);
+  return end === -1 ? text.length : end;
+};
+
+const plateCharacters = (written: string): string => written.normalize("NFKC").replaceAll(PLATE_GAP, "").toUpperCase();
+
+/** The parts of a plate but its serial, each evened out, so two plates of one vehicle's region, class and kana meet. */
+const fixedParts = (parts: Record<string, string | undefined>): string =>
+  Object.entries(parts)
+    .flatMap(([name, part]) => (name === SERIAL_PART || part === undefined ? [] : [plateCharacters(part)]))
+    .join(PART_JOIN);
+
+/** A shape's pattern read right after a label, or nothing when it is not a valid expression. */
+const compiledShape = (entry: LexiconEntry): RegExp | undefined => {
+  try {
+    return new RegExp(`${BEFORE_PLATE}(?:${entry.pattern})${PLATE_END}`, FLAGS);
+  } catch {
+    return undefined;
+  }
+};
+
+/** The plate a shape matched right after a label: matched is the label's separators and the plate. */
+const plateOf = (text: string, label: LabelHit, matched: string, shape: RegExp, group: string): VehiclePlate | undefined => {
+  const match = shape.exec(matched);
+  const serial = match?.groups?.[SERIAL_PART];
+  if (match === null || match.groups === undefined || serial === undefined) return undefined;
+  const offset = label.end + (match[1] ?? "").length;
+  const written = matched.slice((match[1] ?? "").length);
+  const lineStart = text.lastIndexOf("\n", label.start - 1) + 1;
+  const head = text.slice(lineStart, label.start);
+  const opensSentence = (head.split(SENTENCE_END).at(-1) ?? "").trim() === "";
+  const onField = head.trim() === "" && text.slice(offset + written.length, lineEnd(text, offset)).trim() === "";
+  return {
+    offset,
+    written,
+    characters: plateCharacters(written),
+    label: group,
+    fixed: fixedParts(match.groups),
+    serial: plateCharacters(serial),
+    opensSentence,
+    onField,
+  };
+};
+
+/**
+ * What one shape reads right after each label, in the labels' order. A shape comes from a lexicon a team may write, so it is
+ * matched with a time limit (boundedMatches), and one that is not a valid expression reads nothing.
+ */
+const readsOfShape = (text: string, hits: readonly LabelHit[], afters: readonly string[], entry: LexiconEntry): (VehiclePlate | undefined)[] => {
+  const shape = compiledShape(entry);
+  if (shape === undefined) return hits.map(() => undefined);
+  const matches = boundedMatches(shape.source, FLAGS, afters);
+  return hits.map((hit, index) => {
+    const matched = matches[index]?.[0];
+    return matched?.index === 0 ? plateOf(text, hit, matched.text, shape, entry.group ?? entry.pattern) : undefined;
+  });
+};
+
+/** The plates of a text, each right after a reference label in one of the plate shapes (the first that reads one wins). */
+export const labelledPlates = (source: string, labels: readonly LexiconEntry[], shapeEntries: readonly LexiconEntry[]): VehiclePlate[] => {
+  if (shapeEntries.length === 0) return [];
+  const text = withoutUrls(source);
+  // The longest label is read last, so the plate after 自動車登録番号 is read with it, not with 登録番号 inside it.
+  const hits = labelHits(text, labels).toSorted((a, b) => a.end - a.start - (b.end - b.start));
+  if (hits.length === 0) return [];
+  const afters = hits.map((hit) => text.slice(hit.end, lineEnd(text, hit.end)));
+  const readsByShape = shapeEntries.map((entry) => readsOfShape(text, hits, afters, entry));
+  const plates = hits.flatMap((_, index) => readsByShape.map((reads) => reads[index]).find((plate) => plate !== undefined) ?? []);
+  return [...new Map(plates.map((plate) => [plate.offset, plate])).values()].toSorted((a, b) => a.offset - b.offset);
+};
+
+/** Whether two serials of one length differ in one character only. */
+const oneCharacterApart = (a: string, b: string): boolean => a.length === b.length && [...a].filter((character, index) => character !== b[index]).length === 1;
+
+/**
+ * The writings of a plate that is the document's own with one character of its serial changed (48-15 and 48-75), the rest
+ * of the plate the same. Only when the document names one vehicle: its plate on a field line, one other plate and no third,
+ * the other never on a field line and its label always opening the sentence. Two different numbers one character apart are
+ * common, so nothing else is read.
+ */
+export const plateVariants = (plates: readonly VehiclePlate[]): PlateVariant[] => {
+  const distinct = new Set(plates.map((plate) => `${plate.label}${PART_JOIN}${plate.characters}`));
+  const fields = plates.filter((plate) => plate.onField);
+  const own = fields[0];
+  if (distinct.size !== 2 || own === undefined || fields.some((field) => field.characters !== own.characters)) return [];
+  const others = plates.filter((plate) => plate.characters !== own.characters);
+  const other = others[0];
+  if (other === undefined || other.label !== own.label || other.fixed !== own.fixed || !oneCharacterApart(other.serial, own.serial)) return [];
+  return others.every((plate) => plate.opensSentence) ? others.map((number) => ({ number, other: own })) : [];
+};

package/src/whole-word-runs.ts

@@ -0,0 +1,38 @@
+/** A word as the tokenizer gives it: what is written and where. */
+export type SpannedSurface = { readonly surface: string; readonly span: { readonly start: number; readonly end: number } };
+
+/** Where a listed word lies in the tokens (from the first token to the last, both included) and the word as written. */
+export type WholeWordRun = { readonly first: number; readonly last: number; readonly word: string };
+
+/** The listed words, as a set or keyed to what they map to. */
+export type ListedWords = ReadonlySet<string> | ReadonlyMap<string, string>;
+
+/** お + 嬢 + さま is the longest cut seen; a listed word is not looked for across more tokens than this. */
+export const MAX_WHOLE_WORD_PARTS = 3;
+
+const joinedSurface = (tokens: readonly SpannedSurface[], first: number, last: number): string =>
+  tokens
+    .slice(first, last + 1)
+    .map((token) => token.surface)
+    .join("");
+
+/** The longest listed word written by tokens from `first` on, each touching the one before. */
+const longestFrom = (tokens: readonly SpannedSurface[], first: number, words: ListedWords): WholeWordRun | undefined => {
+  const lasts = Array.from({ length: MAX_WHOLE_WORD_PARTS }, (_, extra) => first + extra).filter((last) => last < tokens.length);
+  const touching = lasts.filter((last) => tokens.slice(first + 1, last + 1).every((token, at) => tokens[first + at]?.span.end === token.span.start));
+  const written = touching.map((last) => ({ first, last, word: joinedSurface(tokens, first, last) }));
+  return written.filter(({ word }) => words.has(word)).at(-1);
+};
+
+/**
+ * The listed words in a sentence's tokens, each one run, however the tokenizer cut it: お客様 is one token and お客さま is お客 and
+ * さま, and the さま must not be read as the さま written after a name. Runs do not overlap; the earlier one wins.
+ */
+export const wholeWordRuns = (tokens: readonly SpannedSurface[], words: ListedWords): WholeWordRun[] =>
+  words.size === 0
+    ? []
+    : tokens.reduce<WholeWordRun[]>((runs, _, first) => {
+        if ((runs.at(-1)?.last ?? -1) >= first) return runs;
+        const run = longestFrom(tokens, first, words);
+        return run === undefined ? runs : [...runs, run];
+      }, []);