chaffjs 0.30.0 → 0.32.0

package/src/contacts/table-rows.ts

@@ -0,0 +1,51 @@
+// A two-column table row named by an address label (| 物件所在地 | 東京都… |, | Address | 12 Elm Street … |) read as the
+// line `物件所在地 東京都…` the contact readers read: the prose masks tables, so the row's name is written back right before
+// its value, at the row's own offsets. Only a table of two columns: a wider table's rows name whose address it is in
+// another cell, and a list of shops or venues would compare neighbours. Pure.
+import type { LexiconEntry } from "../plugin.ts";
+import { cellsOf, tablesOf, type Cell } from "../facts/table-facts.ts";
+import { withoutEdgeMarks } from "../facts/trim-marks.ts";
+import { linesOf } from "../structure/lines.ts";
+
+const TWO_COLUMNS = 2;
+const LETTER = /\p{L}/u;
+const LATIN_START = /^[A-Za-z]/u;
+
+/** Whether a row's name ends with a label: 物件所在地 with 所在地, Property address with address (a Latin label as a whole word). */
+const endsWithLabel = (name: string, label: string): boolean => {
+  const lowered = name.toLowerCase();
+  const pattern = label.toLowerCase();
+  if (!lowered.endsWith(pattern)) return false;
+  return !LATIN_START.test(label) || !LETTER.test(lowered.charAt(lowered.length - pattern.length - 1));
+};
+
+type LabelledRow = { readonly name: string; readonly nameEnd: number; readonly value: Cell };
+
+const labelledRow = (cells: readonly Cell[], labels: readonly LexiconEntry[]): LabelledRow[] => {
+  const [first, value] = cells;
+  if (cells.length !== TWO_COLUMNS || first === undefined || value === undefined) return [];
+  const name = withoutEdgeMarks(first.text);
+  return labels.some((entry) => endsWithLabel(name, entry.pattern)) ? [{ name, nameEnd: first.end, value }] : [];
+};
+
+/** The two-column rows of a text's tables whose first cell names an address. */
+const labelledRows = (tables: string, labels: readonly LexiconEntry[]): LabelledRow[] =>
+  tablesOf(linesOf(tables))
+    .filter((table) => cellsOf(table.header).length === TWO_COLUMNS)
+    .flatMap((table) => table.rows.flatMap((row) => labelledRow(cellsOf(row), labels)));
+
+/**
+ * The prose with each labelled two-column row of `tables` (the same text with its tables shown) written back as its name
+ * then its value. The name ends where its cell ends, so it stays inside the row's span. Offsets are kept.
+ */
+export const proseWithLabelledRows = (prose: string, tables: string, labels: readonly LexiconEntry[]): string => {
+  const pieces: string[] = [];
+  const end = labelledRows(tables, labels).reduce((from, row) => {
+    const nameStart = row.nameEnd - row.name.length;
+    if (nameStart < from) return from;
+    pieces.push(prose.slice(from, nameStart), row.name, prose.slice(row.nameEnd, row.value.start), row.value.text);
+    return row.value.end;
+  }, 0);
+  pieces.push(prose.slice(end));
+  return pieces.join("");
+};

package/src/contacts/variants.ts

