chaffjs 0.30.0 → 0.31.0

package/src/structure/scaled-quantities.ts

@@ -0,0 +1,225 @@
+import type { Span } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { measuredValues, type MeasureUnit } from "../facts/measures.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf, type Line } from "./lines.ts";
+import type { Mark } from "./time-marks.ts";
+
+/**
+ * A table with one column per number of servings or batch size (4人分 / 8人分, Serves 4 / Serves 8, ×1 / ×2), and the one
+ * row that does not grow by the columns' ratio while the others do. The words come from the language packages. Pure.
+ */
+export type ScaleWords = {
+  /** What marks a column as a number of servings (人分 after the number, Serves before it). */
+  readonly columns: readonly Mark[];
+  /** An amount that is left to the cook (少々, to taste): its row may stay as it is. */
+  readonly unscaled: readonly string[];
+  /** Spellings of one unit (teaspoon, teaspoons, tsp), each named by its group. */
+  readonly unitForms: readonly { readonly pattern: string; readonly group: string }[];
+  /** Units with a factor to a base unit (g and kg), so 1 kg and 1000 g read as one amount. */
+  readonly measures: readonly MeasureUnit[];
+};
+
+/** amount is in the base unit when the unit has a factor (1 kg is 1000); written is the number as written (1). */
+export type Amount = { readonly amount: number; readonly written: number; readonly unit: string };
+
+export type ScaleSlip = {
+  /** The row's first cell: the item. */
+  readonly item: Cell;
+  /** The cell that does not scale, and the column it is in. */
+  readonly cell: Cell;
+  readonly heading: string;
+  /** The cell it is compared with, and that column. */
+  readonly other: Cell;
+  readonly otherHeading: string;
+  /** What the cell would hold if it scaled like the other rows, in the unit it is written in. */
+  readonly expected: number;
+  readonly scaledRows: number;
+};
+
+/** Fewer rows than this that scale exactly are no evidence that the table scales at all. */
+export const MIN_SCALED_ROWS = 3;
+const SAME = 1e-9;
+const MIN_COLUMNS = 2;
+
+const NUMBER_TEXT = "[0-9]+(?:\\.[0-9]+)?";
+
+/** The number of servings a column heading names (4人分, Serves 8, ×2), or undefined. */
+export const servingsOf = (heading: string, marks: readonly Mark[]): number | undefined => {
+  const text = withoutEdgeMarks(heading.normalize("NFKC").trim()).toLowerCase();
+  const read = marks
+    .map((mark) => {
+      const word = escapeRegExp(mark.pattern.normalize("NFKC").toLowerCase());
+      const pattern = mark.position === "before" ? `^${word}\\s*(${NUMBER_TEXT})$` : `^(${NUMBER_TEXT})\\s*${word}$`;
+      return new RegExp(pattern, "u").exec(text)?.[1];
+    })
+    .find((number) => number !== undefined);
+  const servings = read === undefined ? undefined : Number(read);
+  return servings === undefined || !Number.isFinite(servings) || servings <= 0 ? undefined : servings;
+};
+
+/** A whole or decimal number (1,000 and 1.5), with a fraction after it (1 1/2) or as a fraction (1/2, ½). */
+const WHOLE = String.raw`[0-9]+(?:,[0-9]{3})*(?:\.[0-9]+)?`;
+const FRACTION = String.raw`(?:\s([0-9]+)[/⁄]([0-9]+)|[/⁄]([0-9]+))?`;
+const AMOUNT = new RegExp(String.raw`(?<![\p{N}.,/⁄])(${WHOLE})${FRACTION}(?![\p{N}/⁄])`, "gu");
+
+const valueOf = (match: RegExpMatchArray): number => {
+  const whole = Number((match[1] ?? "").replace(/,/gu, ""));
+  if (match[4] !== undefined) return whole / Number(match[4]);
+  return match[2] === undefined ? whole : whole + Number(match[2]) / Number(match[3]);
+};
+
+const LETTER_BEFORE = "(?<!\\p{L})";
+const LETTER_AFTER = "(?!\\p{L})";
+
+/** The cell's text with its number taken out and each spelling of a unit written as its group: "2 teaspoons" is "#teaspoon". */
+const unitKey = (text: string, numberAt: Span, forms: ScaleWords["unitForms"]): string => {
+  const rest = `${text.slice(0, numberAt.start)}#${text.slice(numberAt.end)}`.toLowerCase();
+  const groups = new Map(forms.map((form) => [form.pattern.toLowerCase(), form.group]));
+  const spellings = [...groups.keys()].filter((pattern) => pattern !== "").toSorted((left, right) => right.length - left.length);
+  const grouped =
+    spellings.length === 0
+      ? rest
+      : rest.replace(
+          new RegExp(`${LETTER_BEFORE}(?:${spellings.map(escapeRegExp).join("|")})${LETTER_AFTER}`, "gu"),
+          (spelling) => `<${groups.get(spelling) ?? spelling}>`,
+        );
+  return grouped.replace(/\s+/gu, "");
+};
+
+/** NFKC writes ½ as 1⁄2, so 1½ would read as 11⁄2: a space keeps the whole number apart (1 1⁄2). */
+const VULGAR_AFTER_DIGIT = /([0-9０-９])([¼½¾⅐-⅞])/gu;
+
+const normalized = (cellText: string): string => withoutEdgeMarks(cellText.replace(VULGAR_AFTER_DIGIT, "$1 $2").normalize("NFKC").trim());
+
+/** One cell's amount and the unit it is in. undefined when the cell holds no number, or more than one (1と1/2, 2 (300 g)). */
+export const amountOf = (cellText: string, words: ScaleWords): Amount | undefined => {
+  const text = normalized(cellText);
+  const numbers = [...text.matchAll(AMOUNT)];
+  const [only] = numbers;
+  if (numbers.length !== 1 || only === undefined) return undefined;
+  const written = valueOf(only);
+  if (!Number.isFinite(written)) return undefined;
+  const [measured] = measuredValues(text, words.measures);
+  const factor = measured?.factors[0];
+  if (measured !== undefined && factor !== undefined && measured.start === only.index && measured.end === text.length) {
+    return { amount: measured.amount * factor, written: measured.amount, unit: `=${measured.dimension}` };
+  }
+  return { amount: written, written, unit: unitKey(text, { start: only.index, end: only.index + only[0].length }, words.unitForms) };
+};
+
+const isUnscaled = (text: string, unscaled: readonly string[]): boolean => {
+  const lower = text.normalize("NFKC").toLowerCase();
+  return unscaled.some((word) => word !== "" && lower.includes(word.normalize("NFKC").toLowerCase()));
+};
+
+type Column = { readonly index: number; readonly servings: number; readonly heading: string };
+
+type Row = { readonly item: Cell; readonly cells: readonly Cell[] };
+
+/** The rows of one table whose item is named, as cells. */
+const rowsOf = (rows: readonly Line[]): Row[] =>
+  rows.flatMap((line) => {
+    const cells = cellsOf(line);
+    const [item] = cells;
+    return item === undefined || withoutEdgeMarks(item.text) === "" ? [] : [{ item, cells }];
+  });
+
+type Pair = {
+  readonly row: Row;
+  readonly baseCell: Cell;
+  readonly cell: Cell;
+  readonly from: Amount;
+  readonly to: Amount;
+  readonly scales: boolean;
+};
+
+/** Each row's two cells, when both are amounts in one unit and the row is not left to the cook. */
+const readablePairs = (rows: readonly Row[], base: Column, other: Column, words: ScaleWords): Pair[] =>
+  rows.flatMap((row): Pair[] => {
+    const [baseCell, cell] = [row.cells[base.index], row.cells[other.index]];
+    if (baseCell === undefined || cell === undefined) return [];
+    if (isUnscaled(baseCell.text, words.unscaled) || isUnscaled(cell.text, words.unscaled)) return [];
+    const [from, to] = [amountOf(baseCell.text, words), amountOf(cell.text, words)];
+    if (from === undefined || to === undefined || from.unit !== to.unit) return [];
+    const scaled = (from.amount * other.servings) / base.servings;
+    return [{ row, baseCell, cell, from, to, scales: Math.abs(to.amount - scaled) <= SAME * Math.max(Math.abs(scaled), 1) }];
+  });
+
+type Departure = { readonly pair: Pair; readonly scaled: number };
+
+/** The one row of a column that departs from the base column while at least MIN_SCALED_ROWS others scale exactly. */
+const departureOf = (rows: readonly Row[], base: Column, other: Column, words: ScaleWords): Departure | undefined => {
+  const pairs = readablePairs(rows, base, other, words);
+  const departing = pairs.filter((pair) => !pair.scales);
+  const [only] = departing;
+  const scaled = pairs.length - departing.length;
+  return departing.length === 1 && only !== undefined && scaled >= MIN_SCALED_ROWS ? { pair: only, scaled } : undefined;
+};
+
+/** What `amount` would be if it were `ratio` times `from`, in the unit `amount` is written in. */
+export const expectedOf = (from: Amount, amount: Amount, ratio: number): number => {
+  const perWritten = amount.written === 0 || amount.amount === 0 ? 1 : amount.amount / amount.written;
+  return (from.amount * ratio) / perWritten;
+};
+
+const columnSlip = (base: Column, other: Column, { pair, scaled }: Departure): ScaleSlip => ({
+  item: pair.row.item,
+  cell: pair.cell,
+  heading: other.heading,
+  other: pair.baseCell,
+  otherHeading: base.heading,
+  expected: expectedOf(pair.from, pair.to, other.servings / base.servings),
+  scaledRows: scaled,
+});
+
+const baseSlip = (base: Column, other: Column, { pair, scaled }: Departure): ScaleSlip => ({
+  item: pair.row.item,
+  cell: pair.baseCell,
+  heading: base.heading,
+  other: pair.cell,
+  otherHeading: other.heading,
+  expected: expectedOf(pair.to, pair.from, base.servings / other.servings),
+  scaledRows: scaled,
+});
+
+type Found = { readonly other: Column; readonly departure: Departure | undefined };
+
+/** Whether the row's cells outside the first column scale with each other (a row fixed in every column does not). */
+const othersAgree = (found: readonly Found[]): boolean => {
+  const perServing = found.map(({ other, departure }) => (departure === undefined ? Number.NaN : departure.pair.to.amount / other.servings));
+  const [first] = perServing;
+  return first !== undefined && perServing.every((value) => Math.abs(value - first) <= SAME * Math.max(Math.abs(first), 1));
+};
+
+/**
+ * One table's slips. Each column is compared with the first servings column. When the same row departs in every other column
+ * (three or more columns) and those columns scale with each other, it is the first column's cell that is off, and that cell is
+ * reported once; a row that departs everywhere without that (the same amount in every column) may be fixed on purpose.
+ */
+const tableSlips = (columns: readonly Column[], rows: readonly Row[], words: ScaleWords): ScaleSlip[] => {
+  const [base, ...others] = columns;
+  if (base === undefined) return [];
+  const found: Found[] = others.map((other) => ({ other, departure: departureOf(rows, base, other, words) }));
+  const [first] = found;
+  const offRows = new Set(found.map(({ departure }) => departure?.pair.row));
+  if (others.length > 1 && offRows.size === 1 && first?.departure !== undefined) {
+    return othersAgree(found) ? [baseSlip(base, first.other, first.departure)] : [];
+  }
+  return found.flatMap(({ other, departure }) => (departure === undefined ? [] : [columnSlip(base, other, departure)]));
+};
+
+const columnsOf = (header: Line, marks: readonly Mark[]): Column[] =>
+  cellsOf(header).flatMap((cell, index): Column[] => {
+    const servings = index === 0 ? undefined : servingsOf(cell.text, marks);
+    return servings === undefined ? [] : [{ index, servings, heading: withoutEdgeMarks(cell.text.trim()) }];
+  });
+
+/** Every table of the source with two or more servings columns, and the cells in them that do not scale. */
+export const scaleSlips = (source: string, words: ScaleWords): ScaleSlip[] =>
+  tablesOf(linesOf(source)).flatMap((table) => {
+    const columns = columnsOf(table.header, words.columns);
+    const distinct = new Set(columns.map((column) => column.servings));
+    return distinct.size === columns.length && columns.length >= MIN_COLUMNS ? tableSlips(columns, rowsOf(table.rows), words) : [];
+  });

