chaffjs 0.29.0 → 0.31.0

package/src/contacts/addresses.ts

@@ -0,0 +1,179 @@
+// Postal addresses written two ways in one document: the same street with its block numbers swapped or one of them changed
+// (丸の内二丁目4番1号 and 丸の内二丁目1番4号, 2-4-1 and 2-1-4 Marunouchi), or the same street and numbers under two postcodes.
+// Only an address with a label shortly before it on its line is read (住所, 本店所在地, Address, head office); the labels come
+// from the language's address-label lexicon, grouped by whose address they name, so a head office and a branch are never
+// compared. Pure.
+import type { LexiconEntry } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { writingVariants, type Variant, type Writing } from "./variants.ts";
+
+/** An address as written: the street it is on and the area written with it (東京都千代田区, Chiyoda-ku), its block numbers, its postcode when the line has one, and its label's group. */
+export type AddressWriting = Writing & {
+  readonly street: string;
+  readonly area: string;
+  readonly numbers: readonly number[];
+  readonly postcode: string | undefined;
+  readonly label: string;
+};
+
+/** A group that names no one office (住所, Address) and so may be compared with any. */
+const ANY_OFFICE = "address";
+const KANA_HAN = String.raw`\p{sc=Han}\p{sc=Hiragana}\p{sc=Katakana}ー々ヶ`;
+const BLOCK_JOIN = String.raw`\s?(?:丁目|番地|番|号|の|[-‐−－])\s?`;
+/** A Japanese street (its town, ward, city) and its block numbers: 東京都千代田区丸の内二丁目4番1号, 梅田1-2-3. */
+const JA_ADDRESS = new RegExp(String.raw`([${KANA_HAN}]{2,40}?)([0-9０-９]{1,4}(?:${BLOCK_JOIN}[0-9０-９]{1,4}){1,3})(?:\s?(?:号|番地|番))?`, "gu");
+/** Block numbers, the capitalised street after them and the area after a comma: 2-4-1 Marunouchi, Chiyoda-ku; 120 Main Street, Springfield. */
+const EN_BLOCK = String.raw`(?<![\w.\-/])(\d{1,5}(?:-\d{1,5}){0,3})`;
+const EN_STREET = String.raw`([A-Z][a-z]+(?:\s[A-Z][a-z]+){0,3})`;
+const EN_AREA = String.raw`(?:,\s?([A-Z][A-Za-z]*(?:-[a-z]+)?))?`;
+const EN_ADDRESS = new RegExp(String.raw`${EN_BLOCK}\s+${EN_STREET}${EN_AREA}`, "gu");
+/** 都道府県, 市, 区 and 郡: what comes after the last of them in a Japanese street is the town the numbers count in. */
+const DIVISIONS = [..."都道府県市区郡"];
+const CHOME = "丁目";
+const KANJI_NUMERALS = "一二三四五六七八九十";
+const KANJI_DIGITS = "一二三四五六七八九";
+const JP_POSTCODE = /(?<![\d\-‐−－])〒?\s?(\d{3})[-‐−－](\d{4})(?![\d\-‐−－])/u;
+const US_ZIP = /\b[A-Z]{2}\s(\d{5})(?:-\d{4})?\b/u;
+const JP_POSTCODE_ONLY = /^\d{3}-\d{4}$/u;
+const YEAR = /^(?:19|20)\d{2}$/u;
+const FULL_WIDTH_DIGIT = /[０-９]/gu;
+const NUMBER = /\d+/gu;
+const LATIN_START = /^[A-Za-z]/u;
+const LETTER = /\p{L}/u;
+/** How far before an address its label may end: 「本店所在地（」, "head office at ". */
+const MAX_LABEL_GAP = 20;
+const MIN_STREET_LENGTH = 2;
+
+/** 一 to 九十九 as a number; the 丁目 of a Japanese street. */
+const kanjiNumber = (kanji: string): number => {
+  const digit = (char: string): number => KANJI_DIGITS.indexOf(char) + 1;
+  if (!kanji.includes("十")) return digit(kanji);
+  const [tens = "", ones = ""] = kanji.split("十");
+  return (tens === "" ? 1 : digit(tens)) * 10 + (ones === "" ? 0 : digit(ones));
+};
+
+const halfWidth = (text: string): string => text.replaceAll(FULL_WIDTH_DIGIT, (char) => String.fromCharCode(char.charCodeAt(0) - 0xfee0));
+const numbersOf = (text: string): number[] => [...halfWidth(text).matchAll(NUMBER)].map((match) => Number(match[0]));
+
+/** The 二丁目 a street ends with, or "" when it ends with none. */
+const chomeOf = (street: string): string => {
+  if (!street.endsWith(CHOME)) return "";
+  const numeral = Array.from(street.slice(0, -CHOME.length))
+    .toReversed()
+    .findIndex((char) => !KANJI_NUMERALS.includes(char));
+  const length = numeral === -1 ? street.length - CHOME.length : numeral;
+  return length === 0 ? "" : street.slice(street.length - CHOME.length - length);
+};
+
+/** The town of a Japanese street as written (丸の内二丁目), its name without the 丁目 and the 丁目 as a number; undefined when the street names no ward, city or prefecture. */
+const jaStreet = (run: string): { area: string; written: string; town: string; chome: number[] } | undefined => {
+  const lastDivision = Math.max(...DIVISIONS.map((division) => run.lastIndexOf(division)));
+  if (lastDivision < 0) return undefined;
+  const written = run.slice(lastDivision + 1);
+  const chome = chomeOf(written);
+  const town = written.slice(0, written.length - chome.length);
+  const numbered = chome === "" ? [] : [kanjiNumber(chome.slice(0, -CHOME.length))];
+  return town.length < MIN_STREET_LENGTH ? undefined : { area: run.slice(0, lastDivision + 1), written, town, chome: numbered };
+};
+
+type Place = { readonly offset: number; readonly written: string; readonly street: string; readonly area: string; readonly numbers: number[] };
+
+const jaPlaces = (text: string): Place[] =>
+  [...text.matchAll(JA_ADDRESS)].flatMap((match) => {
+    const run = match[1] ?? "";
+    const street = jaStreet(run);
+    if (street === undefined) return [];
+    const townStart = run.length - street.written.length;
+    return [
+      {
+        offset: match.index + townStart,
+        written: match[0].slice(townStart),
+        street: street.town,
+        area: street.area,
+        numbers: [...street.chome, ...numbersOf(match[2] ?? "")],
+      },
+    ];
+  });
+
+/** A lone number before capitalised words is an address only when a comma goes on to the area (120 Main Street, Springfield), not a count (365 Plan). */
+const isAddressBlock = (block: string, area: string): boolean => block.includes("-") || area !== "";
+
+const enPlaces = (text: string): Place[] =>
+  [...text.matchAll(EN_ADDRESS)].flatMap((match) => {
+    const [, block = "", street = "", area = ""] = match;
+    if (JP_POSTCODE_ONLY.test(block) || YEAR.test(block) || !isAddressBlock(block, area)) return [];
+    return [{ offset: match.index, written: `${block} ${street}`, street: street.toLowerCase(), area: area.toLowerCase(), numbers: numbersOf(block) }];
+  });
+
+/** Where a label last occurs before an address on its line; a Latin label only as a whole word (office, not officer). */
+const lastPlace = (before: string, label: string): number => {
+  const lowered = label.toLowerCase();
+  const places = [...before.matchAll(new RegExp(escapeRegExp(lowered), "gu"))].map((match) => match.index);
+  const whole = LATIN_START.test(label) ? places.filter((at) => !LETTER.test(before[at - 1] ?? "") && !LETTER.test(before[at + lowered.length] ?? "")) : places;
+  return whole.at(-1) ?? -1;
+};
+
+/** The group of the label ending nearest before an address on its line, the longest when two end together (本店所在地 over 所在地). */
+const labelBefore = (before: string, labels: readonly LexiconEntry[]): string | undefined =>
+  labels
+    .map((entry) => {
+      const at = lastPlace(before, entry.pattern);
+      return { group: entry.group ?? ANY_OFFICE, at, end: at + entry.pattern.length };
+    })
+    .filter((hit) => hit.at >= 0 && before.length - hit.end <= MAX_LABEL_GAP)
+    .toSorted((a, b) => b.end - a.end || a.at - b.at)[0]?.group;
+
+const postcodeOf = (line: string): string | undefined => {
+  const japanese = JP_POSTCODE.exec(line);
+  if (japanese !== null) return `${japanese[1] ?? ""}-${japanese[2] ?? ""}`;
+  return US_ZIP.exec(line)?.[1];
+};
+
+/** The labelled addresses of one line; its postcode is given to an address only when the line holds one address. */
+const lineAddresses = (line: string, start: number, labels: readonly LexiconEntry[]): AddressWriting[] => {
+  const places = [...jaPlaces(line), ...enPlaces(line)];
+  const postcode = places.length === 1 ? postcodeOf(line) : undefined;
+  return places.flatMap((place) => {
+    const label = labelBefore(line.slice(0, place.offset).toLowerCase(), labels);
+    if (label === undefined) return [];
+    const key = `${place.street}\u0000${place.numbers.join("-")}`;
+    return [{ ...place, offset: start + place.offset, key, postcode, label }];
+  });
+};
+
+/** The postal addresses of a text that have a label shortly before them on their line. */
+export const labelledAddresses = (text: string, labels: readonly LexiconEntry[]): AddressWriting[] => {
+  const lines = text.split("\n");
+  const starts = lines.reduce<number[]>((acc, line, index) => [...acc, index === 0 ? 0 : (acc[index - 1] ?? 0) + (lines[index - 1] ?? "").length + 1], []);
+  return lines.flatMap((line, index) => lineAddresses(line, starts[index] ?? 0, labels));
+};
+
+/** Two lists of block numbers that are one address mistyped: the same numbers in another order, or one of them changed. */
+export const isBlockSlip = (a: readonly number[], b: readonly number[]): boolean => {
+  if (a.length !== b.length || a.join("-") === b.join("-")) return false;
+  const sorted = (numbers: readonly number[]): string => numbers.toSorted((x, y) => x - y).join("-");
+  const differing = a.filter((number, index) => number !== b[index]).length;
+  return sorted(a) === sorted(b) || differing === 1;
+};
+
+/** Whether two writings are on one street: the same town or street name, in the same area where both write one (千代田区 within 東京都千代田区). */
+const sameStreet = (a: AddressWriting, b: AddressWriting): boolean => a.street === b.street && (a.area.endsWith(b.area) || b.area.endsWith(a.area));
+
+const sameOffice = (a: AddressWriting, b: AddressWriting): boolean => a.label === b.label || a.label === ANY_OFFICE || b.label === ANY_OFFICE;
+
+export type AddressVariant = { readonly variant: "address" | "postcode"; readonly found: Variant<AddressWriting> };
+
+/** Every writing of an address that is another of the same street with its numbers mistyped, or under another postcode. */
+export const addressVariants = (text: string, labels: readonly LexiconEntry[]): AddressVariant[] => {
+  const addresses = labelledAddresses(text, labels);
+  const numbered = writingVariants(addresses, (a, b) => sameStreet(a, b) && sameOffice(a, b) && isBlockSlip(a.numbers, b.numbers));
+  const withPostcode = addresses.flatMap((address) => (address.postcode === undefined ? [] : [{ ...address, key: `${address.key}\u0000${address.postcode}` }]));
+  const postcoded = writingVariants(
+    withPostcode,
+    (a, b) => sameStreet(a, b) && a.numbers.join("-") === b.numbers.join("-") && a.postcode !== b.postcode && sameOffice(a, b),
+  );
+  const tagged =
+    (variant: AddressVariant["variant"]) =>
+    (found: Variant<AddressWriting>): AddressVariant => ({ variant, found });
+  return [...numbered.map(tagged("address")), ...postcoded.map(tagged("postcode"))];
+};