@@ -0,0 +1,33 @@
+// One contact written two ways: of two related writings, the one written fewer times, or the one first written later when
+// both are written as often, is reported with the other. Pure: what a writing is and which writings are related come from
+// the caller (an email address, a postal address).
+
+/** A contact as written and where. key is what makes two writings the same contact. */
+export type Writing = { readonly offset: number; readonly written: string; readonly key: string };
+
+/** A writing that is a variant of another contact's writing, and that other writing. */
+export type Variant<T extends Writing> = { readonly writing: T; readonly other: T };
+
+const byKey = <T extends Writing>(writings: readonly T[]): Map<string, T[]> =>
+  writings.reduce((groups, writing) => groups.set(writing.key, [...(groups.get(writing.key) ?? []), writing]), new Map<string, T[]>());
+
+/** Every writing of the minority side of each related pair, with the first writing of the other side, in document order. */
+export const writingVariants = <T extends Writing>(writings: readonly T[], related: (a: T, b: T) => boolean): Variant<T>[] => {
+  const groups = byKey(writings);
+  const timesOf = (writing: T): number => groups.get(writing.key)?.length ?? 0;
+  const firsts = [...groups.values()].flatMap((group) => group.slice(0, 1));
+  const minorityOf = (a: T, b: T): T => {
+    if (timesOf(a) !== timesOf(b)) return timesOf(a) < timesOf(b) ? a : b;
+    return a.offset > b.offset ? a : b;
+  };
+  return firsts
+    .flatMap((first, index) =>
+      firsts.slice(index + 1).flatMap((second) => {
+        if (!related(first, second)) return [];
+        const minority = minorityOf(first, second);
+        const other = minority === first ? second : first;
+        return (groups.get(minority.key) ?? []).map((writing) => ({ writing, other }));
+      }),
+    )
+    .toSorted((a, b) => a.writing.offset - b.writing.offset);
+};

package/src/derived/age-on-date.ts