package/src/structure/stamp-order.ts

@@ -0,0 +1,100 @@
+import type { DatedSpan } from "./date-range.ts";
+import type { StructureIssue } from "./issues.ts";
+import { linesOf } from "./lines.ts";
+
+/**
+ * A document's stamp dates out of order: an established date (2024年10月1日 制定, Established: April 1, 2023) later than an
+ * update (2024年9月1日 最終改定, Last updated: September 1, 2024). A stamp line (or one part of a line that holds several dates)
+ * holds one full date and, once the date is taken out, nothing but one stamp word (with colons, brackets, emphasis or a list
+ * marker around it). Only stamps written together are compared. Both stamps are reported, each naming the other: nothing tells
+ * which of the two dates is the wrong one. Pure; the stamp words come from the caller.
+ */
+export type StampWords = { readonly established: readonly string[]; readonly updated: readonly string[] };
+
+type Stamp = { readonly kind: "established" | "updated"; readonly date: DatedSpan; readonly line: number };
+
+const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
+/** How many lines apart two stamps may be and still be one document's stamp block; further apart, they date two documents. */
+const MAX_LINE_GAP = 6;
+/** What may stand around a stamp word: spaces, colons, brackets, table bars, Markdown emphasis and list markers. */
+const AROUND_WORD = /[\s:：*_()（）[\]「」【】|｜\-‐−・]/u;
+/** A part of a line between a wide space, a tab or a bar. */
+const FIELD = /[^\t\u3000|｜]+/gu;
+
+const bareWord = (text: string): string => {
+  const chars = [...text];
+  const first = chars.findIndex((char) => !AROUND_WORD.test(char));
+  const last = chars.findLastIndex((char) => !AROUND_WORD.test(char));
+  return first === -1
+    ? ""
+    : chars
+        .slice(first, last + 1)
+        .join("")
+        .toLowerCase();
+};
+
+const kindOf = (word: string, words: StampWords): Stamp["kind"] | undefined => {
+  const isOne = (list: readonly string[]): boolean => list.some((entry) => entry.toLowerCase() === word);
+  if (isOne(words.established)) return "established";
+  return isOne(words.updated) ? "updated" : undefined;
+};
+
+type Field = { readonly start: number; readonly end: number; readonly line: number };
+
+const datesIn = (dates: readonly DatedSpan[], field: Field): DatedSpan[] => dates.filter((date) => date.offset >= field.start && date.end <= field.end);
+
+/** A line, or, when it holds more than one date, its parts between wide spaces, tabs and bars (作成：平成16年2月4日, a wide space, 最終改定：令和3年11月19日). */
+const fieldsOf = (source: string, dates: readonly DatedSpan[]): Field[] =>
+  linesOf(source).flatMap((line) => {
+    const whole = { start: line.start, end: line.start + line.text.length, line: line.number };
+    if (datesIn(dates, whole).length < 2) return [whole];
+    return [...line.text.matchAll(FIELD)].map((match) => ({
+      start: line.start + match.index,
+      end: line.start + match.index + match[0].length,
+      line: line.number,
+    }));
+  });
+
+/** The stamps of a text: a line or field holding one full date and one stamp word, nothing else. */
+const stampsOf = (source: string, dates: readonly DatedSpan[], words: StampWords): Stamp[] =>
+  fieldsOf(source, dates).flatMap((field) => {
+    const [date, ...more] = datesIn(dates, field);
+    if (date === undefined || more.length > 0 || !FULL_DATE.test(date.value)) return [];
+    const rest = `${source.slice(field.start, date.offset)} ${source.slice(date.end, field.end)}`;
+    const kind = kindOf(bareWord(rest), words);
+    return kind === undefined ? [] : [{ kind, date, line: field.line }];
+  });
+
+/** Stamps written together, each within MAX_LINE_GAP lines of the one before: one document's stamp block. */
+const blocksOf = (stamps: readonly Stamp[]): Stamp[][] =>
+  stamps.reduce<Stamp[][]>((blocks, stamp, index) => {
+    const previous = stamps[index - 1];
+    const last = blocks.at(-1);
+    if (previous === undefined || last === undefined || stamp.line - previous.line > MAX_LINE_GAP) return [...blocks, [stamp]];
+    return [...blocks.slice(0, -1), [...last, stamp]];
+  }, []);
+
+const valuesOf = (established: Stamp, updated: Stamp): Record<string, string> => ({ established: established.date.value, updated: updated.date.value });
+
+/** In one block: each established stamp later than an update, against the latest such update, and each such update against the first such established stamp. */
+const blockIssues = (block: readonly Stamp[]): StructureIssue[] => {
+  const established = block.filter((stamp) => stamp.kind === "established");
+  const updates = block.filter((stamp) => stamp.kind === "updated").toSorted((a, b) => b.date.value.localeCompare(a.date.value));
+  const ofEstablished = established.flatMap((stamp) => {
+    const latest = updates.find((updated) => updated.date.value < stamp.date.value);
+    return latest === undefined ? [] : [{ offset: stamp.date.offset, values: valuesOf(stamp, latest) }];
+  });
+  const ofUpdates = updates.flatMap((updated) => {
+    const later = established.find((stamp) => stamp.date.value > updated.date.value);
+    return later === undefined ? [] : [{ offset: updated.date.offset, values: { ...valuesOf(later, updated), side: "updated" } }];
+  });
+  return [...ofEstablished, ...ofUpdates];
+};
+
+/** Each established stamp later than an update of its block, and each such update, the one naming the other. */
+export const stampOrderIssues = (source: string, dates: readonly DatedSpan[], words: StampWords): StructureIssue[] => {
+  if (words.established.length === 0 || words.updated.length === 0) return [];
+  return blocksOf(stampsOf(source, dates, words))
+    .flatMap(blockIssues)
+    .toSorted((a, b) => a.offset - b.offset);
+};

