chaffjs 0.31.0 → 0.33.0

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

@@ -9,6 +9,7 @@ import { dayShiftOf, type TimeSpan, type TimeWords } from "./time-marks.ts";
  * 夜をまたぐ範囲（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;
@@ -35,20 +36,25 @@ const borrowed = (bare: number, written: number): number => {
   return bare;
 };
 
-type Reading = { readonly from: number; readonly to: number; readonly borrowed: boolean };
+/** 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 };
-  return { from: start.seconds, to: end.seconds, borrowed: false };
+  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;
-  return back > 0 && back < (reading.borrowed ? BORROWED_SLIP_SECONDS : SLIP_SECONDS);
+  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: "" });

package/src/structure/total-line.ts

@@ -1,11 +1,29 @@
 import { isTotalLabel, leadingText } from "./total.ts";
+import { CELL_SEPARATOR } from "./bare-numbers.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[] };
+/**
+ * labels: 合計の語（total-label）。qualifiers: 合計の語の前後に置いても合計の行のままの語（total-label-qualifier）。
+ * nounQualifiers: 合計に付けた名詞の前後に置いても、数える物を変えない語（total-noun-qualifier。修得単位の修得、credits earned の earned）。
+ * unsummedNouns: 上の行の和とは限らない量の名詞（total-noun-unsummed。部屋を並べた表の Total area は、廊下も含みうる）。
+ */
+export type TotalLineWords = {
+  readonly labels: readonly string[];
+  readonly qualifiers: readonly TotalQualifier[];
+  readonly nounQualifiers?: readonly TotalQualifier[] | undefined;
+  readonly unsummedNouns?: readonly string[] | undefined;
+  /** 合計が足す期間の語（total-period-qualifier。年間合計の年間、Total for the year の for the year）。見出しの頭か尻から除いて読む。 */
+  readonly periodQualifiers?: readonly TotalQualifier[] | undefined;
+  /** それだけで一年の合計を言う合計の語（total-label の group period。年額）。期間の語を付けた合計と同じに読む。 */
+  readonly periodLabels?: readonly string[] | undefined;
+  /** 見出しが名指さなくても上の行の和と読める合計の名詞（total-noun-listed。差引合計の差引、Total deductions の deductions）。 */
+  readonly listedNouns?: readonly string[] | undefined;
+  /** 差し引きで決まる金額の名前（net-amount-label。総支給額、Gross pay）。表の行がこの名前なら、表は一つの和の内訳ではない。 */
+  readonly amountNames?: readonly string[] | undefined;
+};
 
 /** 見出しの終わり。区切り（: |）があればそこまで、無ければ金額の始まりまで。 */
 const SEPARATOR = /[:：|]/u;
@@ -51,13 +69,164 @@ const isQualifiedLabel = (words: readonly string[], label: readonly string[], qu
   );
 };
 
