chaffjs 0.29.0 → 0.31.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/version-order.ts

@@ -32,6 +32,16 @@ const compareVersions = (left: Version, right: Version): number => {
   return differing === -1 ? comparePrerelease(left.prerelease, right.prerelease) : Math.sign((left.parts[differing] ?? 0) - (right.parts[differing] ?? 0));
 };
 
+/** Whether every label is a version and no step goes against direction (equal versions do not break it). */
+export const versionsAlong = (labels: readonly (string | undefined)[], direction: number): boolean => {
+  const versions = labels.flatMap((label) => {
+    const version = label === undefined ? undefined : parse(label);
+    return version === undefined ? [] : [version];
+  });
+  if (versions.length !== labels.length) return false;
+  return versions.slice(1).every((version, index) => compareVersions(version, versions[index] ?? version) !== -direction);
+};
+
 /** The longest run along direction ending at each version (equal versions do not break it). */
 const longestEndingAt = (versions: readonly Version[], direction: number): number[] =>
   versions.reduce<number[]>((lengths, version, 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,
+          },
+        },
+      ];
+    }),
+  );
+};

package/src/surname-near.ts

@@ -0,0 +1,31 @@
+// 名が同じ人の名前の、姓だけの書き損じ（Whitford と Whitfield）。一字違い（isNearWord）より遠い違いを、英字の長い姓に限って見る。
+
+const LATIN_WORD = /^[a-z]+$/u;
+
+/** 二字違いまで見る姓の長さ。短い姓（Martin と Marten、Hansen と Hanson）は別の姓のことが多い。 */
+const MIN_SURNAME_LENGTH = 7;
+/** 頭からそろう字の数。頭が違えば別の姓（Robertson と Robinson）。 */
+const MIN_SURNAME_PREFIX = 4;
+/** 頭と終わりのそろった字のあいだに残る字の数。短いほうで二字まで、長いほうで三字まで（Whitford の or と Whitfield の iel）。 */
+const MAX_SURNAME_GAP = 2;
+
+const sharedPrefix = (left: string, right: string): number => {
+  const differ = [...left].findIndex((char, index) => char !== right.charAt(index));
+  return differ < 0 ? left.length : differ;
+};
+
+/**
+ * 二つの英字の姓が、頭が四字以上そろい、終わりの字もそろい、あいだの二字（長いほうは三字）までだけ違うか。どちらも七字以上で。
+ * 終わりだけの違い（Whitford と Whitfords）は語の形の違い。
+ */
+export const isNearSurname = (left: string, right: string): boolean => {
+  if (left === right || !LATIN_WORD.test(left) || !LATIN_WORD.test(right) || Math.min(left.length, right.length) < MIN_SURNAME_LENGTH) return false;
+  const prefix = sharedPrefix(left, right);
+  if (prefix < MIN_SURNAME_PREFIX) return false;
+  const [leftRest, rightRest] = [left.slice(prefix), right.slice(prefix)];
+  const suffix = sharedPrefix([...leftRest].toReversed().join(""), [...rightRest].toReversed().join(""));
+  if (suffix === 0) return false;
+  const gaps = [leftRest.length - suffix, rightRest.length - suffix].toSorted((first, second) => first - second);
+  const [shorter = 0, longer = 0] = gaps;
+  return shorter <= MAX_SURNAME_GAP && longer <= MAX_SURNAME_GAP + 1;
+};

package/src/table-cells.ts

@@ -0,0 +1,41 @@
+import type { ProseDocument, Segmentation, Span, TableCell, Token } from "./plugin.ts";
+import { proseAndTablesOf } from "./table-text.ts";
+import { tableBodyCells, type Cell } from "./facts/table-facts.ts";
+
+// 表の升の語。本文は表を覆うので、升の字は文の分割も品詞解析も通らない。升ごとに adapter に渡し、語の位置を source の上に戻す。
+
+const LETTER = /\p{L}/u;
+
+const shiftToken = (token: Token, by: number): Token => ({ ...token, span: { start: token.span.start + by, end: token.span.end + by } });
+
+/** 升一つの語。字の無い升（数だけ、空）は解析しない。adapter が語を返さなければ tokens は無い。 */
+export const cellWithTokens = (cell: Cell, segment: (text: string) => Segmentation): TableCell => {
+  if (!LETTER.test(cell.text)) return cell;
+  const sentences = segment(cell.text).sentences;
+  if (!sentences.some((sentence) => sentence.tokens !== undefined)) return cell;
+  return { ...cell, tokens: sentences.flatMap((sentence) => (sentence.tokens ?? []).map((token) => shiftToken(token, cell.start))) };
+};
+
+/** 文書の表（引用とコードの外）の本体の升と、その語。 */
+export const tableCellsOf = (doc: ProseDocument, segment: (text: string) => Segmentation): TableCell[] =>
+  tableBodyCells(proseAndTablesOf(doc)).map((cell) => cellWithTokens(cell, segment));
+
+/** prose に、升の字だけを書き戻したもの（表の見出しの行と区切りの | は覆ったまま）。位置は変えない。 */
+export const proseWithCells = (prose: string, cells: readonly (Span & { readonly text: string })[]): string => {
+  const pieces: string[] = [];
+  const end = cells
+    .toSorted((left, right) => left.start - right.start)
+    .reduce((from, cell) => {
+      if (cell.start < from || cell.end - cell.start !== cell.text.length) return from;
+      pieces.push(prose.slice(from, cell.start), cell.text);
+      return cell.end;
+    }, 0);
+  pieces.push(prose.slice(end));
+  return pieces.join("");
+};
+
+/** 表の升の語は、読む rule があるときに一度だけ作る。升ごとの解析を、表を読まない rule に払わせない。 */
+export const lazyCells = (make: () => readonly TableCell[]): (() => readonly TableCell[]) => {
+  const cells: { value?: readonly TableCell[] } = {};
+  return () => (cells.value ??= make());
+};