chaffjs 0.30.0 → 0.31.0

package/src/structure/total.ts

@@ -8,7 +8,14 @@ import { bareNumbersIn, CELL_SEPARATOR, NO_UNIT } from "./bare-numbers.ts";
  * 小計と税のあとの総計のように、足し方が何通りかある。どの足し方でも合わないときだけ言う。
  * 表の升に数だけを書いた列（単位は見出しにある）も足す。そのときは上の行の升がどれも数でなければ足さない。年や番号の列を足さないため。
  */
-export type Amount = { readonly offset: number; readonly end: number; readonly value: number; readonly unit: string };
+export type Amount = {
+  readonly offset: number;
+  readonly end: number;
+  readonly value: number;
+  readonly unit: string;
+  /** 単位の付いた量（0.5 g）は、量の種類の一番小さい単位（mg）に直して足す。scale は書いた単位一つがその単位いくつか（g なら 1,000）。 */
+  readonly scale?: number;
+};
 
 const CENTS = 100;
 
@@ -36,7 +43,7 @@ const isNegative = (source: string, line: Line, amount: Amount): boolean => {
 };
 
 /** 行の最初の文字列（表なら最初の列）から、強調の印と箇条書きの印を除いたもの。 */
-const leadingText = (text: string): string =>
+export const leadingText = (text: string): string =>
   text
     .replace(/^[ \t]*(?:[-*+]|\d{1,3}[.)])?[ \t]*\|?[ \t]*/u, "")
     .replace(/^[*_]+/u, "")
@@ -58,8 +65,11 @@ const centsOf = (source: string, line: Line, amount: Amount): number | undefined
   return Math.round(amount.value * CENTS) * (isNegative(source, line, amount) ? -1 : 1);
 };
 
-const entryOf = (source: string, line: Line, amounts: readonly Amount[], labels: readonly string[]): Entry => ({
-  label: isTotalLabel(source.slice(line.start, line.end), labels),
+/** 行が合計の行か。語彙で決める判定は呼ぶ側が渡す。 */
+export type IsTotalLine = (text: string) => boolean;
+
+const entryOf = (source: string, line: Line, amounts: readonly Amount[], isTotal: IsTotalLine): Entry => ({
+  label: isTotal(source.slice(line.start, line.end)),
   amounts: amounts
     .filter((amount) => amount.offset >= line.start && amount.offset <= line.end)
     .map((amount) => ({ ...amount, column: columnOf(source, line, amount.offset), cents: centsOf(source, line, amount) })),
@@ -169,6 +179,30 @@ export const shownTotal = (source: string, total: Amount, sumCents: number): Rec
 const readsAsSum = (cell: Cell, writtenCents: number, above: RowsAbove): boolean =>
   cell.unit !== NO_UNIT || above.parts.some((part) => part < 0) || above.parts.every((part) => part < writtenCents);
 
+/** 書いた数の小数の桁（0.25 g なら 2）。 */
+const decimalsOf = (written: string): number => /[.．](\d+)/u.exec(written.normalize("NFKC"))?.[1]?.length ?? 0;
+
+/** 見せる和の小数の桁の上限。合計より細かい単位の内訳（1 g の合計に 250 mg の内訳）の和を、合計の単位で見せるため。 */
+const MAX_SHOWN_DECIMALS = 3;
+
+/** 換算の倍率が割り切れない単位（8 oz + 8 oz = 1 lb）で、丸めの差を合うとみなす割合。 */
+const MEASURE_TOLERANCE = 1e-6;
+
+/** 単位の付いた量の合計。和は合計に書いた単位と書き方で見せる（1 g の合計に 300 mg と 0.6 g の内訳なら 0.9 g）。 */
+const measuredMismatch = (source: string, total: Placed, scale: number, sums: readonly number[], reported: number): StructureIssue[] => {
+  const number = source.slice(total.offset, total.end);
+  const digits = decimalsOf(number);
+  const written = total.value * CENTS;
+  if (sums.some((sum) => Math.abs(sum - written) <= Math.abs(written) * MEASURE_TOLERANCE)) return [];
+  const inTotalUnit = (cents: number): number => cents / CENTS / scale;
+  const sum = inTotalUnit(reported).toLocaleString("en-US", {
+    minimumFractionDigits: digits,
+    maximumFractionDigits: Math.max(digits, MAX_SHOWN_DECIMALS),
+    useGrouping: !UNGROUPED.test(number),
+  });
+  return [{ offset: total.offset, values: { written: number, sum: `${sum}${unitAfterNumber(number, total.unit)}` } }];
+};
+
 const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue[] =>
   entries.flatMap((entry, index) => {
     if (!entry.label) return [];
@@ -176,16 +210,17 @@ const mismatchesIn = (source: string, entries: readonly Entry[]): StructureIssue
       const writtenCents = valueIn(entry, total);
       const above = windowAbove(entries.slice(0, index), total);
       if (typeof writtenCents !== "number" || above === undefined || !enoughRows(above) || !readsAsSum(total, writtenCents, above)) return [];
+      if (total.scale !== undefined) return measuredMismatch(source, total, total.scale, candidateSums(above), reportedSum(above));
       if (candidateSums(above).includes(writtenCents)) return [];
       return [{ offset: total.offset, values: shownAmounts(source, total, reportedSum(above)) }];
     });
   });
 
-export const totalMismatches = (source: string, amounts: readonly Amount[], labels: readonly string[]): StructureIssue[] =>
+export const totalMismatches = (source: string, amounts: readonly Amount[], isTotal: IsTotalLine): StructureIssue[] =>
   runsOf(source).flatMap((run) => {
     const inRun = [...amounts, ...bareNumbersIn(source, run)];
     return mismatchesIn(
       source,
-      run.map((line) => entryOf(source, line, inRun, labels)),
+      run.map((line) => entryOf(source, line, inRun, isTotal)),
     );
   });

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