+/** 語の変化（deduction と deductions、控除と控除項目）とみなす、長い方の語の終わりの文字数の上限。 */
+const INFLECTION_SLACK = 2;
+/** 見出しが名指す語の短さの下限。一文字の語（設計の「設」）は名指しとみなさない。 */
+const MIN_NOUN_LENGTH = 2;
+/** 英字と数字。合計の語がこの字で始まる・終わるなら、隣の字が同じ種類でないときだけ語の切れ目とみなす。 */
+const WORD_CHAR = /[a-z0-9]/u;
+
+/** 同じ語か。どちらかがもう一方で始まり、残りが二文字まで（deduction と deductions、控除と控除項目）なら同じ語と読む。 */
+const sameWord = (left: string, right: string): boolean => {
+  const [shorter, longer] = left.length <= right.length ? [left, right] : [right, left];
+  return shorter.length >= MIN_NOUN_LENGTH && longer.startsWith(shorter) && longer.length - shorter.length <= INFLECTION_SLACK;
+};
+
+/** 名詞と見出しの語が一つずつ対応するか。見出しに名詞の無い語（Tax deduction の deduction）があれば、別の種類の量と読む。 */
+const namesEachOther = (nouns: readonly string[], headerWords: readonly string[]): boolean =>
+  nouns.length > 0 &&
+  nouns.every((noun) => headerWords.some((word) => sameWord(noun, word))) &&
+  headerWords.every((word) => nouns.some((noun) => sameWord(noun, word)));
+
+/** 二つの字が続けて一つの英数字の語になるか。 */
+const joinsWord = (left: string | undefined, right: string | undefined): boolean => WORD_CHAR.test(left ?? "") && WORD_CHAR.test(right ?? "");
+
+const boundedAt = (text: string, total: string, index: number): boolean =>
+  !joinsWord(text[index - 1], total[0]) && !joinsWord(total.at(-1), text[index + total.length]);
+
+/** 名詞に添える語を、語の頭（修得単位の修得）と尻から除く。英数字の語の途中（earnedincome）では切らない。 */
+const withoutNounQualifiers = (word: string, before: ReadonlySet<string>, after: ReadonlySet<string>): string => {
+  const prefix = [...before].find((qualifier) => qualifier.length > 0 && word.startsWith(qualifier) && !joinsWord(qualifier.at(-1), word[qualifier.length]));
+  const rest = prefix === undefined ? word : word.slice(prefix.length);
+  const suffix = [...after].find(
+    (qualifier) => qualifier.length > 0 && rest.endsWith(qualifier) && !joinsWord(rest[rest.length - qualifier.length - 1], qualifier[0]),
+  );
+  return suffix === undefined ? rest : rest.slice(0, rest.length - suffix.length);
+};
+
+/** 数を書いた升。強調の印と負の印（-、▲）と通貨の記号は、数の前に置ける。 */
+const NUMBER_CELL = /^[*_]*[-−▲△]?[ \t]?[$€£¥￥]?[ \t]?[-−]?\p{N}/u;
+
+/** 表の行の升。行頭の区切り（|）の前は升にしない。 */
+const cellsOf = (row: string): string[] => row.trim().replace(/^\|/u, "").split(CELL_SEPARATOR);
+
+/** 合計の行が数を書いた列の見出し。最初の列（合計の語を書いた列）は除く。 */
+const summedColumnHeaders = (row: string, header: string): string[] => {
+  const headers = cellsOf(header);
+  return cellsOf(row)
+    .map((cell, column) => ({ cell: cell.trim(), column }))
+    .filter(({ cell, column }) => column > 0 && NUMBER_CELL.test(cell))
+    .map(({ column }) => headers[column] ?? "");
+};
+
+type Split = { readonly before: readonly string[]; readonly after: readonly string[] };
+
+/** 見出しの中の合計の語の位置ごとに、その前と後ろの語。日本語の「控除合計」は、合計の語の前の「控除」を一語にする。 */
+const splitsAround = (text: string, total: string): Split[] =>
+  Array.from({ length: text.length }, (_, index) => index)
+    .filter((index) => total.length > 0 && text.startsWith(total, index) && boundedAt(text, total, index))
+    .map((index) => ({ before: wordsOf(text.slice(0, index)), after: wordsOf(text.slice(index + total.length)) }));
+
 /**
- * 合計の行か。合計の語で始まる行（Total、合計（月額））に加えて、合計の語に添える語だけを前後に置いた見出し
- * （Total per month、Monthly total、Total due）も合計の行と読む。添える語でない語（Total area）が入れば読まない。
+ * 合計の語に、添える語のほかに名詞（控除、deductions）を付けた見出しが、表の見出しが名指す項目の合計か。名指すのは、最初の列の
+ * 見出し（控除項目の表の控除合計）か、合計の行が数を書いたどの列の見出し（単位数の列の修得単位合計）でもよい。名詞が見出しに
+ * 無ければ、別の種類の量（Total tax、Total area）かもしれないので読まない。
  */
