chaffjs 0.30.0 → 0.32.0

package/src/structure/tax-price.ts

@@ -0,0 +1,136 @@
+// tax-mismatch in a price list: one row's tax-included price that is not its tax-excluded price plus the rate. The two
+// columns are the ones whose headings are the same apart from the excluded / included words and a rate (「1箱の価格（税抜）」,
+// 「1箱の価格（税込・10%）」); the rate is the included heading's, else the one rate the document states beside a tax word. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { withoutWord } from "./net-gross-weight.ts";
+import { bodyRows, offsetOf } from "./order-quantity.ts";
+import { roundedMatches } from "./tax.ts";
+
+/** excluded: a price before tax. included: a price with tax. rate: a word beside which a rate in a sentence is the tax rate. */
+export type TaxPriceRole = "excluded" | "included" | "rate";
+export type TaxPriceWord = { readonly pattern: string; readonly role: TaxPriceRole };
+/** The document's tables and its lines outside tables. */
+export type TaxPriceText = { readonly tables: readonly ChangeTable[]; readonly lines: readonly string[] };
+export type TaxPricePair = { readonly excluded: number; readonly included: number; readonly rate: number | undefined };
+
+const RATE = /(\d{1,2}(?:\.\d{1,2})?)[ \t]?%/gu;
+const MAX_RATE = 100;
+const CENTS = 100;
+const SPACES = /\s+/gu;
+/** Spaces and punctuation: 「（税込・10%）」 and "(incl. 8% tax)" say nothing besides once the words are out; $ and € still do. */
+const SPACES_AND_MARKS = /[\s\p{P}]+/gu;
+/** What may stand between a tax word and its rate: 「消費税率は10%」, "sales tax of 8%", "VAT: 20%". */
+const FILLER_MARKS: ReadonlySet<string> = new Set([":", "：", "=", "（", "(", "は", "が", "の"]);
+const FILLER_WORDS: readonly string[] = [" of", " at", " is"];
+const AFTER_RATE = /^[\s)）]+/u;
+const NUMBER = /\d[\d,]*(?:\.\d+)?/u;
+const LATIN_LETTER = /[a-z]/u;
+
+const ratesIn = (text: string): number[] =>
+  [...text.matchAll(RATE)].map((match) => Number(match[1])).filter((rate) => Number.isFinite(rate) && rate > 0 && rate < MAX_RATE);
+
+type Heading = { readonly role: "excluded" | "included"; readonly rest: string; readonly rate: number | undefined };
+
+const heldWords = (key: string, words: readonly TaxPriceWord[], role: TaxPriceRole): string[] =>
+  words
+    .filter((word) => word.role === role && holds(key, word.pattern))
+    .map((word) => word.pattern)
+    .toSorted((left, right) => right.length - left.length);
+
+/** The role a heading names, what it says besides, and its one rate. A heading naming both roles is not read. */
+const headingOf = (heading: string, words: readonly TaxPriceWord[]): Heading | undefined => {
+  const key = plain(heading).toLowerCase();
+  const rates = ratesIn(key);
+  const withoutRate = key.replace(RATE, " ").replace(SPACES, " ");
+  const [excluded, included] = [heldWords(withoutRate, words, "excluded"), heldWords(withoutRate, words, "included")];
+  if (excluded.length > 0 === included.length > 0) return undefined;
+  const role = excluded.length > 0 ? "excluded" : "included";
+  const rest = [...excluded, ...included].reduce((left, word) => withoutWord(left, word), withoutRate);
+  return { role, rest: rest.replace(SPACES_AND_MARKS, ""), rate: rates.length === 1 ? rates[0] : undefined };
+};
+
+/** Each included column with the one excluded column whose heading says the same besides, and the included heading's rate. */
+export const taxPricePairsOf = (headings: readonly string[], words: readonly TaxPriceWord[]): TaxPricePair[] => {
+  const read = headings.map((heading) => headingOf(heading, words));
+  const columnsOf = (role: Heading["role"], rest: string): number[] =>
+    read.flatMap((found, index) => (found?.role === role && found.rest === rest ? [index] : []));
+  return read.flatMap((found, included) => {
+    if (found?.role !== "included" || columnsOf("included", found.rest).length !== 1) return [];
+    const [excluded, ...others] = columnsOf("excluded", found.rest);
+    return excluded === undefined || others.length > 0 ? [] : [{ excluded, included, rate: found.rate }];
+  });
+};
+
+const withoutFillers = (text: string): string => {
+  const trimmed = text.trimEnd();
+  const last = trimmed.at(-1);
+  if (last !== undefined && FILLER_MARKS.has(last)) return withoutFillers(trimmed.slice(0, -1));
+  const word = FILLER_WORDS.find((filler) => trimmed.endsWith(filler));
+  return word === undefined ? trimmed : withoutFillers(trimmed.slice(0, -word.length));
+};
+
+const besideWord = (line: string, at: number, end: number, word: string): boolean => {
+  const written = plain(word).toLowerCase();
+  const before = withoutFillers(line.slice(0, at).toLowerCase());
+  const after = line.slice(end).toLowerCase().replace(AFTER_RATE, "");
+  const standsAlone = (next: string | undefined): boolean => !LATIN_LETTER.test(written) || next === undefined || !LATIN_LETTER.test(next);
+  return (before.endsWith(written) && standsAlone(before.at(-written.length - 1))) || (after.startsWith(written) && standsAlone(after[written.length]));
+};
+
+/** The distinct rates the lines state right beside a rate word: 「消費税10%」, "8% sales tax", "tax rate of 8%". */
+export const statedTaxRates = (lines: readonly string[], words: readonly TaxPriceWord[]): number[] => {
+  const rateWords = words.filter((word) => word.role === "rate").map((word) => word.pattern);
+  const rates = lines.flatMap((written) => {
+    const line = plain(written);
+    return [...line.matchAll(RATE)].flatMap((match) => {
+      const end = match.index + match[0].length;
+      return rateWords.some((word) => besideWord(line, match.index, end, word)) ? ratesIn(match[0]) : [];
+    });
+  });
+  return [...new Set(rates)];
+};
+
+/** The tax-included price as the cell writes it: its unit, its grouping and its decimals. */
+const shownLike = (written: string, exactCents: number, decimals: number): string => {
+  const number = (Math.round(exactCents) / CENTS).toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+    useGrouping: written.includes(","),
+  });
+  return written.replace(NUMBER, number);
+};
+
+const decimalsOf = (text: string): number => NUMBER.exec(text)?.[0].split(".")[1]?.length ?? 0;
+
+const rowIssue = (excludedCell: TableCell | undefined, includedCell: TableCell | undefined, rate: number): StructureIssue[] => {
+  const [excluded, included] = [excludedCell && valueIn(excludedCell.text), includedCell && valueIn(includedCell.text)];
+  if (includedCell === undefined || excluded === undefined || included === undefined || excluded.marks !== included.marks) return [];
+  if (excluded.value <= 0) return [];
+  // price × (100 + rate)% in cents is price × (100 + rate); the price is not rounded first ($0.335 at 10% is $0.3685).
+  const exactCents = excluded.value * (CENTS + rate);
+  if (roundedMatches(Math.round(included.value * CENTS), exactCents, included.step >= 1)) return [];
+  const written = plain(includedCell.text);
+  const values = { written, expected: shownLike(written, exactCents, decimalsOf(written)), rate: `${String(rate)}%`, base: plain(excludedCell?.text ?? "") };
+  return [{ offset: offsetOf(includedCell), values }];
+};
+
+/**
+ * Each row of a price list whose tax-included price is not its tax-excluded price plus the rate, rounded down, to nearest or
+ * up. A pair is not read when the document states a rate other than its own (a reduced rate beside the standard one): which
+ * items take which is not written in the columns.
+ */
+export const taxIncludedPriceMismatches = (text: TaxPriceText, words: readonly TaxPriceWord[]): StructureIssue[] => {
+  if (words.length === 0) return [];
+  const stated = statedTaxRates(text.lines, words);
+  return text.tables.flatMap((table) =>
+    taxPricePairsOf(
+      table.header.map((cell) => cell.text),
+      words,
+    ).flatMap((pair) => {
+      const rate = pair.rate ?? stated[0];
+      if (rate === undefined || stated.some((other) => other !== rate)) return [];
+      return bodyRows(table).flatMap((row) => rowIssue(row[pair.excluded], row[pair.included], rate));
+    }),
+  );
+};

