chaffjs 0.30.0 → 0.32.0

package/src/structure/unlisted-items.ts

@@ -0,0 +1,207 @@
+// unlisted-item-used: a numbered step that uses an ingredient or a tool the document's own list of what is needed (材料,
+// 用意するもの, Ingredients, What you need) does not name. Only a noun in a use frame is read: the object of a use verb
+// (塩を加える, add salt), and, when the document lists tools, the thing used (紙やすりで磨く, with a multi-tool) or put into
+// (バケツに沈める, in a bucket). A noun is listed when the document has written it before the step (the list, the title, an
+// earlier step), whole or by its last word; a noun always at hand (水, 手, water) is never reported. The words are the
+// language package's (item-list-heading, item-use, item-amount, item-at-hand, enumeration-joiner).
+
+export type ItemToken = { readonly surface: string; readonly pos: string; readonly lemma: string; readonly start: number; readonly end: number };
+
+/** A word that marks a use frame. after: it follows the noun (を, に, で); before: it precedes it (add, with, in). */
+export type UseMarker = { readonly word: string; readonly group: UseGroup; readonly position: "before" | "after" };
+
+export type UseGroup = "object" | "place" | "instrument";
+
+export type ItemWords = {
+  readonly ingredientHeadings: readonly string[];
+  readonly toolHeadings: readonly string[];
+  readonly markers: readonly UseMarker[];
+  /** The verbs that must follow an after-marker of each group; a group with none takes any verb. */
+  readonly verbs: Readonly<Partial<Record<UseGroup, readonly string[]>>>;
+  /** Words right after a verb (ず, ない) or right before it (not) that deny the use. */
+  readonly negations: readonly string[];
+  /** Verbs the tagger may read as nouns (stir, knead): a coordination ends at one. */
+  readonly actions: readonly string[];
+  readonly joiners: readonly string[];
+  /** A word after which the thing itself starts again (30 ml of soy sauce). */
+  readonly partitives: readonly string[];
+  readonly amounts: readonly string[];
+  readonly atHand: readonly string[];
+};
+
+export type ItemStep = { readonly start: number; readonly tokens: readonly ItemToken[] };
+
+export type UnlistedItem = { readonly offset: number; readonly item: string; readonly list: string };
+
+type ItemList = { readonly heading: string; readonly tools: boolean };
+
+type Candidate = { readonly tokens: readonly ItemToken[]; readonly group: UseGroup };
+
+const NOUN_POS = new Set(["NOUN", "PROPN"]);
+const SKIPPED_POS = new Set(["DET", "ADJ", "NUM"]);
+const CLAUSE_OPENER_POS = new Set(["PUNCT", "CCONJ", "ADV", "SCONJ", "X"]);
+const HAS_DIGIT = /\p{Nd}/u;
+const HEADING_TAIL_OPENER = /[（(:：【[]/u;
+
+const lower = (text: string): string => text.toLowerCase();
+
+/** A heading's words before a bracket or a colon, in lower case: 材料（2～3人分） is 材料. */
+export const headingKey = (heading: string): string => lower((heading.split(HEADING_TAIL_OPENER)[0] ?? "").trim());
+
+/** Spaces, hyphens and case are not a different word: multi-tool is multitool. */
+export const squeezed = (text: string): string => lower(text).replace(/[\s\-‐]/gu, "");
+
+const listKind = (heading: string, words: ItemWords): ItemList | undefined => {
+  const key = headingKey(heading);
+  const tools = words.toolHeadings.some((word) => lower(word) === key);
+  if (!tools && !words.ingredientHeadings.some((word) => lower(word) === key)) return undefined;
+  return { heading: heading.trim(), tools };
+};
+
+export const itemLists = (headings: readonly string[], words: ItemWords): ItemList[] => headings.flatMap((heading) => listKind(heading, words) ?? []);
+
+const isWord = (token: ItemToken | undefined, words: readonly string[]): boolean =>
+  token !== undefined && words.some((word) => word === token.surface || word === lower(token.surface) || word === token.lemma);
+
+const isAmount = (token: ItemToken, words: ItemWords): boolean => HAS_DIGIT.test(token.surface) || isWord(token, words.amounts);
+
+const isNoun = (token: ItemToken | undefined): boolean => token !== undefined && NOUN_POS.has(token.pos);
+
+const isHyphen = (token: ItemToken | undefined): boolean => token !== undefined && /^[-‐]$/u.test(token.surface);
+
+const BRACKET_PAIRS: Readonly<Record<string, string>> = { "）": "（", ")": "(", "」": "「", "]": "[" };
+
+/** The index of the bracket that opens the aside closing at index, or -1 when it does not close one. */
+const asideOpening = (tokens: readonly ItemToken[], index: number): number => {
+  const open = BRACKET_PAIRS[tokens[index]?.surface ?? ""];
+  if (open === undefined) return -1;
+  return tokens.findLastIndex((token, at) => at < index && token.surface === open);
+};
+
+type Reading = { readonly segments: readonly (readonly ItemToken[])[]; readonly current: readonly ItemToken[] };
+
+const EMPTY_READING: Reading = { segments: [], current: [] };
+
+const closed = (reading: Reading): Reading => (reading.current.length === 0 ? reading : { segments: [...reading.segments, reading.current], current: [] });
+
+const stepBack = (tokens: readonly ItemToken[], index: number, reading: Reading, words: ItemWords): Reading => {
+  const token = tokens[index];
+  if (token === undefined) return closed(reading);
+  const aside = asideOpening(tokens, index);
+  if (aside >= 0) return stepBack(tokens, aside - 1, reading, words);
+  if (isWord(token, words.joiners)) return stepBack(tokens, index - 1, closed(reading), words);
+  if (isAmount(token, words)) return stepBack(tokens, index - 1, reading, words);
+  if (isNoun(token)) return stepBack(tokens, index - 1, { segments: reading.segments, current: [token, ...reading.current] }, words);
+  return closed(reading);
+};
+
+/** The nouns joined before an after-marker (合いびき肉、卵、塩、こしょうを), read backwards up to the first other word. */
+export const phrasesBefore = (tokens: readonly ItemToken[], marker: number, words: ItemWords): (readonly ItemToken[])[] => [
+  ...stepBack(tokens, marker - 1, EMPTY_READING, words).segments,
+];
+
+const isModifier = (token: ItemToken, words: ItemWords): boolean =>
+  SKIPPED_POS.has(token.pos) || isAmount(token, words) || (token.pos === "VERB" && token.surface.endsWith("ed"));
+
+const isAction = (token: ItemToken, reading: Reading, words: ItemWords): boolean =>
+  reading.current.length === 0 && reading.segments.length > 0 && isWord(token, words.actions);
+
+const stepOn = (tokens: readonly ItemToken[], index: number, reading: Reading, words: ItemWords): Reading => {
+  const token = tokens[index];
+  if (token === undefined) return closed(reading);
+  const next = (after: Reading): Reading => stepOn(tokens, index + 1, after, words);
+  if (isWord(token, words.partitives)) return next({ segments: reading.segments, current: [] });
+  if (isWord(token, words.joiners)) return next(closed(reading));
+  if (isNoun(token) && !isAction(token, reading, words)) return next({ segments: reading.segments, current: [...reading.current, token] });
+  if (isHyphen(token) && reading.current.length > 0 && isNoun(tokens[index + 1])) return next(reading);
+  if (reading.current.length === 0 && isModifier(token, words)) return next(reading);
+  return closed(reading);
+};
+
+/** The nouns joined after a before-marker (add the egg, salt and pepper), read forwards up to the first other word. */
+export const phrasesAfter = (tokens: readonly ItemToken[], marker: number, words: ItemWords): (readonly ItemToken[])[] => [
+  ...stepOn(tokens, marker + 1, EMPTY_READING, words).segments,
+];
+
+const markerLength = (tokens: readonly ItemToken[], index: number, word: string): number => {
+  const parts = word.split(" ");
+  return parts.every((part, at) => isWord(tokens[index + at], [part])) ? parts.length : 0;
+};
+
+const deniedAfter = (tokens: readonly ItemToken[], verb: number, words: ItemWords): boolean => isWord(tokens[verb + 1], words.negations);
+
+const followedByUse = (tokens: readonly ItemToken[], index: number, group: UseGroup, words: ItemWords): boolean => {
+  const verb = tokens[index + 1];
+  if (verb === undefined || verb.pos !== "VERB") return false;
+  const verbs = words.verbs[group] ?? [];
+  return (verbs.length === 0 || isWord(verb, verbs)) && !deniedAfter(tokens, index + 1, words);
+};
+
+/** How far before a verb a negation still denies it (do not ever add). */
+const NEGATION_REACH = 3;
+
+const opensClause = (tokens: readonly ItemToken[], index: number, words: ItemWords): boolean => {
+  const previous = tokens[index - 1];
+  const denied = tokens.slice(Math.max(0, index - NEGATION_REACH), index).some((token) => isWord(token, words.negations));
+  return !denied && (previous === undefined || CLAUSE_OPENER_POS.has(previous.pos));
+};
+
+const candidatesAt = (tokens: readonly ItemToken[], index: number, marker: UseMarker, words: ItemWords): Candidate[] => {
+  if (marker.position === "after") {
+    if (tokens[index]?.pos !== "ADP" || !isWord(tokens[index], [marker.word]) || !followedByUse(tokens, index, marker.group, words)) return [];
+    return phrasesBefore(tokens, index, words).map((phrase) => ({ tokens: phrase, group: marker.group }));
+  }
+  const length = markerLength(tokens, index, marker.word);
+  const object = marker.group === "object";
+  if (length === 0 || (object && !opensClause(tokens, index, words))) return [];
+  // The thing a step puts in or works with comes before "of" (in a bucket of water); what it adds, after it (a pinch of salt).
+  const read = object ? words : { ...words, partitives: [] };
+  return phrasesAfter(tokens, index + length - 1, read).map((phrase) => ({ tokens: phrase, group: marker.group }));
+};
+
+/** Every noun phrase a step uses, in the order written. */
+export const usedPhrases = (tokens: readonly ItemToken[], words: ItemWords): Candidate[] =>
+  tokens
+    .flatMap((_, index) => words.markers.flatMap((marker) => candidatesAt(tokens, index, marker, words)))
+    .toSorted((left, right) => (left.tokens[0]?.start ?? 0) - (right.tokens[0]?.start ?? 0));
+
+const phraseText = (source: string, phrase: readonly ItemToken[]): string => source.slice(phrase[0]?.start ?? 0, phrase.at(-1)?.end ?? 0);
+
+const isAtHand = (source: string, phrase: readonly ItemToken[], words: ItemWords): boolean => {
+  const text = squeezed(phraseText(source, phrase));
+  const last = phrase.at(-1);
+  return words.atHand.some((word) => text.endsWith(squeezed(word)) || (last !== undefined && lower(last.lemma) === lower(word)));
+};
+
+/** The document as written and as the tagger read it: the source, and every word with its lemma (berries is berry). */
+export type ItemText = { readonly source: string; readonly words: readonly ItemToken[] };
+
+/** Written before: the whole phrase, or its last word as written or as its lemma (eggs, egg). */
+const isWrittenBefore = (text: ItemText, phrase: readonly ItemToken[]): boolean => {
+  const start = phrase[0]?.start ?? 0;
+  const earlier = squeezed(text.source.slice(0, start));
+  const last = phrase.at(-1);
+  const forms = [phraseText(text.source, phrase), last?.surface ?? "", last?.lemma ?? ""].map(squeezed).filter((form) => form !== "");
+  const lemma = lower(last?.lemma ?? "");
+  return forms.some((form) => earlier.includes(form)) || text.words.some((word) => word.start < start && lower(word.lemma) === lemma);
+};
+
+const unlistedIn = (text: ItemText, step: ItemStep, lists: readonly ItemList[], words: ItemWords): UnlistedItem[] => {
+  const tools = lists.some((list) => list.tools);
+  const listNames = lists.map((list) => list.heading).join(" / ");
+  return usedPhrases(step.tokens, words)
+    .filter((candidate) => (candidate.group === "object" || tools) && candidate.tokens.at(-1)?.pos === "NOUN")
+    .filter((candidate) => !isAtHand(text.source, candidate.tokens, words) && !isWrittenBefore(text, candidate.tokens))
+    .map((candidate) => ({ offset: candidate.tokens[0]?.start ?? step.start, item: phraseText(text.source, candidate.tokens), list: listNames }));
+};
+
+/**
+ * The things the numbered steps use that the document's list of what is needed does not name. Nothing when the document
+ * has no such list: a document that promises no list cannot leave something off it.
+ */
+export const unlistedItems = (text: ItemText, headings: readonly string[], steps: readonly ItemStep[], words: ItemWords): UnlistedItem[] => {
+  const lists = itemLists(headings, words);
+  if (lists.length === 0) return [];
+  const found = steps.flatMap((step) => unlistedIn(text, step, lists, words));
+  return found.filter((item, index) => found.findIndex((other) => squeezed(other.item) === squeezed(item.item)) === index);
+};

package/src/structure/variance-table.ts

@@ -0,0 +1,167 @@
+// variance-mismatch: a budget-versus-actual table whose variance cell is not the actual less the budget, or the budget less
+// the actual, whichever the table's other rows follow. Which heading names which column is data (lexicon variance-column);
+// the cells are read with change-rate-table's readers. Pure.
+import type { StructureIssue } from "./issues.ts";
+import { holds, plain, valueIn, type ChangeTable, type TableCell } from "./change-rate-table.ts";
+import { bodyRows, offsetOf } from "./order-quantity.ts";
+
+export type VarianceRole = "rate" | "variance" | "budget" | "actual";
+export type VarianceWord = { readonly pattern: string; readonly role: VarianceRole };
+export type VarianceWords = {
+  readonly columns: readonly VarianceWord[];
+  /** Words of magnitude (千, million): an amount written in them is rounded. */
+  readonly multipliers: readonly string[];
+};
+
+/** Rate words first (増減率 holds 増減, 予算比率 holds 予算), then the variance (予算比 holds 予算). */
+const ROLE_ORDER: readonly VarianceRole[] = ["rate", "variance", "budget", "actual"];
+const NEGATIVE_MARKS: ReadonlySet<string> = new Set(["-", "−", "▲", "△"]);
+/** A negative written in brackets: ($20.00), $(20.00), (6,000)円. */
+const BRACKETED = /^([^()\d]*)\(([^()]*)\)([^()\d]*)$/u;
+/** The mark of a negative or positive: △6,000円, ▲6,000, -$20.00, $-20.00, +4,680円. */
+const SIGN = /[△▲\-−+]/u;
+const SIGN_OR_BRACKET = /[△▲\-−+()]/u;
+const DIGIT_OR_MARK = /[\d△▲\-−+()]/u;
+const HALF = 0.5;
+
+type Columns = { readonly budget: number; readonly actual: number; readonly variance: number };
+type Amount = { readonly value: number; readonly step: number; readonly marks: string };
+type Variance = Amount & { readonly written: string };
+
+/** The heading's role; none when it names both the budget and the actual and no variance or rate (Budget / Actual). */
+const roleOf = (heading: string, words: readonly VarianceWord[]): VarianceRole | undefined => {
+  const key = plain(heading).toLowerCase();
+  const named = ROLE_ORDER.filter((role) => words.some((word) => word.role === role && holds(key, word.pattern)));
+  const [first] = named;
+  return first === "budget" && named.includes("actual") ? undefined : first;
+};
+
+/** The one budget, actual and variance column the headings name; undefined when any is missing or named twice. */
+export const varianceColumnsOf = (headings: readonly string[], words: readonly VarianceWord[]): Columns | undefined => {
+  const roles = headings.map((heading) => roleOf(heading, words));
+  const only = (role: VarianceRole): number | undefined => {
+    const indexes = roles.flatMap((found, index) => (found === role ? [index] : []));
+    return indexes.length === 1 ? indexes[0] : undefined;
+  };
+  const [budget, actual, variance] = [only("budget"), only("actual"), only("variance")];
+  return budget === undefined || actual === undefined || variance === undefined ? undefined : { budget, actual, variance };
+};
+
+/** The signed amount a variance cell writes: △, ▲, −, - or brackets for a negative; undefined when it is not an amount (—, 1.2%). */
+export const signedIn = (text: string): Amount | undefined => {
+  const cell = plain(text);
+  const bracket = BRACKETED.exec(cell);
+  if (bracket !== null) {
+    const inner = valueIn(`${bracket[1] ?? ""}${bracket[2] ?? ""}${bracket[3] ?? ""}`);
+    return inner === undefined ? undefined : { ...inner, value: -inner.value };
+  }
+  const at = cell.search(SIGN);
+  if (at < 0) return valueIn(cell);
+  const [before, mark, after] = [cell.slice(0, at), cell.charAt(at), cell.slice(at + 1)];
+  if (DIGIT_OR_MARK.test(before) || SIGN_OR_BRACKET.test(after)) return undefined;
+  const inner = valueIn(`${before.trimEnd()}${after.trimStart()}`);
+  if (inner === undefined) return undefined;
+  return NEGATIVE_MARKS.has(mark) ? { ...inner, value: -inner.value } : inner;
+};
+
+/** A mark of currency and no word of magnitude: the amounts are exact. A bare number or 千円, $ million may be rounded. */
+const isRounded = (marks: string, multipliers: readonly string[]): boolean =>
+  marks === "|" || multipliers.some((word) => marks.toLowerCase().includes(word.toLowerCase()));
+
+type Row = {
+  readonly cell: TableCell;
+  readonly label: string;
+  readonly variance: Variance;
+  /** actual − budget */
+  readonly difference: number;
+  readonly gap: number;
+};
+
+/** How far a written variance may be from the difference: rounded amounts by one step of the coarsest last digit. */
+const gapOf = (amounts: readonly Amount[], rounded: boolean): number => {
+  const steps = amounts.map((amount) => amount.step);
+  const [finest, coarsest] = [Math.min(...steps), Math.max(...steps)];
+  return rounded ? coarsest + HALF * finest : HALF * finest;
+};
+
+const rowOf = (row: readonly TableCell[], columns: Columns, words: VarianceWords): Row | undefined => {
+  const [budgetCell, actualCell, cell] = [row[columns.budget], row[columns.actual], row[columns.variance]];
+  const budget = budgetCell === undefined ? undefined : valueIn(budgetCell.text);
+  const actual = actualCell === undefined ? undefined : valueIn(actualCell.text);
+  const variance = cell === undefined ? undefined : signedIn(cell.text);
+  if (cell === undefined || budget === undefined || actual === undefined || variance === undefined) return undefined;
+  if (budget.marks !== actual.marks || (variance.marks !== budget.marks && variance.marks !== "|")) return undefined;
+  const gap = gapOf([budget, actual, variance], isRounded(budget.marks, words.multipliers));
+  return { cell, label: plain(row[0]?.text ?? ""), variance: { ...variance, written: plain(cell.text) }, difference: actual.value - budget.value, gap };
+};
+
+type Convention = 1 | -1;
+const CONVENTIONS: readonly Convention[] = [1, -1];
+
+const opposite = (convention: Convention): Convention => (convention === 1 ? -1 : 1);
+
+const follows = (row: Row, convention: Convention): boolean => Math.abs(row.variance.value - convention * row.difference) <= row.gap;
+
+/** Rows whose variance is the same under both conventions (a zero difference) say nothing about which one the table uses. */
+const votesFor = (rows: readonly Row[], convention: Convention): number =>
+  rows.filter((row) => follows(row, convention) && !follows(row, opposite(convention))).length;
+
+/**
+ * The convention most rows follow (1: actual − budget, -1: budget − actual); undefined on a tie. A row following the
+ * other convention is a sign slip only when it is the one such row: two or more are a convention the writer chose.
+ */
+const conventionOf = (rows: readonly Row[]): { readonly convention: Convention; readonly others: number } | undefined => {
+  const [forward, backward] = CONVENTIONS.map((convention) => votesFor(rows, convention));
+  if (forward === backward || forward === undefined || backward === undefined) return undefined;
+  return forward > backward ? { convention: 1, others: backward } : { convention: -1, others: forward };
+};
+
+const NUMBER = /\d[\d,]*(?:\.\d+)?/u;
+const SIGN_MARKS = /[△▲\-−+()]/gu;
+
+const sameSign = (value: number, expected: number): boolean => value < 0 === expected < 0;
+
+/** The expected variance written the way a cell of the same sign in the table is (△6,900円, ($10.80)), else like the written one. */
+const shown = (expected: number, row: Row, rows: readonly Row[]): string => {
+  const like = rows.find((other) => other.variance.marks === row.variance.marks && sameSign(other.variance.value, expected)) ?? row;
+  const decimals = Math.max(0, -Math.round(Math.log10(row.variance.step)));
+  const number = Math.abs(expected).toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals,
+    useGrouping: like.variance.written.includes(","),
+  });
+  const filled = like.variance.written.replace(NUMBER, number);
+  if (sameSign(like.variance.value, expected)) return filled;
+  const unsigned = filled.replace(SIGN_MARKS, "").trim();
+  return expected < 0 ? `-${unsigned}` : unsigned;
+};
+
+const tableIssues = (rows: readonly Row[], fallback: Convention | undefined): StructureIssue[] => {
+  const silent = votesFor(rows, 1) === 0 && votesFor(rows, -1) === 0;
+  const decided = silent && fallback !== undefined ? { convention: fallback, others: 0 } : conventionOf(rows);
+  if (decided === undefined) return [];
+  const { convention, others } = decided;
+  return rows.flatMap((row) => {
+    if (follows(row, convention) || (follows(row, opposite(convention)) && others > 1)) return [];
+    const expected = convention * row.difference;
+    return [{ offset: offsetOf(row.cell), values: { item: row.label, written: row.variance.written, expected: shown(expected, row, rows) } }];
+  });
+};
+
+/**
+ * Each row of a budget / actual / variance table whose variance is neither rounding away from the actual less the budget
+ * nor, in a table whose rows take the budget less the actual, from that. The convention is the one most of the table's
+ * rows follow; a table where no row tells takes the document's, and one where the rows split evenly is left alone.
+ */
+export const varianceMismatches = (tables: readonly ChangeTable[], words: VarianceWords): StructureIssue[] => {
+  const read = tables.flatMap((table) => {
+    const columns = varianceColumnsOf(
+      table.header.map((cell) => cell.text),
+      words.columns,
+    );
+    if (columns === undefined) return [];
+    return [bodyRows(table).flatMap((row) => rowOf(row, columns, words) ?? [])];
+  });
+  const fallback = conventionOf(read.flat())?.convention;
+  return read.flatMap((rows) => tableIssues(rows, fallback));
+};