@@ -0,0 +1,161 @@
+import type { Span } from "../plugin.ts";
+import { calendarDateOf } from "./date-arithmetic.ts";
+
+/**
+ * 生年月日のラベルの付いた日付と同じ行の年齢（「生年月日：1978年4月12日（受診時 48歳）」）を、ラベルの付いた日（受診日、報告日、
+ * Examination date）の満年齢と比べる。年齢の印（受診時）があれば、その印と同じ group のラベルの日で数える。
+ * 数える日が決まらない（無い、同じ group に違う日が二つ、日によって満年齢が変わる）ときは何も言わない。
+ */
+export type LabelWord = { readonly pattern: string; readonly position?: "before" | "after" | undefined; readonly group?: string | undefined };
+
+export type Age = Span & { readonly amount: number; readonly approximate: boolean };
+
+/** The span is the date of birth; birth is its value (1978-04-12). */
+export type LabelledBirth = Span & { readonly birth: string; readonly age: Age; readonly group: string | undefined };
+
+export type LabelledReference = Span & { readonly date: string; readonly group: string };
+
+export type AgeVerdict = { readonly birth: LabelledBirth; readonly reference: LabelledReference; readonly expected: number };
+
+const FEBRUARY = 2;
+const LEAP_DAY = 29;
+const LEAP_DAY_EVE = 28;
+const LEAP_CYCLE = 4;
+const CENTURY = 100;
+const LEAP_CENTURY = 400;
+
+const isLeapYear = (year: number): boolean => (year % LEAP_CYCLE === 0 && year % CENTURY !== 0) || year % LEAP_CENTURY === 0;
+
+/**
+ * 満年齢。誕生日の前日までは一つ少ない。2月29日生まれの、うるう年でない年の2月28日は、法と慣習で数え方が分かれるので undefined。
+ * 年の無い日付、生まれる前の日も undefined。
+ */
+export const ageOn = (birthValue: string, onValue: string): number | undefined => {
+  const birth = calendarDateOf(birthValue);
+  const on = calendarDateOf(onValue);
+  if (birth?.year === undefined || on?.year === undefined) return undefined;
+  const leapDayEve = birth.month === FEBRUARY && birth.day === LEAP_DAY && on.month === FEBRUARY && on.day === LEAP_DAY_EVE && !isLeapYear(on.year);
+  if (leapDayEve) return undefined;
+  const reached = on.month > birth.month || (on.month === birth.month && on.day >= birth.day);
+  const age = on.year - birth.year - (reached ? 0 : 1);
+  return age < 0 ? undefined : age;
+};
+
+/** 年齢の印（受診時）が名指す group のラベルの日。その group の日が無ければ、ラベルの付いた日すべて。 */
+const candidatesFor = (birth: LabelledBirth, references: readonly LabelledReference[]): readonly LabelledReference[] => {
+  const named = references.filter((reference) => reference.group === birth.group);
+  return named.length > 0 ? named : references;
+};
+
+/** 同じ group に違う日が二つあれば（受診日が二つ）、どちらの日の年齢か決まらない。 */
+const hasConflictingGroup = (candidates: readonly LabelledReference[]): boolean =>
+  candidates.some((left) => candidates.some((right) => left.group === right.group && left.date !== right.date));
+
+const verdictOf = (birth: LabelledBirth, references: readonly LabelledReference[]): AgeVerdict[] => {
+  const candidates = candidatesFor(birth, references);
+  const [first] = candidates;
+  if (birth.age.approximate || first === undefined || hasConflictingGroup(candidates)) return [];
+  const ages = candidates.map((reference) => ageOn(birth.birth, reference.date));
+  const expected = ages[0];
+  if (expected === undefined || ages.some((age) => age !== expected)) return [];
+  return [{ birth, reference: first, expected }];
+};
+
+/** 数える日が一つに決まった年齢と、その日の満年齢。書いた年齢と合うものも含む。 */
+export const ageVerdicts = (births: readonly LabelledBirth[], references: readonly LabelledReference[]): AgeVerdict[] =>
+  births.flatMap((birth) => verdictOf(birth, references));
+
+export const ageMismatches = (births: readonly LabelledBirth[], references: readonly LabelledReference[]): AgeVerdict[] =>
+  ageVerdicts(births, references).filter((verdict) => verdict.birth.age.amount !== verdict.expected);
+
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+const SEPARATOR = /[\s:：|*＊]/u;
+
+const withoutTrailingSeparators = (text: string): string => {
+  let end = text.length;
+  while (end > 0 && SEPARATOR.test(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+};
+
+const isWordAt = (text: string, at: number): boolean => WORD_CHAR.test(text.charAt(at));
+
+/** text の終わりに、語の切れ目から書いた word。 */
+const endsWithWord = (text: string, word: string): boolean => text.endsWith(word) && !isWordAt(text, text.length - word.length - 1);
+
+/** text の頭に書いた word。英字の語は、後ろが語の切れ目のときだけ。 */
+const startsWithWord = (text: string, word: string): boolean => text.startsWith(word) && (!/[a-z]$/u.test(word) || !isWordAt(text, word.length));
+
+const before = (word: LabelWord): boolean => (word.position ?? "before") === "before";
+
+/** ラベルの前に書いてよいもの: 行の頭、表の区切り、強調や箇条書きの印、括弧や読点。「前回受診日」「Previous examination date」は別の日。 */
+const FIELD_START = /(?:^|[|*＊#>\-・•(（)）、,;；。.])$/u;
+
+/** text の終わりに書いた年齢（「(age 23」の後ろの as of は、その年齢を数える日の印）。 */
+const endsWithAge = (text: string, words: AgeWords | undefined): boolean => words !== undefined && agesIn(text, words).some((age) => age.end === text.length);
+
+/** 日付の前（同じ行の、日付までの文字）の終わりに、区切り（：、|、**）を除いて書いたラベル。ラベルは欄の頭から、または words の年齢のすぐ後ろに書いたものだけ。 */
+export const labelBefore = (lineBefore: string, labels: readonly LabelWord[], words?: AgeWords): LabelWord | undefined => {
+  const head = withoutTrailingSeparators(lineBefore).toLowerCase();
+  return labels.filter(before).find((label) => {
+    const pattern = label.pattern.toLowerCase();
+    if (!head.endsWith(pattern)) return false;
+    const lead = head.slice(0, head.length - pattern.length).trimEnd();
+    return FIELD_START.test(lead) || endsWithAge(lead, words);
+  });
+};
+
+/** 日付のすぐ後ろに書いたラベル（2026年4月1日時点）。 */
+export const labelAfter = (lineAfter: string, labels: readonly LabelWord[]): LabelWord | undefined => {
+  const tail = lineAfter.trimStart().toLowerCase();
+  return labels.filter((label) => !before(label)).find((label) => startsWithWord(tail, label.pattern.toLowerCase()));
+};
+
+/** 年齢の書き方。before は数の前の語（age、aged）、after は数の後ろの語（歳、old）、skip は数と after のあいだに書いてよい語（years）。 */
+export type AgeWords = {
+  readonly before: readonly string[];
+  readonly after: readonly string[];
+  readonly skip: readonly string[];
+  readonly approximateBefore: readonly string[];
+  readonly approximateAfter: readonly string[];
+};
+
+/** 年齢の幅（59-60歳、59〜60 years old）の片方は、書いた年齢ではない。 */
+const RANGE_BEFORE = /[0-9０-９]\s*(?:[-–—~〜～]|\sto)$/iu;
+const RANGE_AFTER = /^\s*(?:[-–—~〜～]|to\s)\s*[0-9０-９]/iu;
+
+const AGE_NUMBER = /(?<![0-9０-９]|[0-9０-９][.,．，])[0-9０-９]{1,3}(?![0-9０-９]|[.,．，][0-9０-９])/gu;
+
+const longestStart = (text: string, words: readonly string[]): string | undefined =>
+  words
+    .filter((word) => startsWithWord(text, word.toLowerCase()))
+    .toSorted((left, right) => right.length - left.length)
+    .at(0);
+
+/** 数の後ろ: 書いてよい語（years）を飛ばしてから、年齢の語（歳、old）があれば、その語の後ろの文字。無ければ undefined。 */
+const restAfterMarker = (afterNumber: string, words: AgeWords): string | undefined => {
+  const trimmed = afterNumber.trimStart().toLowerCase();
+  const skipped = longestStart(trimmed, words.skip);
+  const rest = skipped === undefined ? trimmed : trimmed.slice(skipped.length).trimStart();
+  const marker = longestStart(rest, words.after);
+  return marker === undefined ? undefined : rest.slice(marker.length);
+};
+
+/** 一行の中の年齢と、後ろに書いた年齢の語まで（48歳、満48歳、age 57、aged 57、57 years old）。目安の年齢（約48歳、48歳前後）と年齢の幅（59-60歳）は approximate。 */
+export const agesIn = (text: string, words: AgeWords): Age[] =>
+  [...text.matchAll(AGE_NUMBER)].flatMap((match): Age[] => {
+    const start = match.index;
+    const end = start + match[0].length;
+    const head = text.slice(0, start).trimEnd().toLowerCase();
+    const afterNumber = text.slice(end);
+    const rest = restAfterMarker(afterNumber, words);
+    const marker = words.before.find((word) => endsWithWord(head, word.toLowerCase()));
+    if (rest === undefined && marker === undefined) return [];
+    const headBeforeMarker = marker === undefined ? head : head.slice(0, head.length - marker.length).trimEnd();
+    const approximate =
+      RANGE_BEFORE.test(headBeforeMarker) ||
+      RANGE_AFTER.test(afterNumber) ||
+      words.approximateBefore.some((word) => headBeforeMarker.endsWith(word.toLowerCase())) ||
+      (rest !== undefined && words.approximateAfter.some((word) => rest.trimStart().startsWith(word.toLowerCase())));
+    const markerEnd = rest === undefined ? end : end + afterNumber.length - rest.length;
+    return [{ start, end: markerEnd, amount: Number(match[0].normalize("NFKC")), approximate }];
+  });

package/src/derived/battery-runtime.ts

@@ -0,0 +1,284 @@
+// capacity-runtime-mismatch: a battery capacity divided by the stated consumption is the longest the device can run; a stated
+// runtime above it by more than its written precision cannot be right (5000 mAh at 500 mA is 10 h, not 15 h). The item names
+// come from battery-label, the units from battery-unit and unit-time, the rough marks from approximate-marker. Pure.
+
+export type Family = "charge" | "current" | "energy" | "power";
+export type Role = "capacity" | "consumption" | "runtime";
+
+export type ScaledUnit = { readonly pattern: string; readonly weight: number };
+export type ElectricUnit = ScaledUnit & { readonly family: Family };
+export type Marker = { readonly pattern: string; readonly position: "before" | "after" };
+
+export type BatteryWords = {
+  readonly electric: readonly ElectricUnit[];
+  /** Units of time, weight in seconds. */
+  readonly time: readonly ScaledUnit[];
+  readonly approximate: readonly Marker[];
+  /** Marks that bound a value from one side (以上, 以内, at least, under): the value is not compared at all. */
+  readonly bounds: readonly Marker[];
+  readonly connectors: readonly string[];
+  readonly labels: readonly { readonly pattern: string; readonly group: string }[];
+};
+
+/** A value as written: the low and high end of a range (the same for one number), in mAh, mA, Wh, W or seconds. */
+export type Reading = {
+  readonly low: number;
+  readonly high: number;
+  readonly family: Family | "time";
+  /** One step of the last written digit, in the reading's unit (15時間 → 3600 s, 10.5 h → 360 s). */
+  readonly step: number;
+  readonly approximate: boolean;
+};
+
+export type LabelReading = { readonly role: Role; readonly standby: boolean; readonly peak: boolean; readonly condition: string };
+
+export type Entry = LabelReading & { readonly reading: Reading; readonly start: number; readonly text: string };
+
+export type CapacityRuntimeMismatch = {
+  readonly capacity: Entry;
+  readonly consumption: Entry;
+  readonly runtime: Entry;
+  readonly idealHours: number;
+};
+
+const SECONDS_PER_HOUR = 3600;
+const APPROXIMATE_FACTOR = 2;
+const EPSILON = 1e-9;
+const NUMBER = /^(?:\d{1,3}(?:,\d{3})+|\d+)(?:\.\d+)?/u;
+const LETTER = /\p{L}/u;
+const SPACES = /^\s*/u;
+
+const normal = (text: string): string => text.normalize("NFKC").trim();
+const folded = (text: string): string => normal(text).toLowerCase();
+const conditionKey = (text: string): string => folded(text).replace(/\s+/gu, "");
+
+/** The text without a note in brackets at its end, and the note (連続再生時間（音量50%）). */
+export const splitCondition = (text: string): { readonly bare: string; readonly condition: string } => {
+  const plain = normal(text);
+  const open = plain.lastIndexOf("(");
+  if (!plain.endsWith(")") || open <= 0) return { bare: plain, condition: "" };
+  return { bare: plain.slice(0, open).trim(), condition: conditionKey(plain.slice(open + 1, -1)) };
+};
+
+const wordsOf = (words: BatteryWords, group: string): string[] => words.labels.filter((entry) => entry.group === group).map((entry) => folded(entry.pattern));
+
+const holds = (text: string, patterns: readonly string[]): boolean => patterns.some((pattern) => text.includes(pattern));
+
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+
+/** The text without the marks at its ends (Max. → max). */
+const withoutEdgeMarks = (text: string): string => {
+  const chars = [...text];
+  const first = chars.findIndex((char) => WORD_CHAR.test(char));
+  const last = chars.findLastIndex((char) => WORD_CHAR.test(char));
+  return first === -1 ? "" : chars.slice(first, last + 1).join("");
+};
+
+/** Whether a condition or a heading is only one of the words, with a word of the state after it (待機時, Max., idle mode). */
+const isOnly = (text: string, patterns: readonly string[], words: BatteryWords): boolean => {
+  const bare = withoutEdgeMarks(folded(text));
+  const suffixes = ["", ...wordsOf(words, "state")];
+  return patterns.some((pattern) => suffixes.some((suffix) => [pattern + suffix, `${pattern} ${suffix}`].includes(bare)));
+};
+
+const ROLES: readonly Role[] = ["capacity", "consumption", "runtime"];
+
+/** What an item name says: which value, under which condition, whether idle or at the maximum. */
+export const labelOf = (label: string, words: BatteryWords): LabelReading | undefined => {
+  const { bare, condition } = splitCondition(label);
+  const head = folded(bare);
+  const roles = ROLES.filter((role) => holds(head, wordsOf(words, role)));
+  const [role] = roles;
+  if (role === undefined || roles.length > 1) return undefined;
+  const standby = wordsOf(words, "standby");
+  return {
+    role,
+    standby: holds(head, standby) || (role === "consumption" && isOnly(condition, standby, words)),
+    peak: holds(head, wordsOf(words, "peak")) || isOnly(condition, wordsOf(words, "peak"), words),
+    condition,
+  };
+};
+
+/** Whether a column heading is only a word of the maximum (最大, Max.). */
+export const isPeakHeading = (heading: string, words: BatteryWords): boolean => isOnly(heading, wordsOf(words, "peak"), words);
+
+type Stripped = { readonly core: string; readonly marks: readonly string[] };
+
+const markAt = (text: string, marker: Marker): boolean => {
+  const lower = text.toLowerCase();
+  const pattern = folded(marker.pattern);
+  return marker.position === "before" ? lower.startsWith(pattern) : lower.endsWith(pattern);
+};
+
+const stripOnce = (text: string, markers: readonly Marker[]): Stripped | undefined => {
+  const marker = markers.find((candidate) => markAt(text, candidate));
+  if (marker === undefined) return undefined;
+  const length = folded(marker.pattern).length;
+  const core = marker.position === "before" ? text.slice(length) : text.slice(0, text.length - length);
+  return { core: core.trim(), marks: [folded(marker.pattern)] };
+};
+
+const MAX_MARKS = 3;
+
+/** The value without the marks around it (約, 最大, 以上, about, up to), and the marks taken off. */
+export const stripMarks = (text: string, markers: readonly Marker[]): Stripped =>
+  Array.from({ length: MAX_MARKS }).reduce<Stripped>(
+    (stripped) => {
+      const next = stripOnce(stripped.core, markers);
+      return next === undefined ? stripped : { core: next.core, marks: [...stripped.marks, ...next.marks] };
+    },
+    { core: normal(text), marks: [] },
+  );
+
+type Scanned = { readonly value: number; readonly decimals: number; readonly unit: ScaledUnit | undefined; readonly end: number };
+
+const byLength = (units: readonly ScaledUnit[]): ScaledUnit[] => [...units].sort((left, right) => right.pattern.length - left.pattern.length);
+
+/** The unit written at `at`, not running on into a word. A unit in lower case (hours) is read in any case; mA and W as written. */
+const unitAt = (text: string, at: number, units: readonly ScaledUnit[]): ScaledUnit | undefined =>
+  byLength(units).find((unit) => {
+    const pattern = normal(unit.pattern);
+    const written = text.slice(at, at + pattern.length);
+    const caseless = pattern === pattern.toLowerCase();
+    return (caseless ? written.toLowerCase() === pattern : written === pattern) && !LETTER.test(text[at + pattern.length] ?? "");
+  });
+
+const spacesAt = (text: string, at: number): number => at + (SPACES.exec(text.slice(at))?.[0].length ?? 0);
+
+/** A number at `at` and the unit right after it (spaces between allowed). */
+const scanAt = (text: string, at: number, units: readonly ScaledUnit[]): Scanned | undefined => {
+  const number = NUMBER.exec(text.slice(at))?.[0];
+  if (number === undefined) return undefined;
+  const unitStart = spacesAt(text, at + number.length);
+  const unit = unitAt(text, unitStart, units);
+  const end = unit === undefined ? at + number.length : unitStart + normal(unit.pattern).length;
+  return { value: Number(number.replaceAll(",", "")), decimals: number.split(".")[1]?.length ?? 0, unit, end };
+};
+
+/** Every number and unit from `at` to the end; a number without a unit only last. Undefined when anything else is written. */
+const scanAll = (text: string, at: number, units: readonly ScaledUnit[]): Scanned[] | undefined => {
+  const from = spacesAt(text, at);
+  if (from >= text.length) return [];
+  const scanned = scanAt(text, from, units);
+  if (scanned === undefined) return undefined;
+  if (scanned.unit === undefined) return spacesAt(text, scanned.end) >= text.length ? [scanned] : undefined;
+  const rest = scanAll(text, scanned.end, units);
+  return rest === undefined ? undefined : [scanned, ...rest];
+};
+
+const DECIMAL_BASE = 10;
+
+type Side = { readonly value: number; readonly step: number; readonly unit: ScaledUnit | undefined };
+
+/** One side of a range: a number and unit, or for time a run of them (10時間30分, 1 h 30 min), or a bare number. */
+const sideOf = (text: string, units: readonly ScaledUnit[], compound: boolean): Side | undefined => {
+  const parts = scanAll(text, 0, units);
+  const last = parts?.at(-1);
+  if (parts === undefined || last === undefined || (parts.length > 1 && (!compound || last.unit === undefined))) return undefined;
+  const step = DECIMAL_BASE ** -last.decimals;
+  if (last.unit === undefined) return { value: last.value, step, unit: undefined };
+  const value = parts.reduce((sum, part) => sum + part.value * (part.unit?.weight ?? 0), 0);
+  return { value, step: step * last.unit.weight, unit: last.unit };
+};
+
+const splitRange = (text: string, connectors: readonly string[]): readonly string[] => {
+  const connector = connectors.map(normal).find((candidate) => text.indexOf(candidate) > 0);
+  if (connector === undefined) return [text];
+  const at = text.indexOf(connector);
+  return [text.slice(0, at).trim(), text.slice(at + connector.length).trim()];
+};
+
+/** A side written without a unit (8〜10時間) takes the unit of the other side. */
+const withUnit = (side: Side, other: Side): Side | undefined => {
+  if (side.unit !== undefined) return side;
+  if (other.unit === undefined) return undefined;
+  return { value: side.value * other.unit.weight, step: side.step * other.unit.weight, unit: other.unit };
+};
+
+const rangeOf = (core: string, units: readonly ScaledUnit[], connectors: readonly string[], compound: boolean): [Side, Side] | undefined => {
+  const parts = splitRange(core, connectors);
+  const sides = parts.map((part) => sideOf(part, units, compound));
+  const [first, second] = sides;
+  if (sides.some((side) => side === undefined) || first === undefined) return undefined;
+  if (second === undefined) return first.unit === undefined ? undefined : [first, first];
+  const low = withUnit(first, second);
+  return low === undefined || second.unit === undefined ? undefined : [low, second];
+};
+
+const familyOf = (unit: ScaledUnit | undefined, units: readonly ElectricUnit[]): Family | undefined => units.find((candidate) => candidate === unit)?.family;
+
+const ROLE_FAMILIES: Readonly<Record<Role, readonly (Family | "time")[]>> = {
+  capacity: ["charge", "energy"],
+  consumption: ["current", "power"],
+  runtime: ["time"],
+};
+
+export type ValueReading = { readonly reading: Reading; readonly peak: boolean };
+
+/**
+ * A value cell or the value after a label's colon. A runtime is a time (15時間, 8〜10 hours, 1 h 30 min); a capacity or a
+ * consumption one number with an electric unit, or a range of them. A note in brackets at the end is not part of it.
+ * Undefined when the value is anything else, or is bounded from one side (10時間以上, under 500 mA).
+ */
+export const valueOf = (text: string, role: Role, words: BatteryWords): ValueReading | undefined => {
+  const { bare } = splitCondition(text);
+  const { core, marks } = stripMarks(bare, words.approximate);
+  if (words.bounds.some((marker) => markAt(bare, marker) || markAt(core, marker))) return undefined;
+  const units: readonly ScaledUnit[] = role === "runtime" ? words.time : words.electric;
+  const range = rangeOf(core, units, words.connectors, role === "runtime");
+  if (range === undefined) return undefined;
+  const [low, high] = range;
+  const family = role === "runtime" ? "time" : familyOf(high.unit, words.electric);
+  if (family === undefined || !ROLE_FAMILIES[role].includes(family) || (role !== "runtime" && familyOf(low.unit, words.electric) !== family)) return undefined;
+  const reading: Reading = { low: low.value, high: high.value, family, step: low.step, approximate: marks.length > 0 };
+  return { reading, peak: marks.some((mark) => wordsOf(words, "peak").includes(mark)) };
+};
+
+const DIVIDES: Readonly<Record<string, Family>> = { current: "charge", power: "energy" };
+
+/** The consumption a runtime is read against: the one under the same condition, or the only one. */
+const partnerOf = (runtime: Entry, consumptions: readonly Entry[]): Entry | undefined => {
+  const kind = consumptions.filter((entry) => entry.standby === runtime.standby);
+  const same = kind.filter((entry) => entry.condition === runtime.condition);
+  if (same.length === 1) return same[0];
+  const [only] = kind;
+  return same.length === 0 && kind.length === 1 && only !== undefined && (only.condition === "" || runtime.condition === "") ? only : undefined;
+};
+
+/** The one capacity a consumption divides: of the matching kind, and only one value of it. */
+const capacityFor = (consumption: Entry, capacities: readonly Entry[]): Entry | undefined => {
+  const kind = capacities.filter((entry) => entry.reading.family === DIVIDES[consumption.reading.family]);
+  const values = new Set(kind.map((entry) => entry.reading.high));
+  return values.size === 1 ? kind[0] : undefined;
+};
+
+type Pair = readonly [runtime: Entry, consumption: Entry];
+
+const pairsOf = (entries: readonly Entry[]): Pair[] => {
+  const consumptions = entries.filter((entry) => entry.role === "consumption" && !entry.peak);
+  const pairs = entries
+    .filter((entry) => entry.role === "runtime")
+    .flatMap((runtime): Pair[] => {
+      const partner = partnerOf(runtime, consumptions);
+      return partner === undefined ? [] : [[runtime, partner]];
+    });
+  return pairs.filter(([, consumption]) => pairs.filter(([, other]) => other === consumption).length === 1);
+};
+
+/**
+ * Runtimes stated above what the capacity divided by the consumption allows. Entries are one device's: one key-value table and
+ * the labelled lines of a section, or one column of a wider table. The margin is one step of the runtime's last written digit
+ * (15時間 → 1 h), twice that when any of the three is marked rough (約, about). A runtime at or below the ideal is normal.
+ */
+export const capacityRuntimeMismatches = (entries: readonly Entry[]): CapacityRuntimeMismatch[] => {
+  const capacities = entries.filter((entry) => entry.role === "capacity");
+  return pairsOf(entries).flatMap(([runtime, consumption]) => {
+    const capacity = capacityFor(consumption, capacities);
+    if (capacity === undefined || consumption.reading.low <= 0) return [];
+    const idealHours = capacity.reading.high / consumption.reading.low;
+    const rough = [runtime, consumption, capacity].some((entry) => entry.reading.approximate);
+    const margin = (runtime.reading.step / SECONDS_PER_HOUR) * (rough ? APPROXIMATE_FACTOR : 1);
+    const statedHours = runtime.reading.low / SECONDS_PER_HOUR;
+    return statedHours > idealHours + margin + EPSILON ? [{ capacity, consumption, runtime, idealHours }] : [];
+  });
+};