chaffjs 0.29.0 → 0.31.0

package/src/name-word-order.ts

@@ -0,0 +1,149 @@
+import { escapeRegExp } from "./orthography.ts";
+
+// 語の順を入れ替えて書いた同じ名前（統計学基礎 と 基礎統計学、Foundations of Statistics と Statistical Foundations）。
+// 名前と読める所（括弧や引用符の中、大文字で始まる語の並び、名前を書く欄の後ろ）だけを比べ、同じ語（日本語は形態素、英語は語幹）を
+// 違う順に並べた二つのうち、少ないほうを指す。片方がもう片方を含む名前（統計学 と 統計学基礎）は別の名前として比べない。
+// 大文字の語の並びだけでは名前と言い切れない（Florida Supreme Court と Supreme Court of Florida はふつうの言い換え）ので、
+// 二つのどちらかが、括弧の中か欄の後ろか表の升まるごとに書いた名前（anchored）のときだけ比べる。
+
+/**
+ * anchored は、括弧の中、欄の後ろ、表の升まるごとのように、名前として書いたと分かる所。clipped は欄の後ろのように、名前の後ろに
+ * 文が続きうる所で、名前は最初の名前の外の語（を、in）の手前まで。
+ */
+export type NameSpan = { readonly start: number; readonly end: number; readonly anchored?: boolean; readonly clipped?: boolean };
+
+/** 名前の中の内容語。key は比べるための形（英語は語幹）。 */
+export type OrderWord = { readonly start: number; readonly end: number; readonly key: string };
+
+export type OrderName = { readonly offset: number; readonly surface: string; readonly keys: readonly string[]; readonly anchored: boolean };
+
+export type OrderVariant = { readonly name: OrderName; readonly usual: string };
+
+/** 名前と読む長さの上限（字）。これより長い括弧の中は、名前ではなく引用した文。 */
+export const MAX_NAME_LENGTH = 80;
+
+/** 名前の中に来ない文の区切り。 */
+const CLAUSE_MARKS = "\\n。、．，.,;；:：!！?？";
+
+/** 括弧や引用符の組（「」、“”）の中身。開きと閉じの二字で一つの組。 */
+export const quotedSpans = (text: string, pairs: readonly string[]): NameSpan[] =>
+  pairs.flatMap((pair) => {
+    const [open = "", close = ""] = [...pair];
+    if (open === "" || close === "") return [];
+    const body = `[^${escapeRegExp(open)}${escapeRegExp(close)}${CLAUSE_MARKS}]{1,${String(MAX_NAME_LENGTH)}}`;
+    return [...text.matchAll(new RegExp(`${escapeRegExp(open)}(${body})${escapeRegExp(close)}`, "gu"))].map((found) => {
+      const start = (found.index ?? 0) + open.length;
+      return { start, end: start + (found[1] ?? "").length, anchored: true };
+    });
+  });
+
+const CAPITALISED = "\\p{Lu}[\\p{L}'’-]*";
+
+const FIRST_WORD = new RegExp(`^${CAPITALISED}[ \\t]+`, "u");
+
+/**
+ * 大文字で始まる語が二つ以上並んだ所（Foundations of Statistics）。語のあいだに小さな語（of）を挟んでよい。文の頭の語は、
+ * 文の頭だから大文字のことがあるので、外す（Take Data Lab の Take）。
+ */
+export const titleCaseSpans = (text: string, joiners: readonly string[], isSentenceStart: (offset: number) => boolean = () => false): NameSpan[] => {
+  const joiner = joiners.length === 0 ? "" : `(?:(?:${joiners.map(escapeRegExp).join("|")})[ \\t]+)*`;
+  const pattern = new RegExp(`(?<![\\p{L}'’-])${CAPITALISED}(?:[ \\t]+${joiner}${CAPITALISED})+`, "gu");
+  return [...text.matchAll(pattern)].map((found) => {
+    const start = found.index ?? 0;
+    const lead = isSentenceStart(start) ? (FIRST_WORD.exec(found[0])?.[0].length ?? 0) : 0;
+    return { start: start + lead, end: start + found[0].length };
+  });
+};
+
+/** 名前を書く欄の語（前提科目：、Course:）の後ろの、句読点か行の終わりまで。 */
+export const labelledSpans = (text: string, labels: readonly string[]): NameSpan[] => {
+  if (labels.length === 0) return [];
+  const label = labels.map(escapeRegExp).join("|");
+  const pattern = new RegExp(`(?<![\\p{L}])(?:${label})[ \\t]*[:：][ \\t]*([^${CLAUSE_MARKS}]{1,${String(MAX_NAME_LENGTH)}})`, "giu");
+  return [...text.matchAll(pattern)].map((found) => {
+    const value = (found[1] ?? "").trimEnd();
+    const start = (found.index ?? 0) + found[0].length - (found[1] ?? "").length;
+    return { start, end: start + value.length, anchored: true, clipped: true };
+  });
+};
+
+/** 語の比べる形: 小文字にして、語尾の語（ical、ics、s）を一つ、長いほうから外す。語幹が短くなりすぎる語尾は外さない。 */
+const MIN_STEM = 4;
+
+export const stemOf = (word: string, suffixes: readonly string[]): string => {
+  const lower = word.toLowerCase();
+  const suffix = suffixes
+    .toSorted((left, right) => right.length - left.length)
+    .find((candidate) => lower.endsWith(candidate.toLowerCase()) && lower.length - candidate.length >= MIN_STEM);
+  return suffix === undefined ? lower : lower.slice(0, lower.length - suffix.length);
+};
+
+/** clipped の範囲の終わり: 範囲の中で、内容語の後に来る最初の名前の外の語（stops の位置）の手前。 */
+const clippedEnd = (span: NameSpan, words: readonly OrderWord[], stops: readonly number[]): number => {
+  if (span.clipped !== true) return span.end;
+  const firstWord = words.find((word) => word.start >= span.start && word.end <= span.end);
+  if (firstWord === undefined) return span.end;
+  return stops.find((stop) => stop > firstWord.start && stop < span.end) ?? span.end;
+};
+
+/** 名前が、もっと長い名前の一部か（“West Indies Hurricanes and other Tropical Cyclones” の West Indies Hurricanes）。 */
+const isPartOf = (name: OrderName, longer: OrderName): boolean =>
+  name.offset >= longer.offset && name.offset + name.surface.length <= longer.offset + longer.surface.length;
+
+/** 範囲の中の内容語の形。同じ所の同じ名前は一つにまとめ、どれかが anchored ならその名前は anchored。
+ * anchored の名前の一部だけを大文字の語の並びとして読んだものは除く。 */
+export const orderNamesOf = (text: string, spans: readonly NameSpan[], words: readonly OrderWord[], stops: readonly number[] = []): OrderName[] => {
+  const named = spans.flatMap((span): OrderName[] => {
+    const end = clippedEnd(span, words, stops);
+    const inside = words.filter((word) => word.start >= span.start && word.end <= end);
+    const first = inside[0];
+    const last = inside.at(-1);
+    if (first === undefined || last === undefined) return [];
+    return [{ offset: first.start, surface: text.slice(first.start, last.end), keys: inside.map((word) => word.key), anchored: span.anchored === true }];
+  });
+  const byPlace = named.reduce<Map<string, OrderName>>((places, name) => {
+    const id = `${String(name.offset)}:${name.surface}`;
+    const known = places.get(id);
+    return places.set(id, known === undefined ? name : { ...known, anchored: known.anchored || name.anchored });
+  }, new Map());
+  const names = [...byPlace.values()];
+  return names
+    .filter((name) => name.anchored || !names.some((other) => other.anchored && isPartOf(name, other)))
+    .toSorted((left, right) => left.offset - right.offset);
+};
+
+type Tally = { readonly first: OrderName; readonly count: number; readonly anchored: boolean };
+
+const talliesOf = (names: readonly OrderName[]): Tally[] => [
+  ...names
+    .reduce<Map<string, Tally>>((tallies, name) => {
+      const known = tallies.get(name.surface);
+      return tallies.set(name.surface, { first: known?.first ?? name, count: (known?.count ?? 0) + 1, anchored: (known?.anchored ?? false) || name.anchored });
+    }, new Map())
+    .values(),
+];
+
+/** 多いほうが前。同じ数なら先に書いたほうが前。 */
+const byUse = (left: Tally, right: Tally): number => right.count - left.count || left.first.offset - right.first.offset;
+
+const bagOf = (keys: readonly string[]): string => keys.toSorted((left, right) => left.localeCompare(right)).join("\u0000");
+
+/** 同じ語を違う順に並べた別の書き方で、どちらも他方を含まないか。 */
+export const isReordered = (left: OrderName, right: OrderName): boolean =>
+  left.keys.join("\u0000") !== right.keys.join("\u0000") &&
+  bagOf(left.keys) === bagOf(right.keys) &&
+  !left.surface.includes(right.surface) &&
+  !right.surface.includes(left.surface);
+
+/**
+ * 多く使った書き方と同じ語を違う順に並べた名前。少ないほうを一つずつ指す。二つのどちらかが名前として書いた所（anchored）に
+ * あるときだけ。surfaces は表の升まるごとの書き方で、その書き方の名前も anchored と見る。
+ */
+export const wordOrderVariants = (names: readonly OrderName[], surfaces: ReadonlySet<string> = new Set()): OrderVariant[] => {
+  const tallies = talliesOf(names).toSorted(byUse);
+  const anchored = (tally: Tally): boolean => tally.anchored || surfaces.has(tally.first.surface);
+  return tallies.flatMap((tally, index) => {
+    const usual = tallies.slice(0, index).find((other) => (anchored(other) || anchored(tally)) && isReordered(other.first, tally.first));
+    return usual === undefined ? [] : [{ name: tally.first, usual: usual.first.surface }];
+  });
+};

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;
 };
 
 /**
@@ -362,8 +364,13 @@ export type ProseDocument = {
   readonly markup?: Markup | undefined;
   /** adapter の綴りの辞書。持たない言語では無い。 */
   readonly dictionary?: (() => ReadonlySet<string>) | undefined;
+  /** 表の本体の升と、升ごとに解析した語（位置は source の上）。本文（prose）は表を覆うので、升の語は sentences に入らない。呼んだときに作る。 */
+  readonly tableCells?: (() => readonly TableCell[]) | undefined;
 };
 
+/** 表の升一つ。text は区切りの | のあいだの字のまま。tokens は升の字を adapter が解析した語で、解析しない adapter では無い。 */
+export type TableCell = Span & { readonly text: string; readonly tokens?: readonly Token[] };
+
 /** 見出し 1 つ。text は属性（`{#id}`）を外した言葉。 */
 export type MarkupHeading = { readonly depth: number; readonly text: string; readonly start: number; readonly end: number };
 

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