package/src/contacts/emails.ts

@@ -0,0 +1,63 @@
+// Email addresses written two ways in one document (support@hibari-lab.example and suport@hibari-lab.example). Two addresses
+// are one contact misspelt only when everything but one word of them is the same, so sales@ and support@ of one domain, or
+// one mailbox at two domains that differ by more than a slip, stay apart. Pure.
+import { writingVariants, type Variant, type Writing } from "./variants.ts";
+
+export type EmailWriting = Writing;
+
+const EMAIL = /(?<![\w.%+-])[a-z0-9][a-z0-9._%+-]*@[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+/giu;
+const SEPARATOR = /[.@\-_+%]/u;
+const SEPARATORS = /[.\-_]/gu;
+const DIGIT = /\d/u;
+/** A word shorter than this is a whole name (hr, pr, jp, sale, info), not one to be misspelt. */
+const MIN_WORD_LENGTH = 5;
+/** Longer than this, a word is an id rather than a name, and is not compared. */
+const MAX_WORD_LENGTH = 64;
+/** From this length a word may differ by two edits and still be a slip; a shorter one by one. */
+const TWO_EDIT_LENGTH = 6;
+
+/** The email addresses of a text, lower-cased into their key. */
+export const emailWritings = (text: string): EmailWriting[] =>
+  [...text.matchAll(EMAIL)].map((match) => ({ offset: match.index, written: match[0], key: match[0].toLowerCase() }));
+
+/** Edits (insert, delete, replace, swap of neighbours) between two short strings: the optimal string alignment distance. */
+export const editDistance = (a: string, b: string): number => {
+  const rows = [...a].reduce<number[][]>(
+    (done, charA, i) => {
+      const previous = done[i] ?? [];
+      const row = [...b].reduce<number[]>(
+        (cells, charB, j) => {
+          const cost = charA === charB ? 0 : 1;
+          const swapped = i > 0 && j > 0 && charA === b[j - 1] && a[i - 1] === charB ? (done[i - 1]?.[j - 1] ?? Infinity) + 1 : Infinity;
+          return [...cells, Math.min((previous[j + 1] ?? Infinity) + 1, (cells[j] ?? Infinity) + 1, (previous[j] ?? Infinity) + cost, swapped)];
+        },
+        [i + 1],
+      );
+      return [...done, row];
+    },
+    [[...Array(b.length + 1).keys()]],
+  );
+  return rows.at(-1)?.at(-1) ?? 0;
+};
+
+const separatorsOf = (address: string): string => [...address].filter((char) => SEPARATOR.test(char)).join("");
+
+/** One word of the two differs, by a slip: both long enough, no digits (support1@ and support2@ are two mailboxes). */
+const oneWordSlip = (a: string, b: string): boolean => {
+  if (separatorsOf(a) !== separatorsOf(b)) return false;
+  const wordsA = a.split(SEPARATOR);
+  const wordsB = b.split(SEPARATOR);
+  const differing = wordsA.flatMap((word, index): [string, string][] => (word === wordsB[index] ? [] : [[word, wordsB[index] ?? ""]]));
+  const [pair] = differing;
+  if (differing.length !== 1 || pair === undefined) return false;
+  const [wordA, wordB] = pair;
+  const shorter = Math.min(wordA.length, wordB.length);
+  if (shorter < MIN_WORD_LENGTH || Math.max(wordA.length, wordB.length) > MAX_WORD_LENGTH || DIGIT.test(wordA) || DIGIT.test(wordB)) return false;
+  return editDistance(wordA, wordB) <= (shorter >= TWO_EDIT_LENGTH ? 2 : 1);
+};
+
+/** Whether two addresses are one written two ways: a dot or hyphen dropped or added, or one word misspelt. */
+export const isEmailSlip = (a: string, b: string): boolean => a !== b && (a.replaceAll(SEPARATORS, "") === b.replaceAll(SEPARATORS, "") || oneWordSlip(a, b));
+
+/** Every writing of an address that is another address of the document written with a slip, with that other address. */
+export const emailVariants = (text: string): Variant<EmailWriting>[] => writingVariants(emailWritings(text), (a, b) => isEmailSlip(a.key, b.key));

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/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 }] : [];
+  });
+};