package/src/structure/tax.ts

@@ -15,6 +15,8 @@ export type TaxWords = {
   readonly totals: readonly string[];
   /** 税の行が内税だと分かる語（うち、included）。 */
   readonly included: readonly string[];
+  /** 率で掛かる料金の行の頭の語（サービス料、Service charge）。税はその料金を足した額に掛かってもよい。 */
+  readonly charges: readonly string[];
 };
 
 const RATE = /(\d{1,2}(?:\.\d{1,2})?)[ \t]?[%％]/u;
@@ -22,6 +24,8 @@ const PERCENT = new Set(["%", "％"]);
 /** A sign or an opening bracket right before an amount (-$200, ▲500, (1,200)): the amount may be negative. */
 const SIGNED = /[-−▲△(（][ \t]?(?:[$€£¥￥][ \t]?)?$/u;
 const CENTS = 100;
+/** More charge rows than this in a row give too many ways to tax them, so there is no base. */
+const MAX_CHARGES = 4;
 const MAX_RATE = 100;
 
 type Row = { readonly line: Line; readonly text: string; readonly amounts: readonly Amount[] };
@@ -41,6 +45,8 @@ const rateOf = (text: string): number | undefined => {
 const isTaxRow = (row: Row, words: TaxWords): boolean =>
   isTotalLabel(row.text, words.labels) && !words.included.some((word) => row.text.toLowerCase().includes(word.toLowerCase()));
 
+const isChargeRow = (row: Row, words: TaxWords): boolean => isTotalLabel(row.text, words.charges) && rateOf(row.text) !== undefined;
+
 /** The list marker at the start of a line (- $500) is not a sign. */
 const isSigned = (source: string, row: Row, amount: Amount): boolean => {
   const before = source.slice(row.line.start, amount.offset);
@@ -58,21 +64,40 @@ const amountAt = (source: string, row: Row, column: number, unit: string): Amoun
   return matching.length === 1 && only !== undefined && !isSigned(source, row, only) ? only : undefined;
 };
 
+const sumOf = (values: readonly number[]): number => values.reduce((sum, value) => sum + value, 0);
+
+/** The amounts of the rows in the column and unit of the tax, undefined when a row has none (or more than one). */
+const valuesAt = (source: string, rows: readonly Row[], column: number, unit: string): number[] | undefined => {
+  const amounts = rows.map((row) => amountAt(source, row, column, unit));
+  return amounts.some((amount) => amount === undefined) ? undefined : amounts.flatMap((amount) => (amount === undefined ? [] : [amount.value]));
+};
+
 /**
- * The base the tax is on: the last total row above, or the sum of the item rows above when there is no total row. A row
- * with an amount between the total and the tax (a discount, shipping) may or may not be taxed, so there is no base.
+ * The base with each set of the charges above it added, the full sum last: a tax may be on the subtotal alone or with some
+ * charges (hotels tax the service charge; a gratuity may be untaxed).
  */
-const baseOf = (source: string, above: readonly Row[], tax: Amount, column: number, words: TaxWords): Amount | undefined => {
-  const lastTotalIndex = above.findLastIndex((row) => isTotalLabel(row.text, words.totals));
-  const lastTotal = above[lastTotalIndex];
+const withCharges = (base: number, charges: readonly number[]): number[] =>
+  charges.length > MAX_CHARGES ? [] : charges.reduce<number[]>((sums, charge) => [...sums, ...sums.map((sum) => sum + charge)], [0]).map((sum) => base + sum);
+
+/**
+ * The bases the rate may be on: the last total row above, or the sum of the item rows above when there is no total row,
+ * each with and without the rate charge rows (a service charge) right above the row. Any other row with an amount between
+ * the total and the row (a discount, shipping) may or may not be taxed, so there is no base.
+ */
+const basesOf = (source: string, above: readonly Row[], tax: Amount, column: number, words: TaxWords): number[] => {
+  const chargeStart = above.findLastIndex((row) => !isChargeRow(row, words)) + 1;
+  const charges = valuesAt(source, above.slice(chargeStart), column, tax.unit);
+  if (charges === undefined) return [];
+  const before = above.slice(0, chargeStart);
+  const lastTotalIndex = before.findLastIndex((row) => isTotalLabel(row.text, words.totals));
+  const lastTotal = before[lastTotalIndex];
   if (lastTotal !== undefined) {
-    const between = above.slice(lastTotalIndex + 1);
-    return between.some((row) => row.amounts.length > 0) ? undefined : amountAt(source, lastTotal, column, tax.unit);
+    const total = amountAt(source, lastTotal, column, tax.unit);
+    const between = before.slice(lastTotalIndex + 1);
+    return total === undefined || between.some((row) => row.amounts.length > 0) ? [] : withCharges(total.value, charges);
   }
-  const items = above.map((row) => amountAt(source, row, column, tax.unit));
-  if (items.length === 0 || items.some((item) => item === undefined)) return undefined;
-  const values = items.flatMap((item) => (item === undefined ? [] : [item.value]));
-  return { offset: tax.offset, end: tax.end, unit: tax.unit, value: values.reduce((sum, value) => sum + value, 0) };
+  const items = valuesAt(source, before, column, tax.unit);
+  return items === undefined || items.length === 0 ? [] : withCharges(sumOf(items), charges);
 };
 
 /**
@@ -94,21 +119,31 @@ const issueOf = (source: string, rows: readonly Row[], index: number, rate: numb
   const tax = row?.amounts.length === 1 ? row.amounts[0] : undefined;
   if (row === undefined || tax === undefined || isSigned(source, row, tax)) return [];
   const column = columnOf(source, row.line, tax.offset);
-  const base = baseOf(source, rows.slice(0, index), tax, column, words);
-  if (base === undefined || taxMatches(Math.round(tax.value * CENTS), base.value, rate)) return [];
-  const expectedCents = Math.round(base.value * rate);
+  const bases = basesOf(source, rows.slice(0, index), tax, column, words);
+  const base = bases.at(-1);
+  if (base === undefined || bases.some((candidate) => taxMatches(Math.round(tax.value * CENTS), candidate, rate))) return [];
+  const expectedCents = Math.round(base * rate);
   const shown = shownTotal(source, tax, expectedCents);
   return [{ offset: tax.offset, values: { written: shown.written ?? "", expected: shown.sum ?? "", rate: `${String(rate)}%` } }];
 };
 
-const runIssues = (source: string, rows: readonly Row[], words: TaxWords): StructureIssue[] => {
-  const taxRows = rows.flatMap((row, index) => {
-    const rate = isTaxRow(row, words) ? rateOf(row.text) : undefined;
+type RateRow = { readonly index: number; readonly rate: number };
+
+const rateRowsOf = (rows: readonly Row[], isRateRow: (row: Row) => boolean): RateRow[] =>
+  rows.flatMap((row, index) => {
+    const rate = isRateRow(row) ? rateOf(row.text) : undefined;
     return rate === undefined ? [] : [{ index, rate }];
   });
-  if (new Set(taxRows.map((row) => row.rate)).size > 1) return [];
-  return taxRows.flatMap(({ index, rate }) => issueOf(source, rows, index, rate, words));
+
+/** Tax rows of different rates split the base (a reduced rate), so none is compared; a charge row is not a tax row. */
+const runIssues = (source: string, rows: readonly Row[], words: TaxWords): StructureIssue[] => {
+  const taxRows = rateRowsOf(rows, (row) => isTaxRow(row, words) && !isChargeRow(row, words));
+  const firstTax = taxRows[0]?.index ?? rows.length;
+  // A charge below a tax row (a suggested gratuity under the total) is often on the amount before tax, so it is not read.
+  const chargeRows = rateRowsOf(rows, (row) => isChargeRow(row, words)).filter((row) => row.index < firstTax);
+  const comparable = new Set(taxRows.map((row) => row.rate)).size > 1 ? chargeRows : [...taxRows, ...chargeRows];
+  return comparable.flatMap(({ index, rate }) => issueOf(source, rows, index, rate, words));
 };
 
 export const taxMismatches = (source: string, amounts: readonly Amount[], words: TaxWords): StructureIssue[] =>
-  words.labels.length === 0 ? [] : runsOf(source).flatMap((run) => runIssues(source, rowsOf(source, run, amounts), words));
+  words.labels.length + words.charges.length === 0 ? [] : runsOf(source).flatMap((run) => runIssues(source, rowsOf(source, run, amounts), words));

package/src/structure/term-deadline.ts

@@ -0,0 +1,35 @@
+/**
+ * 文書の仕事の期間（開講期間、Term）と、後ろの節の締め切りの日付を比べた結果。語の有無は呼ぶ側が読んで渡す。
+ * 年の無い締め切りは、期間の始まりと終わりが同じ年のときだけその年と読む。年をまたぐ期間では、期間の外の月日は始まりの前とも終わりの後とも読める。
+ */
+export type TermDates = { readonly start: string; readonly end: string };
+
+/** 締め切りの日付を囲む項目か文の語: 締め切りの語、期間の外に置く語、期間の後に来てよい仕事の語（成績発表、再試験）。 */
+export type DeadlineMarks = { readonly deadline: boolean; readonly aside: boolean; readonly afterTerm: boolean };
+
+export type DeadlineVerdict = "late" | "within" | "before" | "no-year" | "not-deadline" | "aside" | "after-term";
+
+const YEAR_LENGTH = "2026".length;
+const DATED = /^\d{4}-\d{2}-\d{2}$/u;
+const MONTH_DAY = /^\d{2}-\d{2}$/u;
+
+/** 締め切りの日付を年月日で。年が無ければ、期間の始まりと終わりの年が同じときだけその年を足す。 */
+export const deadlineDate = (value: string, term: TermDates): string | undefined => {
+  if (DATED.test(value)) return value;
+  if (!MONTH_DAY.test(value) || !DATED.test(term.start) || !DATED.test(term.end)) return undefined;
+  const year = term.start.slice(0, YEAR_LENGTH);
+  return year === term.end.slice(0, YEAR_LENGTH) ? `${year}-${value}` : undefined;
+};
+
+const placeOf = (date: string, term: TermDates): DeadlineVerdict => {
+  if (date > term.end) return "late";
+  return date < term.start ? "before" : "within";
+};
+
+export const deadlineVerdict = (value: string, term: TermDates, marks: DeadlineMarks): DeadlineVerdict => {
+  if (!marks.deadline) return "not-deadline";
+  if (marks.afterTerm) return "after-term";
+  if (marks.aside) return "aside";
+  const date = deadlineDate(value, term);
+  return date === undefined || !DATED.test(term.end) ? "no-year" : placeOf(date, term);
+};

package/src/structure/tier-threshold.ts

@@ -0,0 +1,218 @@
+// tier-threshold-mismatch: a tier stated for a member ("Tier: Gold") whose own stated value of the tier's unit ("Points earned
+// last year: 42,400 points") falls outside that tier's band in the document's tier table or list. A band is read with
+// range-band-mismatch's reading (structure/range-bands.ts). Pure.
+import { normalizeBandText, parseBand, unitKey, type Band, type BandWords, type Bound } from "./range-bands.ts";
+
+/** One tier as the document defines it: its name and the text that states its band (a cell, or a list item after the colon). */
+export type TierEntry = { readonly name: string; readonly text: string };
+
+/** A line "key: value" outside a table, with where the value starts and the section (counted by headings) it is in. */
+export type KeyValueLine = { readonly key: string; readonly value: string; readonly valueStart: number; readonly section: number };
+
+export type TierText = { readonly tierRuns: readonly (readonly TierEntry[])[]; readonly lines: readonly KeyValueLine[] };
+
+export type TierWords = {
+  readonly band: BandWords;
+  /** The keys of a line that states the member's tier (会員ランク, Tier). */
+  readonly labels: readonly string[];
+  /** Words in a key that make its value some other figure than the one the tier is earned by (残高, needed for next). */
+  readonly others: readonly string[];
+};
+
+export type TierSlip = {
+  readonly offset: number;
+  readonly values: { readonly tier: string; readonly band: string; readonly value: string; readonly actual: string };
+};
+
+type Edge = { readonly value: number; readonly closed: boolean };
+
+type Tier = { readonly entry: TierEntry; readonly band: Band; readonly low: Edge; readonly high: Edge };
+
+type TierSet = { readonly unit: string; readonly tiers: readonly Tier[] };
+
+const EMPHASIS = /[*_`]/gu;
+const NUMBER_RUN = /\d[\d,.]*/gu;
+const FIGURE = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?$/u;
+const DIGIT = /\d/u;
+const DIGITISH = /[\d,.]/u;
+const LATIN = /[a-z]/u;
+/** How far before a number a band's word may start (at least, under) and how far after it its unit and word may end. */
+const WINDOW_BEFORE = 16;
+const WINDOW_AFTER = 24;
+/** A text with more numbers than this is a sentence, not a threshold. */
+const MAX_NUMBERS = 4;
+const MIN_TIERS = 2;
+
+export const plainKey = (text: string): string => text.normalize("NFKC").toLowerCase().replace(EMPHASIS, "").trim();
+
+/** A tier's name as compared: letter case is kept, so "gold" is not the tier "Gold". */
+const nameKey = (text: string): string => text.normalize("NFKC").replace(EMPHASIS, "").trim();
+
+const NOT_WORD = /[^\p{L}\p{N}]+/u;
+
+/** A Latin word of the lexicon is a whole word of the key; any other is a part of it (残高 in ポイント残高). */
+const hasWord = (key: string, word: string): boolean => {
+  const plain = plainKey(word);
+  return LATIN.test(plain) ? ` ${key.split(NOT_WORD).join(" ")} `.includes(` ${plain} `) : key.includes(plain);
+};
+
+const isStart = (text: string, at: number): boolean => {
+  const here = text[at] ?? "";
+  const before = text[at - 1] ?? "";
+  if (here === " " || here === "") return false;
+  if (DIGIT.test(here) && DIGITISH.test(before)) return false;
+  return !(LATIN.test(here) && LATIN.test(before));
+};
+
+const isEnd = (text: string, at: number): boolean => {
+  const last = text[at - 1] ?? "";
+  const next = text[at] ?? "";
+  if (last === " " || last === "" || DIGIT.test(next)) return false;
+  return !(LATIN.test(last) && LATIN.test(next));
+};
+
+const range = (from: number, to: number): number[] => Array.from({ length: Math.max(0, to - from + 1) }, (_, index) => from + index);
+
+type Reading = { readonly from: number; readonly to: number; readonly band: Band };
+
+/** Every stretch of the text around its numbers that reads as one band with a unit. */
+const readingsOf = (text: string, words: BandWords): Reading[] => {
+  const numbers = [...text.matchAll(NUMBER_RUN)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+  if (numbers.length === 0 || numbers.length > MAX_NUMBERS) return [];
+  const starts = [...new Set(numbers.flatMap(({ start }) => range(Math.max(0, start - WINDOW_BEFORE), start)))].filter((at) => isStart(text, at));
+  const ends = [...new Set(numbers.flatMap(({ end }) => range(end, Math.min(text.length, end + WINDOW_AFTER))))].filter((at) => isEnd(text, at));
+  return starts.flatMap((from) =>
+    ends.flatMap((to) => {
+      const band = to > from ? parseBand(text.slice(from, to), words) : undefined;
+      return band === undefined || band.unit === "" ? [] : [{ from, to, band }];
+    }),
+  );
+};
+
+const contains = (outer: Reading, inner: Reading): boolean => outer !== inner && outer.from <= inner.from && inner.to <= outer.to;
+
+/** "10,000 points to" and "under 50,000 points" written one after the other are one band. */
+const joined = (first: Band, second: Band): Band | undefined => {
+  const { low } = first;
+  const { high } = second;
+  if (first.high !== undefined || second.low !== undefined || low === undefined || high === undefined) return undefined;
+  return first.unit === second.unit && low.value < high.value ? { low, high, unit: first.unit } : undefined;
+};
+
+/** The one band a text states (前年度のご宿泊数が30泊以上, 30 nights or more stayed last year), or undefined. */
+export const bandIn = (written: string, words: BandWords): Band | undefined => {
+  const text = normalizeBandText(written);
+  const readings = readingsOf(text, words);
+  const widest = readings.filter((reading) => !readings.some((other) => contains(other, reading))).toSorted((a, b) => a.from - b.from);
+  const [first, second] = widest;
+  if (first === undefined) return undefined;
+  if (widest.length === 1) return first.band;
+  return widest.length === 2 && second !== undefined && first.to <= second.from ? joined(first.band, second.band) : undefined;
+};
+
+const NEGATIVE: Edge = { value: Number.NEGATIVE_INFINITY, closed: false };
+const POSITIVE: Edge = { value: Number.POSITIVE_INFINITY, closed: false };
+
+const edgeOf = (bound: Bound): Edge => ({ value: bound.value, closed: bound.kind !== "exclusive" });
+
+/** The edge where the next tier up starts closes this one: below 30 when the next starts at 30, up to 30 when it starts above it. */
+const belowEdge = (next: Edge): Edge => ({ value: next.value, closed: !next.closed });
+
+/** The tier below runs into the next one: it ends past where the next starts, or both hold the number they meet at. */
+const overlaps = (below: Band, next: Edge): boolean => {
+  if (below.high === undefined) return false;
+  const end = edgeOf(below.high);
+  return end.value > next.value || (end.value === next.value && end.closed && next.closed);
+};
+
+type Placed = { readonly entry: TierEntry; readonly band: Band; readonly low: Edge };
+
+const placedTiers = (placed: readonly Placed[]): Tier[] | undefined => {
+  const tiers = placed.map((tier, index): Tier | undefined => {
+    const next = placed[index + 1];
+    if (next !== undefined && (next.low.value === tier.low.value || overlaps(tier.band, next.low))) return undefined;
+    if (tier.band.high !== undefined) return { ...tier, high: edgeOf(tier.band.high) };
+    return { ...tier, high: next === undefined ? POSITIVE : belowEdge(next.low) };
+  });
+  return tiers.every((tier) => tier !== undefined) ? tiers : undefined;
+};
+
+const uniqueNames = (entries: readonly TierEntry[]): boolean => new Set(entries.map((entry) => plainKey(entry.name))).size === entries.length;
+
+/**
+ * The tiers of one table or list: at least two, each named once, each stating one band in one shared unit, and no two
+ * bands holding one value. A tier written with its lower end only (20泊以上) runs up to where the next tier starts.
+ */
+export const tierSetOf = (entries: readonly TierEntry[], words: BandWords): TierSet | undefined => {
+  if (entries.length < MIN_TIERS || !uniqueNames(entries) || entries.some((entry) => plainKey(entry.name) === "")) return undefined;
+  const bands = entries.map((entry) => bandIn(entry.text, words));
+  const units = new Set(bands.map((band) => band?.unit));
+  const unit = [...units][0];
+  if (units.size !== 1 || unit === undefined) return undefined;
+  const placed = entries
+    .flatMap((entry, index): Placed[] => {
+      const band = bands[index];
+      return band === undefined ? [] : [{ entry, band, low: band.low === undefined ? NEGATIVE : edgeOf(band.low) }];
+    })
+    .toSorted((a, b) => a.low.value - b.low.value);
+  const tiers = placedTiers(placed);
+  return tiers === undefined ? undefined : { unit, tiers };
+};
+
+const holds = (low: Edge, high: Edge, value: number): boolean =>
+  (low.closed ? value >= low.value : value > low.value) && (high.closed ? value <= high.value : value < high.value);
+
+/** The value as its band was written: 20泊以上 holds 35, though the tier above starts at 30. */
+const inWrittenBand = (band: Band, value: number): boolean =>
+  holds(band.low === undefined ? NEGATIVE : edgeOf(band.low), band.high === undefined ? POSITIVE : edgeOf(band.high), value);
+
+type Figure = { readonly value: number; readonly unit: string };
+
+/** A value that is one number in one tier unit and nothing else (42,400ポイント, 24 nights, $1,250). */
+export const figureIn = (written: string, words: BandWords): Figure | undefined => {
+  const text = plainKey(written);
+  return words.units.flatMap((entry): Figure[] => {
+    const unit = entry.pattern.normalize("NFKC").toLowerCase();
+    const before = entry.position === "before";
+    const holdsUnit = before ? text.startsWith(unit) : text.endsWith(unit);
+    const digits = (before ? text.slice(unit.length) : text.slice(0, text.length - unit.length)).trim();
+    return holdsUnit && FIGURE.test(digits) ? [{ value: Number(digits.replaceAll(",", "")), unit: unitKey(unit) }] : [];
+  })[0];
+};
+
+type Statement = { readonly line: KeyValueLine; readonly name: string };
+
+/** The one set naming the tier whose unit the section states exactly one value in, with that value. */
+const comparedSet = (statement: Statement, sets: readonly TierSet[], text: TierText, words: TierWords) => {
+  const lines = text.lines.filter((line) => line.section === statement.line.section && !words.others.some((word) => hasWord(plainKey(line.key), word)));
+  const pairs = sets
+    .filter((set) => set.tiers.some((tier) => nameKey(tier.entry.name) === statement.name))
+    .flatMap((set) => {
+      const values = lines.flatMap((line) => {
+        const figure = figureIn(line.value, words.band);
+        return figure !== undefined && figure.unit === set.unit ? [{ line, figure }] : [];
+      });
+      const [only] = values;
+      return values.length === 1 && only !== undefined ? [{ set, ...only }] : [];
+    });
+  return pairs.length === 1 ? pairs[0] : undefined;
+};
+
+const slipOf = (statement: Statement, sets: readonly TierSet[], text: TierText, words: TierWords): TierSlip[] => {
+  const compared = comparedSet(statement, sets, text, words);
+  const stated = compared?.set.tiers.find((tier) => nameKey(tier.entry.name) === statement.name);
+  if (compared === undefined || stated === undefined || inWrittenBand(stated.band, compared.figure.value)) return [];
+  const actual = compared.set.tiers.find((tier) => holds(tier.low, tier.high, compared.figure.value));
+  if (actual === undefined || actual === stated) return [];
+  const values = { tier: stated.entry.name, band: stated.entry.text, value: compared.line.value, actual: actual.entry.name };
+  return [{ offset: compared.line.valueStart, values }];
+};
+
+/** Each stated tier ("会員ランク：ゴールド") whose member's value of the tier's unit, in the same section, is outside its band. */
+export const tierSlips = (text: TierText, words: TierWords): TierSlip[] => {
+  const labels = new Set(words.labels.map(plainKey));
+  const statements = text.lines.filter((line) => labels.has(plainKey(line.key))).map((line) => ({ line, name: nameKey(line.value) }));
+  if (statements.length === 0) return [];
+  const sets = text.tierRuns.flatMap((run) => tierSetOf(run, words.band) ?? []);
+  return statements.flatMap((statement) => slipOf(statement, sets, text, words));
+};

package/src/structure/time-range.ts

@@ -0,0 +1,70 @@
+import type { StructureIssue } from "./issues.ts";
+import { isRange, type RangeWords } from "./date-range.ts";
+import { dayShiftOf, type TimeSpan, type TimeWords } from "./time-marks.ts";
+
+/**
+ * 時刻の範囲の終わりが始まりより前（14:00〜13:30、2:00–1:30 pm、午後2時から午後1時半まで）。隣り合う二つの時刻の間が
+ * 範囲の記号だけか、「から … まで」「from … to」のときを範囲と読む（date-range と同じ読み方）。変更の語のある文は読まない。
+ * 終わりに翌日の印（翌、+1、next day）があれば日をまたぐ範囲で、言わない。印が無くても、三時間以上戻る終わりは
+ * 夜をまたぐ範囲（22:00〜6:00 の夜勤、18:00〜9:00）か十二時間制の読み違い（9:00–5:00）と見て言わない。打ち間違いは一、二時間の戻り。
+ * 片方にだけ午前・午後（a.m.、p.m.）を書いた範囲は、書いていない側も同じと読む（2:00–1:30 pm は 14:00 から 13:30）。
+ * ただし正午をまたぐ書き方（8:00–6:00 pm）があるので、そのときは一時間未満の戻りだけを言う。
+ * 両方に同じ午前・午後を書いた範囲（9:00 AM – 5:30 AM）は、戻りの幅を問わず言う。夜をまたぐなら午後から午前になるので、同じ側のまま戻るのは書き間違い。
+ */
+
+const SECONDS_PER_HOUR = 3600;
+/** 書いたまま読んだ範囲で、打ち間違いと見る戻りの上限。 */
+const SLIP_SECONDS = 3 * SECONDS_PER_HOUR;
+/** 午前・午後を片方から借りた範囲で、打ち間違いと見る戻りの上限。 */
+const BORROWED_SLIP_SECONDS = SECONDS_PER_HOUR;
+const NOON_SECONDS = 12 * SECONDS_PER_HOUR;
+const ONE_OCLOCK_SECONDS = SECONDS_PER_HOUR;
+const LAST_TWELVE_HOUR_SECONDS = 13 * SECONDS_PER_HOUR;
+
+const MERIDIEM = /[ap]\.?m\b|午前|午後/iu;
+
+const hasMeridiem = (source: string, time: TimeSpan): boolean => MERIDIEM.test(source.slice(time.start, time.end));
+
+/** 午前・午後を書かず、十二時間制でも読める時刻（1:00〜12:59）。 */
+const isTwelveHour = (time: TimeSpan): boolean => time.seconds >= ONE_OCLOCK_SECONDS && time.seconds < LAST_TWELVE_HOUR_SECONDS;
+
+/** 午前・午後を書かない時刻を、もう片方の午前・午後で読む。 */
+const borrowed = (bare: number, written: number): number => {
+  const afternoon = written >= NOON_SECONDS;
+  if (afternoon && bare < NOON_SECONDS) return bare + NOON_SECONDS;
+  if (!afternoon && bare >= NOON_SECONDS) return bare - NOON_SECONDS;
+  return bare;
+};
+
+/** sameHalf は、両方に午前・午後を書き、どちらも同じ側のもの（9:00 AM – 5:30 AM）。 */
+type Reading = { readonly from: number; readonly to: number; readonly borrowed: boolean; readonly sameHalf?: boolean };
+
+const isAfternoon = (seconds: number): boolean => seconds >= NOON_SECONDS;
+
+/** 範囲の二つの時刻を秒で。片方にだけ午前・午後があれば、もう片方もそれで読む。 */
+export const rangeReading = (source: string, start: TimeSpan, end: TimeSpan): Reading => {
+  const [startMarked, endMarked] = [hasMeridiem(source, start), hasMeridiem(source, end)];
+  if (endMarked && !startMarked && isTwelveHour(start)) return { from: borrowed(start.seconds, end.seconds), to: end.seconds, borrowed: true };
+  if (startMarked && !endMarked && isTwelveHour(end)) return { from: start.seconds, to: borrowed(end.seconds, start.seconds), borrowed: true };
+  const sameHalf = startMarked && endMarked && isAfternoon(start.seconds) === isAfternoon(end.seconds);
+  return { from: start.seconds, to: end.seconds, borrowed: false, ...(sameHalf ? { sameHalf } : {}) };
+};
+
+/** 終わりが始まりより前で、その戻りが打ち間違いの幅に収まるか。 */
+export const isReversed = (reading: Reading): boolean => {
+  const back = reading.from - reading.to;
+  if (back <= 0) return false;
+  return reading.sameHalf === true || back < (reading.borrowed ? BORROWED_SLIP_SECONDS : SLIP_SECONDS);
+};
+
+const asDated = (time: TimeSpan): { offset: number; end: number; value: string } => ({ offset: time.start, end: time.end, value: "" });
+
+/** 隣り合う二つの時刻のうち、範囲をなし、終わりが始まりより前のもの。範囲の書き出しを指し、書いたままの範囲を見せる。 */
+export const reversedTimeRanges = (source: string, times: readonly TimeSpan[], range: RangeWords, words: TimeWords): StructureIssue[] =>
+  times.slice(1).flatMap((end, index) => {
+    const start = times[index];
+    if (start === undefined || !isRange(source, asDated(start), asDated(end), range, () => false)) return [];
+    if (dayShiftOf(source.slice(start.end, end.start), source, end.end, words) !== 0 || !isReversed(rangeReading(source, start, end))) return [];
+    const written = source.slice(start.start, end.end).replace(/\s+/gu, " ");
+    return [{ offset: start.start, values: { range: written, start: source.slice(start.start, start.end), end: source.slice(end.start, end.end) } }];
+  });