chaffjs 0.29.0 → 0.31.0

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-order.ts

@@ -13,7 +13,7 @@ import { crossesZones, dayShiftOf, withoutDayShiftBefore, zonesIn, SECONDS_PER_D
  */
 
 /** 頭に時刻を書いた項目。seconds は 0 時からの秒、shift は翌日の印（1）か無印（0）。 */
-type Stop = {
+export type Stop = {
   readonly offset: number;
   readonly written: string;
   readonly seconds: number;
@@ -130,11 +130,12 @@ const breaksIn = (day: readonly Stop[]): StructureIssue[] => {
   return values.slice(1).flatMap((value, index) => (value < (values[index] ?? "") ? issueAt(day, outOfPlace(values, index + 1, 1)) : []));
 };
 
-/** 一日の予定の時刻のうち、早い順から外れたもの。 */
-export const timeOrderBreaks = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords): StructureIssue[] => {
+/** 一日の予定として並べた時刻を、日ごとに。並びの中で日付か時間帯が変われば別の日。 */
+export const scheduleDays = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords): Stop[][] => {
   const inputs = { source, times, dates, words };
-  return runsOf(source).flatMap((run) => {
-    const stops = run.flatMap((line) => stopOf(line, inputs) ?? []);
-    return daysOf(stops).flatMap(breaksIn);
-  });
+  return runsOf(source).flatMap((run) => daysOf(run.flatMap((line) => stopOf(line, inputs) ?? [])));
 };
+
+/** 一日の予定の時刻のうち、早い順から外れたもの。 */
+export const timeOrderBreaks = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords): StructureIssue[] =>
+  scheduleDays(source, times, dates, words).flatMap(breaksIn);

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

package/src/structure/total.ts

@@ -8,7 +8,14 @@ import { bareNumbersIn, CELL_SEPARATOR, NO_UNIT } from "./bare-numbers.ts";
  * 小計と税のあとの総計のように、足し方が何通りかある。どの足し方でも合わないときだけ言う。
  * 表の升に数だけを書いた列（単位は見出しにある）も足す。そのときは上の行の升がどれも数でなければ足さない。年や番号の列を足さないため。
  */
-export type Amount = { readonly offset: number; readonly end: number; readonly value: number; readonly unit: string };
+export type Amount = {
+  readonly offset: number;
+  readonly end: number;
+  readonly value: number;
+  readonly unit: string;
+  /** 単位の付いた量（0.5 g）は、量の種類の一番小さい単位（mg）に直して足す。scale は書いた単位一つがその単位いくつか（g なら 1,000）。 */
+  readonly scale?: number;
+};
 
 const CENTS = 100;
 
@@ -36,7 +43,7 @@ const isNegative = (source: string, line: Line, amount: Amount): boolean => {
 };
 
 /** 行の最初の文字列（表なら最初の列）から、強調の印と箇条書きの印を除いたもの。 */
-const leadingText = (text: string): string =>
+export const leadingText = (text: string): string =>
   text
     .replace(/^[ \t]*(?:[-*+]|\d{1,3}[.)])?[ \t]*\|?[ \t]*/u, "")
     .replace(/^[*_]+/u, "")
@@ -58,8 +65,11 @@ const centsOf = (source: string, line: Line, amount: Amount): number | undefined
   return Math.round(amount.value * CENTS) * (isNegative(source, line, amount) ? -1 : 1);
 };
 
-const entryOf = (source: string, line: Line, amounts: readonly Amount[], labels: readonly string[]): Entry => ({
-  label: isTotalLabel(source.slice(line.start, line.end), labels),
+/** 行が合計の行か。語彙で決める判定は呼ぶ側が渡す。 */
+export type IsTotalLine = (text: string) => boolean;
+
+const entryOf = (source: string, line: Line, amounts: readonly Amount[], isTotal: IsTotalLine): Entry => ({
+  label: isTotal(source.slice(line.start, line.end)),
   amounts: amounts
     .filter((amount) => amount.offset >= line.start && amount.offset <= line.end)
     .map((amount) => ({ ...amount, column: columnOf(source, line, amount.offset), cents: centsOf(source, line, amount) })),
@@ -169,6 +179,30 @@ export const shownTotal = (source: string, total: Amount, sumCents: number): Rec
 const readsAsSum = (cell: Cell, writtenCents: number, above: RowsAbove): boolean =>
   cell.unit !== NO_UNIT || above.parts.some((part) => part < 0) || above.parts.every((part) => part < writtenCents);
 
+/** 書いた数の小数の桁（0.25 g なら 2）。 */
+const decimalsOf = (written: string): number => /[.．](\d+)/u.exec(written.normalize("NFKC"))?.[1]?.length ?? 0;
+
+/** 見せる和の小数の桁の上限。合計より細かい単位の内訳（1 g の合計に 250 mg の内訳）の和を、合計の単位で見せるため。 */
+const MAX_SHOWN_DECIMALS = 3;
+
+/** 換算の倍率が割り切れない単位（8 oz + 8 oz = 1 lb）で、丸めの差を合うとみなす割合。 */
+const MEASURE_TOLERANCE = 1e-6;
+
+/** 単位の付いた量の合計。和は合計に書いた単位と書き方で見せる（1 g の合計に 300 mg と 0.6 g の内訳なら 0.9 g）。 */
+const measuredMismatch = (source: string, total: Placed, scale: number, sums: readonly number[], reported: number): StructureIssue[] => {
+  const number = source.slice(total.offset, total.end);
+  const digits = decimalsOf(number);
+  const written = total.value * CENTS;
+  if (sums.some((sum) => Math.abs(sum - written) <= Math.abs(written) * MEASURE_TOLERANCE)) return [];
+  const inTotalUnit = (cents: number): number => cents / CENTS / scale;
+  const sum = inTotalUnit(reported).toLocaleString("en-US", {
+    minimumFractionDigits: digits,
+    maximumFractionDigits: Math.max(digits, MAX_SHOWN_DECIMALS),
+    useGrouping: !UNGROUPED.test(number),
+  });
+  return [{ offset: total.offset, values: { written: number, sum: `${sum}${unitAfterNumber(number, total.unit)}` } }];
+};
+
 const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue[] =>
   entries.flatMap((entry, index) => {
     if (!entry.label) return [];
@@ -176,16 +210,17 @@ const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue
       const writtenCents = valueIn(entry, total);
       const above = windowAbove(entries.slice(0, index), total);
       if (typeof writtenCents !== "number" || above === undefined || !enoughRows(above) || !readsAsSum(total, writtenCents, above)) return [];
+      if (total.scale !== undefined) return measuredMismatch(source, total, total.scale, candidateSums(above), reportedSum(above));
       if (candidateSums(above).includes(writtenCents)) return [];
       return [{ offset: total.offset, values: shownAmounts(source, total, reportedSum(above)) }];
     });
   });
 
-export const totalMismatches = (source: string, amounts: readonly Amount[], labels: readonly string[]): StructureIssue[] =>
+export const totalMismatches = (source: string, amounts: readonly Amount[], isTotal: IsTotalLine): StructureIssue[] =>
   runsOf(source).flatMap((run) => {
     const inRun = [...amounts, ...bareNumbersIn(source, run)];
     return mismatchesIn(
       source,
-      run.map((line) => entryOf(source, line, inRun, labels)),
+      run.map((line) => entryOf(source, line, inRun, isTotal)),
     );
   });