chaffjs 0.30.0 → 0.31.0

package/src/facts/unit-tolerance.ts

@@ -0,0 +1,17 @@
+import type { Tolerance } from "./measures.ts";
+
+/** 丸めた書き方（1 mile と 1.6 km、300 kPa と 44 psi）を合うとみなす差。大きいほうの値の 2%。 */
+const ROUNDING_SHARE = 0.02;
+
+/**
+ * 温度は割合では比べられない（0 ℃ の 2% は 0）。オーブンの換算表は 25 °F 刻みの目盛りに丸める（170 ℃ と 325 °F は 13 °F 違う）ので、
+ * 一目盛りより小さい 15 °F までの差は合うとみなす。
+ */
+const OVEN_ROUNDING_FAHRENHEIT = 15;
+const CELSIUS_PER_FAHRENHEIT_DEGREE = 5 / 9;
+
+const DEFAULT_TOLERANCE: Tolerance = { relative: ROUNDING_SHARE, absolute: 0 };
+const TEMPERATURE_TOLERANCE: Tolerance = { relative: 0, absolute: OVEN_ROUNDING_FAHRENHEIT * CELSIUS_PER_FAHRENHEIT_DEGREE };
+
+/** 量の種類（語彙表の id）ごとの、換算して合うとみなす差。 */
+export const toleranceOf = (dimension: string): Tolerance => (dimension === "unit-temperature" ? TEMPERATURE_TOLERANCE : DEFAULT_TOLERANCE);

package/src/facts/unit-word.ts

@@ -0,0 +1,35 @@
+const LATIN_WORD = /^\p{Script=Latin}+$/u;
+const WORD_CHAR = /[\p{L}\p{N}]/u;
+/** 単位のすぐ後ろに、数（空白一つまで）か、ハイフンでつながる語が続く。 */
+const CONTINUED = /^(?:[ \t]?[0-9０-９]|-[\p{L}\p{N}])/u;
+
+const isLatinWord = (word: string): boolean => LATIN_WORD.test(word);
+
+/** 英字の語が、語として行にあるか（"x" は "box" の中では数えない）。 */
+const hasWord = (line: string, word: string): boolean => {
+  let from = line.indexOf(word);
+  while (from !== -1) {
+    const end = from + word.length;
+    if (!WORD_CHAR.test(line.charAt(from - 1)) && !WORD_CHAR.test(line.charAt(end))) return true;
+    from = line.indexOf(word, from + 1);
+  }
+  return false;
+};
+
+/** 単位に要る文脈の語が、行にどれかあるか。英字の語は語として探し、ほかの字（オーブン、×）は字の並びとして探す。大文字と小文字は区別しない。 */
+export const lineHasContext = (line: string, words: readonly string[]): boolean => {
+  const lowered = line.toLowerCase();
+  return words.some((word) => {
+    const target = word.toLowerCase();
+    return isLatinWord(target) ? hasWord(lowered, target) : lowered.includes(target);
+  });
+};
+
+/**
+ * 文脈の要る英字の単位（"in"）は、その言語のふつうの語でもある。単位として読むのは、語がそこで終わり（"5 interns" の in ではない）、
+ * 後ろに数もハイフンでつながる語も続かない（"1 in 3"、"2-in-1"）ときだけ。文脈の要らない単位と、英字でない単位（度）は、この形を見ない。
+ */
+export const standsAsUnitWord = (pattern: string, needsContext: boolean, after: string): boolean => {
+  if (!needsContext || !isLatinWord(pattern)) return true;
+  return !WORD_CHAR.test(after.charAt(0)) && !CONTINUED.test(after);
+};

package/src/facts/written-precision.ts

@@ -0,0 +1,23 @@
+import type { Tolerance } from "./measures.ts";
+
+const HALF = 0.5;
+const DECIMAL_BASE = 10;
+const DECIMALS = /[.．]([0-9０-９]+)/u;
+/** 端の値（1.2 kg と 1,250 g）が浮動小数の誤差で外れないための余り。 */
+const FLOAT_SLACK = 1 + 1e-9;
+
+/**
+ * 小数で書いた量が言える幅の半分を、基準の単位で（1.2 kg は 1.15〜1.25 kg なので 0.05 kg）。書き手は小数点の後ろの最後の桁で丸めて
+ * 書いている。整数（410 g、1 mile）は 0：末尾の 0 が丸めか（1,200 g）は書き方から分からず、仕様の整数はふつう書いたとおりの値なので、
+ * 量の種類ごとの差（unit-tolerance）だけで比べる。
+ */
+export const writtenHalfStep = (written: string, factors: readonly number[]): number => {
+  const decimals = DECIMALS.exec(written)?.[1]?.length;
+  return decimals === undefined || factors.length === 0 ? 0 : HALF * DECIMAL_BASE ** -decimals * Math.max(...factors) * FLOAT_SLACK;
+};
+
+/** 二つの量を比べるときの、合うとみなす差。粗いほうの量の書いた桁の半分が、量の種類ごとの差より広ければそちら。 */
+export const precisionTolerance = (tolerance: Tolerance, halfSteps: readonly number[]): Tolerance => ({
+  relative: tolerance.relative,
+  absolute: Math.max(tolerance.absolute, ...halfSteps),
+});