-export const isTotalLine = (text: string, words: TotalLineWords): boolean => {
+/** 合計の語の前後の語から、合計の語に添える語を除き、残った名詞から名詞に添える語（修得、earned）を除く。 */
+const nounsOf = (split: Split, words: TotalLineWords): string[] => {
+  const before = allowedOn("before", words.qualifiers);
+  const after = allowedOn("after", words.qualifiers);
+  const nounBefore = allowedOn("before", words.nounQualifiers ?? []);
+  const nounAfter = allowedOn("after", words.nounQualifiers ?? []);
+  return [...split.before.filter((word) => !before.has(word)), ...split.after.filter((word) => !after.has(word))]
+    .map((word) => withoutNounQualifiers(word, nounBefore, nounAfter))
+    .filter((word) => word.length > 0);
+};
+
+const isUnsummed = (nouns: readonly string[], unsummedNouns: readonly string[]): boolean =>
+  nouns.some((noun) => unsummedNouns.some((word) => sameWord(noun, word.toLowerCase())));
+
+/**
+ * 合計の語に、添える語のほかに名詞（控除、deductions）を付けた見出しが、表の見出しが名指す項目の合計か。名指すのは、最初の列の
+ * 見出し（控除項目の表の控除合計）か、合計の行が数を書いたどの列の見出し（単位数の列の修得単位合計）でもよい。名詞が見出しに
+ * 無ければ、別の種類の量（Total tax、Total area）かもしれないので読まない。
+ */
+const isNamedTotal = (text: string, words: TotalLineWords, header: string): boolean => {
+  const label = labelWords(text).join(" ");
+  const firstColumn = labelWords(header);
+  const columns = summedColumnHeaders(text, header).map(labelWords);
+  const namesTotal = (nouns: readonly string[]): boolean =>
+    !isUnsummed(nouns, words.unsummedNouns ?? []) &&
+    (namesEachOther(nouns, firstColumn) || (columns.length > 0 && columns.every((headerWords) => namesEachOther(nouns, headerWords))));
+  return words.labels.some((total) => splitsAround(label, total.toLowerCase()).some((split) => namesTotal(nounsOf(split, words))));
+};
+
+/** 合計の語だけか、合計の語に添える語だけを前後に置いた見出しか。 */
+const isPlainTotal = (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));
 };