package/src/structure/step-times.ts

@@ -0,0 +1,169 @@
+import type { Span } from "../plugin.ts";
+import { labelOf, timeLengths, type LengthWords, type TimeLength } from "../derived/time-lengths.ts";
+import { isWordAt, type Mark } from "./time-marks.ts";
+import { linesOf } from "./lines.ts";
+
+/**
+ * A stated total time (所要時間：80分, Total time: 1 hr 20 min) against the sum of the times written in the numbered steps
+ * ((10分), bake for 40 minutes). The words come from the language packages; nothing here knows a language. Pure.
+ */
+export type StepTimeWords = {
+  readonly lengths: LengthWords;
+  /** Labels of a total time (所要時間, Total time), written before the length. */
+  readonly totals: readonly Mark[];
+  /** Marks of a rough figure (約, about, 程度): the total or a step that carries one is compared with a margin. */
+  readonly approximate: readonly Mark[];
+  /** Marks of a time that is not how long the step takes (10分後, every 5 minutes, after 10 minutes). */
+  readonly notOwn: readonly Mark[];
+  /** What joins the two ends of a range (10〜15分, 10 to 15 minutes): a step or total with a range is not read. */
+  readonly rangeJoiners: readonly string[];
+};
+
+/** A length of time with whether it was written as a rough figure. */
+export type ReadTime = Span & { readonly minutes: number; readonly approximate: boolean };
+
+export type StepTimeSlip = {
+  readonly total: ReadTime;
+  readonly sum: number;
+  readonly steps: number;
+  /** How far the sum may be from the total and still agree, in minutes: 0 unless a rough figure is involved. */
+  readonly margin: number;
+};
+
+/** A rough total agrees with a sum within this share of the total, and never less than ROUGH_MINUTES. */
+export const ROUGH_SHARE = 0.1;
+export const ROUGH_MINUTES = 5;
+const MIN_STEPS = 2;
+
+/** 1. or 1) with a space after it (so 1.5 hours is no step); the full-width 1．or 1）may run straight on. */
+const STEP_ITEM = /^\s*\p{Nd}{1,3}(?:[.)]\s|[．）])/u;
+const INDENTED = /^\s+\S/u;
+
+type ListRead = { readonly lists: Span[][]; readonly open: boolean; readonly lastLine: number };
+
+/** One line's place in the numbered lists: a new item, a line under the last item, a blank, or the end of the list. */
+const readLine = (read: ListRead, line: { readonly text: string; readonly start: number; readonly number: number }): ListRead => {
+  const end = line.start + line.text.length;
+  const list = read.lists[read.lists.length - 1];
+  const last = list?.[list.length - 1];
+  if (STEP_ITEM.test(line.text)) {
+    if (read.open && list !== undefined) list.push({ start: line.start, end });
+    else read.lists.push([{ start: line.start, end }]);
+    return { lists: read.lists, open: true, lastLine: line.number };
+  }
+  if (line.text.trim() === "") return read;
+  if (read.open && list !== undefined && last !== undefined && INDENTED.test(line.text)) {
+    if (read.lastLine === line.number - 1) list[list.length - 1] = { start: last.start, end };
+    return { ...read, lastLine: line.number };
+  }
+  return { ...read, open: false };
+};
+
+/** The numbered lists of the source, each a run of items with only blank or indented lines between them. An item holds its line and the indented lines right under it. */
+export const stepLists = (source: string): Span[][] => linesOf(source).reduce<ListRead>(readLine, { lists: [], open: false, lastLine: 0 }).lists;
+
+/** Every numbered step of the source. */
+export const stepItems = (source: string): Span[] => stepLists(source).flat();
+
+const lower = (text: string): string => text.toLowerCase();
+
+const sideOf = (marks: readonly Mark[], side: "before" | "after"): string[] =>
+  marks
+    .filter((mark) => (mark.position ?? "before") === side)
+    .map((mark) => lower(mark.pattern))
+    .filter((pattern) => pattern !== "")
+    .toSorted((left, right) => right.length - left.length);
+
+/** The mark written right before at (white space between only), and where it starts. */
+const markEndingAt = (text: string, at: number, patterns: readonly string[]): number | undefined => {
+  const head = lower(text.slice(0, at)).trimEnd();
+  const found = patterns.find((pattern) => isWordAt(head, head.length - pattern.length, pattern));
+  return found === undefined ? undefined : head.length - found.length;
+};
+
+/** Whether a mark is written right after at (white space between only). */
+const markStartingAt = (text: string, at: number, patterns: readonly string[]): boolean => {
+  const tail = lower(text.slice(at));
+  const gap = tail.length - tail.trimStart().length;
+  return patterns.some((pattern) => isWordAt(tail, gap, pattern));
+};
+
+const DIGIT_BEFORE = /\p{Nd}\s*$/u;
+
+/** Whether the length is the second end of a range: a joiner right before it, after a number, a number word or a unit (10〜15分, one to two hours, 10 minutes to 15 minutes). */
+const endsRange = (text: string, at: number, words: StepTimeWords): boolean => {
+  const start = markEndingAt(text, at, words.rangeJoiners.map(lower));
+  if (start === undefined) return false;
+  const { numberWords, hourUnits, minuteUnits } = words.lengths;
+  const ends = [...numberWords, ...hourUnits, ...minuteUnits].map(lower).filter((word) => word !== "");
+  return DIGIT_BEFORE.test(text.slice(0, start)) || markEndingAt(text, start, ends) !== undefined;
+};
+
+type Reading = { readonly time: ReadTime; readonly from: number; readonly own: boolean; readonly range: boolean };
+
+/** Each length in text, with where its rough-figure mark starts, whether it is the step's own time, and whether it ends a range. */
+const readingsOf = (text: string, words: StepTimeWords): Reading[] =>
+  timeLengths(text, words.lengths).map((length: TimeLength): Reading => {
+    const roughBefore = markEndingAt(text, length.start, sideOf(words.approximate, "before"));
+    const roughAfter = markStartingAt(text, length.end, sideOf(words.approximate, "after"));
+    const from = roughBefore ?? length.start;
+    const notOwn =
+      markEndingAt(text, from, sideOf(words.notOwn, "before")) !== undefined ||
+      (!roughAfter && markStartingAt(text, length.end, sideOf(words.notOwn, "after")));
+    return {
+      time: { start: length.start, end: length.end, minutes: length.minutes, approximate: roughBefore !== undefined || roughAfter },
+      from,
+      own: !notOwn,
+      range: endsRange(text, length.start, words),
+    };
+  });
+
+/** How long one step takes: its one own length of time. undefined when it has none, more than one, or a range. */
+export const stepTime = (text: string, words: StepTimeWords): ReadTime | undefined => {
+  const readings = readingsOf(text, words);
+  if (readings.some((reading) => reading.range)) return undefined;
+  const own = readings.filter((reading) => reading.own);
+  return own.length === 1 ? own[0]?.time : undefined;
+};
+
+const outside = (offset: number, items: readonly Span[]): boolean => !items.some((item) => offset >= item.start && offset < item.end);
+
+/** The totals written on one line. A line with a range (Total time: 10 to 15 minutes) states no exact total. */
+const totalsOn = (line: { readonly text: string; readonly start: number }, words: StepTimeWords): ReadTime[] => {
+  const readings = readingsOf(line.text, words);
+  if (readings.some((reading) => reading.range)) return [];
+  return readings.flatMap((reading): ReadTime[] => {
+    const label = labelOf(line.text, { start: reading.from, end: reading.time.end }, words.totals);
+    if (label === undefined || !reading.own) return [];
+    return [{ ...reading.time, start: line.start + reading.time.start, end: line.start + reading.time.end }];
+  });
+};
+
+/** The total time the source states outside its steps: a length with a total label right before it. Only one value is read. */
+export const statedTotal = (source: string, items: readonly Span[], words: StepTimeWords): ReadTime | undefined => {
+  const totals = linesOf(source)
+    .filter((line) => outside(line.start, items))
+    .flatMap((line) => totalsOn(line, words));
+  const values = new Set(totals.map((total) => total.minutes));
+  return values.size === 1 ? totals[0] : undefined;
+};
+
+/** The margin a rough figure allows: ROUGH_SHARE of the total, at least ROUGH_MINUTES. */
+export const marginOf = (total: number, rough: boolean): number => (rough ? Math.max(ROUGH_MINUTES, total * ROUGH_SHARE) : 0);
+
+/**
+ * The stated total against the sum of the steps' times, when the document has one numbered list, every step's time is readable,
+ * and they do not agree. Two lists may be two procedures, or one of them no procedure, so a document with two is not read.
+ */
+export const stepTimeSlip = (source: string, words: StepTimeWords): StepTimeSlip | undefined => {
+  const lists = stepLists(source);
+  const [items] = lists;
+  if (lists.length !== 1 || items === undefined || items.length < MIN_STEPS) return undefined;
+  const total = statedTotal(source, items, words);
+  if (total === undefined) return undefined;
+  const times = items.map((item) => stepTime(source.slice(item.start, item.end), words));
+  if (times.some((time) => time === undefined)) return undefined;
+  const sum = times.reduce((minutes, time) => minutes + (time?.minutes ?? 0), 0);
+  const margin = marginOf(total.minutes, total.approximate || times.some((time) => time?.approximate === true));
+  return Math.abs(sum - total.minutes) <= margin ? undefined : { total, sum, steps: items.length, margin };
+};

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/time-range.ts