package/src/kana-spelling.ts

@@ -22,6 +22,31 @@ export const kanjiSkeleton = (text: string): string => [...text.matchAll(KANJI)]
 export const dropsOkurigana = (spelling: string, spellings: readonly string[]): boolean =>
   spelling !== "" && kanjiSkeleton(spelling) === spelling && spellings.some((other) => other !== spelling && kanjiSkeleton(other) === spelling);
 
+const KANJI_OR_KANA_RUN = /[\p{Script=Han}々]|[^\p{Script=Han}々]+/gu;
+
+/**
+ * Whether a spelling writes in kana part of the word another spells with more kanji (かたくり粉 beside 片栗粉, とり扱い beside
+ * 取り扱い): every kanji it keeps stands where the other has it, each kana run stands for something there, and the other keeps
+ * more kanji. Only the letters are compared; the caller has already matched the readings.
+ */
+export const isKanaForKanji = (partial: string, full: string): boolean => {
+  const kept = kanjiSkeleton(partial);
+  if (kept === "" || kept === partial || [...kanjiSkeleton(full)].length <= [...kept].length) return false;
+  const pattern = [...partial.matchAll(KANJI_OR_KANA_RUN)].map(([part]) => (kanjiSkeleton(part) === part ? part : ".+")).join("");
+  return new RegExp(`^${pattern}$`, "u").test(full);
+};
+
+/**
+ * The kanji a spelling is keyed by among spellings of one reading: its own, or, when it writes part of the word in kana
+ * (かたくり粉), the kanji of the spelling with more kanji it stands for (片栗粉). When it could stand for two (two words of one
+ * reading), its own.
+ */
+export const kanjiKeyAmong = (spelling: string, spellings: readonly string[]): string => {
+  const fuller = new Set(spellings.filter((other) => isKanaForKanji(spelling, other)).map(kanjiSkeleton));
+  const [only] = fuller;
+  return fuller.size === 1 && only !== undefined ? only : kanjiSkeleton(spelling);
+};
+
 /** The length, in UTF-16 units, of the start both strings share, compared character by character (𠮟 is one character, two units). */
 const sharedPrefixLength = (left: string, right: string): number => {
   const [leftChars, rightChars] = [[...left], [...right]];

package/src/model-codes.ts

@@ -0,0 +1,104 @@
+// 型番の書き分け（KM-SP300 と KM-SP-300、KMSP300、km-sp300）。型番と読むのは、文書の題か型番の欄（語彙表 model-code-label）の後ろに
+// 書いた、英大文字と数字を合わせた語だけ。ハイフン・空白・大小・幅を除いて同じ字の並びになるものを同じ型番と見る。字や数の違う
+// 型番（KM-SP300 と KM-SP310）は別の型番なので比べない。
+
+export type ModelCode = { readonly offset: number; readonly surface: string };
+export type ModelCodeVariant = { readonly code: ModelCode; readonly usual: string };
+
+/** 型番と読む字の数（ハイフンと空白を除く）の下限。S3 や v2 は短すぎて型番か分からない。 */
+const MIN_KEY_LENGTH = 4;
+
+const ALNUM = "A-Za-z0-9Ａ-Ｚａ-ｚ０-９";
+const HYPHENS = "\\-‐‑－";
+/** 型番の字の間に書いてよい区切り。 */
+const SEPARATOR = `[${HYPHENS} ]?`;
+/** 型番の前に来れば、より長い語・パス・URL・ファイル名・色（#FF0000）の一部。 */
+const BEFORE_OTHER = new RegExp(`[${ALNUM}${HYPHENS}_./\\\\@=#]$`, "u");
+/** 型番の後ろに来れば、より長い語・パス・ファイル名（.pdf）・版（.2）の一部。 */
+const AFTER_OTHER = new RegExp(`^(?:[${ALNUM}${HYPHENS}_/\\\\]|\\.[${ALNUM}])`, "u");
+const CODE_SHAPE = new RegExp(`[${ALNUM}]+(?:[${HYPHENS}][${ALNUM}]+)*`, "gu");
+const URL = /(?:https?:\/\/|www\.)[^\s<>"'）)」]+/gu;
+
+/** ハイフン・空白・大小・幅を除いた字の並び。同じ並びなら同じ型番。 */
+export const modelCodeKey = (surface: string): string =>
+  surface
+    .normalize("NFKC")
+    .toLowerCase()
+    .replaceAll(/[\s\-‐‑]/gu, "");
+
+/** 英大文字と数字を両方含み、英小文字を含まない、短すぎない語。iOS17 や v1 は型番と読まない。 */
+export const isModelCodeShape = (surface: string): boolean => {
+  const key = modelCodeKey(surface);
+  const ascii = surface.normalize("NFKC");
+  return key.length >= MIN_KEY_LENGTH && /[A-Z]/u.test(ascii) && /\d/u.test(ascii) && !/[a-z]/u.test(ascii);
+};
+
+const standsAlone = (text: string, start: number, end: number): boolean =>
+  !BEFORE_OTHER.test(text.slice(Math.max(0, start - 1), start)) && !AFTER_OTHER.test(text.slice(end, end + 2));
+
+/** 範囲の中の、型番の形をした語。 */
+export const codesInTitle = (text: string, start: number, end: number): ModelCode[] =>
+  [...text.slice(start, end).matchAll(CODE_SHAPE)]
+    .map((match) => ({ offset: start + match.index, surface: match[0] }))
+    .filter((code) => isModelCodeShape(code.surface) && standsAlone(text, code.offset, code.offset + code.surface.length));
+
+const escaped = (pattern: string): string => pattern.replaceAll(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/** 欄の語の直後（「：」や空白を挟んでよい）に書いた、型番の形をした語。英字の欄の語は大小を問わず、語の途中からは読まない。 */
+export const codesAfterLabels = (text: string, labels: readonly string[]): ModelCode[] => {
+  if (labels.length === 0) return [];
+  const alternatives = labels.toSorted((left, right) => right.length - left.length).map(escaped);
+  const pattern = new RegExp(
+    `(?<![A-Za-z])(?:${alternatives.join("|")})(?![A-Za-z])[ \\t]*[:：]?[ \\t\\u3000]*([${ALNUM}]+(?:[${HYPHENS}][${ALNUM}]+)*)`,
+    "giu",
+  );
+  return [...text.matchAll(pattern)]
+    .map((match) => ({ offset: match.index + match[0].length - (match[1] ?? "").length, surface: match[1] ?? "" }))
+    .filter((code) => isModelCodeShape(code.surface) && standsAlone(text, code.offset, code.offset + code.surface.length));
+};
+
+/** 一つの字の、大小と全角の形。 */
+const charClass = (char: string): string => {
+  const forms = new Set([char, char.toUpperCase(), char.toLowerCase()].flatMap((form) => [form, String.fromCodePoint((form.codePointAt(0) ?? 0) + 0xfee0)]));
+  return `[${[...forms].join("")}]`;
+};
+
+const urlSpans = (text: string): { start: number; end: number }[] =>
+  [...text.matchAll(URL)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** 字の並びが key と同じになる語のすべて。字の間にはハイフンか空白を一つまで挟んでよい。URL の中は読まない。 */
+export const codesWithKey = (text: string, key: string): ModelCode[] => {
+  const pattern = new RegExp([...key].map(charClass).join(SEPARATOR), "gu");
+  const urls = urlSpans(text);
+  return [...text.matchAll(pattern)]
+    .map((match) => ({ offset: match.index, surface: match[0] }))
+    .filter((code) => standsAlone(text, code.offset, code.offset + code.surface.length))
+    .filter((code) => !urls.some((url) => url.start <= code.offset && code.offset < url.end));
+};
+
+const countsOf = (codes: readonly ModelCode[]): Map<string, number> =>
+  codes.reduce((counts, code) => counts.set(code.surface, (counts.get(code.surface) ?? 0) + 1), new Map<string, number>());
+
+/** 一番多く書いた形。数が同じなら、題か欄に先に書いた形。 */
+const usualOf = (codes: readonly ModelCode[], anchor: string): string => {
+  const counts = countsOf(codes);
+  const most = Math.max(...counts.values());
+  return (counts.get(anchor) ?? 0) === most ? anchor : ([...counts].find(([, count]) => count === most)?.[0] ?? anchor);
+};
+
+/** 一つの型番の、少ないほうの形。型番が二度以上出てこなければ、比べるものが無い。 */
+const variantsOfKey = (text: string, anchor: ModelCode): ModelCodeVariant[] => {
+  const codes = codesWithKey(text, modelCodeKey(anchor.surface));
+  if (codes.length < 2) return [];
+  const usual = usualOf(codes, anchor.surface);
+  return codes.filter((code) => code.surface !== usual).map((code) => ({ code, usual }));
+};
+
+/**
+ * 文書の型番（題か欄に書いたもの）を、ほかの所で別の形に書いた所。anchors は文書の順。同じ字の並びの型番は一度だけ見る。
+ */
+export const modelCodeVariants = (text: string, anchors: readonly ModelCode[]): ModelCodeVariant[] => {
+  const keys = anchors.map((anchor) => modelCodeKey(anchor.surface));
+  const firstPerKey = anchors.filter((_, index) => keys.indexOf(keys[index] ?? "") === index);
+  return firstPerKey.flatMap((anchor) => variantsOfKey(text, anchor)).toSorted((left, right) => left.code.offset - right.code.offset);
+};

package/src/name-spelling-chars.ts

@@ -0,0 +1,34 @@
+import type { NameMention } from "./name-variants.ts";
+
+// 一語の名前の中で、同じ音を二通りに書く字（桜ヶ丘・桜ケ丘・桜が丘、霞ヶ関・霞が関）。どの字が同じかは語彙表 name-spelling-char が
+// 組（group）ごとに言う。漢字に挟まれた字だけを寄せる。かなの語の中の字は寄せない。名前は解析器が一語と読んだもの
+// （霞が関）に限る。桜・が・丘 と読む書き方を本文にそのまま探すと、助詞の が（桜が丘を彩る）を名前と取り違える。
+
+/** 字から、その組の代表の字へ。 */
+export type SpellingChars = ReadonlyMap<string, string>;
+
+/**
+ * 名前の中の同じ音の字を比べる材料。chars はその字の組。alsoWritten は、この比べ方にだけ加える名前の現れ（表の升の名前）。升の名前をほかの見方に加えると、表の識別子（contentType）を本文の名前（Content-Type）と比べてしまう。
+ */
+export type SpellingInput = { readonly chars: SpellingChars; readonly alsoWritten: readonly NameMention[] };
+
+export const NO_SPELLING: SpellingInput = { chars: new Map(), alsoWritten: [] };
+
+const HAN = /^\p{Script=Han}$/u;
+
+const isBetweenHan = (chars: readonly string[], index: number): boolean => HAN.test(chars[index - 1] ?? "") && HAN.test(chars[index + 1] ?? "");
+
+/** 漢字に挟まれた、組のある字の位置。 */
+const foldableAt = (chars: readonly string[], spelling: SpellingChars): number[] =>
+  chars.flatMap((char, index) => (spelling.has(char) && isBetweenHan(chars, index) ? [index] : []));
+
+/** 漢字に挟まれた組の字を、組の代表に寄せた形。寄せる字が無ければ書いたまま。 */
+export const foldSpelling = (surface: string, spelling: SpellingChars): string => {
+  const chars = [...surface];
+  const at = new Set(foldableAt(chars, spelling));
+  return chars.map((char, index) => (at.has(index) ? (spelling.get(char) ?? char) : char)).join("");
+};
+
+/** 比べる形。漢字に挟まれた組の字を含む名前だけが、寄せた形を一つ持つ。含まない名前（Content-Type）はこの比べ方に入らない。 */
+export const foldedKeysOf = (surface: string, spelling: SpellingChars): string[] =>
+  foldableAt([...surface], spelling).length > 0 ? [foldSpelling(surface, spelling)] : [];

package/src/name-variants.ts

@@ -2,6 +2,7 @@ import type { Token } from "./plugin.ts";
 import { escapeRegExp } from "./orthography.ts";
 import { nameCueAt, type NameCue, type NameCues } from "./name-cue.ts";
 import { isNearSurname } from "./surname-near.ts";
+import { foldedKeysOf, NO_SPELLING, type SpellingInput } from "./name-spelling-chars.ts";
 
 // 同じ名前（人・会社・製品）を、文書の中で少しだけ違う形に書いた所。どの形が正しいかは決めず、少ないほうを指す。
 // 三通りで同じ名前と見る。書き方の違いだけ（GitHub と Github、Mac OS と macOS）、読みが同じ（山田太郎 と 山田太朗）、
@@ -23,7 +24,7 @@ export type NameMention = {
 export type NameVariant = {
   readonly mention: NameMention;
   readonly usual: string;
-  readonly kind: "spelling" | "reading" | "near" | "surname" | "character";
+  readonly kind: "spelling" | "kana" | "reading" | "near" | "surname" | "character";
 };
 
 /** 字体の違う同じ字（斎・斉・齋）。字から、その組の代表の字へ。 */
@@ -405,13 +406,17 @@ const personReadingVariants = (tallies: readonly Tally[]): NameVariant[] =>
  * 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。chars は字体の
  * 違う同じ字の組（語彙表 name-variant-char）。
  */
-export const nameVariants = (mentions: readonly NameMention[], chars: VariantChars = new Map()): NameVariant[] => {
+export const nameVariants = (mentions: readonly NameMention[], chars: VariantChars = new Map(), spelling: SpellingInput = NO_SPELLING): NameVariant[] => {
   const tallies = talliesOf(mentions);
   const found = [
     ...variantsIn(
       groupBy(tallies, (tally) => [nameKey(tally.surface)]),
       "spelling",
     ),
+    ...variantsIn(
+      groupBy(talliesOf([...mentions, ...spelling.alsoWritten]), (tally) => foldedKeysOf(tally.surface, spelling.chars).map(nameKey)),
+      "kana",
+    ),
     ...variantsIn(
       groupBy(tallies, (tally) => (tally.first.reading === undefined ? [] : [tally.first.reading])),
       "reading",
@@ -424,10 +429,6 @@ export const nameVariants = (mentions: readonly NameMention[], chars: VariantCha
   ];
   const reported = new Set<string>();
   return found
-    .filter((variant) => {
-      if (reported.has(variant.mention.surface)) return false;
-      reported.add(variant.mention.surface);
-      return true;
-    })
+    .filter((variant) => !reported.has(variant.mention.surface) && reported.add(variant.mention.surface).size > 0)
     .toSorted((left, right) => left.mention.offset - right.mention.offset);
 };

package/src/phone-numbers.ts

@@ -20,6 +20,18 @@ const NUMBER_EDGE_AFTER = String.raw`(?![\d\-‐−]|[.,]\d)`;
 const COUNTRY_CODE = String.raw`(?:\+\d{1,3}[ -]?)?`;
 /** Groups of digits joined by hyphens or brackets (03-1234-5678, 03（1234）5678, (555) 123-4567, +81-3-1234-5678). */
 const NUMBER_SHAPE = new RegExp(String.raw`${NUMBER_EDGE_BEFORE}${COUNTRY_CODE}[(（]?\d{1,5}(?:${GROUP_JOIN}\d{1,5}){1,3}${NUMBER_EDGE_AFTER}`, "gu");
+/**
+ * Groups of digits joined by spaces (020 7946 0186, +44 20 7946 0186, 03 1234 5678). The last group has three digits or
+ * more and no such group follows it, so a count after the number ("0186 24 hours") is left out and a run that does not
+ * split one way only ("2026 10 09 020 7946 0186") is not read.
+ */
+const SPACED_SHAPE = new RegExp(
+  String.raw`${NUMBER_EDGE_BEFORE}(?:\+\d{1,3}[ \u00A0])?\d{1,5}(?:[ \u00A0]\d{1,5}){0,2}[ \u00A0]\d{3,5}${NUMBER_EDGE_AFTER}(?![ \u00A0]\d{3})`,
+  "gu",
+);
+/** Spaced digits are a phone number only with a country code, or right after their label: dates, amounts and ids are spaced too. */
+const COUNTRY_CODE_START = /^\+/u;
+const LABEL_TO_NUMBER = /^(?:[\s:：.．]|\uFE0F)*$/u;
 const NOT_DIGIT = /\D/gu;
 const LATIN_START = /^[A-Za-z]/u;
 const LETTER = /\p{L}/u;
@@ -35,8 +47,10 @@ const lastPlace = (before: string, label: string): number => {
   return whole.at(-1) ?? -1;
 };
 
-/** The group of the label ending nearest before a number on its line, the longest when two end together (携帯電話 over 電話). */
-const labelBefore = (text: string, offset: number, labels: readonly LexiconEntry[]): string | undefined => {
+type LabelBefore = { readonly group: string; readonly between: string };
+
+/** The label ending nearest before a number on its line, the longest when two end together (携帯電話 over 電話), and what lies between. */
+const labelBefore = (text: string, offset: number, labels: readonly LexiconEntry[]): LabelBefore | undefined => {
   const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
   const before = text.slice(lineStart, offset).toLowerCase();
   const nearest = labels
@@ -46,7 +60,7 @@ const labelBefore = (text: string, offset: number, labels: readonly LexiconEntry
     })
     .filter((hit) => hit.at >= 0 && before.length - hit.end <= MAX_LABEL_GAP)
     .toSorted((a, b) => b.end - a.end || a.at - b.at)[0];
-  return nearest?.group;
+  return nearest === undefined ? undefined : { group: nearest.group, between: before.slice(nearest.end) };
 };
 
 /** URLs covered with spaces, so neither a path segment (/call/) nor an id in one is read. Offsets stay the same. */
@@ -55,12 +69,18 @@ const withoutUrls = (text: string): string => text.replaceAll(URL, (url) => " ".
 /** The phone numbers of a text that have a label shortly before them on their line; unlabelled digits and URLs are not read. */
 export const labelledPhoneNumbers = (source: string, labels: readonly LexiconEntry[]): PhoneNumber[] => {
   const text = withoutUrls(source);
-  return [...text.matchAll(NUMBER_SHAPE)].flatMap((match) => {
+  const read = (match: RegExpExecArray, spaced: boolean): PhoneNumber[] => {
     const digits = match[0].replaceAll(NOT_DIGIT, "");
     if (digits.length < MIN_DIGITS || digits.length > MAX_DIGITS) return [];
     const label = labelBefore(text, match.index, labels);
-    return label === undefined ? [] : [{ offset: match.index, written: match[0].trim(), digits, label }];
-  });
+    if (label === undefined) return [];
+    if (spaced && !COUNTRY_CODE_START.test(match[0]) && !LABEL_TO_NUMBER.test(label.between)) return [];
+    return [{ offset: match.index, written: match[0].trim(), digits, label: label.group }];
+  };
+  return [
+    ...[...text.matchAll(NUMBER_SHAPE)].flatMap((match) => read(match, false)),
+    ...[...text.matchAll(SPACED_SHAPE)].flatMap((match) => read(match, true)),
+  ].toSorted((a, b) => a.offset - b.offset);
 };
 
 /** Whether two digit strings are the same but for one pair of neighbours swapped. */

package/src/place-names.ts

@@ -165,14 +165,53 @@ export const placeMentionsIn = (source: string, words: readonly PlaceWord[], rea
 };
 
 const DIGIT = /\p{N}/u;
+const HAN = /^\p{Script=Han}$/u;
 
-/** 漢字・かなの名前の部分が一字だけ違い、その字が、多いほうで固有名詞の語に入る（八重洲 と 八重州）。数字や方角（北口 と 南口）は別の所。 */
-const isCjkSlip = (slip: PlaceMention, usual: PlaceMention): boolean => {
+/**
+ * 名前の字について語彙表が言うこと。directions は方角や位置の字（東、上、新）で、それだけが違う名前は別の所（下北沢 と 上北沢）。
+ * sameReading は読みの同じ字から組の代表へ（洲 と 州）。
+ */
+export type PlaceChars = { readonly directions: ReadonlySet<string>; readonly sameReading: ReadonlyMap<string, string> };
+
+const NO_PLACE_CHARS: PlaceChars = { directions: new Set(), sameReading: new Map() };
+
+type CharDifference = { readonly at: number; readonly slip: string; readonly usual: string };
+
+/** 漢字・かなの名前の部分が、字数が同じで一字だけ違うときの、その字。 */
+const oneCharDifference = (slip: PlaceMention, usual: PlaceMention): CharDifference | undefined => {
   const [slipChars, usualChars] = [[...slip.base], [...usual.base]];
-  if (slipChars.length !== usualChars.length) return false;
+  if (slipChars.length !== usualChars.length) return undefined;
   const differ = usualChars.flatMap((char, index) => (char === slipChars[index] ? [] : [index]));
   const [at] = differ;
-  return differ.length === 1 && at !== undefined && usual.properAt.includes(at) && !DIGIT.test(usualChars[at] ?? "") && !DIGIT.test(slipChars[at] ?? "");
+  return differ.length === 1 && at !== undefined ? { at, slip: slipChars[at] ?? "", usual: usualChars[at] ?? "" } : undefined;
+};
+
+const isDirectionDifference = (difference: CharDifference | undefined, chars: PlaceChars): boolean =>
+  difference !== undefined && (chars.directions.has(difference.slip) || chars.directions.has(difference.usual));
+
+/** 漢字どうしの一字違いは、読みの同じ字の組のときだけ（八重洲 と 八重州）。読みの違う字（戸塚 と 戸山）は別の所のことが多い。 */
+const isReadAlike = (difference: CharDifference, chars: PlaceChars): boolean =>
+  !HAN.test(difference.slip) || !HAN.test(difference.usual) || isSameGroup(difference, chars);
+
+const isSameGroup = (difference: CharDifference, chars: PlaceChars): boolean => {
+  const group = chars.sameReading.get(difference.slip);
+  return group !== undefined && group === chars.sameReading.get(difference.usual);
+};
+
+/** 同じ数を、漢数字と数字で書き分けた一字（第二 と 第2）。どちらの字が同じ数を言うかは語彙表の組が言う。 */
+const isNumeralSpelling = (difference: CharDifference | undefined, chars: PlaceChars): boolean =>
+  difference !== undefined && (DIGIT.test(difference.slip) || DIGIT.test(difference.usual)) && isSameGroup(difference, chars);
+
+/** 漢字・かなの名前の部分が一字だけ違い、その字が、多いほうで固有名詞の語に入る（八重洲 と 八重州）。数字は別の所。 */
+const isCjkSlip = (slip: PlaceMention, usual: PlaceMention, chars: PlaceChars): boolean => {
+  const difference = oneCharDifference(slip, usual);
+  return (
+    difference !== undefined &&
+    usual.properAt.includes(difference.at) &&
+    !DIGIT.test(difference.usual) &&
+    !DIGIT.test(difference.slip) &&
+    isReadAlike(difference, chars)
+  );
 };
 
 const latinWords = (base: string): string[] =>
@@ -208,19 +247,19 @@ const isSlipOf = (slip: Counted, usual: Counted): boolean => slip.count === 1 &&
 
 /**
  * 二つの書き方が、同じ所を二通りに書いたものか。場所の語の組が同じで、名前と語の全体が記号・幅・大小だけ違うか、場所の語の
- * 書き方だけが違う（11th St. と 11th Street）か。名前の部分の読みが同じか、かなで書いた読み（筑紫口 と ちくし口）か、一字違い
- * （八重洲 と 八重州）なのは、
- * 少ないほうが一度だけ、多いほうが二度以上のときに限る。
+ * 書き方だけが違う（11th St. と 11th Street）か。名前の部分の読みが同じか、同じ数の漢数字と数字（第二 と 第2）か、かなで書いた読み（筑紫口 と ちくし口）か、一字違い
+ * （八重洲 と 八重州）なのは、少ないほうが一度だけ、多いほうが二度以上のときに限る。違う一字が方角や位置の字なら別の所。
  */
-export const placeRelation = (slip: Counted, usual: Counted): PlaceRelation | undefined => {
+export const placeRelation = (slip: Counted, usual: Counted, chars: PlaceChars = NO_PLACE_CHARS): PlaceRelation | undefined => {
   const [left, right] = [slip.mention, usual.mention];
   if (left.surface === right.surface || left.place !== right.place) return undefined;
   if (nameKey(left.surface) === nameKey(right.surface)) return "spelling";
   if (nameKey(left.base) === nameKey(right.base)) return "place-word";
-  if (!isSlipOf(slip, usual)) return undefined;
-  if ((left.reading !== undefined && left.reading === right.reading) || isKanaSpellingOf(left, right)) return "reading";
+  const difference = oneCharDifference(left, right);
+  if (!isSlipOf(slip, usual) || isDirectionDifference(difference, chars)) return undefined;
+  if ((left.reading !== undefined && left.reading === right.reading) || isKanaSpellingOf(left, right) || isNumeralSpelling(difference, chars)) return "reading";
   const latin = LATIN.test(left.base) && LATIN.test(right.base);
-  const slipped = latin ? isLatinSlip(left, right) : isCjkSlip(left, right);
+  const slipped = latin ? isLatinSlip(left, right) : isCjkSlip(left, right, chars);
   return slipped ? "near" : undefined;
 };
 
@@ -237,12 +276,12 @@ const talliesOf = (mentions: readonly PlaceMention[]): Counted[] => {
 const byUsage = (left: Counted, right: Counted): number => right.count - left.count || left.mention.offset - right.mention.offset;
 
 /** 同じ所の、少ないほうの書き方。同じ所と言える相手のうち一番多いものと比べる。書き方ごとに最初の現れを一つ。 */
-export const placeVariants = (mentions: readonly PlaceMention[]): PlaceVariant[] => {
+export const placeVariants = (mentions: readonly PlaceMention[], chars: PlaceChars = NO_PLACE_CHARS): PlaceVariant[] => {
   const tallies = talliesOf(mentions);
   return tallies.flatMap((tally) => {
-    const [usual] = tallies.filter((other) => other !== tally && placeRelation(tally, other) !== undefined).toSorted(byUsage);
+    const [usual] = tallies.filter((other) => other !== tally && placeRelation(tally, other, chars) !== undefined).toSorted(byUsage);
     if (usual === undefined || byUsage(usual, tally) > 0) return [];
-    const kind = placeRelation(tally, usual);
+    const kind = placeRelation(tally, usual, chars);
     return kind === undefined ? [] : [{ mention: tally.mention, usual: usual.mention.surface, kind }];
   });
 };

package/src/plugin.ts

@@ -277,6 +277,8 @@ export type DocumentProfile = {
   readonly unnumbered?: { readonly indent: string; readonly inside: string; readonly depth: number } | undefined;
   /** 定義した語を括弧に入れて、語そのものを指す（「株主」とあるのは、"controller" has the same meaning）。定義し直しでも、括弧の付け忘れでもない。 */
   readonly quoteMentionsTerm?: boolean | undefined;
+  /** 文書に速さが無いときの、徒歩の分数を出す速さ（m/分）と、端数を切り上げるか。不動産の広告は 80m で1分、切り上げ。 */
+  readonly walkRate?: { readonly metresPerMinute: number; readonly roundUp: boolean } | undefined;
 };
 
 /**

package/src/preamble-paragraphs.ts

@@ -1,9 +1,28 @@
 import type { Paragraph } from "./plugin.ts";
 import { isClosed } from "./sentence-shape.ts";
 
+/** A header field on one line: a short label, a colon, and its value (To: …, Quote number: …). */
+const FIELD_LINE = /^[^:：。.!?！？\n]{1,30}[:：][ \t]*(?<value>\S[^\n]*)$/u;
+
+/** Small words a name keeps in lower case (Bank of Minato, Smith and Sons). */
+const NAME_JOINERS = new Set(["of", "and", "&", "the", "for"]);
+
+const isNameWord = (word: string): boolean => NAME_JOINERS.has(word) || /^[\p{Lu}\d]/u.test(word);
+
+/**
+ * A paragraph that is one header field whose value is a name, every word capitalised (To: Minato Manufacturing Inc.): a
+ * letter's or an invoice's address block, closed only by the period of Inc. A value with a word in lower case
+ * (Summary: Sales up 5%., Note: This guide covers the setup.) is a sentence.
+ */
+const isNameField = (paragraph: Paragraph, source: string): boolean => {
+  const value = FIELD_LINE.exec(source.slice(paragraph.span.start, paragraph.span.end).trim())?.groups?.["value"];
+  return value !== undefined && value.split(/\s+/u).every(isNameWord);
+};
+
 /**
  * 本題の前にあって、読み手が読み通す段落。文が一つも終止符で閉じない段落は数えない。
  * 分類の札（「エネルギー・環境」）、著者と所属の行、「印刷」、テンプレートの指示は文ではなく、読ませる前置きではない。
+ * 宛先や差出人の欄（To: Minato Manufacturing Inc.）も、値が名前だけなら数えない。source は段落の範囲を読む文書。
  */
-export const preambleParagraphs = (paragraphs: readonly Paragraph[], bodyStart: number): Paragraph[] =>
-  paragraphs.filter((paragraph) => paragraph.span.start < bodyStart && paragraph.sentences.some(isClosed));
+export const preambleParagraphs = (paragraphs: readonly Paragraph[], bodyStart: number, source = ""): Paragraph[] =>
+  paragraphs.filter((paragraph) => paragraph.span.start < bodyStart && paragraph.sentences.some(isClosed) && !isNameField(paragraph, source));

package/src/profile/parse.ts

@@ -53,6 +53,14 @@ const unnumberedOf = (value: unknown): DocumentProfile["unnumbered"] => {
   return indent === undefined || inside === undefined || !Number.isInteger(depth) || typeof depth !== "number" ? undefined : { indent, inside, depth };
 };
 
+/** 正の速さが無ければ読まない。 */
+const walkRateOf = (value: unknown): DocumentProfile["walkRate"] => {
+  if (!isRecord(value)) return undefined;
+  const metresPerMinute = value["metres_per_minute"];
+  if (typeof metresPerMinute !== "number" || !Number.isFinite(metresPerMinute) || metresPerMinute <= 0) return undefined;
+  return { metresPerMinute, roundUp: value["round_up"] === true };
+};
+
 /** 単位が一つも無ければ読まない。何を指すのか決められない。 */
 const relativeOf = (value: unknown): RelativeVocabulary | undefined => {
   if (!isRecord(value)) return undefined;
@@ -88,6 +96,7 @@ const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, D
         const caption = text(section["caption"]);
         const relative = relativeOf(section["relative"]);
         const unnumbered = unnumberedOf(section["unnumbered"]);
+        const walkRate = walkRateOf(section["walk_rate"]);
         return [
           language,
           {
@@ -99,6 +108,7 @@ const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, D
             relative,
             unnumbered,
             ...(section["quote_mentions_term"] === true ? { quoteMentionsTerm: true } : {}),
+            ...(walkRate === undefined ? {} : { walkRate }),
           },
         ];
       }),

package/src/spacing-code.ts

@@ -0,0 +1,26 @@
+import type { Span } from "./plugin.ts";
+
+// Text beside which a space is not a spacing choice: a clock time (13:30), which like 3時 names a time rather than a
+// quantity, and an e-mail address or a URL, whose end a reader and an auto-linker find by the space after it. Pure.
+
+/** A clock time: hours, a colon, minutes, and seconds optionally (9:05, 13:30, 08:00:15). */
+const CLOCK_TIME = /(?<![\d:：.])\d{1,2}[:：][0-5]\d(?:[:：][0-5]\d)?(?![\d:：])/gu;
+
+/** A run of printable ASCII without brackets: an address ends where Japanese text, a space or a bracket starts (…/faq で). */
+const ASCII_RUN = /[!-'*-~]+/gu;
+
+/** An e-mail address (a local part, @, and a domain with a dot) or a URL with its scheme or www. */
+const EMAIL = /^[\w.+-]+@[\w-]+\.[\w.-]+$/u;
+const URL_START = /^(?:https?:\/\/|www\.)/u;
+
+const isAddress = (word: string): boolean => EMAIL.test(word) || URL_START.test(word);
+
+const spansOf = (text: string, pattern: RegExp): Span[] =>
+  [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+export const clockTimeSpans = (text: string): Span[] => spansOf(text, CLOCK_TIME);
+
+export const addressSpans = (text: string): Span[] => spansOf(text, ASCII_RUN).filter((span) => isAddress(text.slice(span.start, span.end)));
+
+/** Whether the character at `at` is inside one of the spans. */
+export const isInsideSpan = (spans: readonly Span[], at: number): boolean => spans.some((span) => span.start <= at && at < span.end);

package/src/structure/amount-range.ts

@@ -1,11 +1,11 @@
-// amount-range-reversed: a range of amounts whose upper end is below its lower end (月給30万円〜25万円, $90,000–$70,000,
-// 下限30万円・上限25万円). The amounts come read (currency, value, the word of scale they carry); the words that join a range,
-// change a price, and label a bound come from the lexicons. Pure.
+// amount-range-reversed and quantity-range-reversed: a range whose upper end is below its lower end (月給30万円〜25万円,
+// $90,000–$70,000, 下限30万円・上限25万円, 5–2 kg, -10〜-40℃). The ends come read (currency or unit, value, the word of scale
+// they carry); the words that join a range, change a value, and label a bound come from the lexicons. Pure.
 import { escapeRegExp } from "../orthography.ts";
 import { amountValue, type ScaleWord } from "./amount-scale.ts";
 import type { StructureIssue } from "./issues.ts";
 
-/** One amount written with its currency. scale is the value of the word of scale written in it (万, million), if any. */
+/** One amount written with its currency (or a quantity with its unit, in currency). scale is the value of the word of scale written in it (万, million), if any. */
 export type RangeAmount = {
   readonly offset: number;
   readonly end: number;
@@ -27,7 +27,7 @@ export type AmountRangeWords = {
   readonly lowers: readonly string[];
   readonly uppers: readonly string[];
   readonly links: readonly string[];
-  /** The words of scale (万, million, k) and the digits of a number (the currency reader's pattern). */
+  /** The words of scale (万, million, k) and the digits of a number (the reader's pattern; a quantity's may open with a minus sign). */
   readonly scales: readonly ScaleWord[];
   readonly number: string;
 };
@@ -94,11 +94,20 @@ const alternation = (patterns: readonly string[]): string => patterns.toSorted((
 
 const scalePart = (words: AmountRangeWords): string => {
   const scales = alternation(words.scales.map((scale) => escapeRegExp(scale.word)));
-  return scales === "" ? "" : `(?:\\s?(${scales}))?`;
+  // With no words of scale the group still stands, never matching, so the joint keeps its group number.
+  return scales === "" ? "((?!))?" : `(?:\\s?(${scales}))?`;
 };
 
 const jointPart = (words: AmountRangeWords): string => `(\\s?(?:${alternation([...words.connectors, ...words.openers].map(wordPattern))})\\s?)`;
 
+const MINUS = /^[-−－]/u;
+
+/** The value of a bare number, negative when it opens with a minus sign (-10〜-40℃). */
+const signedValue = (digits: string): number | undefined => {
+  const value = amountValue(digits.replace(MINUS, ""), []);
+  return value === undefined || !MINUS.test(digits) ? value : -value;
+};
+
 /** A bare number (no currency) and its word of scale, if any. */
 const bareReading = (
   span: { readonly offset: number; readonly end: number },
@@ -106,7 +115,7 @@ const bareReading = (
   scaleWord: string | undefined,
   words: AmountRangeWords,
 ): Reading | undefined => {
-  const value = amountValue(digits, []);
+  const value = signedValue(digits);
   if (value === undefined) return undefined;
   const scale = scaleOf(scaleWord, words);
   return { ...span, value: scale === undefined ? value : value * scale, scale };