chaffjs 0.31.0 → 0.33.0

package/src/structure/labelled-date-order.ts

@@ -1,84 +1,100 @@
 import type { DatedPoint } from "./due-date.ts";
 import type { StructureIssue } from "./issues.ts";
-import { linesOf } from "./lines.ts";
-import { isTotalLabel } from "./total.ts";
+import type { Line } from "./lines.ts";
+import { labelPairsOf, pointsOutOfOrder, type OrderLabel, type PairWords, type PointOf } from "./labelled-order.ts";
+import { TABLE_ROW } from "./runs.ts";
+import { statedPeriod, type DateMention, type PeriodWords } from "./stated-period.ts";
 
 /**
  * Two labelled dates that must come in order: a line (or a list item, or a table's first column) starting with an
  * earlier-date word and one starting with a later-date word, each with one full date on it. A later date before the
  * first earlier date, and written near it, is out of order. A line with a passed word (期限切れ, overdue) reports on a
- * date rather than setting one and is not read. Pure.
+ * date rather than setting one and is not read. A span word (対象期間, Reporting period) labels a period, and the
+ * period's end is its date. Pure.
  */
-export type DateOrderWords = {
-  readonly earlier: readonly string[];
-  readonly later: readonly string[];
-  readonly passed: readonly string[];
-  /** How many lines from the earlier date a later date may be and still be read as the same record's. */
-  readonly maxLineGap: number;
+export type DateOrderWords = PairWords & {
+  /** The words whose line states a period rather than one date (labels), with the range signs and names to read it. */
+  readonly spans?: PeriodWords | undefined;
 };
 
-/** A labelled date: the word that labels it, as the lexicon writes it. */
-export type LabelledDate = { readonly label: string; readonly date: DatedPoint; readonly line: number };
+/** A date from the tree; end is where its text ends, needed only to read a period. */
+export type OrderDate = DatedPoint & { readonly end?: number | undefined };
+
+/** A labelled date: the word that labels it, as the lexicon writes it. span is set when the date ends a stated period. */
+export type LabelledDate = { readonly label: string; readonly date: DatedPoint; readonly line: number; readonly span: boolean };
 
 export type OutOfOrder = { readonly earlier: LabelledDate; readonly later: LabelledDate };
 
 const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
 
-type Read = LabelledDate & { readonly kind: "earlier" | "later" };
-
-const labelOf = (text: string, words: readonly string[]): string | undefined => words.find((word) => isTotalLabel(text, [word]));
+const mentionsOf = (dates: readonly OrderDate[]): DateMention[] => dates.flatMap((date) => (date.end === undefined ? [] : [{ ...date, end: date.end }]));
 
-const kindOf = (text: string, words: DateOrderWords): Pick<Read, "kind" | "label"> | undefined => {
-  const earlier = labelOf(text, words.earlier);
-  if (earlier !== undefined) return { kind: "earlier", label: earlier };
-  const later = labelOf(text, words.later);
-  return later === undefined ? undefined : { kind: "later", label: later };
+/**
+ * The end of the period a span word's line states (対象期間：2026年4月1日〜9月30日 ends 2026-09-30), with its year.
+ * A period without a year, or a line that states no period, gives undefined. tableOf gives the table the line is a row of
+ * (| 対象期間 | 2026年4月1日〜9月30日 |), read when the row is the table's only row labelled with any span word: a table with
+ * both Reporting period and Period covered rows lists periods. A row's label cell is the span word itself, so all of them are passed.
+ */
+export const periodEndOf = (
+  line: Line,
+  label: string,
+  dates: readonly OrderDate[],
+  spans: PeriodWords,
+  tableOf: () => readonly string[] = () => [],
+): DatedPoint | undefined => {
+  const labels = TABLE_ROW.test(line.text) ? spans.labels : [label];
+  const period = statedPeriod(line.text, line.start, mentionsOf(dates), { ...spans, labels }, tableOf);
+  return period === undefined || !FULL_DATE.test(period.end) ? undefined : { offset: line.start, value: period.end };
 };
 
-const labelledDates = (source: string, dates: readonly DatedPoint[], words: DateOrderWords): Read[] =>
-  linesOf(source).flatMap((line) => {
-    const passed = words.passed.some((word) => line.text.toLowerCase().includes(word.toLowerCase()));
-    const kind = passed ? undefined : kindOf(line.text, words);
-    const end = line.start + line.text.length;
-    const onLine = dates.filter((date) => date.offset >= line.start && date.offset <= end && FULL_DATE.test(date.value));
-    const [date] = onLine;
-    return kind === undefined || date === undefined || onLine.length > 1 ? [] : [{ ...kind, date, line: line.number }];
-  });
-
-export const datesOutOfOrder = (source: string, dates: readonly DatedPoint[], words: DateOrderWords): OutOfOrder[] => {
-  if (words.earlier.length === 0 || words.later.length === 0) return [];
-  const labelled = labelledDates(source, dates, words);
-  const earlier = labelled.find((entry) => entry.kind === "earlier");
-  if (earlier === undefined) return [];
-  return labelled
-    .filter((entry) => entry.kind === "later" && entry.date.value < earlier.date.value && Math.abs(entry.line - earlier.line) < words.maxLineGap)
-    .map((later) => ({ earlier, later }));
+const oneDateOf = (line: Line, dates: readonly OrderDate[]): DatedPoint | undefined => {
+  const end = line.start + line.text.length;
+  const onLine = dates.filter((date) => date.offset >= line.start && date.offset <= end && FULL_DATE.test(date.value));
+  return onLine.length === 1 ? onLine[0] : undefined;
 };
 
-/** A lexicon entry naming its pair (group) and its side: before for the earlier date, after for the later one. */
-export type OrderLabel = { readonly pattern: string; readonly group?: string | undefined; readonly position?: "before" | "after" | undefined };
+const dateOf =
+  (dates: readonly OrderDate[], spans: PeriodWords | undefined): PointOf =>
+  (line, label, tableOf) => {
+    if (spans === undefined || !spans.labels.includes(label)) {
+      const date = oneDateOf(line, dates);
+      return date === undefined ? undefined : { point: date, span: false };
+    }
+    const end = periodEndOf(line, label, dates, spans, tableOf);
+    return end === undefined ? undefined : { point: end, span: true };
+  };
 
-const groupsOf = (labels: readonly OrderLabel[]): string[] => [...new Set(labels.flatMap((label) => (label.group === undefined ? [] : [label.group])))];
+/**
+ * A later date before the first earlier date. When both sides are written more than once (a history listing one record
+ * per row, newest first), the later date must also be before the earlier date written closest to it: that is its own
+ * record's. A later date written once (an issue date below the records) belongs to the whole document and keeps the first.
+ */
+export const datesOutOfOrder = (source: string, dates: readonly OrderDate[], words: DateOrderWords): OutOfOrder[] =>
+  pointsOutOfOrder(source, words, dateOf(dates, words.spans)).map(({ earlier, later }) => ({
+    earlier: { label: earlier.label, date: earlier.point, line: earlier.line, span: earlier.span },
+    later: { label: later.label, date: later.point, line: later.line, span: later.span },
+  }));
 
-const sideOf = (labels: readonly OrderLabel[], group: string, position: "before" | "after"): string[] =>
-  labels.filter((label) => label.group === group && label.position === position).map((label) => label.pattern);
+/** An out-of-order pair; period is set when the earlier date is the end of a stated period. */
+export type PairedIssue = StructureIssue & { readonly period: boolean };
 
 /**
  * Every pair of a dated-pair lexicon: the entries of one group with position before label the earlier date, those with
- * position after the later one. The values name both labels, so the message can quote them.
+ * position after the later one. The values name both labels, so the message can quote them. The issue is on whichever
+ * of the two dates is written second: a reader meets the contradiction there (a cancellation deadline below check-in).
  */
 export const pairedDatesOutOfOrder = (
   source: string,
-  dates: readonly DatedPoint[],
+  dates: readonly OrderDate[],
   labels: readonly OrderLabel[],
   passed: readonly string[],
   maxLineGap: number,
-): StructureIssue[] =>
-  groupsOf(labels).flatMap((group) =>
-    datesOutOfOrder(source, dates, { earlier: sideOf(labels, group, "before"), later: sideOf(labels, group, "after"), passed, maxLineGap }).map(
-      ({ earlier, later }) => ({
-        offset: later.date.offset,
-        values: { later: later.date.value, earlier: earlier.date.value, later_label: later.label, earlier_label: earlier.label },
-      }),
-    ),
+  spans?: PeriodWords,
+): PairedIssue[] =>
+  labelPairsOf(labels).flatMap((pair) =>
+    datesOutOfOrder(source, dates, { ...pair, passed, maxLineGap, spans }).map(({ earlier, later }) => ({
+      offset: Math.max(later.date.offset, earlier.date.offset),
+      values: { later: later.date.value, earlier: earlier.date.value, later_label: later.label, earlier_label: earlier.label },
+      period: earlier.span,
+    })),
   );

package/src/structure/labelled-order.ts

@@ -0,0 +1,122 @@
+import { linesOf, type Line } from "./lines.ts";
+import { tableAround } from "./key-value-row.ts";
+import { isTotalLabel } from "./total.ts";
+
+/**
+ * Two labelled points that must come in order: a line (or a list item, or a table's first column) starting with an
+ * earlier-side word and one starting with a later-side word, each giving one point. What a point is (a date, a time of
+ * day) is the caller's: pointOf reads it off the line, and its value sorts as text. Pure.
+ */
+
+/** A point in the text: where it is written, and a value that sorts as text (2026-04-01, a padded count of seconds). */
+export type OrderPoint = { readonly offset: number; readonly value: string };
+
+export type PairWords = {
+  readonly earlier: readonly string[];
+  readonly later: readonly string[];
+  /** A line with one of these words reports on a point rather than setting one (期限切れ, overdue) and is not read. */
+  readonly passed: readonly string[];
+  /** How many lines from the earlier point a later point may be and still be read as the same record's. */
+  readonly maxLineGap: number;
+};
+
+/** A labelled point: the word that labels it, as the lexicon writes it. span is set when the point ends a stated period. */
+export type LabelledPoint = { readonly label: string; readonly point: OrderPoint; readonly line: number; readonly span: boolean };
+
+export type PointPair = { readonly earlier: LabelledPoint; readonly later: LabelledPoint };
+
+/** The point a labelled line gives, or undefined when it gives none. tableOf gives the table the line is a row of. */
+export type PointOf = (line: Line, label: string, tableOf: () => readonly string[]) => Pick<LabelledPoint, "point" | "span"> | undefined;
+
+type Read = LabelledPoint & { readonly kind: "earlier" | "later" };
+
+const labelOf = (text: string, words: readonly string[]): string | undefined => words.find((word) => isTotalLabel(text, [word]));
+
+const kindOf = (text: string, words: PairWords): Pick<Read, "kind" | "label"> | undefined => {
+  const earlier = labelOf(text, words.earlier);
+  if (earlier !== undefined) return { kind: "earlier", label: earlier };
+  const later = labelOf(text, words.later);
+  return later === undefined ? undefined : { kind: "later", label: later };
+};
+
+const labelledPoints = (source: string, words: PairWords, pointOf: PointOf): Read[] => {
+  const lines = linesOf(source);
+  const texts = lines.map((line) => line.text);
+  return lines.flatMap((line, index) => {
+    const passed = words.passed.some((word) => line.text.toLowerCase().includes(word.toLowerCase()));
+    const kind = passed ? undefined : kindOf(line.text, words);
+    const read = kind === undefined ? undefined : pointOf(line, kind.label, () => tableAround(texts, index));
+    return kind === undefined || read === undefined ? [] : [{ ...kind, ...read, line: line.number }];
+  });
+};
+
+/** The earlier point written closest to a later one; of two as close, the one above. */
+const nearestEarlier = (earliers: readonly Read[], later: Read): Read | undefined =>
+  earliers.reduce<Read | undefined>((nearest, entry) => {
+    if (nearest === undefined) return entry;
+    const distance = Math.abs(entry.line - later.line);
+    const nearestDistance = Math.abs(nearest.line - later.line);
+    return distance < nearestDistance || (distance === nearestDistance && entry.line < nearest.line) ? entry : nearest;
+  }, undefined);
+
+/** How a later point finds the earlier point it is compared with, and which pairs the caller can compare at all. */
+export type PairReading = {
+  /**
+   * first: the first earlier point of the document, and, when the later side is written more than once, the nearest one
+   * too (an issue date heads the whole document). nearest: only the earlier point written closest (each show of a
+   * programme has its own doors and start).
+   */
+  readonly anchor?: "first" | "nearest" | undefined;
+  /** Drops a pair the caller cannot compare (two times of different days). */
+  readonly related?: ((pair: PointPair) => boolean) | undefined;
+};
+
+/** Each later point before the earlier point written closest to it. */
+const nearestOutOfOrder = (labelled: readonly Read[], earliers: readonly Read[], maxLineGap: number): PointPair[] =>
+  labelled.flatMap((later) => {
+    const earlier = later.kind === "later" ? nearestEarlier(earliers, later) : undefined;
+    return earlier !== undefined && later.point.value < earlier.point.value && Math.abs(later.line - earlier.line) < maxLineGap ? [{ earlier, later }] : [];
+  });
+
+/**
+ * A later point before the first earlier point. When both sides are written more than once (a history listing one record
+ * per row, newest first), the later point must also be before the earlier point written closest to it: that is its own
+ * record's. A later point written once (an issue date below the records) belongs to the whole document and keeps the first.
+ */
+const firstOutOfOrder = (labelled: readonly Read[], earliers: readonly Read[], maxLineGap: number): PointPair[] => {
+  const earlier = earliers[0];
+  if (earlier === undefined) return [];
+  const records = labelled.filter((entry) => entry.kind === "later").length > 1;
+  const beforeOwnRecord = (later: Read): boolean => !records || later.point.value < (nearestEarlier(earliers, later) ?? earlier).point.value;
+  return labelled
+    .filter(
+      (entry) =>
+        entry.kind === "later" && entry.point.value < earlier.point.value && Math.abs(entry.line - earlier.line) < maxLineGap && beforeOwnRecord(entry),
+    )
+    .map((later) => ({ earlier, later }));
+};
+
+/** The labelled pairs out of order, each with the earlier point it is compared with. */
+export const pointsOutOfOrder = (source: string, words: PairWords, pointOf: PointOf, reading: PairReading = {}): PointPair[] => {
+  if (words.earlier.length === 0 || words.later.length === 0) return [];
+  const labelled = labelledPoints(source, words, pointOf);
+  const earliers = labelled.filter((entry) => entry.kind === "earlier");
+  const pairs = reading.anchor === "nearest" ? nearestOutOfOrder(labelled, earliers, words.maxLineGap) : firstOutOfOrder(labelled, earliers, words.maxLineGap);
+  return reading.related === undefined ? pairs : pairs.filter(reading.related);
+};
+
+/** A lexicon entry naming its pair (group) and its side: before for the earlier point, after for the later one. */
+export type OrderLabel = { readonly pattern: string; readonly group?: string | undefined; readonly position?: "before" | "after" | undefined };
+
+/** One pair of a lexicon: the words of its group that label the earlier point, and those that label the later one. */
+export type LabelPair = { readonly earlier: string[]; readonly later: string[] };
+
+const sideOf = (labels: readonly OrderLabel[], group: string, position: "before" | "after"): string[] =>
+  labels.filter((label) => label.group === group && label.position === position).map((label) => label.pattern);
+
+/** Every pair a lexicon names, in the order its groups first appear. */
+export const labelPairsOf = (labels: readonly OrderLabel[]): LabelPair[] =>
+  [...new Set(labels.flatMap((label) => (label.group === undefined ? [] : [label.group])))].map((group) => ({
+    earlier: sideOf(labels, group, "before"),
+    later: sideOf(labels, group, "after"),
+  }));

package/src/structure/labelled-time-order.ts

@@ -0,0 +1,100 @@
+import type { StructureIssue } from "./issues.ts";
+import { labelPairsOf, pointsOutOfOrder, type OrderLabel, type PointOf, type PointPair } from "./labelled-order.ts";
+import { crossesZones, dayShiftOf, withoutDayShiftBefore, zonesIn, SECONDS_PER_DAY, type DateSpan, type TimeSpan, type TimeWords } from "./time-marks.ts";
+
+/**
+ * Two labelled times of one day that must come in order: doors open before the show starts (開場 before 開演), the group
+ * meets before it departs. A line (or a list item, or a table's first column) starting with an earlier-time word and one
+ * starting with a later-time word, each with one time on it; each later time is compared with the earlier time written
+ * closest to it, so a programme of two shows pairs each start with its own doors. Times of different days are not
+ * compared: the date in force on each line (the last date written before its end) must be the same, and a later time
+ * more than half a day back is past midnight (23:30 then 0:15). Two lines with different time-zone marks are not
+ * compared. A time marked as the next day (翌 1:00, +1) counts a day on; one marked as the day before is not read. Pure.
+ */
+
+/** How many lines from the earlier time a later time may be and still be read as the same event's. */
+const MAX_LINE_GAP = 10;
+/** A later time further back than this is read as past midnight, as time-order reads a day's schedule. */
+const HALF_DAY = SECONDS_PER_DAY / 2;
+/** Digits enough for a few days of seconds, so the values sort as text. */
+const PADDED = 8;
+
+const sortable = (seconds: number): string => String(seconds).padStart(PADDED, "0");
+
+type Inputs = { readonly source: string; readonly times: readonly TimeSpan[]; readonly dates: readonly DateSpan[]; readonly words: TimeWords };
+
+/**
+ * The line's one time, counted from the day's start: a next-day mark adds a day. A line with two times states a range.
+ * The point starts at a next-day mark written before the time (翌0:30), so the message quotes it.
+ */
+const timeOf =
+  ({ source, times, words }: Inputs): PointOf =>
+  (line) => {
+    const end = line.start + line.text.length;
+    const onLine = times.filter((time) => time.start >= line.start && time.end <= end);
+    const time = onLine.length === 1 ? onLine[0] : undefined;
+    if (time === undefined) return undefined;
+    const head = source.slice(line.start, time.start);
+    const shift = dayShiftOf(head, source, time.end, words);
+    const offset = line.start + withoutDayShiftBefore(head, words).length;
+    return shift < 0 ? undefined : { point: { offset, value: sortable(shift * SECONDS_PER_DAY + time.seconds) }, span: false };
+  };
+
+const lineEndAt = (source: string, offset: number): number => {
+  const end = source.indexOf("\n", offset);
+  return end === -1 ? source.length : end;
+};
+
+const lineTextAt = (source: string, offset: number): string => source.slice(source.lastIndexOf("\n", offset - 1) + 1, lineEndAt(source, offset));
+
+/** The date in force on a time's line: the last date written before the line ends, or "" before any date. */
+const dayOf = (source: string, dates: readonly DateSpan[], offset: number): string => {
+  const end = lineEndAt(source, offset);
+  return dates.findLast((date) => date.start < end)?.value ?? "";
+};
+
+/** The line's time-zone marks, or undefined when the line crosses zones (two zones, 現地時間). */
+const zoneOf = (text: string, words: TimeWords): string | undefined => {
+  const zones = zonesIn(text, words);
+  return crossesZones(zones) ? undefined : (zones[0]?.text ?? "");
+};
+
+/** Whether the two times can be compared: one date in force, one time zone, and the later time not more than half a day back. */
+const comparable =
+  ({ source, dates, words }: Inputs) =>
+  ({ earlier, later }: PointPair): boolean => {
+    const zone = zoneOf(lineTextAt(source, earlier.point.offset), words);
+    return (
+      dayOf(source, dates, earlier.point.offset) === dayOf(source, dates, later.point.offset) &&
+      zone !== undefined &&
+      zone === zoneOf(lineTextAt(source, later.point.offset), words) &&
+      Number(earlier.point.value) - Number(later.point.value) <= HALF_DAY
+    );
+  };
+
+/** The text of a point: from its start (a next-day mark, or the time) to the end of the time. */
+const writtenAt = (source: string, times: readonly TimeSpan[], offset: number): string => {
+  const time = times.find((candidate) => candidate.start >= offset);
+  return time === undefined ? "" : source.slice(offset, time.end);
+};
+
+/**
+ * Every pair of a timed-pair lexicon (group, position before and after, as dated-pair-label) whose later-labelled time is
+ * before its earlier-labelled one on the same day. The issue is on the earlier-labelled time (doors open at 18:45): the
+ * later one is the event's own time, the one a reader plans around and the one most often written again elsewhere.
+ */
+export const pairedTimesOutOfOrder = (inputs: Inputs, labels: readonly OrderLabel[]): StructureIssue[] =>
+  labelPairsOf(labels).flatMap((pair) =>
+    pointsOutOfOrder(inputs.source, { ...pair, passed: [], maxLineGap: MAX_LINE_GAP }, timeOf(inputs), {
+      anchor: "nearest",
+      related: comparable(inputs),
+    }).map(({ earlier, later }) => ({
+      offset: earlier.point.offset,
+      values: {
+        time: writtenAt(inputs.source, inputs.times, earlier.point.offset),
+        later: writtenAt(inputs.source, inputs.times, later.point.offset),
+        earlier_label: earlier.label,
+        later_label: later.label,
+      },
+    })),
+  );

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

@@ -0,0 +1,100 @@
+import type { StructureIssue } from "./issues.ts";
+import { linesOf, type Line } from "./lines.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { roundedMatches } from "./tax.ts";
+import { hasSuperscriptPower } from "../facts/superscript-power.ts";
+import { cellNumber, cellsOf, plain, shownExpected, tablesOf, type Cell, type CellNumber } from "./line-amount.ts";
+
+/**
+ * line-amount-mismatch, the product written in an item cell: 「| 会費（3,000円×24名） | 72,000円 |」,
+ * "| Membership dues (24 members × $40) | $960.00 |". The bracket must be exactly one price and one count joined by one
+ * times mark, in either order: the price one amount of money, the count a whole number in a counting word. The row must
+ * hold that one amount besides the item cell, written with the price's marks. A bracket with two marks, a %, or factors
+ * that are not one price and one count, and a row with a second number, are not read. Pure.
+ */
+export type LabelProductWords = {
+  /** Marks that multiply (×); one in letters (x) counts only between spaces. */
+  readonly times: readonly string[];
+  /** Words a count multiplied by a price counts (名, members). */
+  readonly counts: readonly string[];
+  /** Whether a text is one amount of money and nothing else (currency-notation). */
+  readonly isMoney: (text: string) => boolean;
+};
+
+type LabelProduct = { readonly price: CellNumber; readonly count: number; readonly countWritten: string };
+
+const CENTS = 100;
+const BRACKETED = /\(([^()]*)\)/gu;
+const COUNT = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?![\d,.])/u;
+const LATIN = /[A-Za-z]/u;
+
+const timesPattern = (marks: readonly string[]): RegExp | undefined =>
+  marks.length === 0
+    ? undefined
+    : new RegExp(marks.map((mark) => (LATIN.test(mark) ? `(?<=\\s)${escapeRegExp(mark)}(?=\\s)` : escapeRegExp(mark))).join("|"), "gu");
+
+/** The bracket split at its one times mark, undefined when it holds none, more, or a %. */
+export const factorsOf = (content: string, marks: readonly string[]): [string, string] | undefined => {
+  const pattern = timesPattern(marks);
+  if (pattern === undefined || content.includes("%")) return undefined;
+  const found = [...content.matchAll(pattern)];
+  const [only] = found;
+  if (found.length !== 1 || only === undefined) return undefined;
+  return [content.slice(0, only.index).trim(), content.slice(only.index + only[0].length).trim()];
+};
+
+/** A whole count in a counting word ("24名", "24 members"), undefined for anything else. */
+export const countOf = (factor: string, counts: readonly string[]): number | undefined => {
+  const number = COUNT.exec(factor)?.[0];
+  const word = number === undefined ? "" : factor.slice(number.length).trim().toLowerCase();
+  if (number === undefined || !counts.some((count) => count.toLowerCase() === word)) return undefined;
+  return Number(number.replaceAll(",", ""));
+};
+
+const priceOf = (factor: string, words: LabelProductWords): CellNumber | undefined =>
+  words.isMoney(factor) ? cellNumber({ start: 0, text: factor }) : undefined;
+
+const productOf = (factors: readonly [string, string], words: LabelProductWords): LabelProduct | undefined => {
+  const orders: readonly (readonly [string, string])[] = [factors, [factors[1], factors[0]]];
+  const readings = orders.flatMap(([priceText, countText]) => {
+    const [price, count] = [priceOf(priceText, words), countOf(countText, words.counts)];
+    return price === undefined || count === undefined ? [] : [{ price, count, countWritten: countText }];
+  });
+  return readings.length === 1 ? readings[0] : undefined;
+};
+
+/** The one product written in brackets in the item cell, undefined when there is none, more than one, or a footnote mark NFKC would join to a number (24¹). */
+export const labelProductOf = (label: string, words: LabelProductWords): LabelProduct | undefined => {
+  if (hasSuperscriptPower(label)) return undefined;
+  const products = [...plain(label).matchAll(BRACKETED)].flatMap((match) => {
+    const factors = factorsOf(match[1] ?? "", words.times);
+    const product = factors === undefined ? undefined : productOf(factors, words);
+    return product === undefined ? [] : [product];
+  });
+  return products.length === 1 ? products[0] : undefined;
+};
+
+/** The row's one amount besides the item cell, undefined when no other cell or more than one holds a number. */
+const amountOf = (cells: readonly Cell[], words: LabelProductWords): CellNumber | undefined => {
+  const numbered = cells.slice(1).filter((cell) => /\d/u.test(plain(cell.text)));
+  const [only] = numbered;
+  if (numbered.length !== 1 || only === undefined || !words.isMoney(plain(only.text))) return undefined;
+  return cellNumber(only);
+};
+
+const rowIssue = (row: Line, words: LabelProductWords): StructureIssue[] => {
+  const cells = cellsOf(row);
+  const [label] = cells;
+  const product = label === undefined ? undefined : labelProductOf(label.text, words);
+  const amount = product === undefined ? undefined : amountOf(cells, words);
+  if (product === undefined || amount === undefined) return [];
+  const { price, count, countWritten } = product;
+  if (price.before !== amount.before || price.after !== amount.after) return [];
+  const exactCents = count * price.value * CENTS;
+  if (roundedMatches(Math.round(amount.value * CENTS), exactCents, amount.decimals === 0)) return [];
+  const values = { written: amount.written, quantity: countWritten, price: price.written, expected: shownExpected(amount, exactCents) };
+  return [{ offset: amount.offset, values }];
+};
+
+export const labelProductMismatches = (source: string, words: LabelProductWords): StructureIssue[] =>
+  tablesOf(linesOf(source)).flatMap(({ rows }) => rows.flatMap((row) => rowIssue(row, words)));