package/src/structure/walk-time.ts

@@ -0,0 +1,285 @@
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * 書いた距離と合わない徒歩の分数（駅 徒歩3分（約600m）、a 3-minute walk (600 m)）。徒歩の語に付いた分数と、そのすぐ前かすぐ後ろの
+ * 距離だけを組にし、文書の速さで歩いた分数と比べる。速さは文書に書いたもの（道路距離80mを1分、80 m per minute、5 km/h）を使い、
+ * 書いていなければ呼ぶ側が渡す速さ（文書の種類の速さ。不動産の広告は 80m で1分、切り上げ）を使う。どちらも無ければ速さを推し量らない。
+ * 約の付いた距離は、書いた一番下の桁の半分だけ幅を持たせる（約1.2km は 1.15〜1.25km）。小数の距離は書いた桁の半分の幅を持つ。
+ * 範囲（5〜7分）、上限（10分以内）、約の付いた分数は比べない。語は言語パッケージの語彙表から受け取る。
+ */
+
+/** 語彙表の一語。position は数のどちら側に書くか。weight は単位の倍率（長さは m、時間は秒）。 */
+export type WalkMark = {
+  readonly pattern: string;
+  readonly position?: "before" | "after" | undefined;
+  readonly weight?: number | undefined;
+};
+
+export type WalkWords = {
+  /** 分数を徒歩の時間にする語（徒歩、walk）。position は分数のどちら側か。 */
+  readonly walks: readonly WalkMark[];
+  /** 徒歩の語と分数の間に挟んでよい語（徒歩で5分の で）。 */
+  readonly gaps: readonly string[];
+  /** 分数を上限にする語（以内、within）。position は分数のどちら側か。 */
+  readonly bounds: readonly WalkMark[];
+  /** 二つの数を範囲にする語（5から7分、8 to 10 minutes）。〜 や - の記号は語彙表に書かなくても読む。 */
+  readonly ranges: readonly string[];
+  /** 約や上限の語と数の間で読み飛ばす語（about a 5-minute walk の a）。 */
+  readonly fillers: readonly string[];
+  /** 長さの単位。weight は m への倍率。 */
+  readonly lengths: readonly WalkMark[];
+  /** 時間の単位。weight は秒への倍率。分より短い単位は分数に使わない。 */
+  readonly times: readonly WalkMark[];
+  /** 数を概数にする語（約、about）。 */
+  readonly hedges: readonly string[];
+  /** 長さを速さにする語（を1分、per minute、/h、分速）。weight はその時間の秒。 */
+  readonly perTimes: readonly WalkMark[];
+  /** 速さの行にあれば、端数を切り上げると言う語（切り上げ、rounded up）。 */
+  readonly roundUps: readonly string[];
+  /** 速さの行にあれば、切り上げの語があっても切り上げではないと言う語（切り上げません、not rounded up）。 */
+  readonly notRoundUps: readonly string[];
+};
+
+/** 1分に歩く m と、端数の扱い。up は切り上げだけ、any は切り上げでも切り捨てでも合う。 */
+export type WalkRate = { readonly metresPerMinute: number; readonly rounding: "up" | "any" };
+
+/** 読んだ距離。metres は書いた値、margin は書いた桁から来る幅の半分（m）。 */
+export type Distance = { readonly start: number; readonly end: number; readonly metres: number; readonly margin: number };
+
+/** 徒歩の分数。lead は前に書いた徒歩の語の始まり（徒歩5分 の 徒歩）、後ろに書くなら数の始まり。 */
+type Minutes = { readonly start: number; readonly end: number; readonly lead: number; readonly value: number };
+
+type Reading = { readonly start: number; readonly end: number; readonly digits: string; readonly unit: WalkMark; readonly unitEnd: number };
+
+const DIGIT = "[0-9０-９]";
+const NUMBER = new RegExp(`(?<!${DIGIT}|[.,，．])${DIGIT}+(?:[,，]${DIGIT}{3})*(?:[.．]${DIGIT}+)?(?!${DIGIT}|[.．,，]${DIGIT})`, "gu");
+const LETTER = /[A-Za-z]/u;
+/** 単位のすぐ後ろにあれば、その単位ではない（m のあとの in、㎡ の 2、m² の ²）。 */
+const UNIT_CONTINUES = /^[A-Za-z0-9０-９²³]/u;
+/** 数と単位の間に置けるもの（1.2 km、5-minute）。 */
+const NUMBER_UNIT_GAP = /^[ \u00a0-]?/u;
+/** 分数と後ろの徒歩の語の間に置けるもの（5 minutes' walk、5 min. walk）。 */
+const MINUTES_WALK_GAP = /^[\s'’.]*/u;
+/**
+ * 分数と距離の間に置けるもの。開き括弧か・か / の一つだけ（徒歩5分（400m）、400m（徒歩5分）、徒歩5分・400m）。
+ * 読点では組にしない（標高600m、徒歩3分 の 600m は道のりではない）。
+ */
+const PAIR_GAP = /^\s*[(（[［【・/／]\s*$/u;
+const RANGE_MARKS: readonly string[] = ["〜", "~", "～", "–", "—", "-"];
+const DIGIT_START = new RegExp(`^${DIGIT}`, "u");
+const DIGIT_END = new RegExp(`${DIGIT}$`, "u");
+/** 浮動小数の誤差（1150 / 80 など）で切り上げが一つずれないための小さな数。 */
+const EPSILON = 1e-9;
+const MINUTE_SECONDS = 60;
+/** 時速から出した速さ（4km/h は 66.66…m/分）を、言うときに小数一桁にする。 */
+const RATE_DECIMALS = 10;
+
+const normal = (text: string): string => text.normalize("NFKC").toLowerCase();
+
+const valueOf = (digits: string): number => Number(digits.normalize("NFKC").replaceAll(",", ""));
+
+const isWordEdge = (text: string, at: number): boolean => !(LETTER.test(text.charAt(at - 1)) && LETTER.test(text.charAt(at)));
+
+const startsWithWord = (text: string, word: string): boolean => normal(text.slice(0, word.length)) === normal(word) && isWordEdge(text, word.length);
+
+const endsWithWord = (text: string, word: string): boolean =>
+  text.length >= word.length && normal(text.slice(-word.length)) === normal(word) && isWordEdge(text, text.length - word.length);
+
+/** 末尾の空白と、読み飛ばす語を除く（about a の a）。 */
+const trimFillers = (text: string, fillers: readonly string[]): string => {
+  const trimmed = text.trimEnd();
+  const filler = fillers.find((word) => endsWithWord(trimmed, word));
+  return filler === undefined ? trimmed : trimFillers(trimmed.slice(0, -filler.length), fillers);
+};
+
+/** 位置 at から始まる単位。㎞ のような一字の単位も NFKC で照らす。長い語から。 */
+const unitAt = (line: string, at: number, units: readonly WalkMark[]): { readonly unit: WalkMark; readonly end: number } | undefined =>
+  units
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((unit) =>
+      Array.from({ length: unit.pattern.length }, (_, index) => at + index + 1)
+        .filter((end) => normal(line.slice(at, end)) === normal(unit.pattern) && !UNIT_CONTINUES.test(line.slice(end)))
+        .map((end) => ({ unit, end })),
+    )[0];
+
+/** 一行の中の、単位の付いた数。 */
+const readingsIn = (line: string, units: readonly WalkMark[]): Reading[] =>
+  [...line.matchAll(NUMBER)].flatMap((match) => {
+    const numberEnd = match.index + match[0].length;
+    const unitStart = numberEnd + (NUMBER_UNIT_GAP.exec(line.slice(numberEnd))?.[0].length ?? 0);
+    const found = unitAt(line, unitStart, units);
+    return found === undefined ? [] : [{ start: match.index, end: numberEnd, digits: match[0], unit: found.unit, unitEnd: found.end }];
+  });
+
+const endsWithAny = (text: string, words: readonly string[]): boolean => words.some((word) => endsWithWord(text, word));
+
+/** 範囲の片側の数か（5〜7分 の 7、5分から10分 の 5分、400m〜600m の 400m、8 to 10 minutes の 10）。 */
+const isRangeEnd = (line: string, reading: Reading, units: readonly WalkMark[], rangeWords: readonly string[]): boolean => {
+  const joins = [...RANGE_MARKS, ...rangeWords];
+  const after = line.slice(reading.unitEnd).trimStart();
+  const next = joins.find((word) => startsWithWord(after, word));
+  if (next !== undefined && DIGIT_START.test(after.slice(next.length).trimStart())) return true;
+  const before = line.slice(0, reading.start).trimEnd();
+  const previous = joins.find((word) => endsWithWord(before, word));
+  if (previous === undefined) return false;
+  const left = before.slice(0, -previous.length).trimEnd();
+  const unit = units.find((mark) => endsWithWord(left, mark.pattern));
+  return DIGIT_END.test(unit === undefined ? left : left.slice(0, -unit.pattern.length).trimEnd());
+};
+
+/** 数のすぐ前（読み飛ばす語の後ろ）に約の語があるか。 */
+const isHedged = (line: string, start: number, words: WalkWords): boolean =>
+  endsWithAny(trimFillers(line.slice(0, start).replace(/[(（[［]$/u, ""), words.fillers), words.hedges);
+
+const boundBefore = (prefix: string, words: WalkWords): boolean =>
+  endsWithAny(
+    trimFillers(prefix, words.fillers),
+    words.bounds.filter((bound) => bound.position === "before").map((bound) => bound.pattern),
+  );
+
+const boundAfter = (rest: string, words: WalkWords): boolean =>
+  words.bounds.filter((bound) => bound.position !== "before").some((bound) => startsWithWord(rest.trimStart(), bound.pattern));
+
+/** 前に書く徒歩の語（徒歩5分、徒歩で5分）。あれば、その語の始まりの位置。 */
+const walkBeforeStart = (prefix: string, words: WalkWords): number | undefined => {
+  const trimmed = prefix.trimEnd();
+  const gap = words.gaps.find((word) => trimmed.endsWith(word));
+  const head = gap === undefined ? trimmed : trimmed.slice(0, -gap.length).trimEnd();
+  const walk = words.walks.find((mark) => mark.position === "before" && endsWithWord(head, mark.pattern));
+  return walk === undefined ? undefined : head.length - walk.pattern.length;
+};
+
+/** 後ろに書く徒歩の語（a 5-minute walk）。あれば、その語の終わりの位置。 */
+const walkAfterEnd = (line: string, from: number, words: WalkWords): number | undefined => {
+  const at = from + (MINUTES_WALK_GAP.exec(line.slice(from))?.[0].length ?? 0);
+  const walk = words.walks.find((mark) => mark.position === "after" && startsWithWord(line.slice(at), mark.pattern));
+  return walk === undefined ? undefined : at + walk.pattern.length;
+};
+
+const minuteUnits = (words: WalkWords): WalkMark[] => words.times.filter((unit) => (unit.weight ?? 0) >= MINUTE_SECONDS);
+
+/** 一行の中の、徒歩の分数。範囲、上限、約の付いた分数は読まない。 */
+export const walkMinutesIn = (line: string, words: WalkWords): Minutes[] =>
+  readingsIn(line, minuteUnits(words)).flatMap((reading) => {
+    const prefix = line.slice(0, reading.start);
+    const leadStart = walkBeforeStart(prefix, words);
+    const afterEnd = walkAfterEnd(line, reading.unitEnd, words);
+    if (leadStart === undefined && afterEnd === undefined) return [];
+    if (isRangeEnd(line, reading, words.times, words.ranges) || isHedged(line, reading.start, words)) return [];
+    if (boundBefore(prefix, words) || boundAfter(line.slice(afterEnd ?? reading.unitEnd), words)) return [];
+    const value = (valueOf(reading.digits) * (reading.unit.weight ?? 0)) / MINUTE_SECONDS;
+    if (!Number.isInteger(value) || value <= 0) return [];
+    return [{ start: reading.start, end: afterEnd ?? reading.unitEnd, lead: leadStart ?? reading.start, value }];
+  });
+
+/** 書いた数の桁から来る幅の半分（書いた単位で）。小数は最後の桁、約の付いた整数は最後の 0 でない桁。それ以外は 0。 */
+export const marginOf = (digits: string, hedged: boolean): number => {
+  const plain = digits.normalize("NFKC").replaceAll(",", "");
+  const point = plain.indexOf(".");
+  if (point !== -1) return 10 ** -(plain.length - point - 1) / 2;
+  if (!hedged) return 0;
+  const lastNonZero = [...plain].findLastIndex((digit) => digit !== "0");
+  const zeros = plain.length - 1 - lastNonZero;
+  return 10 ** zeros / 2;
+};
+
+/** 一行の中の距離。範囲の片側は読まない。 */
+export const distancesIn = (line: string, words: WalkWords): Distance[] =>
+  readingsIn(line, words.lengths)
+    .filter((reading) => !isRangeEnd(line, reading, words.lengths, words.ranges))
+    .flatMap((reading) => {
+      const weight = reading.unit.weight ?? 0;
+      const metres = valueOf(reading.digits) * weight;
+      const margin = marginOf(reading.digits, isHedged(line, reading.start, words)) * weight;
+      return metres > 0 ? [{ start: reading.start, end: reading.unitEnd, metres, margin }] : [];
+    });
+
+/**
+ * 分数と組になる距離。すぐ後ろ（徒歩5分（400m））を先に、無ければすぐ前（400m（徒歩5分））を見る。間に置けるのは記号と約の語だけ。
+ * 一つの距離は一つの分数とだけ組にする。
+ */
+export const walkPairs = (line: string, words: WalkWords): { readonly minutes: Minutes; readonly distance: Distance }[] => {
+  const distances = distancesIn(line, words);
+  const between = (from: number, to: number): boolean => from <= to && PAIR_GAP.test(trimFillers(line.slice(from, to), [...words.hedges, ...words.fillers]));
+  const used = new Set<Distance>();
+  return walkMinutesIn(line, words).flatMap((minutes) => {
+    const after = distances.find((distance) => !used.has(distance) && between(minutes.end, distance.start));
+    const before = after ?? distances.findLast((distance) => !used.has(distance) && between(distance.end, minutes.lead));
+    if (before === undefined) return [];
+    used.add(before);
+    return [{ minutes, distance: before }];
+  });
+};
+
+/** 一行に書いた速さ（m/分）。距離のすぐ後ろ（80mを1分、80 m per minute）かすぐ前（分速80m）に時間の語がある距離。 */
+export const ratesIn = (line: string, words: WalkWords): number[] =>
+  distancesIn(line, words).flatMap((distance) => {
+    const rest = line.slice(distance.end).trimStart();
+    const head = line.slice(0, distance.start).trimEnd();
+    const per =
+      words.perTimes.find((mark) => mark.position !== "before" && startsWithWord(rest, mark.pattern)) ??
+      words.perTimes.find((mark) => mark.position === "before" && endsWithWord(head, mark.pattern));
+    return per === undefined ? [] : [distance.metres / ((per.weight ?? MINUTE_SECONDS) / MINUTE_SECONDS)];
+  });
+
+const containsAny = (text: string, words: readonly string[]): boolean => words.some((word) => normal(text).includes(normal(word)));
+
+/** 速さを読む行。徒歩の語（Walking も walk の語として）を含む行。 */
+const hasWalkWord = (line: string, words: WalkWords): boolean =>
+  containsAny(
+    line,
+    words.walks.map((walk) => walk.pattern),
+  );
+
+const linesOf = (source: string): { readonly text: string; readonly start: number }[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1), start }));
+};
+
+/**
+ * 文書の速さ。徒歩の語のある行に書いた速さが一つ（一つの値）だけなら、それを使う。端数は、その行に切り上げの語があれば切り上げだけ、
+ * 無ければどちらでもよい。二つ以上の値があれば、どの分数がどれで計ったか決められないので比べない。書いていなければ fallback。
+ */
+export const statedRate = (source: string, words: WalkWords, fallback?: WalkRate): WalkRate | undefined => {
+  const stated = linesOf(source)
+    .filter((line) => hasWalkWord(line.text, words))
+    .flatMap((line) =>
+      ratesIn(line.text, words).map((rate) => ({ rate, up: containsAny(line.text, words.roundUps) && !containsAny(line.text, words.notRoundUps) })),
+    );
+  const first = stated[0];
+  if (first === undefined) return fallback;
+  if (stated.some((other) => other.rate !== first.rate)) return undefined;
+  return { metresPerMinute: first.rate, rounding: stated.some((other) => other.up) ? "up" : "any" };
+};
+
+/** その距離を歩いて合う分数の幅。margin の幅の上の端は含まない（1.25km は 1.3km と書く）。 */
+export const expectedMinutes = (distance: Pick<Distance, "metres" | "margin">, rate: WalkRate): { readonly low: number; readonly high: number } => {
+  const low = (distance.metres - distance.margin) / rate.metresPerMinute;
+  const high = (distance.metres + distance.margin) / rate.metresPerMinute;
+  return { low: rate.rounding === "up" ? Math.ceil(low - EPSILON) : Math.floor(low + EPSILON), high: Math.ceil(high - EPSILON) };
+};
+
+const rangeText = (low: number, high: number): string => (low === high ? String(low) : `${String(low)}–${String(high)}`);
+
+/** 距離と合わない徒歩の分数。分数の位置を指す。 */
+export const walkTimeMismatches = (source: string, words: WalkWords, fallback?: WalkRate): StructureIssue[] => {
+  const rate = statedRate(source, words, fallback);
+  if (rate === undefined) return [];
+  return linesOf(source).flatMap((line) =>
+    walkPairs(line.text, words).flatMap(({ minutes, distance }) => {
+      const { low, high } = expectedMinutes(distance, rate);
+      if (minutes.value >= low && minutes.value <= high) return [];
+      return [
+        {
+          offset: line.start + minutes.lead,
+          values: {
+            minutes: line.text.slice(minutes.lead, minutes.end),
+            distance: line.text.slice(distance.start, distance.end),
+            expected: rangeText(Math.max(low, 1), Math.max(high, 1)),
+            rate: Math.round(rate.metresPerMinute * RATE_DECIMALS) / RATE_DECIMALS,
+          },
+        },
+      ];
+    }),
+  );
+};