@@ -0,0 +1,64 @@
+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）があるので、そのときは一時間未満の戻りだけを言う。
+ */
+
+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;
+};
+
+type Reading = { readonly from: number; readonly to: number; readonly borrowed: boolean };
+
+/** 範囲の二つの時刻を秒で。片方にだけ午前・午後があれば、もう片方もそれで読む。 */
+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 };
+  return { from: start.seconds, to: end.seconds, borrowed: false };
+};
+
+/** 終わりが始まりより前で、その戻りが打ち間違いの幅に収まるか。 */
+export const isReversed = (reading: Reading): boolean => {
+  const back = reading.from - reading.to;
+  return back > 0 && 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) } }];
+  });

package/src/structure/total-line.ts

@@ -0,0 +1,63 @@
+import { isTotalLabel, leadingText } from "./total.ts";
+import { outsideBrackets } from "./connection-times.ts";
+
+/** 合計の語に添える語。position が before なら合計の語の前だけ、after なら後ろだけ、無ければどちらにも置ける。 */
+export type TotalQualifier = { readonly pattern: string; readonly position?: "before" | "after" | undefined };
+
+/** labels: 合計の語（total-label）。qualifiers: 合計の語の前後に置いても合計の行のままの語（total-label-qualifier）。 */
+export type TotalLineWords = { readonly labels: readonly string[]; readonly qualifiers: readonly TotalQualifier[] };
+
+/** 見出しの終わり。区切り（: |）があればそこまで、無ければ金額の始まりまで。 */
+const SEPARATOR = /[:：|]/u;
+const AMOUNT_START = /[$€£¥￥\p{N}]/u;
+const EMPHASIS = /[*_]/gu;
+const SPACES = /\s+/u;
+
+const wordsOf = (text: string): string[] =>
+  text
+    .toLowerCase()
+    .split(SPACES)
+    .filter((word) => word.length > 0);
+
+const labelText = (lead: string): string => {
+  const separator = lead.search(SEPARATOR);
+  if (separator !== -1) return lead.slice(0, separator);
+  const amount = lead.search(AMOUNT_START);
+  return amount === -1 ? lead : lead.slice(0, amount);
+};
+
+/** 行頭の見出しを語に分ける。括弧の注記（(incl. tax)）と強調の印は除く。 */
+const labelWords = (text: string): string[] => wordsOf(outsideBrackets(labelText(leadingText(text))).replace(EMPHASIS, ""));
+
+const startsAt = (words: readonly string[], label: readonly string[], index: number): boolean => label.every((word, offset) => words[index + offset] === word);
+
+const allowedOn = (side: "before" | "after", qualifiers: readonly TotalQualifier[]): ReadonlySet<string> =>
+  new Set(
+    qualifiers.filter((qualifier) => qualifier.position !== (side === "before" ? "after" : "before")).map((qualifier) => qualifier.pattern.toLowerCase()),
+  );
+
+/** 見出しの語のどこかに合計の語が一つ続けてあり、その前と後ろの語がどれも、そちら側に置ける添える語か。 */
+const isQualifiedLabel = (words: readonly string[], label: readonly string[], qualifiers: readonly TotalQualifier[]): boolean => {
+  const before = allowedOn("before", qualifiers);
+  const after = allowedOn("after", qualifiers);
+  return (
+    label.length > 0 &&
+    words.some(
+      (_, index) =>
+        startsAt(words, label, index) &&
+        words.slice(0, index).every((word) => before.has(word)) &&
+        words.slice(index + label.length).every((word) => after.has(word)),
+    )
+  );
+};
+
+/**
+ * 合計の行か。合計の語で始まる行（Total、合計（月額））に加えて、合計の語に添える語だけを前後に置いた見出し
+ * （Total per month、Monthly total、Total due）も合計の行と読む。添える語でない語（Total area）が入れば読まない。
+ */
+export const isTotalLine = (text: string, words: TotalLineWords): boolean => {
+  if (isTotalLabel(text, words.labels)) return true;
+  if (words.qualifiers.length === 0) return false;
+  const label = labelWords(text);
+  return words.labels.some((total) => isQualifiedLabel(label, wordsOf(total), words.qualifiers));
+};