chaffjs 0.30.0 → 0.32.0

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/layout-codes.ts

@@ -0,0 +1,210 @@
+// layout-code-mismatch: a layout code (2LDK, "2 bedrooms") against the rooms a listing names. Pure: the words come in as
+// LayoutWords (the layout-code and layout-room lexicons), the text as strings.
+
+export type LayoutPart = "living" | "dining" | "kitchen";
+export type LetterGroup = LayoutPart | "storage" | "one-room";
+export type RoomGroup = LayoutPart | "room" | "storage" | "unclear";
+
+export type LayoutWords = {
+  /** One-letter marks written right after the number (L, D, K, S, R). */
+  readonly letters: ReadonlyMap<string, LetterGroup>;
+  /** Marks that add a room not counted (2LDK+S). */
+  readonly joiners: readonly string[];
+  /** Words after the number that say what it counts ("bedrooms", "BR"). */
+  readonly counted: readonly string[];
+  readonly rooms: readonly { readonly pattern: string; readonly group: RoomGroup }[];
+  /** Words after a number that make it a count of rooms (洋室2室): an entry with one is not read as one room. */
+  readonly counters: readonly string[];
+};
+
+export type LayoutCode = {
+  readonly text: string;
+  /** Where the code starts and ends in the text it was read from. */
+  readonly start: number;
+  readonly end: number;
+  readonly rooms: number;
+  /** The L, D and K a lettered code has. Undefined for a code that says nothing about them ("2 bedrooms", 1R). */
+  readonly parts: ReadonlySet<LayoutPart> | undefined;
+};
+
+export type Breakdown = {
+  readonly rooms: number;
+  /** Each L, D or K part the breakdown names, with the entry that names it. */
+  readonly parts: ReadonlyMap<LayoutPart, string>;
+  /** An entry that is a room in some listings and not in others, or names two kinds at once. */
+  readonly unclear: boolean;
+};
+
+export type LayoutSlip =
+  { readonly kind: "count"; readonly code: LayoutCode; readonly listed: number } | { readonly kind: "part"; readonly code: LayoutCode; readonly entry: string };
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const FULLWIDTH_FIRST = 0xff01;
+const FULLWIDTH_LAST = 0xff5e;
+
+/** Full-width ASCII (２ＬＤＫ) as ASCII, one character for one, so offsets stay those of the source. */
+export const foldWidth = (text: string): string =>
+  text.replace(/[！-～]/gu, (char) => {
+    const code = char.charCodeAt(0);
+    return code >= FULLWIDTH_FIRST && code <= FULLWIDTH_LAST ? String.fromCharCode(code - FULLWIDTH_OFFSET) : char;
+  });
+
+const DIGITS = /\d+/uy;
+const LATIN = /[a-z]/iu;
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+
+/** Whether text has pattern at index, and does not run on into a longer word when the pattern is Latin (2BR is a word after a number). */
+const wordAt = (text: string, index: number, pattern: string): boolean => {
+  if (text.slice(index, index + pattern.length).toLowerCase() !== pattern.toLowerCase()) return false;
+  if (!LATIN.test(pattern)) return true;
+  return !WORD_CHAR.test(text.charAt(index + pattern.length)) && !/\p{L}/u.test(text.charAt(index - 1));
+};
+
+/** The longest code letters run (3SLDK). A longer run is a word, not a code. */
+const MAX_CODE_LETTERS = 5;
+/** The most "+S" a code adds (2LDK+S+納戸). */
+const MAX_JOINS = 3;
+
+/** The run of code letters at index (LDK, SLDK), with what they say; empty when the run is longer than a code. */
+const lettersAt = (text: string, index: number, words: LayoutWords): LetterGroup[] => {
+  const head = Array.from(text.slice(index, index + MAX_CODE_LETTERS + 1));
+  const stop = head.findIndex((char) => !words.letters.has(char));
+  const length = stop === -1 ? head.length : stop;
+  if (length > MAX_CODE_LETTERS) return [];
+  return head.slice(0, length).flatMap((char) => words.letters.get(char) ?? []);
+};
+
+/** After a lettered code, each "+S" or "+納戸" that adds a room not counted: the index where they end. */
+const joinedEnd = (text: string, index: number, words: LayoutWords, joins = 0): number => {
+  const joiner = words.joiners.find((mark) => text.startsWith(mark, index));
+  if (joiner === undefined || joins === MAX_JOINS) return index;
+  const after = index + joiner.length;
+  const letter = words.letters.get(text.charAt(after)) === "storage" ? 1 : 0;
+  const word = words.rooms.find((room) => room.group === "storage" && wordAt(text, after, room.pattern))?.pattern.length ?? letter;
+  return word === 0 ? index : joinedEnd(text, after + word, words, joins + 1);
+};
+
+const letteredCode = (text: string, start: number, digitsEnd: number, words: LayoutWords): LayoutCode | undefined => {
+  const groups = lettersAt(text, digitsEnd, words);
+  const lettersEnd = digitsEnd + groups.length;
+  if (!groups.includes("kitchen") && !groups.includes("one-room")) return undefined;
+  if (LATIN.test(text.charAt(lettersEnd))) return undefined;
+  const end = joinedEnd(text, lettersEnd, words);
+  const parts = groups.includes("one-room") ? undefined : new Set(groups.filter((group): group is LayoutPart => group !== "storage"));
+  return { text: text.slice(start, end), start, end, rooms: Number(text.slice(start, digitsEnd)), parts };
+};
+
+const SPACER = /[ \-‐–]?/uy;
+
+const countedCode = (text: string, start: number, digitsEnd: number, words: LayoutWords): LayoutCode | undefined => {
+  SPACER.lastIndex = digitsEnd;
+  const after = digitsEnd + (SPACER.exec(text)?.[0].length ?? 0);
+  const word = words.counted.find((pattern) => wordAt(text, after, pattern));
+  if (word === undefined) return undefined;
+  const end = after + word.length;
+  return { text: text.slice(start, end), start, end, rooms: Number(text.slice(start, digitsEnd)), parts: undefined };
+};
+
+const codeAt = (text: string, start: number, words: LayoutWords): LayoutCode | undefined => {
+  if (/[\p{L}\p{N}.,]/u.test(text.charAt(start - 1))) return undefined;
+  DIGITS.lastIndex = start;
+  const digits = DIGITS.exec(text)?.[0];
+  if (digits === undefined) return undefined;
+  const digitsEnd = start + digits.length;
+  return letteredCode(text, start, digitsEnd, words) ?? countedCode(text, start, digitsEnd, words);
+};
+
+/**
+ * The one layout code a field value gives (2LDK, 3SLDK, 2LDK+S, "2 bedrooms", 2-bed, 2BR). A value with two codes of
+ * different counts ("2LDK or 3DK") gives none: which one the breakdown is for cannot be told.
+ */
+export const parseLayoutCode = (value: string, words: LayoutWords): LayoutCode | undefined => {
+  const text = foldWidth(value);
+  const codes = [...text.matchAll(/\d+/gu)].flatMap((match) => codeAt(text, match.index, words) ?? []);
+  const first = codes[0];
+  if (first === undefined || codes.some((code) => code.rooms !== first.rooms)) return undefined;
+  return { ...first, text: value.slice(first.start, first.end) };
+};
+
+const ENTRY_SEPARATOR = /[、，,・/／+＋;；\n]/u;
+const MULTIPLIER = /(?:[×✕]|(?<=[\s\d])[xX])\s*(\d+)\s*$/u;
+
+/** The kinds of room an entry names, by the room words in it; a lone run of code letters (LDK 12帖, S 4帖) by its letters. */
+const groupsOfEntry = (entry: string, words: LayoutWords): RoomGroup[] => {
+  const named = words.rooms.filter((room) => positions(entry).some((index) => wordAt(entry, index, room.pattern))).map((room) => room.group);
+  if (named.length > 0) return [...new Set(named)];
+  const letters = /^[A-Z]+(?![A-Za-z])/u.exec(entry)?.[0] ?? "";
+  const groups = [...letters].map((letter) => words.letters.get(letter));
+  if (letters === "" || groups.some((group) => group === undefined || group === "one-room")) return [];
+  return [...new Set(groups.flatMap((group): RoomGroup[] => (group === undefined || group === "one-room" ? [] : [group])))];
+};
+
+const positions = (entry: string): number[] => Array.from({ length: entry.length }, (_, index) => index);
+
+/** How many rooms an entry names in words (Bedroom 1 and Bedroom 2 names two). */
+const roomMentions = (entry: string, words: LayoutWords): number => {
+  const rooms = words.rooms.filter((room) => room.group === "room");
+  return positions(entry).filter((index) => rooms.some((room) => wordAt(entry, index, room.pattern))).length;
+};
+
+/** Whether the entry counts rooms with a number (洋室2室, 和室 2間). */
+const countsRooms = (entry: string, words: LayoutWords): boolean =>
+  [...entry.matchAll(/\d+\s*/gu)].some((match) => words.counters.some((counter) => entry.startsWith(counter, match.index + match[0].length)));
+
+const isPart = (group: RoomGroup): group is LayoutPart => group === "living" || group === "dining" || group === "kitchen";
+
+type Tally = { rooms: number; parts: Map<LayoutPart, string>; unclear: boolean };
+
+const tallyEntry = (tally: Tally, entry: string, words: LayoutWords): Tally => {
+  const groups = groupsOfEntry(entry, words);
+  const rooms = groups.includes("room");
+  const several = rooms && (groups.length > 1 || roomMentions(entry, words) > 1 || countsRooms(entry, words));
+  if (groups.includes("unclear") || several) return { ...tally, unclear: true };
+  const times = Number(MULTIPLIER.exec(entry)?.[1] ?? 1);
+  const parts = new Map(tally.parts);
+  groups.filter(isPart).forEach((part) => parts.set(part, parts.get(part) ?? entry));
+  return { rooms: tally.rooms + (rooms ? times : 0), parts, unclear: tally.unclear };
+};
+
+/** The rooms a breakdown names ("LDK 11.5帖、洋室 6帖、洋室 5帖", "Bedroom 1, Bedroom 2, Bathroom"). Entries it cannot name are left out. */
+export const parseBreakdown = (entries: readonly string[], words: LayoutWords): Breakdown =>
+  entries
+    .flatMap((entry) => foldWidth(entry).split(ENTRY_SEPARATOR))
+    .map((entry) => entry.trim())
+    .filter((entry) => entry !== "")
+    .reduce<Tally>((tally, entry) => tallyEntry(tally, entry, words), { rooms: 0, parts: new Map(), unclear: false });
+
+/**
+ * Where a code and the breakdown of the same listing disagree. Silent when the breakdown names no room (it may list only
+ * the LDK), or names one that is counted in some listings and not in others. A lettered code is also checked for an L, D or
+ * K part the breakdown names and the code lacks; a one-room code (1R) and a counted code ("2 bedrooms") are not.
+ */
+export const layoutSlip = (code: LayoutCode, breakdown: Breakdown): LayoutSlip | undefined => {
+  if (breakdown.unclear || breakdown.rooms === 0) return undefined;
+  if (breakdown.rooms !== code.rooms) return { kind: "count", code, listed: breakdown.rooms };
+  const parts = code.parts;
+  if (parts === undefined) return undefined;
+  const extra = [...breakdown.parts].find(([part]) => !parts.has(part));
+  return extra === undefined ? undefined : { kind: "part", code, entry: extra[1] };
+};
+
+/**
+ * The codes and breakdowns of one page, paired listing by listing: within one scope (a section), the first code with the
+ * first breakdown and so on, but only when the scope has as many of each. Any other count is several listings that cannot
+ * be told apart, and none is paired.
+ */
+export const pairByScope = <C extends { readonly scope: number }, B extends { readonly scope: number }>(
+  codes: readonly C[],
+  breakdowns: readonly B[],
+): [C, B][] => {
+  const scopes = [...new Set(codes.map((code) => code.scope))];
+  return scopes.flatMap((scope) => {
+    const inCodes = codes.filter((code) => code.scope === scope);
+    const inBreakdowns = breakdowns.filter((breakdown) => breakdown.scope === scope);
+    if (inCodes.length !== inBreakdowns.length) return [];
+    return inCodes.flatMap((code, index): [C, B][] => {
+      const breakdown = inBreakdowns[index];
+      return breakdown === undefined ? [] : [[code, breakdown]];
+    });
+  });
+};

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