chaffjs 0.30.0 → 0.32.0

package/src/structure/discount-rate.ts

@@ -0,0 +1,209 @@
+// discount-rate-mismatch: a volume-tier price list whose discount is not what its tier price and its list price give (list
+// 8.0円 a sheet, 7.2円 at 1,000 sheets is 10% off, and the row says 15%). The list price is a column of the table, else the
+// one price the document states as the list price: a sentence (「定価は1枚8.0円」, "The list price is $0.080 per envelope")
+// or a row (| 定価 | 8.0円 |). Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf, sameUnit } from "./order-quantity.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+/** rate: the discount column. price: the price after the discount. list: the list price. not: a rate that is no discount (tax). per: a unit mark. */
+export type DiscountRole = "rate" | "price" | "list" | "not" | "per";
+export type DiscountWord = { readonly pattern: string; readonly role: DiscountRole };
+/** A line outside tables and the amounts of money written in it, each at its offset in the line. */
+export type MoneyLine = { readonly text: string; readonly amounts: readonly { readonly offset: number; readonly written: string }[] };
+export type DiscountText = { readonly tables: readonly ChangeTable[]; readonly lines: readonly MoneyLine[] };
+
+type Price = { readonly value: number; readonly marks: string; readonly unit: string | undefined; readonly text: string };
+type StatedRate = { readonly value: number; readonly decimals: number; readonly written: string };
+type Columns = {
+  readonly rate: number;
+  readonly price: number;
+  readonly list: number | undefined;
+  readonly priceUnit: string | undefined;
+  readonly listUnit: string | undefined;
+};
+
+/** A discount written 10%, 12.5 %, -10%, △10%, or in tenths 1割 / 1割5分 (15%). */
+const PERCENT_RATE = /^[-−▲△]?\s*(\d{1,3})(?:\.(\d+))?\s*%$/u;
+const TENTHS_RATE = /^([1-9])割(?:([1-9])分)?$/u;
+const TENTH = 10;
+const HUNDRED = 100;
+const DECIMAL_BASE = 10;
+/** A unit after its mark: 枚 in 1枚, envelope in "per envelope", box in /box. Hiragana ends it (1枚の単価, 1枚あたり). */
+const UNIT_WORD = /^\s*([\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}ー]+)/u;
+const DIGIT_BEFORE = /[\d.,]$/u;
+/** What may stand between a list-price word and its amount once a unit is out: 「定価は1枚8.0円」, "List price: $0.080", "is". */
+const GAP_MARKS = /[\s:：=、,（()）*_.]/gu;
+const GAP_WORDS: readonly string[] = ["あたり", "当たり", "につき", "税抜き", "税抜", "税込み", "税込", "税別", "は", "が", "の"];
+const GAP_LATIN = /^(?:is|was|of|at|each|excl|excluding|incl|including|tax)$/u;
+/** A sentence ends at 。 or at a full stop before a space or the line's end ($0.080 is one amount). */
+const SENTENCE_END = /。|\.(?=\s|$)/u;
+/** A unit after the amount belongs to it up to the next comma: "$0.080 per envelope, excluding tax". */
+const CLAUSE_END = /[,、，]/u;
+const KEY_VALUE_CELLS = 2;
+const ROLE_ORDER: readonly DiscountRole[] = ["list", "price"];
+
+const wordsOf = (words: readonly DiscountWord[], role: DiscountRole): string[] => words.filter((word) => word.role === role).map((word) => word.pattern);
+
+const LATIN_END = /[a-z]$/u;
+
+/** A word as it stands in a lowercased text: a Latin word whole (per is not in "upper"), anything else as written. */
+const wordPattern = (word: string): string => {
+  const written = escapeRegExp(plain(word).toLowerCase());
+  return LATIN_END.test(word.toLowerCase()) ? `(?<![a-z0-9])${written}(?![a-z0-9])` : written;
+};
+
+/**
+ * A discount column heading holds a rate word outside its price words (割引 is not read in 割引後の単価) and no not word;
+ * else it is a list price, then a price.
+ */
+const roleOf = (heading: string, words: readonly DiscountWord[]): DiscountRole | undefined => {
+  const key = plain(heading).toLowerCase();
+  const held = (role: DiscountRole, text = key): boolean => wordsOf(words, role).some((word) => holds(text, word));
+  const outsidePrices = wordsOf(words, "price").reduce((left, word) => left.replace(new RegExp(wordPattern(word), "gu"), " "), key);
+  if (held("rate", outsidePrices)) return held("not") ? "not" : "rate";
+  return ROLE_ORDER.find((role) => held(role));
+};
+
+/** The discount as written: 10%, 1割5分. Undefined for anything else and for 100% and more. */
+export const discountIn = (text: string): StatedRate | undefined => {
+  const written = plain(text);
+  const percent = PERCENT_RATE.exec(written);
+  const tenths = TENTHS_RATE.exec(written);
+  if (percent !== null) {
+    const value = Number(`${percent[1] ?? ""}.${percent[2] ?? "0"}`);
+    return value < HUNDRED ? { value, decimals: percent[2]?.length ?? 0, written } : undefined;
+  }
+  if (tenths === null) return undefined;
+  const value = Number(tenths[1]) * TENTH + Number(tenths[2] ?? 0);
+  return { value, decimals: 0, written };
+};
+
+/** Each unit after a per mark that is not part of a number (1枚, not the 1 of 10枚): where it starts, where it ends, and the unit. */
+const unitsIn = (text: string, words: readonly DiscountWord[]): { readonly start: number; readonly end: number; readonly unit: string }[] => {
+  const key = text.toLowerCase();
+  return wordsOf(words, "per").flatMap((mark) =>
+    [...key.matchAll(new RegExp(wordPattern(mark), "gu"))].flatMap((match) => {
+      const after = match.index + match[0].length;
+      const unit = UNIT_WORD.exec(key.slice(after));
+      if (unit?.[1] === undefined || DIGIT_BEFORE.test(key.slice(0, match.index))) return [];
+      return [{ start: match.index, end: after + unit[0].length, unit: unit[1] }];
+    }),
+  );
+};
+
+/** The one unit a price is of (1枚, "per envelope", 円/枚); undefined when none or two. */
+export const unitOf = (text: string, words: readonly DiscountWord[]): string | undefined => {
+  const units = [...new Set(unitsIn(text, words).map((found) => found.unit))];
+  return units.length === 1 ? units[0] : undefined;
+};
+
+const priceIn = (text: string, unit: string | undefined): Price | undefined => {
+  const value = valueIn(text);
+  return value === undefined || value.value <= 0 ? undefined : { value: value.value, marks: value.marks, unit, text: plain(text) };
+};
+
+/** Only marks and filler words: 「は」, ": ", " is ", " (excl. tax): ". */
+const isGap = (text: string): boolean =>
+  text
+    .toLowerCase()
+    .split(GAP_MARKS)
+    .every((part) => part === "" || GAP_LATIN.test(part) || GAP_WORDS.reduce((left, word) => left.replaceAll(word, ""), part) === "");
+
+const withoutUnits = (text: string, words: readonly DiscountWord[]): string =>
+  unitsIn(text, words)
+    .toSorted((left, right) => right.start - left.start)
+    .reduce((left, found) => left.slice(0, found.start) + left.slice(found.end), text);
+
+/** Each price a line states as the list price: the amount right after a list word, with only fillers and a unit between. */
+const sentencePrices = (line: MoneyLine, words: readonly DiscountWord[]): Price[] => {
+  const key = line.text.toLowerCase();
+  return wordsOf(words, "list").flatMap((word) =>
+    [...key.matchAll(new RegExp(wordPattern(word), "gu"))].flatMap((match) => {
+      const from = match.index + match[0].length;
+      const amount = line.amounts.find((found) => found.offset >= from);
+      if (amount === undefined) return [];
+      const gap = line.text.slice(from, amount.offset);
+      if (!isGap(withoutUnits(gap, words))) return [];
+      const rest = line.text.slice(amount.offset + amount.written.length).split(SENTENCE_END)[0] ?? "";
+      const price = priceIn(amount.written, unitOf(gap, words) ?? unitOf(rest.split(CLAUSE_END)[0] ?? "", words));
+      return price === undefined ? [] : [price];
+    }),
+  );
+};
+
+/** A table row that is a list price: its first cell holds a list word; the price is the price column's cell, or a two-cell row's second. */
+const rowPrice = (row: readonly TableCell[], words: readonly DiscountWord[], priceColumn: number | undefined, unit: string | undefined): Price[] => {
+  const [label] = row;
+  if (label === undefined || roleOf(label.text, words) !== "list") return [];
+  const keyValue = row.length === KEY_VALUE_CELLS ? row[1] : undefined;
+  const cell = priceColumn === undefined ? keyValue : row[priceColumn];
+  const price = cell === undefined ? undefined : priceIn(cell.text, unitOf(label.text, words) ?? unit);
+  return price === undefined ? [] : [price];
+};
+
+const onlyIndex = (indexes: readonly number[]): number | undefined => (indexes.length === 1 ? indexes[0] : undefined);
+
+const columnsOf = (table: ChangeTable, words: readonly DiscountWord[]): Columns | undefined => {
+  const roles = table.header.map((cell) => roleOf(cell.text, words));
+  const at = (role: DiscountRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const [rate, price, lists] = [onlyIndex(at("rate")), onlyIndex(at("price")), at("list")];
+  if (rate === undefined || price === undefined || lists.length > 1) return undefined;
+  const list = lists[0];
+  const [priceUnit, listUnit] = [
+    unitOf(table.header[price]?.text ?? "", words),
+    list === undefined ? undefined : unitOf(table.header[list]?.text ?? "", words),
+  ];
+  return { rate, price, list, priceUnit, listUnit };
+};
+
+/** The one list price the document states in a sentence or a table row; undefined when none, or two different ones. */
+const statedListPrice = (text: DiscountText, words: readonly DiscountWord[]): Price | undefined => {
+  const fromTables = text.tables.flatMap((table) => {
+    const columns = columnsOf(table, words);
+    return bodyRows(table).flatMap((row) => rowPrice(row, words, columns?.price, columns?.priceUnit));
+  });
+  const prices = [...text.lines.flatMap((line) => sentencePrices(line, words)), ...fromTables];
+  const distinct = new Set(prices.map((price) => `${String(price.value)}|${price.marks}|${price.unit ?? ""}`));
+  return distinct.size === 1 ? prices[0] : undefined;
+};
+
+/** Whether the stated rate is the discount within its own rounding, or the tier price is the list less the rate within the price's. */
+export const discountMatches = (list: number, tier: number, stated: number, decimals: number, tierStep: number): boolean => {
+  const computed = (1 - tier / list) * HUNDRED;
+  const rateStep = DECIMAL_BASE ** -decimals;
+  const epsilon = 1e-9;
+  return Math.abs(computed - stated) < rateStep - epsilon || Math.abs(list * (1 - stated / HUNDRED) - tier) < tierStep - epsilon;
+};
+
+/** The row's list price: its list column's cell, else the stated one; undefined when its unit is not the tier price's. */
+const listPriceOf = (row: readonly TableCell[], columns: Columns, stated: Price | undefined): Price | undefined => {
+  const listCell = columns.list === undefined ? undefined : row[columns.list];
+  const list = listCell === undefined ? stated : priceIn(listCell.text, columns.listUnit);
+  const otherUnit = list?.unit !== undefined && columns.priceUnit !== undefined && !sameUnit(list.unit, columns.priceUnit);
+  return otherUnit ? undefined : list;
+};
+
+const rowIssue = (row: readonly TableCell[], columns: Columns, stated: Price | undefined): StructureIssue[] => {
+  const [rateCell, priceCell] = [row[columns.rate], row[columns.price]];
+  const list = listPriceOf(row, columns, stated);
+  const rate = rateCell === undefined ? undefined : discountIn(rateCell.text);
+  const tier = priceCell === undefined ? undefined : valueIn(priceCell.text);
+  if (rateCell === undefined || list === undefined || rate === undefined || tier === undefined || tier.marks !== list.marks) return [];
+  // A price not below the list price is no tier price: an invoice's price before its discount, another unit, a surcharge.
+  if (tier.value >= list.value || discountMatches(list.value, tier.value, rate.value, rate.decimals, tier.step)) return [];
+  const computed = ((1 - tier.value / list.value) * HUNDRED).toFixed(rate.decimals);
+  const values = { written: rate.written, expected: `${computed}%`, list: list.text, price: plain(priceCell?.text ?? "") };
+  return [{ offset: offsetOf(rateCell), values }];
+};
+
+/** Each discount in a tier table that its row's price and the list price do not give. */
+export const discountRateMismatches = (text: DiscountText, words: readonly DiscountWord[]): StructureIssue[] => {
+  if (words.length === 0) return [];
+  const stated = statedListPrice(text, words);
+  return text.tables.flatMap((table) => {
+    const columns = columnsOf(table, words);
+    return columns === undefined ? [] : bodyRows(table).flatMap((row) => rowIssue(row, columns, stated));
+  });
+};

package/src/structure/due-date.ts

@@ -1,6 +1,5 @@
+import { datesOutOfOrder } from "./labelled-date-order.ts";
 import type { StructureIssue } from "./issues.ts";
-import { linesOf } from "./lines.ts";
-import { isTotalLabel } from "./total.ts";
 
 /**
  * A due date before the issue date. A line (or a list item, or a table's first column) starting with an issue-date word
@@ -10,37 +9,14 @@ import { isTotalLabel } from "./total.ts";
  */
 export type DueWords = { readonly issue: readonly string[]; readonly due: readonly string[]; readonly passed: readonly string[] };
 
-/** How many lines from the issue date a due date may be and still be read as the same document's deadline. */
-const MAX_LINE_GAP = 8;
-
 /** A date of the structure tree: where it starts and its value (2026-11-25). */
 export type DatedPoint = { readonly offset: number; readonly value: string };
 
-const FULL_DATE = /^\d{4}-\d{2}-\d{2}$/u;
-
-type Labelled = { readonly kind: "issue" | "due"; readonly date: DatedPoint; readonly line: number };
-
-const kindOf = (text: string, words: DueWords): Labelled["kind"] | undefined => {
-  if (isTotalLabel(text, words.issue)) return "issue";
-  return isTotalLabel(text, words.due) ? "due" : undefined;
-};
-
-const labelledDates = (source: string, dates: readonly DatedPoint[], words: DueWords): Labelled[] =>
-  linesOf(source).flatMap((line) => {
-    const passed = words.passed.some((word) => line.text.toLowerCase().includes(word.toLowerCase()));
-    const kind = passed ? undefined : kindOf(line.text, words);
-    const end = line.start + line.text.length;
-    const onLine = dates.filter((date) => date.offset >= line.start && date.offset <= end && FULL_DATE.test(date.value));
-    const [date] = onLine;
-    return kind === undefined || date === undefined || onLine.length > 1 ? [] : [{ kind, date, line: line.number }];
-  });
+/** How many lines from the issue date a due date may be and still be read as the same document's deadline. */
+const MAX_LINE_GAP = 8;
 
-export const dueBeforeIssue = (source: string, dates: readonly DatedPoint[], words: DueWords): StructureIssue[] => {
-  if (words.issue.length === 0 || words.due.length === 0) return [];
-  const labelled = labelledDates(source, dates, words);
-  const issued = labelled.find((entry) => entry.kind === "issue");
-  if (issued === undefined) return [];
-  return labelled
-    .filter((entry) => entry.kind === "due" && entry.date.value < issued.date.value && Math.abs(entry.line - issued.line) < MAX_LINE_GAP)
-    .map((entry) => ({ offset: entry.date.offset, values: { due: entry.date.value, issued: issued.date.value } }));
-};
+export const dueBeforeIssue = (source: string, dates: readonly DatedPoint[], words: DueWords): StructureIssue[] =>
+  datesOutOfOrder(source, dates, { earlier: words.issue, later: words.due, passed: words.passed, maxLineGap: MAX_LINE_GAP }).map(({ earlier, later }) => ({
+    offset: later.date.offset,
+    values: { due: later.date.value, issued: earlier.date.value },
+  }));

package/src/structure/generic-role.ts

@@ -0,0 +1,8 @@
+/**
+ * A role word in the plural with nothing before it at the head of a sentence (Customers who register …, Buyers may …) is
+ * the ordinary noun, capitalised because it opens the sentence. A contract that calls a party by its role writes it in the
+ * singular (Vendor shall …) or with an article (the Vendors).
+ */
+const PLURAL = /^s(?![\p{L}\p{N}'’])/u;
+
+export const isGenericPlural = (bare: boolean, after: string): boolean => bare && PLURAL.test(after);

package/src/structure/gpa.ts

@@ -0,0 +1,218 @@
+// gpa-mismatch: a written grade-point average ("GPA: 3.00") that the course rows of the same document do not give, as
+// Σ(grade points × credits) / Σ credits. Columns are named by heading words, grade points come from the document's own
+// grading key ("S (4), A (3)") or from one unambiguous scale of the grade-point lexicon. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { escapeRegExp } from "../orthography.ts";
+
+export type TranscriptRole = "points" | "grade" | "credits" | "course" | "total";
+export type TranscriptWord = { readonly pattern: string; readonly role: TranscriptRole };
+/** A grade word on one scale, with its points; undefined points is a grade that carries none (Pass, 認定). */
+export type GradeWord = { readonly pattern: string; readonly scale: string; readonly points?: number };
+export type GpaLabel = { readonly pattern: string; readonly part: boolean };
+export type GpaWords = {
+  readonly columns: readonly TranscriptWord[];
+  readonly grades: readonly GradeWord[];
+  readonly labels: readonly GpaLabel[];
+};
+export type TextLine = { readonly text: string; readonly start: number };
+
+/** Grade-points columns first, so "Grade points" is not the grade column. */
+const ROLE_ORDER: readonly TranscriptRole[] = ["points", "grade", "credits", "course"];
+
+const roleOf = (heading: string, words: readonly TranscriptWord[]): TranscriptRole | undefined => {
+  const key = plain(heading).toLowerCase();
+  return ROLE_ORDER.find((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+};
+
+type CourseColumns = { readonly grade: number; readonly credits: number };
+
+/** A course table: at least one course column, and exactly one grade and one credits column. */
+export const courseColumnsOf = (headings: readonly string[], words: readonly TranscriptWord[]): CourseColumns | undefined => {
+  const roles = headings.map((heading) => roleOf(heading, words));
+  const all = (role: TranscriptRole): number[] => roles.flatMap((found, index) => (found === role ? [index] : []));
+  const [grades, credits] = [all("grade"), all("credits")];
+  const [grade, credit] = [grades[0], credits[0]];
+  if (all("course").length === 0 || grades.length !== 1 || credits.length !== 1 || grade === undefined || credit === undefined) return undefined;
+  return { grade, credits: credit };
+};
+
+/** One course row as written: its grade word and its credits cell. */
+export type CourseRow = { readonly grade: string; readonly credits: string };
+
+const holdsAny = (text: string, patterns: readonly string[]): boolean => patterns.some((pattern) => holds(plain(text).toLowerCase(), pattern));
+
+/** The course rows of every course table; a total row and a row that writes the GPA itself are not courses. */
+export const courseRowsOf = (tables: readonly ChangeTable[], words: GpaWords): CourseRow[] => {
+  const skip = [...words.columns.filter((word) => word.role === "total"), ...words.labels.filter((label) => !label.part)].map((word) => word.pattern);
+  return tables.flatMap((table) => {
+    const columns = courseColumnsOf(
+      table.header.map((cell) => cell.text),
+      words.columns,
+    );
+    if (columns === undefined) return [];
+    const rows = table.rows.filter((row) => row.length === table.header.length && !holdsAny(row[0]?.text ?? "", skip));
+    const textOf = (row: readonly TableCell[], index: number): string => plain(row[index]?.text ?? "");
+    return rows
+      .filter((row) => row.some((cell) => plain(cell.text) !== ""))
+      .map((row) => ({ grade: textOf(row, columns.grade), credits: textOf(row, columns.credits) }));
+  });
+};
+
+const CREDITS = /^\d+(?:\.\d+)?$/u;
+
+type GradedRow = { readonly grade: string; readonly credits: number };
+
+/** The rows that carry points; undefined when a row's grade is on no scale or its credits are not a number. */
+export const gradedRowsOf = (rows: readonly CourseRow[], grades: readonly GradeWord[]): GradedRow[] | undefined => {
+  const noPoints = new Set(grades.filter((word) => word.points === undefined).map((word) => word.pattern));
+  const onScale = new Set(grades.filter((word) => word.points !== undefined).map((word) => word.pattern));
+  const counted = rows.filter((row) => !noPoints.has(row.grade));
+  if (counted.some((row) => !onScale.has(row.grade) || !CREDITS.test(row.credits))) return undefined;
+  return counted.map((row) => ({ grade: row.grade, credits: Number(row.credits) }));
+};
+
+/** Above this, a number beside a grade is a range of marks (S (90)), not grade points. */
+const GRADE_POINT_CEILING = 5;
+
+const keyPattern = (grades: readonly GradeWord[]): RegExp => {
+  const words = [...new Set(grades.filter((word) => word.points !== undefined).map((word) => word.pattern))].toSorted(
+    (left, right) => right.length - left.length,
+  );
+  const number = String.raw`(\d+(?:\.\d+)?)`;
+  return new RegExp(
+    String.raw`(?<![A-Za-z0-9])(${words.map(escapeRegExp).join("|")})\s*(?:\(\s*${number}\s*(?:点|pts?\.?|points?)?\s*\)|=\s*${number}\s*点?)`,
+    "gu",
+  );
+};
+
+/**
+ * The grade points a key line writes: a line naming grades (評価, Grades) with "S（4）" or "A = 4" pairs, so "Room A (4)"
+ * is not read. "conflict" when the document gives one grade two different points, or numbers too large to be points.
+ */
+export const gradingKeyOf = (lines: readonly TextLine[], grades: readonly GradeWord[], cues: readonly string[]): ReadonlyMap<string, number> | "conflict" => {
+  const pattern = keyPattern(grades);
+  const keyLines = lines.filter((line) => holdsAny(line.text, cues));
+  const pairs = keyLines.flatMap((line) =>
+    [...plain(line.text).matchAll(pattern)].map((match) => ({ grade: match[1] ?? "", points: Number(match[2] ?? match[3]) })),
+  );
+  const key = new Map<string, number>();
+  const clash = pairs.some(({ grade, points }) => {
+    const known = key.get(grade);
+    key.set(grade, points);
+    return points > GRADE_POINT_CEILING || (known !== undefined && known !== points);
+  });
+  return clash ? "conflict" : key;
+};
+
+/** The points every lexicon scale holding all the grades agrees on; undefined when no scale holds them or two disagree. */
+export const scalePointsOf = (used: readonly string[], grades: readonly GradeWord[]): ReadonlyMap<string, number> | undefined => {
+  const scales = [...new Set(grades.flatMap((word) => (word.points === undefined ? [] : [word.scale])))];
+  const pointsIn = (scale: string, grade: string): number | undefined => grades.find((word) => word.scale === scale && word.pattern === grade)?.points;
+  const fitting = scales.filter((scale) => used.every((grade) => pointsIn(scale, grade) !== undefined));
+  const points = new Map(used.map((grade) => [grade, new Set(fitting.map((scale) => pointsIn(scale, grade)))]));
+  if (fitting.length === 0 || [...points.values()].some((values) => values.size !== 1)) return undefined;
+  return new Map(used.map((grade) => [grade, [...(points.get(grade) ?? [])][0] ?? 0]));
+};
+
+/**
+ * The document's key when it gives every used grade its points; otherwise the lexicon's scale, when the key gives none
+ * of the used grades points other than the scale's.
+ */
+export const pointsFor = (
+  used: readonly string[],
+  key: ReadonlyMap<string, number> | "conflict",
+  grades: readonly GradeWord[],
+): ReadonlyMap<string, number> | undefined => {
+  if (key === "conflict") return undefined;
+  if (used.every((grade) => key.has(grade))) return key;
+  const scale = scalePointsOf(used, grades);
+  return scale !== undefined && used.every((grade) => !key.has(grade) || key.get(grade) === scale.get(grade)) ? scale : undefined;
+};
+
+/** A written GPA: where its number starts, the number as written, and its decimals. */
+export type GpaStatement = { readonly offset: number; readonly text: string; readonly value: number; readonly decimals: number };
+
+const LINE_MARK = /^\s*(?:>\s*)*(?:(?:[-*+]|\d+[.)])\s+)?/u;
+const COLON = /[:：]/u;
+const BRACKET = /[()]/u;
+const WRITTEN_GPA = /^(\s*)(\d+(?:\.(\d+))?)/u;
+
+/** A label without what it writes in brackets: 「評価平均(gpa)」 is 「評価平均」. */
+const outsideBrackets = (label: string): string =>
+  label
+    .split(BRACKET)
+    .filter((_, index) => index % 2 === 0)
+    .join(" ")
+    .replace(/\s+/gu, " ")
+    .trim();
+
+/** What one "label: value" line says of a GPA: a statement, one of a part of the record, another figure, or nothing. */
+type GpaLine = { readonly kind: "statement"; readonly statement: GpaStatement } | { readonly kind: "part" | "other" } | undefined;
+
+const gpaLineOf = (line: TextLine, labels: readonly GpaLabel[]): GpaLine => {
+  const mark = LINE_MARK.exec(line.text)?.[0] ?? "";
+  const colon = line.text.slice(mark.length).search(COLON);
+  if (colon <= 0) return undefined;
+  const label = plain(line.text.slice(mark.length, mark.length + colon)).toLowerCase();
+  const named = (part: boolean): boolean => labels.some((word) => word.part === part && holds(label, word.pattern));
+  if (!named(false)) return undefined;
+  if (named(true)) return { kind: "part" };
+  const valueFrom = mark.length + colon + 1;
+  const number = WRITTEN_GPA.exec(line.text.slice(valueFrom));
+  if (number === null) return undefined;
+  const outside = outsideBrackets(label);
+  if (!labels.some((word) => !word.part && plain(word.pattern).toLowerCase() === outside)) return { kind: "other" };
+  const [, space = "", text = "", fraction = ""] = number;
+  return { kind: "statement", statement: { offset: line.start + valueFrom + space.length, text, value: Number(text), decimals: fraction.length } };
+};
+
+/** The written GPAs; none when a line gives one part of the record's, or a GPA figure under another label, or two values. */
+export const gpaStatementsOf = (lines: readonly TextLine[], labels: readonly GpaLabel[]): GpaStatement[] => {
+  const read = lines.flatMap((line) => gpaLineOf(line, labels) ?? []);
+  const statements = read.flatMap((found) => (found.kind === "statement" ? [found.statement] : []));
+  if (read.some((found) => found.kind !== "statement") || new Set(statements.map((statement) => statement.value)).size > 1) return [];
+  return statements;
+};
+
+const DECIMAL_BASE = 10;
+const SLACK = 1e-9;
+/** Decimals of the computed GPA shown beside a GPA written as a whole number. */
+const WHOLE_SHOWN_DECIMALS = 2;
+
+/** The written GPA is the computed one rounded, or cut off, to the written decimals. */
+export const withinRounding = (written: GpaStatement, computed: number): boolean => {
+  const step = DECIMAL_BASE ** -written.decimals;
+  const rounded = Math.abs(computed - written.value) <= step / 2 + SLACK;
+  const cutOff = written.value <= computed + SLACK && computed - written.value < step - SLACK;
+  return rounded || cutOff;
+};
+
+/** Σ(points × credits) / Σ credits, undefined with no credits. */
+export const averageOf = (rows: readonly GradedRow[], points: ReadonlyMap<string, number>): number | undefined => {
+  const credits = rows.reduce((sum, row) => sum + row.credits, 0);
+  if (credits === 0) return undefined;
+  return rows.reduce((sum, row) => sum + (points.get(row.grade) ?? 0) * row.credits, 0) / credits;
+};
+
+const computedGpa = (tables: readonly ChangeTable[], lines: readonly TextLine[], words: GpaWords): number | undefined => {
+  const rows = gradedRowsOf(courseRowsOf(tables, words), words.grades);
+  if (rows === undefined || rows.length === 0) return undefined;
+  const cues = words.columns.filter((word) => word.role === "grade" || word.role === "points").map((word) => word.pattern);
+  const points = pointsFor([...new Set(rows.map((row) => row.grade))], gradingKeyOf(lines, words.grades, cues), words.grades);
+  return points === undefined ? undefined : averageOf(rows, points);
+};
+
+/** Each written GPA the document's course rows do not give, with the GPA they do give. */
+export const gpaMismatches = (tables: readonly ChangeTable[], lines: readonly TextLine[], words: GpaWords): StructureIssue[] => {
+  const statements = gpaStatementsOf(lines, words.labels);
+  if (statements.length === 0) return [];
+  const computed = computedGpa(tables, lines, words);
+  if (computed === undefined) return [];
+  return statements
+    .filter((statement) => !withinRounding(statement, computed))
+    .map((statement) => ({
+      offset: statement.offset,
+      values: { gpa: statement.text, computed: computed.toFixed(statement.decimals === 0 ? WHOLE_SHOWN_DECIMALS : statement.decimals) },
+    }));
+};