+
+/** 期間の語の端の英数字（inner）が、その外の字（outer）へ続くか。空白でない字（year-to-date の -）なら続くとみなす。 */
+const continuesWord = (inner: string | undefined, outer: string | undefined): boolean =>
+  WORD_CHAR.test(inner ?? "") && outer !== undefined && !SPACES.test(outer);
+
+/** 見出しの頭（before）か尻（after）から期間の語を除いた残り。語の途中（yearly の year、year-to-date の year）では切らない。 */
+export const withoutPeriod = (label: string, qualifier: TotalQualifier): string | undefined => {
+  const pattern = qualifier.pattern.toLowerCase();
+  if (pattern.length === 0) return undefined;
+  if (qualifier.position !== "after" && label.startsWith(pattern) && !continuesWord(pattern.at(-1), label[pattern.length]))
+    return label.slice(pattern.length).trim();
+  if (qualifier.position !== "before" && label.endsWith(pattern) && !continuesWord(pattern[0], label[label.length - pattern.length - 1]))
+    return label.slice(0, label.length - pattern.length).trim();
+  return undefined;
+};
+
+/**
+ * 合計が足す期間の語（年間、for the year）を見出しの頭か尻から除くと合計の行になるか（年間合計、年計、Total for the year、Year total）。
+ * 前の年の合計（前年合計、Prior-year total）は、期間の語が頭にも尻にも無いので読まない。
+ */
+export const isPeriodTotalLine = (text: string, words: TotalLineWords): boolean => {
+  if (isTotalLabel(text, words.periodLabels ?? [])) return true;
+  const label = labelWords(text).join(" ");
+  return (words.periodQualifiers ?? []).some((qualifier) => {
+    const rest = withoutPeriod(label, qualifier);
+    return rest !== undefined && rest.length > 0 && isPlainTotal(rest, words);
+  });
+};
+
+/**
+ * 合計の行か。合計の語で始まる行（Total、合計（月額））に加えて、合計の語に添える語だけを前後に置いた見出し
+ * （Total per month、Monthly total、Total due）も合計の行と読む。添える語でない語（Total area）が入れば読まない。
+ * 合計が足す期間の語を付けた見出し（年間合計、Total for the year）も合計の行と読む。
+ * 表の見出しの行（header）を渡せば、その見出しが名指す名詞を付けた見出し（控除項目の表の控除合計、単位数の列の修得単位合計）も合計の行と読む。
+ */
+export const isTotalLine = (text: string, words: TotalLineWords, header?: string): boolean =>
+  isPlainTotal(text, words) || isPeriodTotalLine(text, words) || (header !== undefined && isNamedTotal(text, words, header));
+
+/** 見出しの合計の語の位置ごとに、合計の語に添える語を除いた名詞。 */
+const nounSplitsOf = (text: string, words: TotalLineWords): string[][] => {
+  const label = labelWords(text).join(" ");
+  return words.labels.flatMap((total) => splitsAround(label, total.toLowerCase()).map((split) => nounsOf(split, words)));
+};
+
+/**
+ * 合計の語に、見出しが名指さなくても上の行の和と読める名詞（total-noun-listed）だけを付けた見出しか（差引合計、Total deductions）。
+ * 名詞は一語のまま比べる（差引支給合計の差引支給は読まない）。
+ */
+export const isListedTotal = (text: string, words: TotalLineWords): boolean => {
+  const listed = new Set((words.listedNouns ?? []).map((noun) => noun.toLowerCase()));
+  return nounSplitsOf(text, words).some((nouns) => nouns.length > 0 && nouns.every((noun) => listed.has(noun)));
+};
+
+/** 見出しが差し引きで決まる金額の名前（総支給額、Gross pay）そのものか。 */
+export const isAmountNameLine = (text: string, words: TotalLineWords): boolean => {
+  const label = labelWords(text).join(" ");
+  return (words.amountNames ?? []).some((name) => wordsOf(name).join(" ") === label);
+};
+
+/** 合計のような行か。合計の行、見出しのどこかに合計の語がある行（支給合計、Total earnings）、差し引きの名前の行（総支給額、Gross pay）。 */
+export const isTotalLikeLine = (text: string, words: TotalLineWords, header?: string): boolean =>
+  isTotalLine(text, words, header) || nounSplitsOf(text, words).length > 0 || isAmountNameLine(text, words);

package/src/structure/total-row-blank.ts

@@ -0,0 +1,23 @@
+// A total, subtotal or tax row of a priced table fills only the amount: its quantity and unit-price cells are blank
+// because they have nothing to say (| 合計 | | | 48,400円 |). Pure; the caller decides which rows are total rows.
+
+/** One body row: whether its first cell is a total or tax label, and each cell's text (undefined when blank). */
+export type BodyRow = { readonly total: boolean; readonly cells: readonly (string | undefined)[] };
+
+const FIGURE = /\p{Nd}/u;
+
+/** Whether every filled cell of a column, in the rows that are not totals, holds a figure, and at least one is filled. */
+const isFigureColumn = (rows: readonly BodyRow[], column: number): boolean => {
+  const filled = rows.filter((row) => !row.total).flatMap((row) => row.cells[column] ?? []);
+  return filled.length > 0 && filled.every((text) => FIGURE.test(text));
+};
+
+/** The amount column: the rightmost column after the first whose item rows all give a figure. Undefined when none does. */
+export const amountColumnOf = (rows: readonly BodyRow[], columns: number): number | undefined =>
+  Array.from({ length: columns }, (_unused, column) => column)
+    .slice(1)
+    .findLast((column) => isFigureColumn(rows, column));
+
+/** A blank a total row may leave: any cell but the amount, and only in a table that has an amount column to fill. */
+export const isTotalRowGap = (row: BodyRow, column: number, amountColumn: number | undefined): boolean =>
+  row.total && amountColumn !== undefined && column !== amountColumn;